lib/socks.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at http://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 #include "setup.h"
  24
  25 #if !defined(CURL_DISABLE_PROXY)
  26
  27 #ifdef HAVE_SYS_SOCKET_H
  28 #include <sys/socket.h>
  29 #endif
  30 #ifdef HAVE_NETINET_IN_H
  31 #include <netinet/in.h>
  32 #endif
  33 #ifdef HAVE_ARPA_INET_H
  34 #include <arpa/inet.h>
  35 #endif
  36
  37 #include "urldata.h"
  38 #include "sendf.h"
  39 #include "strequal.h"
  40 #include "select.h"
  41 #include "connect.h"
  42 #include "timeval.h"
  43 #include "socks.h"
  44
  45 /* The last #include file should be: */
  46 #include "memdebug.h"
  47
  48 /*
  49  * Helper read-from-socket functions. Does the same as Curl_read() but it
  50  * blocks until all bytes amount of buffersize will be read. No more, no less.
  51  *
  52  * This is STUPID BLOCKING behaviour which we frown upon, but right now this
  53  * is what we have...
  54  */
  55 int Curl_blockread_all(struct connectdata *conn, /* connection data */
  56                        curl_socket_t sockfd,     /* read from this socket */
  57                        char *buf,                /* store read data here */
  58                        ssize_t buffersize,       /* max amount to read */
  59                        ssize_t *n)               /* amount bytes read */
  60 {
  61   ssize_t nread;
  62   ssize_t allread = 0;
  63   int result;
  64   long timeleft;
  65   *n = 0;
  66   for(;;) {
  67     timeleft = Curl_timeleft(conn->data, NULL, TRUE);
  68     if(timeleft < 0) {
  69       /* we already got the timeout */
  70       result = CURLE_OPERATION_TIMEDOUT;
  71       break;
  72     }
  73     if(Curl_socket_ready(sockfd, CURL_SOCKET_BAD, timeleft) <= 0) {
  74       result = ~CURLE_OK;
  75       break;
  76     }
  77     result = Curl_read_plain(sockfd, buf, buffersize, &nread);
  78     if(CURLE_AGAIN == result)
  79       continue;
  80     else if(result)
  81       break;
  82
  83     if(buffersize == nread) {
  84       allread += nread;
  85       *n = allread;
  86       result = CURLE_OK;
  87       break;
  88     }
  89     if(!nread) {
  90       result = ~CURLE_OK;
  91       break;
  92     }
  93
  94     buffersize -= nread;
  95     buf += nread;
  96     allread += nread;
  97   }
  98   return result;
  99 }
 100
 101 /*
 102 * This function logs in to a SOCKS4 proxy and sends the specifics to the final
 103 * destination server.
 104 *
 105 * Reference :
 106 *   http://socks.permeo.com/protocol/socks4.protocol
 107 *
 108 * Note :
 109 *   Set protocol4a=true for  "SOCKS 4A (Simple Extension to SOCKS 4 Protocol)"
 110 *   Nonsupport "Identification Protocol (RFC1413)"
 111 */
 112 CURLcode Curl_SOCKS4(const char *proxy_name,
 113                      const char *hostname,
 114                      int remote_port,
 115                      int sockindex,
 116                      struct connectdata *conn,
 117                      bool protocol4a)
 118 {
 119 #define SOCKS4REQLEN 262
 120   unsigned char socksreq[SOCKS4REQLEN]; /* room for SOCKS4 request incl. user
 121                                            id */
 122   int result;
 123   CURLcode code;
 124   curl_socket_t sock = conn->sock[sockindex];
 125   struct SessionHandle *data = conn->data;
 126
 127   if(Curl_timeleft(data, NULL, TRUE) < 0) {
 128     /* time-out, bail out, go home */
 129     failf(data, "Connection time-out");
 130     return CURLE_OPERATION_TIMEDOUT;
 131   }
 132
 133   curlx_nonblock(sock, FALSE);
 134
 135   /*
 136    * Compose socks4 request
 137    *
 138    * Request format
 139    *
 140    *     +----+----+----+----+----+----+----+----+----+----+....+----+
 141    *     | VN | CD | DSTPORT |      DSTIP        | USERID       |NULL|
 142    *     +----+----+----+----+----+----+----+----+----+----+....+----+
 143    * # of bytes:  1    1      2              4           variable       1
 144    */
 145
 146   socksreq[0] = 4; /* version (SOCKS4) */
 147   socksreq[1] = 1; /* connect */
 148   socksreq[2] = (unsigned char)((remote_port >> 8) & 0xff); /* PORT MSB */
 149   socksreq[3] = (unsigned char)(remote_port & 0xff);        /* PORT LSB */
 150
 151   /* DNS resolve only for SOCKS4, not SOCKS4a */
 152   if(!protocol4a) {
 153     struct Curl_dns_entry *dns;
 154     Curl_addrinfo *hp=NULL;
 155     int rc;
 156
 157     rc = Curl_resolv(conn, hostname, remote_port, &dns);
 158
 159     if(rc == CURLRESOLV_ERROR)
 160       return CURLE_COULDNT_RESOLVE_PROXY;
 161
 162     if(rc == CURLRESOLV_PENDING)
 163       /* ignores the return code, but 'dns' remains NULL on failure */
 164       (void)Curl_resolver_wait_resolv(conn, &dns);
 165
 166     /*
 167      * We cannot use 'hostent' as a struct that Curl_resolv() returns.  It
 168      * returns a Curl_addrinfo pointer that may not always look the same.
 169      */
 170     if(dns)
 171       hp=dns->addr;
 172     if(hp) {
 173       char buf[64];
 174       unsigned short ip[4];
 175       Curl_printable_address(hp, buf, sizeof(buf));
 176
 177       if(4 == sscanf( buf, "%hu.%hu.%hu.%hu",
 178                       &ip[0], &ip[1], &ip[2], &ip[3])) {
 179         /* Set DSTIP */
 180         socksreq[4] = (unsigned char)ip[0];
 181         socksreq[5] = (unsigned char)ip[1];
 182         socksreq[6] = (unsigned char)ip[2];
 183         socksreq[7] = (unsigned char)ip[3];
 184       }
 185       else
 186         hp = NULL; /* fail! */
 187
 188       Curl_resolv_unlock(data, dns); /* not used anymore from now on */
 189
 190     }
 191     if(!hp) {
 192       failf(data, "Failed to resolve \"%s\" for SOCKS4 connect.",
 193             hostname);
 194       return CURLE_COULDNT_RESOLVE_HOST;
 195     }
 196   }
 197
 198   /*
 199    * This is currently not supporting "Identification Protocol (RFC1413)".
 200    */
 201   socksreq[8] = 0; /* ensure empty userid is NUL-terminated */
 202   if(proxy_name)
 203     strlcat((char*)socksreq + 8, proxy_name, sizeof(socksreq) - 8);
 204
 205   /*
 206    * Make connection
 207    */
 208   {
 209     ssize_t actualread;
 210     ssize_t written;
 211     ssize_t hostnamelen = 0;
 212     int packetsize = 9 +
 213       (int)strlen((char*)socksreq + 8); /* size including NUL */
 214
 215     /* If SOCKS4a, set special invalid IP address 0.0.0.x */
 216     if(protocol4a) {
 217       socksreq[4] = 0;
 218       socksreq[5] = 0;
 219       socksreq[6] = 0;
 220       socksreq[7] = 1;
 221       /* If still enough room in buffer, also append hostname */
 222       hostnamelen = (ssize_t)strlen(hostname) + 1; /* length including NUL */
 223       if(packetsize + hostnamelen <= SOCKS4REQLEN)
 224         strcpy((char*)socksreq + packetsize, hostname);
 225       else
 226         hostnamelen = 0; /* Flag: hostname did not fit in buffer */
 227     }
 228
 229     /* Send request */
 230     code = Curl_write_plain(conn, sock, (char *)socksreq,
 231                             packetsize + hostnamelen,
 232                             &written);
 233     if((code != CURLE_OK) || (written != packetsize + hostnamelen)) {
 234       failf(data, "Failed to send SOCKS4 connect request.");
 235       return CURLE_COULDNT_CONNECT;
 236     }
 237     if(protocol4a && hostnamelen == 0) {
 238       /* SOCKS4a with very long hostname - send that name separately */
 239       hostnamelen = (ssize_t)strlen(hostname) + 1;
 240       code = Curl_write_plain(conn, sock, (char *)hostname, hostnamelen,
 241                               &written);
 242       if((code != CURLE_OK) || (written != hostnamelen)) {
 243         failf(data, "Failed to send SOCKS4 connect request.");
 244         return CURLE_COULDNT_CONNECT;
 245       }
 246     }
 247
 248     packetsize = 8; /* receive data size */
 249
 250     /* Receive response */
 251     result = Curl_blockread_all(conn, sock, (char *)socksreq, packetsize,
 252                                 &actualread);
 253     if((result != CURLE_OK) || (actualread != packetsize)) {
 254       failf(data, "Failed to receive SOCKS4 connect request ack.");
 255       return CURLE_COULDNT_CONNECT;
 256     }
 257
 258     /*
 259      * Response format
 260      *
 261      *     +----+----+----+----+----+----+----+----+
 262      *     | VN | CD | DSTPORT |      DSTIP        |
 263      *     +----+----+----+----+----+----+----+----+
 264      * # of bytes:  1    1      2              4
 265      *
 266      * VN is the version of the reply code and should be 0. CD is the result
 267      * code with one of the following values:
 268      *
 269      * 90: request granted
 270      * 91: request rejected or failed
 271      * 92: request rejected because SOCKS server cannot connect to
 272      *     identd on the client
 273      * 93: request rejected because the client program and identd
 274      *     report different user-ids
 275      */
 276
 277     /* wrong version ? */
 278     if(socksreq[0] != 0) {
 279       failf(data,
 280             "SOCKS4 reply has wrong version, version should be 4.");
 281       return CURLE_COULDNT_CONNECT;
 282     }
 283
 284     /* Result */
 285     switch(socksreq[1]) {
 286     case 90:
 287       infof(data, "SOCKS4%s request granted.\n", protocol4a?"a":"");
 288       break;
 289     case 91:
 290       failf(data,
 291             "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)"
 292             ", request rejected or failed.",
 293             (unsigned char)socksreq[4], (unsigned char)socksreq[5],
 294             (unsigned char)socksreq[6], (unsigned char)socksreq[7],
 295             ((socksreq[8] << 8) | socksreq[9]),
 296             socksreq[1]);
 297       return CURLE_COULDNT_CONNECT;
 298     case 92:
 299       failf(data,
 300             "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)"
 301             ", request rejected because SOCKS server cannot connect to "
 302             "identd on the client.",
 303             (unsigned char)socksreq[4], (unsigned char)socksreq[5],
 304             (unsigned char)socksreq[6], (unsigned char)socksreq[7],
 305             ((socksreq[8] << 8) | socksreq[9]),
 306             socksreq[1]);
 307       return CURLE_COULDNT_CONNECT;
 308     case 93:
 309       failf(data,
 310             "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)"
 311             ", request rejected because the client program and identd "
 312             "report different user-ids.",
 313             (unsigned char)socksreq[4], (unsigned char)socksreq[5],
 314             (unsigned char)socksreq[6], (unsigned char)socksreq[7],
 315             ((socksreq[8] << 8) | socksreq[9]),
 316             socksreq[1]);
 317       return CURLE_COULDNT_CONNECT;
 318     default:
 319       failf(data,
 320             "Can't complete SOCKS4 connection to %d.%d.%d.%d:%d. (%d)"
 321             ", Unknown.",
 322             (unsigned char)socksreq[4], (unsigned char)socksreq[5],
 323             (unsigned char)socksreq[6], (unsigned char)socksreq[7],
 324             ((socksreq[8] << 8) | socksreq[9]),
 325             socksreq[1]);
 326       return CURLE_COULDNT_CONNECT;
 327     }
 328   }
 329
 330   curlx_nonblock(sock, TRUE);
 331
 332   return CURLE_OK; /* Proxy was successful! */
 333 }
 334
 335 /*
 336  * This function logs in to a SOCKS5 proxy and sends the specifics to the final
 337  * destination server.
 338  */
 339 CURLcode Curl_SOCKS5(const char *proxy_name,
 340                      const char *proxy_password,
 341                      const char *hostname,
 342                      int remote_port,
 343                      int sockindex,
 344                      struct connectdata *conn)
 345 {
 346   /*
 347     According to the RFC1928, section "6.  Replies". This is what a SOCK5
 348     replies:
 349
 350         +----+-----+-------+------+----------+----------+
 351         |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
 352         +----+-----+-------+------+----------+----------+
 353         | 1  |  1  | X'00' |  1   | Variable |    2     |
 354         +----+-----+-------+------+----------+----------+
 355
 356     Where:
 357
 358     o  VER    protocol version: X'05'
 359     o  REP    Reply field:
 360     o  X'00' succeeded
 361   */
 362
 363   unsigned char socksreq[600]; /* room for large user/pw (255 max each) */
 364   ssize_t actualread;
 365   ssize_t written;
 366   int result;
 367   CURLcode code;
 368   curl_socket_t sock = conn->sock[sockindex];
 369   struct SessionHandle *data = conn->data;
 370   long timeout;
 371   bool socks5_resolve_local = (conn->proxytype == CURLPROXY_SOCKS5)?TRUE:FALSE;
 372   const size_t hostname_len = strlen(hostname);
 373   ssize_t packetsize = 0;
 374   int len;
 375
 376   /* RFC1928 chapter 5 specifies max 255 chars for domain name in packet */
 377   if(!socks5_resolve_local && hostname_len > 255) {
 378     infof(conn->data,"SOCKS5: server resolving disabled for hostnames of "
 379           "length > 255 [actual len=%zu]\n", hostname_len);
 380     socks5_resolve_local = TRUE;
 381   }
 382
 383   /* get timeout */
 384   timeout = Curl_timeleft(data, NULL, TRUE);
 385
 386   if(timeout < 0) {
 387     /* time-out, bail out, go home */
 388     failf(data, "Connection time-out");
 389     return CURLE_OPERATION_TIMEDOUT;
 390   }
 391
 392   curlx_nonblock(sock, TRUE);
 393
 394   /* wait until socket gets connected */
 395   result = Curl_socket_ready(CURL_SOCKET_BAD, sock, timeout);
 396
 397   if(-1 == result) {
 398     failf(conn->data, "SOCKS5: no connection here");
 399     return CURLE_COULDNT_CONNECT;
 400   }
 401   else if(0 == result) {
 402     failf(conn->data, "SOCKS5: connection timeout");
 403     return CURLE_OPERATION_TIMEDOUT;
 404   }
 405
 406   if(result & CURL_CSELECT_ERR) {
 407     failf(conn->data, "SOCKS5: error occurred during connection");
 408     return CURLE_COULDNT_CONNECT;
 409   }
 410
 411   socksreq[0] = 5; /* version */
 412 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 413   socksreq[1] = (char)(proxy_name ? 3 : 2); /* number of methods (below) */
 414   socksreq[2] = 0; /* no authentication */
 415   socksreq[3] = 1; /* gssapi */
 416   socksreq[4] = 2; /* username/password */
 417 #else
 418   socksreq[1] = (char)(proxy_name ? 2 : 1); /* number of methods (below) */
 419   socksreq[2] = 0; /* no authentication */
 420   socksreq[3] = 2; /* username/password */
 421 #endif
 422
 423   curlx_nonblock(sock, FALSE);
 424
 425   code = Curl_write_plain(conn, sock, (char *)socksreq, (2 + (int)socksreq[1]),
 426                           &written);
 427   if((code != CURLE_OK) || (written != (2 + (int)socksreq[1]))) {
 428     failf(data, "Unable to send initial SOCKS5 request.");
 429     return CURLE_COULDNT_CONNECT;
 430   }
 431
 432   curlx_nonblock(sock, TRUE);
 433
 434   result = Curl_socket_ready(sock, CURL_SOCKET_BAD, timeout);
 435
 436   if(-1 == result) {
 437     failf(conn->data, "SOCKS5 nothing to read");
 438     return CURLE_COULDNT_CONNECT;
 439   }
 440   else if(0 == result) {
 441     failf(conn->data, "SOCKS5 read timeout");
 442     return CURLE_OPERATION_TIMEDOUT;
 443   }
 444
 445   if(result & CURL_CSELECT_ERR) {
 446     failf(conn->data, "SOCKS5 read error occurred");
 447     return CURLE_RECV_ERROR;
 448   }
 449
 450   curlx_nonblock(sock, FALSE);
 451
 452   result=Curl_blockread_all(conn, sock, (char *)socksreq, 2, &actualread);
 453   if((result != CURLE_OK) || (actualread != 2)) {
 454     failf(data, "Unable to receive initial SOCKS5 response.");
 455     return CURLE_COULDNT_CONNECT;
 456   }
 457
 458   if(socksreq[0] != 5) {
 459     failf(data, "Received invalid version in initial SOCKS5 response.");
 460     return CURLE_COULDNT_CONNECT;
 461   }
 462   if(socksreq[1] == 0) {
 463     /* Nothing to do, no authentication needed */
 464     ;
 465   }
 466 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 467   else if(socksreq[1] == 1) {
 468     code = Curl_SOCKS5_gssapi_negotiate(sockindex, conn);
 469     if(code != CURLE_OK) {
 470       failf(data, "Unable to negotiate SOCKS5 gssapi context.");
 471       return CURLE_COULDNT_CONNECT;
 472     }
 473   }
 474 #endif
 475   else if(socksreq[1] == 2) {
 476     /* Needs user name and password */
 477     size_t userlen, pwlen;
 478     if(proxy_name && proxy_password) {
 479       userlen = strlen(proxy_name);
 480       pwlen = strlen(proxy_password);
 481     }
 482     else {
 483       userlen = 0;
 484       pwlen = 0;
 485     }
 486
 487     /*   username/password request looks like
 488      * +----+------+----------+------+----------+
 489      * |VER | ULEN |  UNAME   | PLEN |  PASSWD  |
 490      * +----+------+----------+------+----------+
 491      * | 1  |  1   | 1 to 255 |  1   | 1 to 255 |
 492      * +----+------+----------+------+----------+
 493      */
 494     len = 0;
 495     socksreq[len++] = 1;    /* username/pw subnegotiation version */
 496     socksreq[len++] = (unsigned char) userlen;
 497     if(proxy_name && userlen)
 498       memcpy(socksreq + len, proxy_name, userlen);
 499     len += (int)userlen;
 500     socksreq[len++] = (unsigned char) pwlen;
 501     if(proxy_password && pwlen)
 502       memcpy(socksreq + len, proxy_password, pwlen);
 503     len += (int)pwlen;
 504
 505     code = Curl_write_plain(conn, sock, (char *)socksreq, len, &written);
 506     if((code != CURLE_OK) || (len != written)) {
 507       failf(data, "Failed to send SOCKS5 sub-negotiation request.");
 508       return CURLE_COULDNT_CONNECT;
 509     }
 510
 511     result=Curl_blockread_all(conn, sock, (char *)socksreq, 2, &actualread);
 512     if((result != CURLE_OK) || (actualread != 2)) {
 513       failf(data, "Unable to receive SOCKS5 sub-negotiation response.");
 514       return CURLE_COULDNT_CONNECT;
 515     }
 516
 517     /* ignore the first (VER) byte */
 518     if(socksreq[1] != 0) { /* status */
 519       failf(data, "User was rejected by the SOCKS5 server (%d %d).",
 520             socksreq[0], socksreq[1]);
 521       return CURLE_COULDNT_CONNECT;
 522     }
 523
 524     /* Everything is good so far, user was authenticated! */
 525   }
 526   else {
 527     /* error */
 528 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 529     if(socksreq[1] == 255) {
 530 #else
 531     if(socksreq[1] == 1) {
 532       failf(data,
 533             "SOCKS5 GSSAPI per-message authentication is not supported.");
 534       return CURLE_COULDNT_CONNECT;
 535     }
 536     else if(socksreq[1] == 255) {
 537 #endif
 538       if(!proxy_name || !*proxy_name) {
 539         failf(data,
 540               "No authentication method was acceptable. (It is quite likely"
 541               " that the SOCKS5 server wanted a username/password, since none"
 542               " was supplied to the server on this connection.)");
 543       }
 544       else {
 545         failf(data, "No authentication method was acceptable.");
 546       }
 547       return CURLE_COULDNT_CONNECT;
 548     }
 549     else {
 550       failf(data,
 551             "Undocumented SOCKS5 mode attempted to be used by server.");
 552       return CURLE_COULDNT_CONNECT;
 553     }
 554   }
 555
 556   /* Authentication is complete, now specify destination to the proxy */
 557   len = 0;
 558   socksreq[len++] = 5; /* version (SOCKS5) */
 559   socksreq[len++] = 1; /* connect */
 560   socksreq[len++] = 0; /* must be zero */
 561
 562   if(!socks5_resolve_local) {
 563     socksreq[len++] = 3; /* ATYP: domain name = 3 */
 564     socksreq[len++] = (char) hostname_len; /* address length */
 565     memcpy(&socksreq[len], hostname, hostname_len); /* address bytes w/o NULL */
 566     len += hostname_len;
 567   }
 568   else {
 569     struct Curl_dns_entry *dns;
 570     Curl_addrinfo *hp = NULL;
 571     int rc = Curl_resolv(conn, hostname, remote_port, &dns);
 572
 573     if(rc == CURLRESOLV_ERROR)
 574       return CURLE_COULDNT_RESOLVE_HOST;
 575
 576     if(rc == CURLRESOLV_PENDING) {
 577       /* this requires that we're in "wait for resolve" state */
 578       code = Curl_resolver_wait_resolv(conn, &dns);
 579       if(code != CURLE_OK)
 580         return code;
 581     }
 582
 583     /*
 584      * We cannot use 'hostent' as a struct that Curl_resolv() returns.  It
 585      * returns a Curl_addrinfo pointer that may not always look the same.
 586      */
 587     if(dns)
 588       hp=dns->addr;
 589     if(hp) {
 590       struct sockaddr_in *saddr_in;
 591       struct sockaddr_in6 *saddr_in6;
 592       int i;
 593
 594       if(hp->ai_family == AF_INET) {
 595         socksreq[len++] = 1; /* IPv4 = 1 */
 596
 597         saddr_in = (struct sockaddr_in*)hp->ai_addr;
 598         for(i = 0; i < 4; i++) {
 599           socksreq[len++] = ((unsigned char*)&saddr_in->sin_addr.s_addr)[i];
 600           infof(data, "%d\n", socksreq[len-1]);
 601         }
 602       }
 603       else if(hp->ai_family == AF_INET6) {
 604         socksreq[len++] = 4; /* IPv6 = 4 */
 605
 606         saddr_in6 = (struct sockaddr_in6*)hp->ai_addr;
 607         for(i = 0; i < 16; i++) {
 608           socksreq[len++] = ((unsigned char*)&saddr_in6->sin6_addr.s6_addr)[i];
 609         }
 610       }
 611       else
 612         hp = NULL; /* fail! */
 613
 614       Curl_resolv_unlock(data, dns); /* not used anymore from now on */
 615     }
 616     if(!hp) {
 617       failf(data, "Failed to resolve \"%s\" for SOCKS5 connect.",
 618             hostname);
 619       return CURLE_COULDNT_RESOLVE_HOST;
 620     }
 621   }
 622
 623   socksreq[len++] = (unsigned char)((remote_port >> 8) & 0xff); /* PORT MSB */
 624   socksreq[len++] = (unsigned char)(remote_port & 0xff);        /* PORT LSB */
 625
 626   packetsize = len;
 627
 628 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 629   if(conn->socks5_gssapi_enctype) {
 630     failf(data, "SOCKS5 gssapi protection not yet implemented.");
 631   }
 632   else
 633 #endif
 634     code = Curl_write_plain(conn, sock, (char *)socksreq, packetsize,
 635                             &written);
 636   if((code != CURLE_OK) || (written != packetsize)) {
 637     failf(data, "Failed to send SOCKS5 connect request.");
 638     return CURLE_COULDNT_CONNECT;
 639   }
 640
 641   packetsize = 10; /* minimum packet size is 10 */
 642
 643 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 644   if(conn->socks5_gssapi_enctype) {
 645     failf(data, "SOCKS5 gssapi protection not yet implemented.");
 646   }
 647   else
 648 #endif
 649     result = Curl_blockread_all(conn, sock, (char *)socksreq, packetsize,
 650                                 &actualread);
 651   if((result != CURLE_OK) || (actualread != packetsize)) {
 652     failf(data, "Failed to receive SOCKS5 connect request ack.");
 653     return CURLE_COULDNT_CONNECT;
 654   }
 655
 656   if(socksreq[0] != 5) { /* version */
 657     failf(data,
 658           "SOCKS5 reply has wrong version, version should be 5.");
 659     return CURLE_COULDNT_CONNECT;
 660   }
 661   if(socksreq[1] != 0) { /* Anything besides 0 is an error */
 662     if(socksreq[3] == 1) {
 663       failf(data,
 664             "Can't complete SOCKS5 connection to %d.%d.%d.%d:%d. (%d)",
 665             (unsigned char)socksreq[4], (unsigned char)socksreq[5],
 666             (unsigned char)socksreq[6], (unsigned char)socksreq[7],
 667             ((socksreq[8] << 8) | socksreq[9]),
 668             socksreq[1]);
 669     }
 670     else if(socksreq[3] == 3) {
 671       failf(data,
 672             "Can't complete SOCKS5 connection to %s:%d. (%d)",
 673             hostname,
 674             ((socksreq[8] << 8) | socksreq[9]),
 675             socksreq[1]);
 676     }
 677     else if(socksreq[3] == 4) {
 678       failf(data,
 679             "Can't complete SOCKS5 connection to %02x%02x:%02x%02x:"
 680             "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%d. (%d)",
 681             (unsigned char)socksreq[4], (unsigned char)socksreq[5],
 682             (unsigned char)socksreq[6], (unsigned char)socksreq[7],
 683             (unsigned char)socksreq[8], (unsigned char)socksreq[9],
 684             (unsigned char)socksreq[10], (unsigned char)socksreq[11],
 685             (unsigned char)socksreq[12], (unsigned char)socksreq[13],
 686             (unsigned char)socksreq[14], (unsigned char)socksreq[15],
 687             (unsigned char)socksreq[16], (unsigned char)socksreq[17],
 688             (unsigned char)socksreq[18], (unsigned char)socksreq[19],
 689             ((socksreq[8] << 8) | socksreq[9]),
 690             socksreq[1]);
 691     }
 692     return CURLE_COULDNT_CONNECT;
 693   }
 694
 695   /* Fix: in general, returned BND.ADDR is variable length parameter by RFC
 696      1928, so the reply packet should be read until the end to avoid errors at
 697      subsequent protocol level.
 698
 699     +----+-----+-------+------+----------+----------+
 700     |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
 701     +----+-----+-------+------+----------+----------+
 702     | 1  |  1  | X'00' |  1   | Variable |    2     |
 703     +----+-----+-------+------+----------+----------+
 704
 705      ATYP:
 706      o  IP v4 address: X'01', BND.ADDR = 4 byte
 707      o  domain name:  X'03', BND.ADDR = [ 1 byte length, string ]
 708      o  IP v6 address: X'04', BND.ADDR = 16 byte
 709      */
 710
 711   /* Calculate real packet size */
 712   if(socksreq[3] == 3) {
 713     /* domain name */
 714     int addrlen = (int) socksreq[4];
 715     packetsize = 5 + addrlen + 2;
 716   }
 717   else if(socksreq[3] == 4) {
 718     /* IPv6 */
 719     packetsize = 4 + 16 + 2;
 720   }
 721
 722   /* At this point we already read first 10 bytes */
 723 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 724   if(!conn->socks5_gssapi_enctype) {
 725     /* decrypt_gssapi_blockread already read the whole packet */
 726 #endif
 727     if(packetsize > 10) {
 728       packetsize -= 10;
 729       result = Curl_blockread_all(conn, sock, (char *)&socksreq[10],
 730                                   packetsize, &actualread);
 731       if((result != CURLE_OK) || (actualread != packetsize)) {
 732         failf(data, "Failed to receive SOCKS5 connect request ack.");
 733         return CURLE_COULDNT_CONNECT;
 734       }
 735     }
 736 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 737   }
 738 #endif
 739
 740   curlx_nonblock(sock, TRUE);
 741   return CURLE_OK; /* Proxy was successful! */
 742 }
 743
 744 #endif /* CURL_DISABLE_PROXY */
 745