老大们，帮忙看看

Question

我是Winsock新手！
我的SOCKS代理服务器是192.168.1.1，
我现在想通过代理连出去，
所以我首先与代理建立连接，连接成功后与代理进行协商，
现在我想与www.163.com连接，所以我在协商代码中
得地址是163得，可我老是不成功，是不是我的思路有问题，
还是代码有问题，谢谢！
clientAddr.sin_family= AF_INET;
clientAddr.sin_port= htons(1080);
clientAddr.sin_addr.s_addr = inet_addr("192.168.1.1");
socketClient= socket(AF_INET,SOCK_STREAM,0);
if((socketClient==INVALID_SOCKET)||(iResult==SOCKET_ERROR))
{
DisplayMessage("socket() ERROR!");
iResult=WSAGetLastError();
WSACleanup();
}
else
DisplayMessage("Connect success!");
iResult=connect(socketClient,(struct sockaddr *)&clientAddr, sizeof(clientAddr));
if((iResult==SOCKET_ERROR)
{
DisplayMessage("socket() ERROR!");
iResult=WSAGetLastError();
WSACleanup();
}
WORD PortNo = 80; 
buffer[0]   = 0x05; //协议版本 211.80.40.8
buffer[1]   = 0x01; //选择方法 
buffer[2]   = 0x00; //无需认证 
buffer[3] = 0x01; //地址类型:IpV4 
buffer[4] = 0xCA; //211//交大测试地址
buffer[5] = 0x6C; //80 
buffer[6] = 0x24; //40 
buffer[7] = 0xA7; //8 
buffer[8] = PortNo/256; //0x1080; 
buffer[9] = (BYTE)PortNo%256; //0x00; 
PortNo += 1; 
send(socketClient,(const far char*)buffer,3,0); 
recv(socketClient,(char*)buffer,10,0);
if(buffer[1] != 0x00) 
MessageBox(NULL,"Need to authenticate!","Info",MB_OK);

Answer 1

没有看出来问题。
给你一个支持代理的socket类：
/* -------------------- winSocketEx.h ----------------------- *
 *  Definition of winSocketEx class.                          *
 *  Extends winSocket to include support for SOCKS proxies    *
 *  that are RFC 1928 and 1929 compliant. Supports both       *
 *  version 4 and 5 of the protocol. Implemented commands are *
 *  CONNECT and BIND.                                         *
 *                                                            *
 *  This code is FREE!                                        *
 *  Written by Ryan Lederman - [email protected]               *
 **************************************************************/#ifndef _WINSOCKETEX_H
#define _WINSOCKETEX_H#include "winSocket.h"#define PROXY_V5 0 // Protocol versions supported //
#define PROXY_V4 1typedef struct tagSOCKS5AUTHSTRUCT {
char *szUserName; // Null terminated user name
char *szPassWord; // Null terminated password
int  iUserNameLength; // Length of user name, in bytes
int  iPassWordLength; // Length of password in bytes
} SOCKS5AUTHSTRUCT, *PSOCKS5AUTHSTRUCT;typedef struct tagPROXYCONNECTSTRUCT {
unsigned int uiProtocolVer; // Version to use (4 or 5)
unsigned int iProxyPort; // Port to connect on proxy machine
unsigned long ulHostIP; // Remote host address (network order)
unsigned short usHostPort; // Remote host port (network order)
bool bUseSocksLogin; // Boolean switch for login/pass or not
char *szProxyIP; // Dotted quad IP address of proxy machine
SOCKS5AUTHSTRUCT auth;      // User name, password, and associated lengths
char msg[512];              // Any string data that is passed back
} PROXYCONNECTSTRUCT, *PPROXYCONNECTSTRUCT;typedef struct tagPROXYBINDSTRUCT {
unsigned int uiProtocolVer; // Version to use (4 or 5)
unsigned long ulIPAddress;  // IP address
unsigned short usPort;      // Port
unsigned int iProxyPort;    // Port number to connect on proxy machine
unsigned int iProxyBindPort;// Port number returned by proxy
bool bUseSocksLogin; // Boolean switch for login/pass or not
SOCKS5AUTHSTRUCT auth;      // User name, password, and associated lengths
char *szProxyIP;            // Dotted quad IP address of proxy machine
} PROXYBINDSTRUCT, *PPROXYBINDSTRUCT;typedef struct tagSOCKS4COMMAND {
unsigned char vn;   // Version
unsigned char cd;   // Command
unsigned char dstPort[2]; // Port field (network order)
unsigned char dstAddr[4]; // IP field (network order)
unsigned char ucUserID[2];// User ID (2 octets)
unsigned char ucNull;   // Must be set to zero
int           iSize;      // Size of data being sent to server, in bytes
} SOCKS4COMMAND, *PSOCKS4COMMAND;typedef struct tagSOCKS5COMMAND {
unsigned char vn;         // Version
unsigned char cd;         // Command
unsigned char flag;   // Command dependant flag
unsigned char tAddr;   // Address type
unsigned char dstAddr[4]; // IP field (network order)
unsigned char dstPort[2]; // Port field (network order)
int           iSize;      // Size of data being sent to server, in bytes
} SOCKS5COMMAND, *PSOCKS5COMMAND;typedef struct tagSOCKS5VMSTRUCT {
unsigned char vn;  // Version
unsigned char nmethods;  // Number of methods being requested
unsigned char mthd[255]; // Array of requested method identifiers
} SOCKS5VMSTRUCT, *PSOCKS5VMSTRUCT;typedef struct tagSOCKS4REPLY {
unsigned char vn;   // Version (should be 0)
unsigned char cd;       // Response code (see SOCKS4REPLY_* below)
unsigned char dstPort[2]; // 16-bit network ordered port number
unsigned char dstAddr[4]; // 32-bit network ordered internet address
unsigned char msg[512]; // String message
} SOCKS4REPLY, *PSOCKS4REPLY;typedef struct tagSOCKS5REPLY {
unsigned char vn;       // Version number
unsigned char rep;        // Reply code (see SOCKS5REPLY_* below)
unsigned char rsv;       // Reserved
unsigned char tAddr;   // Address type
unsigned char bndAddr[4]; // Internet address
unsigned char bndPort[2]; // Port number
unsigned char msg[512];   // String message
} SOCKS5REPLY, *PSOCKS5REPLY;#define SOCKS4REPLY_SUCCESS       90
#define SOCKS4REPLY_REQUESTFAILED 91
#define SOCKS4REPLY_NOIDENTD      92
#define SOCKS4REPLY_DIFFIDENTD    93#define SOCKS5REPLY_SUCCESS              0
#define SOCKS5REPLY_GENERALFAILURE       1
#define SOCKS5REPLY_CONNNOTALLOWED       2
#define SOCKS5REPLY_NETWORKUNREACHABLE   3
#define SOCKS5REPLY_HOSTUNREACHABLE      4
#define SOCKS5REPLY_CONNREFUSED          5
#define SOCKS5REPLY_TTLEXPIRED           6
#define SOCKS5REPLY_COMMANDNOTSUPPORTED  7
#define SOCKS5REPLY_ADDRTYPENOTSUPPORTED 8#define PCERR_NOCONN        0 // Error return codes for ProxyConnect //
#define PCERR_REQUESTFAILED        1
#define PCERR_AUTHREQUIRED         2
#define PCERR_AUTHTYPEUNKNOWN      3
#define PCERR_AUTHFAILED           4
#define PCERR_AUTHNOLOGON          5
#define PCERR_BADPARAM             6
#define PCERR_GENFAILURE           7
#define PCERR_CONNNOTALLOWED       8
#define PCERR_HOSTUNREACHABLE      9
#define PCERR_COMMANDNOTIMPL       10
#define PCERR_TTLEXPIRED           11
#define PCERR_ADDRTYPENOTSUPPORTED 12
#define PCERR_CONNREFUSED          13
#define PCERR_NOIDENTD             14
#define PCERR_DIFFIDENTD           15
#define PCERR_NOGSSAPISUPPORT      16
#define PC_SUCCESS                 17 // Success code //#define RECVERR_WSAERROR      0
#define RECV_SUCCESS          1#define BINDERR_REQUESTFAILED   0
#define BINDERR_NOCONNECTION    1
#define BINDERR_WSAERROR        2
#define BINDERR_BADPARAM        3
#define BINDERR_NOGSSAPISUPPORT 4
#define BINDERR_AUTHREQUIRED    5
#define BINDERR_AUTHFAILED      6
#define BIND_SUCCESS            7#define MSELECTERR_WSAERROR           0 // Error codes for SOCKS5 method selection //
#define MSELECTERR_NOCLIENTSUPPORT    1 // <--- GSSAPI is not supported, feel free to add it and tell me!
#define MSELECTERR_NOMETHODACCEPTABLE 2
#define MSELECT_AUTHREQUIRED          3
#define MSELECT_NOAUTHREQUIRED        4#define AUTH_SUCCESS     1
#define AUTH_FAILURE     0
#define AUTHERR_BADPARAM 2
#define AUTHERR_WSAERROR 3class winSocketEx : public winSocket
{
public: // Public Methods //
winSocketEx( void );
~winSocketEx( void );
int  ProxyConnect( PPROXYCONNECTSTRUCT pPcs );
int  PrepareBind( PPROXYBINDSTRUCT pSbs );
BOOL PostBind( int iProtocolVer  );
private: // Private Methods //
BOOL SendSocks4Command( PSOCKS4COMMAND pCmd );
BOOL SendSocks5Command( PSOCKS5COMMAND pCmd );
int  RecvSocks4Reply( PSOCKS4REPLY );
int  RecvSocks5Reply( PSOCKS5REPLY );
int  DoSocks4Bind( PPROXYBINDSTRUCT pSbs );     // Private Members //
int  DoSocks5Bind( PPROXYBINDSTRUCT pSbs );
int  Socks5MethodSelect( PSOCKS5VMSTRUCT );
int  Socks5DoAuthentication( PSOCKS5AUTHSTRUCT pAs );
};#endif /* _WINSOCKETEX_H */

Answer 2

/*******************************************
 *   winSocket.cpp - Implementation of     * 
 *   winSocketEx Winsock API wrapper class *
 *    Ryan Lederman [email protected]       *
 *            January 2002                 *
 *          THIS CODE IS FREE              *
 *                                         *
 *******************************************/#include "winSocketEx.h"winSocketEx::winSocketEx( void ) {}
winSocketEx::~winSocketEx( void ){}int winSocketEx::ProxyConnect( PPROXYCONNECTSTRUCT pPcs )
{
SOCKS4COMMAND s4c;
SOCKS5COMMAND s5c;
unsigned char command[10] = {0};
unsigned char *buffer     = NULL;
int iReadFromQueue        = 0;
char szHostIP[16]         = {0};
SOCKS5REPLY s5r;
SOCKS4REPLY s4r;
SOCKS5VMSTRUCT svm;
int iReplyCode            = 0; if( pPcs->szProxyIP == NULL || pPcs->iProxyPort == 0 || pPcs->usHostPort == 0 )
return PCERR_BADPARAM; if( pPcs->uiProtocolVer != PROXY_V5 && pPcs->uiProtocolVer != PROXY_V4 ) // No proxy used
{
winSocket::longToDottedQuad( ntohl(pPcs->ulHostIP), szHostIP ); // Connect directly to host
if( winSocket::Connect( szHostIP, (u_short)ntohl(pPcs->usHostPort) ) != ERR_SUCCESS )
return PCERR_NOCONN;
}
else
if( winSocket::Connect( pPcs->szProxyIP, pPcs->iProxyPort ) != ERR_SUCCESS )
return PCERR_NOCONN; if( pPcs->uiProtocolVer == PROXY_V4 ) // Do version 4 connection
{
memset( &s4c, 0, sizeof(SOCKS4COMMAND) );

s4c.vn = 4; // Set version to 4
s4c.cd = 1; // Set command to '1': CONNECT memcpy( &s4c.dstPort, &pPcs->usHostPort, 2 ); // Copy 16-bit (big-endian) port number
memcpy( &s4c.dstAddr, &pPcs->ulHostIP, 4 );   // Copy 32-bit (big-endian) IP Address s4c.iSize = 9; if( !SendSocks4Command( &s4c ) ) // Send command to proxy
return PCERR_REQUESTFAILED; // Failed to send data to the proxy if( RecvSocks4Reply( &s4r ) != RECV_SUCCESS ) // Receive response from proxy
return PCERR_REQUESTFAILED; // proxy denied request memset( pPcs->msg, 0, 512 );
memcpy( pPcs->msg, s4r.msg, strlen((const char*)s4r.msg) ); switch( s4r.cd )
{
case SOCKS4REPLY_SUCCESS: return PC_SUCCESS;
case SOCKS4REPLY_REQUESTFAILED: return PCERR_REQUESTFAILED;
case SOCKS4REPLY_NOIDENTD: return PCERR_NOIDENTD;
case SOCKS4REPLY_DIFFIDENTD: return PCERR_DIFFIDENTD;
} return -1;
}
else // Do SOCKS 5 connect
{
memset( &s5c, 0, sizeof(SOCKS5COMMAND) );
memset( &svm, 0, sizeof(SOCKS5VMSTRUCT) ); svm.vn       = 5;
svm.nmethods = 1;
svm.mthd[0]  = 1; iReplyCode = Socks5MethodSelect( &svm ); if( iReplyCode == MSELECTERR_NOMETHODACCEPTABLE )
return PCERR_REQUESTFAILED; if( iReplyCode == MSELECTERR_NOCLIENTSUPPORT )
return PCERR_NOGSSAPISUPPORT; if( iReplyCode == MSELECT_AUTHREQUIRED && pPcs->bUseSocksLogin == false )
return PCERR_AUTHREQUIRED; if( iReplyCode == MSELECT_AUTHREQUIRED )
if( Socks5DoAuthentication( &pPcs->auth ) != AUTH_SUCCESS )
return PCERR_AUTHFAILED; memset( &s5c, 0, sizeof(SOCKS5COMMAND) );

s5c.vn = 5;    // Version requested: 5
s5c.cd = 1;    // Command:           CONNECT
s5c.tAddr = 1; // Address Type:      IPv4

memcpy( &s5c.dstAddr , &pPcs->ulHostIP, 4 ); // Assumes values have already
memcpy( &s5c.dstPort, &pPcs->usHostPort, 2 ); // been converted to network order s5c.iSize = 10; if( !SendSocks5Command( &s5c ) )
return PCERR_REQUESTFAILED; memset( &s5r, 0, sizeof(SOCKS5REPLY) ); if( RecvSocks5Reply( &s5r ) != RECV_SUCCESS )
return PCERR_REQUESTFAILED;

memset( pPcs->msg, 0, 512 );
memcpy( pPcs->msg, s5r.msg, strlen((const char*)s5r.msg) ); switch( s5r.rep )
{
case SOCKS5REPLY_SUCCESS: return PC_SUCCESS;
case SOCKS5REPLY_GENERALFAILURE: return PCERR_GENFAILURE;
case SOCKS5REPLY_CONNNOTALLOWED: return PCERR_CONNNOTALLOWED;
case SOCKS5REPLY_NETWORKUNREACHABLE: return PCERR_NOCONN;
case SOCKS5REPLY_HOSTUNREACHABLE: return PCERR_HOSTUNREACHABLE;
case SOCKS5REPLY_CONNREFUSED: return PCERR_CONNREFUSED;
case SOCKS5REPLY_TTLEXPIRED: return PCERR_TTLEXPIRED;
case SOCKS5REPLY_COMMANDNOTSUPPORTED: return PCERR_COMMANDNOTIMPL;
case SOCKS5REPLY_ADDRTYPENOTSUPPORTED: return PCERR_ADDRTYPENOTSUPPORTED;
}
} return -1;
}int winSocketEx::Socks5DoAuthentication( PSOCKS5AUTHSTRUCT pAs )
{
unsigned char command[514] = {0};
int iReadFromQueue         = 0; if( pAs == NULL )
return AUTHERR_BADPARAM; command[0] = 5;
command[1] = pAs->iUserNameLength;
memcpy( &command[2], pAs->szUserName, pAs->iUserNameLength );
command[2+ pAs->iUserNameLength] = pAs->iPassWordLength;
memcpy( &command[3 + pAs->iUserNameLength], pAs->szPassWord, pAs->iPassWordLength ); if( winSocket::Send( (char*)command, (3+ pAs->iPassWordLength + pAs->iUserNameLength ) ) != ERR_SUCCESS )
return AUTHERR_WSAERROR; memset( command, 0, 514 ); iReadFromQueue = winSocket::Receive( winSocket::m_hSocket, (char*)command, 2 ); if( iReadFromQueue == 0 || iReadFromQueue == SOCKET_ERROR )
return AUTHERR_WSAERROR; if( command[1] == 0x00 )
return AUTH_SUCCESS;
else
return AUTH_FAILURE;}int winSocketEx::Socks5MethodSelect( PSOCKS5VMSTRUCT psVm )
{
unsigned char command[258] = {0};
int size                   = 0;
int iReadFromQueue         = 0; command[0] = psVm->vn;
command[1] = psVm->nmethods;
memcpy( &command[2], psVm->mthd, (int)psVm->nmethods ); size = (2 + ((int)psVm->nmethods)); if( winSocket::Send( (char*)command, size ) != ERR_SUCCESS )
return MSELECTERR_WSAERROR; memset( command, 0, 258 ); iReadFromQueue = winSocket::Receive( winSocket::m_hSocket, (char*)command, 2 ); if( iReadFromQueue == 0 || iReadFromQueue == SOCKET_ERROR )
return MSELECTERR_WSAERROR; switch( command[1] )
{
case 0x02: return MSELECT_AUTHREQUIRED;
case 0x00: return MSELECT_NOAUTHREQUIRED;
case 0xFF: return MSELECTERR_NOMETHODACCEPTABLE;
} return MSELECTERR_NOCLIENTSUPPORT;
}

Answer 3

int winSocketEx::PrepareBind( PPROXYBINDSTRUCT pSbs )
{
switch( pSbs->uiProtocolVer )
{
case PROXY_V4: return DoSocks4Bind( pSbs );
case PROXY_V5: return DoSocks5Bind( pSbs );
}
return -1;
}int winSocketEx::DoSocks4Bind( PPROXYBINDSTRUCT pSbs )
{
SOCKS4COMMAND s4c         = {0};
char szIP[16]             = {0};
char szPort[6]            = {0};
int iReadFromQueue        = 0;
unsigned short ulPort     = 0;
unsigned char command[10] = {0}; if( winSocket::Connect( pSbs->szProxyIP, pSbs->iProxyPort ) != ERR_SUCCESS )
return BINDERR_NOCONNECTION; memset( &s4c, 0, sizeof(SOCKS4COMMAND) );

s4c.vn = 4;
s4c.cd = 2;
memcpy( &s4c.dstPort, &pSbs->usPort, 2 );
memcpy( &s4c.dstAddr, &pSbs->ulIPAddress, 4 );

s4c.iSize = 9; if( !SendSocks4Command( &s4c ) )
return BINDERR_REQUESTFAILED; iReadFromQueue = winSocket::Receive( winSocket::m_hSocket, (char*)command, 8 ); if( iReadFromQueue != 8 )
return BINDERR_REQUESTFAILED; if( command[1] != 90 )
return BINDERR_REQUESTFAILED; memcpy( &ulPort, &command[2], 2 ); pSbs->iProxyBindPort = ntohs( ulPort ); return BIND_SUCCESS;
}int winSocketEx::DoSocks5Bind( PPROXYBINDSTRUCT pSbs )
{
int iReplyCode            = 0;
int iReadFromQueue        = 0;
unsigned char command[10] = {0};
unsigned short usPort     = 0;
SOCKS5REPLY s5r;
SOCKS5COMMAND s5c;
SOCKS5VMSTRUCT sVm; if( pSbs->iProxyPort == 0     || pSbs->usPort == 0       ||
pSbs->szProxyIP == NULL   || pSbs->ulIPAddress == 0  ||
pSbs->uiProtocolVer != PROXY_V4 && pSbs->uiProtocolVer != PROXY_V5 ) 
return BINDERR_BADPARAM; if( winSocket::Connect( pSbs->szProxyIP, pSbs->iProxyPort ) != ERR_SUCCESS )
return BINDERR_NOCONNECTION; memset( &sVm, 0, sizeof(SOCKS5VMSTRUCT) ); sVm.vn       = 5;
sVm.nmethods = 1;
sVm.mthd[0]  = 2; iReplyCode = Socks5MethodSelect( &sVm ); if( iReplyCode == MSELECTERR_NOMETHODACCEPTABLE )
return BINDERR_REQUESTFAILED; if( iReplyCode == MSELECTERR_NOCLIENTSUPPORT )
return BINDERR_NOGSSAPISUPPORT; if( iReplyCode == MSELECT_AUTHREQUIRED && pSbs->bUseSocksLogin == false )
return BINDERR_AUTHREQUIRED; if( iReplyCode == MSELECT_AUTHREQUIRED ) // Authorization required
if( Socks5DoAuthentication( &pSbs->auth ) != AUTH_SUCCESS )
return BINDERR_AUTHFAILED; memset( &s5c, 0, sizeof(SOCKS5COMMAND) );
memset( &s5r, 0, sizeof(SOCKS5REPLY) ); s5c.vn = 5;
s5c.cd = 2;
s5c.flag = 0;
s5c.tAddr = 1;

memcpy( s5c.dstAddr, &pSbs->ulIPAddress, 4 );
memcpy( s5c.dstPort, &pSbs->usPort, 2 ); s5c.iSize = 11; if( !SendSocks5Command( &s5c ) )
return BINDERR_WSAERROR; iReadFromQueue = winSocket::Receive( winSocket::m_hSocket, (char*)command, 10 ); if( iReadFromQueue == 0 || iReadFromQueue == SOCKET_ERROR )
return BINDERR_WSAERROR; if( command[1] != 0x00 )
return (int)command[1]; memcpy( &usPort, &command[8], 2 ); pSbs->iProxyBindPort = usPort; return BIND_SUCCESS;
}BOOL winSocketEx::PostBind( int iProtocolVer )
{
unsigned char response[10]   = {0};
int  iReadFromQueue = 0;
fd_set sock; sock.fd_array[0] = winSocket::m_hSocket;
sock.fd_count = 1; if( select( 0, &sock, 0, 0, NULL ) == SOCKET_ERROR )
return false; iReadFromQueue = winSocket::Receive( winSocket::m_hSocket, (char*)response, 8 ); if( iReadFromQueue == SOCKET_ERROR || iReadFromQueue == 0 )
return false; switch( iProtocolVer )
{
case PROXY_V4:
if( response[1] != 90 )
return false;
break;
case PROXY_V5:
if( response[1] != 00 )
return false;
break;
} return true;
}BOOL winSocketEx::SendSocks4Command( PSOCKS4COMMAND pCmd )
{
unsigned char command[256] = {0};
int iRetVal = 0; command[0] = pCmd->vn;
command[1] = pCmd->cd; memcpy( &command[2], pCmd->dstPort, 2 );
memcpy( &command[4], pCmd->dstAddr, 4 ); iRetVal = winSocket::Send( (char*)command, pCmd->iSize ); if( iRetVal != ERR_SUCCESS )
return false; return true;
}BOOL winSocketEx::SendSocks5Command( PSOCKS5COMMAND pCmd )
{
unsigned char command[256] = {0}; command[0] = pCmd->vn;
command[1] = pCmd->cd;
command[2] = pCmd->flag;
command[3] = pCmd->tAddr; memcpy( &command[4], pCmd->dstAddr, 4 );
memcpy( &command[8], pCmd->dstPort, 2 ); if( winSocket::Send( (char*)command, pCmd->iSize ) != ERR_SUCCESS )
return false; return true;
}int winSocketEx::RecvSocks4Reply( PSOCKS4REPLY pSr )
{
char buffer[256]    = {0};
int  iReadFromQueue = 0; iReadFromQueue = winSocket::Receive( winSocket::m_hSocket, buffer, 256 ) ; if( iReadFromQueue == 0 || iReadFromQueue == SOCKET_ERROR )
return RECVERR_WSAERROR; memset( pSr, 0, sizeof(SOCKS4REPLY) );
memcpy( &pSr->vn, &buffer[0], 1 );     // Should be zero
memcpy( &pSr->cd, &buffer[1], 1 );    // Reply code
memcpy( pSr->dstPort, &buffer[2], 2 ); // Port number (if any)
memcpy( pSr->dstAddr, &buffer[4], 4 ); // IP address (if any) switch( pSr->cd )
{
case SOCKS4REPLY_SUCCESS: memcpy( pSr->msg, "Operation successful.", 20 ); break;
case SOCKS4REPLY_REQUESTFAILED: memcpy( pSr->msg, "Request failed.", 15 ); break;
case SOCKS4REPLY_NOIDENTD: memcpy( pSr->msg, "No identd found.", 16 ); break;
case SOCKS4REPLY_DIFFIDENTD: memcpy( pSr->msg, "Identd does not match.", 22 ); break;
default: memcpy( pSr->msg, "Unrecognized response.", 22 ); break;
} return RECV_SUCCESS;
}int winSocketEx::RecvSocks5Reply( PSOCKS5REPLY pSr )
{
char buffer[256] = {0};
int  iReadFromQueue = 0; iReadFromQueue = winSocket::Receive( winSocket::m_hSocket, buffer, 256 ) ; if( iReadFromQueue == 0 || iReadFromQueue == SOCKET_ERROR )
return RECVERR_WSAERROR; memcpy( &pSr->vn, &buffer[0], 1 );
memcpy( &pSr->rep, &buffer[1], 1 );
memcpy( &pSr->tAddr, &buffer[3], 1 );
memcpy( pSr->bndAddr, &buffer[4], 4 );
memcpy( pSr->bndPort, &buffer[8], 2 ); switch( pSr->rep )
{
case SOCKS5REPLY_SUCCESS: memcpy( pSr->msg, "Action succeeded.", 17 ); break;
case SOCKS5REPLY_GENERALFAILURE: memcpy( pSr->msg, "A general failure occurred.", 27 ); break;
case SOCKS5REPLY_CONNNOTALLOWED: memcpy( pSr->msg, "Connection not allowed.", 23 ); break;
case SOCKS5REPLY_NETWORKUNREACHABLE: memcpy( pSr->msg, "Network is unreachable.", 23 ); break;
case SOCKS5REPLY_HOSTUNREACHABLE: memcpy( pSr->msg, "Host is unreachable.", 20 ); break;
case SOCKS5REPLY_CONNREFUSED: memcpy( pSr->msg, "Connection is refused.", 22 ); break;
case SOCKS5REPLY_TTLEXPIRED: memcpy( pSr->msg, "TTL has expired.", 16 ); break;
case SOCKS5REPLY_COMMANDNOTSUPPORTED: memcpy( pSr->msg, "Command not supported.", 22 ); break;
case SOCKS5REPLY_ADDRTYPENOTSUPPORTED: memcpy( pSr->msg, "Address type not supported.", 27 ); break;
default: memcpy( pSr->msg, "Unrecognized response.", 22 ); break;
}
return RECV_SUCCESS;
}