socket.cpp

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

				return false;
				
			throw CSocketException(strerror(errno), __FILE__, __LINE__);
		}

		switch (m_iDomain)
		{
			case PF_INET:
				if (!OnAccept(stInetSockAddr.sin_addr, ntohs(stInetSockAddr.sin_port)))
				{
					close(i);
					return false;
				}			
				break;
				
			case PF_LOCAL:
				if (!OnAccept(stUnixSockAddr.sun_path))
				{
					close(i);
					return false;
				}			
				break;
				
			default:
				throw CSocketException("unknown domain", __FILE__, __LINE__);
		}
		
		pstTcpStream->m_iSocket = i;
		pstTcpStream->SetBlock(m_bBlock);
		pstTcpStream->m_eState = S_CONNECTED;
		pstTcpStream->m_iDomain = m_iDomain;
		return true;
	}
}


void CTcpSocket::Listen(int iBackLog = 5)
{
	if (listen(m_iSocket, iBackLog) < 0)
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
}


CTcpStream::CTcpStream(int iBufSize)
		: CTcpSocket(), CStream(iBufSize)
{
}


CTcpStream::CTcpStream(const CSocket* pstSocket, int iBufSize)
		: CTcpSocket(pstSocket), CStream(iBufSize)
{
}


CTcpStream::CTcpStream(const CInetAddress& stInetAddr, tcport_t tPort, int iBufSize)
		: CTcpSocket(stInetAddr, tPort), CStream(iBufSize)
{
}


CTcpStream::CTcpStream(const CUnixAddress& stUnixAddr, int iBufSize)
		: CTcpSocket(stUnixAddr), CStream(iBufSize)
{
}


int CTcpStream::overflow(int ch)
{
	assert(pptr()	&& pbase());
	int iInBuf = pptr() - pbase();
	assert(iInBuf >= 0);
	char* pToWrite = pbase();
	int iTotalSend = 0;
	while (iInBuf > 0)	//because this function will be possibly called by flush
	{
		int iSend = ::write(m_iSocket, pToWrite, iInBuf);
		if (iSend <= 0)
		{
			if (m_bBlock && errno == EINTR)
			{
				if (OnWriteIntr())
					continue;
				else
					return EOF;
			}
			else if (!m_bBlock && errno == EWOULDBLOCK)
			{
				return EOF;
			}
			else
			{
				clear(ios::failbit | rdstate());
				return EOF;
			}
		}
		
		iInBuf -= iSend;
		iTotalSend += iSend;
		pToWrite += iSend;
		if (!m_bBlock)
			break;
	}

	if (iInBuf > 0)
		memmove(pbase(), pbase() + iTotalSend, iInBuf);

	setp(m_pchPutBuf, m_pchPutBuf + m_iBufSize);
	pbump(iInBuf);
	
	if(ch != EOF)
	{
		*pptr() = (char)ch;
		pbump(1);
	}

	return ch;
}


int CTcpStream::underflow()
{
	assert(eback() && gptr() && egptr());
	assert(gptr() <= egptr());
//	if(gptr() < egptr())
//		return (unsigned char)*gptr();

	int iBufLeft = gptr() - eback();
	int iInBuf = egptr() - gptr();
	if (iInBuf > 0)
		memmove(eback(), gptr(), iInBuf);
	
	int iRead;
	while (true)
	{
		iRead = ::read(m_iSocket, eback()+iInBuf, iBufLeft);
		if (iRead < 0)
		{
			if (m_bBlock && errno == EINTR)
			{
				if (OnReadIntr())
					continue;
				else
					return EOF;
			}
			else if (!m_bBlock && errno == EWOULDBLOCK)
			{
				return EOF;
			}
			else
			{
				clear(ios::failbit | rdstate());
				return EOF;
			}
		}
		else if (iRead == 0)
		{
			clear(ios::eofbit | rdstate());
			return EOF;
		}
		
		break;
	}

	if (iRead < iBufLeft)
		memmove(eback()+(iBufLeft-iRead), eback(), iInBuf+iRead);

	setg(eback(), eback()+(iBufLeft-iRead), egptr());
	return (unsigned char)*gptr();
}


CUdpSocket::CUdpSocket(const CInetAddress& stInetAddr, tcport_t tPort)
		: CSocket(PF_INET, SOCK_DGRAM)
{
	Bind(stInetAddr, tPort);
	m_eState = S_BOUND;
	m_bConnected = false;
	m_tPort = 0;
}


CUdpSocket::CUdpSocket(const CUnixAddress& stUnixAddr)
		: CSocket(PF_LOCAL, SOCK_DGRAM)
{
	Bind(stUnixAddr);
	m_eState = S_BOUND;
	m_bConnected = false;
	m_tPort = 0;	
}


void CUdpSocket::Connect(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)
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
		
	m_bConnected = true;
	m_stInetAddr = stInetAddr;
	m_tPort = tPort;
}


void CUdpSocket::Connect(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)
		throw CSocketException(strerror(errno), __FILE__, __LINE__);
		
	m_bConnected = true;
	m_stUnixAddr = stUnixAddr;
}


void CUdpSocket::Disconnect()
{
	switch (m_iDomain)
	{
		case PF_INET:
		{
			struct sockaddr_in stSockAddr;
			memset(&stSockAddr, 0, sizeof(stSockAddr));
			stSockAddr.sin_family = AF_UNSPEC;
			connect(m_iSocket, (struct sockaddr*)&stSockAddr, sizeof(stSockAddr));
			m_bConnected = false;
			m_stInetAddr = CInetAddress();
			m_tPort = 0;
		}
		break;
			
		case PF_LOCAL:
		{
			struct sockaddr_un stSockAddr;
			memset(&stSockAddr, 0, sizeof(stSockAddr));
			stSockAddr.sun_family = AF_UNSPEC;
			connect(m_iSocket, (struct sockaddr*)&stSockAddr, sizeof(stSockAddr));
			m_bConnected = false;
			m_stUnixAddr = "";
		}
		break;
			
		default:
			throw CSocketException("unknown domain", __FILE__, __LINE__);
	}
}


int CUdpSocket::Read(void* pMsg, int iLen)
{
	if (m_bConnected)
		return read(m_iSocket, pMsg, iLen);

	return recvfrom(m_iSocket, pMsg, iLen, 0, NULL, NULL);
}


int CUdpSocket::Read(void* pMsg, int iLen, CInetAddress& stInetAddr, tcport_t& tPort)
{
	if (m_bConnected)
	{
		stInetAddr = m_stInetAddr;
		tPort = m_tPort;
		return read(m_iSocket, pMsg, iLen);
	}

	struct sockaddr_in stSockAddr;
	memset(&stSockAddr, 0, sizeof(stSockAddr));
	socklen_t tLen = sizeof(stSockAddr);
	int iRead = recvfrom(m_iSocket, pMsg, iLen, 0, (struct sockaddr*)&stSockAddr, &tLen);
	stInetAddr = stSockAddr.sin_addr;
	tPort = ntohs(stSockAddr.sin_port);
	return iRead;
}


int CUdpSocket::Read(void* pMsg, int iLen, CUnixAddress& stUnixAddr)
{
	if (m_bConnected)
	{
		stUnixAddr = m_stUnixAddr;
		return read(m_iSocket, pMsg, iLen);
	}

	struct sockaddr_un stSockAddr;
	memset(&stSockAddr, 0, sizeof(stSockAddr));
	socklen_t tLen = sizeof(stSockAddr);
	int iRead = recvfrom(m_iSocket, pMsg, iLen, 0, (struct sockaddr*)&stSockAddr, &tLen);
	stUnixAddr = stSockAddr.sun_path;
	return iRead;
}


int CUdpSocket::Write(const void* pMsg, int iLen)
{
	if (!m_bConnected)
		throw CSocketException("Write parameters error", __FILE__, __LINE__);
		
	return write(m_iSocket, pMsg, iLen);
}


int CUdpSocket::Write(const void* pMsg, int iLen, const CInetAddress& stInetAddr, tcport_t tPort)
{
	if (m_bConnected || !stInetAddr.IsInetAddress())
		throw CSocketException("Write parameters error", __FILE__, __LINE__);
		
	struct sockaddr_in stSockAddr;
	memset(&stSockAddr, 0, sizeof(stSockAddr));
	stSockAddr.sin_family = AF_INET;
	stSockAddr.sin_port = htons(tPort);
	stSockAddr.sin_addr = stInetAddr.GetAddress();
	socklen_t tLen = sizeof(stSockAddr);
	return sendto(m_iSocket, pMsg, iLen, 0, (struct sockaddr*)&stSockAddr, tLen);
}


int CUdpSocket::Write(const void* pMsg, int iLen, const CUnixAddress& stUnixAddr)
{
	if (m_bConnected || !stUnixAddr.IsUnixAddress())
		throw CSocketException("Write parameters error", __FILE__, __LINE__);
		
	struct sockaddr_un stSockAddr;
	memset(&stSockAddr, 0, sizeof(stSockAddr));
	stSockAddr.sun_family = AF_LOCAL;
	strcpy(stSockAddr.sun_path, stUnixAddr.path());
	socklen_t tLen = sizeof(stSockAddr);
	return sendto(m_iSocket, pMsg, iLen, 0, (struct sockaddr*)&stSockAddr, tLen);
}


ostream& operator << (ostream& os, const hton4& obj)
{
	os.write(&obj.m_ulValue, 4);
	return os;
}


ostream& operator << (ostream& os, const hton2& obj)
{
	os.write(&obj.m_ushValue, 2);
	return os;
}


istream& operator >> (istream& is, const ntoh4& obj)
{
	is.read(obj.m_pulValue, 4);
	*obj.m_pulValue = ntohl(*obj.m_pulValue);
	return is;
}


istream& operator >> (istream& is, const ntoh2& obj)
{
	is.read(obj.m_pushValue, 2);
	*obj.m_pushValue = ntohs(*obj.m_pushValue);
	return is;
}