src/ptclib/socks.cxx

   1 /*
   2  * socks.cxx
   3  *
   4  * SOCKS protocol
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 1993-2002 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23  *
  24  * $Log$
  25  * Revision 1.8  2003/09/08 01:42:48  dereksmithies
  26  * Add patch from Diego Tartara <dtartara@mens2.hq.novamens.com>. Many Thanks!
  27  *
  28  * Revision 1.7  2002/11/06 22:47:25  robertj
  29  * Fixed header comment (copyright etc)
  30  *
  31  * Revision 1.6  2002/08/05 05:40:45  robertj
  32  * Fixed missing pragma interface/implementation
  33  *
  34  * Revision 1.5  2001/09/10 02:51:23  robertj
  35  * Major change to fix problem with error codes being corrupted in a
  36  *   PChannel when have simultaneous reads and writes in threads.
  37  *
  38  * Revision 1.4  1999/11/23 08:45:10  robertj
  39  * Fixed bug in user/pass authentication version, thanks Dmitry <dipa@linkline.com>
  40  *
  41  * Revision 1.3  1999/02/16 08:08:06  robertj
  42  * MSVC 6.0 compatibility changes.
  43  *
  44  * Revision 1.2  1998/12/23 00:35:28  robertj
  45  * UDP support.
  46  *
  47  * Revision 1.1  1998/12/22 10:30:24  robertj
  48  * Initial revision
  49  *
  50  */
  51
  52 #include <ptlib.h>
  53
  54 #ifdef __GNUC__
  55 #pragma implementation "socks.h"
  56 #endif
  57
  58 #include <ptclib/socks.h>
  59
  60 #define new PNEW
  61
  62 #define SOCKS_VERSION_4 ((BYTE)4)
  63 #define SOCKS_VERSION_5 ((BYTE)5)
  64
  65 #define SOCKS_CMD_CONNECT       ((BYTE)1)
  66 #define SOCKS_CMD_BIND          ((BYTE)2)
  67 #define SOCKS_CMD_UDP_ASSOCIATE ((BYTE)3)
  68
  69 #define SOCKS_AUTH_NONE      ((BYTE)0)
  70 #define SOCKS_AUTH_USER_PASS ((BYTE)2)
  71 #define SOCKS_AUTH_FAILED    ((BYTE)0xff)
  72
  73 #define SOCKS_ADDR_IPV4       ((BYTE)1)
  74 #define SOCKS_ADDR_DOMAINNAME ((BYTE)3)
  75 #define SOCKS_ADDR_IPV6       ((BYTE)4)
  76
  77
  78 ///////////////////////////////////////////////////////////////////////////////
  79
  80 PSocksProtocol::PSocksProtocol(WORD port)
  81   : serverHost("proxy")
  82 {
  83   serverPort = DefaultServerPort;
  84   remotePort = port;
  85   localPort = 0;
  86
  87   // get proxy information
  88   PConfig config(PConfig::System, "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\");
  89
  90   // get the proxy configuration string
  91   PString str = config.GetString("Internet Settings", "ProxyServer", "");
  92   if (str.Find('=') == P_MAX_INDEX)
  93     SetServer("socks");
  94   else {
  95     PStringArray tokens = str.Tokenise(";");
  96     PINDEX i;
  97     for (i = 0; i < tokens.GetSize(); i++) {
  98       str = tokens[i];
  99       PINDEX equalPos = str.Find('=');
 100       if (equalPos != P_MAX_INDEX && (str.Left(equalPos) *= "socks")) {
 101         SetServer(str.Mid(equalPos+1));
 102         break;
 103       }
 104     }
 105   }
 106 }
 107
 108
 109 BOOL PSocksProtocol::SetServer(const PString & hostname, const char * service)
 110 {
 111   return SetServer(hostname, PIPSocket::GetPortByService("tcp", service));
 112 }
 113
 114
 115 BOOL PSocksProtocol::SetServer(const PString & hostname, WORD port)
 116 {
 117   PINDEX colon = hostname.Find(':');
 118   if (colon == P_MAX_INDEX)
 119     serverHost = hostname;
 120   else {
 121     unsigned portnum = hostname.Mid(colon+1).AsUnsigned();
 122     if (portnum == 0)
 123       serverHost = hostname;
 124     else {
 125       serverHost = hostname.Left(colon);
 126       port = (WORD)portnum;
 127     }
 128   }
 129
 130   if (port == 0)
 131     port = DefaultServerPort;
 132
 133   serverPort = port;
 134
 135   return TRUE;
 136 }
 137
 138
 139 void PSocksProtocol::SetAuthentication(const PString & username, const PString & password)
 140 {
 141   PAssert(authenticationUsername.GetLength() < 256, PInvalidParameter);
 142   authenticationUsername = username;
 143   PAssert(authenticationPassword.GetLength() < 256, PInvalidParameter);
 144   authenticationPassword = password;
 145 }
 146
 147
 148 BOOL PSocksProtocol::ConnectSocksServer(PTCPSocket & socket)
 149 {
 150   PIPSocket::Address ipnum;
 151   if (!PIPSocket::GetHostAddress(serverHost, ipnum))
 152     return FALSE;
 153
 154   remotePort = socket.GetPort();
 155   socket.SetPort(serverPort);
 156   return socket.PTCPSocket::Connect(0, ipnum);
 157 }
 158
 159
 160 BOOL PSocksProtocol::SendSocksCommand(PTCPSocket & socket,
 161                                       BYTE command,
 162                                       const char * hostname,
 163                                       PIPSocket::Address addr)
 164 {
 165   if (!socket.IsOpen()) {
 166     if (!ConnectSocksServer(socket))
 167       return FALSE;
 168
 169     socket << SOCKS_VERSION_5
 170            << (authenticationUsername.IsEmpty() ? '\001' : '\002') // length
 171            << SOCKS_AUTH_NONE;
 172     if (!authenticationUsername)
 173       socket << SOCKS_AUTH_USER_PASS;  // Simple cleartext username/password
 174     socket.flush();
 175
 176     BYTE auth_pdu[2];
 177     if (!socket.ReadBlock(auth_pdu, sizeof(auth_pdu)))  // Should get 2 byte reply
 178       return FALSE;
 179
 180     if (auth_pdu[0] != SOCKS_VERSION_5 || auth_pdu[1] == SOCKS_AUTH_FAILED) {
 181       socket.Close();
 182       SetErrorCodes(PChannel::AccessDenied, EACCES);
 183       return FALSE;
 184     }
 185
 186     if (auth_pdu[1] == SOCKS_AUTH_USER_PASS) {
 187       // Send username and pasword
 188       socket << '\x01'
 189              << (BYTE)authenticationUsername.GetLength()  // Username length as single byte
 190              << authenticationUsername
 191              << (BYTE)authenticationPassword.GetLength()  // Password length as single byte
 192              << authenticationPassword
 193              << ::flush;
 194
 195       if (!socket.ReadBlock(auth_pdu, sizeof(auth_pdu)))  // Should get 2 byte reply
 196         return FALSE;
 197
 198       if (/*auth_pdu[0] != SOCKS_VERSION_5 ||*/ auth_pdu[1] != 0) {
 199         socket.Close();
 200         SetErrorCodes(PChannel::AccessDenied, EACCES);
 201         return FALSE;
 202       }
 203     }
 204   }
 205
 206   socket << SOCKS_VERSION_5
 207          << command
 208          << '\000'; // Reserved
 209   if (hostname != NULL)
 210     socket << SOCKS_ADDR_DOMAINNAME << (BYTE)strlen(hostname) << hostname;
 211 #if P_HAS_IPV6
 212   else if ( addr.GetVersion() == 6 )
 213   {
 214     socket << SOCKS_ADDR_IPV6;
 215     /* Should be 16 bytes */
 216     for ( PINDEX i = 0; i < addr.GetSize(); i++ )
 217     {
 218         socket << addr[i];
 219     }
 220   }
 221 #endif
 222   else
 223     socket << SOCKS_ADDR_IPV4
 224            << addr.Byte1() << addr.Byte2() << addr.Byte3() << addr.Byte4();
 225
 226   socket << (BYTE)(remotePort >> 8) << (BYTE)remotePort
 227          << ::flush;
 228
 229   return ReceiveSocksResponse(socket, localAddress, localPort);
 230 }
 231
 232
 233 BOOL PSocksProtocol::ReceiveSocksResponse(PTCPSocket & socket,
 234                                           PIPSocket::Address & addr,
 235                                           WORD & port)
 236 {
 237   int reply;
 238   if ((reply = socket.ReadChar()) < 0)
 239     return FALSE;
 240
 241   if (reply != SOCKS_VERSION_5) {
 242     SetErrorCodes(PChannel::Miscellaneous, EINVAL);
 243     return FALSE;
 244   }
 245
 246   if ((reply = socket.ReadChar()) < 0)
 247     return FALSE;
 248
 249   switch (reply) {
 250     case 0 :  // No error
 251       break;
 252
 253     case 2 :  // Refused permission
 254       SetErrorCodes(PChannel::AccessDenied, EACCES);
 255       return FALSE;
 256
 257     case 3 : // Network unreachable
 258       SetErrorCodes(PChannel::NotFound, ENETUNREACH);
 259       return FALSE;
 260
 261     case 4 : // Host unreachable
 262       SetErrorCodes(PChannel::NotFound, EHOSTUNREACH);
 263       return FALSE;
 264
 265     case 5 : // Connection refused
 266       SetErrorCodes(PChannel::NotFound, EHOSTUNREACH);
 267       return FALSE;
 268
 269     default :
 270       SetErrorCodes(PChannel::Miscellaneous, EINVAL);
 271       return FALSE;
 272   }
 273
 274   // Ignore next byte (reserved)
 275   if ((reply = socket.ReadChar()) < 0)
 276     return FALSE;
 277
 278   // Get type byte for bound address
 279   if ((reply = socket.ReadChar()) < 0)
 280     return FALSE;
 281
 282   switch (reply) {
 283     case SOCKS_ADDR_DOMAINNAME :
 284       // Get length
 285       if ((reply = socket.ReadChar()) < 0)
 286         return FALSE;
 287
 288       if (!PIPSocket::GetHostAddress(socket.ReadString(reply), addr))
 289         return FALSE;
 290       break;
 291
 292     case SOCKS_ADDR_IPV4 :
 293       {
 294           in_addr add;
 295           if (!socket.ReadBlock(&add, sizeof(add)))
 296               return FALSE;
 297           addr = add;
 298       }
 299       break;
 300
 301 #if P_HAS_IPV6
 302     case SOCKS_ADDR_IPV6 :
 303       {
 304         in6_addr add;
 305         if (!socket.ReadBlock(&add, sizeof(add)))
 306             return FALSE;
 307         addr = add;
 308       }
 309       break;
 310 #endif
 311
 312     default :
 313       SetErrorCodes(PChannel::Miscellaneous, EINVAL);
 314       return FALSE;
 315   }
 316
 317   WORD rxPort;
 318   if (!socket.ReadBlock(&rxPort, sizeof(rxPort)))
 319     return FALSE;
 320
 321   port = PSocket::Net2Host(rxPort);
 322   return TRUE;
 323 }
 324
 325
 326 ///////////////////////////////////////////////////////////////////////////////
 327
 328 PSocksSocket::PSocksSocket(WORD port)
 329   : PSocksProtocol(port)
 330 {
 331 }
 332
 333
 334 BOOL PSocksSocket::Connect(const PString & address)
 335 {
 336   if (!SendSocksCommand(*this, SOCKS_CMD_CONNECT, address, 0))
 337     return FALSE;
 338
 339   port = remotePort;
 340   return TRUE;
 341 }
 342
 343
 344 BOOL PSocksSocket::Connect(const Address & addr)
 345 {
 346   if (!SendSocksCommand(*this, SOCKS_CMD_CONNECT, NULL, addr))
 347     return FALSE;
 348
 349   port = remotePort;
 350   return TRUE;
 351 }
 352
 353
 354 BOOL PSocksSocket::Connect(WORD, const Address &)
 355 {
 356   PAssertAlways(PUnsupportedFeature);
 357   return FALSE;
 358 }
 359
 360
 361 BOOL PSocksSocket::Listen(unsigned, WORD newPort, Reusability reuse)
 362 {
 363   PAssert(newPort == 0 && port == 0, PUnsupportedFeature);
 364   PAssert(reuse, PUnsupportedFeature);
 365
 366   if (!SendSocksCommand(*this, SOCKS_CMD_BIND, NULL, 0))
 367     return FALSE;
 368
 369   port = localPort;
 370   return TRUE;
 371 }
 372
 373
 374 BOOL PSocksSocket::Accept()
 375 {
 376   if (!IsOpen())
 377     return FALSE;
 378
 379   return ReceiveSocksResponse(*this, remoteAddress, remotePort);
 380 }
 381
 382
 383 BOOL PSocksSocket::Accept(PSocket & socket)
 384 {
 385   // If is right class, transfer the SOCKS socket to class to receive the accept
 386   // The "listener" socket is implicitly closed as there is really only one
 387   // handle in a SOCKS BIND operation.
 388   PAssert(socket.IsDescendant(PSocksSocket::Class()), PUnsupportedFeature);
 389   os_handle = ((PSocksSocket &)socket).TransferHandle(*this);
 390   return Accept();
 391 }
 392
 393
 394 int PSocksSocket::TransferHandle(PSocksSocket & destination)
 395 {
 396   // This "transfers" the socket from one onstance to another.
 397
 398   int the_handle = os_handle;
 399   destination.SetReadTimeout(readTimeout);
 400   destination.SetWriteTimeout(writeTimeout);
 401
 402   // Close the instance of the socket but don't actually close handle.
 403   os_handle = -1;
 404
 405   return the_handle;
 406 }
 407
 408
 409 BOOL PSocksSocket::GetLocalAddress(Address & addr)
 410 {
 411   if (!IsOpen())
 412     return FALSE;
 413
 414   addr = localAddress;
 415   return TRUE;
 416 }
 417
 418
 419 BOOL PSocksSocket::GetLocalAddress(Address & addr, WORD & port)
 420 {
 421   if (!IsOpen())
 422     return FALSE;
 423
 424   addr = localAddress;
 425   port = localPort;
 426   return TRUE;
 427 }
 428
 429
 430 BOOL PSocksSocket::GetPeerAddress(Address & addr)
 431 {
 432   if (!IsOpen())
 433     return FALSE;
 434
 435   addr = remoteAddress;
 436   return TRUE;
 437 }
 438
 439
 440 BOOL PSocksSocket::GetPeerAddress(Address & addr, WORD & port)
 441 {
 442   if (!IsOpen())
 443     return FALSE;
 444
 445   addr = remoteAddress;
 446   port = remotePort;
 447   return TRUE;
 448 }
 449
 450
 451 void PSocksSocket::SetErrorCodes(PChannel::Errors errCode, int osErr)
 452 {
 453   SetErrorValues(errCode, osErr);
 454 }
 455
 456
 457 ///////////////////////////////////////////////////////////////////////////////
 458
 459 PSocks4Socket::PSocks4Socket(WORD port)
 460   : PSocksSocket(port)
 461 {
 462 }
 463
 464
 465 PSocks4Socket::PSocks4Socket(const PString & host, WORD port)
 466   : PSocksSocket(port)
 467 {
 468   Connect(host);
 469 }
 470
 471
 472 PObject * PSocks4Socket::Clone() const
 473 {
 474   return new PSocks4Socket(remotePort);
 475 }
 476
 477
 478 BOOL PSocks4Socket::SendSocksCommand(PTCPSocket & socket,
 479                                      BYTE command,
 480                                      const char * hostname,
 481                                      Address addr)
 482 {
 483   if (hostname != NULL) {
 484     if (!GetHostAddress(hostname, addr))
 485       return FALSE;
 486   }
 487
 488   if (!IsOpen()) {
 489     if (!ConnectSocksServer(*this))
 490       return FALSE;
 491   }
 492
 493   PString user = PProcess::Current().GetUserName();
 494   socket << SOCKS_VERSION_4
 495          << command
 496          << (BYTE)(remotePort >> 8) << (BYTE)remotePort
 497          << addr.Byte1() << addr.Byte2() << addr.Byte3() << addr.Byte4()
 498          << user << ((BYTE)0)
 499          << ::flush;
 500
 501   return ReceiveSocksResponse(socket, localAddress, localPort);
 502 }
 503
 504
 505 BOOL PSocks4Socket::ReceiveSocksResponse(PTCPSocket & socket,
 506                                          Address & addr,
 507                                          WORD & port)
 508 {
 509   int reply;
 510   if ((reply = socket.ReadChar()) < 0)
 511     return FALSE;
 512
 513   if (reply != 0 /*!= SOCKS_VERSION_4*/) {
 514     SetErrorCodes(PChannel::Miscellaneous, EINVAL);
 515     return FALSE;
 516   }
 517
 518   if ((reply = socket.ReadChar()) < 0)
 519     return FALSE;
 520
 521   switch (reply) {
 522     case 90 :  // No error
 523       break;
 524
 525     case 91 : // Connection refused
 526       SetErrorCodes(PChannel::NotFound, EHOSTUNREACH);
 527       return FALSE;
 528
 529     case 92 :  // Refused permission
 530       SetErrorCodes(PChannel::AccessDenied, EACCES);
 531       return FALSE;
 532
 533     default :
 534       SetErrorCodes(PChannel::Miscellaneous, EINVAL);
 535       return FALSE;
 536   }
 537
 538   WORD rxPort;
 539   if (!socket.ReadBlock(&rxPort, sizeof(rxPort)))
 540     return FALSE;
 541
 542   port = PSocket::Net2Host(rxPort);
 543
 544   in_addr add;
 545   if ( socket.ReadBlock(&add, sizeof(add)) )
 546   {
 547     addr = add;
 548     return TRUE;
 549   }
 550
 551   return FALSE;
 552 }
 553
 554
 555 ///////////////////////////////////////////////////////////////////////////////
 556
 557 PSocks5Socket::PSocks5Socket(WORD port)
 558   : PSocksSocket(port)
 559 {
 560 }
 561
 562
 563 PSocks5Socket::PSocks5Socket(const PString & host, WORD port)
 564   : PSocksSocket(port)
 565 {
 566   Connect(host);
 567 }
 568
 569
 570 PObject * PSocks5Socket::Clone() const
 571 {
 572   return new PSocks5Socket(remotePort);
 573 }
 574
 575
 576 ///////////////////////////////////////////////////////////////////////////////
 577
 578 PSocksUDPSocket::PSocksUDPSocket(WORD port)
 579   : PSocksProtocol(port)
 580 {
 581 }
 582
 583
 584 PSocksUDPSocket::PSocksUDPSocket(const PString & host, WORD port)
 585   : PSocksProtocol(port)
 586 {
 587   Connect(host);
 588 }
 589
 590
 591 PObject * PSocksUDPSocket::Clone() const
 592 {
 593   return new PSocksUDPSocket(port);
 594 }
 595
 596
 597 BOOL PSocksUDPSocket::Connect(const PString & address)
 598 {
 599   if (!SendSocksCommand(socksControl, SOCKS_CMD_UDP_ASSOCIATE, address, 0))
 600     return FALSE;
 601
 602   socksControl.GetPeerAddress(serverAddress);
 603   return TRUE;
 604 }
 605
 606
 607 BOOL PSocksUDPSocket::Connect(const Address & addr)
 608 {
 609   if (!SendSocksCommand(socksControl, SOCKS_CMD_UDP_ASSOCIATE, NULL, addr))
 610     return FALSE;
 611
 612   socksControl.GetPeerAddress(serverAddress);
 613   return TRUE;
 614 }
 615
 616
 617 BOOL PSocksUDPSocket::Connect(WORD, const Address &)
 618 {
 619   PAssertAlways(PUnsupportedFeature);
 620   return FALSE;
 621 }
 622
 623
 624 BOOL PSocksUDPSocket::Listen(unsigned, WORD newPort, Reusability reuse)
 625 {
 626   PAssert(newPort == 0 && port == 0, PUnsupportedFeature);
 627   PAssert(reuse, PUnsupportedFeature);
 628
 629   if (!SendSocksCommand(socksControl, SOCKS_CMD_UDP_ASSOCIATE, NULL, 0))
 630     return FALSE;
 631
 632   socksControl.GetPeerAddress(serverAddress);
 633   port = localPort;
 634   return TRUE;
 635 }
 636
 637
 638 BOOL PSocksUDPSocket::GetLocalAddress(Address & addr)
 639 {
 640   if (!IsOpen())
 641     return FALSE;
 642
 643   addr = localAddress;
 644   return TRUE;
 645 }
 646
 647
 648 BOOL PSocksUDPSocket::GetLocalAddress(Address & addr, WORD & port)
 649 {
 650   if (!IsOpen())
 651     return FALSE;
 652
 653   addr = localAddress;
 654   port = localPort;
 655   return TRUE;
 656 }
 657
 658
 659 BOOL PSocksUDPSocket::GetPeerAddress(Address & addr)
 660 {
 661   if (!IsOpen())
 662     return FALSE;
 663
 664   addr = remoteAddress;
 665   return TRUE;
 666 }
 667
 668
 669 BOOL PSocksUDPSocket::GetPeerAddress(Address & addr, WORD & port)
 670 {
 671   if (!IsOpen())
 672     return FALSE;
 673
 674   addr = remoteAddress;
 675   port = remotePort;
 676   return TRUE;
 677 }
 678
 679
 680 BOOL PSocksUDPSocket::ReadFrom(void * buf, PINDEX len, Address & addr, WORD & port)
 681 {
 682   PBYTEArray newbuf(len+262);
 683   Address rx_addr;
 684   WORD rx_port;
 685   if (!PUDPSocket::ReadFrom(newbuf.GetPointer(), newbuf.GetSize(), rx_addr, rx_port))
 686     return FALSE;
 687
 688   if (rx_addr != serverAddress || rx_port != serverPort)
 689     return FALSE;
 690
 691   PINDEX port_pos;
 692   switch (newbuf[3]) {
 693     case SOCKS_ADDR_DOMAINNAME :
 694       if (!PIPSocket::GetHostAddress(PString((const char *)&newbuf[5], (PINDEX)newbuf[4]), addr))
 695         return FALSE;
 696
 697       port_pos = newbuf[4]+5;
 698       break;
 699
 700     case SOCKS_ADDR_IPV4 :
 701       memcpy(&addr, &newbuf[4], 4);
 702       port_pos = 4;
 703       break;
 704
 705     default :
 706       SetErrorCodes(PChannel::Miscellaneous, EINVAL);
 707       return FALSE;
 708   }
 709
 710   port = (WORD)((newbuf[port_pos] << 8)|newbuf[port_pos+1]);
 711   memcpy(buf, &newbuf[port_pos+2], len);
 712
 713   return TRUE;
 714 }
 715
 716
 717 BOOL PSocksUDPSocket::WriteTo(const void * buf, PINDEX len, const Address & addr, WORD port)
 718 {
 719   PBYTEArray newbuf(len+10);
 720   BYTE * bufptr = newbuf.GetPointer();
 721
 722   // Build header, bytes 0, 1 & 2 are zero
 723
 724   bufptr[3] = SOCKS_ADDR_IPV4;
 725   memcpy(bufptr+4, &addr, 4);
 726   bufptr[8] = (BYTE)(port >> 8);
 727   bufptr[9] = (BYTE)port;
 728   memcpy(bufptr+10, buf, len);
 729
 730   return PUDPSocket::WriteTo(newbuf, newbuf.GetSize(), serverAddress, serverPort);
 731 }
 732
 733
 734 void PSocksUDPSocket::SetErrorCodes(PChannel::Errors errCode, int osErr)
 735 {
 736   SetErrorValues(errCode, osErr);
 737 }
 738
 739
 740 // End of File ///////////////////////////////////////////////////////////////