socket.cpp

这是一个完整的图书馆供销存管理系统

/***************************************************************************
                          socket.h  -  description
                             -------------------
    begin                : Fri Jul 20 2001
    copyright            : (C) 2001 by Mark
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/


#include <string.h>

#include "socket.h"


CInetAddress::CInetAddress()
{
	memset(&m_stInetAddr, 0, sizeof(m_stInetAddr));
}


CInetAddress::CInetAddress(const struct in_addr& stInetAddr)
{
	m_stInetAddr = stInetAddr;
}


CInetAddress::CInetAddress(const char* sInetAddr)
{
	*this = sInetAddr;
}


bool CInetAddress::IsInetAddress() const
{
	struct in_addr stInetAddr;
	memset(&stInetAddr, 0, sizeof(stInetAddr));
	if(memcmp(&m_stInetAddr, &stInetAddr, sizeof(m_stInetAddr)))
		return true;
	return false;
}


CInetAddress& CInetAddress::operator = (const struct in_addr& stInetAddr)
{
	m_stInetAddr = stInetAddr;
	return *this;
}


CInetAddress& CInetAddress::operator = (const char* sInetAddr)
{
	if (strcmp(sInetAddr, "*") == 0)
	{
		m_stInetAddr.s_addr = htonl(INADDR_ANY);
		return *this;
	}

	if (inet_aton(sInetAddr, &m_stInetAddr))
		return *this;

	struct hostent stHostBuf, *pstHost;
	char* pchBuffer;
	size_t tBufLen;
	int iHErr;
	
	tBufLen = 1024;
	pchBuffer = new char [tBufLen];
	while (gethostbyname_r(sInetAddr, &stHostBuf, pchBuffer, tBufLen, &pstHost, &iHErr) != 0 || pstHost == NULL)
	{
		if (iHErr != NETDB_INTERNAL || errno != ERANGE)
		{
			delete [] pchBuffer;
			throw CSocketException("gethostbyname_r fail", __FILE__, __LINE__);
		}
		else
		{
			/* Enlarge buffer.  */
			delete [] pchBuffer;
			tBufLen *= 2;
			pchBuffer = new char [tBufLen];
		}
	}

	m_stInetAddr = *(struct in_addr*)pstHost->h_addr_list[0];
	delete [] pchBuffer;
	return *this;
}


CSocket::CSocket()
{
	Init();
}


CSocket::CSocket(const CSocket* pstSocket)
{
	Init();
	m_iSocket = dup(pstSocket->m_iSocket);
	if (m_iSocket < 0)
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
		
	m_eState = pstSocket->m_eState;
	m_iDomain = pstSocket->m_iDomain;
	m_bBlock = pstSocket->m_bBlock;
}


CSocket::CSocket(int iDomain, int iType, int iProtocol)
{
	Init();
	m_iDomain = iDomain;	
	Socket(iDomain, iType, iProtocol);
	m_eState = S_AVAILABLE;	
}


void CSocket::Init()
{
	m_iSocket = -1;
	m_eState = S_INITIAL;
	m_bBlock = true;
}


void CSocket::End()
{
	if (m_iSocket < 0)
	{
		m_iSocket = -1;
		m_eState = S_INITIAL;
		return;
	}
	
	close(m_iSocket);
	m_iSocket = -1;
	m_eState = S_INITIAL;
}


void CSocket::SetBlock(bool bBlock)
{
	int iFlag = fcntl(m_iSocket, F_GETFL);
	if (iFlag < 0)
		throw CSocketException(strerror(errno), __FILE__, __LINE__);

	if (bBlock)
		iFlag &= ~O_NONBLOCK;
	else
		iFlag |= O_NONBLOCK;
		
	if (fcntl(m_iSocket, F_SETFL, iFlag) < 0)
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
		
	m_bBlock = bBlock;
}


void CSocket::Bind(const CInetAddress& stInetAddr, tcport_t tPort)
{
	struct sockaddr_in stSockAddr;
	memset(&stSockAddr, 0, sizeof(stSockAddr));
	stSockAddr.sin_family = AF_INET;
	stSockAddr.sin_port = htons(tPort);
	stSockAddr.sin_addr = stInetAddr.GetAddress();
	if (bind(m_iSocket, (struct sockaddr*)&stSockAddr, sizeof(stSockAddr)) < 0)
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
}


void CSocket::Bind(const CUnixAddress& stUnixAddr)
{
	unlink(stUnixAddr.path());
	struct sockaddr_un stSockAddr;
	memset(&stSockAddr, 0, sizeof(stSockAddr));
	stSockAddr.sun_family = AF_LOCAL;
	strcpy(stSockAddr.sun_path, stUnixAddr.path());
	if (bind(m_iSocket, (struct sockaddr*)&stSockAddr, sizeof(stSockAddr)) < 0)
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
}


CTcpSocket::CTcpSocket(const CSocket* pstSocket)
		: CSocket(pstSocket)
{
}


CTcpSocket::CTcpSocket(const CInetAddress& stInetAddr, tcport_t tPort)
		: CSocket(PF_INET, SOCK_STREAM)
{
	Bind(stInetAddr, tPort);
	m_eState = S_BOUND;
}


CTcpSocket::CTcpSocket(const CUnixAddress& stUnixAddr)
		: CSocket(PF_LOCAL, SOCK_STREAM)
{
	Bind(stUnixAddr);
	m_eState = S_BOUND;
}


void CTcpSocket::Open(int iBackLog)
{
	Listen(iBackLog);
}


bool CTcpSocket::Open(const CInetAddress& stInetAddr, tcport_t tPort)
{
	struct sockaddr_in stSockAddr;
	memset(&stSockAddr, 0, sizeof(stSockAddr));
	stSockAddr.sin_family = AF_INET;
	stSockAddr.sin_port = htons(tPort);
	stSockAddr.sin_addr = stInetAddr.GetAddress();
	if (connect(m_iSocket, (struct sockaddr*)&stSockAddr, sizeof(stSockAddr)) < 0)
	{
		if ( (m_bBlock && errno == EINTR) || (!m_bBlock && errno == EINPROGRESS) )
		{
			m_eState = S_CONNECTING;
			return false;
		}
			
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
	}

	m_eState = S_CONNECTED;	
	return true;
}


bool CTcpSocket::Open(const CUnixAddress& stUnixAddr)
{
	struct sockaddr_un stSockAddr;
	memset(&stSockAddr, 0, sizeof(stSockAddr));
	stSockAddr.sun_family = AF_LOCAL;
	strcpy(stSockAddr.sun_path, stUnixAddr.path());
	if (connect(m_iSocket, (struct sockaddr*)&stSockAddr, sizeof(stSockAddr)) < 0)
	{
		if ( (m_bBlock && errno == EINTR) || (!m_bBlock && errno == EINPROGRESS) )
		{
			m_eState = S_CONNECTING;
			return false;
		}
			
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
	}

	m_eState = S_CONNECTED;	
	return true;
}


bool CTcpSocket::CheckOpen(long lSec, long lUSec)
{
	fd_set rset, wset;
	FD_ZERO(&rset);
	FD_SET(m_iSocket, &rset);
	FD_ZERO(&wset);
	FD_SET(m_iSocket, &wset);

	while (true)
	{
		struct timeval stTimeVal;
		stTimeVal.tv_sec = lSec;
		stTimeVal.tv_usec = lUSec;	
		
		int i = 0;	
		i = select(m_iSocket + 1, &rset, &wset, NULL, (lSec == 0 && lUSec == 0) ? NULL : &stTimeVal);
		if (i == 0)	//timeout
			return false;
		
		if (i < 0)
		{
			if (errno == EINTR)
			{
				if (OnCheckOpenIntr())
					continue;
				else
					return false;
			}
				
			throw CSocketException(strerror(errno), __FILE__, __LINE__);
		}
		
		if (FD_ISSET(m_iSocket, &rset) || FD_ISSET(m_iSocket, &wset))
		{
			socklen_t tLen = sizeof(errno);
			if (getsockopt(m_iSocket, SOL_SOCKET, SO_ERROR, &errno, &tLen) < 0	//solaris < 0 when error occurs
					|| errno < 0)
				throw CSocketException(strerror(errno), __FILE__, __LINE__);
				
			m_eState = S_CONNECTED;
			return true;
		}
		
		throw CSocketException("unknown error occurs", __FILE__, __LINE__);
	}
}


bool CTcpSocket::Accept(CTcpStream* pstTcpStream)
{
	if (pstTcpStream->m_iSocket >= 0)
	{
		if (pstTcpStream->m_iBufSize > 0)
			pstTcpStream->sync();
			
		pstTcpStream->clear();
		pstTcpStream->setb(pstTcpStream->m_pchGetBuf, pstTcpStream->m_pchGetBuf + pstTcpStream->m_iBufSize, 0);
		pstTcpStream->setg(pstTcpStream->m_pchGetBuf, pstTcpStream->m_pchGetBuf + pstTcpStream->m_iBufSize, pstTcpStream->m_pchGetBuf + pstTcpStream->m_iBufSize);
		pstTcpStream->setp(pstTcpStream->m_pchPutBuf, pstTcpStream->m_pchPutBuf + pstTcpStream->m_iBufSize);
		pstTcpStream->End();
	}
	
	struct sockaddr_in stInetSockAddr;
	struct sockaddr_un stUnixSockAddr;
	socklen_t tSockLen;	
	sockaddr* pstSockAddr;
	switch (m_iDomain)
	{
		case PF_INET:
			pstSockAddr = (sockaddr*)&stInetSockAddr;
			tSockLen = sizeof(stInetSockAddr);
			break;
				
		case PF_LOCAL:
			pstSockAddr = (sockaddr*)&stUnixSockAddr;
			tSockLen = sizeof(stUnixSockAddr);
			break;
			
		default:
			throw CSocketException("unknown domain", __FILE__, __LINE__);
	}	
		
	while (true)
	{
		int i = accept(m_iSocket, pstSockAddr, &tSockLen);
		if (i < 0)
		{
			if (m_bBlock && errno == EINTR)
			{
				if (OnAcceptIntr())
					continue;
				else
					return false;
			}
				
			if ( (!m_bBlock) && (errno == EWOULDBLOCK
#ifdef ECONNABORTED
					|| errno == ECONNABORTED
#endif
#ifdef EPROTO
					|| errno == EPROTO
#endif
					) )