soc.cpp

bofangqi wenjian 文件的播放起 文件的

				return 0;
			}
		}
		else
		{
			return 2;
		}
	}
	catch(...)
	{
		return 3;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 打开socket，如果pucGroupIP不为空，则Socket方式为组播
// 参数：	nLocalPort		当地的端口
//			pucGroupIP		组播组的IP
//			bRoot			叶节点还是根节点（注意：不要将bRoot设为根节点）
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CUDPSocket::OpenSocket( int nLocalPort, BYTE *pucGroupIP, bool bRoot )
{
	sockaddr_in uSocLocalAddIn;

	if( m_bUDPOpen )
	{
		return 2;
	}

	try
	{
		if( pucGroupIP == NULL )
		{
			//不需要组播的普通UDP
			m_socUDP = socket( AF_INET, SOCK_DGRAM, 0 );
			if( m_socUDP == INVALID_SOCKET )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			m_bUDPOpen = true;

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

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

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

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

			m_bGroup = false;
		}
		else
		{
			//组播UDP
			int nValue;
			sockaddr_in uSocGroup;

			if( bRoot )
			{
				m_socUDP = WSASocket( AF_INET, SOCK_DGRAM, 0, NULL, 0, 
					WSA_FLAG_OVERLAPPED | WSA_FLAG_MULTIPOINT_C_ROOT | WSA_FLAG_MULTIPOINT_D_ROOT );
			}
			else
			{
				m_socUDP = WSASocket( AF_INET, SOCK_DGRAM, 0, NULL, 0, 
					WSA_FLAG_OVERLAPPED | WSA_FLAG_MULTIPOINT_C_LEAF | WSA_FLAG_MULTIPOINT_D_LEAF );
			}
			if( m_socUDP == INVALID_SOCKET )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			m_bUDPOpen = true;

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

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

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

			//路由TTL=8
			//IP_MULTICAST_TTL = 10
			nValue = 8;
			if(setsockopt( m_socUDP, IPPROTO_IP, 10, (char*)&nValue, 4 ) 
				== SOCKET_ERROR)
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}

			//禁止多播返还
			//IP_MULTICAST_LOOP = 11;
			nValue = 0;
			if(setsockopt( m_socUDP, IPPROTO_IP, 11, (char*)&nValue, 4 )
				== SOCKET_ERROR)
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}

			memset( &uSocGroup, 0, sizeof(uSocGroup) );
			uSocGroup.sin_family = AF_INET;
			uSocGroup.sin_port = htons( nLocalPort );
			uSocGroup.sin_addr.S_un.S_un_b.s_b1 = pucGroupIP[0];
			uSocGroup.sin_addr.S_un.S_un_b.s_b2 = pucGroupIP[1];
			uSocGroup.sin_addr.S_un.S_un_b.s_b3 = pucGroupIP[2];
			uSocGroup.sin_addr.S_un.S_un_b.s_b4 = pucGroupIP[3];
			m_socGroup = WSAJoinLeaf( m_socUDP, (sockaddr*)&uSocGroup, sizeof(uSocGroup),
				NULL, NULL, NULL, NULL, JL_BOTH );
			if( m_socGroup == INVALID_SOCKET )
			{
				CErrorLog::Instance()->SetSdkError(WSAGetLastError());
				return 1;
			}
			else
			{
				memcpy( m_pucGroupIP, pucGroupIP, 4 );
				m_nGroupPort = nLocalPort;
				m_bGSocOpen = true;
			}

			m_bGroup = true;
		}
	}
	catch(...)
	{
		return 3;
	}

	return 0;
}

/////////////////////////////////////////////////////////////////////////////
//
// 关闭socket
// 参数：	none
// 返回值：	none
//
/////////////////////////////////////////////////////////////////////////////
void CUDPSocket::CloseSocket()
{
	try
	{
		if( m_bUDPOpen )
		{
			if( m_bGSocOpen )
			{
				closesocket( m_socGroup );
				m_bGSocOpen = false;
			}
			closesocket( m_socUDP );
			m_bUDPOpen = false;
		}
	}
	catch(...)
	{
		;
	}

	return;
}

/////////////////////////////////////////////////////////////////////////////
//
// 发送数据
// 参数：	pucIP			接收主机的IP，4个字节
//			nDesPort		接收主机的端口
//			pucSendBuf		发送的数据
//			nLen			传入时为数据长度，返回时为实际发送的数据长度
// 返回值：	0				成功
//
/////////////////////////////////////////////////////////////////////////////
int CUDPSocket::SendData( BYTE *pucIP, int nDesPort, const BYTE *pucSendBuf, int &nLen )
{
	int nSendBytes;
	sockaddr_in uDestination;

	if( !m_bUDPOpen )
	{
		return 2;
	}

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

	try
	{
		nSendBytes = sendto( m_socUDP, (char*)pucSendBuf, nLen, 0, (sockaddr*)&uDestination,
			sizeof(uDestination) );
		nLen = nSendBytes;
	}
	catch(...)
	{
		return 3;
	}

	return 0;
}

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

	if( !m_bGroup )
	{
		return 2;
	}

	if( !m_bUDPOpen || !m_bGSocOpen )
	{
		return 3;
	}

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

	try
	{
		nSendBytes = sendto( m_socUDP, (char*)pucSendBuf, nLen, 0, (sockaddr*)&uDestination,
			sizeof(uDestination) );
		nLen = nSendBytes;
	}
	catch(...)
	{
		return 4;
	}

	return 0;
}

CUDPSock5::CUDPSock5()
{
	m_pData = NULL;

	m_bOpen = false;
	m_socTCPToProxy = NULL;
	m_socUDPData = NULL;

	nPorxyAlloPort = 0;

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

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

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

/////////////////////////////////////////////////////////////////////////////
//
// 返回代理分配给客户端的端口
// 参数：	none
// 返回值：					返回的端口
//
/////////////////////////////////////////////////////////////////////////////
int CUDPSock5::GetProxyAlloPort()
{
	return nPorxyAlloPort;
}

/////////////////////////////////////////////////////////////////////////////
//
// 设置接收数据的缓冲区大小
// 参数：	nLen			缓冲区大小
// 返回值：	none
//
/////////////////////////////////////////////////////////////////////////////
void CUDPSock5::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 CUDPSock5::GetOption( int nLevel, int nName, char *pcNewValue, int *pnValueLen )
{
	if( m_bOpen )
	{
		if( getsockopt( m_socUDPData, 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 CUDPSock5::SetOption( int nLevel, int nName, const char *pcNewValue, int nValueLen )
{
	if( m_bOpen )
	{
		if( setsockopt( m_socUDPData, nLevel, nName, pcNewValue, nValueLen )
			== SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			return 1;
		}
		else
		{
			return 0;
		}
	}
	else
	{
		return 2;
	}
}

/////////////////////////////////////////////////////////////////////////////
//
// 打开socket，并链接到远程主机
// 参数：	pucProxyInterIP	Socks5代理的内网IP，4元素的BYTE数组
//			nProxyPort		Socks5代理的端口
//			nLocalPort		本地主机UDP端口
//			pucProxyOuterIP	Socks5代理的外网IP，4元素的BYTE数组
//			strUser			Socks5安全验证的用户名
//			strPass			Socks5安全验证的密码
// 返回值：	0				成功
//			12				用户名密码验证未通过
//
/////////////////////////////////////////////////////////////////////////////
int CUDPSock5::OpenSocket( BYTE *pucProxyInterIP, int nProxyPort, int nLocalPort, BYTE *pucProxyOuterIP,
	CString strUser, CString strPass )
{
	int nReturn;
	int nTemp;

	//代理返回的支持的验证方法：0，无验证；2，用户名密码验证
	int nMethod;

	sockaddr_in uSocLocalAddIn;
	sockaddr_in uSocRemoteAddIn;

	//收发数据缓冲区
	BYTE pucSendBuf[1024];
	BYTE pucReceiveBuf[1024];

	if( strUser.GetLength() > 255 || strPass.GetLength() > 255 )
	{
		return 2;
	}

	if( m_bOpen )
	{
		return 3;
	}

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

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

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

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

	if( connect( m_socTCPToProxy, (sockaddr*)&uSocRemoteAddIn, sizeof(uSocRemoteAddIn) )
		== SOCKET_ERROR)
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		closesocket( m_socTCPToProxy );
		return 1;
	}

	//两种验证方法让SOCKS5代理选择：1、无验证；2、用户名密码验证
	pucSendBuf[0] = 5;		//ver 5
	pucSendBuf[1] = 2;		//2个方法由代理选择
	pucSendBuf[2] = 0;		//无验证
	pucSendBuf[3] = 2;		//用户名密码验证

	if( send( m_socTCPToProxy, (char*)pucSendBuf, 4, 0 ) == SOCKET_ERROR )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		closesocket( m_socTCPToProxy );
		return 1;
	}
	
	nReturn = recv( m_socTCPToProxy, (char*)pucReceiveBuf, 1024, 0 );
	if( nReturn == SOCKET_ERROR )
	{
		CErrorLog::Instance()->SetSdkError(WSAGetLastError());
		closesocket( m_socTCPToProxy );
		return 1;
	}

	if( nReturn < 2 )
	{
		closesocket( m_socTCPToProxy );
		return 4;
	}

	//只选择代理允许的第一种方法
	nMethod = pucReceiveBuf[1];
	if( nMethod == 2 )
	{
		if( !strUser.GetLength() || !strPass.GetLength() )
		{
			closesocket( m_socTCPToProxy );
			return 5;
		}

		//代理需要用户名密码验证
		pucSendBuf[0] = 1;
		pucSendBuf[1] = strUser.GetLength();
		memcpy( &pucSendBuf[2], strUser.GetBuffer(strUser.GetLength()), strUser.GetLength() );
		nTemp = strUser.GetLength() + 2;
		pucSendBuf[nTemp] = strPass.GetLength();
		nTemp++;
		memcpy( &pucSendBuf[nTemp], strPass.GetBuffer(strPass.GetLength()), strPass.GetLength() );
		nTemp += strPass.GetLength();

		if( send( m_socTCPToProxy, (char*)pucSendBuf, nTemp, 0 ) 
			== SOCKET_ERROR )
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			closesocket( m_socTCPToProxy );
			return 1;
		}
		
		nReturn = recv( m_socTCPToProxy, (char*)pucReceiveBuf, 1024, 0 );
		if(nReturn == SOCKET_ERROR)
		{
			CErrorLog::Instance()->SetSdkError(WSAGetLastError());
			closesocket( m_socTCPToProxy );
			return 1;
		}

		if( nReturn < 2 )
		{
			closesocket( m_socTCPToProxy );
			return 6;
		}

		if( pucReceiveBuf[1] != 0 )
		{
			//用户名密码验证未通过
			closesocket( m_socTCPToProxy );
			return 7;
		}