mysocket.cpp

学习java的经典教程源代码

#include <stdafx.h>
#include "mysocket.h"

#include <cassert>
using namespace std;
#ifdef  _WIN32
CSocketInit::~CSocketInit()
{
	WSACleanup();
	
}
CSocketInit::CSocketInit()
{
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD(2, 2);
	if(WSAStartup(wVersionRequested, &wsaData) == SOCKET_ERROR)
	{
		throw 1;
	}	
}	
CSocketInit& CSocketInit::Instance()
{
	static CSocketInit socketInit;
	return socketInit;
}
static CSocketInit& socketinit=CSocketInit::Instance();

#endif

#include <time.h>
#include <stdio.h>
void    WritesocketRunLog(char* pdatatype)
{
	
	struct tm *pNow;
	WORD wYear;
	long itime=time(NULL);
	pNow = localtime(&itime);
	pNow->tm_year += 1900;
	pNow->tm_mon += 1;
	wYear = pNow->tm_year;
	
	char szTime[50]="0";	
	sprintf(szTime," %02d:%02d:%02d", pNow->tm_hour,pNow->tm_min,pNow->tm_sec);
	char szDate[50]="0";
	sprintf(szDate, "%04d-%02d-%02d" , wYear, pNow->tm_mon, pNow->tm_mday);
		
	char cfilename[512]="0";
	strcpy(cfilename, "c:\\CMySocketError");
	strcat(cfilename, szDate);
	strcat(cfilename, ".txt");
	FILE* m_fp = fopen(cfilename, "ab+");
	if(m_fp)
	{		
		fseek(m_fp, 0, SEEK_END);
		fwrite("\r\n",2,1,m_fp);	
		char cmemo[512]="0";
		//sprintf(szNowTime,"%04d-%02d-%02d %02d:%02d:%02d", wYear,pNow->tm_mon, pNow->tm_mday,pNow->tm_hour,pNow->tm_min,pNow->tm_sec);
		strcpy(cmemo, szDate);
		strcat(cmemo, szTime);
		strcat(cmemo,pdatatype);
		strcat(cmemo,"\r\n");
		fwrite(cmemo, strlen(cmemo), 1, m_fp);
		fclose(m_fp);
		
	}

}	

bool CMySocket::Create(unsigned int nSocketPort,int nSocketType,int nProtocolType,const char* lpszSocketAddress)
{
	if(!Socket(nSocketType,nProtocolType,AF_INET))
	{
		int ierror = WSAGetLastError();
		char err[256];
		sprintf(err, "CMySocket::Create失败，ConnectDs.doit 退出 errornum=%d", ierror);
		WritesocketRunLog(err);
		return false;
	}
	unsigned int dwOptVal=1;
	SetSockOpt(SO_REUSEADDR,(char*)&dwOptVal,sizeof(dwOptVal));
	if(Bind(nSocketPort,lpszSocketAddress))
		return true;
	else
	{
		int ierror = WSAGetLastError();
		char err[256];
		sprintf(err, "CMySocket::Create Bind失败，ConnectDs.doit 退出 errornum=%d", ierror);
		WritesocketRunLog(err);
	}
    Close();
	return false;
	
}

bool CMySocket::Listen(int nConnectionBacklog)
{
	if (listen(m_hSocket,nConnectionBacklog) == SOCKET_ERROR)
	{
		Close();
		return false;
	}
	return true;
}

bool CMySocket::Accept(CMySocket& rConnectedSocket,sockaddr* lpSockAddr, int* lpSockAddrLen)
{
	//	assert(rConnectedSocket.m_hSocket == INVALID_SOCKET);
	
	SOCKET sc = accept(m_hSocket, lpSockAddr, (SOCKLEN*)lpSockAddrLen);
	if (sc == INVALID_SOCKET)
	{
		rConnectedSocket.m_hSocket = INVALID_SOCKET;
		
	}
	else
	{
		rConnectedSocket.m_hSocket = sc;
	}
	return (sc != INVALID_SOCKET);
}
void CMySocket::Close()

{
	if(m_hSocket==INVALID_SOCKET)return ;
//	try
//	{
	
#ifdef _WIN32
	
	closesocket(m_hSocket);
	shutdown(m_hSocket,both);
#else
	close(m_hSocket);
#endif
//	}
//	catch (...) {
//        m_hSocket= INVALID_SOCKET;      
//	}
	m_hSocket= INVALID_SOCKET;
	
}

bool CMySocket::ShutDown(int nHow)
{
	int Result=shutdown(m_hSocket,nHow);
	return Result!=SOCKET_ERROR;
}

bool CMySocket::Connect(const char* lpszHostAddress, unsigned int nHostPort)
{
	assert(lpszHostAddress != NULL);
	
	sockaddr_in sockAddr;
	memset(&sockAddr,0,sizeof(sockAddr));
	sockAddr.sin_family = AF_INET;
	sockAddr.sin_addr.s_addr = inet_addr(lpszHostAddress);
	
	if (sockAddr.sin_addr.s_addr == INADDR_NONE)
	{
		hostent* lphost;
		lphost = gethostbyname(lpszHostAddress);
		if (lphost != NULL)
			sockAddr.sin_addr =* ((in_addr*)lphost->h_addr);
		else
		{
			int ierror = WSAGetLastError();
			char err[256];
			sprintf(err, "CMySocket::Connect连接失败，ConnectDs.doit 退出 errornum=%d", ierror);
			WritesocketRunLog(err);
			return false;
		}
	}
	
	sockAddr.sin_port = htons(nHostPort);
	int ires = connect(m_hSocket,(sockaddr*)&sockAddr, sizeof(sockAddr));
	
	return ires==0;
}
int CMySocket::Receive(void* lpBuf, int nBufLen, int nFlags)
{
	return recv(m_hSocket, (char*)lpBuf, nBufLen, nFlags);
}
int CMySocket::ReceiveFrom(void* lpBuf, int nBufLen, string& rSocketAddress, unsigned int& rSocketPort, int nFlags)
{
	sockaddr_in sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));
	
	SOCKLEN nSockAddrLen = sizeof(sockAddr);
	int nResult = recvfrom(m_hSocket,(char*)lpBuf, nBufLen,nFlags, (sockaddr*)&sockAddr, &nSockAddrLen);
	if(nResult != SOCKET_ERROR)
	{
		rSocketPort = ntohs(sockAddr.sin_port);
		rSocketAddress = inet_ntoa(sockAddr.sin_addr);
	}
	return nResult;
}

int CMySocket::Send(const void* lpBuf, int nBufLen, int nFlags)
{
	return send(m_hSocket, (const char*)lpBuf, nBufLen, nFlags);
}

int  CMySocket::SendTo(const void* lpBuf, int nBufLen, unsigned int nHostPort, const char* lpszHostAddress, int nFlags)
{

	sockaddr_in sockAddr;
	memset(&sockAddr,0,sizeof(sockAddr));
	sockAddr.sin_family = AF_INET;
	
	if (lpszHostAddress == NULL)
		sockAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
	else
	{
		sockAddr.sin_addr.s_addr = inet_addr(lpszHostAddress);
		if (sockAddr.sin_addr.s_addr == INADDR_NONE)
		{
			hostent* lphost;
			lphost = gethostbyname(lpszHostAddress);
			if (lphost != NULL)
				sockAddr.sin_addr =* ((in_addr*)lphost->h_addr);
			
			else
			{
#ifdef  _WIN32
				
				WSASetLastError(WSAEINVAL);

#endif
				return SOCKET_ERROR;
			}
		}
	}
	
	sockAddr.sin_port = htons((u_short)nHostPort);
	
	return sendto(m_hSocket,(const char*)lpBuf, nBufLen, nFlags, (sockaddr*)&sockAddr, sizeof(sockAddr));
}


bool CMySocket::GetPeerName(string& rPeerAddress, unsigned int& rPeerPort)
{
	sockaddr_in sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));
	
	SOCKLEN nSockAddrLen = sizeof(sockAddr);
	int iResult = getpeername(m_hSocket,(sockaddr*)&sockAddr, &nSockAddrLen);
	if (iResult!=SOCKET_ERROR)
	{
		rPeerPort =    ntohs(sockAddr.sin_port);
		
		rPeerAddress = inet_ntoa(sockAddr.sin_addr);
	}
	return iResult!=SOCKET_ERROR;
}
bool CMySocket::GetPeerInfo(unsigned int& rip,unsigned int& rPeerPort)
{
	sockaddr_in sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));
	
	SOCKLEN nSockAddrLen = sizeof(sockAddr);
	int iResult = getpeername(m_hSocket,(sockaddr*)&sockAddr, &nSockAddrLen);
	if (iResult!=SOCKET_ERROR)
	{
		rPeerPort =    ntohs(sockAddr.sin_port);
		
#ifdef  _WIN32
		rip=sockAddr.sin_addr.S_un.S_addr;
#else
		rip= sockAddr.sin_addr.s_addr;
#endif
	}
	return iResult!=SOCKET_ERROR;
}




bool CMySocket::GetSockName(string& rSocketAddress, unsigned int& rSocketPort)
{
	sockaddr_in  sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));
	
	SOCKLEN nSockAddrLen = sizeof(sockAddr);
	int iResult = getsockname(m_hSocket,(sockaddr*)&sockAddr,&nSockAddrLen);
	if (iResult!=SOCKET_ERROR)
	{
		rSocketPort = ntohs(sockAddr.sin_port);
		rSocketAddress = inet_ntoa(sockAddr.sin_addr);
	}
	return iResult!=SOCKET_ERROR;
}
bool CMySocket::GetSockInfo(unsigned int& rip,unsigned int& rSocketPort)
{
	sockaddr_in  sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));
	
	SOCKLEN nSockAddrLen = sizeof(sockAddr);
	int iResult = getsockname(m_hSocket,(sockaddr*)&sockAddr,&nSockAddrLen);
	if (iResult!=SOCKET_ERROR)
	{
		rSocketPort = ntohs(sockAddr.sin_port);
#ifdef  _WIN32
		rip=sockAddr.sin_addr.S_un.S_addr;
#else
		rip= sockAddr.sin_addr.s_addr;
#endif
	}
	return iResult!=SOCKET_ERROR;
	
}


bool CMySocket::IsSocketReadReady()
{
	
	bool bEmpty = true;
	try
	{
		
		if(ReadableTimeOut(0,0) > 0)
		{
			char szBuffer[1] = "";
			int iRet = Receive(szBuffer, 1, MSG_PEEK);
			if (iRet > 0)
			{
				bEmpty = false;
			}
		}
	}
	catch (...) {
      return  !bEmpty ;   
	}
	return  !bEmpty ;
}

bool CMySocket::IsSocketSendReady()
{
	bool bReady = false;
	try
	{
	
	if(SendableTimeOut(0,0) > 0)
	{
		bReady = true;
	}
	}
	catch (...) {
        return bReady ;
	}
	return( bReady );
}
//is right?
bool CMySocket::IsConnectionDropped()
{
//	return false;
	
	bool bConnDropped = false;
	int iFDSelect = 0;
	iFDSelect = ReadableTimeOut(0,100); 
	if(iFDSelect > 0)
	{
		char szBuffer[1] = "";
		int iRet = Receive(szBuffer, 1, MSG_PEEK);
		int iTem = WSAGetLastError();
		if (iRet == SOCKET_ERROR)
		{
			#ifdef  _WIN32
				int iError = ::WSAGetLastError();
				bConnDropped = ( ( iError == WSAENETRESET ) || ( iError == WSAECONNABORTED ) || ( iError == WSAECONNRESET ) || ( iError == WSAEINVAL ) );
			#else
				bConnDropped = true;
			#endif
		}
		//else if (iRet == 0)
		else if (iRet < 0)
		{
			bConnDropped = true;			
		}		
	}
    //???
    else if(ReadableTimeOut(0,0) < 0)
	{
		bConnDropped = true;    
	}
	return  bConnDropped;
	
	/*
	bool bConnDropped = false;
	int iFDSelect = 0;
	iFDSelect = ReadableTimeOut(0,100); 
	if(iFDSelect < 0) 
		return false;
	else
		return true;
		*/
	
}
//
int CMySocket::ReadableTimeOut(int second, int microsecond)
{	
	
	struct timeval timeout;
	fd_set readSocketSet;
	FD_ZERO( &readSocketSet );
	FD_SET( m_hSocket, &readSocketSet );
	timeout.tv_sec = second;
	timeout.tv_usec = microsecond;
	return (select( m_hSocket+1, &readSocketSet, NULL, NULL, &timeout ));
	
	/*
	fd_set fd_read;
	fd_set fd_active;
	FD_SET(m_hSocket, &fd_read);
	FD_SET(m_hSocket, &fd_active);
	struct timeval timeout;
	timeout.tv_sec = second;
	timeout.tv_usec = microsecond;
	
	memcpy(&fd_read, &fd_active, sizeof(fd_read));
	int sel = select(m_hSocket+1, &fd_read, NULL, 0, &timeout);
	return sel;
	*/
	/*
	struct timeval tmVal;	
	while ( !m_bStop ) 
	{
		Sleep(5);
		memcpy(&m_fdReadSet, &m_fdActiveSet, sizeof(m_fdReadSet) );

		// 信道查询
		tmVal.tv_sec = 1;
		tmVal.tv_usec =0;
		int sel = select(0, &m_fdReadSet, &m_fdWriteSet, 0, &tmVal);
		if( sel == 0 )	// 超时
		{			
		}

		if( sel< 0 )	// 错误
		{		
			Sleep(200);			
			break;
		}
	}
	*/
}
//
int CMySocket::SendableTimeOut(int second, int microsecond)
{

	struct timeval timeout;
	fd_set writeSocketSet;
	
	FD_ZERO( &writeSocketSet );
	FD_SET(m_hSocket, &writeSocketSet );
	timeout.tv_sec = second;
	timeout.tv_usec = microsecond;
	return (select( m_hSocket+1, NULL, &writeSocketSet, NULL, &timeout ));
}



////////////////protected
bool CMySocket::Socket(int nSocketType, int nProtocolType,int nAddressFormat)
{
    assert(m_hSocket == INVALID_SOCKET);
	m_hSocket = socket(nAddressFormat,nSocketType,nProtocolType);
	if (m_hSocket != INVALID_SOCKET)
		return true;
	return false;
}

bool CMySocket::Bind(unsigned int nSocketPort, const char* lpszSocketAddress)
{
	
	sockaddr_in sockAddr;
	memset(&sockAddr,0,sizeof(sockAddr));
	sockAddr.sin_family = AF_INET;
	if (lpszSocketAddress == 0)
		sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else
	{
		unsigned long lResult = inet_addr(lpszSocketAddress);
		if (lResult == INADDR_NONE)
		{
			return false;
		}
		sockAddr.sin_addr.s_addr = lResult;
	}
	sockAddr.sin_port = htons((u_short)nSocketPort);
	
	return !(bind(m_hSocket,(sockaddr*)&sockAddr, sizeof(sockAddr))==SOCKET_ERROR);
}