开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
socks.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：15k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

socks.cxx：源码内容
  1. /*
  2.  * main.cxx
  3.  *
  4.  * PWLib application source file for GetCyberPatrol
  5.  *
  6.  * Main program entry point.
  7.  *
  8.  * Copyright 98 Equivalence
  9.  *
  10.  * $Log: socks.cxx,v $
  11.  * Revision 1.4  1999/11/23 08:45:10  robertj
  12.  * Fixed bug in user/pass authentication version, thanks Dmitry <dipa@linkline.com>
  13.  *
  14.  * Revision 1.3  1999/02/16 08:08:06  robertj
  15.  * MSVC 6.0 compatibility changes.
  16.  *
  17.  * Revision 1.2  1998/12/23 00:35:28  robertj
  18.  * UDP support.
  19.  *
  20.  * Revision 1.1  1998/12/22 10:30:24  robertj
  21.  * Initial revision
  22.  *
  23.  */
  25. #include <ptlib.h>
  26. #include <ptclib/socks.h>
  28. #define new PNEW
  30. #define SOCKS_VERSION_4 ((BYTE)4)
  31. #define SOCKS_VERSION_5 ((BYTE)5)
  33. #define SOCKS_CMD_CONNECT       ((BYTE)1)
  34. #define SOCKS_CMD_BIND          ((BYTE)2)
  35. #define SOCKS_CMD_UDP_ASSOCIATE ((BYTE)3)
  37. #define SOCKS_AUTH_NONE      ((BYTE)0)
  38. #define SOCKS_AUTH_USER_PASS ((BYTE)2)
  39. #define SOCKS_AUTH_FAILED    ((BYTE)0xff)
  41. #define SOCKS_ADDR_IPV4       ((BYTE)1)
  42. #define SOCKS_ADDR_DOMAINNAME ((BYTE)3)
  43. #define SOCKS_ADDR_IPV6       ((BYTE)4)
  46. ///////////////////////////////////////////////////////////////////////////////
  48. PSocksProtocol::PSocksProtocol(WORD port)
  49.   : serverHost("proxy")
  50. {
  51.   serverPort = DefaultServerPort;
  52.   remotePort = port;
  53.   localPort = 0;
  55.   // get proxy information
  56.   PConfig config(PConfig::System, "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\");
  58.   // get the proxy configuration string
  59.   PString str = config.GetString("Internet Settings", "ProxyServer", "");
  60.   if (str.Find('=') == P_MAX_INDEX)
  61.     SetServer("socks");
  62.   else {
  63.     PStringArray tokens = str.Tokenise(";");
  64.     PINDEX i;
  65.     for (i = 0; i < tokens.GetSize(); i++) {
  66.       str = tokens[i];
  67.       PINDEX equalPos = str.Find('=');
  68.       if (equalPos != P_MAX_INDEX && (str.Left(equalPos) *= "socks")) {
  69.         SetServer(str.Mid(equalPos+1));
  70.         break;
  71.       }
  72.     }
  73.   }
  74. }
  77. BOOL PSocksProtocol::SetServer(const PString & hostname, const char * service)
  78. {
  79.   return SetServer(hostname, PIPSocket::GetPortByService("tcp", service));
  80. }
  83. BOOL PSocksProtocol::SetServer(const PString & hostname, WORD port)
  84. {
  85.   PINDEX colon = hostname.Find(':');
  86.   if (colon == P_MAX_INDEX)
  87.     serverHost = hostname;
  88.   else {
  89.     unsigned portnum = hostname.Mid(colon+1).AsUnsigned();
  90.     if (portnum == 0)
  91.       serverHost = hostname;
  92.     else {
  93.       serverHost = hostname.Left(colon);
  94.       port = (WORD)portnum;
  95.     }
  96.   }
  98.   if (port == 0)
  99.     port = DefaultServerPort;
  101.   serverPort = port;
  103.   return TRUE;
  104. }
  107. void PSocksProtocol::SetAuthentication(const PString & username, const PString & password)
  108. {
  109.   PAssert(authenticationUsername.GetLength() < 256, PInvalidParameter);
  110.   authenticationUsername = username;
  111.   PAssert(authenticationPassword.GetLength() < 256, PInvalidParameter);
  112.   authenticationPassword = password;
  113. }
  116. BOOL PSocksProtocol::ConnectSocksServer(PTCPSocket & socket)
  117. {
  118.   PIPSocket::Address ipnum;
  119.   if (!PIPSocket::GetHostAddress(serverHost, ipnum))
  120.     return FALSE;
  122.   remotePort = socket.GetPort();
  123.   socket.SetPort(serverPort);
  124.   return socket.PTCPSocket::Connect(0, ipnum);
  125. }
  128. BOOL PSocksProtocol::SendSocksCommand(PTCPSocket & socket,
  129.                                       BYTE command,
  130.                                       const char * hostname,
  131.                                       PIPSocket::Address addr)
  132. {
  133.   if (!socket.IsOpen()) {
  134.     if (!ConnectSocksServer(socket))
  135.       return FALSE;
  137.     socket << SOCKS_VERSION_5
  138.            << (authenticationUsername.IsEmpty() ? '01' : '02') // length
  139.            << SOCKS_AUTH_NONE;
  140.     if (!authenticationUsername)
  141.       socket << SOCKS_AUTH_USER_PASS;  // Simple cleartext username/password
  142.     socket.flush();
  144.     BYTE auth_pdu[2];
  145.     if (!socket.ReadBlock(auth_pdu, sizeof(auth_pdu)))  // Should get 2 byte reply
  146.       return FALSE;
  148.     if (auth_pdu[0] != SOCKS_VERSION_5 || auth_pdu[1] == SOCKS_AUTH_FAILED) {
  149.       socket.Close();
  150.       SetErrorCodes(PChannel::AccessDenied, EACCES);
  151.       return FALSE;
  152.     }
  154.     if (auth_pdu[1] == SOCKS_AUTH_USER_PASS) {
  155.       // Send username and pasword
  156.       socket << 'x01'
  157.              << (BYTE)authenticationUsername.GetLength()  // Username length as single byte
  158.              << authenticationUsername
  159.              << (BYTE)authenticationPassword.GetLength()  // Password length as single byte
  160.              << authenticationPassword
  161.              << ::flush;
  163.       if (!socket.ReadBlock(auth_pdu, sizeof(auth_pdu)))  // Should get 2 byte reply
  164.         return FALSE;
  166.       if (auth_pdu[0] != SOCKS_VERSION_5 || auth_pdu[1] != 0) {
  167.         socket.Close();
  168.         SetErrorCodes(PChannel::AccessDenied, EACCES);
  169.         return FALSE;
  170.       }
  171.     }
  172.   }
  174.   socket << SOCKS_VERSION_5
  175.          << command
  176.          << '00'; // Reserved
  177.   if (hostname != NULL)
  178.     socket << SOCKS_ADDR_DOMAINNAME << (BYTE)strlen(hostname) << hostname;
  179.   else
  180.     socket << SOCKS_ADDR_IPV4
  181.            << addr.Byte1() << addr.Byte2() << addr.Byte3() << addr.Byte4();
  182.   socket << (BYTE)(remotePort >> 8) << (BYTE)remotePort
  183.          << ::flush;
  185.   return ReceiveSocksResponse(socket, localAddress, localPort);
  186. }
  189. BOOL PSocksProtocol::ReceiveSocksResponse(PTCPSocket & socket,
  190.                                           PIPSocket::Address & addr,
  191.                                           WORD & port)
  192. {
  193.   int reply;
  194.   if ((reply = socket.ReadChar()) < 0)
  195.     return FALSE;
  197.   if (reply != SOCKS_VERSION_5) {
  198.     SetErrorCodes(PChannel::Miscellaneous, EINVAL);
  199.     return FALSE;
  200.   }
  202.   if ((reply = socket.ReadChar()) < 0)
  203.     return FALSE;
  205.   switch (reply) {
  206.     case 0 :  // No error
  207.       break;
  209.     case 2 :  // Refused permission
  210.       SetErrorCodes(PChannel::AccessDenied, EACCES);
  211.       return FALSE;
  213.     case 3 : // Network unreachable
  214.       SetErrorCodes(PChannel::NotFound, ENETUNREACH);
  215.       return FALSE;
  217.     case 4 : // Host unreachable
  218.       SetErrorCodes(PChannel::NotFound, EHOSTUNREACH);
  219.       return FALSE;
  221.     case 5 : // Connection refused
  222.       SetErrorCodes(PChannel::NotFound, EHOSTUNREACH);
  223.       return FALSE;
  225.     default :
  226.       SetErrorCodes(PChannel::Miscellaneous, EINVAL);
  227.       return FALSE;
  228.   }
  230.   // Ignore next byte (reserved)
  231.   if ((reply = socket.ReadChar()) < 0)
  232.     return FALSE;
  234.   // Get type byte for bound address
  235.   if ((reply = socket.ReadChar()) < 0)
  236.     return FALSE;
  238.   switch (reply) {
  239.     case SOCKS_ADDR_DOMAINNAME :
  240.       // Get length
  241.       if ((reply = socket.ReadChar()) < 0)
  242.         return FALSE;
  244.       if (!PIPSocket::GetHostAddress(socket.ReadString(reply), addr))
  245.         return FALSE;
  246.       break;
  248.     case SOCKS_ADDR_IPV4 :
  249.       if (!socket.ReadBlock(&addr, sizeof(addr)))
  250.         return FALSE;
  251.       break;
  253.     default :
  254.       SetErrorCodes(PChannel::Miscellaneous, EINVAL);
  255.       return FALSE;
  256.   }
  258.   WORD rxPort;
  259.   if (!socket.ReadBlock(&rxPort, sizeof(rxPort)))
  260.     return FALSE;
  262.   port = PSocket::Net2Host(rxPort);
  263.   return TRUE;
  264. }
  267. ///////////////////////////////////////////////////////////////////////////////
  269. PSocksSocket::PSocksSocket(WORD port)
  270.   : PSocksProtocol(port)
  271. {
  272. }
  275. BOOL PSocksSocket::Connect(const PString & address)
  276. {
  277.   if (!SendSocksCommand(*this, SOCKS_CMD_CONNECT, address, 0))
  278.     return FALSE;
  280.   port = remotePort;
  281.   return TRUE;
  282. }
  285. BOOL PSocksSocket::Connect(const Address & addr)
  286. {
  287.   if (!SendSocksCommand(*this, SOCKS_CMD_CONNECT, NULL, addr))
  288.     return FALSE;
  290.   port = remotePort;
  291.   return TRUE;
  292. }
  295. BOOL PSocksSocket::Connect(WORD, const Address &)
  296. {
  297.   PAssertAlways(PUnsupportedFeature);
  298.   return FALSE;
  299. }
  302. BOOL PSocksSocket::Listen(unsigned, WORD newPort, Reusability reuse)
  303. {
  304.   PAssert(newPort == 0 && port == 0, PUnsupportedFeature);
  305.   PAssert(reuse, PUnsupportedFeature);
  307.   if (!SendSocksCommand(*this, SOCKS_CMD_BIND, NULL, 0))
  308.     return FALSE;
  310.   port = localPort;
  311.   return TRUE;
  312. }
  315. BOOL PSocksSocket::Accept()
  316. {
  317.   if (!IsOpen())
  318.     return FALSE;
  320.   return ReceiveSocksResponse(*this, remoteAddress, remotePort);
  321. }
  324. BOOL PSocksSocket::Accept(PSocket & socket)
  325. {
  326.   // If is right class, transfer the SOCKS socket to class to receive the accept
  327.   // The "listener" socket is implicitly closed as there is really only one
  328.   // handle in a SOCKS BIND operation.
  329.   PAssert(socket.IsDescendant(PSocksSocket::Class()), PUnsupportedFeature);
  330.   os_handle = ((PSocksSocket &)socket).TransferHandle(*this);
  331.   return Accept();
  332. }
  335. int PSocksSocket::TransferHandle(PSocksSocket & destination)
  336. {
  337.   // This "transfers" the socket from one onstance to another.
  339.   int the_handle = os_handle;
  340.   destination.SetReadTimeout(readTimeout);
  341.   destination.SetWriteTimeout(writeTimeout);
  343.   // Close the instance of the socket but don't actually close handle.
  344.   os_handle = -1;
  346.   return the_handle;
  347. }
  350. BOOL PSocksSocket::GetLocalAddress(Address & addr)
  351. {
  352.   if (!IsOpen())
  353.     return FALSE;
  355.   addr = localAddress;
  356.   return TRUE;
  357. }
  360. BOOL PSocksSocket::GetLocalAddress(Address & addr, WORD & port)
  361. {
  362.   if (!IsOpen())
  363.     return FALSE;
  365.   addr = localAddress;
  366.   port = localPort;
  367.   return TRUE;
  368. }
  371. BOOL PSocksSocket::GetPeerAddress(Address & addr)
  372. {
  373.   if (!IsOpen())
  374.     return FALSE;
  376.   addr = remoteAddress;
  377.   return TRUE;
  378. }
  381. BOOL PSocksSocket::GetPeerAddress(Address & addr, WORD & port)
  382. {
  383.   if (!IsOpen())
  384.     return FALSE;
  386.   addr = remoteAddress;
  387.   port = remotePort;
  388.   return TRUE;
  389. }
  392. void PSocksSocket::SetErrorCodes(PChannel::Errors errCode, int osErr)
  393. {
  394.   lastError = errCode;
  395.   osError = osErr;
  396. }
  399. ///////////////////////////////////////////////////////////////////////////////
  401. PSocks4Socket::PSocks4Socket(WORD port)
  402.   : PSocksSocket(port)
  403. {
  404. }
  407. PSocks4Socket::PSocks4Socket(const PString & host, WORD port)
  408.   : PSocksSocket(port)
  409. {
  410.   Connect(host);
  411. }
  414. PObject * PSocks4Socket::Clone() const
  415. {
  416.   return new PSocks4Socket(remotePort);
  417. }
  420. BOOL PSocks4Socket::SendSocksCommand(PTCPSocket & socket,
  421.                                      BYTE command,
  422.                                      const char * hostname,
  423.                                      Address addr)
  424. {
  425.   if (hostname != NULL) {
  426.     if (!GetHostAddress(hostname, addr))
  427.       return FALSE;
  428.   }
  430.   if (!IsOpen()) {
  431.     if (!ConnectSocksServer(*this))
  432.       return FALSE;
  433.   }
  435.   PString user = PProcess::Current().GetUserName();
  436.   socket << SOCKS_VERSION_4
  437.          << command
  438.          << (BYTE)user.GetLength() << user
  439.          << (BYTE)(remotePort >> 8) << (BYTE)remotePort
  440.          << addr.Byte1() << addr.Byte2() << addr.Byte3() << addr.Byte4()
  441.          << ::flush;
  443.   return ReceiveSocksResponse(socket, localAddress, localPort);
  444. }
  447. BOOL PSocks4Socket::ReceiveSocksResponse(PTCPSocket & socket,
  448.                                          Address & addr,
  449.                                          WORD & port)
  450. {
  451.   int reply;
  452.   if ((reply = socket.ReadChar()) < 0)
  453.     return FALSE;
  455.   if (reply != SOCKS_VERSION_4) {
  456.     SetErrorCodes(PChannel::Miscellaneous, EINVAL);
  457.     return FALSE;
  458.   }
  460.   if ((reply = socket.ReadChar()) < 0)
  461.     return FALSE;
  463.   switch (reply) {
  464.     case 90 :  // No error
  465.       break;
  467.     case 91 : // Connection refused
  468.       SetErrorCodes(PChannel::NotFound, EHOSTUNREACH);
  469.       return FALSE;
  471.     case 92 :  // Refused permission
  472.       SetErrorCodes(PChannel::AccessDenied, EACCES);
  473.       return FALSE;
  475.     default :
  476.       SetErrorCodes(PChannel::Miscellaneous, EINVAL);
  477.       return FALSE;
  478.   }
  480.   WORD rxPort;
  481.   if (!socket.ReadBlock(&rxPort, sizeof(rxPort)))
  482.     return FALSE;
  484.   port = PSocket::Net2Host(rxPort);
  486.   return socket.ReadBlock(&addr, sizeof(addr));
  487. }
  490. ///////////////////////////////////////////////////////////////////////////////
  492. PSocks5Socket::PSocks5Socket(WORD port)
  493.   : PSocksSocket(port)
  494. {
  495. }
  498. PSocks5Socket::PSocks5Socket(const PString & host, WORD port)
  499.   : PSocksSocket(port)
  500. {
  501.   Connect(host);
  502. }
  505. PObject * PSocks5Socket::Clone() const
  506. {
  507.   return new PSocks5Socket(remotePort);
  508. }
  511. ///////////////////////////////////////////////////////////////////////////////
  513. PSocksUDPSocket::PSocksUDPSocket(WORD port)
  514.   : PSocksProtocol(port)
  515. {
  516. }
  519. PSocksUDPSocket::PSocksUDPSocket(const PString & host, WORD port)
  520.   : PSocksProtocol(port)
  521. {
  522.   Connect(host);
  523. }
  526. PObject * PSocksUDPSocket::Clone() const
  527. {
  528.   return new PSocksUDPSocket(port);
  529. }
  532. BOOL PSocksUDPSocket::Connect(const PString & address)
  533. {
  534.   if (!SendSocksCommand(socksControl, SOCKS_CMD_UDP_ASSOCIATE, address, 0))
  535.     return FALSE;
  537.   socksControl.GetPeerAddress(serverAddress);
  538.   return TRUE;
  539. }
  542. BOOL PSocksUDPSocket::Connect(const Address & addr)
  543. {
  544.   if (!SendSocksCommand(socksControl, SOCKS_CMD_UDP_ASSOCIATE, NULL, addr))
  545.     return FALSE;
  547.   socksControl.GetPeerAddress(serverAddress);
  548.   return TRUE;
  549. }
  552. BOOL PSocksUDPSocket::Connect(WORD, const Address &)
  553. {
  554.   PAssertAlways(PUnsupportedFeature);
  555.   return FALSE;
  556. }
  559. BOOL PSocksUDPSocket::Listen(unsigned, WORD newPort, Reusability reuse)
  560. {
  561.   PAssert(newPort == 0 && port == 0, PUnsupportedFeature);
  562.   PAssert(reuse, PUnsupportedFeature);
  564.   if (!SendSocksCommand(socksControl, SOCKS_CMD_UDP_ASSOCIATE, NULL, 0))
  565.     return FALSE;
  567.   socksControl.GetPeerAddress(serverAddress);
  568.   port = localPort;
  569.   return TRUE;
  570. }
  573. BOOL PSocksUDPSocket::GetLocalAddress(Address & addr)
  574. {
  575.   if (!IsOpen())
  576.     return FALSE;
  578.   addr = localAddress;
  579.   return TRUE;
  580. }
  583. BOOL PSocksUDPSocket::GetLocalAddress(Address & addr, WORD & port)
  584. {
  585.   if (!IsOpen())
  586.     return FALSE;
  588.   addr = localAddress;
  589.   port = localPort;
  590.   return TRUE;
  591. }
  594. BOOL PSocksUDPSocket::GetPeerAddress(Address & addr)
  595. {
  596.   if (!IsOpen())
  597.     return FALSE;
  599.   addr = remoteAddress;
  600.   return TRUE;
  601. }
  604. BOOL PSocksUDPSocket::GetPeerAddress(Address & addr, WORD & port)
  605. {
  606.   if (!IsOpen())
  607.     return FALSE;
  609.   addr = remoteAddress;
  610.   port = remotePort;
  611.   return TRUE;
  612. }
  615. BOOL PSocksUDPSocket::ReadFrom(void * buf, PINDEX len, Address & addr, WORD & port)
  616. {
  617.   PBYTEArray newbuf(len+262);
  618.   Address rx_addr;
  619.   WORD rx_port;
  620.   if (!PUDPSocket::ReadFrom(newbuf.GetPointer(), newbuf.GetSize(), rx_addr, rx_port))
  621.     return FALSE;
  623.   if (rx_addr != serverAddress || rx_port != serverPort)
  624.     return FALSE;
  626.   PINDEX port_pos;
  627.   switch (newbuf[3]) {
  628.     case SOCKS_ADDR_DOMAINNAME :
  629.       if (!PIPSocket::GetHostAddress(PString((const char *)&newbuf[5], (PINDEX)newbuf[4]), addr))
  630.         return FALSE;
  632.       port_pos = newbuf[4]+5;
  633.       break;
  635.     case SOCKS_ADDR_IPV4 :
  636.       memcpy(&addr, &newbuf[4], 4);
  637.       port_pos = 4;
  638.       break;
  640.     default :
  641.       SetErrorCodes(PChannel::Miscellaneous, EINVAL);
  642.       return FALSE;
  643.   }
  645.   port = (WORD)((newbuf[port_pos] << 8)|newbuf[port_pos+1]);
  646.   memcpy(buf, &newbuf[port_pos+2], len);
  648.   return TRUE;
  649. }
  652. BOOL PSocksUDPSocket::WriteTo(const void * buf, PINDEX len, const Address & addr, WORD port)
  653. {
  654.   PBYTEArray newbuf(len+10);
  655.   BYTE * bufptr = newbuf.GetPointer();
  657.   // Build header, bytes 0, 1 & 2 are zero
  659.   bufptr[3] = SOCKS_ADDR_IPV4;
  660.   memcpy(bufptr+4, &addr, 4);
  661.   bufptr[8] = (BYTE)(port >> 8);
  662.   bufptr[9] = (BYTE)port;
  663.   memcpy(bufptr+10, buf, len);
  665.   return PUDPSocket::WriteTo(newbuf, newbuf.GetSize(), serverAddress, serverPort);
  666. }
  669. void PSocksUDPSocket::SetErrorCodes(PChannel::Errors errCode, int osErr)
  670. {
  671.   lastError = errCode;
  672.   osError = osErr;
  673. }
  676. // End of File ///////////////////////////////////////////////////////////////