soc.cpp

socket代理的C++源码,实现了代理服务器的大部分功能

	m_pSocData.clear();

	if( m_pbOpenSev )
	{
		if (closesocket( m_socServer ) == SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		}
		m_pbOpenSev = false;
	}

	return;
}

/////////////////////////////////////////////////////////////////////////////
//
// 在指定的socket通道中发送数据
// 参数：	ID				子socket的ID
//			pucSendBuf		发送的数据
//			nLen			传入时为数据长度，返回时为实际发送的数据长度
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::SendData( int nID, const BYTE *pucSendBuf, int &nLen )
{
	int nSendBytes;

	int nIndex = GetSocIndex( nID );

	if( nIndex == -1 )
	{
		return 2;
	}

	if( !m_pbSocOpen[nIndex] )
	{
		return 3;
	}

	nSendBytes = send( m_pSocData[nIndex], (char*)pucSendBuf, nLen, 0 );
	nLen = nSendBytes;

	return 0;
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回指定的ID的子socket在数组中的序号
// 参数：	nID				子socket的ID
// 返回值：	-1				失败
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::GetSocIndex( int nID )
{
	vector<int>::iterator iteFind;
	iteFind = find( m_pnSocID.begin(), m_pnSocID.end(), nID );
	if( iteFind != m_pnSocID.end() )
	{
		return iteFind - m_pnSocID.begin();
	}
	else
	{
		return -1;
	}
}

CTCPClient::CTCPClient()
{
	m_pData = NULL;

	m_bClientOpen = false;
	m_socClient = NULL;

	m_pucDataBuf = NULL;
	m_nDataLen = 0;
	m_nBufLen = 0;

	m_pdlgMes = new CSocMesWnd;
	m_pdlgMes->CreateEx( 0, AfxRegisterWndClass(0), 
		_T("Socket Notification Sink NOT CSOCKET"), 
		WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL);
	m_pdlgMes->ShowWindow( SW_HIDE );
	m_pdlgMes->m_pTcpClient = this;

	m_hWndMsg = NULL;
	m_nMsg = WM_USER;
	m_pFuncMes = NULL;
}

CTCPClient::~CTCPClient()
{
	CloseSocket();

	if( m_pdlgMes != NULL )
	{
		delete m_pdlgMes;
		m_pdlgMes = NULL;
	}

	if( m_nBufLen > 0 )
	{
		delete [] m_pucDataBuf;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回当前socket的连接情况，true为连接，false为未连接
// 参数：	none
// 返回值：	true			该socket已连接
//			false			该socket未连接
//
/////////////////////////////////////////////////////////////////////////////
bool CTCPClient::GetSocketState()
{
	return m_bClientOpen;
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回当前连接的socket的远程主机IP和端口
// 参数：	strPeerAddress	远程主机IP
//			nPeerPort		远程主机端口
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPClient::GetRemoteIP( CString& strPeerAddress, int &nPeerPort )
{
	int nLen;
	sockaddr_in uSocAddIn;

	nLen = sizeof( uSocAddIn );

	if( m_bClientOpen )
	{
		if( getpeername( m_socClient, (sockaddr*) &uSocAddIn, &nLen )
			== SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			return 1;
		}
		else
		{
			strPeerAddress.Format( "%d.%d.%d.%d", uSocAddIn.sin_addr.S_un.S_un_b.s_b1,
				uSocAddIn.sin_addr.S_un.S_un_b.s_b2,uSocAddIn.sin_addr.S_un.S_un_b.s_b3,
				uSocAddIn.sin_addr.S_un.S_un_b.s_b4 );
			nPeerPort = ntohs( uSocAddIn.sin_port );
			return 0;
		}
	}

	return 2;
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回当前连接的socket的远程主机IP和端口
// 参数：	strPeerAddress	远程主机IP
//			nPeerPort		远程主机端口
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPClient::GetLocalIP( CString& strPeerAddress, int &nPeerPort )
{
	int nLen;
	sockaddr_in uSocAddIn;

	nLen = sizeof( uSocAddIn );

	if( m_bClientOpen )
	{
		if( getsockname( m_socClient, (sockaddr*) &uSocAddIn, &nLen ) 
			== SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			return 1;
		}
		else
		{
			strPeerAddress.Format( "%d.%d.%d.%d", uSocAddIn.sin_addr.S_un.S_un_b.s_b1,
				uSocAddIn.sin_addr.S_un.S_un_b.s_b2,uSocAddIn.sin_addr.S_un.S_un_b.s_b3,
				uSocAddIn.sin_addr.S_un.S_un_b.s_b4 );
			nPeerPort = ntohs( uSocAddIn.sin_port );
			return 0;
		}
	}

	return 2;
}

/////////////////////////////////////////////////////////////////////////////
//
// 设置接收数据的缓冲区大小
// 参数：	nLen			缓冲区大小
// 返回值：none
//
/////////////////////////////////////////////////////////////////////////////
void CTCPClient::SetBufferLen( int nLen )
{
	if( nLen <= 0 || nLen == m_nBufLen)
	{
		return;
	}

	if( m_pucDataBuf != NULL )
	{
		delete [] m_pucDataBuf;
		m_pucDataBuf = NULL;
		m_nBufLen = 0;
		m_nDataLen = 0;
	}

	m_pucDataBuf = new BYTE[nLen];
	if( m_pucDataBuf != NULL )
	{
		m_nBufLen = nLen;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 获取socket参数
// 参数：	nLevel			
//			nName
//			pcNewValue
//			pnValueLen
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPClient::GetOption( int nLevel, int nName, char *pcNewValue, int *pnValueLen )
{
	if( m_bClientOpen )
	{
		if( getsockopt( m_socClient, nLevel, nName, pcNewValue, pnValueLen )
			== SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			return 1;
		}
		else
		{
			return 0;
		}
	}
	else
	{
		return 2;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 设置socket参数
// 参数：	nLevel			
//			nName
//			pcNewValue
//			nValueLen
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPClient::SetOption( int nLevel, int nName, const char *pcNewValue, int nValueLen )
{
	if( m_bClientOpen )
	{
		if( setsockopt( m_socClient, nLevel, nName, pcNewValue, nValueLen ) 
			== SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			return 1;
		}
		else
		{
			return 0;
		}
	}
	else
	{
		return 2;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 打开socket，并链接到远程主机
// 参数：	pucIP			远程主机的IP
//			nRemotePort		远程主机的端口
//			nLocalPort		当地的端口
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPClient::OpenSocket( BYTE *pucIP, int nRemotePort, int nLocalPort )
{
	int nReturn;
	int nSocErr;

	sockaddr_in uSocLocalAddIn;
	sockaddr_in uSocRemoteAddIn;

	if( m_bClientOpen )
	{
		return 2;
	}

	m_socClient = socket( AF_INET, SOCK_STREAM, 0 );
	if( m_socClient == INVALID_SOCKET )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		return 1;
	}
	m_bClientOpen = true;

	//nReuse = TRUE;
	//nReturn = setsockopt( m_socClient, SOL_SOCKET, SO_REUSEADDR, (char*)&nReuse, sizeof(nReuse) );
	//nReuse = FALSE;
	//nReturn = setsockopt( m_socClient, SOL_SOCKET, SO_LINGER, (char*)&nReuse, sizeof(nReuse) );

    memset( &uSocLocalAddIn, 0, sizeof(uSocLocalAddIn) );
    uSocLocalAddIn.sin_family = AF_INET;
    uSocLocalAddIn.sin_port = htons( nLocalPort );

	if( bind( m_socClient, (sockaddr*) &uSocLocalAddIn, sizeof( uSocLocalAddIn ) ) 
		== SOCKET_ERROR )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		return 1;
	}

	if( WSAAsyncSelect( m_socClient, m_pdlgMes->m_hWnd, SOC_NETCLIENT, 
		FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE ) == SOCKET_ERROR )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		return 1;
	}

    memset( &uSocRemoteAddIn, 0, sizeof(uSocRemoteAddIn) );
    uSocRemoteAddIn.sin_family = AF_INET;
    uSocRemoteAddIn.sin_port = htons( nRemotePort );
	uSocRemoteAddIn.sin_addr.S_un.S_un_b.s_b1 = pucIP[0];
	uSocRemoteAddIn.sin_addr.S_un.S_un_b.s_b2 = pucIP[1];
	uSocRemoteAddIn.sin_addr.S_un.S_un_b.s_b3 = pucIP[2];
	uSocRemoteAddIn.sin_addr.S_un.S_un_b.s_b4 = pucIP[3];

	nReturn =connect( m_socClient, (sockaddr*)&uSocRemoteAddIn, sizeof(uSocRemoteAddIn) );
	if(nReturn == SOCKET_ERROR)
	{
		nSocErr = WSAGetLastError();
		if (nSocErr != WSAEWOULDBLOCK)
		{
			CErrorLog::Instance()->SetSdkError(nSocErr);
			return 1;
		}
	}

	//int nBufSize;
	//int nSize = 4;
	//getsockopt( m_socClient, SOL_SOCKET, SO_RCVBUF, (char*)&nBufSize, &nSize );
	//getsockopt( m_socClient, SOL_SOCKET, SO_SNDBUF, (char*)&nBufSize, &nSize );

	return 0;
}

/////////////////////////////////////////////////////////////////////////////
//
// 关闭socket
// 参数：	none
// 返回值：	none
//
/////////////////////////////////////////////////////////////////////////////
void CTCPClient::CloseSocket()
{
	if( m_bClientOpen )
	{
		if (closesocket( m_socClient ) == SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		}
		m_bClientOpen = false;
	}

	return;
}

/////////////////////////////////////////////////////////////////////////////
//
// 发送数据
// 参数：	pucSendBuf		发送的数据
//			nLen			传入时为数据长度，返回时为实际发送的数据长度
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPClient::SendData( const BYTE *pucSendBuf, int &nLen )
{
	int nSendBytes;

	if( !m_bClientOpen )
	{
		return 2;
	}

	nSendBytes = send( m_socClient, (char*)pucSendBuf, nLen, 0 );
	nLen = nSendBytes;

	return 0;
}

CUDPSocket::CUDPSocket()
{
	m_pData = NULL;

	m_bUDPOpen = false;
	m_socUDP = NULL;

	m_pucDataBuf = NULL;
	m_nDataLen = 0;
	m_nBufLen = 0;

	m_pdlgMes = new CSocMesWnd;
	m_pdlgMes->CreateEx( 0, AfxRegisterWndClass(0), 
		_T("Socket Notification Sink NOT CSOCKET"), 
		WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL);
	m_pdlgMes->ShowWindow( SW_HIDE );
	m_pdlgMes->m_pUDPSocket = this;

	m_hWndMsg = NULL;
	m_nMsg = WM_USER;
	m_pFuncMes = NULL;

	m_bGroup = false;
	m_socGroup = NULL;
	m_bGSocOpen = false;
}

CUDPSocket::~CUDPSocket()
{
	CloseSocket();

	if( m_pdlgMes != NULL )
	{
		delete m_pdlgMes;
		m_pdlgMes = NULL;
	}

	if( m_pucDataBuf != NULL )
	{
		delete [] m_pucDataBuf;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回当前socket的连接情况，true为连接，false为未连接
// 参数：	none
// 返回值：	true			该socket已连接
//			false			该socket未连接
//
/////////////////////////////////////////////////////////////////////////////
bool CUDPSocket::GetSocketState()
{
	return m_bUDPOpen;
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回当前连接的socket的远程主机IP和端口（非组播传输）
// 参数：	strPeerAddress	远程主机IP
//			nPeerPort		远程主机端口
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CUDPSocket::GetLocalIP( CString& strPeerAddress, int &nPeerPort )
{
	int nLen;
	sockaddr_in uSocAddIn;

	nLen = sizeof( uSocAddIn );

	if( m_bUDPOpen )
	{
		if( getsockname( m_socUDP, (sockaddr*) &uSocAddIn, &nLen ) 
			== SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			return 1;
		}
		else
		{
			strPeerAddress.Format( "%d.%d.%d.%d", uSocAddIn.sin_addr.S_un.S_un_b.s_b1,
				uSocAddIn.sin_addr.S_un.S_un_b.s_b2,uSocAddIn.sin_addr.S_un.S_un_b.s_b3,
				uSocAddIn.sin_addr.S_un.S_un_b.s_b4 );
			nPeerPort = ntohs( uSocAddIn.sin_port );
			return 0;
		}
	}

	return 2;
}

/////////////////////////////////////////////////////////////////////////////
//
// 设置接收数据的缓冲区大小
// 参数：	nLen			缓冲区大小
// 返回值：	none
//
/////////////////////////////////////////////////////////////////////////////
void CUDPSocket::SetBufferLen( int nLen )
{
	if( nLen <= 0 || nLen == m_nBufLen)
	{
		return;
	}

	if( m_pucDataBuf != NULL )
	{
		delete [] m_pucDataBuf;
		m_pucDataBuf = NULL;
		m_nBufLen = 0;
		m_nDataLen = 0;
	}

	m_pucDataBuf = new BYTE[nLen];
	if( m_pucDataBuf != NULL )
	{
		m_nBufLen = nLen;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 获取socket参数
// 参数：	nLevel			
//			nName
//			pcNewValue
//			pnValueLen
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CUDPSocket::GetOption( int nLevel, int nName, char *pcNewValue, int *pnValueLen )
{
	try
	{
		if( m_bUDPOpen )
		{
			if( getsockopt( m_socUDP, nLevel, nName, pcNewValue, pnValueLen ) 
				== SOCKET_ERROR )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			else
			{
				return 0;
			}
		}
		else
		{
			return 2;
		}
	}
	catch(...)
	{
		return 3;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 设置socket参数
// 参数：	nLevel			
//			nName
//			pcNewValue
//			nValueLen
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CUDPSocket::SetOption( int nLevel, int nName, const char *pcNewValue, int nValueLen )
{
	try
	{
		if( m_bUDPOpen )
		{
			if( setsockopt( m_socUDP, nLevel, nName, pcNewValue, nValueLen )
				== SOCKET_ERROR )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			else
			{