luna - curl/lib/socks.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) 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 https://curl.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 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25
  26#ifndef CURL_DISABLE_PROXY
  27
  28#ifdef HAVE_NETINET_IN_H
  29#include <netinet/in.h>
  30#endif
  31#ifdef HAVE_ARPA_INET_H
  32#include <arpa/inet.h>
  33#endif
  34
  35#include "urldata.h"
  36#include "bufq.h"
  37#include "curl_addrinfo.h"
  38#include "curl_trc.h"
  39#include "select.h"
  40#include "cfilters.h"
  41#include "cf-dns.h"
  42#include "connect.h"
  43#include "socks.h"
  44#include "curlx/inet_pton.h"
  45
  46/* for the (SOCKS) connect state machine */
  47enum socks_state_t {
  48  SOCKS_ST_INIT,
  49  /* SOCKS Version 4 states */
  50  SOCKS4_ST_START,
  51  SOCKS4_ST_RESOLVING,
  52  SOCKS4_ST_SEND,
  53  SOCKS4_ST_RECV,
  54  /* SOCKS Version 5 states */
  55  SOCKS5_ST_START,
  56  SOCKS5_ST_REQ0_SEND,
  57  SOCKS5_ST_RESP0_RECV, /* set up read */
  58  SOCKS5_ST_GSSAPI_INIT,
  59  SOCKS5_ST_AUTH_INIT, /* setup outgoing auth buffer */
  60  SOCKS5_ST_AUTH_SEND, /* send auth */
  61  SOCKS5_ST_AUTH_RECV, /* read auth response */
  62  SOCKS5_ST_REQ1_INIT,  /* init SOCKS "request" */
  63  SOCKS5_ST_RESOLVING,
  64  SOCKS5_ST_REQ1_SEND,
  65  SOCKS5_ST_RESP1_RECV,
  66  /* Terminal states, all SOCKS versions */
  67  SOCKS_ST_SUCCESS,
  68  SOCKS_ST_FAILED
  69};
  70
  71#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
  72static const char * const cf_socks_statename[] = {
  73  "SOCKS_INIT",
  74  "SOCKS4_START",
  75  "SOCKS4_RESOLVING",
  76  "SOCKS4_SEND",
  77  "SOCKS4_RECV",
  78  "SOCKS5_START",
  79  "SOCKS5_REQ0_SEND",
  80  "SOCKS5_RESP0_RECV",
  81  "SOCKS5_GSSAPI_INIT",
  82  "SOCKS5_AUTH_INIT",
  83  "SOCKS5_AUTH_SEND",
  84  "SOCKS5_AUTH_RECV",
  85  "SOCKS5_REQ1_INIT",
  86  "SOCKS5_RESOLVING",
  87  "SOCKS5_REQ1_SEND",
  88  "SOCKS5_RESP1_RECV",
  89  "SOCKS_SUCCESS",
  90  "SOCKS_FAILED"
  91};
  92#endif
  93
  94#define SOCKS_CHUNK_SIZE    1024
  95#define SOCKS_CHUNKS        1
  96
  97struct socks_ctx {
  98  enum socks_state_t state;
  99  struct bufq iobuf;
 100  struct Curl_peer *dest;
 101  struct Curl_creds *creds;
 102  CURLproxycode presult;
 103  uint32_t resolv_id;
 104  uint8_t ip_version;
 105  uint8_t proxy_type;
 106  unsigned char version;
 107  BIT(resolve_local);
 108  BIT(start_resolving);
 109  BIT(socks4a);
 110};
 111
 112#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 113/*
 114 * Helper read-from-socket functions. Does the same as Curl_read() but it
 115 * blocks until all bytes amount of buffersize will be read. No more, no less.
 116 *
 117 * This is STUPID BLOCKING behavior. Only used by the SOCKS GSSAPI functions.
 118 */
 119CURLcode Curl_blockread_all(struct Curl_cfilter *cf,
 120                            struct Curl_easy *data,
 121                            char *buf,             /* store read data here */
 122                            size_t blen,           /* space in buf */
 123                            size_t *pnread)        /* amount bytes read */
 124{
 125  size_t nread = 0;
 126  CURLcode result;
 127
 128  *pnread = 0;
 129  for(;;) {
 130    timediff_t timeout_ms = Curl_timeleft_ms(data);
 131    curl_socket_t sock = Curl_conn_cf_get_socket(cf, data);
 132
 133    if(timeout_ms < 0) {
 134      /* we already got the timeout */
 135      return CURLE_OPERATION_TIMEDOUT;
 136    }
 137    if(!timeout_ms)
 138      timeout_ms = TIMEDIFF_T_MAX;
 139    if(SOCKET_READABLE(sock, timeout_ms) <= 0)
 140      return CURLE_OPERATION_TIMEDOUT;
 141    result = Curl_conn_cf_recv(cf->next, data, buf, blen, &nread);
 142    if(result == CURLE_AGAIN)
 143      continue;
 144    else if(result)
 145      return result;
 146
 147    if(blen == nread) {
 148      *pnread += nread;
 149      return CURLE_OK;
 150    }
 151    if(!nread) /* EOF */
 152      return CURLE_RECV_ERROR;
 153
 154    buf += nread;
 155    blen -= nread;
 156    *pnread += nread;
 157  }
 158}
 159#endif
 160
 161#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
 162#define sxstate(x, c, d, y) socksstate(x, c, d, y, __LINE__)
 163#else
 164#define sxstate(x, c, d, y) socksstate(x, c, d, y)
 165#endif
 166
 167/* always use this function to change state, to make debugging easier */
 168static void socksstate(struct socks_ctx *sx,
 169                       struct Curl_cfilter *cf,
 170                       struct Curl_easy *data,
 171                       enum socks_state_t state
 172#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
 173                       , int lineno
 174#endif
 175)
 176{
 177  enum socks_state_t oldstate = sx->state;
 178
 179  if(oldstate == state)
 180    /* do not bother when the new state is the same as the old state */
 181    return;
 182
 183  sx->state = state;
 184
 185#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
 186  CURL_TRC_CF(data, cf, "[%s] -> [%s] (line %d)",
 187              cf_socks_statename[oldstate],
 188              cf_socks_statename[sx->state], lineno);
 189#else
 190  (void)cf;
 191  (void)data;
 192#endif
 193}
 194
 195static CURLproxycode socks_failed(struct socks_ctx *sx,
 196                                  struct Curl_cfilter *cf,
 197                                  struct Curl_easy *data,
 198                                  CURLproxycode presult)
 199{
 200  sxstate(sx, cf, data, SOCKS_ST_FAILED);
 201  sx->presult = presult;
 202  return presult;
 203}
 204
 205static CURLproxycode socks_flush(struct socks_ctx *sx,
 206                                 struct Curl_cfilter *cf,
 207                                 struct Curl_easy *data,
 208                                 bool *done)
 209{
 210  CURLcode result;
 211  size_t nwritten;
 212
 213  *done = FALSE;
 214  while(!Curl_bufq_is_empty(&sx->iobuf)) {
 215    result = Curl_cf_send_bufq(cf->next, data, &sx->iobuf, NULL, 0,
 216                               &nwritten);
 217    if(result == CURLE_AGAIN)
 218      return CURLPX_OK;
 219    else if(result) {
 220      failf(data, "Failed to send SOCKS request: %s",
 221            curl_easy_strerror(result));
 222      return socks_failed(sx, cf, data, CURLPX_SEND_CONNECT);
 223    }
 224  }
 225  *done = TRUE;
 226  return CURLPX_OK;
 227}
 228
 229static CURLproxycode socks_recv(struct socks_ctx *sx,
 230                                struct Curl_cfilter *cf,
 231                                struct Curl_easy *data,
 232                                size_t min_bytes,
 233                                bool *done)
 234{
 235  CURLcode result;
 236  size_t nread;
 237
 238  *done = FALSE;
 239  while(Curl_bufq_len(&sx->iobuf) < min_bytes) {
 240    result = Curl_cf_recv_bufq(cf->next, data, &sx->iobuf,
 241                               min_bytes - Curl_bufq_len(&sx->iobuf),
 242                               &nread);
 243    if(result == CURLE_AGAIN)
 244      return CURLPX_OK;
 245    else if(result) {
 246      failf(data, "Failed to receive SOCKS response: %s",
 247            curl_easy_strerror(result));
 248      return CURLPX_RECV_CONNECT;
 249    }
 250    else if(!nread) { /* EOF */
 251      if(Curl_bufq_len(&sx->iobuf) < min_bytes) {
 252        failf(data, "Failed to receive SOCKS response, "
 253              "proxy closed connection");
 254        return CURLPX_RECV_CONNECT;
 255      }
 256      break;
 257    }
 258  }
 259  *done = TRUE;
 260  return CURLPX_OK;
 261}
 262
 263static CURLproxycode socks4_req_add_hd(struct socks_ctx *sx,
 264                                       struct Curl_easy *data)
 265{
 266  unsigned char buf[4];
 267  size_t nwritten;
 268  CURLcode result;
 269
 270  (void)data;
 271  buf[0] = 4; /* version (SOCKS4) */
 272  buf[1] = 1; /* connect */
 273  buf[2] = (unsigned char)((sx->dest->port >> 8) & 0xffU); /* MSB */
 274  buf[3] = (unsigned char)(sx->dest->port & 0xffU);        /* LSB */
 275
 276  result = Curl_bufq_write(&sx->iobuf, buf, 4, &nwritten);
 277  if(result || (nwritten != 4))
 278    return CURLPX_SEND_REQUEST;
 279  return CURLPX_OK;
 280}
 281
 282static CURLproxycode socks4_req_add_user(struct socks_ctx *sx,
 283                                         struct Curl_easy *data)
 284{
 285  CURLcode result;
 286  size_t nwritten;
 287
 288  if(sx->creds) {
 289    size_t plen = strlen(sx->creds->user);
 290    if(plen > 255) {
 291      /* there is no real size limit to this field in the protocol, but
 292         SOCKS5 limits the proxy user field to 255 bytes and it seems likely
 293         that a longer field is either a mistake or malicious input */
 294      failf(data, "Too long SOCKS proxy username");
 295      return CURLPX_LONG_USER;
 296    }
 297    /* add proxy name WITH trailing zero */
 298    result = Curl_bufq_cwrite(&sx->iobuf, sx->creds->user, plen + 1,
 299                              &nwritten);
 300    if(result || (nwritten != (plen + 1)))
 301      return CURLPX_SEND_REQUEST;
 302  }
 303  else {
 304    /* empty username */
 305    unsigned char b = 0;
 306    result = Curl_bufq_write(&sx->iobuf, &b, 1, &nwritten);
 307    if(result || (nwritten != 1))
 308      return CURLPX_SEND_REQUEST;
 309  }
 310  return CURLPX_OK;
 311}
 312
 313static CURLproxycode socks4_resolving(struct socks_ctx *sx,
 314                                      struct Curl_cfilter *cf,
 315                                      struct Curl_easy *data,
 316                                      bool *done)
 317{
 318  const struct Curl_addrinfo *ai = NULL;
 319  CURLcode result;
 320  size_t nwritten;
 321  bool dns_done;
 322
 323  *done = FALSE;
 324  if(sx->start_resolving) {
 325    /* need to resolve hostname to add destination address */
 326    sx->start_resolving = FALSE;
 327    result = Curl_cf_dns_insert_after(
 328      cf, data, Curl_resolv_dns_queries(data, sx->ip_version),
 329      sx->dest, TRNSPRT_TCP, TRUE);
 330    if(result) {
 331      failf(data, "unable to create DNS filter for socks");
 332      return CURLPX_UNKNOWN_FAIL;
 333    }
 334  }
 335
 336  /* resolve the hostname by connecting the DNS filter */
 337  result = Curl_conn_cf_connect(cf->next, data, &dns_done);
 338  if(result) {
 339    failf(data, "Failed to resolve \"%s\" for SOCKS4 connect.",
 340          sx->dest->hostname);
 341    return CURLPX_RESOLVE_HOST;
 342  }
 343  else if(!dns_done)
 344    return CURLPX_OK;
 345
 346  ai = Curl_cf_dns_get_ai(cf->next, data, AF_INET, 0);
 347  if(ai) {
 348    struct sockaddr_in *saddr_in;
 349    char ipbuf[64];
 350
 351    Curl_printable_address(ai, ipbuf, sizeof(ipbuf));
 352    CURL_TRC_CF(data, cf, "SOCKS4 connect to IPv4 %s (locally resolved)",
 353                ipbuf);
 354
 355    saddr_in = (struct sockaddr_in *)(void *)ai->ai_addr;
 356    result = Curl_bufq_write(&sx->iobuf,
 357                             (unsigned char *)&saddr_in->sin_addr.s_addr, 4,
 358                             &nwritten);
 359
 360    if(result || (nwritten != 4))
 361      return CURLPX_SEND_REQUEST;
 362  }
 363  else {
 364    /* No ipv4 address resolved */
 365    failf(data, "SOCKS4 connection to %s not supported", sx->dest->hostname);
 366    return CURLPX_RESOLVE_HOST;
 367  }
 368
 369  *done = TRUE;
 370  return CURLPX_OK;
 371}
 372
 373static CURLproxycode socks4_check_resp(struct socks_ctx *sx,
 374                                       struct Curl_cfilter *cf,
 375                                       struct Curl_easy *data)
 376{
 377  const unsigned char *resp;
 378  size_t rlen;
 379
 380  if(!Curl_bufq_peek(&sx->iobuf, &resp, &rlen) || rlen < 8) {
 381    failf(data, "SOCKS4 reply is incomplete.");
 382    return CURLPX_RECV_CONNECT;
 383  }
 384
 385  DEBUGASSERT(rlen == 8);
 386  /*
 387   * Response format
 388   *
 389   *     +----+----+----+----+----+----+----+----+
 390   *     | VN | CD | DSTPORT |      DSTIP        |
 391   *     +----+----+----+----+----+----+----+----+
 392   * # of bytes:  1    1      2              4
 393   *
 394   * VN is the version of the reply code and should be 0. CD is the result
 395   * code with one of the following values:
 396   *
 397   * 90: request granted
 398   * 91: request rejected or failed
 399   * 92: request rejected because SOCKS server cannot connect to
 400   *     identd on the client
 401   * 93: request rejected because the client program and identd
 402   *     report different user-ids
 403   */
 404
 405  /* wrong version ? */
 406  if(resp[0]) {
 407    failf(data, "SOCKS4 reply has wrong version, version should be 0.");
 408    return CURLPX_BAD_VERSION;
 409  }
 410
 411  /* Result */
 412  switch(resp[1]) {
 413  case 90:
 414    CURL_TRC_CF(data, cf, "SOCKS4%s request granted.", sx->socks4a ? "a" : "");
 415    Curl_bufq_skip(&sx->iobuf, 8);
 416    return CURLPX_OK;
 417  case 91:
 418    failf(data,
 419          "[SOCKS] cannot complete SOCKS4 connection to %u.%u.%u.%u:%u. (%u)"
 420          ", request rejected or failed.",
 421          resp[4], resp[5], resp[6], resp[7],
 422          (unsigned int)((resp[2] << 8) | resp[3]), resp[1]);
 423    return CURLPX_REQUEST_FAILED;
 424  case 92:
 425    failf(data,
 426          "[SOCKS] cannot complete SOCKS4 connection to %u.%u.%u.%u:%u. (%u)"
 427          ", request rejected because SOCKS server cannot connect to "
 428          "identd on the client.",
 429          resp[4], resp[5], resp[6], resp[7],
 430          (unsigned int)((resp[2] << 8) | resp[3]), resp[1]);
 431    return CURLPX_IDENTD;
 432  case 93:
 433    failf(data,
 434          "[SOCKS] cannot complete SOCKS4 connection to %u.%u.%u.%u:%u. (%u)"
 435          ", request rejected because the client program and identd "
 436          "report different user-ids.",
 437          resp[4], resp[5], resp[6], resp[7],
 438          (unsigned int)((resp[2] << 8) | resp[3]), resp[1]);
 439    return CURLPX_IDENTD_DIFFER;
 440  default:
 441    failf(data,
 442          "[SOCKS] cannot complete SOCKS4 connection to %u.%u.%u.%u:%u. (%u)"
 443          ", Unknown.",
 444          resp[4], resp[5], resp[6], resp[7],
 445          (unsigned int)((resp[2] << 8) | resp[3]), resp[1]);
 446    return CURLPX_UNKNOWN_FAIL;
 447  }
 448}
 449
 450/*
 451 * This function logs in to a SOCKS4 proxy and sends the specifics to the final
 452 * destination server.
 453 *
 454 * Reference :
 455 *   https://www.openssh.com/txt/socks4.protocol
 456 *
 457 * Note :
 458 *   Set protocol4a=true for  "SOCKS 4A (Simple Extension to SOCKS 4 Protocol)"
 459 *   Nonsupport "Identification Protocol (RFC1413)"
 460 */
 461static CURLproxycode socks4_connect(struct Curl_cfilter *cf,
 462                                    struct socks_ctx *sx,
 463                                    struct Curl_easy *data)
 464{
 465  size_t nwritten;
 466  CURLproxycode presult;
 467  CURLcode result;
 468  bool done;
 469
 470process_state:
 471  switch(sx->state) {
 472  case SOCKS_ST_INIT:
 473    sx->version = 4;
 474    sxstate(sx, cf, data, SOCKS4_ST_START);
 475    FALLTHROUGH();
 476
 477  case SOCKS4_ST_START:
 478    Curl_bufq_reset(&sx->iobuf);
 479    sx->start_resolving = FALSE;
 480    sx->socks4a = (sx->proxy_type == CURLPROXY_SOCKS4A);
 481    sx->resolve_local = !sx->socks4a;
 482    sx->presult = CURLPX_OK;
 483
 484    /* SOCKS4 can only do IPv4, insist! */
 485    sx->ip_version = CURL_IPRESOLVE_V4;
 486    CURL_TRC_CF(data, cf, "SOCKS4%s connecting to %s:%u",
 487                sx->socks4a ? "a" : "",
 488                sx->dest->hostname, sx->dest->port);
 489
 490    /*
 491     * Compose socks4 request
 492     *
 493     * Request format
 494     *
 495     *     +----+----+----+----+----+----+----+----+----+----+....+----+
 496     *     | VN | CD | DSTPORT |      DSTIP        | USERID       |NULL|
 497     *     +----+----+----+----+----+----+----+----+----+----+....+----+
 498     * # of bytes:  1    1      2              4           variable       1
 499     */
 500    presult = socks4_req_add_hd(sx, data);
 501    if(presult)
 502      return socks_failed(sx, cf, data, presult);
 503
 504    /* DNS resolve only for SOCKS4, not SOCKS4a */
 505    if(!sx->resolve_local) {
 506      /* socks4a, not resolving locally, sends the hostname.
 507       * add an invalid address + user + hostname */
 508      unsigned char buf[4] = { 0, 0, 0, 1 };
 509      size_t hlen = strlen(sx->dest->hostname) + 1; /* including NUL */
 510
 511      if(hlen > 255) {
 512        failf(data, "SOCKS4: too long hostname");
 513        return socks_failed(sx, cf, data, CURLPX_LONG_HOSTNAME);
 514      }
 515      result = Curl_bufq_write(&sx->iobuf, buf, 4, &nwritten);
 516      if(result || (nwritten != 4))
 517        return socks_failed(sx, cf, data, CURLPX_SEND_REQUEST);
 518      presult = socks4_req_add_user(sx, data);
 519      if(presult)
 520        return socks_failed(sx, cf, data, presult);
 521      result = Curl_bufq_cwrite(&sx->iobuf, sx->dest->hostname, hlen,
 522                                &nwritten);
 523      if(result || (nwritten != hlen))
 524        return socks_failed(sx, cf, data, CURLPX_SEND_REQUEST);
 525      /* request complete */
 526      sxstate(sx, cf, data, SOCKS4_ST_SEND);
 527      goto process_state;
 528    }
 529    sx->start_resolving = TRUE;
 530    sxstate(sx, cf, data, SOCKS4_ST_RESOLVING);
 531    FALLTHROUGH();
 532
 533  case SOCKS4_ST_RESOLVING:
 534    presult = socks4_resolving(sx, cf, data, &done);
 535    if(presult)
 536      return socks_failed(sx, cf, data, presult);
 537    if(!done)
 538      return CURLPX_OK;
 539    /* append user */
 540    presult = socks4_req_add_user(sx, data);
 541    if(presult)
 542      return socks_failed(sx, cf, data, presult);
 543    sxstate(sx, cf, data, SOCKS4_ST_SEND);
 544    FALLTHROUGH();
 545
 546  case SOCKS4_ST_SEND:
 547    presult = socks_flush(sx, cf, data, &done);
 548    if(presult)
 549      return socks_failed(sx, cf, data, presult);
 550    else if(!done)
 551      return CURLPX_OK;
 552    sxstate(sx, cf, data, SOCKS4_ST_RECV);
 553    FALLTHROUGH();
 554
 555  case SOCKS4_ST_RECV:
 556    /* Receive 8 byte response */
 557    presult = socks_recv(sx, cf, data, 8, &done);
 558    if(presult)
 559      return socks_failed(sx, cf, data, presult);
 560    else if(!done)
 561      return CURLPX_OK;
 562    presult = socks4_check_resp(sx, cf, data);
 563    if(presult)
 564      return socks_failed(sx, cf, data, presult);
 565    sxstate(sx, cf, data, SOCKS_ST_SUCCESS);
 566    FALLTHROUGH();
 567
 568  case SOCKS_ST_SUCCESS:
 569    return CURLPX_OK;
 570
 571  case SOCKS_ST_FAILED:
 572    DEBUGASSERT(sx->presult);
 573    return sx->presult;
 574
 575  default:
 576    DEBUGASSERT(0);
 577    return socks_failed(sx, cf, data, CURLPX_SEND_REQUEST);
 578  }
 579}
 580
 581static CURLproxycode socks5_req0_init(struct Curl_cfilter *cf,
 582                                      struct socks_ctx *sx,
 583                                      struct Curl_easy *data)
 584{
 585  const unsigned char auth = data->set.socks5auth;
 586  unsigned char req[5]; /* version + len + 3 possible auth methods */
 587  unsigned char nauths;
 588  size_t req_len, nwritten;
 589  CURLcode result;
 590
 591  (void)cf;
 592  /* RFC1928 chapter 5 specifies max 255 chars for domain name in packet */
 593  if(!sx->resolve_local && strlen(sx->dest->hostname) > 255) {
 594    failf(data, "SOCKS5: the destination hostname is too long to be "
 595          "resolved remotely by the proxy.");
 596    return CURLPX_LONG_HOSTNAME;
 597  }
 598
 599  if(auth & ~(CURLAUTH_BASIC | CURLAUTH_GSSAPI))
 600    infof(data, "warning: unsupported value passed to "
 601          "CURLOPT_SOCKS5_AUTH: %u", auth);
 602  if(!(auth & CURLAUTH_BASIC))
 603    /* disable username/password auth */
 604    Curl_creds_unlink(&sx->creds);
 605
 606  req[0] = 5;   /* version */
 607  nauths = 1;
 608  req[1 + nauths] = 0;   /* 1. no authentication */
 609#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 610  if(auth & CURLAUTH_GSSAPI) {
 611    ++nauths;
 612    req[1 + nauths] = 1; /* GSS-API */
 613  }
 614#endif
 615  if(sx->creds) {
 616    ++nauths;
 617    req[1 + nauths] = 2; /* username/password */
 618  }
 619  req[1] = nauths;
 620  req_len = 2 + nauths;
 621
 622  result = Curl_bufq_write(&sx->iobuf, req, req_len, &nwritten);
 623  if(result || (nwritten != req_len))
 624    return CURLPX_SEND_REQUEST;
 625  return CURLPX_OK;
 626}
 627
 628static CURLproxycode socks5_check_resp0(struct socks_ctx *sx,
 629                                        struct Curl_cfilter *cf,
 630                                        struct Curl_easy *data)
 631{
 632  const unsigned char *resp;
 633  unsigned char auth_mode;
 634  size_t rlen;
 635
 636  if(!Curl_bufq_peek(&sx->iobuf, &resp, &rlen) || rlen < 2) {
 637    failf(data, "SOCKS5 initial reply is incomplete.");
 638    return CURLPX_RECV_CONNECT;
 639  }
 640
 641  if(resp[0] != 5) {
 642    failf(data, "Received invalid version in initial SOCKS5 response.");
 643    return CURLPX_BAD_VERSION;
 644  }
 645
 646  auth_mode = resp[1];
 647  Curl_bufq_skip(&sx->iobuf, 2);
 648
 649  switch(auth_mode) {
 650  case 0:
 651    /* DONE! No authentication needed. Send request. */
 652    sxstate(sx, cf, data, SOCKS5_ST_REQ1_INIT);
 653    return CURLPX_OK;
 654  case 1:
 655    if(data->set.socks5auth & CURLAUTH_GSSAPI) {
 656      sxstate(sx, cf, data, SOCKS5_ST_GSSAPI_INIT);
 657      return CURLPX_OK;
 658    }
 659    failf(data,
 660          "SOCKS5 GSSAPI per-message authentication is not enabled.");
 661    return CURLPX_GSSAPI_PERMSG;
 662  case 2:
 663    /* regular name + password authentication */
 664    if(data->set.socks5auth & CURLAUTH_BASIC) {
 665      sxstate(sx, cf, data, SOCKS5_ST_AUTH_INIT);
 666      return CURLPX_OK;
 667    }
 668    failf(data, "BASIC authentication proposed but not enabled.");
 669    return CURLPX_NO_AUTH;
 670  case 255:
 671    failf(data, "No authentication method was acceptable.");
 672    return CURLPX_NO_AUTH;
 673  default:
 674    failf(data, "Unknown SOCKS5 mode attempted to be used by server.");
 675    return CURLPX_UNKNOWN_MODE;
 676  }
 677}
 678
 679static CURLproxycode socks5_auth_init(struct Curl_cfilter *cf,
 680                                      struct socks_ctx *sx,
 681                                      struct Curl_easy *data)
 682{
 683  /* Needs username and password */
 684  size_t ulen = 0, plen = 0, nwritten;
 685  unsigned char buf[2];
 686  CURLcode result;
 687
 688  if(sx->creds) {
 689    ulen = strlen(sx->creds->user);
 690    plen = strlen(sx->creds->passwd);
 691    /* the lengths must fit in a single byte */
 692    if(ulen > 255) {
 693      failf(data, "Excessive username length for proxy auth");
 694      return CURLPX_LONG_USER;
 695    }
 696    if(plen > 255) {
 697      failf(data, "Excessive password length for proxy auth");
 698      return CURLPX_LONG_PASSWD;
 699    }
 700  }
 701
 702  /*   username/password request looks like
 703   * +----+------+----------+------+----------+
 704   * |VER | ULEN |  UNAME   | PLEN |  PASSWD  |
 705   * +----+------+----------+------+----------+
 706   * | 1  |  1   | 1 to 255 |  1   | 1 to 255 |
 707   * +----+------+----------+------+----------+
 708   */
 709  buf[0] = 1;    /* username/pw subnegotiation version */
 710  buf[1] = (unsigned char)ulen;
 711  result = Curl_bufq_write(&sx->iobuf, buf, 2, &nwritten);
 712  if(result || (nwritten != 2))
 713    return CURLPX_SEND_REQUEST;
 714  if(ulen) {
 715    result = Curl_bufq_cwrite(&sx->iobuf, sx->creds->user, ulen,
 716                              &nwritten);
 717    if(result || (nwritten != ulen))
 718      return CURLPX_SEND_REQUEST;
 719  }
 720  buf[0] = (unsigned char)plen;
 721  result = Curl_bufq_write(&sx->iobuf, buf, 1, &nwritten);
 722  if(result || (nwritten != 1))
 723    return CURLPX_SEND_REQUEST;
 724  if(plen) {
 725    result = Curl_bufq_cwrite(&sx->iobuf, sx->creds->passwd, plen,
 726                              &nwritten);
 727    if(result || (nwritten != plen))
 728      return CURLPX_SEND_REQUEST;
 729  }
 730  sxstate(sx, cf, data, SOCKS5_ST_AUTH_SEND);
 731  return CURLPX_OK;
 732}
 733
 734static CURLproxycode socks5_check_auth_resp(struct socks_ctx *sx,
 735                                            struct Curl_cfilter *cf,
 736                                            struct Curl_easy *data)
 737{
 738  const unsigned char *resp;
 739  unsigned char auth_status;
 740  size_t rlen;
 741
 742  (void)cf;
 743  if(!Curl_bufq_peek(&sx->iobuf, &resp, &rlen) || rlen < 2) {
 744    failf(data, "SOCKS5 sub-negotiation response incomplete.");
 745    return CURLPX_RECV_CONNECT;
 746  }
 747
 748  /* ignore the first (VER) byte */
 749  auth_status = resp[1];
 750  if(auth_status) {
 751    failf(data, "User was rejected by the SOCKS5 server (%d %d).",
 752          resp[0], resp[1]);
 753    return CURLPX_USER_REJECTED;
 754  }
 755  Curl_bufq_skip(&sx->iobuf, 2);
 756  return CURLPX_OK;
 757}
 758
 759static CURLproxycode socks5_req1_init(struct socks_ctx *sx,
 760                                      struct Curl_cfilter *cf,
 761                                      struct Curl_easy *data)
 762{
 763  unsigned char req[5];
 764  unsigned char ipbuf[16];
 765  const unsigned char *destination;
 766  unsigned char desttype, destlen, hdlen;
 767  size_t nwritten;
 768  CURLcode result;
 769
 770  req[0] = 5; /* version (SOCKS5) */
 771  req[1] = 1; /* connect */
 772  req[2] = 0; /* must be zero */
 773  if(sx->resolve_local) {
 774    /* rest of request is added after resolving */
 775    result = Curl_bufq_write(&sx->iobuf, req, 3, &nwritten);
 776    if(result || (nwritten != 3))
 777      return CURLPX_SEND_REQUEST;
 778    return CURLPX_OK;
 779  }
 780
 781  /* remote resolving, send what type+addr/string to resolve */
 782#ifdef USE_IPV6
 783  if(strchr(sx->dest->hostname, ':')) {
 784    desttype = 4;
 785    destination = ipbuf;
 786    destlen = 16;
 787    if(curlx_inet_pton(AF_INET6, sx->dest->hostname, ipbuf) != 1)
 788      return CURLPX_BAD_ADDRESS_TYPE;
 789  }
 790  else
 791#endif
 792  if(curlx_inet_pton(AF_INET, sx->dest->hostname, ipbuf) == 1) {
 793    desttype = 1;
 794    destination = ipbuf;
 795    destlen = 4;
 796  }
 797  else {
 798    const size_t hostname_len = strlen(sx->dest->hostname);
 799    /* socks5_req0_init() already rejects hostnames longer than 255 bytes, so
 800       this cast to unsigned char is safe. Assert to guard against future
 801       refactoring that might remove or reorder that earlier check. */
 802    DEBUGASSERT(hostname_len <= 255);
 803    desttype = 3;
 804    destination = (const unsigned char *)sx->dest->hostname;
 805    destlen = (unsigned char)hostname_len; /* one byte length */
 806  }
 807
 808  req[3] = desttype;
 809  req[4] = destlen;
 810  hdlen = (desttype == 3) ? 5 : 4; /* no length byte for ip addresses */
 811  result = Curl_bufq_write(&sx->iobuf, req, hdlen, &nwritten);
 812  if(result || (nwritten != hdlen))
 813    return CURLPX_SEND_REQUEST;
 814  result = Curl_bufq_write(&sx->iobuf, destination, destlen, &nwritten);
 815  if(result || (nwritten != destlen))
 816    return CURLPX_SEND_REQUEST;
 817  /* PORT MSB+LSB */
 818  req[0] = (unsigned char)((sx->dest->port >> 8) & 0xff);
 819  req[1] = (unsigned char)(sx->dest->port & 0xff);
 820  result = Curl_bufq_write(&sx->iobuf, req, 2, &nwritten);
 821  if(result || (nwritten != 2))
 822    return CURLPX_SEND_REQUEST;
 823  CURL_TRC_CF(data, cf, "SOCKS5 connect to %s:%u (remotely resolved)",
 824              sx->dest->hostname, sx->dest->port);
 825  return CURLPX_OK;
 826}
 827
 828static CURLproxycode socks5_resolving(struct socks_ctx *sx,
 829                                      struct Curl_cfilter *cf,
 830                                      struct Curl_easy *data,
 831                                      bool *done)
 832{
 833  const struct Curl_addrinfo *ai = NULL;
 834  char dest[MAX_IPADR_LEN];  /* printable address */
 835  const unsigned char *destination = NULL;
 836  unsigned char desttype = 1, destlen = 4;
 837  unsigned char req[2];
 838  CURLcode result;
 839  CURLproxycode presult = CURLPX_OK;
 840  size_t nwritten;
 841  bool dns_done;
 842
 843  *done = FALSE;
 844  if(sx->start_resolving) {
 845    /* need to resolve hostname to add destination address */
 846    sx->start_resolving = FALSE;
 847    result = Curl_cf_dns_insert_after(
 848      cf, data, Curl_resolv_dns_queries(data, sx->ip_version),
 849      sx->dest, TRNSPRT_TCP, TRUE);
 850    if(result) {
 851      failf(data, "unable to create DNS filter for socks");
 852      return CURLPX_UNKNOWN_FAIL;
 853    }
 854  }
 855
 856  /* resolve the hostname by connecting the DNS filter */
 857  result = Curl_conn_cf_connect(cf->next, data, &dns_done);
 858  if(result) {
 859    failf(data, "Failed to resolve \"%s\" for SOCKS5 connect.",
 860          sx->dest->hostname);
 861    return CURLPX_RESOLVE_HOST;
 862  }
 863  else if(!dns_done)
 864    return CURLPX_OK;
 865
 866#ifdef USE_IPV6
 867  if(data->set.ipver != CURL_IPRESOLVE_V4)
 868    ai = Curl_cf_dns_get_ai(cf->next, data, AF_INET6, 0);
 869#endif
 870  if(!ai)
 871    ai = Curl_cf_dns_get_ai(cf->next, data, AF_INET, 0);
 872
 873  if(!ai) {
 874    failf(data, "Failed to resolve \"%s\" for SOCKS5 connect.",
 875          sx->dest->hostname);
 876    presult = CURLPX_RESOLVE_HOST;
 877    goto out;
 878  }
 879
 880  Curl_printable_address(ai, dest, sizeof(dest));
 881
 882  if(ai->ai_family == AF_INET) {
 883    struct sockaddr_in *saddr_in;
 884    desttype = 1; /* ATYP: IPv4 = 1 */
 885    destlen = 4;
 886    saddr_in = (struct sockaddr_in *)(void *)ai->ai_addr;
 887    destination = (const unsigned char *)&saddr_in->sin_addr.s_addr;
 888    CURL_TRC_CF(data, cf, "SOCKS5 connect to %s:%u (locally resolved)",
 889                dest, sx->dest->port);
 890  }
 891#ifdef USE_IPV6
 892  else if(ai->ai_family == AF_INET6) {
 893    struct sockaddr_in6 *saddr_in6;
 894    desttype = 4; /* ATYP: IPv6 = 4 */
 895    destlen = 16;
 896    saddr_in6 = (struct sockaddr_in6 *)(void *)ai->ai_addr;
 897    destination = (const unsigned char *)&saddr_in6->sin6_addr.s6_addr;
 898    CURL_TRC_CF(data, cf, "SOCKS5 connect to [%s]:%u (locally resolved)",
 899                dest, sx->dest->port);
 900  }
 901#endif
 902
 903  if(!destination) {
 904    failf(data, "SOCKS5 connection to %s not supported", dest);
 905    presult = CURLPX_RESOLVE_HOST;
 906    goto out;
 907  }
 908
 909  req[0] = desttype;
 910  result = Curl_bufq_write(&sx->iobuf, req, 1, &nwritten);
 911  if(result || (nwritten != 1)) {
 912    presult = CURLPX_SEND_REQUEST;
 913    goto out;
 914  }
 915  result = Curl_bufq_write(&sx->iobuf, destination, destlen, &nwritten);
 916  if(result || (nwritten != destlen)) {
 917    presult = CURLPX_SEND_REQUEST;
 918    goto out;
 919  }
 920  /* PORT MSB+LSB */
 921  req[0] = (unsigned char)((sx->dest->port >> 8) & 0xffU);
 922  req[1] = (unsigned char)(sx->dest->port & 0xffU);
 923  result = Curl_bufq_write(&sx->iobuf, req, 2, &nwritten);
 924  if(result || (nwritten != 2)) {
 925    presult = CURLPX_SEND_REQUEST;
 926    goto out;
 927  }
 928
 929out:
 930  *done = (presult == CURLPX_OK);
 931  return presult;
 932}
 933
 934static CURLproxycode socks5_recv_resp1(struct socks_ctx *sx,
 935                                       struct Curl_cfilter *cf,
 936                                       struct Curl_easy *data,
 937                                       bool *done)
 938{
 939  const unsigned char *resp;
 940  size_t rlen, resp_len = 8; /* minimum response length */
 941  CURLproxycode presult;
 942
 943  presult = socks_recv(sx, cf, data, resp_len, done);
 944  if(presult)
 945    return presult;
 946  else if(!*done)
 947    return CURLPX_OK;
 948
 949  if(!Curl_bufq_peek(&sx->iobuf, &resp, &rlen) || rlen < resp_len) {
 950    failf(data, "SOCKS5 response is incomplete.");
 951    return CURLPX_RECV_CONNECT;
 952  }
 953
 954  /* Response packet includes BND.ADDR is variable length parameter by RFC
 955     1928, so the response packet MUST be read until the end to avoid errors
 956     at subsequent protocol level.
 957
 958     +----+-----+-------+------+----------+----------+
 959     |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
 960     +----+-----+-------+------+----------+----------+
 961     | 1  |  1  | X'00' |  1   | Variable |    2     |
 962     +----+-----+-------+------+----------+----------+
 963
 964     ATYP:
 965     o  IP v4 address: X'01', BND.ADDR = 4 byte
 966     o  domain name:   X'03', BND.ADDR = [ 1 byte length, string ]
 967     o  IP v6 address: X'04', BND.ADDR = 16 byte
 968  */
 969  if(resp[0] != 5) { /* version */
 970    failf(data, "SOCKS5 reply has wrong version, version should be 5.");
 971    return CURLPX_BAD_VERSION;
 972  }
 973  else if(resp[1]) { /* Anything besides 0 is an error */
 974    CURLproxycode rc = CURLPX_REPLY_UNASSIGNED;
 975    int code = resp[1];
 976    failf(data, "cannot complete SOCKS5 connection to %s. (%d)",
 977          sx->dest->hostname, code);
 978    if(code < 9) {
 979      /* RFC 1928 section 6 lists: */
 980      static const CURLproxycode lookup[] = {
 981        CURLPX_OK,
 982        CURLPX_REPLY_GENERAL_SERVER_FAILURE,
 983        CURLPX_REPLY_NOT_ALLOWED,
 984        CURLPX_REPLY_NETWORK_UNREACHABLE,
 985        CURLPX_REPLY_HOST_UNREACHABLE,
 986        CURLPX_REPLY_CONNECTION_REFUSED,
 987        CURLPX_REPLY_TTL_EXPIRED,
 988        CURLPX_REPLY_COMMAND_NOT_SUPPORTED,
 989        CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED,
 990      };
 991      rc = lookup[code];
 992    }
 993    return rc;
 994  }
 995
 996  /* Calculate real packet size */
 997  switch(resp[3]) {
 998  case 1: /* IPv4 */
 999    resp_len = 4 + 4 + 2;
1000    break;
1001  case 3: /* domain name */
1002    resp_len = 4 + 1 + resp[4] + 2; /* header, var length, var bytes, port */
1003    break;
1004  case 4: /* IPv6 */
1005    resp_len = 4 + 16 + 2;
1006    break;
1007  default:
1008    failf(data, "SOCKS5 reply has wrong address type.");
1009    return CURLPX_BAD_ADDRESS_TYPE;
1010  }
1011
1012  /* receive the rest of the response */
1013  presult = socks_recv(sx, cf, data, resp_len, done);
1014  if(presult)
1015    return presult;
1016  else if(!*done)
1017    return CURLPX_OK;
1018
1019  if(!Curl_bufq_peek(&sx->iobuf, &resp, &rlen) || rlen < resp_len) {
1020    failf(data, "SOCKS5 response is incomplete.");
1021    return CURLPX_RECV_CONNECT;
1022  }
1023  /* got it all */
1024  *done = TRUE;
1025  return CURLPX_OK;
1026}
1027
1028/*
1029 * This function logs in to a SOCKS5 proxy and sends the specifics to the final
1030 * destination server.
1031 */
1032static CURLproxycode socks5_connect(struct Curl_cfilter *cf,
1033                                    struct socks_ctx *sx,
1034                                    struct Curl_easy *data)
1035{
1036  CURLproxycode presult;
1037  bool done;
1038
1039process_state:
1040  switch(sx->state) {
1041  case SOCKS_ST_INIT:
1042    sx->version = 5;
1043    sx->resolve_local = (sx->proxy_type == CURLPROXY_SOCKS5);
1044    sxstate(sx, cf, data, SOCKS5_ST_START);
1045    FALLTHROUGH();
1046
1047  case SOCKS5_ST_START:
1048    CURL_TRC_CF(data, cf, "SOCKS5: connecting to %s:%u",
1049                sx->dest->hostname, sx->dest->port);
1050    presult = socks5_req0_init(cf, sx, data);
1051    if(presult)
1052      return socks_failed(sx, cf, data, presult);
1053    sxstate(sx, cf, data, SOCKS5_ST_REQ0_SEND);
1054    FALLTHROUGH();
1055
1056  case SOCKS5_ST_REQ0_SEND:
1057    presult = socks_flush(sx, cf, data, &done);
1058    if(presult)
1059      return socks_failed(sx, cf, data, presult);
1060    else if(!done)
1061      return CURLPX_OK;
1062    /* done sending! */
1063    sxstate(sx, cf, data, SOCKS5_ST_RESP0_RECV);
1064    FALLTHROUGH();
1065
1066  case SOCKS5_ST_RESP0_RECV:
1067    presult = socks_recv(sx, cf, data, 2, &done);
1068    if(presult)
1069      return socks_failed(sx, cf, data, presult);
1070    else if(!done)
1071      return CURLPX_OK;
1072    presult = socks5_check_resp0(sx, cf, data);
1073    if(presult)
1074      return socks_failed(sx, cf, data, presult);
1075    /* socks5_check_resp0() sets next socks state */
1076    goto process_state;
1077
1078  case SOCKS5_ST_GSSAPI_INIT: {
1079#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
1080    /* GSSAPI stuff done non-blocking */
1081    CURLcode result = Curl_SOCKS5_gssapi_negotiate(cf, data, sx->creds);
1082    if(result) {
1083      failf(data, "Unable to negotiate SOCKS5 GSS-API context.");
1084      return CURLPX_GSSAPI;
1085    }
1086    sxstate(sx, cf, data, SOCKS5_ST_REQ1_INIT);
1087    goto process_state;
1088#else
1089    failf(data,
1090          "SOCKS5 GSSAPI per-message authentication is not supported.");
1091    return socks_failed(sx, cf, data, CURLPX_GSSAPI_PERMSG);
1092#endif
1093  }
1094
1095  case SOCKS5_ST_AUTH_INIT:
1096    presult = socks5_auth_init(cf, sx, data);
1097    if(presult)
1098      return socks_failed(sx, cf, data, presult);
1099    sxstate(sx, cf, data, SOCKS5_ST_AUTH_SEND);
1100    FALLTHROUGH();
1101
1102  case SOCKS5_ST_AUTH_SEND:
1103    presult = socks_flush(sx, cf, data, &done);
1104    if(presult)
1105      return socks_failed(sx, cf, data, presult);
1106    else if(!done)
1107      return CURLPX_OK;
1108    sxstate(sx, cf, data, SOCKS5_ST_AUTH_RECV);
1109    FALLTHROUGH();
1110
1111  case SOCKS5_ST_AUTH_RECV:
1112    presult = socks_recv(sx, cf, data, 2, &done);
1113    if(presult)
1114      return socks_failed(sx, cf, data, presult);
1115    else if(!done)
1116      return CURLPX_OK;
1117    presult = socks5_check_auth_resp(sx, cf, data);
1118    if(presult)
1119      return socks_failed(sx, cf, data, presult);
1120    /* Everything is good so far, user was authenticated! */
1121    sxstate(sx, cf, data, SOCKS5_ST_REQ1_INIT);
1122    FALLTHROUGH();
1123
1124  case SOCKS5_ST_REQ1_INIT:
1125    presult = socks5_req1_init(sx, cf, data);
1126    if(presult)
1127      return socks_failed(sx, cf, data, presult);
1128    if(!sx->resolve_local) {
1129      /* we do not resolve, request is complete */
1130      sxstate(sx, cf, data, SOCKS5_ST_REQ1_SEND);
1131      goto process_state;
1132    }
1133    sx->start_resolving = TRUE;
1134    sxstate(sx, cf, data, SOCKS5_ST_RESOLVING);
1135    FALLTHROUGH();
1136
1137  case SOCKS5_ST_RESOLVING:
1138    presult = socks5_resolving(sx, cf, data, &done);
1139    if(presult)
1140      return socks_failed(sx, cf, data, presult);
1141    if(!done)
1142      return CURLPX_OK;
1143    sxstate(sx, cf, data, SOCKS5_ST_REQ1_SEND);
1144    FALLTHROUGH();
1145
1146  case SOCKS5_ST_REQ1_SEND:
1147    presult = socks_flush(sx, cf, data, &done);
1148    if(presult)
1149      return socks_failed(sx, cf, data, presult);
1150    else if(!done)
1151      return CURLPX_OK;
1152#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
1153    if(cf->conn->socks5_gssapi_enctype) {
1154      failf(data, "SOCKS5 GSS-API protection not yet implemented.");
1155      return CURLPX_GSSAPI_PROTECTION;
1156    }
1157#endif
1158    sxstate(sx, cf, data, SOCKS5_ST_RESP1_RECV);
1159    FALLTHROUGH();
1160
1161  case SOCKS5_ST_RESP1_RECV:
1162    presult = socks5_recv_resp1(sx, cf, data, &done);
1163    if(presult)
1164      return socks_failed(sx, cf, data, presult);
1165    if(!done)
1166      return CURLPX_OK;
1167    CURL_TRC_CF(data, cf, "SOCKS5 request granted.");
1168    sxstate(sx, cf, data, SOCKS_ST_SUCCESS);
1169    FALLTHROUGH();
1170
1171  case SOCKS_ST_SUCCESS:
1172    return CURLPX_OK;
1173
1174  case SOCKS_ST_FAILED:
1175    DEBUGASSERT(sx->presult);
1176    return sx->presult;
1177
1178  default:
1179    DEBUGASSERT(0);
1180    return socks_failed(sx, cf, data, CURLPX_SEND_REQUEST);
1181  }
1182}
1183
1184static void socks_proxy_ctx_free(struct socks_ctx *ctx)
1185{
1186  if(ctx) {
1187    Curl_peer_unlink(&ctx->dest);
1188    Curl_creds_unlink(&ctx->creds);
1189    Curl_bufq_free(&ctx->iobuf);
1190    curlx_free(ctx);
1191  }
1192}
1193
1194/* After a TCP connection to the proxy has been verified, this function does
1195   the next magic steps. If 'done' is not set TRUE, it is not done yet and
1196   must be called again.
1197
1198   Note: this function's sub-functions call failf()
1199
1200*/
1201static CURLcode socks_proxy_cf_connect(struct Curl_cfilter *cf,
1202                                       struct Curl_easy *data,
1203                                       bool *done)
1204{
1205  struct socks_ctx *ctx = cf->ctx;
1206  CURLproxycode pxresult = CURLPX_OK;
1207  CURLcode result;
1208
1209  if(cf->connected) {
1210    *done = TRUE;
1211    return CURLE_OK;
1212  }
1213
1214  result = cf->next->cft->do_connect(cf->next, data, done);
1215  if(result || !*done)
1216    return result;
1217
1218  switch(ctx->proxy_type) {
1219  case CURLPROXY_SOCKS5:
1220  case CURLPROXY_SOCKS5_HOSTNAME:
1221    pxresult = socks5_connect(cf, ctx, data);
1222    break;
1223
1224  case CURLPROXY_SOCKS4:
1225  case CURLPROXY_SOCKS4A:
1226    pxresult = socks4_connect(cf, ctx, data);
1227    break;
1228
1229  default:
1230    DEBUGASSERT(0); /* should not come here, checked it at creation time */
1231    result = CURLE_COULDNT_CONNECT;
1232    goto out;
1233  }
1234
1235  if(pxresult) {
1236    result = CURLE_PROXY;
1237    data->info.pxcode = pxresult;
1238    goto out;
1239  }
1240  else if(ctx->state != SOCKS_ST_SUCCESS)
1241    goto out;
1242
1243#ifdef CURLVERBOSE
1244  if(Curl_trc_is_verbose(data)) {
1245    struct ip_quadruple ipquad;
1246    bool is_ipv6;
1247    if(!Curl_conn_cf_get_ip_info(cf->next, data, &is_ipv6, &ipquad))
1248      infof(data, "Opened %sSOCKS connection from %s port %d to %s port %d "
1249            "(via %s port %u)",
1250            (cf->sockindex == SECONDARYSOCKET) ? "2nd " : "",
1251            ipquad.local_ip, ipquad.local_port,
1252            ctx->dest->hostname, ctx->dest->port,
1253            ipquad.remote_ip, ipquad.remote_port);
1254    else
1255      infof(data, "Opened %sSOCKS connection",
1256            (cf->sockindex == SECONDARYSOCKET) ? "2nd " : "");
1257  }
1258#endif
1259  cf->connected = TRUE;
1260
1261out:
1262  *done = (bool)cf->connected;
1263  if(*done || result)
1264    Curl_creds_unlink(&ctx->creds);
1265  return result;
1266}
1267
1268static CURLcode socks_cf_adjust_pollset(struct Curl_cfilter *cf,
1269                                        struct Curl_easy *data,
1270                                        struct easy_pollset *ps)
1271{
1272  struct socks_ctx *sx = cf->ctx;
1273  CURLcode result = CURLE_OK;
1274
1275  if(!cf->connected && sx) {
1276    /* If we are not connected, the filter below is and has nothing
1277     * to wait on, we determine what to wait for. */
1278    curl_socket_t sock = Curl_conn_cf_get_socket(cf, data);
1279    switch(sx->state) {
1280    case SOCKS4_ST_SEND:
1281    case SOCKS5_ST_REQ0_SEND:
1282    case SOCKS5_ST_AUTH_SEND:
1283    case SOCKS5_ST_REQ1_SEND:
1284      CURL_TRC_CF(data, cf, "adjust pollset out (%d)", sx->state);
1285      result = Curl_pollset_set_out_only(data, ps, sock);
1286      break;
1287    default:
1288      CURL_TRC_CF(data, cf, "adjust pollset in (%d)", sx->state);
1289      result = Curl_pollset_set_in_only(data, ps, sock);
1290      break;
1291    }
1292  }
1293  return result;
1294}
1295
1296static void socks_proxy_cf_close(struct Curl_cfilter *cf,
1297                                 struct Curl_easy *data)
1298{
1299  cf->connected = FALSE;
1300  if(cf->next)
1301    cf->next->cft->do_close(cf->next, data);
1302}
1303
1304static void socks_proxy_cf_destroy(struct Curl_cfilter *cf,
1305                                   struct Curl_easy *data)
1306{
1307  (void)data;
1308  socks_proxy_ctx_free(cf->ctx);
1309  cf->ctx = NULL;
1310}
1311
1312static CURLcode socks_cf_query(struct Curl_cfilter *cf,
1313                               struct Curl_easy *data,
1314                               int query, int *pres1, void *pres2)
1315{
1316  struct socks_ctx *sx = cf->ctx;
1317
1318  switch(query) {
1319  case CF_QUERY_HOST_PORT:
1320    if(sx) {
1321      *pres1 = sx->dest->port;
1322      *((const char **)pres2) = sx->dest->hostname;
1323      return CURLE_OK;
1324    }
1325    break;
1326  case CF_QUERY_ALPN_NEGOTIATED: {
1327    const char **palpn = pres2;
1328    DEBUGASSERT(palpn);
1329    *palpn = NULL;
1330    return CURLE_OK;
1331  }
1332  default:
1333    break;
1334  }
1335  return cf->next ?
1336    cf->next->cft->query(cf->next, data, query, pres1, pres2) :
1337    CURLE_UNKNOWN_OPTION;
1338}
1339
1340struct Curl_cftype Curl_cft_socks_proxy = {
1341  "SOCKS",
1342  CF_TYPE_IP_CONNECT | CF_TYPE_PROXY,
1343  0,
1344  socks_proxy_cf_destroy,
1345  socks_proxy_cf_connect,
1346  socks_proxy_cf_close,
1347  Curl_cf_def_shutdown,
1348  socks_cf_adjust_pollset,
1349  Curl_cf_def_data_pending,
1350  Curl_cf_def_send,
1351  Curl_cf_def_recv,
1352  Curl_cf_def_cntrl,
1353  Curl_cf_def_conn_is_alive,
1354  Curl_cf_def_conn_keep_alive,
1355  socks_cf_query,
1356};
1357
1358CURLcode Curl_cf_socks_proxy_insert_after(struct Curl_cfilter *cf_at,
1359                                          struct Curl_easy *data,
1360                                          struct Curl_peer *dest,
1361                                          uint8_t ip_version,
1362                                          uint8_t proxy_type,
1363                                          struct Curl_creds *creds)
1364{
1365  struct Curl_cfilter *cf;
1366  struct socks_ctx *ctx;
1367  CURLcode result;
1368
1369  if(!dest)
1370    return CURLE_FAILED_INIT;
1371
1372  switch(proxy_type) {
1373  case CURLPROXY_SOCKS5:
1374  case CURLPROXY_SOCKS5_HOSTNAME:
1375  case CURLPROXY_SOCKS4:
1376  case CURLPROXY_SOCKS4A:
1377    break; /* all supported */
1378  default:
1379    failf(data, "unknown proxytype %d option given", proxy_type);
1380    return CURLE_COULDNT_CONNECT;
1381  }
1382
1383  /* NUL byte already part of struct size */
1384  ctx = curlx_calloc(1, sizeof(*ctx));
1385  if(!ctx) {
1386    return CURLE_OUT_OF_MEMORY;
1387  }
1388
1389  Curl_peer_link(&ctx->dest, dest);
1390  ctx->ip_version = ip_version;
1391  ctx->proxy_type = proxy_type;
1392  Curl_creds_link(&ctx->creds, creds);
1393  Curl_bufq_init2(&ctx->iobuf, SOCKS_CHUNK_SIZE, SOCKS_CHUNKS,
1394                  BUFQ_OPT_SOFT_LIMIT);
1395
1396  result = Curl_cf_create(&cf, &Curl_cft_socks_proxy, ctx);
1397  if(!result)
1398    Curl_conn_cf_insert_after(cf_at, cf);
1399  else
1400    socks_proxy_ctx_free(ctx);
1401  return result;
1402}
1403
1404#endif /* CURL_DISABLE_PROXY */