www.pudn.com > 221315556.rar > Socket.cpp

// MirSocket.cpp: implementation of the CMirSocket class. 
// 
////////////////////////////////////////////////////////////////////// 
 
 
#include "stdserver.h" 
#include "Socket.h" 
#include  
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
CSocket::CSocket() 
{ 
 
} 
 
CSocket::~CSocket() 
{ 
 
} 
int CSocket::SetNoBlock( SOCKET s ) 
{ 
	unsigned long mode = 1; 
	if( ioctlsocket( s, FIONBIO, &mode ) == -1 ) 
		return 0; 
	return 1; 
} 
int CSocket::SetBlock( SOCKET s ) 
{ 
	unsigned long mode = 0; 
	if( ioctlsocket( s, FIONBIO, &mode ) == -1 ) 
		return 0; 
	return 1; 
} 
BOOL	CSocket::NetStartup() 
{ 
	return NetStartup( 2,2 ); 
} 
BOOL	CSocket::NetCleanup() 
{ 
	return WSACleanup(); 
} 
 
SOCKET	CSocket::OpenConnection( const char * ip, const UINT port ) 
{ 
	LPHOSTENT m_pHost; 
	SOCKET	s; 
	struct	sockaddr_in ServAddr; 
	m_pHost = gethostbyname(ip); 
	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
	ServAddr.sin_family	= AF_INET; 
	ServAddr.sin_addr.s_addr = *(ULONG *)m_pHost->h_addr_list[0]; 
	ServAddr.sin_port = htons(port); 
	int erri = connect(s, (struct sockaddr *)&ServAddr, sizeof(ServAddr)); 
	if( erri == -1) 
		return 0; 
	return s; 
} 
void	CSocket::CloseConnection( SOCKET s ) 
{ 
	closesocket( s ); 
} 
 
 
SOCKET CSocket::Listen(UINT port, int maxqueue) 
{ 
	struct	sockaddr_in	serveraddr; 
	SOCKET	s; 
	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
	if( s == INVALID_SOCKET ) 
		return 0; 
 
	memset( (void*)&serveraddr, 0, sizeof( struct sockaddr_in )); 
 
	serveraddr.sin_family = PF_INET; 
    serveraddr.sin_addr.s_addr = htonl( INADDR_ANY ); 
	serveraddr.sin_port = htons( port ); 
	 
	 
	if( bind(s, (struct sockaddr * )&serveraddr, sizeof( struct sockaddr_in )) < 0 ) 
	{ 
		closesocket( s ); 
		return 0; 
	} 
	if( listen( s, maxqueue ) == SOCKET_ERROR ) 
	{	 
		closesocket( s ); 
		return 0; 
	} 
	 
	return s; 
} 
 
BOOL CSocket::Accept(SOCKET sListen, SOCKET & sAccept) 
{ 
	sockaddr_in	addr; 
	int addrlen; 
	addrlen = sizeof( addr ); 
 
	sAccept = accept( sListen, (sockaddr*)&addr, &addrlen ); 
	printf( "%u.%u.%u.%u:%u connected!\n", addr.sin_addr.S_un.S_addr & 0xff, (addr.sin_addr.S_un.S_addr & 0xff00)>>8, (addr.sin_addr.S_un.S_addr & 0xff0000)>>16, (addr.sin_addr.S_un.S_addr & 0xff000000)>>24, htons(addr.sin_port) ); 
	if( sAccept != INVALID_SOCKET ) 
	{ 
		return TRUE; 
	} 
	return FALSE; 
} 
 
int CSocket::Recv(SOCKET s, void *buf, int len) 
{ 
	return recv( s, (char*)buf, len, 0 ); 
} 
 
int CSocket::Send(SOCKET s, void *buf, int len) 
{ 
	return send( s, (char*)buf, len, 0 ); 
} 
 
// 网络初始化 
BOOL CSocket::NetStartup(int ver1, int ver2) 
{ 
	WSADATA m_wsaData; 
	return (WSAStartup(MAKEWORD(ver1,ver2), &m_wsaData) != SOCKET_ERROR); 
} 
 
BOOL CSocket::Accept(SOCKET sListen, SOCKET& sAccept, char* pszIpAddr, UINT& usPort) 
{ 
	sockaddr_in	addr; 
	int addrlen; 
	addrlen = sizeof( addr ); 
 
	sAccept = accept( sListen, (sockaddr*)&addr, &addrlen ); 
 
 
	if( sAccept != INVALID_SOCKET ) 
	{ 
		printf( "%u.%u.%u.%u:%u connected!\n", addr.sin_addr.S_un.S_addr & 0xff, (addr.sin_addr.S_un.S_addr & 0xff00)>>8, (addr.sin_addr.S_un.S_addr & 0xff0000)>>16, (addr.sin_addr.S_un.S_addr & 0xff000000)>>24, htons(addr.sin_port) ); 
		usPort = htons( addr.sin_port ); 
		if( pszIpAddr != NULL ) 
			sprintf( pszIpAddr, "%u.%u.%u.%u", addr.sin_addr.S_un.S_addr & 0xff, (addr.sin_addr.S_un.S_addr & 0xff00)>>8, (addr.sin_addr.S_un.S_addr & 0xff0000)>>16, (addr.sin_addr.S_un.S_addr & 0xff000000)>>24 ); 
		return TRUE; 
	} 
	return FALSE; 
} 
 
BOOL CSocket::OpenConnection(const char * IpAddress ,const UINT Port, PCONNECTION pConnection) 
{ 
	pConnection->Socket = OpenConnection( IpAddress, Port ); 
	if( pConnection->Socket == 0 ) 
		return FALSE; 
	return TRUE; 
} 
 
BOOL CSocket::Listen(UINT Port, int MaxQueue, PCONNECTION pConnection) 
{ 
	if( (pConnection->Socket = Listen( Port, MaxQueue ))== 0 ) 
	{ 
		return FALSE; 
	} 
	pConnection->Port = Port; 
	return TRUE; 
} 
 
BOOL CSocket::Accept(SOCKET sListen, PCONNECTION pConnection) 
{ 
	return Accept( sListen, pConnection->Socket, pConnection->IpAddress, pConnection->Port ); 
} 
 
BOOL CSocket::CloseConnection(PCONNECTION pConnection) 
{ 
	return (closesocket( pConnection->Socket ) != SOCKET_ERROR ); 
	//return 0; 
} 
BOOL CSocket::SetNoBlock(PCONNECTION pConnection) 
{ 
	return SetNoBlock(pConnection->Socket); 
} 
BOOL CSocket::OpenConnection(const char * IpAddress , const UINT Port, PCONNECTION pConnection, int nSeconds) 
{ 
	LPHOSTENT m_pHost; 
	SOCKET	s; 
	struct	sockaddr_in ServAddr; 
	m_pHost = gethostbyname(IpAddress); 
	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
	if( s == INVALID_SOCKET	) 
		return 0; 
	SetNoBlock(s); 
	ServAddr.sin_family	= AF_INET; 
	ServAddr.sin_addr.s_addr = *(ULONG *)m_pHost->h_addr_list[0]; 
	ServAddr.sin_port = htons(Port); 
 
	int erri = connect(s, (struct sockaddr *)&ServAddr, sizeof(ServAddr)); 
	if( erri == -1 ) 
	{ 
		if(  WSAGetLastError() == 10035 ) 
		{ 
			fd_set	fds; 
			fds.fd_count = 0; 
			FD_SET(s,&fds); 
			timeval	tv; 
			tv.tv_sec = nSeconds; 
			tv.tv_usec = 0; 
			select( 0, 0, &fds, 0,&tv ); 
			if(! FD_ISSET(s, &fds )) 
			{ 
				return FALSE; 
			} 
		} 
		else 
		{ 
			return FALSE; 
		} 
	} 
	pConnection->Socket = s; 
	pConnection->Port = Port; 
	strncpy( pConnection->IpAddress, IpAddress, 16 ); 
	pConnection->IpAddress[16] = '\0'; 
	return TRUE; 
 } 
 
BOOL CSocket::UDPBind(char* szIpAddress, UINT uPort, PCONNECTION pConnection) 
{ 
	/* 
	LPHOSTENT m_pHost; 
	SOCKET	s; 
	struct	sockaddr_in ServAddr; 
	m_pHost = gethostbyname(ip); 
	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
	if( s == INVALID_SOCKET) 
		return FALSE; 
	ServAddr.sin_family	= AF_INET; 
	ServAddr.sin_addr.s_addr = *(ULONG *)m_pHost->h_addr_list[0]; 
	ServAddr.sin_port = htons(port); 
	*/ 
	return 0; 
} 
struct sock5req1  
{  
	char Ver;  
	char nMethods;  
	char Methods[255];  
};  
 
struct sock5ans1  
{  
	char Ver;  
	char Method;  
};  
 
struct sock5req2  
{  
	char Ver;  
	char Cmd;  
	char Rsv;  
	char Atyp;  
	char other[1];  
};  
 
struct sock5ans2  
{  
	char Ver;  
	char Rep;  
	char Rsv;  
	char Atyp;  
	char other[1];  
};  
 
struct authreq  
{  
	char Ver;  
	char Ulen;  
	char Name[255];  
	char PLen;  
	char Pass[255];  
};  
 
struct authans  
{  
	char Ver;  
	char Status;  
};  
 
BOOL CSocket::OpenConnection(const char * IpAddress , const UINT Port,const char * szProxyIpAddress , const UINT nProxyPort,const CHAR*szProxyUserName, const CHAR *szProxyPassword, UINT	nProxyType,  PCONNECTION pConnection ) 
{ 
	if( !OpenConnection( szProxyIpAddress, nProxyPort, pConnection )) 
	{ 
		return FALSE; 
	} 
	char buff[600]; 
	struct sock5req1 *m_proxyreq1;  
	m_proxyreq1 = (struct sock5req1 *)buff;  
	m_proxyreq1->Ver = 5;  
	m_proxyreq1->nMethods = 2;  
	m_proxyreq1->Methods[0] = 0;  
	m_proxyreq1->Methods[1] = 2;  
	send(pConnection->Socket, buff,4, 0);  
	struct sock5ans1 *m_proxyans1;  
	m_proxyans1 = (struct sock5ans1 *)buff;  
	memset(buff,0,600);  
	recv(pConnection->Socket,buff,600, 0);  
	if(m_proxyans1->Ver != 5 || (m_proxyans1->Method!=0 && m_proxyans1->Method!=2))  
	{  
		printf("通过代理连接主站不成功!\n");  
		CloseConnection(pConnection); 
		return FALSE;  
	}  
	if(m_proxyans1->Method == 2)  
	{ 
 
		int nUserLen = strlen("abcdefg");  
		int nPassLen = strlen("1234556");  
		struct authreq *m_authreq;  
		m_authreq = (struct authreq *)buff;  
		m_authreq->Ver = 1;  
		m_authreq->Ulen = nUserLen;  
		strcpy(m_authreq->Name,"abcdefg");  
		m_authreq->PLen = nPassLen;  
		strcpy(m_authreq->Pass,"1234556");  
		send(pConnection->Socket,buff,513, 0);  
		struct authans *m_authans;  
		m_authans = (struct authans *)buff;  
		memset(buff,0,600);  
		recv(pConnection->Socket,buff,600,0);  
		if(m_authans->Ver != 1 || m_authans->Status != 0)  
		{  
			printf("代理服务器用户验证不成功!\n");  
			CloseConnection(pConnection); 
			return FALSE;  
		}  
	}  
	struct sock5req2 *m_proxyreq2;  
	m_proxyreq2 = (struct sock5req2 *)buff;  
	m_proxyreq2->Ver = 5;  
	m_proxyreq2->Cmd = 1;  
	m_proxyreq2->Rsv = 0;  
	m_proxyreq2->Atyp = 1;  
	unsigned long tmpLong = inet_addr(IpAddress);  
	unsigned short port = ntohs(Port);//GetPort());  
	memcpy(m_proxyreq2->other,&tmpLong,4);  
	memcpy(m_proxyreq2->other+4,&port,2);  
	send(pConnection->Socket, buff,sizeof(struct sock5req2)+5, 0);  
	struct sock5ans2 *m_proxyans2;  
	memset(buff,0,600);  
	m_proxyans2 = (struct sock5ans2 *)buff;  
	recv(pConnection->Socket,buff,600, 0);  
	if(m_proxyans2->Ver != 5 || m_proxyans2->Rep != 0)  
	{  
		printf("通过代理连接主站不成功!\n");  
		CloseConnection(pConnection);  
		return FALSE;  
	}  
 
 
	return TRUE; 
}