soc.cpp

bofangqi wenjian 文件的播放起 文件的

#include "stdafx.h"
#include "Soc.h"

#include "ErrorLog.h"
#include "SocMesWnd.h"

#include <algorithm>
using namespace std;

/////////////////////////////////////////////////////////////////////////////
//
// 初始化socket服务
// 参数：	none
// 返回值：	0			成功
//			1			失败
//
/////////////////////////////////////////////////////////////////////////////
int IniAPISocket()
{
	WORD wVersionRequested;
	WSADATA wsaData;
	int err;
	 
	wVersionRequested = MAKEWORD( 2, 2 );
	
	try
	{
		err = WSAStartup( wVersionRequested, &wsaData );
		if ( err != 0 ) 
		{
			/* Tell the user that we could not find a usable */
			/* WinSock DLL.                                  */
			CErrorLog::Instance()->SetSdkError(err);
			return 1;
		}
		else
		{
			return 0;
		}
	}
	catch(...)
	{
		return 2;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 结束socket服务
// 参数：   none
// 返回值： none
//
/////////////////////////////////////////////////////////////////////////////
void CloseAPISocket()
{
	try
	{
		if (WSACleanup() == SOCKET_ERROR)
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		}
	}
	catch(...)
	{
		;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 枚举本地主机的IP
// 参数：   pucIP		枚举的本地主机IP
//			nNumber		输入为pucIP的大小，输出为本地主机IP数量*4
// 返回值： 0			成功
//
/////////////////////////////////////////////////////////////////////////////
int EnumLocalIP( BYTE * pucIP, int &nNumber )
{
	int nCount = 0;
	hostent * phstLocal;

	char pcBuf[260];

	if( gethostname( pcBuf, 260 ) == SOCKET_ERROR )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		return 1;
	}

	phstLocal = gethostbyname(pcBuf);
	if( phstLocal == NULL )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		return 1;
	}

	if( phstLocal->h_length != 4 )
	{
		return 3;
	}
	
	while( phstLocal->h_addr_list[nCount] )
	{
		memcpy( &pucIP[nCount * 4], phstLocal->h_addr_list[nCount], phstLocal->h_length );
		nCount++;
	}

	nNumber = nCount * 4;

	return 0;
}

CTCPServe::CTCPServe()
{
	m_pData = NULL;

	m_pbOpenSev = false;
	m_socServer = NULL;

	m_nNextID = 1;

	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_pTcpServe = this;

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

CTCPServe::~CTCPServe()
{
	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 CTCPServe::GetSocketState()
{
	return m_pbOpenSev;
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回当前连接的客户socket数量（即当前打开的子socket数量）
// 参数：	none
// 返回值：					当前连接的客户socket数量（即当前打开的子socket数量）
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::GetClientCount()
{
	return m_pSocData.size();
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回当前打开的子socket的ID
// 参数：	nIndex			子socket序号
// 返回值：	0				失败
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::GetDataSocketID( int nIndex )
{
	if( nIndex >= 0 && nIndex <= m_pnSocID.size()
		&& m_pnSocID.size() > 0 )
	{
		return m_pnSocID[nIndex];
	}
	else
	{
		return 0;
	}
}

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

	int nIndex = GetSocIndex( nID );

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

	nLen = sizeof( uSocAddIn );

	if( m_pbSocOpen[nIndex] )
	{
		if( getpeername( m_pSocData[nIndex], (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 3;
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回当前连接的socket的本地主机IP和端口
// 参数：	nID				需要查询的子socket的ID
//			strPeerAddress	本地主机IP
//			nPeerPort		本地主机端口
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::GetLocalIP( int nID, CString& strPeerAddress, int &nPeerPort )
{
	int nLen;
	sockaddr_in uSocAddIn;

	int nIndex = GetSocIndex( nID );

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

	nLen = sizeof( uSocAddIn );

	if( m_pbSocOpen[nIndex] )
	{
		if( getsockname( m_pSocData[nIndex], (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 3;
}

/////////////////////////////////////////////////////////////////////////////
//
// 返回服务socket监听端口和本地IP
// 参数：	strPeerAddress	本地主机IP
//			nPeerPort		本地主机监听端口
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::GetServerIP(CString &strPeerAddress, int &nPeerPort)
{
	int nLen;
	sockaddr_in uSocAddIn;

	nLen = sizeof( uSocAddIn );

	if( m_pbOpenSev )
	{
		if( getsockname( m_socServer, (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 CTCPServe::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参数
// 参数：	nID				需要查询的子socket的ID（如果为0，则表示操作服务socket）
//			nLevel			
//			nName
//			pcNewValue
//			pnValueLen
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::GetOption( int nID, int nLevel, int nName, char *pcNewValue, int *pnValueLen )
{
	int nIndex;

	if( nID == 0 )
	{
		if( m_pbOpenSev )
		{
			if( getsockopt( m_socServer, nLevel, nName, pcNewValue, pnValueLen )
				== SOCKET_ERROR )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			else
			{
				return 0;
			}
		}
		else
		{
			return 2;
		}
	}
	else
	{
		nIndex = GetSocIndex( nID );

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

		if( m_pbSocOpen[nIndex] )
		{
			if( getsockopt( m_pSocData[nIndex], nLevel, nName, pcNewValue, pnValueLen ) 
				== SOCKET_ERROR )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			else
			{
				return 0;
			}
		}
		else
		{
			return 4;
		}
	}

	return 5;
}

/////////////////////////////////////////////////////////////////////////////
//
// 设置socket参数
// 参数：	nID				需要设置的子socket的ID（如果为0，则表示操作服务socket）
//			nLevel			
//			nName
//			pcNewValue
//			nValueLen
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::SetOption( int nID, int nLevel, int nName, const char *pcNewValue, int nValueLen )
{
	int nIndex;

	if( nID == 0 )
	{
		if( m_pbOpenSev )
		{
			if( setsockopt( m_socServer, nLevel, nName, pcNewValue, nValueLen ) 
				== SOCKET_ERROR )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			else
			{
				return 0;
			}
		}
		else
		{
			return 2;
		}
	}
	else
	{
		nIndex = GetSocIndex( nID );

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

		if( m_pbSocOpen[nIndex] )
		{
			if( setsockopt( m_pSocData[nIndex], nLevel, nName, pcNewValue, nValueLen )
				== SOCKET_ERROR )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			else
			{
				return 0;
			}
		}
		else
		{
			return 4;
		}
	}

	return 5;
}

/////////////////////////////////////////////////////////////////////////////
//
// 打开socket，并开始侦听
// 参数：	nPort			当地socket的端口
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::OpenSocket( int nPort )
{
	sockaddr_in uSocAddIn;

	if( m_pbOpenSev )
	{
		return 2;
	}

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

	m_pbOpenSev = true;

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

    memset( &uSocAddIn, 0, sizeof(uSocAddIn) );
	uSocAddIn.sin_family = AF_INET;
	uSocAddIn.sin_addr.s_addr = htonl(INADDR_ANY);//ADDR_ANY;
	uSocAddIn.sin_port = htons(nPort);
	if( bind( m_socServer, (sockaddr*) &uSocAddIn, sizeof( uSocAddIn ) )
		== SOCKET_ERROR )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		return 1;
	}

	if( listen( m_socServer, 5 ) == SOCKET_ERROR )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		return 1;
	}

	return 0;
}

/////////////////////////////////////////////////////////////////////////////
//
// 关闭通讯socket通道
// 参数：	nID				子socket的ID
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CTCPServe::CloseDataSocket( int nID )
{
	int nIndex = GetSocIndex( nID );

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

	if( m_pbSocOpen[nIndex] )
	{
		if (closesocket( m_pSocData[nIndex] ) == SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			return 1;
		}
		m_pbSocOpen.erase( m_pbSocOpen.begin() + nIndex );
		m_pnSocID.erase( m_pnSocID.begin() + nIndex );
		m_pSocData.erase( m_pSocData.begin() + nIndex );
	}

	return 0;
}

/////////////////////////////////////////////////////////////////////////////
//
// 关闭socket
// 参数：	none
// 返回值：	none
//
/////////////////////////////////////////////////////////////////////////////
void CTCPServe::CloseSocket()
{
	int nCount;

	for( nCount = 0; nCount < m_pSocData.size(); nCount++ )
	{
		if( m_pbSocOpen[nCount] )
		{
			closesocket( m_pSocData[nCount] );
		}
	}

	m_pbSocOpen.clear();
	m_pnSocID.clear();