lib/url.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2017, 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.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 "curl_setup.h"
  24
  25 #ifdef HAVE_NETINET_IN_H
  26 #include <netinet/in.h>
  27 #endif
  28 #ifdef HAVE_NETDB_H
  29 #include <netdb.h>
  30 #endif
  31 #ifdef HAVE_ARPA_INET_H
  32 #include <arpa/inet.h>
  33 #endif
  34 #ifdef HAVE_NET_IF_H
  35 #include <net/if.h>
  36 #endif
  37 #ifdef HAVE_SYS_IOCTL_H
  38 #include <sys/ioctl.h>
  39 #endif
  40
  41 #ifdef HAVE_SYS_PARAM_H
  42 #include <sys/param.h>
  43 #endif
  44
  45 #ifdef __VMS
  46 #include <in.h>
  47 #include <inet.h>
  48 #endif
  49
  50 #ifdef HAVE_SYS_UN_H
  51 #include <sys/un.h>
  52 #endif
  53
  54 #ifndef HAVE_SOCKET
  55 #error "We can't compile without socket() support!"
  56 #endif
  57
  58 #ifdef HAVE_LIMITS_H
  59 #include <limits.h>
  60 #endif
  61
  62 #ifdef USE_LIBIDN2
  63 #include <idn2.h>
  64
  65 #elif defined(USE_WIN32_IDN)
  66 /* prototype for curl_win32_idn_to_ascii() */
  67 bool curl_win32_idn_to_ascii(const char *in, char **out);
  68 #endif  /* USE_LIBIDN2 */
  69
  70 #include "urldata.h"
  71 #include "netrc.h"
  72
  73 #include "formdata.h"
  74 #include "vtls/vtls.h"
  75 #include "hostip.h"
  76 #include "transfer.h"
  77 #include "sendf.h"
  78 #include "progress.h"
  79 #include "cookie.h"
  80 #include "strcase.h"
  81 #include "strerror.h"
  82 #include "escape.h"
  83 #include "strtok.h"
  84 #include "share.h"
  85 #include "content_encoding.h"
  86 #include "http_digest.h"
  87 #include "http_negotiate.h"
  88 #include "select.h"
  89 #include "multiif.h"
  90 #include "easyif.h"
  91 #include "speedcheck.h"
  92 #include "warnless.h"
  93 #include "non-ascii.h"
  94 #include "inet_pton.h"
  95 #include "getinfo.h"
  96
  97 /* And now for the protocols */
  98 #include "ftp.h"
  99 #include "dict.h"
 100 #include "telnet.h"
 101 #include "tftp.h"
 102 #include "http.h"
 103 #include "http2.h"
 104 #include "file.h"
 105 #include "curl_ldap.h"
 106 #include "ssh.h"
 107 #include "imap.h"
 108 #include "url.h"
 109 #include "connect.h"
 110 #include "inet_ntop.h"
 111 #include "http_ntlm.h"
 112 #include "curl_ntlm_wb.h"
 113 #include "socks.h"
 114 #include "curl_rtmp.h"
 115 #include "gopher.h"
 116 #include "http_proxy.h"
 117 #include "conncache.h"
 118 #include "multihandle.h"
 119 #include "pipeline.h"
 120 #include "dotdot.h"
 121 #include "strdup.h"
 122 /* The last 3 #include files should be in this order */
 123 #include "curl_printf.h"
 124 #include "curl_memory.h"
 125 #include "memdebug.h"
 126
 127 /* Local static prototypes */
 128 static struct connectdata *
 129 find_oldest_idle_connection_in_bundle(struct Curl_easy *data,
 130                                       struct connectbundle *bundle);
 131 static void conn_free(struct connectdata *conn);
 132 static void free_fixed_hostname(struct hostname *host);
 133 static void signalPipeClose(struct curl_llist *pipeline, bool pipe_broke);
 134 static CURLcode parse_url_login(struct Curl_easy *data,
 135                                 struct connectdata *conn,
 136                                 char **userptr, char **passwdptr,
 137                                 char **optionsptr);
 138 static CURLcode parse_login_details(const char *login, const size_t len,
 139                                     char **userptr, char **passwdptr,
 140                                     char **optionsptr);
 141 static unsigned int get_protocol_family(unsigned int protocol);
 142
 143 /*
 144  * Protocol table.
 145  */
 146
 147 static const struct Curl_handler * const protocols[] = {
 148
 149 #ifndef CURL_DISABLE_HTTP
 150   &Curl_handler_http,
 151 #endif
 152
 153 #if defined(USE_SSL) && !defined(CURL_DISABLE_HTTP)
 154   &Curl_handler_https,
 155 #endif
 156
 157 #ifndef CURL_DISABLE_FTP
 158   &Curl_handler_ftp,
 159 #endif
 160
 161 #if defined(USE_SSL) && !defined(CURL_DISABLE_FTP)
 162   &Curl_handler_ftps,
 163 #endif
 164
 165 #ifndef CURL_DISABLE_TELNET
 166   &Curl_handler_telnet,
 167 #endif
 168
 169 #ifndef CURL_DISABLE_DICT
 170   &Curl_handler_dict,
 171 #endif
 172
 173 #ifndef CURL_DISABLE_LDAP
 174   &Curl_handler_ldap,
 175 #if !defined(CURL_DISABLE_LDAPS) && \
 176     ((defined(USE_OPENLDAP) && defined(USE_SSL)) || \
 177      (!defined(USE_OPENLDAP) && defined(HAVE_LDAP_SSL)))
 178   &Curl_handler_ldaps,
 179 #endif
 180 #endif
 181
 182 #ifndef CURL_DISABLE_FILE
 183   &Curl_handler_file,
 184 #endif
 185
 186 #ifndef CURL_DISABLE_TFTP
 187   &Curl_handler_tftp,
 188 #endif
 189
 190 #ifdef USE_LIBSSH2
 191   &Curl_handler_scp,
 192   &Curl_handler_sftp,
 193 #endif
 194
 195 #ifndef CURL_DISABLE_IMAP
 196   &Curl_handler_imap,
 197 #ifdef USE_SSL
 198   &Curl_handler_imaps,
 199 #endif
 200 #endif
 201
 202 #ifndef CURL_DISABLE_POP3
 203   &Curl_handler_pop3,
 204 #ifdef USE_SSL
 205   &Curl_handler_pop3s,
 206 #endif
 207 #endif
 208
 209 #if !defined(CURL_DISABLE_SMB) && defined(USE_NTLM) && \
 210    (CURL_SIZEOF_CURL_OFF_T > 4) && \
 211    (!defined(USE_WINDOWS_SSPI) || defined(USE_WIN32_CRYPTO))
 212   &Curl_handler_smb,
 213 #ifdef USE_SSL
 214   &Curl_handler_smbs,
 215 #endif
 216 #endif
 217
 218 #ifndef CURL_DISABLE_SMTP
 219   &Curl_handler_smtp,
 220 #ifdef USE_SSL
 221   &Curl_handler_smtps,
 222 #endif
 223 #endif
 224
 225 #ifndef CURL_DISABLE_RTSP
 226   &Curl_handler_rtsp,
 227 #endif
 228
 229 #ifndef CURL_DISABLE_GOPHER
 230   &Curl_handler_gopher,
 231 #endif
 232
 233 #ifdef USE_LIBRTMP
 234   &Curl_handler_rtmp,
 235   &Curl_handler_rtmpt,
 236   &Curl_handler_rtmpe,
 237   &Curl_handler_rtmpte,
 238   &Curl_handler_rtmps,
 239   &Curl_handler_rtmpts,
 240 #endif
 241
 242   (struct Curl_handler *) NULL
 243 };
 244
 245 /*
 246  * Dummy handler for undefined protocol schemes.
 247  */
 248
 249 static const struct Curl_handler Curl_handler_dummy = {
 250   "<no protocol>",                      /* scheme */
 251   ZERO_NULL,                            /* setup_connection */
 252   ZERO_NULL,                            /* do_it */
 253   ZERO_NULL,                            /* done */
 254   ZERO_NULL,                            /* do_more */
 255   ZERO_NULL,                            /* connect_it */
 256   ZERO_NULL,                            /* connecting */
 257   ZERO_NULL,                            /* doing */
 258   ZERO_NULL,                            /* proto_getsock */
 259   ZERO_NULL,                            /* doing_getsock */
 260   ZERO_NULL,                            /* domore_getsock */
 261   ZERO_NULL,                            /* perform_getsock */
 262   ZERO_NULL,                            /* disconnect */
 263   ZERO_NULL,                            /* readwrite */
 264   0,                                    /* defport */
 265   0,                                    /* protocol */
 266   PROTOPT_NONE                          /* flags */
 267 };
 268
 269 void Curl_freeset(struct Curl_easy *data)
 270 {
 271   /* Free all dynamic strings stored in the data->set substructure. */
 272   enum dupstring i;
 273   for(i=(enum dupstring)0; i < STRING_LAST; i++) {
 274     Curl_safefree(data->set.str[i]);
 275   }
 276
 277   if(data->change.referer_alloc) {
 278     Curl_safefree(data->change.referer);
 279     data->change.referer_alloc = FALSE;
 280   }
 281   data->change.referer = NULL;
 282   if(data->change.url_alloc) {
 283     Curl_safefree(data->change.url);
 284     data->change.url_alloc = FALSE;
 285   }
 286   data->change.url = NULL;
 287 }
 288
 289 static CURLcode setstropt(char **charp, const char *s)
 290 {
 291   /* Release the previous storage at `charp' and replace by a dynamic storage
 292      copy of `s'. Return CURLE_OK or CURLE_OUT_OF_MEMORY. */
 293
 294   Curl_safefree(*charp);
 295
 296   if(s) {
 297     char *str = strdup(s);
 298
 299     if(!str)
 300       return CURLE_OUT_OF_MEMORY;
 301
 302     *charp = str;
 303   }
 304
 305   return CURLE_OK;
 306 }
 307
 308 static CURLcode setstropt_userpwd(char *option, char **userp, char **passwdp)
 309 {
 310   CURLcode result = CURLE_OK;
 311   char *user = NULL;
 312   char *passwd = NULL;
 313
 314   /* Parse the login details if specified. It not then we treat NULL as a hint
 315      to clear the existing data */
 316   if(option) {
 317     result = parse_login_details(option, strlen(option),
 318                                  (userp ? &user : NULL),
 319                                  (passwdp ? &passwd : NULL),
 320                                  NULL);
 321   }
 322
 323   if(!result) {
 324     /* Store the username part of option if required */
 325     if(userp) {
 326       if(!user && option && option[0] == ':') {
 327         /* Allocate an empty string instead of returning NULL as user name */
 328         user = strdup("");
 329         if(!user)
 330           result = CURLE_OUT_OF_MEMORY;
 331       }
 332
 333       Curl_safefree(*userp);
 334       *userp = user;
 335     }
 336
 337     /* Store the password part of option if required */
 338     if(passwdp) {
 339       Curl_safefree(*passwdp);
 340       *passwdp = passwd;
 341     }
 342   }
 343
 344   return result;
 345 }
 346
 347 CURLcode Curl_dupset(struct Curl_easy *dst, struct Curl_easy *src)
 348 {
 349   CURLcode result = CURLE_OK;
 350   enum dupstring i;
 351
 352   /* Copy src->set into dst->set first, then deal with the strings
 353      afterwards */
 354   dst->set = src->set;
 355
 356   /* clear all string pointers first */
 357   memset(dst->set.str, 0, STRING_LAST * sizeof(char *));
 358
 359   /* duplicate all strings */
 360   for(i=(enum dupstring)0; i< STRING_LASTZEROTERMINATED; i++) {
 361     result = setstropt(&dst->set.str[i], src->set.str[i]);
 362     if(result)
 363       return result;
 364   }
 365
 366   /* duplicate memory areas pointed to */
 367   i = STRING_COPYPOSTFIELDS;
 368   if(src->set.postfieldsize && src->set.str[i]) {
 369     /* postfieldsize is curl_off_t, Curl_memdup() takes a size_t ... */
 370     dst->set.str[i] = Curl_memdup(src->set.str[i],
 371                                   curlx_sotouz(src->set.postfieldsize));
 372     if(!dst->set.str[i])
 373       return CURLE_OUT_OF_MEMORY;
 374     /* point to the new copy */
 375     dst->set.postfields = dst->set.str[i];
 376   }
 377
 378   return CURLE_OK;
 379 }
 380
 381 /*
 382  * This is the internal function curl_easy_cleanup() calls. This should
 383  * cleanup and free all resources associated with this sessionhandle.
 384  *
 385  * NOTE: if we ever add something that attempts to write to a socket or
 386  * similar here, we must ignore SIGPIPE first. It is currently only done
 387  * when curl_easy_perform() is invoked.
 388  */
 389
 390 CURLcode Curl_close(struct Curl_easy *data)
 391 {
 392   struct Curl_multi *m;
 393
 394   if(!data)
 395     return CURLE_OK;
 396
 397   Curl_expire_clear(data); /* shut off timers */
 398
 399   m = data->multi;
 400
 401   if(m)
 402     /* This handle is still part of a multi handle, take care of this first
 403        and detach this handle from there. */
 404     curl_multi_remove_handle(data->multi, data);
 405
 406   if(data->multi_easy)
 407     /* when curl_easy_perform() is used, it creates its own multi handle to
 408        use and this is the one */
 409     curl_multi_cleanup(data->multi_easy);
 410
 411   /* Destroy the timeout list that is held in the easy handle. It is
 412      /normally/ done by curl_multi_remove_handle() but this is "just in
 413      case" */
 414   if(data->state.timeoutlist) {
 415     Curl_llist_destroy(data->state.timeoutlist, NULL);
 416     data->state.timeoutlist = NULL;
 417   }
 418
 419   data->magic = 0; /* force a clear AFTER the possibly enforced removal from
 420                       the multi handle, since that function uses the magic
 421                       field! */
 422
 423   if(data->state.rangestringalloc)
 424     free(data->state.range);
 425
 426   /* Free the pathbuffer */
 427   Curl_safefree(data->state.pathbuffer);
 428   data->state.path = NULL;
 429
 430   /* freed here just in case DONE wasn't called */
 431   Curl_free_request_state(data);
 432
 433   /* Close down all open SSL info and sessions */
 434   Curl_ssl_close_all(data);
 435   Curl_safefree(data->state.first_host);
 436   Curl_safefree(data->state.scratch);
 437   Curl_ssl_free_certinfo(data);
 438
 439   /* Cleanup possible redirect junk */
 440   free(data->req.newurl);
 441   data->req.newurl = NULL;
 442
 443   if(data->change.referer_alloc) {
 444     Curl_safefree(data->change.referer);
 445     data->change.referer_alloc = FALSE;
 446   }
 447   data->change.referer = NULL;
 448
 449   if(data->change.url_alloc) {
 450     Curl_safefree(data->change.url);
 451     data->change.url_alloc = FALSE;
 452   }
 453   data->change.url = NULL;
 454
 455   Curl_safefree(data->state.buffer);
 456   Curl_safefree(data->state.headerbuff);
 457
 458   Curl_flush_cookies(data, 1);
 459
 460   Curl_digest_cleanup(data);
 461
 462   Curl_safefree(data->info.contenttype);
 463   Curl_safefree(data->info.wouldredirect);
 464
 465   /* this destroys the channel and we cannot use it anymore after this */
 466   Curl_resolver_cleanup(data->state.resolver);
 467
 468   Curl_http2_cleanup_dependencies(data);
 469   Curl_convert_close(data);
 470
 471   /* No longer a dirty share, if it exists */
 472   if(data->share) {
 473     Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
 474     data->share->dirty--;
 475     Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
 476   }
 477
 478   if(data->set.wildcardmatch) {
 479     /* destruct wildcard structures if it is needed */
 480     struct WildcardData *wc = &data->wildcard;
 481     Curl_wildcard_dtor(wc);
 482   }
 483
 484   Curl_freeset(data);
 485   free(data);
 486   return CURLE_OK;
 487 }
 488
 489 /*
 490  * Initialize the UserDefined fields within a Curl_easy.
 491  * This may be safely called on a new or existing Curl_easy.
 492  */
 493 CURLcode Curl_init_userdefined(struct UserDefined *set)
 494 {
 495   CURLcode result = CURLE_OK;
 496
 497   set->out = stdout; /* default output to stdout */
 498   set->in_set = stdin;  /* default input from stdin */
 499   set->err  = stderr;  /* default stderr to stderr */
 500
 501   /* use fwrite as default function to store output */
 502   set->fwrite_func = (curl_write_callback)fwrite;
 503
 504   /* use fread as default function to read input */
 505   set->fread_func_set = (curl_read_callback)fread;
 506   set->is_fread_set = 0;
 507   set->is_fwrite_set = 0;
 508
 509   set->seek_func = ZERO_NULL;
 510   set->seek_client = ZERO_NULL;
 511
 512   /* conversion callbacks for non-ASCII hosts */
 513   set->convfromnetwork = ZERO_NULL;
 514   set->convtonetwork   = ZERO_NULL;
 515   set->convfromutf8    = ZERO_NULL;
 516
 517   set->filesize = -1;        /* we don't know the size */
 518   set->postfieldsize = -1;   /* unknown size */
 519   set->maxredirs = -1;       /* allow any amount by default */
 520
 521   set->httpreq = HTTPREQ_GET; /* Default HTTP request */
 522   set->rtspreq = RTSPREQ_OPTIONS; /* Default RTSP request */
 523   set->ftp_use_epsv = TRUE;   /* FTP defaults to EPSV operations */
 524   set->ftp_use_eprt = TRUE;   /* FTP defaults to EPRT operations */
 525   set->ftp_use_pret = FALSE;  /* mainly useful for drftpd servers */
 526   set->ftp_filemethod = FTPFILE_MULTICWD;
 527
 528   set->dns_cache_timeout = 60; /* Timeout every 60 seconds by default */
 529
 530   /* Set the default size of the SSL session ID cache */
 531   set->general_ssl.max_ssl_sessions = 5;
 532
 533   set->proxyport = 0;
 534   set->proxytype = CURLPROXY_HTTP; /* defaults to HTTP proxy */
 535   set->httpauth = CURLAUTH_BASIC;  /* defaults to basic */
 536   set->proxyauth = CURLAUTH_BASIC; /* defaults to basic */
 537
 538   /* make libcurl quiet by default: */
 539   set->hide_progress = TRUE;  /* CURLOPT_NOPROGRESS changes these */
 540
 541   /*
 542    * libcurl 7.10 introduced SSL verification *by default*! This needs to be
 543    * switched off unless wanted.
 544    */
 545   set->ssl.primary.verifypeer = TRUE;
 546   set->ssl.primary.verifyhost = TRUE;
 547 #ifdef USE_TLS_SRP
 548   set->ssl.authtype = CURL_TLSAUTH_NONE;
 549 #endif
 550   set->ssh_auth_types = CURLSSH_AUTH_DEFAULT; /* defaults to any auth
 551                                                       type */
 552   set->ssl.primary.sessionid = TRUE; /* session ID caching enabled by
 553                                         default */
 554   set->proxy_ssl = set->ssl;
 555
 556   set->new_file_perms = 0644;    /* Default permissions */
 557   set->new_directory_perms = 0755; /* Default permissions */
 558
 559   /* for the *protocols fields we don't use the CURLPROTO_ALL convenience
 560      define since we internally only use the lower 16 bits for the passed
 561      in bitmask to not conflict with the private bits */
 562   set->allowed_protocols = CURLPROTO_ALL;
 563   set->redir_protocols = CURLPROTO_ALL &  /* All except FILE, SCP and SMB */
 564                           ~(CURLPROTO_FILE | CURLPROTO_SCP | CURLPROTO_SMB |
 565                             CURLPROTO_SMBS);
 566
 567 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 568   /*
 569    * disallow unprotected protection negotiation NEC reference implementation
 570    * seem not to follow rfc1961 section 4.3/4.4
 571    */
 572   set->socks5_gssapi_nec = FALSE;
 573 #endif
 574
 575   /* This is our preferred CA cert bundle/path since install time */
 576 #if defined(CURL_CA_BUNDLE)
 577   result = setstropt(&set->str[STRING_SSL_CAFILE_ORIG], CURL_CA_BUNDLE);
 578   if(result)
 579     return result;
 580
 581   result = setstropt(&set->str[STRING_SSL_CAFILE_PROXY], CURL_CA_BUNDLE);
 582   if(result)
 583     return result;
 584 #endif
 585 #if defined(CURL_CA_PATH)
 586   result = setstropt(&set->str[STRING_SSL_CAPATH_ORIG], CURL_CA_PATH);
 587   if(result)
 588     return result;
 589
 590   result = setstropt(&set->str[STRING_SSL_CAPATH_PROXY], CURL_CA_PATH);
 591   if(result)
 592     return result;
 593 #endif
 594
 595   set->wildcardmatch  = FALSE;
 596   set->chunk_bgn      = ZERO_NULL;
 597   set->chunk_end      = ZERO_NULL;
 598
 599   /* tcp keepalives are disabled by default, but provide reasonable values for
 600    * the interval and idle times.
 601    */
 602   set->tcp_keepalive = FALSE;
 603   set->tcp_keepintvl = 60;
 604   set->tcp_keepidle = 60;
 605   set->tcp_fastopen = FALSE;
 606   set->tcp_nodelay = TRUE;
 607
 608   set->ssl_enable_npn = TRUE;
 609   set->ssl_enable_alpn = TRUE;
 610
 611   set->expect_100_timeout = 1000L; /* Wait for a second by default. */
 612   set->sep_headers = TRUE; /* separated header lists by default */
 613
 614   Curl_http2_init_userset(set);
 615   return result;
 616 }
 617
 618 /**
 619  * Curl_open()
 620  *
 621  * @param curl is a pointer to a sessionhandle pointer that gets set by this
 622  * function.
 623  * @return CURLcode
 624  */
 625
 626 CURLcode Curl_open(struct Curl_easy **curl)
 627 {
 628   CURLcode result;
 629   struct Curl_easy *data;
 630
 631   /* Very simple start-up: alloc the struct, init it with zeroes and return */
 632   data = calloc(1, sizeof(struct Curl_easy));
 633   if(!data) {
 634     /* this is a very serious error */
 635     DEBUGF(fprintf(stderr, "Error: calloc of Curl_easy failed\n"));
 636     return CURLE_OUT_OF_MEMORY;
 637   }
 638
 639   data->magic = CURLEASY_MAGIC_NUMBER;
 640
 641   result = Curl_resolver_init(&data->state.resolver);
 642   if(result) {
 643     DEBUGF(fprintf(stderr, "Error: resolver_init failed\n"));
 644     free(data);
 645     return result;
 646   }
 647
 648   /* We do some initial setup here, all those fields that can't be just 0 */
 649
 650   data->state.buffer = malloc(BUFSIZE + 1);
 651   if(!data->state.buffer) {
 652     DEBUGF(fprintf(stderr, "Error: malloc of buffer failed\n"));
 653     result = CURLE_OUT_OF_MEMORY;
 654   }
 655
 656   data->state.headerbuff = malloc(HEADERSIZE);
 657   if(!data->state.headerbuff) {
 658     DEBUGF(fprintf(stderr, "Error: malloc of headerbuff failed\n"));
 659     result = CURLE_OUT_OF_MEMORY;
 660   }
 661   else {
 662     result = Curl_init_userdefined(&data->set);
 663
 664     data->state.headersize=HEADERSIZE;
 665
 666     Curl_convert_init(data);
 667
 668     Curl_initinfo(data);
 669
 670     /* most recent connection is not yet defined */
 671     data->state.lastconnect = NULL;
 672
 673     data->progress.flags |= PGRS_HIDE;
 674     data->state.current_speed = -1; /* init to negative == impossible */
 675
 676     data->wildcard.state = CURLWC_INIT;
 677     data->wildcard.filelist = NULL;
 678     data->set.fnmatch = ZERO_NULL;
 679     data->set.maxconnects = DEFAULT_CONNCACHE_SIZE; /* for easy handles */
 680
 681     Curl_http2_init_state(&data->state);
 682   }
 683
 684   if(result) {
 685     Curl_resolver_cleanup(data->state.resolver);
 686     free(data->state.buffer);
 687     free(data->state.headerbuff);
 688     Curl_freeset(data);
 689     free(data);
 690     data = NULL;
 691   }
 692   else
 693     *curl = data;
 694
 695   return result;
 696 }
 697
 698 CURLcode Curl_setopt(struct Curl_easy *data, CURLoption option,
 699                      va_list param)
 700 {
 701   char *argptr;
 702   CURLcode result = CURLE_OK;
 703   long arg;
 704 #ifndef CURL_DISABLE_HTTP
 705   curl_off_t bigsize;
 706 #endif
 707
 708   switch(option) {
 709   case CURLOPT_DNS_CACHE_TIMEOUT:
 710     data->set.dns_cache_timeout = va_arg(param, long);
 711     break;
 712   case CURLOPT_DNS_USE_GLOBAL_CACHE:
 713     /* remember we want this enabled */
 714     arg = va_arg(param, long);
 715     data->set.global_dns_cache = (0 != arg) ? TRUE : FALSE;
 716     break;
 717   case CURLOPT_SSL_CIPHER_LIST:
 718     /* set a list of cipher we want to use in the SSL connection */
 719     result = setstropt(&data->set.str[STRING_SSL_CIPHER_LIST_ORIG],
 720                        va_arg(param, char *));
 721     break;
 722   case CURLOPT_PROXY_SSL_CIPHER_LIST:
 723     /* set a list of cipher we want to use in the SSL connection for proxy */
 724     result = setstropt(&data->set.str[STRING_SSL_CIPHER_LIST_PROXY],
 725                        va_arg(param, char *));
 726     break;
 727
 728   case CURLOPT_RANDOM_FILE:
 729     /*
 730      * This is the path name to a file that contains random data to seed
 731      * the random SSL stuff with. The file is only used for reading.
 732      */
 733     result = setstropt(&data->set.str[STRING_SSL_RANDOM_FILE],
 734                        va_arg(param, char *));
 735     break;
 736   case CURLOPT_EGDSOCKET:
 737     /*
 738      * The Entropy Gathering Daemon socket pathname
 739      */
 740     result = setstropt(&data->set.str[STRING_SSL_EGDSOCKET],
 741                        va_arg(param, char *));
 742     break;
 743   case CURLOPT_MAXCONNECTS:
 744     /*
 745      * Set the absolute number of maximum simultaneous alive connection that
 746      * libcurl is allowed to have.
 747      */
 748     data->set.maxconnects = va_arg(param, long);
 749     break;
 750   case CURLOPT_FORBID_REUSE:
 751     /*
 752      * When this transfer is done, it must not be left to be reused by a
 753      * subsequent transfer but shall be closed immediately.
 754      */
 755     data->set.reuse_forbid = (0 != va_arg(param, long)) ? TRUE : FALSE;
 756     break;
 757   case CURLOPT_FRESH_CONNECT:
 758     /*
 759      * This transfer shall not use a previously cached connection but
 760      * should be made with a fresh new connect!
 761      */
 762     data->set.reuse_fresh = (0 != va_arg(param, long)) ? TRUE : FALSE;
 763     break;
 764   case CURLOPT_VERBOSE:
 765     /*
 766      * Verbose means infof() calls that give a lot of information about
 767      * the connection and transfer procedures as well as internal choices.
 768      */
 769     data->set.verbose = (0 != va_arg(param, long)) ? TRUE : FALSE;
 770     break;
 771   case CURLOPT_HEADER:
 772     /*
 773      * Set to include the header in the general data output stream.
 774      */
 775     data->set.include_header = (0 != va_arg(param, long)) ? TRUE : FALSE;
 776     break;
 777   case CURLOPT_NOPROGRESS:
 778     /*
 779      * Shut off the internal supported progress meter
 780      */
 781     data->set.hide_progress = (0 != va_arg(param, long)) ? TRUE : FALSE;
 782     if(data->set.hide_progress)
 783       data->progress.flags |= PGRS_HIDE;
 784     else
 785       data->progress.flags &= ~PGRS_HIDE;
 786     break;
 787   case CURLOPT_NOBODY:
 788     /*
 789      * Do not include the body part in the output data stream.
 790      */
 791     data->set.opt_no_body = (0 != va_arg(param, long)) ? TRUE : FALSE;
 792     break;
 793   case CURLOPT_FAILONERROR:
 794     /*
 795      * Don't output the >=400 error code HTML-page, but instead only
 796      * return error.
 797      */
 798     data->set.http_fail_on_error = (0 != va_arg(param, long)) ? TRUE : FALSE;
 799     break;
 800   case CURLOPT_KEEP_SENDING_ON_ERROR:
 801     data->set.http_keep_sending_on_error = (0 != va_arg(param, long)) ?
 802                                            TRUE : FALSE;
 803     break;
 804   case CURLOPT_UPLOAD:
 805   case CURLOPT_PUT:
 806     /*
 807      * We want to sent data to the remote host. If this is HTTP, that equals
 808      * using the PUT request.
 809      */
 810     data->set.upload = (0 != va_arg(param, long)) ? TRUE : FALSE;
 811     if(data->set.upload) {
 812       /* If this is HTTP, PUT is what's needed to "upload" */
 813       data->set.httpreq = HTTPREQ_PUT;
 814       data->set.opt_no_body = FALSE; /* this is implied */
 815     }
 816     else
 817       /* In HTTP, the opposite of upload is GET (unless NOBODY is true as
 818          then this can be changed to HEAD later on) */
 819       data->set.httpreq = HTTPREQ_GET;
 820     break;
 821   case CURLOPT_FILETIME:
 822     /*
 823      * Try to get the file time of the remote document. The time will
 824      * later (possibly) become available using curl_easy_getinfo().
 825      */
 826     data->set.get_filetime = (0 != va_arg(param, long)) ? TRUE : FALSE;
 827     break;
 828   case CURLOPT_FTP_CREATE_MISSING_DIRS:
 829     /*
 830      * An FTP option that modifies an upload to create missing directories on
 831      * the server.
 832      */
 833     switch(va_arg(param, long)) {
 834     case 0:
 835       data->set.ftp_create_missing_dirs = 0;
 836       break;
 837     case 1:
 838       data->set.ftp_create_missing_dirs = 1;
 839       break;
 840     case 2:
 841       data->set.ftp_create_missing_dirs = 2;
 842       break;
 843     default:
 844       /* reserve other values for future use */
 845       result = CURLE_UNKNOWN_OPTION;
 846       break;
 847     }
 848     break;
 849   case CURLOPT_SERVER_RESPONSE_TIMEOUT:
 850     /*
 851      * Option that specifies how quickly an server response must be obtained
 852      * before it is considered failure. For pingpong protocols.
 853      */
 854     data->set.server_response_timeout = va_arg(param, long) * 1000;
 855     break;
 856   case CURLOPT_TFTP_NO_OPTIONS:
 857     /*
 858      * Option that prevents libcurl from sending TFTP option requests to the
 859      * server.
 860      */
 861     data->set.tftp_no_options = va_arg(param, long) != 0;
 862     break;
 863   case CURLOPT_TFTP_BLKSIZE:
 864     /*
 865      * TFTP option that specifies the block size to use for data transmission.
 866      */
 867     data->set.tftp_blksize = va_arg(param, long);
 868     break;
 869   case CURLOPT_DIRLISTONLY:
 870     /*
 871      * An option that changes the command to one that asks for a list
 872      * only, no file info details.
 873      */
 874     data->set.ftp_list_only = (0 != va_arg(param, long)) ? TRUE : FALSE;
 875     break;
 876   case CURLOPT_APPEND:
 877     /*
 878      * We want to upload and append to an existing file.
 879      */
 880     data->set.ftp_append = (0 != va_arg(param, long)) ? TRUE : FALSE;
 881     break;
 882   case CURLOPT_FTP_FILEMETHOD:
 883     /*
 884      * How do access files over FTP.
 885      */
 886     data->set.ftp_filemethod = (curl_ftpfile)va_arg(param, long);
 887     break;
 888   case CURLOPT_NETRC:
 889     /*
 890      * Parse the $HOME/.netrc file
 891      */
 892     data->set.use_netrc = (enum CURL_NETRC_OPTION)va_arg(param, long);
 893     break;
 894   case CURLOPT_NETRC_FILE:
 895     /*
 896      * Use this file instead of the $HOME/.netrc file
 897      */
 898     result = setstropt(&data->set.str[STRING_NETRC_FILE],
 899                        va_arg(param, char *));
 900     break;
 901   case CURLOPT_TRANSFERTEXT:
 902     /*
 903      * This option was previously named 'FTPASCII'. Renamed to work with
 904      * more protocols than merely FTP.
 905      *
 906      * Transfer using ASCII (instead of BINARY).
 907      */
 908     data->set.prefer_ascii = (0 != va_arg(param, long)) ? TRUE : FALSE;
 909     break;
 910   case CURLOPT_TIMECONDITION:
 911     /*
 912      * Set HTTP time condition. This must be one of the defines in the
 913      * curl/curl.h header file.
 914      */
 915     data->set.timecondition = (curl_TimeCond)va_arg(param, long);
 916     break;
 917   case CURLOPT_TIMEVALUE:
 918     /*
 919      * This is the value to compare with the remote document with the
 920      * method set with CURLOPT_TIMECONDITION
 921      */
 922     data->set.timevalue = (time_t)va_arg(param, long);
 923     break;
 924   case CURLOPT_SSLVERSION:
 925     /*
 926      * Set explicit SSL version to try to connect with, as some SSL
 927      * implementations are lame.
 928      */
 929 #ifdef USE_SSL
 930     data->set.ssl.primary.version = va_arg(param, long);
 931 #else
 932     result = CURLE_UNKNOWN_OPTION;
 933 #endif
 934     break;
 935   case CURLOPT_PROXY_SSLVERSION:
 936     /*
 937      * Set explicit SSL version to try to connect with for proxy, as some SSL
 938      * implementations are lame.
 939      */
 940 #ifdef USE_SSL
 941     data->set.proxy_ssl.primary.version = va_arg(param, long);
 942 #else
 943     result = CURLE_UNKNOWN_OPTION;
 944 #endif
 945     break;
 946
 947 #ifndef CURL_DISABLE_HTTP
 948   case CURLOPT_AUTOREFERER:
 949     /*
 950      * Switch on automatic referer that gets set if curl follows locations.
 951      */
 952     data->set.http_auto_referer = (0 != va_arg(param, long)) ? TRUE : FALSE;
 953     break;
 954
 955   case CURLOPT_ACCEPT_ENCODING:
 956     /*
 957      * String to use at the value of Accept-Encoding header.
 958      *
 959      * If the encoding is set to "" we use an Accept-Encoding header that
 960      * encompasses all the encodings we support.
 961      * If the encoding is set to NULL we don't send an Accept-Encoding header
 962      * and ignore an received Content-Encoding header.
 963      *
 964      */
 965     argptr = va_arg(param, char *);
 966     result = setstropt(&data->set.str[STRING_ENCODING],
 967                        (argptr && !*argptr)?
 968                        ALL_CONTENT_ENCODINGS: argptr);
 969     break;
 970
 971   case CURLOPT_TRANSFER_ENCODING:
 972     data->set.http_transfer_encoding = (0 != va_arg(param, long)) ?
 973                                        TRUE : FALSE;
 974     break;
 975
 976   case CURLOPT_FOLLOWLOCATION:
 977     /*
 978      * Follow Location: header hints on a HTTP-server.
 979      */
 980     data->set.http_follow_location = (0 != va_arg(param, long)) ? TRUE : FALSE;
 981     break;
 982
 983   case CURLOPT_UNRESTRICTED_AUTH:
 984     /*
 985      * Send authentication (user+password) when following locations, even when
 986      * hostname changed.
 987      */
 988     data->set.http_disable_hostname_check_before_authentication =
 989       (0 != va_arg(param, long)) ? TRUE : FALSE;
 990     break;
 991
 992   case CURLOPT_MAXREDIRS:
 993     /*
 994      * The maximum amount of hops you allow curl to follow Location:
 995      * headers. This should mostly be used to detect never-ending loops.
 996      */
 997     data->set.maxredirs = va_arg(param, long);
 998     break;
 999
1000   case CURLOPT_POSTREDIR:
1001   {
1002     /*
1003      * Set the behaviour of POST when redirecting
1004      * CURL_REDIR_GET_ALL - POST is changed to GET after 301 and 302
1005      * CURL_REDIR_POST_301 - POST is kept as POST after 301
1006      * CURL_REDIR_POST_302 - POST is kept as POST after 302
1007      * CURL_REDIR_POST_303 - POST is kept as POST after 303
1008      * CURL_REDIR_POST_ALL - POST is kept as POST after 301, 302 and 303
1009      * other - POST is kept as POST after 301 and 302
1010      */
1011     int postRedir = curlx_sltosi(va_arg(param, long));
1012     data->set.keep_post = postRedir & CURL_REDIR_POST_ALL;
1013   }
1014   break;
1015
1016   case CURLOPT_POST:
1017     /* Does this option serve a purpose anymore? Yes it does, when
1018        CURLOPT_POSTFIELDS isn't used and the POST data is read off the
1019        callback! */
1020     if(va_arg(param, long)) {
1021       data->set.httpreq = HTTPREQ_POST;
1022       data->set.opt_no_body = FALSE; /* this is implied */
1023     }
1024     else
1025       data->set.httpreq = HTTPREQ_GET;
1026     break;
1027
1028   case CURLOPT_COPYPOSTFIELDS:
1029     /*
1030      * A string with POST data. Makes curl HTTP POST. Even if it is NULL.
1031      * If needed, CURLOPT_POSTFIELDSIZE must have been set prior to
1032      *  CURLOPT_COPYPOSTFIELDS and not altered later.
1033      */
1034     argptr = va_arg(param, char *);
1035
1036     if(!argptr || data->set.postfieldsize == -1)
1037       result = setstropt(&data->set.str[STRING_COPYPOSTFIELDS], argptr);
1038     else {
1039       /*
1040        *  Check that requested length does not overflow the size_t type.
1041        */
1042
1043       if((data->set.postfieldsize < 0) ||
1044          ((sizeof(curl_off_t) != sizeof(size_t)) &&
1045           (data->set.postfieldsize > (curl_off_t)((size_t)-1))))
1046         result = CURLE_OUT_OF_MEMORY;
1047       else {
1048         char *p;
1049
1050         (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
1051
1052         /* Allocate even when size == 0. This satisfies the need of possible
1053            later address compare to detect the COPYPOSTFIELDS mode, and
1054            to mark that postfields is used rather than read function or
1055            form data.
1056         */
1057         p = malloc((size_t)(data->set.postfieldsize?
1058                             data->set.postfieldsize:1));
1059
1060         if(!p)
1061           result = CURLE_OUT_OF_MEMORY;
1062         else {
1063           if(data->set.postfieldsize)
1064             memcpy(p, argptr, (size_t)data->set.postfieldsize);
1065
1066           data->set.str[STRING_COPYPOSTFIELDS] = p;
1067         }
1068       }
1069     }
1070
1071     data->set.postfields = data->set.str[STRING_COPYPOSTFIELDS];
1072     data->set.httpreq = HTTPREQ_POST;
1073     break;
1074
1075   case CURLOPT_POSTFIELDS:
1076     /*
1077      * Like above, but use static data instead of copying it.
1078      */
1079     data->set.postfields = va_arg(param, void *);
1080     /* Release old copied data. */
1081     (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
1082     data->set.httpreq = HTTPREQ_POST;
1083     break;
1084
1085   case CURLOPT_POSTFIELDSIZE:
1086     /*
1087      * The size of the POSTFIELD data to prevent libcurl to do strlen() to
1088      * figure it out. Enables binary posts.
1089      */
1090     bigsize = va_arg(param, long);
1091
1092     if(data->set.postfieldsize < bigsize &&
1093        data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
1094       /* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */
1095       (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
1096       data->set.postfields = NULL;
1097     }
1098
1099     data->set.postfieldsize = bigsize;
1100     break;
1101
1102   case CURLOPT_POSTFIELDSIZE_LARGE:
1103     /*
1104      * The size of the POSTFIELD data to prevent libcurl to do strlen() to
1105      * figure it out. Enables binary posts.
1106      */
1107     bigsize = va_arg(param, curl_off_t);
1108
1109     if(data->set.postfieldsize < bigsize &&
1110        data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
1111       /* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */
1112       (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
1113       data->set.postfields = NULL;
1114     }
1115
1116     data->set.postfieldsize = bigsize;
1117     break;
1118
1119   case CURLOPT_HTTPPOST:
1120     /*
1121      * Set to make us do HTTP POST
1122      */
1123     data->set.httppost = va_arg(param, struct curl_httppost *);
1124     data->set.httpreq = HTTPREQ_POST_FORM;
1125     data->set.opt_no_body = FALSE; /* this is implied */
1126     break;
1127
1128   case CURLOPT_REFERER:
1129     /*
1130      * String to set in the HTTP Referer: field.
1131      */
1132     if(data->change.referer_alloc) {
1133       Curl_safefree(data->change.referer);
1134       data->change.referer_alloc = FALSE;
1135     }
1136     result = setstropt(&data->set.str[STRING_SET_REFERER],
1137                        va_arg(param, char *));
1138     data->change.referer = data->set.str[STRING_SET_REFERER];
1139     break;
1140
1141   case CURLOPT_USERAGENT:
1142     /*
1143      * String to use in the HTTP User-Agent field
1144      */
1145     result = setstropt(&data->set.str[STRING_USERAGENT],
1146                        va_arg(param, char *));
1147     break;
1148
1149   case CURLOPT_HTTPHEADER:
1150     /*
1151      * Set a list with HTTP headers to use (or replace internals with)
1152      */
1153     data->set.headers = va_arg(param, struct curl_slist *);
1154     break;
1155
1156   case CURLOPT_PROXYHEADER:
1157     /*
1158      * Set a list with proxy headers to use (or replace internals with)
1159      *
1160      * Since CURLOPT_HTTPHEADER was the only way to set HTTP headers for a
1161      * long time we remain doing it this way until CURLOPT_PROXYHEADER is
1162      * used. As soon as this option has been used, if set to anything but
1163      * NULL, custom headers for proxies are only picked from this list.
1164      *
1165      * Set this option to NULL to restore the previous behavior.
1166      */
1167     data->set.proxyheaders = va_arg(param, struct curl_slist *);
1168     break;
1169
1170   case CURLOPT_HEADEROPT:
1171     /*
1172      * Set header option.
1173      */
1174     arg = va_arg(param, long);
1175     data->set.sep_headers = (arg & CURLHEADER_SEPARATE)? TRUE: FALSE;
1176     break;
1177
1178   case CURLOPT_HTTP200ALIASES:
1179     /*
1180      * Set a list of aliases for HTTP 200 in response header
1181      */
1182     data->set.http200aliases = va_arg(param, struct curl_slist *);
1183     break;
1184
1185 #if !defined(CURL_DISABLE_COOKIES)
1186   case CURLOPT_COOKIE:
1187     /*
1188      * Cookie string to send to the remote server in the request.
1189      */
1190     result = setstropt(&data->set.str[STRING_COOKIE],
1191                        va_arg(param, char *));
1192     break;
1193
1194   case CURLOPT_COOKIEFILE:
1195     /*
1196      * Set cookie file to read and parse. Can be used multiple times.
1197      */
1198     argptr = (char *)va_arg(param, void *);
1199     if(argptr) {
1200       struct curl_slist *cl;
1201       /* append the cookie file name to the list of file names, and deal with
1202          them later */
1203       cl = curl_slist_append(data->change.cookielist, argptr);
1204       if(!cl) {
1205         curl_slist_free_all(data->change.cookielist);
1206         data->change.cookielist = NULL;
1207         return CURLE_OUT_OF_MEMORY;
1208       }
1209       data->change.cookielist = cl; /* store the list for later use */
1210     }
1211     break;
1212
1213   case CURLOPT_COOKIEJAR:
1214     /*
1215      * Set cookie file name to dump all cookies to when we're done.
1216      */
1217   {
1218     struct CookieInfo *newcookies;
1219     result = setstropt(&data->set.str[STRING_COOKIEJAR],
1220                        va_arg(param, char *));
1221
1222     /*
1223      * Activate the cookie parser. This may or may not already
1224      * have been made.
1225      */
1226     newcookies = Curl_cookie_init(data, NULL, data->cookies,
1227                                   data->set.cookiesession);
1228     if(!newcookies)
1229       result = CURLE_OUT_OF_MEMORY;
1230     data->cookies = newcookies;
1231   }
1232     break;
1233
1234   case CURLOPT_COOKIESESSION:
1235     /*
1236      * Set this option to TRUE to start a new "cookie session". It will
1237      * prevent the forthcoming read-cookies-from-file actions to accept
1238      * cookies that are marked as being session cookies, as they belong to a
1239      * previous session.
1240      *
1241      * In the original Netscape cookie spec, "session cookies" are cookies
1242      * with no expire date set. RFC2109 describes the same action if no
1243      * 'Max-Age' is set and RFC2965 includes the RFC2109 description and adds
1244      * a 'Discard' action that can enforce the discard even for cookies that
1245      * have a Max-Age.
1246      *
1247      * We run mostly with the original cookie spec, as hardly anyone implements
1248      * anything else.
1249      */
1250     data->set.cookiesession = (0 != va_arg(param, long)) ? TRUE : FALSE;
1251     break;
1252
1253   case CURLOPT_COOKIELIST:
1254     argptr = va_arg(param, char *);
1255
1256     if(argptr == NULL)
1257       break;
1258
1259     if(strcasecompare(argptr, "ALL")) {
1260       /* clear all cookies */
1261       Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
1262       Curl_cookie_clearall(data->cookies);
1263       Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
1264     }
1265     else if(strcasecompare(argptr, "SESS")) {
1266       /* clear session cookies */
1267       Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
1268       Curl_cookie_clearsess(data->cookies);
1269       Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
1270     }
1271     else if(strcasecompare(argptr, "FLUSH")) {
1272       /* flush cookies to file, takes care of the locking */
1273       Curl_flush_cookies(data, 0);
1274     }
1275     else if(strcasecompare(argptr, "RELOAD")) {
1276       /* reload cookies from file */
1277       Curl_cookie_loadfiles(data);
1278       break;
1279     }
1280     else {
1281       if(!data->cookies)
1282         /* if cookie engine was not running, activate it */
1283         data->cookies = Curl_cookie_init(data, NULL, NULL, TRUE);
1284
1285       argptr = strdup(argptr);
1286       if(!argptr || !data->cookies) {
1287         result = CURLE_OUT_OF_MEMORY;
1288         free(argptr);
1289       }
1290       else {
1291         Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
1292
1293         if(checkprefix("Set-Cookie:", argptr))
1294           /* HTTP Header format line */
1295           Curl_cookie_add(data, data->cookies, TRUE, argptr + 11, NULL, NULL);
1296
1297         else
1298           /* Netscape format line */
1299           Curl_cookie_add(data, data->cookies, FALSE, argptr, NULL, NULL);
1300
1301         Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
1302         free(argptr);
1303       }
1304     }
1305
1306     break;
1307 #endif /* CURL_DISABLE_COOKIES */
1308
1309   case CURLOPT_HTTPGET:
1310     /*
1311      * Set to force us do HTTP GET
1312      */
1313     if(va_arg(param, long)) {
1314       data->set.httpreq = HTTPREQ_GET;
1315       data->set.upload = FALSE; /* switch off upload */
1316       data->set.opt_no_body = FALSE; /* this is implied */
1317     }
1318     break;
1319
1320   case CURLOPT_HTTP_VERSION:
1321     /*
1322      * This sets a requested HTTP version to be used. The value is one of
1323      * the listed enums in curl/curl.h.
1324      */
1325     arg = va_arg(param, long);
1326 #ifndef USE_NGHTTP2
1327     if(arg >= CURL_HTTP_VERSION_2)
1328       return CURLE_UNSUPPORTED_PROTOCOL;
1329 #endif
1330     data->set.httpversion = arg;
1331     break;
1332
1333   case CURLOPT_HTTPAUTH:
1334     /*
1335      * Set HTTP Authentication type BITMASK.
1336      */
1337   {
1338     int bitcheck;
1339     bool authbits;
1340     unsigned long auth = va_arg(param, unsigned long);
1341
1342     if(auth == CURLAUTH_NONE) {
1343       data->set.httpauth = auth;
1344       break;
1345     }
1346
1347     /* the DIGEST_IE bit is only used to set a special marker, for all the
1348        rest we need to handle it as normal DIGEST */
1349     data->state.authhost.iestyle = (auth & CURLAUTH_DIGEST_IE) ? TRUE : FALSE;
1350
1351     if(auth & CURLAUTH_DIGEST_IE) {
1352       auth |= CURLAUTH_DIGEST; /* set standard digest bit */
1353       auth &= ~CURLAUTH_DIGEST_IE; /* unset ie digest bit */
1354     }
1355
1356     /* switch off bits we can't support */
1357 #ifndef USE_NTLM
1358     auth &= ~CURLAUTH_NTLM;    /* no NTLM support */
1359     auth &= ~CURLAUTH_NTLM_WB; /* no NTLM_WB support */
1360 #elif !defined(NTLM_WB_ENABLED)
1361     auth &= ~CURLAUTH_NTLM_WB; /* no NTLM_WB support */
1362 #endif
1363 #ifndef USE_SPNEGO
1364     auth &= ~CURLAUTH_NEGOTIATE; /* no Negotiate (SPNEGO) auth without
1365                                     GSS-API or SSPI */
1366 #endif
1367
1368     /* check if any auth bit lower than CURLAUTH_ONLY is still set */
1369     bitcheck = 0;
1370     authbits = FALSE;
1371     while(bitcheck < 31) {
1372       if(auth & (1UL << bitcheck++)) {
1373         authbits = TRUE;
1374         break;
1375       }
1376     }
1377     if(!authbits)
1378       return CURLE_NOT_BUILT_IN; /* no supported types left! */
1379
1380     data->set.httpauth = auth;
1381   }
1382   break;
1383
1384   case CURLOPT_EXPECT_100_TIMEOUT_MS:
1385     /*
1386      * Time to wait for a response to a HTTP request containing an
1387      * Expect: 100-continue header before sending the data anyway.
1388      */
1389     data->set.expect_100_timeout = va_arg(param, long);
1390     break;
1391
1392 #endif   /* CURL_DISABLE_HTTP */
1393
1394   case CURLOPT_CUSTOMREQUEST:
1395     /*
1396      * Set a custom string to use as request
1397      */
1398     result = setstropt(&data->set.str[STRING_CUSTOMREQUEST],
1399                        va_arg(param, char *));
1400
1401     /* we don't set
1402        data->set.httpreq = HTTPREQ_CUSTOM;
1403        here, we continue as if we were using the already set type
1404        and this just changes the actual request keyword */
1405     break;
1406
1407 #ifndef CURL_DISABLE_PROXY
1408   case CURLOPT_HTTPPROXYTUNNEL:
1409     /*
1410      * Tunnel operations through the proxy instead of normal proxy use
1411      */
1412     data->set.tunnel_thru_httpproxy = (0 != va_arg(param, long)) ?
1413                                       TRUE : FALSE;
1414     break;
1415
1416   case CURLOPT_PROXYPORT:
1417     /*
1418      * Explicitly set HTTP proxy port number.
1419      */
1420     data->set.proxyport = va_arg(param, long);
1421     break;
1422
1423   case CURLOPT_PROXYAUTH:
1424     /*
1425      * Set HTTP Authentication type BITMASK.
1426      */
1427   {
1428     int bitcheck;
1429     bool authbits;
1430     unsigned long auth = va_arg(param, unsigned long);
1431
1432     if(auth == CURLAUTH_NONE) {
1433       data->set.proxyauth = auth;
1434       break;
1435     }
1436
1437     /* the DIGEST_IE bit is only used to set a special marker, for all the
1438        rest we need to handle it as normal DIGEST */
1439     data->state.authproxy.iestyle = (auth & CURLAUTH_DIGEST_IE) ? TRUE : FALSE;
1440
1441     if(auth & CURLAUTH_DIGEST_IE) {
1442       auth |= CURLAUTH_DIGEST; /* set standard digest bit */
1443       auth &= ~CURLAUTH_DIGEST_IE; /* unset ie digest bit */
1444     }
1445     /* switch off bits we can't support */
1446 #ifndef USE_NTLM
1447     auth &= ~CURLAUTH_NTLM;    /* no NTLM support */
1448     auth &= ~CURLAUTH_NTLM_WB; /* no NTLM_WB support */
1449 #elif !defined(NTLM_WB_ENABLED)
1450     auth &= ~CURLAUTH_NTLM_WB; /* no NTLM_WB support */
1451 #endif
1452 #ifndef USE_SPNEGO
1453     auth &= ~CURLAUTH_NEGOTIATE; /* no Negotiate (SPNEGO) auth without
1454                                     GSS-API or SSPI */
1455 #endif
1456
1457     /* check if any auth bit lower than CURLAUTH_ONLY is still set */
1458     bitcheck = 0;
1459     authbits = FALSE;
1460     while(bitcheck < 31) {
1461       if(auth & (1UL << bitcheck++)) {
1462         authbits = TRUE;
1463         break;
1464       }
1465     }
1466     if(!authbits)
1467       return CURLE_NOT_BUILT_IN; /* no supported types left! */
1468
1469     data->set.proxyauth = auth;
1470   }
1471   break;
1472
1473   case CURLOPT_PROXY:
1474     /*
1475      * Set proxy server:port to use as proxy.
1476      *
1477      * If the proxy is set to "" (and CURLOPT_SOCKS_PROXY is set to "" or NULL)
1478      * we explicitly say that we don't want to use a proxy
1479      * (even though there might be environment variables saying so).
1480      *
1481      * Setting it to NULL, means no proxy but allows the environment variables
1482      * to decide for us (if CURLOPT_SOCKS_PROXY setting it to NULL).
1483      */
1484     result = setstropt(&data->set.str[STRING_PROXY],
1485                        va_arg(param, char *));
1486     break;
1487
1488   case CURLOPT_PRE_PROXY:
1489     /*
1490      * Set proxy server:port to use as SOCKS proxy.
1491      *
1492      * If the proxy is set to "" or NULL we explicitly say that we don't want
1493      * to use the socks proxy.
1494      */
1495     result = setstropt(&data->set.str[STRING_PRE_PROXY],
1496                        va_arg(param, char *));
1497     break;
1498
1499   case CURLOPT_PROXYTYPE:
1500     /*
1501      * Set proxy type. HTTP/HTTP_1_0/SOCKS4/SOCKS4a/SOCKS5/SOCKS5_HOSTNAME
1502      */
1503     data->set.proxytype = (curl_proxytype)va_arg(param, long);
1504     break;
1505
1506   case CURLOPT_PROXY_TRANSFER_MODE:
1507     /*
1508      * set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy
1509      */
1510     switch(va_arg(param, long)) {
1511     case 0:
1512       data->set.proxy_transfer_mode = FALSE;
1513       break;
1514     case 1:
1515       data->set.proxy_transfer_mode = TRUE;
1516       break;
1517     default:
1518       /* reserve other values for future use */
1519       result = CURLE_UNKNOWN_OPTION;
1520       break;
1521     }
1522     break;
1523 #endif   /* CURL_DISABLE_PROXY */
1524
1525 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
1526   case CURLOPT_SOCKS5_GSSAPI_NEC:
1527     /*
1528      * Set flag for NEC SOCK5 support
1529      */
1530     data->set.socks5_gssapi_nec = (0 != va_arg(param, long)) ? TRUE : FALSE;
1531     break;
1532
1533   case CURLOPT_SOCKS5_GSSAPI_SERVICE:
1534   case CURLOPT_PROXY_SERVICE_NAME:
1535     /*
1536      * Set proxy authentication service name for Kerberos 5 and SPNEGO
1537      */
1538     result = setstropt(&data->set.str[STRING_PROXY_SERVICE_NAME],
1539                        va_arg(param, char *));
1540     break;
1541 #endif
1542
1543 #if !defined(CURL_DISABLE_CRYPTO_AUTH) || defined(USE_KERBEROS5) || \
1544     defined(USE_SPNEGO)
1545   case CURLOPT_SERVICE_NAME:
1546     /*
1547      * Set authentication service name for DIGEST-MD5, Kerberos 5 and SPNEGO
1548      */
1549     result = setstropt(&data->set.str[STRING_SERVICE_NAME],
1550                        va_arg(param, char *));
1551     break;
1552
1553 #endif
1554
1555   case CURLOPT_HEADERDATA:
1556     /*
1557      * Custom pointer to pass the header write callback function
1558      */
1559     data->set.writeheader = (void *)va_arg(param, void *);
1560     break;
1561   case CURLOPT_ERRORBUFFER:
1562     /*
1563      * Error buffer provided by the caller to get the human readable
1564      * error string in.
1565      */
1566     data->set.errorbuffer = va_arg(param, char *);
1567     break;
1568   case CURLOPT_WRITEDATA:
1569     /*
1570      * FILE pointer to write to. Or possibly
1571      * used as argument to the write callback.
1572      */
1573     data->set.out = va_arg(param, void *);
1574     break;
1575   case CURLOPT_FTPPORT:
1576     /*
1577      * Use FTP PORT, this also specifies which IP address to use
1578      */
1579     result = setstropt(&data->set.str[STRING_FTPPORT],
1580                        va_arg(param, char *));
1581     data->set.ftp_use_port = (data->set.str[STRING_FTPPORT]) ? TRUE : FALSE;
1582     break;
1583
1584   case CURLOPT_FTP_USE_EPRT:
1585     data->set.ftp_use_eprt = (0 != va_arg(param, long)) ? TRUE : FALSE;
1586     break;
1587
1588   case CURLOPT_FTP_USE_EPSV:
1589     data->set.ftp_use_epsv = (0 != va_arg(param, long)) ? TRUE : FALSE;
1590     break;
1591
1592   case CURLOPT_FTP_USE_PRET:
1593     data->set.ftp_use_pret = (0 != va_arg(param, long)) ? TRUE : FALSE;
1594     break;
1595
1596   case CURLOPT_FTP_SSL_CCC:
1597     data->set.ftp_ccc = (curl_ftpccc)va_arg(param, long);
1598     break;
1599
1600   case CURLOPT_FTP_SKIP_PASV_IP:
1601     /*
1602      * Enable or disable FTP_SKIP_PASV_IP, which will disable/enable the
1603      * bypass of the IP address in PASV responses.
1604      */
1605     data->set.ftp_skip_ip = (0 != va_arg(param, long)) ? TRUE : FALSE;
1606     break;
1607
1608   case CURLOPT_READDATA:
1609     /*
1610      * FILE pointer to read the file to be uploaded from. Or possibly
1611      * used as argument to the read callback.
1612      */
1613     data->set.in_set = va_arg(param, void *);
1614     break;
1615   case CURLOPT_INFILESIZE:
1616     /*
1617      * If known, this should inform curl about the file size of the
1618      * to-be-uploaded file.
1619      */
1620     data->set.filesize = va_arg(param, long);
1621     break;
1622   case CURLOPT_INFILESIZE_LARGE:
1623     /*
1624      * If known, this should inform curl about the file size of the
1625      * to-be-uploaded file.
1626      */
1627     data->set.filesize = va_arg(param, curl_off_t);
1628     break;
1629   case CURLOPT_LOW_SPEED_LIMIT:
1630     /*
1631      * The low speed limit that if transfers are below this for
1632      * CURLOPT_LOW_SPEED_TIME, the transfer is aborted.
1633      */
1634     data->set.low_speed_limit=va_arg(param, long);
1635     break;
1636   case CURLOPT_MAX_SEND_SPEED_LARGE:
1637     /*
1638      * When transfer uploads are faster then CURLOPT_MAX_SEND_SPEED_LARGE
1639      * bytes per second the transfer is throttled..
1640      */
1641     data->set.max_send_speed=va_arg(param, curl_off_t);
1642     break;
1643   case CURLOPT_MAX_RECV_SPEED_LARGE:
1644     /*
1645      * When receiving data faster than CURLOPT_MAX_RECV_SPEED_LARGE bytes per
1646      * second the transfer is throttled..
1647      */
1648     data->set.max_recv_speed=va_arg(param, curl_off_t);
1649     break;
1650   case CURLOPT_LOW_SPEED_TIME:
1651     /*
1652      * The low speed time that if transfers are below the set
1653      * CURLOPT_LOW_SPEED_LIMIT during this time, the transfer is aborted.
1654      */
1655     data->set.low_speed_time=va_arg(param, long);
1656     break;
1657   case CURLOPT_URL:
1658     /*
1659      * The URL to fetch.
1660      */
1661     if(data->change.url_alloc) {
1662       /* the already set URL is allocated, free it first! */
1663       Curl_safefree(data->change.url);
1664       data->change.url_alloc = FALSE;
1665     }
1666     result = setstropt(&data->set.str[STRING_SET_URL],
1667                        va_arg(param, char *));
1668     data->change.url = data->set.str[STRING_SET_URL];
1669     break;
1670   case CURLOPT_PORT:
1671     /*
1672      * The port number to use when getting the URL
1673      */
1674     data->set.use_port = va_arg(param, long);
1675     break;
1676   case CURLOPT_TIMEOUT:
1677     /*
1678      * The maximum time you allow curl to use for a single transfer
1679      * operation.
1680      */
1681     data->set.timeout = va_arg(param, long) * 1000L;
1682     break;
1683
1684   case CURLOPT_TIMEOUT_MS:
1685     data->set.timeout = va_arg(param, long);
1686     break;
1687
1688   case CURLOPT_CONNECTTIMEOUT:
1689     /*
1690      * The maximum time you allow curl to use to connect.
1691      */
1692     data->set.connecttimeout = va_arg(param, long) * 1000L;
1693     break;
1694
1695   case CURLOPT_CONNECTTIMEOUT_MS:
1696     data->set.connecttimeout = va_arg(param, long);
1697     break;
1698
1699   case CURLOPT_ACCEPTTIMEOUT_MS:
1700     /*
1701      * The maximum time you allow curl to wait for server connect
1702      */
1703     data->set.accepttimeout = va_arg(param, long);
1704     break;
1705
1706   case CURLOPT_USERPWD:
1707     /*
1708      * user:password to use in the operation
1709      */
1710     result = setstropt_userpwd(va_arg(param, char *),
1711                                &data->set.str[STRING_USERNAME],
1712                                &data->set.str[STRING_PASSWORD]);
1713     break;
1714
1715   case CURLOPT_USERNAME:
1716     /*
1717      * authentication user name to use in the operation
1718      */
1719     result = setstropt(&data->set.str[STRING_USERNAME],
1720                        va_arg(param, char *));
1721     break;
1722
1723   case CURLOPT_PASSWORD:
1724     /*
1725      * authentication password to use in the operation
1726      */
1727     result = setstropt(&data->set.str[STRING_PASSWORD],
1728                        va_arg(param, char *));
1729     break;
1730
1731   case CURLOPT_LOGIN_OPTIONS:
1732     /*
1733      * authentication options to use in the operation
1734      */
1735     result = setstropt(&data->set.str[STRING_OPTIONS],
1736                        va_arg(param, char *));
1737     break;
1738
1739   case CURLOPT_XOAUTH2_BEARER:
1740     /*
1741      * OAuth 2.0 bearer token to use in the operation
1742      */
1743     result = setstropt(&data->set.str[STRING_BEARER],
1744                        va_arg(param, char *));
1745     break;
1746
1747   case CURLOPT_POSTQUOTE:
1748     /*
1749      * List of RAW FTP commands to use after a transfer
1750      */
1751     data->set.postquote = va_arg(param, struct curl_slist *);
1752     break;
1753   case CURLOPT_PREQUOTE:
1754     /*
1755      * List of RAW FTP commands to use prior to RETR (Wesley Laxton)
1756      */
1757     data->set.prequote = va_arg(param, struct curl_slist *);
1758     break;
1759   case CURLOPT_QUOTE:
1760     /*
1761      * List of RAW FTP commands to use before a transfer
1762      */
1763     data->set.quote = va_arg(param, struct curl_slist *);
1764     break;
1765   case CURLOPT_RESOLVE:
1766     /*
1767      * List of NAME:[address] names to populate the DNS cache with
1768      * Prefix the NAME with dash (-) to _remove_ the name from the cache.
1769      *
1770      * Names added with this API will remain in the cache until explicitly
1771      * removed or the handle is cleaned up.
1772      *
1773      * This API can remove any name from the DNS cache, but only entries
1774      * that aren't actually in use right now will be pruned immediately.
1775      */
1776     data->set.resolve = va_arg(param, struct curl_slist *);
1777     data->change.resolve = data->set.resolve;
1778     break;
1779   case CURLOPT_PROGRESSFUNCTION:
1780     /*
1781      * Progress callback function
1782      */
1783     data->set.fprogress = va_arg(param, curl_progress_callback);
1784     if(data->set.fprogress)
1785       data->progress.callback = TRUE; /* no longer internal */
1786     else
1787       data->progress.callback = FALSE; /* NULL enforces internal */
1788     break;
1789
1790   case CURLOPT_XFERINFOFUNCTION:
1791     /*
1792      * Transfer info callback function
1793      */
1794     data->set.fxferinfo = va_arg(param, curl_xferinfo_callback);
1795     if(data->set.fxferinfo)
1796       data->progress.callback = TRUE; /* no longer internal */
1797     else
1798       data->progress.callback = FALSE; /* NULL enforces internal */
1799
1800     break;
1801
1802   case CURLOPT_PROGRESSDATA:
1803     /*
1804      * Custom client data to pass to the progress callback
1805      */
1806     data->set.progress_client = va_arg(param, void *);
1807     break;
1808
1809 #ifndef CURL_DISABLE_PROXY
1810   case CURLOPT_PROXYUSERPWD:
1811     /*
1812      * user:password needed to use the proxy
1813      */
1814     result = setstropt_userpwd(va_arg(param, char *),
1815                                &data->set.str[STRING_PROXYUSERNAME],
1816                                &data->set.str[STRING_PROXYPASSWORD]);
1817     break;
1818   case CURLOPT_PROXYUSERNAME:
1819     /*
1820      * authentication user name to use in the operation
1821      */
1822     result = setstropt(&data->set.str[STRING_PROXYUSERNAME],
1823                        va_arg(param, char *));
1824     break;
1825   case CURLOPT_PROXYPASSWORD:
1826     /*
1827      * authentication password to use in the operation
1828      */
1829     result = setstropt(&data->set.str[STRING_PROXYPASSWORD],
1830                        va_arg(param, char *));
1831     break;
1832   case CURLOPT_NOPROXY:
1833     /*
1834      * proxy exception list
1835      */
1836     result = setstropt(&data->set.str[STRING_NOPROXY],
1837                        va_arg(param, char *));
1838     break;
1839 #endif
1840
1841   case CURLOPT_RANGE:
1842     /*
1843      * What range of the file you want to transfer
1844      */
1845     result = setstropt(&data->set.str[STRING_SET_RANGE],
1846                        va_arg(param, char *));
1847     break;
1848   case CURLOPT_RESUME_FROM:
1849     /*
1850      * Resume transfer at the give file position
1851      */
1852     data->set.set_resume_from = va_arg(param, long);
1853     break;
1854   case CURLOPT_RESUME_FROM_LARGE:
1855     /*
1856      * Resume transfer at the give file position
1857      */
1858     data->set.set_resume_from = va_arg(param, curl_off_t);
1859     break;
1860   case CURLOPT_DEBUGFUNCTION:
1861     /*
1862      * stderr write callback.
1863      */
1864     data->set.fdebug = va_arg(param, curl_debug_callback);
1865     /*
1866      * if the callback provided is NULL, it'll use the default callback
1867      */
1868     break;
1869   case CURLOPT_DEBUGDATA:
1870     /*
1871      * Set to a void * that should receive all error writes. This
1872      * defaults to CURLOPT_STDERR for normal operations.
1873      */
1874     data->set.debugdata = va_arg(param, void *);
1875     break;
1876   case CURLOPT_STDERR:
1877     /*
1878      * Set to a FILE * that should receive all error writes. This
1879      * defaults to stderr for normal operations.
1880      */
1881     data->set.err = va_arg(param, FILE *);
1882     if(!data->set.err)
1883       data->set.err = stderr;
1884     break;
1885   case CURLOPT_HEADERFUNCTION:
1886     /*
1887      * Set header write callback
1888      */
1889     data->set.fwrite_header = va_arg(param, curl_write_callback);
1890     break;
1891   case CURLOPT_WRITEFUNCTION:
1892     /*
1893      * Set data write callback
1894      */
1895     data->set.fwrite_func = va_arg(param, curl_write_callback);
1896     if(!data->set.fwrite_func) {
1897       data->set.is_fwrite_set = 0;
1898       /* When set to NULL, reset to our internal default function */
1899       data->set.fwrite_func = (curl_write_callback)fwrite;
1900     }
1901     else
1902       data->set.is_fwrite_set = 1;
1903     break;
1904   case CURLOPT_READFUNCTION:
1905     /*
1906      * Read data callback
1907      */
1908     data->set.fread_func_set = va_arg(param, curl_read_callback);
1909     if(!data->set.fread_func_set) {
1910       data->set.is_fread_set = 0;
1911       /* When set to NULL, reset to our internal default function */
1912       data->set.fread_func_set = (curl_read_callback)fread;
1913     }
1914     else
1915       data->set.is_fread_set = 1;
1916     break;
1917   case CURLOPT_SEEKFUNCTION:
1918     /*
1919      * Seek callback. Might be NULL.
1920      */
1921     data->set.seek_func = va_arg(param, curl_seek_callback);
1922     break;
1923   case CURLOPT_SEEKDATA:
1924     /*
1925      * Seek control callback. Might be NULL.
1926      */
1927     data->set.seek_client = va_arg(param, void *);
1928     break;
1929   case CURLOPT_CONV_FROM_NETWORK_FUNCTION:
1930     /*
1931      * "Convert from network encoding" callback
1932      */
1933     data->set.convfromnetwork = va_arg(param, curl_conv_callback);
1934     break;
1935   case CURLOPT_CONV_TO_NETWORK_FUNCTION:
1936     /*
1937      * "Convert to network encoding" callback
1938      */
1939     data->set.convtonetwork = va_arg(param, curl_conv_callback);
1940     break;
1941   case CURLOPT_CONV_FROM_UTF8_FUNCTION:
1942     /*
1943      * "Convert from UTF-8 encoding" callback
1944      */
1945     data->set.convfromutf8 = va_arg(param, curl_conv_callback);
1946     break;
1947   case CURLOPT_IOCTLFUNCTION:
1948     /*
1949      * I/O control callback. Might be NULL.
1950      */
1951     data->set.ioctl_func = va_arg(param, curl_ioctl_callback);
1952     break;
1953   case CURLOPT_IOCTLDATA:
1954     /*
1955      * I/O control data pointer. Might be NULL.
1956      */
1957     data->set.ioctl_client = va_arg(param, void *);
1958     break;
1959   case CURLOPT_SSLCERT:
1960     /*
1961      * String that holds file name of the SSL certificate to use
1962      */
1963     result = setstropt(&data->set.str[STRING_CERT_ORIG],
1964                        va_arg(param, char *));
1965     break;
1966   case CURLOPT_PROXY_SSLCERT:
1967     /*
1968      * String that holds file name of the SSL certificate to use for proxy
1969      */
1970     result = setstropt(&data->set.str[STRING_CERT_PROXY],
1971                        va_arg(param, char *));
1972     break;
1973   case CURLOPT_SSLCERTTYPE:
1974     /*
1975      * String that holds file type of the SSL certificate to use
1976      */
1977     result = setstropt(&data->set.str[STRING_CERT_TYPE_ORIG],
1978                        va_arg(param, char *));
1979     break;
1980   case CURLOPT_PROXY_SSLCERTTYPE:
1981     /*
1982      * String that holds file type of the SSL certificate to use for proxy
1983      */
1984     result = setstropt(&data->set.str[STRING_CERT_TYPE_PROXY],
1985                        va_arg(param, char *));
1986     break;
1987   case CURLOPT_SSLKEY:
1988     /*
1989      * String that holds file name of the SSL key to use
1990      */
1991     result = setstropt(&data->set.str[STRING_KEY_ORIG],
1992                        va_arg(param, char *));
1993     break;
1994   case CURLOPT_PROXY_SSLKEY:
1995     /*
1996      * String that holds file name of the SSL key to use for proxy
1997      */
1998     result = setstropt(&data->set.str[STRING_KEY_PROXY],
1999                        va_arg(param, char *));
2000     break;
2001   case CURLOPT_SSLKEYTYPE:
2002     /*
2003      * String that holds file type of the SSL key to use
2004      */
2005     result = setstropt(&data->set.str[STRING_KEY_TYPE_ORIG],
2006                        va_arg(param, char *));
2007     break;
2008   case CURLOPT_PROXY_SSLKEYTYPE:
2009     /*
2010      * String that holds file type of the SSL key to use for proxy
2011      */
2012     result = setstropt(&data->set.str[STRING_KEY_TYPE_PROXY],
2013                        va_arg(param, char *));
2014     break;
2015   case CURLOPT_KEYPASSWD:
2016     /*
2017      * String that holds the SSL or SSH private key password.
2018      */
2019     result = setstropt(&data->set.str[STRING_KEY_PASSWD_ORIG],
2020                        va_arg(param, char *));
2021     break;
2022   case CURLOPT_PROXY_KEYPASSWD:
2023     /*
2024      * String that holds the SSL private key password for proxy.
2025      */
2026     result = setstropt(&data->set.str[STRING_KEY_PASSWD_PROXY],
2027                        va_arg(param, char *));
2028     break;
2029   case CURLOPT_SSLENGINE:
2030     /*
2031      * String that holds the SSL crypto engine.
2032      */
2033     argptr = va_arg(param, char *);
2034     if(argptr && argptr[0])
2035       result = Curl_ssl_set_engine(data, argptr);
2036     break;
2037
2038   case CURLOPT_SSLENGINE_DEFAULT:
2039     /*
2040      * flag to set engine as default.
2041      */
2042     result = Curl_ssl_set_engine_default(data);
2043     break;
2044   case CURLOPT_CRLF:
2045     /*
2046      * Kludgy option to enable CRLF conversions. Subject for removal.
2047      */
2048     data->set.crlf = (0 != va_arg(param, long)) ? TRUE : FALSE;
2049     break;
2050
2051   case CURLOPT_INTERFACE:
2052     /*
2053      * Set what interface or address/hostname to bind the socket to when
2054      * performing an operation and thus what from-IP your connection will use.
2055      */
2056     result = setstropt(&data->set.str[STRING_DEVICE],
2057                        va_arg(param, char *));
2058     break;
2059   case CURLOPT_LOCALPORT:
2060     /*
2061      * Set what local port to bind the socket to when performing an operation.
2062      */
2063     data->set.localport = curlx_sltous(va_arg(param, long));
2064     break;
2065   case CURLOPT_LOCALPORTRANGE:
2066     /*
2067      * Set number of local ports to try, starting with CURLOPT_LOCALPORT.
2068      */
2069     data->set.localportrange = curlx_sltosi(va_arg(param, long));
2070     break;
2071   case CURLOPT_KRBLEVEL:
2072     /*
2073      * A string that defines the kerberos security level.
2074      */
2075     result = setstropt(&data->set.str[STRING_KRB_LEVEL],
2076                        va_arg(param, char *));
2077     data->set.krb = (data->set.str[STRING_KRB_LEVEL]) ? TRUE : FALSE;
2078     break;
2079   case CURLOPT_GSSAPI_DELEGATION:
2080     /*
2081      * GSS-API credential delegation
2082      */
2083     data->set.gssapi_delegation = va_arg(param, long);
2084     break;
2085   case CURLOPT_SSL_VERIFYPEER:
2086     /*
2087      * Enable peer SSL verifying.
2088      */
2089     data->set.ssl.primary.verifypeer = (0 != va_arg(param, long)) ?
2090                                        TRUE : FALSE;
2091     break;
2092   case CURLOPT_PROXY_SSL_VERIFYPEER:
2093     /*
2094      * Enable peer SSL verifying for proxy.
2095      */
2096     data->set.proxy_ssl.primary.verifypeer =
2097       (0 != va_arg(param, long))?TRUE:FALSE;
2098     break;
2099   case CURLOPT_SSL_VERIFYHOST:
2100     /*
2101      * Enable verification of the host name in the peer certificate
2102      */
2103     arg = va_arg(param, long);
2104
2105     /* Obviously people are not reading documentation and too many thought
2106        this argument took a boolean when it wasn't and misused it. We thus ban
2107        1 as a sensible input and we warn about its use. Then we only have the
2108        2 action internally stored as TRUE. */
2109
2110     if(1 == arg) {
2111       failf(data, "CURLOPT_SSL_VERIFYHOST no longer supports 1 as value!");
2112       return CURLE_BAD_FUNCTION_ARGUMENT;
2113     }
2114
2115     data->set.ssl.primary.verifyhost = (0 != arg) ? TRUE : FALSE;
2116     break;
2117   case CURLOPT_PROXY_SSL_VERIFYHOST:
2118     /*
2119      * Enable verification of the host name in the peer certificate for proxy
2120      */
2121     arg = va_arg(param, long);
2122
2123     /* Obviously people are not reading documentation and too many thought
2124        this argument took a boolean when it wasn't and misused it. We thus ban
2125        1 as a sensible input and we warn about its use. Then we only have the
2126        2 action internally stored as TRUE. */
2127
2128     if(1 == arg) {
2129       failf(data, "CURLOPT_SSL_VERIFYHOST no longer supports 1 as value!");
2130       return CURLE_BAD_FUNCTION_ARGUMENT;
2131     }
2132
2133     data->set.proxy_ssl.primary.verifyhost = (0 != arg)?TRUE:FALSE;
2134     break;
2135   case CURLOPT_SSL_VERIFYSTATUS:
2136     /*
2137      * Enable certificate status verifying.
2138      */
2139     if(!Curl_ssl_cert_status_request()) {
2140       result = CURLE_NOT_BUILT_IN;
2141       break;
2142     }
2143
2144     data->set.ssl.primary.verifystatus = (0 != va_arg(param, long)) ?
2145                                          TRUE : FALSE;
2146     break;
2147   case CURLOPT_SSL_CTX_FUNCTION:
2148 #ifdef have_curlssl_ssl_ctx
2149     /*
2150      * Set a SSL_CTX callback
2151      */
2152     data->set.ssl.fsslctx = va_arg(param, curl_ssl_ctx_callback);
2153 #else
2154     result = CURLE_NOT_BUILT_IN;
2155 #endif
2156     break;
2157   case CURLOPT_SSL_CTX_DATA:
2158 #ifdef have_curlssl_ssl_ctx
2159     /*
2160      * Set a SSL_CTX callback parameter pointer
2161      */
2162     data->set.ssl.fsslctxp = va_arg(param, void *);
2163 #else
2164     result = CURLE_NOT_BUILT_IN;
2165 #endif
2166     break;
2167   case CURLOPT_SSL_FALSESTART:
2168     /*
2169      * Enable TLS false start.
2170      */
2171     if(!Curl_ssl_false_start()) {
2172       result = CURLE_NOT_BUILT_IN;
2173       break;
2174     }
2175
2176     data->set.ssl.falsestart = (0 != va_arg(param, long)) ? TRUE : FALSE;
2177     break;
2178   case CURLOPT_CERTINFO:
2179 #ifdef have_curlssl_certinfo
2180     data->set.ssl.certinfo = (0 != va_arg(param, long)) ? TRUE : FALSE;
2181 #else
2182     result = CURLE_NOT_BUILT_IN;
2183 #endif
2184     break;
2185   case CURLOPT_PINNEDPUBLICKEY:
2186 #ifdef have_curlssl_pinnedpubkey /* only by supported backends */
2187     /*
2188      * Set pinned public key for SSL connection.
2189      * Specify file name of the public key in DER format.
2190      */
2191     result = setstropt(&data->set.str[STRING_SSL_PINNEDPUBLICKEY_ORIG],
2192                        va_arg(param, char *));
2193 #else
2194     result = CURLE_NOT_BUILT_IN;
2195 #endif
2196     break;
2197   case CURLOPT_PROXY_PINNEDPUBLICKEY:
2198 #ifdef have_curlssl_pinnedpubkey /* only by supported backends */
2199     /*
2200      * Set pinned public key for SSL connection.
2201      * Specify file name of the public key in DER format.
2202      */
2203     result = setstropt(&data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY],
2204                        va_arg(param, char *));
2205 #else
2206     result = CURLE_NOT_BUILT_IN;
2207 #endif
2208     break;
2209   case CURLOPT_CAINFO:
2210     /*
2211      * Set CA info for SSL connection. Specify file name of the CA certificate
2212      */
2213     result = setstropt(&data->set.str[STRING_SSL_CAFILE_ORIG],
2214                        va_arg(param, char *));
2215     break;
2216   case CURLOPT_PROXY_CAINFO:
2217     /*
2218      * Set CA info SSL connection for proxy. Specify file name of the
2219      * CA certificate
2220      */
2221     result = setstropt(&data->set.str[STRING_SSL_CAFILE_PROXY],
2222                        va_arg(param, char *));
2223     break;
2224   case CURLOPT_CAPATH:
2225 #ifdef have_curlssl_ca_path /* not supported by all backends */
2226     /*
2227      * Set CA path info for SSL connection. Specify directory name of the CA
2228      * certificates which have been prepared using openssl c_rehash utility.
2229      */
2230     /* This does not work on windows. */
2231     result = setstropt(&data->set.str[STRING_SSL_CAPATH_ORIG],
2232                        va_arg(param, char *));
2233 #else
2234     result = CURLE_NOT_BUILT_IN;
2235 #endif
2236     break;
2237   case CURLOPT_PROXY_CAPATH:
2238 #ifdef have_curlssl_ca_path /* not supported by all backends */
2239     /*
2240      * Set CA path info for SSL connection proxy. Specify directory name of the
2241      * CA certificates which have been prepared using openssl c_rehash utility.
2242      */
2243     /* This does not work on windows. */
2244     result = setstropt(&data->set.str[STRING_SSL_CAPATH_PROXY],
2245                        va_arg(param, char *));
2246 #else
2247     result = CURLE_NOT_BUILT_IN;
2248 #endif
2249     break;
2250   case CURLOPT_CRLFILE:
2251     /*
2252      * Set CRL file info for SSL connection. Specify file name of the CRL
2253      * to check certificates revocation
2254      */
2255     result = setstropt(&data->set.str[STRING_SSL_CRLFILE_ORIG],
2256                        va_arg(param, char *));
2257     break;
2258   case CURLOPT_PROXY_CRLFILE:
2259     /*
2260      * Set CRL file info for SSL connection for proxy. Specify file name of the
2261      * CRL to check certificates revocation
2262      */
2263     result = setstropt(&data->set.str[STRING_SSL_CRLFILE_PROXY],
2264                        va_arg(param, char *));
2265     break;
2266   case CURLOPT_ISSUERCERT:
2267     /*
2268      * Set Issuer certificate file
2269      * to check certificates issuer
2270      */
2271     result = setstropt(&data->set.str[STRING_SSL_ISSUERCERT_ORIG],
2272                        va_arg(param, char *));
2273     break;
2274   case CURLOPT_TELNETOPTIONS:
2275     /*
2276      * Set a linked list of telnet options
2277      */
2278     data->set.telnet_options = va_arg(param, struct curl_slist *);
2279     break;
2280
2281   case CURLOPT_BUFFERSIZE:
2282     /*
2283      * The application kindly asks for a differently sized receive buffer.
2284      * If it seems reasonable, we'll use it.
2285      */
2286     data->set.buffer_size = va_arg(param, long);
2287
2288     if(data->set.buffer_size > MAX_BUFSIZE)
2289       data->set.buffer_size = MAX_BUFSIZE; /* huge internal default */
2290     else if(data->set.buffer_size < 1)
2291       data->set.buffer_size = BUFSIZE;
2292
2293     /* Resize only if larger than default buffer size. */
2294     if(data->set.buffer_size > BUFSIZE) {
2295       data->state.buffer = realloc(data->state.buffer,
2296                                    data->set.buffer_size + 1);
2297       if(!data->state.buffer) {
2298         DEBUGF(fprintf(stderr, "Error: realloc of buffer failed\n"));
2299         result = CURLE_OUT_OF_MEMORY;
2300       }
2301     }
2302
2303     break;
2304
2305   case CURLOPT_NOSIGNAL:
2306     /*
2307      * The application asks not to set any signal() or alarm() handlers,
2308      * even when using a timeout.
2309      */
2310     data->set.no_signal = (0 != va_arg(param, long)) ? TRUE : FALSE;
2311     break;
2312
2313   case CURLOPT_SHARE:
2314   {
2315     struct Curl_share *set;
2316     set = va_arg(param, struct Curl_share *);
2317
2318     /* disconnect from old share, if any */
2319     if(data->share) {
2320       Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
2321
2322       if(data->dns.hostcachetype == HCACHE_SHARED) {
2323         data->dns.hostcache = NULL;
2324         data->dns.hostcachetype = HCACHE_NONE;
2325       }
2326
2327 #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
2328       if(data->share->cookies == data->cookies)
2329         data->cookies = NULL;
2330 #endif
2331
2332       if(data->share->sslsession == data->state.session)
2333         data->state.session = NULL;
2334
2335       data->share->dirty--;
2336
2337       Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
2338       data->share = NULL;
2339     }
2340
2341     /* use new share if it set */
2342     data->share = set;
2343     if(data->share) {
2344
2345       Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
2346
2347       data->share->dirty++;
2348
2349       if(data->share->specifier & (1<< CURL_LOCK_DATA_DNS)) {
2350         /* use shared host cache */
2351         data->dns.hostcache = &data->share->hostcache;
2352         data->dns.hostcachetype = HCACHE_SHARED;
2353       }
2354 #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
2355       if(data->share->cookies) {
2356         /* use shared cookie list, first free own one if any */
2357         Curl_cookie_cleanup(data->cookies);
2358         /* enable cookies since we now use a share that uses cookies! */
2359         data->cookies = data->share->cookies;
2360       }
2361 #endif   /* CURL_DISABLE_HTTP */
2362       if(data->share->sslsession) {
2363         data->set.general_ssl.max_ssl_sessions = data->share->max_ssl_sessions;
2364         data->state.session = data->share->sslsession;
2365       }
2366       Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
2367
2368     }
2369     /* check for host cache not needed,
2370      * it will be done by curl_easy_perform */
2371   }
2372   break;
2373
2374   case CURLOPT_PRIVATE:
2375     /*
2376      * Set private data pointer.
2377      */
2378     data->set.private_data = va_arg(param, void *);
2379     break;
2380
2381   case CURLOPT_MAXFILESIZE:
2382     /*
2383      * Set the maximum size of a file to download.
2384      */
2385     data->set.max_filesize = va_arg(param, long);
2386     break;
2387
2388 #ifdef USE_SSL
2389   case CURLOPT_USE_SSL:
2390     /*
2391      * Make transfers attempt to use SSL/TLS.
2392      */
2393     data->set.use_ssl = (curl_usessl)va_arg(param, long);
2394     break;
2395
2396   case CURLOPT_SSL_OPTIONS:
2397     arg = va_arg(param, long);
2398     data->set.ssl.enable_beast = arg&CURLSSLOPT_ALLOW_BEAST?TRUE:FALSE;
2399     data->set.ssl.no_revoke = !!(arg & CURLSSLOPT_NO_REVOKE);
2400     break;
2401
2402   case CURLOPT_PROXY_SSL_OPTIONS:
2403     arg = va_arg(param, long);
2404     data->set.proxy_ssl.enable_beast = arg&CURLSSLOPT_ALLOW_BEAST?TRUE:FALSE;
2405     data->set.proxy_ssl.no_revoke = !!(arg & CURLSSLOPT_NO_REVOKE);
2406     break;
2407
2408 #endif
2409   case CURLOPT_FTPSSLAUTH:
2410     /*
2411      * Set a specific auth for FTP-SSL transfers.
2412      */
2413     data->set.ftpsslauth = (curl_ftpauth)va_arg(param, long);
2414     break;
2415
2416   case CURLOPT_IPRESOLVE:
2417     data->set.ipver = va_arg(param, long);
2418     break;
2419
2420   case CURLOPT_MAXFILESIZE_LARGE:
2421     /*
2422      * Set the maximum size of a file to download.
2423      */
2424     data->set.max_filesize = va_arg(param, curl_off_t);
2425     break;
2426
2427   case CURLOPT_TCP_NODELAY:
2428     /*
2429      * Enable or disable TCP_NODELAY, which will disable/enable the Nagle
2430      * algorithm
2431      */
2432     data->set.tcp_nodelay = (0 != va_arg(param, long)) ? TRUE : FALSE;
2433     break;
2434
2435   case CURLOPT_FTP_ACCOUNT:
2436     result = setstropt(&data->set.str[STRING_FTP_ACCOUNT],
2437                        va_arg(param, char *));
2438     break;
2439
2440   case CURLOPT_IGNORE_CONTENT_LENGTH:
2441     data->set.ignorecl = (0 != va_arg(param, long)) ? TRUE : FALSE;
2442     break;
2443
2444   case CURLOPT_CONNECT_ONLY:
2445     /*
2446      * No data transfer, set up connection and let application use the socket
2447      */
2448     data->set.connect_only = (0 != va_arg(param, long)) ? TRUE : FALSE;
2449     break;
2450
2451   case CURLOPT_FTP_ALTERNATIVE_TO_USER:
2452     result = setstropt(&data->set.str[STRING_FTP_ALTERNATIVE_TO_USER],
2453                        va_arg(param, char *));
2454     break;
2455
2456   case CURLOPT_SOCKOPTFUNCTION:
2457     /*
2458      * socket callback function: called after socket() but before connect()
2459      */
2460     data->set.fsockopt = va_arg(param, curl_sockopt_callback);
2461     break;
2462
2463   case CURLOPT_SOCKOPTDATA:
2464     /*
2465      * socket callback data pointer. Might be NULL.
2466      */
2467     data->set.sockopt_client = va_arg(param, void *);
2468     break;
2469
2470   case CURLOPT_OPENSOCKETFUNCTION:
2471     /*
2472      * open/create socket callback function: called instead of socket(),
2473      * before connect()
2474      */
2475     data->set.fopensocket = va_arg(param, curl_opensocket_callback);
2476     break;
2477
2478   case CURLOPT_OPENSOCKETDATA:
2479     /*
2480      * socket callback data pointer. Might be NULL.
2481      */
2482     data->set.opensocket_client = va_arg(param, void *);
2483     break;
2484
2485   case CURLOPT_CLOSESOCKETFUNCTION:
2486     /*
2487      * close socket callback function: called instead of close()
2488      * when shutting down a connection
2489      */
2490     data->set.fclosesocket = va_arg(param, curl_closesocket_callback);
2491     break;
2492
2493   case CURLOPT_CLOSESOCKETDATA:
2494     /*
2495      * socket callback data pointer. Might be NULL.
2496      */
2497     data->set.closesocket_client = va_arg(param, void *);
2498     break;
2499
2500   case CURLOPT_SSL_SESSIONID_CACHE:
2501     data->set.ssl.primary.sessionid = (0 != va_arg(param, long)) ?
2502                                       TRUE : FALSE;
2503     data->set.proxy_ssl.primary.sessionid = data->set.ssl.primary.sessionid;
2504     break;
2505
2506 #ifdef USE_LIBSSH2
2507     /* we only include SSH options if explicitly built to support SSH */
2508   case CURLOPT_SSH_AUTH_TYPES:
2509     data->set.ssh_auth_types = va_arg(param, long);
2510     break;
2511
2512   case CURLOPT_SSH_PUBLIC_KEYFILE:
2513     /*
2514      * Use this file instead of the $HOME/.ssh/id_dsa.pub file
2515      */
2516     result = setstropt(&data->set.str[STRING_SSH_PUBLIC_KEY],
2517                        va_arg(param, char *));
2518     break;
2519
2520   case CURLOPT_SSH_PRIVATE_KEYFILE:
2521     /*
2522      * Use this file instead of the $HOME/.ssh/id_dsa file
2523      */
2524     result = setstropt(&data->set.str[STRING_SSH_PRIVATE_KEY],
2525                        va_arg(param, char *));
2526     break;
2527   case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
2528     /*
2529      * Option to allow for the MD5 of the host public key to be checked
2530      * for validation purposes.
2531      */
2532     result = setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5],
2533                        va_arg(param, char *));
2534     break;
2535 #ifdef HAVE_LIBSSH2_KNOWNHOST_API
2536   case CURLOPT_SSH_KNOWNHOSTS:
2537     /*
2538      * Store the file name to read known hosts from.
2539      */
2540     result = setstropt(&data->set.str[STRING_SSH_KNOWNHOSTS],
2541                        va_arg(param, char *));
2542     break;
2543
2544   case CURLOPT_SSH_KEYFUNCTION:
2545     /* setting to NULL is fine since the ssh.c functions themselves will
2546        then rever to use the internal default */
2547     data->set.ssh_keyfunc = va_arg(param, curl_sshkeycallback);
2548     break;
2549
2550   case CURLOPT_SSH_KEYDATA:
2551     /*
2552      * Custom client data to pass to the SSH keyfunc callback
2553      */
2554     data->set.ssh_keyfunc_userp = va_arg(param, void *);
2555     break;
2556 #endif /* HAVE_LIBSSH2_KNOWNHOST_API */
2557
2558 #endif /* USE_LIBSSH2 */
2559
2560   case CURLOPT_HTTP_TRANSFER_DECODING:
2561     /*
2562      * disable libcurl transfer encoding is used
2563      */
2564     data->set.http_te_skip = (0 == va_arg(param, long)) ? TRUE : FALSE;
2565     break;
2566
2567   case CURLOPT_HTTP_CONTENT_DECODING:
2568     /*
2569      * raw data passed to the application when content encoding is used
2570      */
2571     data->set.http_ce_skip = (0 == va_arg(param, long)) ? TRUE : FALSE;
2572     break;
2573
2574   case CURLOPT_NEW_FILE_PERMS:
2575     /*
2576      * Uses these permissions instead of 0644
2577      */
2578     data->set.new_file_perms = va_arg(param, long);
2579     break;
2580
2581   case CURLOPT_NEW_DIRECTORY_PERMS:
2582     /*
2583      * Uses these permissions instead of 0755
2584      */
2585     data->set.new_directory_perms = va_arg(param, long);
2586     break;
2587
2588   case CURLOPT_ADDRESS_SCOPE:
2589     /*
2590      * We always get longs when passed plain numericals, but for this value we
2591      * know that an unsigned int will always hold the value so we blindly
2592      * typecast to this type
2593      */
2594     data->set.scope_id = curlx_sltoui(va_arg(param, long));
2595     break;
2596
2597   case CURLOPT_PROTOCOLS:
2598     /* set the bitmask for the protocols that are allowed to be used for the
2599        transfer, which thus helps the app which takes URLs from users or other
2600        external inputs and want to restrict what protocol(s) to deal
2601        with. Defaults to CURLPROTO_ALL. */
2602     data->set.allowed_protocols = va_arg(param, long);
2603     break;
2604
2605   case CURLOPT_REDIR_PROTOCOLS:
2606     /* set the bitmask for the protocols that libcurl is allowed to follow to,
2607        as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
2608        to be set in both bitmasks to be allowed to get redirected to. Defaults
2609        to all protocols except FILE and SCP. */
2610     data->set.redir_protocols = va_arg(param, long);
2611     break;
2612
2613   case CURLOPT_DEFAULT_PROTOCOL:
2614     /* Set the protocol to use when the URL doesn't include any protocol */
2615     result = setstropt(&data->set.str[STRING_DEFAULT_PROTOCOL],
2616                        va_arg(param, char *));
2617     break;
2618
2619   case CURLOPT_MAIL_FROM:
2620     /* Set the SMTP mail originator */
2621     result = setstropt(&data->set.str[STRING_MAIL_FROM],
2622                        va_arg(param, char *));
2623     break;
2624
2625   case CURLOPT_MAIL_AUTH:
2626     /* Set the SMTP auth originator */
2627     result = setstropt(&data->set.str[STRING_MAIL_AUTH],
2628                        va_arg(param, char *));
2629     break;
2630
2631   case CURLOPT_MAIL_RCPT:
2632     /* Set the list of mail recipients */
2633     data->set.mail_rcpt = va_arg(param, struct curl_slist *);
2634     break;
2635
2636   case CURLOPT_SASL_IR:
2637     /* Enable/disable SASL initial response */
2638     data->set.sasl_ir = (0 != va_arg(param, long)) ? TRUE : FALSE;
2639     break;
2640
2641   case CURLOPT_RTSP_REQUEST:
2642     {
2643       /*
2644        * Set the RTSP request method (OPTIONS, SETUP, PLAY, etc...)
2645        * Would this be better if the RTSPREQ_* were just moved into here?
2646        */
2647       long curl_rtspreq = va_arg(param, long);
2648       Curl_RtspReq rtspreq = RTSPREQ_NONE;
2649       switch(curl_rtspreq) {
2650         case CURL_RTSPREQ_OPTIONS:
2651           rtspreq = RTSPREQ_OPTIONS;
2652           break;
2653
2654         case CURL_RTSPREQ_DESCRIBE:
2655           rtspreq = RTSPREQ_DESCRIBE;
2656           break;
2657
2658         case CURL_RTSPREQ_ANNOUNCE:
2659           rtspreq = RTSPREQ_ANNOUNCE;
2660           break;
2661
2662         case CURL_RTSPREQ_SETUP:
2663           rtspreq = RTSPREQ_SETUP;
2664           break;
2665
2666         case CURL_RTSPREQ_PLAY:
2667           rtspreq = RTSPREQ_PLAY;
2668           break;
2669
2670         case CURL_RTSPREQ_PAUSE:
2671           rtspreq = RTSPREQ_PAUSE;
2672           break;
2673
2674         case CURL_RTSPREQ_TEARDOWN:
2675           rtspreq = RTSPREQ_TEARDOWN;
2676           break;
2677
2678         case CURL_RTSPREQ_GET_PARAMETER:
2679           rtspreq = RTSPREQ_GET_PARAMETER;
2680           break;
2681
2682         case CURL_RTSPREQ_SET_PARAMETER:
2683           rtspreq = RTSPREQ_SET_PARAMETER;
2684           break;
2685
2686         case CURL_RTSPREQ_RECORD:
2687           rtspreq = RTSPREQ_RECORD;
2688           break;
2689
2690         case CURL_RTSPREQ_RECEIVE:
2691           rtspreq = RTSPREQ_RECEIVE;
2692           break;
2693         default:
2694           rtspreq = RTSPREQ_NONE;
2695       }
2696
2697       data->set.rtspreq = rtspreq;
2698     break;
2699     }
2700
2701
2702   case CURLOPT_RTSP_SESSION_ID:
2703     /*
2704      * Set the RTSP Session ID manually. Useful if the application is
2705      * resuming a previously established RTSP session
2706      */
2707     result = setstropt(&data->set.str[STRING_RTSP_SESSION_ID],
2708                        va_arg(param, char *));
2709     break;
2710
2711   case CURLOPT_RTSP_STREAM_URI:
2712     /*
2713      * Set the Stream URI for the RTSP request. Unless the request is
2714      * for generic server options, the application will need to set this.
2715      */
2716     result = setstropt(&data->set.str[STRING_RTSP_STREAM_URI],
2717                        va_arg(param, char *));
2718     break;
2719
2720   case CURLOPT_RTSP_TRANSPORT:
2721     /*
2722      * The content of the Transport: header for the RTSP request
2723      */
2724     result = setstropt(&data->set.str[STRING_RTSP_TRANSPORT],
2725                        va_arg(param, char *));
2726     break;
2727
2728   case CURLOPT_RTSP_CLIENT_CSEQ:
2729     /*
2730      * Set the CSEQ number to issue for the next RTSP request. Useful if the
2731      * application is resuming a previously broken connection. The CSEQ
2732      * will increment from this new number henceforth.
2733      */
2734     data->state.rtsp_next_client_CSeq = va_arg(param, long);
2735     break;
2736
2737   case CURLOPT_RTSP_SERVER_CSEQ:
2738     /* Same as the above, but for server-initiated requests */
2739     data->state.rtsp_next_client_CSeq = va_arg(param, long);
2740     break;
2741
2742   case CURLOPT_INTERLEAVEDATA:
2743     data->set.rtp_out = va_arg(param, void *);
2744     break;
2745   case CURLOPT_INTERLEAVEFUNCTION:
2746     /* Set the user defined RTP write function */
2747     data->set.fwrite_rtp = va_arg(param, curl_write_callback);
2748     break;
2749
2750   case CURLOPT_WILDCARDMATCH:
2751     data->set.wildcardmatch = (0 != va_arg(param, long)) ? TRUE : FALSE;
2752     break;
2753   case CURLOPT_CHUNK_BGN_FUNCTION:
2754     data->set.chunk_bgn = va_arg(param, curl_chunk_bgn_callback);
2755     break;
2756   case CURLOPT_CHUNK_END_FUNCTION:
2757     data->set.chunk_end = va_arg(param, curl_chunk_end_callback);
2758     break;
2759   case CURLOPT_FNMATCH_FUNCTION:
2760     data->set.fnmatch = va_arg(param, curl_fnmatch_callback);
2761     break;
2762   case CURLOPT_CHUNK_DATA:
2763     data->wildcard.customptr = va_arg(param, void *);
2764     break;
2765   case CURLOPT_FNMATCH_DATA:
2766     data->set.fnmatch_data = va_arg(param, void *);
2767     break;
2768 #ifdef USE_TLS_SRP
2769   case CURLOPT_TLSAUTH_USERNAME:
2770     result = setstropt(&data->set.str[STRING_TLSAUTH_USERNAME_ORIG],
2771                        va_arg(param, char *));
2772     if(data->set.str[STRING_TLSAUTH_USERNAME_ORIG] && !data->set.ssl.authtype)
2773       data->set.ssl.authtype = CURL_TLSAUTH_SRP; /* default to SRP */
2774     break;
2775   case CURLOPT_PROXY_TLSAUTH_USERNAME:
2776     result = setstropt(&data->set.str[STRING_TLSAUTH_USERNAME_PROXY],
2777                        va_arg(param, char *));
2778     if(data->set.str[STRING_TLSAUTH_USERNAME_PROXY] &&
2779        !data->set.proxy_ssl.authtype)
2780       data->set.proxy_ssl.authtype = CURL_TLSAUTH_SRP; /* default to SRP */
2781     break;
2782   case CURLOPT_TLSAUTH_PASSWORD:
2783     result = setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD_ORIG],
2784                        va_arg(param, char *));
2785     if(data->set.str[STRING_TLSAUTH_USERNAME_ORIG] && !data->set.ssl.authtype)
2786       data->set.ssl.authtype = CURL_TLSAUTH_SRP; /* default to SRP */
2787     break;
2788   case CURLOPT_PROXY_TLSAUTH_PASSWORD:
2789     result = setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD_PROXY],
2790                        va_arg(param, char *));
2791     if(data->set.str[STRING_TLSAUTH_USERNAME_PROXY] &&
2792        !data->set.proxy_ssl.authtype)
2793       data->set.proxy_ssl.authtype = CURL_TLSAUTH_SRP; /* default to SRP */
2794     break;
2795   case CURLOPT_TLSAUTH_TYPE:
2796     if(strncasecompare((char *)va_arg(param, char *), "SRP", strlen("SRP")))
2797       data->set.ssl.authtype = CURL_TLSAUTH_SRP;
2798     else
2799       data->set.ssl.authtype = CURL_TLSAUTH_NONE;
2800     break;
2801   case CURLOPT_PROXY_TLSAUTH_TYPE:
2802     if(strncasecompare((char *)va_arg(param, char *), "SRP", strlen("SRP")))
2803       data->set.proxy_ssl.authtype = CURL_TLSAUTH_SRP;
2804     else
2805       data->set.proxy_ssl.authtype = CURL_TLSAUTH_NONE;
2806     break;
2807 #endif
2808   case CURLOPT_DNS_SERVERS:
2809     result = Curl_set_dns_servers(data, va_arg(param, char *));
2810     break;
2811   case CURLOPT_DNS_INTERFACE:
2812     result = Curl_set_dns_interface(data, va_arg(param, char *));
2813     break;
2814   case CURLOPT_DNS_LOCAL_IP4:
2815     result = Curl_set_dns_local_ip4(data, va_arg(param, char *));
2816     break;
2817   case CURLOPT_DNS_LOCAL_IP6:
2818     result = Curl_set_dns_local_ip6(data, va_arg(param, char *));
2819     break;
2820
2821   case CURLOPT_TCP_KEEPALIVE:
2822     data->set.tcp_keepalive = (0 != va_arg(param, long)) ? TRUE : FALSE;
2823     break;
2824   case CURLOPT_TCP_KEEPIDLE:
2825     data->set.tcp_keepidle = va_arg(param, long);
2826     break;
2827   case CURLOPT_TCP_KEEPINTVL:
2828     data->set.tcp_keepintvl = va_arg(param, long);
2829     break;
2830   case CURLOPT_TCP_FASTOPEN:
2831 #if defined(CONNECT_DATA_IDEMPOTENT) || defined(MSG_FASTOPEN)
2832     data->set.tcp_fastopen = (0 != va_arg(param, long))?TRUE:FALSE;
2833 #else
2834     result = CURLE_NOT_BUILT_IN;
2835 #endif
2836     break;
2837   case CURLOPT_SSL_ENABLE_NPN:
2838     data->set.ssl_enable_npn = (0 != va_arg(param, long)) ? TRUE : FALSE;
2839     break;
2840   case CURLOPT_SSL_ENABLE_ALPN:
2841     data->set.ssl_enable_alpn = (0 != va_arg(param, long)) ? TRUE : FALSE;
2842     break;
2843
2844 #ifdef USE_UNIX_SOCKETS
2845   case CURLOPT_UNIX_SOCKET_PATH:
2846     data->set.abstract_unix_socket = FALSE;
2847     result = setstropt(&data->set.str[STRING_UNIX_SOCKET_PATH],
2848                        va_arg(param, char *));
2849     break;
2850   case CURLOPT_ABSTRACT_UNIX_SOCKET:
2851     data->set.abstract_unix_socket = TRUE;
2852     result = setstropt(&data->set.str[STRING_UNIX_SOCKET_PATH],
2853                        va_arg(param, char *));
2854     break;
2855 #endif
2856
2857   case CURLOPT_PATH_AS_IS:
2858     data->set.path_as_is = (0 != va_arg(param, long)) ? TRUE : FALSE;
2859     break;
2860   case CURLOPT_PIPEWAIT:
2861     data->set.pipewait = (0 != va_arg(param, long)) ? TRUE : FALSE;
2862     break;
2863   case CURLOPT_STREAM_WEIGHT:
2864 #ifndef USE_NGHTTP2
2865     return CURLE_NOT_BUILT_IN;
2866 #else
2867     arg = va_arg(param, long);
2868     if((arg>=1) && (arg <= 256))
2869       data->set.stream_weight = (int)arg;
2870     break;
2871 #endif
2872   case CURLOPT_STREAM_DEPENDS:
2873   case CURLOPT_STREAM_DEPENDS_E:
2874   {
2875 #ifndef USE_NGHTTP2
2876     return CURLE_NOT_BUILT_IN;
2877 #else
2878     struct Curl_easy *dep = va_arg(param, struct Curl_easy *);
2879     if(!dep || GOOD_EASY_HANDLE(dep)) {
2880       if(data->set.stream_depends_on) {
2881         Curl_http2_remove_child(data->set.stream_depends_on, data);
2882       }
2883       Curl_http2_add_child(dep, data, (option == CURLOPT_STREAM_DEPENDS_E));
2884     }
2885     break;
2886 #endif
2887   }
2888   case CURLOPT_CONNECT_TO:
2889     data->set.connect_to = va_arg(param, struct curl_slist *);
2890     break;
2891   default:
2892     /* unknown tag and its companion, just ignore: */
2893     result = CURLE_UNKNOWN_OPTION;
2894     break;
2895   }
2896
2897   return result;
2898 }
2899
2900 #ifdef USE_RECV_BEFORE_SEND_WORKAROUND
2901 static void conn_reset_postponed_data(struct connectdata *conn, int num)
2902 {
2903   struct postponed_data * const psnd = &(conn->postponed[num]);
2904   if(psnd->buffer) {
2905     DEBUGASSERT(psnd->allocated_size > 0);
2906     DEBUGASSERT(psnd->recv_size <= psnd->allocated_size);
2907     DEBUGASSERT(psnd->recv_size ?
2908                 (psnd->recv_processed < psnd->recv_size) :
2909                 (psnd->recv_processed == 0));
2910     DEBUGASSERT(psnd->bindsock != CURL_SOCKET_BAD);
2911     free(psnd->buffer);
2912     psnd->buffer = NULL;
2913     psnd->allocated_size = 0;
2914     psnd->recv_size = 0;
2915     psnd->recv_processed = 0;
2916 #ifdef DEBUGBUILD
2917     psnd->bindsock = CURL_SOCKET_BAD; /* used only for DEBUGASSERT */
2918 #endif /* DEBUGBUILD */
2919   }
2920   else {
2921     DEBUGASSERT(psnd->allocated_size == 0);
2922     DEBUGASSERT(psnd->recv_size == 0);
2923     DEBUGASSERT(psnd->recv_processed == 0);
2924     DEBUGASSERT(psnd->bindsock == CURL_SOCKET_BAD);
2925   }
2926 }
2927
2928 static void conn_reset_all_postponed_data(struct connectdata *conn)
2929 {
2930   conn_reset_postponed_data(conn, 0);
2931   conn_reset_postponed_data(conn, 1);
2932 }
2933 #else  /* ! USE_RECV_BEFORE_SEND_WORKAROUND */
2934 /* Use "do-nothing" macros instead of functions when workaround not used */
2935 #define conn_reset_postponed_data(c,n) do {} WHILE_FALSE
2936 #define conn_reset_all_postponed_data(c) do {} WHILE_FALSE
2937 #endif /* ! USE_RECV_BEFORE_SEND_WORKAROUND */
2938
2939 static void conn_free(struct connectdata *conn)
2940 {
2941   if(!conn)
2942     return;
2943
2944   /* possible left-overs from the async name resolvers */
2945   Curl_resolver_cancel(conn);
2946
2947   /* close the SSL stuff before we close any sockets since they will/may
2948      write to the sockets */
2949   Curl_ssl_close(conn, FIRSTSOCKET);
2950   Curl_ssl_close(conn, SECONDARYSOCKET);
2951
2952   /* close possibly still open sockets */
2953   if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET])
2954     Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
2955   if(CURL_SOCKET_BAD != conn->sock[FIRSTSOCKET])
2956     Curl_closesocket(conn, conn->sock[FIRSTSOCKET]);
2957   if(CURL_SOCKET_BAD != conn->tempsock[0])
2958     Curl_closesocket(conn, conn->tempsock[0]);
2959   if(CURL_SOCKET_BAD != conn->tempsock[1])
2960     Curl_closesocket(conn, conn->tempsock[1]);
2961
2962 #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) && \
2963     defined(NTLM_WB_ENABLED)
2964   Curl_ntlm_wb_cleanup(conn);
2965 #endif
2966
2967   Curl_safefree(conn->user);
2968   Curl_safefree(conn->passwd);
2969   Curl_safefree(conn->oauth_bearer);
2970   Curl_safefree(conn->options);
2971   Curl_safefree(conn->http_proxy.user);
2972   Curl_safefree(conn->socks_proxy.user);
2973   Curl_safefree(conn->http_proxy.passwd);
2974   Curl_safefree(conn->socks_proxy.passwd);
2975   Curl_safefree(conn->allocptr.proxyuserpwd);
2976   Curl_safefree(conn->allocptr.uagent);
2977   Curl_safefree(conn->allocptr.userpwd);
2978   Curl_safefree(conn->allocptr.accept_encoding);
2979   Curl_safefree(conn->allocptr.te);
2980   Curl_safefree(conn->allocptr.rangeline);
2981   Curl_safefree(conn->allocptr.ref);
2982   Curl_safefree(conn->allocptr.host);
2983   Curl_safefree(conn->allocptr.cookiehost);
2984   Curl_safefree(conn->allocptr.rtsp_transport);
2985   Curl_safefree(conn->trailer);
2986   Curl_safefree(conn->host.rawalloc); /* host name buffer */
2987   Curl_safefree(conn->conn_to_host.rawalloc); /* host name buffer */
2988   Curl_safefree(conn->secondaryhostname);
2989   Curl_safefree(conn->http_proxy.host.rawalloc); /* http proxy name buffer */
2990   Curl_safefree(conn->socks_proxy.host.rawalloc); /* socks proxy name buffer */
2991   Curl_safefree(conn->master_buffer);
2992
2993   conn_reset_all_postponed_data(conn);
2994
2995   Curl_llist_destroy(conn->send_pipe, NULL);
2996   Curl_llist_destroy(conn->recv_pipe, NULL);
2997
2998   conn->send_pipe = NULL;
2999   conn->recv_pipe = NULL;
3000
3001   Curl_safefree(conn->localdev);
3002   Curl_free_primary_ssl_config(&conn->ssl_config);
3003   Curl_free_primary_ssl_config(&conn->proxy_ssl_config);
3004
3005 #ifdef USE_UNIX_SOCKETS
3006   Curl_safefree(conn->unix_domain_socket);
3007 #endif
3008
3009   free(conn); /* free all the connection oriented data */
3010 }
3011
3012 /*
3013  * Disconnects the given connection. Note the connection may not be the
3014  * primary connection, like when freeing room in the connection cache or
3015  * killing of a dead old connection.
3016  *
3017  * This function MUST NOT reset state in the Curl_easy struct if that
3018  * isn't strictly bound to the life-time of *this* particular connection.
3019  *
3020  */
3021
3022 CURLcode Curl_disconnect(struct connectdata *conn, bool dead_connection)
3023 {
3024   struct Curl_easy *data;
3025   if(!conn)
3026     return CURLE_OK; /* this is closed and fine already */
3027   data = conn->data;
3028
3029   if(!data) {
3030     DEBUGF(fprintf(stderr, "DISCONNECT without easy handle, ignoring\n"));
3031     return CURLE_OK;
3032   }
3033
3034   /*
3035    * If this connection isn't marked to force-close, leave it open if there
3036    * are other users of it
3037    */
3038   if(!conn->bits.close &&
3039      (conn->send_pipe->size + conn->recv_pipe->size)) {
3040     DEBUGF(infof(data, "Curl_disconnect, usecounter: %d\n",
3041                  conn->send_pipe->size + conn->recv_pipe->size));
3042     return CURLE_OK;
3043   }
3044
3045   if(conn->dns_entry != NULL) {
3046     Curl_resolv_unlock(data, conn->dns_entry);
3047     conn->dns_entry = NULL;
3048   }
3049
3050   Curl_hostcache_prune(data); /* kill old DNS cache entries */
3051
3052 #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM)
3053   /* Cleanup NTLM connection-related data */
3054   Curl_http_ntlm_cleanup(conn);
3055 #endif
3056
3057   if(conn->handler->disconnect)
3058     /* This is set if protocol-specific cleanups should be made */
3059     conn->handler->disconnect(conn, dead_connection);
3060
3061     /* unlink ourselves! */
3062   infof(data, "Closing connection %ld\n", conn->connection_id);
3063   Curl_conncache_remove_conn(data->state.conn_cache, conn);
3064
3065   free_fixed_hostname(&conn->host);
3066   free_fixed_hostname(&conn->conn_to_host);
3067   free_fixed_hostname(&conn->http_proxy.host);
3068   free_fixed_hostname(&conn->socks_proxy.host);
3069
3070   Curl_ssl_close(conn, FIRSTSOCKET);
3071
3072   /* Indicate to all handles on the pipe that we're dead */
3073   if(Curl_pipeline_wanted(data->multi, CURLPIPE_ANY)) {
3074     signalPipeClose(conn->send_pipe, TRUE);
3075     signalPipeClose(conn->recv_pipe, TRUE);
3076   }
3077
3078   conn_free(conn);
3079
3080   return CURLE_OK;
3081 }
3082
3083 /*
3084  * This function should return TRUE if the socket is to be assumed to
3085  * be dead. Most commonly this happens when the server has closed the
3086  * connection due to inactivity.
3087  */
3088 static bool SocketIsDead(curl_socket_t sock)
3089 {
3090   int sval;
3091   bool ret_val = TRUE;
3092
3093   sval = SOCKET_READABLE(sock, 0);
3094   if(sval == 0)
3095     /* timeout */
3096     ret_val = FALSE;
3097
3098   return ret_val;
3099 }
3100
3101 /*
3102  * IsPipeliningPossible() returns TRUE if the options set would allow
3103  * pipelining/multiplexing and the connection is using a HTTP protocol.
3104  */
3105 static bool IsPipeliningPossible(const struct Curl_easy *handle,
3106                                  const struct connectdata *conn)
3107 {
3108   /* If a HTTP protocol and pipelining is enabled */
3109   if((conn->handler->protocol & PROTO_FAMILY_HTTP) &&
3110      (!conn->bits.protoconnstart || !conn->bits.close)) {
3111
3112     if(Curl_pipeline_wanted(handle->multi, CURLPIPE_HTTP1) &&
3113        (handle->set.httpversion != CURL_HTTP_VERSION_1_0) &&
3114        (handle->set.httpreq == HTTPREQ_GET ||
3115         handle->set.httpreq == HTTPREQ_HEAD))
3116       /* didn't ask for HTTP/1.0 and a GET or HEAD */
3117       return TRUE;
3118
3119     if(Curl_pipeline_wanted(handle->multi, CURLPIPE_MULTIPLEX) &&
3120        (handle->set.httpversion >= CURL_HTTP_VERSION_2))
3121       /* allows HTTP/2 */
3122       return TRUE;
3123   }
3124   return FALSE;
3125 }
3126
3127 int Curl_removeHandleFromPipeline(struct Curl_easy *handle,
3128                                   struct curl_llist *pipeline)
3129 {
3130   if(pipeline) {
3131     struct curl_llist_element *curr;
3132
3133     curr = pipeline->head;
3134     while(curr) {
3135       if(curr->ptr == handle) {
3136         Curl_llist_remove(pipeline, curr, NULL);
3137         return 1; /* we removed a handle */
3138       }
3139       curr = curr->next;
3140     }
3141   }
3142
3143   return 0;
3144 }
3145
3146 #if 0 /* this code is saved here as it is useful for debugging purposes */
3147 static void Curl_printPipeline(struct curl_llist *pipeline)
3148 {
3149   struct curl_llist_element *curr;
3150
3151   curr = pipeline->head;
3152   while(curr) {
3153     struct Curl_easy *data = (struct Curl_easy *) curr->ptr;
3154     infof(data, "Handle in pipeline: %s\n", data->state.path);
3155     curr = curr->next;
3156   }
3157 }
3158 #endif
3159
3160 static struct Curl_easy* gethandleathead(struct curl_llist *pipeline)
3161 {
3162   struct curl_llist_element *curr = pipeline->head;
3163   if(curr) {
3164     return (struct Curl_easy *) curr->ptr;
3165   }
3166
3167   return NULL;
3168 }
3169
3170 /* remove the specified connection from all (possible) pipelines and related
3171    queues */
3172 void Curl_getoff_all_pipelines(struct Curl_easy *data,
3173                                struct connectdata *conn)
3174 {
3175   bool recv_head = (conn->readchannel_inuse &&
3176                     Curl_recvpipe_head(data, conn));
3177   bool send_head = (conn->writechannel_inuse &&
3178                     Curl_sendpipe_head(data, conn));
3179
3180   if(Curl_removeHandleFromPipeline(data, conn->recv_pipe) && recv_head)
3181     Curl_pipeline_leave_read(conn);
3182   if(Curl_removeHandleFromPipeline(data, conn->send_pipe) && send_head)
3183     Curl_pipeline_leave_write(conn);
3184 }
3185
3186 static void signalPipeClose(struct curl_llist *pipeline, bool pipe_broke)
3187 {
3188   struct curl_llist_element *curr;
3189
3190   if(!pipeline)
3191     return;
3192
3193   curr = pipeline->head;
3194   while(curr) {
3195     struct curl_llist_element *next = curr->next;
3196     struct Curl_easy *data = (struct Curl_easy *) curr->ptr;
3197
3198 #ifdef DEBUGBUILD /* debug-only code */
3199     if(data->magic != CURLEASY_MAGIC_NUMBER) {
3200       /* MAJOR BADNESS */
3201       infof(data, "signalPipeClose() found BAAD easy handle\n");
3202     }
3203 #endif
3204
3205     if(pipe_broke)
3206       data->state.pipe_broke = TRUE;
3207     Curl_multi_handlePipeBreak(data);
3208     Curl_llist_remove(pipeline, curr, NULL);
3209     curr = next;
3210   }
3211 }
3212
3213 /*
3214  * This function finds the connection in the connection
3215  * cache that has been unused for the longest time.
3216  *
3217  * Returns the pointer to the oldest idle connection, or NULL if none was
3218  * found.
3219  */
3220 struct connectdata *
3221 Curl_oldest_idle_connection(struct Curl_easy *data)
3222 {
3223   struct conncache *bc = data->state.conn_cache;
3224   struct curl_hash_iterator iter;
3225   struct curl_llist_element *curr;
3226   struct curl_hash_element *he;
3227   time_t highscore=-1;
3228   time_t score;
3229   struct timeval now;
3230   struct connectdata *conn_candidate = NULL;
3231   struct connectbundle *bundle;
3232
3233   now = Curl_tvnow();
3234
3235   Curl_hash_start_iterate(&bc->hash, &iter);
3236
3237   he = Curl_hash_next_element(&iter);
3238   while(he) {
3239     struct connectdata *conn;
3240
3241     bundle = he->ptr;
3242
3243     curr = bundle->conn_list->head;
3244     while(curr) {
3245       conn = curr->ptr;
3246
3247       if(!conn->inuse) {
3248         /* Set higher score for the age passed since the connection was used */
3249         score = Curl_tvdiff(now, conn->now);
3250
3251         if(score > highscore) {
3252           highscore = score;
3253           conn_candidate = conn;
3254         }
3255       }
3256       curr = curr->next;
3257     }
3258
3259     he = Curl_hash_next_element(&iter);
3260   }
3261
3262   return conn_candidate;
3263 }
3264
3265 static bool
3266 proxy_info_matches(const struct proxy_info* data,
3267                    const struct proxy_info* needle)
3268 {
3269   if((data->proxytype == needle->proxytype) &&
3270      (data->port == needle->port) &&
3271      Curl_safe_strcasecompare(data->host.name, needle->host.name) &&
3272      Curl_safe_strcasecompare(data->user, needle->user) &&
3273      Curl_safe_strcasecompare(data->passwd, needle->passwd))
3274     return TRUE;
3275
3276   return FALSE;
3277 }
3278
3279
3280 /*
3281  * This function finds the connection in the connection
3282  * bundle that has been unused for the longest time.
3283  *
3284  * Returns the pointer to the oldest idle connection, or NULL if none was
3285  * found.
3286  */
3287 static struct connectdata *
3288 find_oldest_idle_connection_in_bundle(struct Curl_easy *data,
3289                                       struct connectbundle *bundle)
3290 {
3291   struct curl_llist_element *curr;
3292   time_t highscore=-1;
3293   time_t score;
3294   struct timeval now;
3295   struct connectdata *conn_candidate = NULL;
3296   struct connectdata *conn;
3297
3298   (void)data;
3299
3300   now = Curl_tvnow();
3301
3302   curr = bundle->conn_list->head;
3303   while(curr) {
3304     conn = curr->ptr;
3305
3306     if(!conn->inuse) {
3307       /* Set higher score for the age passed since the connection was used */
3308       score = Curl_tvdiff(now, conn->now);
3309
3310       if(score > highscore) {
3311         highscore = score;
3312         conn_candidate = conn;
3313       }
3314     }
3315     curr = curr->next;
3316   }
3317
3318   return conn_candidate;
3319 }
3320
3321 /*
3322  * This function checks if given connection is dead and disconnects if so.
3323  * (That also removes it from the connection cache.)
3324  *
3325  * Returns TRUE if the connection actually was dead and disconnected.
3326  */
3327 static bool disconnect_if_dead(struct connectdata *conn,
3328                                struct Curl_easy *data)
3329 {
3330   size_t pipeLen = conn->send_pipe->size + conn->recv_pipe->size;
3331   if(!pipeLen && !conn->inuse) {
3332     /* The check for a dead socket makes sense only if there are no
3333        handles in pipeline and the connection isn't already marked in
3334        use */
3335     bool dead;
3336     if(conn->handler->protocol & CURLPROTO_RTSP)
3337       /* RTSP is a special case due to RTP interleaving */
3338       dead = Curl_rtsp_connisdead(conn);
3339     else
3340       dead = SocketIsDead(conn->sock[FIRSTSOCKET]);
3341
3342     if(dead) {
3343       conn->data = data;
3344       infof(data, "Connection %ld seems to be dead!\n", conn->connection_id);
3345
3346       /* disconnect resources */
3347       Curl_disconnect(conn, /* dead_connection */TRUE);
3348       return TRUE;
3349     }
3350   }
3351   return FALSE;
3352 }
3353
3354 /*
3355  * Wrapper to use disconnect_if_dead() function in Curl_conncache_foreach()
3356  *
3357  * Returns always 0.
3358  */
3359 static int call_disconnect_if_dead(struct connectdata *conn,
3360                                       void *param)
3361 {
3362   struct Curl_easy* data = (struct Curl_easy*)param;
3363   disconnect_if_dead(conn, data);
3364   return 0; /* continue iteration */
3365 }
3366
3367 /*
3368  * This function scans the connection cache for half-open/dead connections,
3369  * closes and removes them.
3370  * The cleanup is done at most once per second.
3371  */
3372 static void prune_dead_connections(struct Curl_easy *data)
3373 {
3374   struct timeval now = Curl_tvnow();
3375   time_t elapsed = Curl_tvdiff(now, data->state.conn_cache->last_cleanup);
3376
3377   if(elapsed >= 1000L) {
3378     Curl_conncache_foreach(data->state.conn_cache, data,
3379                            call_disconnect_if_dead);
3380     data->state.conn_cache->last_cleanup = now;
3381   }
3382 }
3383
3384
3385 static size_t max_pipeline_length(struct Curl_multi *multi)
3386 {
3387   return multi ? multi->max_pipeline_length : 0;
3388 }
3389
3390
3391 /*
3392  * Given one filled in connection struct (named needle), this function should
3393  * detect if there already is one that has all the significant details
3394  * exactly the same and thus should be used instead.
3395  *
3396  * If there is a match, this function returns TRUE - and has marked the
3397  * connection as 'in-use'. It must later be called with ConnectionDone() to
3398  * return back to 'idle' (unused) state.
3399  *
3400  * The force_reuse flag is set if the connection must be used, even if
3401  * the pipelining strategy wants to open a new connection instead of reusing.
3402  */
3403 static bool
3404 ConnectionExists(struct Curl_easy *data,
3405                  struct connectdata *needle,
3406                  struct connectdata **usethis,
3407                  bool *force_reuse,
3408                  bool *waitpipe)
3409 {
3410   struct connectdata *check;
3411   struct connectdata *chosen = 0;
3412   bool foundPendingCandidate = FALSE;
3413   bool canPipeline = IsPipeliningPossible(data, needle);
3414   struct connectbundle *bundle;
3415
3416 #ifdef USE_NTLM
3417   bool wantNTLMhttp = ((data->state.authhost.want &
3418                       (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
3419                       (needle->handler->protocol & PROTO_FAMILY_HTTP));
3420   bool wantProxyNTLMhttp = (needle->bits.proxy_user_passwd &&
3421                            ((data->state.authproxy.want &
3422                            (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
3423                            (needle->handler->protocol & PROTO_FAMILY_HTTP)));
3424 #endif
3425
3426   *force_reuse = FALSE;
3427   *waitpipe = FALSE;
3428
3429   /* We can't pipe if the site is blacklisted */
3430   if(canPipeline && Curl_pipeline_site_blacklisted(data, needle)) {
3431     canPipeline = FALSE;
3432   }
3433
3434   /* Look up the bundle with all the connections to this
3435      particular host */
3436   bundle = Curl_conncache_find_bundle(needle, data->state.conn_cache);
3437   if(bundle) {
3438     /* Max pipe length is zero (unlimited) for multiplexed connections */
3439     size_t max_pipe_len = (bundle->multiuse != BUNDLE_MULTIPLEX)?
3440       max_pipeline_length(data->multi):0;
3441     size_t best_pipe_len = max_pipe_len;
3442     struct curl_llist_element *curr;
3443
3444     infof(data, "Found bundle for host %s: %p [%s]\n",
3445           (needle->bits.conn_to_host ? needle->conn_to_host.name :
3446            needle->host.name), (void *)bundle,
3447           (bundle->multiuse == BUNDLE_PIPELINING ?
3448            "can pipeline" :
3449            (bundle->multiuse == BUNDLE_MULTIPLEX ?
3450             "can multiplex" : "serially")));
3451
3452     /* We can't pipe if we don't know anything about the server */
3453     if(canPipeline) {
3454       if(bundle->multiuse <= BUNDLE_UNKNOWN) {
3455         if((bundle->multiuse == BUNDLE_UNKNOWN) && data->set.pipewait) {
3456           infof(data, "Server doesn't support multi-use yet, wait\n");
3457           *waitpipe = TRUE;
3458           return FALSE; /* no re-use */
3459         }
3460
3461         infof(data, "Server doesn't support multi-use (yet)\n");
3462         canPipeline = FALSE;
3463       }
3464       if((bundle->multiuse == BUNDLE_PIPELINING) &&
3465          !Curl_pipeline_wanted(data->multi, CURLPIPE_HTTP1)) {
3466         /* not asked for, switch off */
3467         infof(data, "Could pipeline, but not asked to!\n");
3468         canPipeline = FALSE;
3469       }
3470       else if((bundle->multiuse == BUNDLE_MULTIPLEX) &&
3471               !Curl_pipeline_wanted(data->multi, CURLPIPE_MULTIPLEX)) {
3472         infof(data, "Could multiplex, but not asked to!\n");
3473         canPipeline = FALSE;
3474       }
3475     }
3476
3477     curr = bundle->conn_list->head;
3478     while(curr) {
3479       bool match = FALSE;
3480       size_t pipeLen;
3481
3482       /*
3483        * Note that if we use a HTTP proxy in normal mode (no tunneling), we
3484        * check connections to that proxy and not to the actual remote server.
3485        */
3486       check = curr->ptr;
3487       curr = curr->next;
3488
3489       if(disconnect_if_dead(check, data))
3490         continue;
3491
3492       pipeLen = check->send_pipe->size + check->recv_pipe->size;
3493
3494       if(canPipeline) {
3495         if(check->bits.protoconnstart && check->bits.close)
3496           continue;
3497
3498         if(!check->bits.multiplex) {
3499           /* If not multiplexing, make sure the pipe has only GET requests */
3500           struct Curl_easy* sh = gethandleathead(check->send_pipe);
3501           struct Curl_easy* rh = gethandleathead(check->recv_pipe);
3502           if(sh) {
3503             if(!IsPipeliningPossible(sh, check))
3504               continue;
3505           }
3506           else if(rh) {
3507             if(!IsPipeliningPossible(rh, check))
3508               continue;
3509           }
3510         }
3511       }
3512       else {
3513         if(pipeLen > 0) {
3514           /* can only happen within multi handles, and means that another easy
3515              handle is using this connection */
3516           continue;
3517         }
3518
3519         if(Curl_resolver_asynch()) {
3520           /* ip_addr_str[0] is NUL only if the resolving of the name hasn't
3521              completed yet and until then we don't re-use this connection */
3522           if(!check->ip_addr_str[0]) {
3523             infof(data,
3524                   "Connection #%ld is still name resolving, can't reuse\n",
3525                   check->connection_id);
3526             continue;
3527           }
3528         }
3529
3530         if((check->sock[FIRSTSOCKET] == CURL_SOCKET_BAD) ||
3531            check->bits.close) {
3532           if(!check->bits.close)
3533             foundPendingCandidate = TRUE;
3534           /* Don't pick a connection that hasn't connected yet or that is going
3535              to get closed. */
3536           infof(data, "Connection #%ld isn't open enough, can't reuse\n",
3537                 check->connection_id);
3538 #ifdef DEBUGBUILD
3539           if(check->recv_pipe->size > 0) {
3540             infof(data,
3541                   "BAD! Unconnected #%ld has a non-empty recv pipeline!\n",
3542                   check->connection_id);
3543           }
3544 #endif
3545           continue;
3546         }
3547       }
3548
3549 #ifdef USE_UNIX_SOCKETS
3550       if(needle->unix_domain_socket) {
3551         if(!check->unix_domain_socket)
3552           continue;
3553         if(strcmp(needle->unix_domain_socket, check->unix_domain_socket))
3554           continue;
3555         if(needle->abstract_unix_socket != check->abstract_unix_socket)
3556           continue;
3557       }
3558       else if(check->unix_domain_socket)
3559         continue;
3560 #endif
3561
3562       if((needle->handler->flags&PROTOPT_SSL) !=
3563          (check->handler->flags&PROTOPT_SSL))
3564         /* don't do mixed SSL and non-SSL connections */
3565         if(get_protocol_family(check->handler->protocol) !=
3566            needle->handler->protocol || !check->tls_upgraded)
3567           /* except protocols that have been upgraded via TLS */
3568           continue;
3569
3570       if(needle->bits.httpproxy != check->bits.httpproxy ||
3571          needle->bits.socksproxy != check->bits.socksproxy)
3572         continue;
3573
3574       if(needle->bits.socksproxy && !proxy_info_matches(&needle->socks_proxy,
3575                                                         &check->socks_proxy))
3576         continue;
3577
3578       if(needle->bits.conn_to_host != check->bits.conn_to_host)
3579         /* don't mix connections that use the "connect to host" feature and
3580          * connections that don't use this feature */
3581         continue;
3582
3583       if(needle->bits.conn_to_port != check->bits.conn_to_port)
3584         /* don't mix connections that use the "connect to port" feature and
3585          * connections that don't use this feature */
3586         continue;
3587
3588       if(needle->bits.httpproxy) {
3589         if(!proxy_info_matches(&needle->http_proxy, &check->http_proxy))
3590           continue;
3591
3592         if(needle->bits.tunnel_proxy != check->bits.tunnel_proxy)
3593           continue;
3594
3595         if(needle->http_proxy.proxytype == CURLPROXY_HTTPS) {
3596           /* use https proxy */
3597           if(needle->handler->flags&PROTOPT_SSL) {
3598             /* use double layer ssl */
3599             if(!Curl_ssl_config_matches(&needle->proxy_ssl_config,
3600                                         &check->proxy_ssl_config))
3601               continue;
3602             if(check->proxy_ssl[FIRSTSOCKET].state != ssl_connection_complete)
3603               continue;
3604           }
3605           else {
3606             if(!Curl_ssl_config_matches(&needle->ssl_config,
3607                                         &check->ssl_config))
3608               continue;
3609             if(check->ssl[FIRSTSOCKET].state != ssl_connection_complete)
3610               continue;
3611           }
3612         }
3613       }
3614
3615       if(!canPipeline && check->inuse)
3616         /* this request can't be pipelined but the checked connection is
3617            already in use so we skip it */
3618         continue;
3619
3620       if(needle->localdev || needle->localport) {
3621         /* If we are bound to a specific local end (IP+port), we must not
3622            re-use a random other one, although if we didn't ask for a
3623            particular one we can reuse one that was bound.
3624
3625            This comparison is a bit rough and too strict. Since the input
3626            parameters can be specified in numerous ways and still end up the
3627            same it would take a lot of processing to make it really accurate.
3628            Instead, this matching will assume that re-uses of bound connections
3629            will most likely also re-use the exact same binding parameters and
3630            missing out a few edge cases shouldn't hurt anyone very much.
3631         */
3632         if((check->localport != needle->localport) ||
3633            (check->localportrange != needle->localportrange) ||
3634            (needle->localdev &&
3635             (!check->localdev || strcmp(check->localdev, needle->localdev))))
3636           continue;
3637       }
3638
3639       if(!(needle->handler->flags & PROTOPT_CREDSPERREQUEST)) {
3640         /* This protocol requires credentials per connection,
3641            so verify that we're using the same name and password as well */
3642         if(strcmp(needle->user, check->user) ||
3643            strcmp(needle->passwd, check->passwd)) {
3644           /* one of them was different */
3645           continue;
3646         }
3647       }
3648
3649       if(!needle->bits.httpproxy || (needle->handler->flags&PROTOPT_SSL) ||
3650          needle->bits.tunnel_proxy) {
3651         /* The requested connection does not use a HTTP proxy or it uses SSL or
3652            it is a non-SSL protocol tunneled or it is a non-SSL protocol which
3653            is allowed to be upgraded via TLS */
3654
3655         if((strcasecompare(needle->handler->scheme, check->handler->scheme) ||
3656             (get_protocol_family(check->handler->protocol) ==
3657              needle->handler->protocol && check->tls_upgraded)) &&
3658            (!needle->bits.conn_to_host || strcasecompare(
3659             needle->conn_to_host.name, check->conn_to_host.name)) &&
3660            (!needle->bits.conn_to_port ||
3661              needle->conn_to_port == check->conn_to_port) &&
3662            strcasecompare(needle->host.name, check->host.name) &&
3663            needle->remote_port == check->remote_port) {
3664           /* The schemes match or the the protocol family is the same and the
3665              previous connection was TLS upgraded, and the hostname and host
3666              port match */
3667           if(needle->handler->flags & PROTOPT_SSL) {
3668             /* This is a SSL connection so verify that we're using the same
3669                SSL options as well */
3670             if(!Curl_ssl_config_matches(&needle->ssl_config,
3671                                         &check->ssl_config)) {
3672               DEBUGF(infof(data,
3673                            "Connection #%ld has different SSL parameters, "
3674                            "can't reuse\n",
3675                            check->connection_id));
3676               continue;
3677             }
3678             else if(check->ssl[FIRSTSOCKET].state != ssl_connection_complete) {
3679               foundPendingCandidate = TRUE;
3680               DEBUGF(infof(data,
3681                            "Connection #%ld has not started SSL connect, "
3682                            "can't reuse\n",
3683                            check->connection_id));
3684               continue;
3685             }
3686           }
3687           match = TRUE;
3688         }
3689       }
3690       else {
3691         /* The requested connection is using the same HTTP proxy in normal
3692            mode (no tunneling) */
3693         match = TRUE;
3694       }
3695
3696       if(match) {
3697 #if defined(USE_NTLM)
3698         /* If we are looking for an HTTP+NTLM connection, check if this is
3699            already authenticating with the right credentials. If not, keep
3700            looking so that we can reuse NTLM connections if
3701            possible. (Especially we must not reuse the same connection if
3702            partway through a handshake!) */
3703         if(wantNTLMhttp) {
3704           if(strcmp(needle->user, check->user) ||
3705              strcmp(needle->passwd, check->passwd))
3706             continue;
3707         }
3708         else if(check->ntlm.state != NTLMSTATE_NONE) {
3709           /* Connection is using NTLM auth but we don't want NTLM */
3710           continue;
3711         }
3712
3713         /* Same for Proxy NTLM authentication */
3714         if(wantProxyNTLMhttp) {
3715           /* Both check->http_proxy.user and check->http_proxy.passwd can be
3716            * NULL */
3717           if(!check->http_proxy.user || !check->http_proxy.passwd)
3718             continue;
3719
3720           if(strcmp(needle->http_proxy.user, check->http_proxy.user) ||
3721              strcmp(needle->http_proxy.passwd, check->http_proxy.passwd))
3722             continue;
3723         }
3724         else if(check->proxyntlm.state != NTLMSTATE_NONE) {
3725           /* Proxy connection is using NTLM auth but we don't want NTLM */
3726           continue;
3727         }
3728
3729         if(wantNTLMhttp || wantProxyNTLMhttp) {
3730           /* Credentials are already checked, we can use this connection */
3731           chosen = check;
3732
3733           if((wantNTLMhttp &&
3734              (check->ntlm.state != NTLMSTATE_NONE)) ||
3735               (wantProxyNTLMhttp &&
3736                (check->proxyntlm.state != NTLMSTATE_NONE))) {
3737             /* We must use this connection, no other */
3738             *force_reuse = TRUE;
3739             break;
3740           }
3741
3742           /* Continue look up for a better connection */
3743           continue;
3744         }
3745 #endif
3746         if(canPipeline) {
3747           /* We can pipeline if we want to. Let's continue looking for
3748              the optimal connection to use, i.e the shortest pipe that is not
3749              blacklisted. */
3750
3751           if(pipeLen == 0) {
3752             /* We have the optimal connection. Let's stop looking. */
3753             chosen = check;
3754             break;
3755           }
3756
3757           /* We can't use the connection if the pipe is full */
3758           if(max_pipe_len && (pipeLen >= max_pipe_len)) {
3759             infof(data, "Pipe is full, skip (%zu)\n", pipeLen);
3760             continue;
3761           }
3762 #ifdef USE_NGHTTP2
3763           /* If multiplexed, make sure we don't go over concurrency limit */
3764           if(check->bits.multiplex) {
3765             /* Multiplexed connections can only be HTTP/2 for now */
3766             struct http_conn *httpc = &check->proto.httpc;
3767             if(pipeLen >= httpc->settings.max_concurrent_streams) {
3768               infof(data, "MAX_CONCURRENT_STREAMS reached, skip (%zu)\n",
3769                     pipeLen);
3770               continue;
3771             }
3772           }
3773 #endif
3774           /* We can't use the connection if the pipe is penalized */
3775           if(Curl_pipeline_penalized(data, check)) {
3776             infof(data, "Penalized, skip\n");
3777             continue;
3778           }
3779
3780           if(max_pipe_len) {
3781             if(pipeLen < best_pipe_len) {
3782               /* This connection has a shorter pipe so far. We'll pick this
3783                  and continue searching */
3784               chosen = check;
3785               best_pipe_len = pipeLen;
3786               continue;
3787             }
3788           }
3789           else {
3790             /* When not pipelining (== multiplexed), we have a match here! */
3791             chosen = check;
3792             infof(data, "Multiplexed connection found!\n");
3793             break;
3794           }
3795         }
3796         else {
3797           /* We have found a connection. Let's stop searching. */
3798           chosen = check;
3799           break;
3800         }
3801       }
3802     }
3803   }
3804
3805   if(chosen) {
3806     *usethis = chosen;
3807     return TRUE; /* yes, we found one to use! */
3808   }
3809
3810   if(foundPendingCandidate && data->set.pipewait) {
3811     infof(data,
3812           "Found pending candidate for reuse and CURLOPT_PIPEWAIT is set\n");
3813     *waitpipe = TRUE;
3814   }
3815
3816   return FALSE; /* no matching connecting exists */
3817 }
3818
3819 /* after a TCP connection to the proxy has been verified, this function does
3820    the next magic step.
3821
3822    Note: this function's sub-functions call failf()
3823
3824 */
3825 CURLcode Curl_connected_proxy(struct connectdata *conn, int sockindex)
3826 {
3827   CURLcode result = CURLE_OK;
3828
3829   if(conn->bits.socksproxy) {
3830 #ifndef CURL_DISABLE_PROXY
3831     /* for the secondary socket (FTP), use the "connect to host"
3832      * but ignore the "connect to port" (use the secondary port)
3833      */
3834     const char * const host = conn->bits.httpproxy ?
3835                               conn->http_proxy.host.name :
3836                               conn->bits.conn_to_host ?
3837                               conn->conn_to_host.name :
3838                               sockindex == SECONDARYSOCKET ?
3839                               conn->secondaryhostname : conn->host.name;
3840     const int port = conn->bits.httpproxy ? (int)conn->http_proxy.port :
3841                      sockindex == SECONDARYSOCKET ? conn->secondary_port :
3842                      conn->bits.conn_to_port ? conn->conn_to_port :
3843                      conn->remote_port;
3844     conn->bits.socksproxy_connecting = TRUE;
3845     switch(conn->socks_proxy.proxytype) {
3846     case CURLPROXY_SOCKS5:
3847     case CURLPROXY_SOCKS5_HOSTNAME:
3848       result = Curl_SOCKS5(conn->socks_proxy.user, conn->socks_proxy.passwd,
3849                          host, port, sockindex, conn);
3850       break;
3851
3852     case CURLPROXY_SOCKS4:
3853     case CURLPROXY_SOCKS4A:
3854       result = Curl_SOCKS4(conn->socks_proxy.user, host, port, sockindex,
3855                            conn);
3856       break;
3857
3858     default:
3859       failf(conn->data, "unknown proxytype option given");
3860       result = CURLE_COULDNT_CONNECT;
3861     } /* switch proxytype */
3862     conn->bits.socksproxy_connecting = FALSE;
3863 #else
3864   (void)sockindex;
3865 #endif /* CURL_DISABLE_PROXY */
3866   }
3867
3868   return result;
3869 }
3870
3871 /*
3872  * verboseconnect() displays verbose information after a connect
3873  */
3874 #ifndef CURL_DISABLE_VERBOSE_STRINGS
3875 void Curl_verboseconnect(struct connectdata *conn)
3876 {
3877   if(conn->data->set.verbose)
3878     infof(conn->data, "Connected to %s (%s) port %ld (#%ld)\n",
3879           conn->bits.socksproxy ? conn->socks_proxy.host.dispname :
3880           conn->bits.httpproxy ? conn->http_proxy.host.dispname :
3881           conn->bits.conn_to_host ? conn->conn_to_host.dispname :
3882           conn->host.dispname,
3883           conn->ip_addr_str, conn->port, conn->connection_id);
3884 }
3885 #endif
3886
3887 int Curl_protocol_getsock(struct connectdata *conn,
3888                           curl_socket_t *socks,
3889                           int numsocks)
3890 {
3891   if(conn->handler->proto_getsock)
3892     return conn->handler->proto_getsock(conn, socks, numsocks);
3893   return GETSOCK_BLANK;
3894 }
3895
3896 int Curl_doing_getsock(struct connectdata *conn,
3897                        curl_socket_t *socks,
3898                        int numsocks)
3899 {
3900   if(conn && conn->handler->doing_getsock)
3901     return conn->handler->doing_getsock(conn, socks, numsocks);
3902   return GETSOCK_BLANK;
3903 }
3904
3905 /*
3906  * We are doing protocol-specific connecting and this is being called over and
3907  * over from the multi interface until the connection phase is done on
3908  * protocol layer.
3909  */
3910
3911 CURLcode Curl_protocol_connecting(struct connectdata *conn,
3912                                   bool *done)
3913 {
3914   CURLcode result=CURLE_OK;
3915
3916   if(conn && conn->handler->connecting) {
3917     *done = FALSE;
3918     result = conn->handler->connecting(conn, done);
3919   }
3920   else
3921     *done = TRUE;
3922
3923   return result;
3924 }
3925
3926 /*
3927  * We are DOING this is being called over and over from the multi interface
3928  * until the DOING phase is done on protocol layer.
3929  */
3930
3931 CURLcode Curl_protocol_doing(struct connectdata *conn, bool *done)
3932 {
3933   CURLcode result=CURLE_OK;
3934
3935   if(conn && conn->handler->doing) {
3936     *done = FALSE;
3937     result = conn->handler->doing(conn, done);
3938   }
3939   else
3940     *done = TRUE;
3941
3942   return result;
3943 }
3944
3945 /*
3946  * We have discovered that the TCP connection has been successful, we can now
3947  * proceed with some action.
3948  *
3949  */
3950 CURLcode Curl_protocol_connect(struct connectdata *conn,
3951                                bool *protocol_done)
3952 {
3953   CURLcode result=CURLE_OK;
3954
3955   *protocol_done = FALSE;
3956
3957   if(conn->bits.tcpconnect[FIRSTSOCKET] && conn->bits.protoconnstart) {
3958     /* We already are connected, get back. This may happen when the connect
3959        worked fine in the first call, like when we connect to a local server
3960        or proxy. Note that we don't know if the protocol is actually done.
3961
3962        Unless this protocol doesn't have any protocol-connect callback, as
3963        then we know we're done. */
3964     if(!conn->handler->connecting)
3965       *protocol_done = TRUE;
3966
3967     return CURLE_OK;
3968   }
3969
3970   if(!conn->bits.protoconnstart) {
3971
3972     result = Curl_proxy_connect(conn, FIRSTSOCKET);
3973     if(result)
3974       return result;
3975
3976     if(CONNECT_FIRSTSOCKET_PROXY_SSL())
3977       /* wait for HTTPS proxy SSL initialization to complete */
3978       return CURLE_OK;
3979
3980     if(conn->bits.tunnel_proxy && conn->bits.httpproxy &&
3981        (conn->tunnel_state[FIRSTSOCKET] != TUNNEL_COMPLETE))
3982       /* when using an HTTP tunnel proxy, await complete tunnel establishment
3983          before proceeding further. Return CURLE_OK so we'll be called again */
3984       return CURLE_OK;
3985
3986     if(conn->handler->connect_it) {
3987       /* is there a protocol-specific connect() procedure? */
3988
3989       /* Call the protocol-specific connect function */
3990       result = conn->handler->connect_it(conn, protocol_done);
3991     }
3992     else
3993       *protocol_done = TRUE;
3994
3995     /* it has started, possibly even completed but that knowledge isn't stored
3996        in this bit! */
3997     if(!result)
3998       conn->bits.protoconnstart = TRUE;
3999   }
4000
4001   return result; /* pass back status */
4002 }
4003
4004 /*
4005  * Helpers for IDNA convertions.
4006  */
4007 static bool is_ASCII_name(const char *hostname)
4008 {
4009   const unsigned char *ch = (const unsigned char *)hostname;
4010
4011   while(*ch) {
4012     if(*ch++ & 0x80)
4013       return FALSE;
4014   }
4015   return TRUE;
4016 }
4017
4018 /*
4019  * Perform any necessary IDN conversion of hostname
4020  */
4021 static void fix_hostname(struct connectdata *conn, struct hostname *host)
4022 {
4023   size_t len;
4024   struct Curl_easy *data = conn->data;
4025
4026 #ifndef USE_LIBIDN2
4027   (void)data;
4028   (void)conn;
4029 #elif defined(CURL_DISABLE_VERBOSE_STRINGS)
4030   (void)conn;
4031 #endif
4032
4033   /* set the name we use to display the host name */
4034   host->dispname = host->name;
4035
4036   len = strlen(host->name);
4037   if(len && (host->name[len-1] == '.'))
4038     /* strip off a single trailing dot if present, primarily for SNI but
4039        there's no use for it */
4040     host->name[len-1]=0;
4041
4042   /* Check name for non-ASCII and convert hostname to ACE form if we can */
4043   if(!is_ASCII_name(host->name)) {
4044 #ifdef USE_LIBIDN2
4045     if(idn2_check_version(IDN2_VERSION)) {
4046       char *ace_hostname = NULL;
4047 #if IDN2_VERSION_NUMBER >= 0x00140000
4048       /* IDN2_NFC_INPUT: Normalize input string using normalization form C.
4049          IDN2_NONTRANSITIONAL: Perform Unicode TR46 non-transitional
4050          processing. */
4051       int flags = IDN2_NFC_INPUT | IDN2_NONTRANSITIONAL;
4052 #else
4053       int flags = IDN2_NFC_INPUT;
4054 #endif
4055       int rc = idn2_lookup_ul((const char *)host->name, &ace_hostname, flags);
4056       if(rc == IDN2_OK) {
4057         host->encalloc = (char *)ace_hostname;
4058         /* change the name pointer to point to the encoded hostname */
4059         host->name = host->encalloc;
4060       }
4061       else
4062         infof(data, "Failed to convert %s to ACE; %s\n", host->name,
4063               idn2_strerror(rc));
4064     }
4065 #elif defined(USE_WIN32_IDN)
4066     char *ace_hostname = NULL;
4067
4068     if(curl_win32_idn_to_ascii(host->name, &ace_hostname)) {
4069       host->encalloc = ace_hostname;
4070       /* change the name pointer to point to the encoded hostname */
4071       host->name = host->encalloc;
4072     }
4073     else
4074       infof(data, "Failed to convert %s to ACE;\n", host->name);
4075 #else
4076     infof(data, "IDN support not present, can't parse Unicode domains\n");
4077 #endif
4078   }
4079 }
4080
4081 /*
4082  * Frees data allocated by fix_hostname()
4083  */
4084 static void free_fixed_hostname(struct hostname *host)
4085 {
4086 #if defined(USE_LIBIDN2)
4087   if(host->encalloc) {
4088     idn2_free(host->encalloc); /* must be freed with idn2_free() since this was
4089                                  allocated by libidn */
4090     host->encalloc = NULL;
4091   }
4092 #elif defined(USE_WIN32_IDN)
4093   free(host->encalloc); /* must be freed withidn_free() since this was
4094                            allocated by curl_win32_idn_to_ascii */
4095   host->encalloc = NULL;
4096 #else
4097   (void)host;
4098 #endif
4099 }
4100
4101 static void llist_dtor(void *user, void *element)
4102 {
4103   (void)user;
4104   (void)element;
4105   /* Do nothing */
4106 }
4107
4108 /*
4109  * Allocate and initialize a new connectdata object.
4110  */
4111 static struct connectdata *allocate_conn(struct Curl_easy *data)
4112 {
4113   struct connectdata *conn = calloc(1, sizeof(struct connectdata));
4114   if(!conn)
4115     return NULL;
4116
4117   conn->handler = &Curl_handler_dummy;  /* Be sure we have a handler defined
4118                                            already from start to avoid NULL
4119                                            situations and checks */
4120
4121   /* and we setup a few fields in case we end up actually using this struct */
4122
4123   conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD;     /* no file descriptor */
4124   conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
4125   conn->tempsock[0] = CURL_SOCKET_BAD; /* no file descriptor */
4126   conn->tempsock[1] = CURL_SOCKET_BAD; /* no file descriptor */
4127   conn->connection_id = -1;    /* no ID */
4128   conn->port = -1; /* unknown at this point */
4129   conn->remote_port = -1; /* unknown at this point */
4130 #if defined(USE_RECV_BEFORE_SEND_WORKAROUND) && defined(DEBUGBUILD)
4131   conn->postponed[0].bindsock = CURL_SOCKET_BAD; /* no file descriptor */
4132   conn->postponed[1].bindsock = CURL_SOCKET_BAD; /* no file descriptor */
4133 #endif /* USE_RECV_BEFORE_SEND_WORKAROUND && DEBUGBUILD */
4134
4135   /* Default protocol-independent behavior doesn't support persistent
4136      connections, so we set this to force-close. Protocols that support
4137      this need to set this to FALSE in their "curl_do" functions. */
4138   connclose(conn, "Default to force-close");
4139
4140   /* Store creation time to help future close decision making */
4141   conn->created = Curl_tvnow();
4142
4143   conn->data = data; /* Setup the association between this connection
4144                         and the Curl_easy */
4145
4146   conn->http_proxy.proxytype = data->set.proxytype;
4147   conn->socks_proxy.proxytype = CURLPROXY_SOCKS4;
4148
4149 #ifdef CURL_DISABLE_PROXY
4150
4151   conn->bits.proxy = FALSE;
4152   conn->bits.httpproxy = FALSE;
4153   conn->bits.socksproxy = FALSE;
4154   conn->bits.proxy_user_passwd = FALSE;
4155   conn->bits.tunnel_proxy = FALSE;
4156
4157 #else /* CURL_DISABLE_PROXY */
4158
4159   /* note that these two proxy bits are now just on what looks to be
4160      requested, they may be altered down the road */
4161   conn->bits.proxy = (data->set.str[STRING_PROXY] &&
4162                       *data->set.str[STRING_PROXY]) ? TRUE : FALSE;
4163   conn->bits.httpproxy = (conn->bits.proxy &&
4164                           (conn->http_proxy.proxytype == CURLPROXY_HTTP ||
4165                            conn->http_proxy.proxytype == CURLPROXY_HTTP_1_0 ||
4166                            conn->http_proxy.proxytype == CURLPROXY_HTTPS)) ?
4167                            TRUE : FALSE;
4168   conn->bits.socksproxy = (conn->bits.proxy &&
4169                            !conn->bits.httpproxy) ? TRUE : FALSE;
4170
4171   if(data->set.str[STRING_PRE_PROXY] && *data->set.str[STRING_PRE_PROXY]) {
4172     conn->bits.proxy = TRUE;
4173     conn->bits.socksproxy = TRUE;
4174   }
4175
4176   conn->bits.proxy_user_passwd =
4177     (data->set.str[STRING_PROXYUSERNAME]) ? TRUE : FALSE;
4178   conn->bits.tunnel_proxy = data->set.tunnel_thru_httpproxy;
4179
4180 #endif /* CURL_DISABLE_PROXY */
4181
4182   conn->bits.user_passwd = (data->set.str[STRING_USERNAME]) ? TRUE : FALSE;
4183   conn->bits.ftp_use_epsv = data->set.ftp_use_epsv;
4184   conn->bits.ftp_use_eprt = data->set.ftp_use_eprt;
4185
4186   conn->ssl_config.verifystatus = data->set.ssl.primary.verifystatus;
4187   conn->ssl_config.verifypeer = data->set.ssl.primary.verifypeer;
4188   conn->ssl_config.verifyhost = data->set.ssl.primary.verifyhost;
4189   conn->proxy_ssl_config.verifystatus =
4190     data->set.proxy_ssl.primary.verifystatus;
4191   conn->proxy_ssl_config.verifypeer = data->set.proxy_ssl.primary.verifypeer;
4192   conn->proxy_ssl_config.verifyhost = data->set.proxy_ssl.primary.verifyhost;
4193
4194   conn->ip_version = data->set.ipver;
4195
4196 #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) && \
4197     defined(NTLM_WB_ENABLED)
4198   conn->ntlm_auth_hlpr_socket = CURL_SOCKET_BAD;
4199   conn->ntlm_auth_hlpr_pid = 0;
4200   conn->challenge_header = NULL;
4201   conn->response_header = NULL;
4202 #endif
4203
4204   if(Curl_pipeline_wanted(data->multi, CURLPIPE_HTTP1) &&
4205      !conn->master_buffer) {
4206     /* Allocate master_buffer to be used for HTTP/1 pipelining */
4207     conn->master_buffer = calloc(BUFSIZE, sizeof(char));
4208     if(!conn->master_buffer)
4209       goto error;
4210   }
4211
4212   /* Initialize the pipeline lists */
4213   conn->send_pipe = Curl_llist_alloc((curl_llist_dtor) llist_dtor);
4214   conn->recv_pipe = Curl_llist_alloc((curl_llist_dtor) llist_dtor);
4215   if(!conn->send_pipe || !conn->recv_pipe)
4216     goto error;
4217
4218 #ifdef HAVE_GSSAPI
4219   conn->data_prot = PROT_CLEAR;
4220 #endif
4221
4222   /* Store the local bind parameters that will be used for this connection */
4223   if(data->set.str[STRING_DEVICE]) {
4224     conn->localdev = strdup(data->set.str[STRING_DEVICE]);
4225     if(!conn->localdev)
4226       goto error;
4227   }
4228   conn->localportrange = data->set.localportrange;
4229   conn->localport = data->set.localport;
4230
4231   /* the close socket stuff needs to be copied to the connection struct as
4232      it may live on without (this specific) Curl_easy */
4233   conn->fclosesocket = data->set.fclosesocket;
4234   conn->closesocket_client = data->set.closesocket_client;
4235
4236   return conn;
4237   error:
4238
4239   Curl_llist_destroy(conn->send_pipe, NULL);
4240   Curl_llist_destroy(conn->recv_pipe, NULL);
4241
4242   conn->send_pipe = NULL;
4243   conn->recv_pipe = NULL;
4244
4245   free(conn->master_buffer);
4246   free(conn->localdev);
4247   free(conn);
4248   return NULL;
4249 }
4250
4251 static CURLcode findprotocol(struct Curl_easy *data,
4252                              struct connectdata *conn,
4253                              const char *protostr)
4254 {
4255   const struct Curl_handler * const *pp;
4256   const struct Curl_handler *p;
4257
4258   /* Scan protocol handler table and match against 'protostr' to set a few
4259      variables based on the URL. Now that the handler may be changed later
4260      when the protocol specific setup function is called. */
4261   for(pp = protocols; (p = *pp) != NULL; pp++) {
4262     if(strcasecompare(p->scheme, protostr)) {
4263       /* Protocol found in table. Check if allowed */
4264       if(!(data->set.allowed_protocols & p->protocol))
4265         /* nope, get out */
4266         break;
4267
4268       /* it is allowed for "normal" request, now do an extra check if this is
4269          the result of a redirect */
4270       if(data->state.this_is_a_follow &&
4271          !(data->set.redir_protocols & p->protocol))
4272         /* nope, get out */
4273         break;
4274
4275       /* Perform setup complement if some. */
4276       conn->handler = conn->given = p;
4277
4278       /* 'port' and 'remote_port' are set in setup_connection_internals() */
4279       return CURLE_OK;
4280     }
4281   }
4282
4283
4284   /* The protocol was not found in the table, but we don't have to assign it
4285      to anything since it is already assigned to a dummy-struct in the
4286      create_conn() function when the connectdata struct is allocated. */
4287   failf(data, "Protocol \"%s\" not supported or disabled in " LIBCURL_NAME,
4288         protostr);
4289
4290   return CURLE_UNSUPPORTED_PROTOCOL;
4291 }
4292
4293 /*
4294  * Parse URL and fill in the relevant members of the connection struct.
4295  */
4296 static CURLcode parseurlandfillconn(struct Curl_easy *data,
4297                                     struct connectdata *conn,
4298                                     bool *prot_missing,
4299                                     char **userp, char **passwdp,
4300                                     char **optionsp)
4301 {
4302   char *at;
4303   char *fragment;
4304   char *path = data->state.path;
4305   char *query;
4306   int i;
4307   int rc;
4308   const char *protop = "";
4309   CURLcode result;
4310   bool rebuild_url = FALSE;
4311   bool url_has_scheme = FALSE;
4312   char protobuf[16];
4313
4314   *prot_missing = FALSE;
4315
4316   /* We might pass the entire URL into the request so we need to make sure
4317    * there are no bad characters in there.*/
4318   if(strpbrk(data->change.url, "\r\n")) {
4319     failf(data, "Illegal characters found in URL");
4320     return CURLE_URL_MALFORMAT;
4321   }
4322
4323   /*************************************************************
4324    * Parse the URL.
4325    *
4326    * We need to parse the url even when using the proxy, because we will need
4327    * the hostname and port in case we are trying to SSL connect through the
4328    * proxy -- and we don't know if we will need to use SSL until we parse the
4329    * url ...
4330    ************************************************************/
4331   if(data->change.url[0] == ':') {
4332     failf(data, "Bad URL, colon is first character");
4333     return CURLE_URL_MALFORMAT;
4334   }
4335
4336   /* Make sure we don't mistake a drive letter for a scheme, for example:
4337      curld --proto-default file c:/foo/bar.txt */
4338   if((('a' <= data->change.url[0] && data->change.url[0] <= 'z') ||
4339       ('A' <= data->change.url[0] && data->change.url[0] <= 'Z')) &&
4340      data->change.url[1] == ':' && data->set.str[STRING_DEFAULT_PROTOCOL] &&
4341      strcasecompare(data->set.str[STRING_DEFAULT_PROTOCOL], "file")) {
4342     ; /* do nothing */
4343   }
4344   else { /* check for a scheme */
4345     for(i = 0; i < 16 && data->change.url[i]; ++i) {
4346       if(data->change.url[i] == '/')
4347         break;
4348       if(data->change.url[i] == ':') {
4349         url_has_scheme = TRUE;
4350         break;
4351       }
4352     }
4353   }
4354
4355   /* handle the file: scheme */
4356   if((url_has_scheme && strncasecompare(data->change.url, "file:", 5)) ||
4357      (!url_has_scheme && data->set.str[STRING_DEFAULT_PROTOCOL] &&
4358       strcasecompare(data->set.str[STRING_DEFAULT_PROTOCOL], "file"))) {
4359     bool path_has_drive = FALSE;
4360
4361     if(url_has_scheme)
4362       rc = sscanf(data->change.url, "%*15[^\n/:]:%[^\n]", path);
4363     else
4364       rc = sscanf(data->change.url, "%[^\n]", path);
4365
4366     if(rc != 1) {
4367       failf(data, "Bad URL");
4368       return CURLE_URL_MALFORMAT;
4369     }
4370
4371     if(url_has_scheme && path[0] == '/' && path[1] == '/') {
4372       /* Allow omitted hostname (e.g. file:/<path>).  This is not strictly
4373        * speaking a valid file: URL by RFC 1738, but treating file:/<path> as
4374        * file://localhost/<path> is similar to how other schemes treat missing
4375        * hostnames.  See RFC 1808. */
4376
4377       /* This cannot be done with strcpy() in a portable manner, since the
4378          memory areas overlap! */
4379       memmove(path, path + 2, strlen(path + 2)+1);
4380     }
4381
4382     /* the path may start with a drive letter. for backwards compatibility
4383        we skip some processing on those paths. */
4384     path_has_drive = (('a' <= path[0] && path[0] <= 'z') ||
4385                       ('A' <= path[0] && path[0] <= 'Z')) && path[1] == ':';
4386
4387     /*
4388      * we deal with file://<host>/<path> differently since it supports no
4389      * hostname other than "localhost" and "127.0.0.1", which is unique among
4390      * the URL protocols specified in RFC 1738
4391      */
4392     if(path[0] != '/' && !path_has_drive) {
4393       /* the URL includes a host name, it must match "localhost" or
4394          "127.0.0.1" to be valid */
4395       char *ptr;
4396       if(!checkprefix("localhost/", path) &&
4397          !checkprefix("127.0.0.1/", path)) {
4398         failf(data, "Invalid file://hostname/, "
4399                     "expected localhost or 127.0.0.1 or none");
4400         return CURLE_URL_MALFORMAT;
4401       }
4402       ptr = &path[9]; /* now points to the slash after the host */
4403
4404       /* there was a host name and slash present
4405
4406          RFC1738 (section 3.1, page 5) says:
4407
4408          The rest of the locator consists of data specific to the scheme,
4409          and is known as the "url-path". It supplies the details of how the
4410          specified resource can be accessed. Note that the "/" between the
4411          host (or port) and the url-path is NOT part of the url-path.
4412
4413          As most agents use file://localhost/foo to get '/foo' although the
4414          slash preceding foo is a separator and not a slash for the path,
4415          a URL as file://localhost//foo must be valid as well, to refer to
4416          the same file with an absolute path.
4417       */
4418
4419       if('/' == ptr[1])
4420         /* if there was two slashes, we skip the first one as that is then
4421            used truly as a separator */
4422         ptr++;
4423
4424       /* This cannot be made with strcpy, as the memory chunks overlap! */
4425       memmove(path, ptr, strlen(ptr)+1);
4426
4427       path_has_drive = (('a' <= path[0] && path[0] <= 'z') ||
4428                         ('A' <= path[0] && path[0] <= 'Z')) && path[1] == ':';
4429     }
4430
4431 #if !defined(MSDOS) && !defined(WIN32) && !defined(__CYGWIN__)
4432     if(path_has_drive) {
4433       failf(data, "File drive letters are only accepted in MSDOS/Windows.");
4434       return CURLE_URL_MALFORMAT;
4435     }
4436 #endif
4437
4438     protop = "file"; /* protocol string */
4439     *prot_missing = !url_has_scheme;
4440   }
4441   else {
4442     /* clear path */
4443     char slashbuf[4];
4444     path[0]=0;
4445
4446     rc = sscanf(data->change.url,
4447                 "%15[^\n/:]:%3[/]%[^\n/?#]%[^\n]",
4448                 protobuf, slashbuf, conn->host.name, path);
4449     if(2 == rc) {
4450       failf(data, "Bad URL");
4451       return CURLE_URL_MALFORMAT;
4452     }
4453     if(3 > rc) {
4454
4455       /*
4456        * The URL was badly formatted, let's try the browser-style _without_
4457        * protocol specified like 'http://'.
4458        */
4459       rc = sscanf(data->change.url, "%[^\n/?#]%[^\n]", conn->host.name, path);
4460       if(1 > rc) {
4461         /*
4462          * We couldn't even get this format.
4463          * djgpp 2.04 has a sscanf() bug where 'conn->host.name' is
4464          * assigned, but the return value is EOF!
4465          */
4466 #if defined(__DJGPP__) && (DJGPP_MINOR == 4)
4467         if(!(rc == -1 && *conn->host.name))
4468 #endif
4469         {
4470           failf(data, "<url> malformed");
4471           return CURLE_URL_MALFORMAT;
4472         }
4473       }
4474
4475       /*
4476        * Since there was no protocol part specified in the URL use the
4477        * user-specified default protocol. If we weren't given a default make a
4478        * guess by matching some protocols against the host's outermost
4479        * sub-domain name. Finally if there was no match use HTTP.
4480        */
4481
4482       protop = data->set.str[STRING_DEFAULT_PROTOCOL];
4483       if(!protop) {
4484         /* Note: if you add a new protocol, please update the list in
4485          * lib/version.c too! */
4486         if(checkprefix("FTP.", conn->host.name))
4487           protop = "ftp";
4488         else if(checkprefix("DICT.", conn->host.name))
4489           protop = "DICT";
4490         else if(checkprefix("LDAP.", conn->host.name))
4491           protop = "LDAP";
4492         else if(checkprefix("IMAP.", conn->host.name))
4493           protop = "IMAP";
4494         else if(checkprefix("SMTP.", conn->host.name))
4495           protop = "smtp";
4496         else if(checkprefix("POP3.", conn->host.name))
4497           protop = "pop3";
4498         else
4499           protop = "http";
4500       }
4501
4502       *prot_missing = TRUE; /* not given in URL */
4503     }
4504     else {
4505       size_t s = strlen(slashbuf);
4506       protop = protobuf;
4507       if(s != 2) {
4508         infof(data, "Unwillingly accepted illegal URL using %d slash%s!\n",
4509               s, s>1?"es":"");
4510
4511         if(data->change.url_alloc)
4512           free(data->change.url);
4513         /* repair the URL to use two slashes */
4514         data->change.url = aprintf("%s://%s%s",
4515                                    protobuf, conn->host.name, path);
4516         if(!data->change.url)
4517           return CURLE_OUT_OF_MEMORY;
4518         data->change.url_alloc = TRUE;
4519       }
4520     }
4521   }
4522
4523   /* We search for '?' in the host name (but only on the right side of a
4524    * @-letter to allow ?-letters in username and password) to handle things
4525    * like http://example.com?param= (notice the missing '/').
4526    */
4527   at = strchr(conn->host.name, '@');
4528   if(at)
4529     query = strchr(at+1, '?');
4530   else
4531     query = strchr(conn->host.name, '?');
4532
4533   if(query) {
4534     /* We must insert a slash before the '?'-letter in the URL. If the URL had
4535        a slash after the '?', that is where the path currently begins and the
4536        '?string' is still part of the host name.
4537
4538        We must move the trailing part from the host name and put it first in
4539        the path. And have it all prefixed with a slash.
4540     */
4541
4542     size_t hostlen = strlen(query);
4543     size_t pathlen = strlen(path);
4544
4545     /* move the existing path plus the zero byte forward, to make room for
4546        the host-name part */
4547     memmove(path+hostlen+1, path, pathlen+1);
4548
4549      /* now copy the trailing host part in front of the existing path */
4550     memcpy(path+1, query, hostlen);
4551
4552     path[0]='/'; /* prepend the missing slash */
4553     rebuild_url = TRUE;
4554
4555     *query=0; /* now cut off the hostname at the ? */
4556   }
4557   else if(!path[0]) {
4558     /* if there's no path set, use a single slash */
4559     strcpy(path, "/");
4560     rebuild_url = TRUE;
4561   }
4562
4563   /* If the URL is malformatted (missing a '/' after hostname before path) we
4564    * insert a slash here. The only letters except '/' that can start a path is
4565    * '?' and '#' - as controlled by the two sscanf() patterns above.
4566    */
4567   if(path[0] != '/') {
4568     /* We need this function to deal with overlapping memory areas. We know
4569        that the memory area 'path' points to is 'urllen' bytes big and that
4570        is bigger than the path. Use +1 to move the zero byte too. */
4571     memmove(&path[1], path, strlen(path)+1);
4572     path[0] = '/';
4573     rebuild_url = TRUE;
4574   }
4575   else if(!data->set.path_as_is) {
4576     /* sanitise paths and remove ../ and ./ sequences according to RFC3986 */
4577     char *newp = Curl_dedotdotify(path);
4578     if(!newp)
4579       return CURLE_OUT_OF_MEMORY;
4580
4581     if(strcmp(newp, path)) {
4582       rebuild_url = TRUE;
4583       free(data->state.pathbuffer);
4584       data->state.pathbuffer = newp;
4585       data->state.path = newp;
4586       path = newp;
4587     }
4588     else
4589       free(newp);
4590   }
4591
4592   /*
4593    * "rebuild_url" means that one or more URL components have been modified so
4594    * we need to generate an updated full version.  We need the corrected URL
4595    * when communicating over HTTP proxy and we don't know at this point if
4596    * we're using a proxy or not.
4597    */
4598   if(rebuild_url) {
4599     char *reurl;
4600
4601     size_t plen = strlen(path); /* new path, should be 1 byte longer than
4602                                    the original */
4603     size_t prefixlen = strlen(conn->host.name);
4604
4605     if(!*prot_missing) {
4606       size_t protolen = strlen(protop);
4607
4608       if(curl_strnequal(protop, data->change.url, protolen))
4609         prefixlen += protolen;
4610       else {
4611         failf(data, "<url> malformed");
4612         return CURLE_URL_MALFORMAT;
4613       }
4614
4615       if(curl_strnequal("://", &data->change.url[protolen], 3))
4616         prefixlen += 3;
4617       /* only file: is allowed to omit one or both slashes */
4618       else if(curl_strnequal("file:", data->change.url, 5))
4619         prefixlen += 1 + (data->change.url[5] == '/');
4620       else {
4621         failf(data, "<url> malformed");
4622         return CURLE_URL_MALFORMAT;
4623       }
4624     }
4625
4626     reurl = malloc(prefixlen + plen + 1);
4627     if(!reurl)
4628       return CURLE_OUT_OF_MEMORY;
4629
4630     /* copy the prefix */
4631     memcpy(reurl, data->change.url, prefixlen);
4632
4633     /* append the trailing piece + zerobyte */
4634     memcpy(&reurl[prefixlen], path, plen + 1);
4635
4636     /* possible free the old one */
4637     if(data->change.url_alloc) {
4638       Curl_safefree(data->change.url);
4639       data->change.url_alloc = FALSE;
4640     }
4641
4642     infof(data, "Rebuilt URL to: %s\n", reurl);
4643
4644     data->change.url = reurl;
4645     data->change.url_alloc = TRUE; /* free this later */
4646   }
4647
4648   result = findprotocol(data, conn, protop);
4649   if(result)
4650     return result;
4651
4652   /*
4653    * Parse the login details from the URL and strip them out of
4654    * the host name
4655    */
4656   result = parse_url_login(data, conn, userp, passwdp, optionsp);
4657   if(result)
4658     return result;
4659
4660   if(conn->host.name[0] == '[') {
4661     /* This looks like an IPv6 address literal.  See if there is an address
4662        scope if there is no location header */
4663     char *percent = strchr(conn->host.name, '%');
4664     if(percent) {
4665       unsigned int identifier_offset = 3;
4666       char *endp;
4667       unsigned long scope;
4668       if(strncmp("%25", percent, 3) != 0) {
4669         infof(data,
4670               "Please URL encode %% as %%25, see RFC 6874.\n");
4671         identifier_offset = 1;
4672       }
4673       scope = strtoul(percent + identifier_offset, &endp, 10);
4674       if(*endp == ']') {
4675         /* The address scope was well formed.  Knock it out of the
4676            hostname. */
4677         memmove(percent, endp, strlen(endp)+1);
4678         conn->scope_id = (unsigned int)scope;
4679       }
4680       else {
4681         /* Zone identifier is not numeric */
4682 #if defined(HAVE_NET_IF_H) && defined(IFNAMSIZ) && defined(HAVE_IF_NAMETOINDEX)
4683         char ifname[IFNAMSIZ + 2];
4684         char *square_bracket;
4685         unsigned int scopeidx = 0;
4686         strncpy(ifname, percent + identifier_offset, IFNAMSIZ + 2);
4687         /* Ensure nullbyte termination */
4688         ifname[IFNAMSIZ + 1] = '\0';
4689         square_bracket = strchr(ifname, ']');
4690         if(square_bracket) {
4691           /* Remove ']' */
4692           *square_bracket = '\0';
4693           scopeidx = if_nametoindex(ifname);
4694           if(scopeidx == 0) {
4695             infof(data, "Invalid network interface: %s; %s\n", ifname,
4696                   strerror(errno));
4697           }
4698         }
4699         if(scopeidx > 0) {
4700           char *p = percent + identifier_offset + strlen(ifname);
4701
4702           /* Remove zone identifier from hostname */
4703           memmove(percent, p, strlen(p) + 1);
4704           conn->scope_id = scopeidx;
4705         }
4706         else
4707 #endif /* HAVE_NET_IF_H && IFNAMSIZ */
4708           infof(data, "Invalid IPv6 address format\n");
4709       }
4710     }
4711   }
4712
4713   if(data->set.scope_id)
4714     /* Override any scope that was set above.  */
4715     conn->scope_id = data->set.scope_id;
4716
4717   /* Remove the fragment part of the path. Per RFC 2396, this is always the
4718      last part of the URI. We are looking for the first '#' so that we deal
4719      gracefully with non conformant URI such as http://example.com#foo#bar. */
4720   fragment = strchr(path, '#');
4721   if(fragment) {
4722     *fragment = 0;
4723
4724     /* we know the path part ended with a fragment, so we know the full URL
4725        string does too and we need to cut it off from there so it isn't used
4726        over proxy */
4727     fragment = strchr(data->change.url, '#');
4728     if(fragment)
4729       *fragment = 0;
4730   }
4731
4732   /*
4733    * So if the URL was A://B/C#D,
4734    *   protop is A
4735    *   conn->host.name is B
4736    *   data->state.path is /C
4737    */
4738   return CURLE_OK;
4739 }
4740
4741 /*
4742  * If we're doing a resumed transfer, we need to setup our stuff
4743  * properly.
4744  */
4745 static CURLcode setup_range(struct Curl_easy *data)
4746 {
4747   struct UrlState *s = &data->state;
4748   s->resume_from = data->set.set_resume_from;
4749   if(s->resume_from || data->set.str[STRING_SET_RANGE]) {
4750     if(s->rangestringalloc)
4751       free(s->range);
4752
4753     if(s->resume_from)
4754       s->range = aprintf("%" CURL_FORMAT_CURL_OFF_TU "-", s->resume_from);
4755     else
4756       s->range = strdup(data->set.str[STRING_SET_RANGE]);
4757
4758     s->rangestringalloc = (s->range) ? TRUE : FALSE;
4759
4760     if(!s->range)
4761       return CURLE_OUT_OF_MEMORY;
4762
4763     /* tell ourselves to fetch this range */
4764     s->use_range = TRUE;        /* enable range download */
4765   }
4766   else
4767     s->use_range = FALSE; /* disable range download */
4768
4769   return CURLE_OK;
4770 }
4771
4772
4773 /*
4774  * setup_connection_internals() -
4775  *
4776  * Setup connection internals specific to the requested protocol in the
4777  * Curl_easy. This is inited and setup before the connection is made but
4778  * is about the particular protocol that is to be used.
4779  *
4780  * This MUST get called after proxy magic has been figured out.
4781  */
4782 static CURLcode setup_connection_internals(struct connectdata *conn)
4783 {
4784   const struct Curl_handler * p;
4785   CURLcode result;
4786   struct Curl_easy *data = conn->data;
4787
4788   /* in some case in the multi state-machine, we go back to the CONNECT state
4789      and then a second (or third or...) call to this function will be made
4790      without doing a DISCONNECT or DONE in between (since the connection is
4791      yet in place) and therefore this function needs to first make sure
4792      there's no lingering previous data allocated. */
4793   Curl_free_request_state(data);
4794
4795   memset(&data->req, 0, sizeof(struct SingleRequest));
4796   data->req.maxdownload = -1;
4797
4798   conn->socktype = SOCK_STREAM; /* most of them are TCP streams */
4799
4800   /* Perform setup complement if some. */
4801   p = conn->handler;
4802
4803   if(p->setup_connection) {
4804     result = (*p->setup_connection)(conn);
4805
4806     if(result)
4807       return result;
4808
4809     p = conn->handler;              /* May have changed. */
4810   }
4811
4812   if(conn->port < 0)
4813     /* we check for -1 here since if proxy was detected already, this
4814        was very likely already set to the proxy port */
4815     conn->port = p->defport;
4816
4817   return CURLE_OK;
4818 }
4819
4820 /*
4821  * Curl_free_request_state() should free temp data that was allocated in the
4822  * Curl_easy for this single request.
4823  */
4824
4825 void Curl_free_request_state(struct Curl_easy *data)
4826 {
4827   Curl_safefree(data->req.protop);
4828   Curl_safefree(data->req.newurl);
4829 }
4830
4831
4832 #ifndef CURL_DISABLE_PROXY
4833 /****************************************************************
4834 * Checks if the host is in the noproxy list. returns true if it matches
4835 * and therefore the proxy should NOT be used.
4836 ****************************************************************/
4837 static bool check_noproxy(const char *name, const char *no_proxy)
4838 {
4839   /* no_proxy=domain1.dom,host.domain2.dom
4840    *   (a comma-separated list of hosts which should
4841    *   not be proxied, or an asterisk to override
4842    *   all proxy variables)
4843    */
4844   size_t tok_start;
4845   size_t tok_end;
4846   const char *separator = ", ";
4847   size_t no_proxy_len;
4848   size_t namelen;
4849   char *endptr;
4850
4851   if(no_proxy && no_proxy[0]) {
4852     if(strcasecompare("*", no_proxy)) {
4853       return TRUE;
4854     }
4855
4856     /* NO_PROXY was specified and it wasn't just an asterisk */
4857
4858     no_proxy_len = strlen(no_proxy);
4859     endptr = strchr(name, ':');
4860     if(endptr)
4861       namelen = endptr - name;
4862     else
4863       namelen = strlen(name);
4864
4865     for(tok_start = 0; tok_start < no_proxy_len; tok_start = tok_end + 1) {
4866       while(tok_start < no_proxy_len &&
4867             strchr(separator, no_proxy[tok_start]) != NULL) {
4868         /* Look for the beginning of the token. */
4869         ++tok_start;
4870       }
4871
4872       if(tok_start == no_proxy_len)
4873         break; /* It was all trailing separator chars, no more tokens. */
4874
4875       for(tok_end = tok_start; tok_end < no_proxy_len &&
4876             strchr(separator, no_proxy[tok_end]) == NULL; ++tok_end)
4877         /* Look for the end of the token. */
4878         ;
4879
4880       /* To match previous behaviour, where it was necessary to specify
4881        * ".local.com" to prevent matching "notlocal.com", we will leave
4882        * the '.' off.
4883        */
4884       if(no_proxy[tok_start] == '.')
4885         ++tok_start;
4886
4887       if((tok_end - tok_start) <= namelen) {
4888         /* Match the last part of the name to the domain we are checking. */
4889         const char *checkn = name + namelen - (tok_end - tok_start);
4890         if(strncasecompare(no_proxy + tok_start, checkn,
4891                            tok_end - tok_start)) {
4892           if((tok_end - tok_start) == namelen || *(checkn - 1) == '.') {
4893             /* We either have an exact match, or the previous character is a .
4894              * so it is within the same domain, so no proxy for this host.
4895              */
4896             return TRUE;
4897           }
4898         }
4899       } /* if((tok_end - tok_start) <= namelen) */
4900     } /* for(tok_start = 0; tok_start < no_proxy_len;
4901          tok_start = tok_end + 1) */
4902   } /* NO_PROXY was specified and it wasn't just an asterisk */
4903
4904   return FALSE;
4905 }
4906
4907 /****************************************************************
4908 * Detect what (if any) proxy to use. Remember that this selects a host
4909 * name and is not limited to HTTP proxies only.
4910 * The returned pointer must be freed by the caller (unless NULL)
4911 ****************************************************************/
4912 static char *detect_proxy(struct connectdata *conn)
4913 {
4914   char *proxy = NULL;
4915
4916   /* If proxy was not specified, we check for default proxy environment
4917    * variables, to enable i.e Lynx compliance:
4918    *
4919    * http_proxy=http://some.server.dom:port/
4920    * https_proxy=http://some.server.dom:port/
4921    * ftp_proxy=http://some.server.dom:port/
4922    * no_proxy=domain1.dom,host.domain2.dom
4923    *   (a comma-separated list of hosts which should
4924    *   not be proxied, or an asterisk to override
4925    *   all proxy variables)
4926    * all_proxy=http://some.server.dom:port/
4927    *   (seems to exist for the CERN www lib. Probably
4928    *   the first to check for.)
4929    *
4930    * For compatibility, the all-uppercase versions of these variables are
4931    * checked if the lowercase versions don't exist.
4932    */
4933   char proxy_env[128];
4934   const char *protop = conn->handler->scheme;
4935   char *envp = proxy_env;
4936   char *prox;
4937
4938   /* Now, build <protocol>_proxy and check for such a one to use */
4939   while(*protop)
4940     *envp++ = (char)tolower((int)*protop++);
4941
4942   /* append _proxy */
4943   strcpy(envp, "_proxy");
4944
4945   /* read the protocol proxy: */
4946   prox=curl_getenv(proxy_env);
4947
4948   /*
4949    * We don't try the uppercase version of HTTP_PROXY because of
4950    * security reasons:
4951    *
4952    * When curl is used in a webserver application
4953    * environment (cgi or php), this environment variable can
4954    * be controlled by the web server user by setting the
4955    * http header 'Proxy:' to some value.
4956    *
4957    * This can cause 'internal' http/ftp requests to be
4958    * arbitrarily redirected by any external attacker.
4959    */
4960   if(!prox && !strcasecompare("http_proxy", proxy_env)) {
4961     /* There was no lowercase variable, try the uppercase version: */
4962     Curl_strntoupper(proxy_env, proxy_env, sizeof(proxy_env));
4963     prox=curl_getenv(proxy_env);
4964   }
4965
4966   if(prox)
4967     proxy = prox; /* use this */
4968   else {
4969     proxy = curl_getenv("all_proxy"); /* default proxy to use */
4970     if(!proxy)
4971       proxy=curl_getenv("ALL_PROXY");
4972   }
4973
4974   return proxy;
4975 }
4976
4977 /*
4978  * If this is supposed to use a proxy, we need to figure out the proxy
4979  * host name, so that we can re-use an existing connection
4980  * that may exist registered to the same proxy host.
4981  */
4982 static CURLcode parse_proxy(struct Curl_easy *data,
4983                             struct connectdata *conn, char *proxy,
4984                             curl_proxytype proxytype)
4985 {
4986   char *prox_portno;
4987   char *endofprot;
4988
4989   /* We use 'proxyptr' to point to the proxy name from now on... */
4990   char *proxyptr;
4991   char *portptr;
4992   char *atsign;
4993   long port = -1;
4994   char *proxyuser = NULL;
4995   char *proxypasswd = NULL;
4996   bool sockstype;
4997
4998   /* We do the proxy host string parsing here. We want the host name and the
4999    * port name. Accept a protocol:// prefix
5000    */
5001
5002   /* Parse the protocol part if present */
5003   endofprot = strstr(proxy, "://");
5004   if(endofprot) {
5005     proxyptr = endofprot+3;
5006     if(checkprefix("https", proxy))
5007       proxytype = CURLPROXY_HTTPS;
5008     else if(checkprefix("socks5h", proxy))
5009       proxytype = CURLPROXY_SOCKS5_HOSTNAME;
5010     else if(checkprefix("socks5", proxy))
5011       proxytype = CURLPROXY_SOCKS5;
5012     else if(checkprefix("socks4a", proxy))
5013       proxytype = CURLPROXY_SOCKS4A;
5014     else if(checkprefix("socks4", proxy) || checkprefix("socks", proxy))
5015       proxytype = CURLPROXY_SOCKS4;
5016     else if(checkprefix("http:", proxy))
5017       ; /* leave it as HTTP or HTTP/1.0 */
5018     else {
5019       /* Any other xxx:// reject! */
5020       failf(data, "Unsupported proxy scheme for \'%s\'", proxy);
5021       return CURLE_COULDNT_CONNECT;
5022     }
5023   }
5024   else
5025     proxyptr = proxy; /* No xxx:// head: It's a HTTP proxy */
5026
5027 #ifndef HTTPS_PROXY_SUPPORT
5028   if(proxytype == CURLPROXY_HTTPS) {
5029     failf(data, "Unsupported proxy \'%s\'"
5030                 ", libcurl is built without the HTTPS-proxy support.", proxy);
5031     return CURLE_NOT_BUILT_IN;
5032   }
5033 #endif
5034
5035   sockstype = proxytype == CURLPROXY_SOCKS5_HOSTNAME ||
5036               proxytype == CURLPROXY_SOCKS5 ||
5037               proxytype == CURLPROXY_SOCKS4A ||
5038               proxytype == CURLPROXY_SOCKS4;
5039
5040   /* Is there a username and password given in this proxy url? */
5041   atsign = strchr(proxyptr, '@');
5042   if(atsign) {
5043     CURLcode result =
5044       parse_login_details(proxyptr, atsign - proxyptr,
5045                               &proxyuser, &proxypasswd, NULL);
5046     if(result)
5047       return result;
5048     proxyptr = atsign + 1;
5049   }
5050
5051   /* start scanning for port number at this point */
5052   portptr = proxyptr;
5053
5054   /* detect and extract RFC6874-style IPv6-addresses */
5055   if(*proxyptr == '[') {
5056     char *ptr = ++proxyptr; /* advance beyond the initial bracket */
5057     while(*ptr && (ISXDIGIT(*ptr) || (*ptr == ':') || (*ptr == '.')))
5058       ptr++;
5059     if(*ptr == '%') {
5060       /* There might be a zone identifier */
5061       if(strncmp("%25", ptr, 3))
5062         infof(data, "Please URL encode %% as %%25, see RFC 6874.\n");
5063       ptr++;
5064       /* Allow unreserved characters as defined in RFC 3986 */
5065       while(*ptr && (ISALPHA(*ptr) || ISXDIGIT(*ptr) || (*ptr == '-') ||
5066                      (*ptr == '.') || (*ptr == '_') || (*ptr == '~')))
5067         ptr++;
5068     }
5069     if(*ptr == ']')
5070       /* yeps, it ended nicely with a bracket as well */
5071       *ptr++ = 0;
5072     else
5073       infof(data, "Invalid IPv6 address format\n");
5074     portptr = ptr;
5075     /* Note that if this didn't end with a bracket, we still advanced the
5076      * proxyptr first, but I can't see anything wrong with that as no host
5077      * name nor a numeric can legally start with a bracket.
5078      */
5079   }
5080
5081   /* Get port number off proxy.server.com:1080 */
5082   prox_portno = strchr(portptr, ':');
5083   if(prox_portno) {
5084     char *endp = NULL;
5085
5086     *prox_portno = 0x0; /* cut off number from host name */
5087     prox_portno ++;
5088     /* now set the local port number */
5089     port = strtol(prox_portno, &endp, 10);
5090     if((endp && *endp && (*endp != '/') && (*endp != ' ')) ||
5091        (port < 0) || (port > 65535)) {
5092       /* meant to detect for example invalid IPv6 numerical addresses without
5093          brackets: "2a00:fac0:a000::7:13". Accept a trailing slash only
5094          because we then allow "URL style" with the number followed by a
5095          slash, used in curl test cases already. Space is also an acceptable
5096          terminating symbol. */
5097       infof(data, "No valid port number in proxy string (%s)\n",
5098             prox_portno);
5099     }
5100     else
5101       conn->port = port;
5102   }
5103   else {
5104     if(proxyptr[0]=='/')
5105       /* If the first character in the proxy string is a slash, fail
5106          immediately. The following code will otherwise clear the string which
5107          will lead to code running as if no proxy was set! */
5108       return CURLE_COULDNT_RESOLVE_PROXY;
5109
5110     /* without a port number after the host name, some people seem to use
5111        a slash so we strip everything from the first slash */
5112     atsign = strchr(proxyptr, '/');
5113     if(atsign)
5114       *atsign = '\0'; /* cut off path part from host name */
5115
5116     if(data->set.proxyport)
5117       /* None given in the proxy string, then get the default one if it is
5118          given */
5119       port = data->set.proxyport;
5120     else {
5121       if(proxytype == CURLPROXY_HTTPS)
5122         port = CURL_DEFAULT_HTTPS_PROXY_PORT;
5123       else
5124         port = CURL_DEFAULT_PROXY_PORT;
5125     }
5126   }
5127
5128   if(*proxyptr) {
5129     struct proxy_info *proxyinfo =
5130       sockstype ? &conn->socks_proxy : &conn->http_proxy;
5131     proxyinfo->proxytype = proxytype;
5132
5133     if(proxyuser) {
5134       /* found user and password, rip them out.  note that we are unescaping
5135          them, as there is otherwise no way to have a username or password
5136          with reserved characters like ':' in them. */
5137       Curl_safefree(proxyinfo->user);
5138       proxyinfo->user = curl_easy_unescape(data, proxyuser, 0, NULL);
5139
5140       if(!proxyinfo->user)
5141         return CURLE_OUT_OF_MEMORY;
5142
5143       Curl_safefree(proxyinfo->passwd);
5144       if(proxypasswd && strlen(proxypasswd) < MAX_CURL_PASSWORD_LENGTH)
5145         proxyinfo->passwd = curl_easy_unescape(data, proxypasswd, 0, NULL);
5146       else
5147         proxyinfo->passwd = strdup("");
5148
5149       if(!proxyinfo->passwd)
5150         return CURLE_OUT_OF_MEMORY;
5151
5152       conn->bits.proxy_user_passwd = TRUE; /* enable it */
5153     }
5154
5155     if(port >= 0) {
5156       proxyinfo->port = port;
5157       if(conn->port < 0 || sockstype || !conn->socks_proxy.host.rawalloc)
5158         conn->port = port;
5159     }
5160
5161     /* now, clone the cleaned proxy host name */
5162     Curl_safefree(proxyinfo->host.rawalloc);
5163     proxyinfo->host.rawalloc = strdup(proxyptr);
5164     proxyinfo->host.name = proxyinfo->host.rawalloc;
5165
5166     if(!proxyinfo->host.rawalloc)
5167       return CURLE_OUT_OF_MEMORY;
5168   }
5169
5170   Curl_safefree(proxyuser);
5171   Curl_safefree(proxypasswd);
5172
5173   return CURLE_OK;
5174 }
5175
5176 /*
5177  * Extract the user and password from the authentication string
5178  */
5179 static CURLcode parse_proxy_auth(struct Curl_easy *data,
5180                                  struct connectdata *conn)
5181 {
5182   char proxyuser[MAX_CURL_USER_LENGTH]="";
5183   char proxypasswd[MAX_CURL_PASSWORD_LENGTH]="";
5184   CURLcode result;
5185
5186   if(data->set.str[STRING_PROXYUSERNAME] != NULL) {
5187     strncpy(proxyuser, data->set.str[STRING_PROXYUSERNAME],
5188             MAX_CURL_USER_LENGTH);
5189     proxyuser[MAX_CURL_USER_LENGTH-1] = '\0';   /*To be on safe side*/
5190   }
5191   if(data->set.str[STRING_PROXYPASSWORD] != NULL) {
5192     strncpy(proxypasswd, data->set.str[STRING_PROXYPASSWORD],
5193             MAX_CURL_PASSWORD_LENGTH);
5194     proxypasswd[MAX_CURL_PASSWORD_LENGTH-1] = '\0'; /*To be on safe side*/
5195   }
5196
5197   result = Curl_urldecode(data, proxyuser, 0, &conn->http_proxy.user, NULL,
5198                           FALSE);
5199   if(!result)
5200     result = Curl_urldecode(data, proxypasswd, 0, &conn->http_proxy.passwd,
5201                             NULL, FALSE);
5202   return result;
5203 }
5204 #endif /* CURL_DISABLE_PROXY */
5205
5206 /*
5207  * parse_url_login()
5208  *
5209  * Parse the login details (user name, password and options) from the URL and
5210  * strip them out of the host name
5211  *
5212  * Inputs: data->set.use_netrc (CURLOPT_NETRC)
5213  *         conn->host.name
5214  *
5215  * Outputs: (almost :- all currently undefined)
5216  *          conn->bits.user_passwd  - non-zero if non-default passwords exist
5217  *          user                    - non-zero length if defined
5218  *          passwd                  - non-zero length if defined
5219  *          options                 - non-zero length if defined
5220  *          conn->host.name         - remove user name and password
5221  */
5222 static CURLcode parse_url_login(struct Curl_easy *data,
5223                                 struct connectdata *conn,
5224                                 char **user, char **passwd, char **options)
5225 {
5226   CURLcode result = CURLE_OK;
5227   char *userp = NULL;
5228   char *passwdp = NULL;
5229   char *optionsp = NULL;
5230
5231   /* At this point, we're hoping all the other special cases have
5232    * been taken care of, so conn->host.name is at most
5233    *    [user[:password][;options]]@]hostname
5234    *
5235    * We need somewhere to put the embedded details, so do that first.
5236    */
5237
5238   char *ptr = strchr(conn->host.name, '@');
5239   char *login = conn->host.name;
5240
5241   DEBUGASSERT(!**user);
5242   DEBUGASSERT(!**passwd);
5243   DEBUGASSERT(!**options);
5244   DEBUGASSERT(conn->handler);
5245
5246   if(!ptr)
5247     goto out;
5248
5249   /* We will now try to extract the
5250    * possible login information in a string like:
5251    * ftp://user:password@ftp.my.site:8021/README */
5252   conn->host.name = ++ptr;
5253
5254   /* So the hostname is sane.  Only bother interpreting the
5255    * results if we could care.  It could still be wasted
5256    * work because it might be overtaken by the programmatically
5257    * set user/passwd, but doing that first adds more cases here :-(
5258    */
5259
5260   if(data->set.use_netrc == CURL_NETRC_REQUIRED)
5261     goto out;
5262
5263   /* We could use the login information in the URL so extract it. Only parse
5264      options if the handler says we should. */
5265   result = parse_login_details(login, ptr - login - 1,
5266                                &userp, &passwdp,
5267                                (conn->handler->flags & PROTOPT_URLOPTIONS)?
5268                                &optionsp:NULL);
5269   if(result)
5270     goto out;
5271
5272   if(userp) {
5273     char *newname;
5274
5275     /* We have a user in the URL */
5276     conn->bits.userpwd_in_url = TRUE;
5277     conn->bits.user_passwd = TRUE; /* enable user+password */
5278
5279     /* Decode the user */
5280     result = Curl_urldecode(data, userp, 0, &newname, NULL, FALSE);
5281     if(result) {
5282       goto out;
5283     }
5284
5285     free(*user);
5286     *user = newname;
5287   }
5288
5289   if(passwdp) {
5290     /* We have a password in the URL so decode it */
5291     char *newpasswd;
5292     result = Curl_urldecode(data, passwdp, 0, &newpasswd, NULL, FALSE);
5293     if(result) {
5294       goto out;
5295     }
5296
5297     free(*passwd);
5298     *passwd = newpasswd;
5299   }
5300
5301   if(optionsp) {
5302     /* We have an options list in the URL so decode it */
5303     char *newoptions;
5304     result = Curl_urldecode(data, optionsp, 0, &newoptions, NULL, FALSE);
5305     if(result) {
5306       goto out;
5307     }
5308
5309     free(*options);
5310     *options = newoptions;
5311   }
5312
5313
5314   out:
5315
5316   free(userp);
5317   free(passwdp);
5318   free(optionsp);
5319
5320   return result;
5321 }
5322
5323 /*
5324  * parse_login_details()
5325  *
5326  * This is used to parse a login string for user name, password and options in
5327  * the following formats:
5328  *
5329  *   user
5330  *   user:password
5331  *   user:password;options
5332  *   user;options
5333  *   user;options:password
5334  *   :password
5335  *   :password;options
5336  *   ;options
5337  *   ;options:password
5338  *
5339  * Parameters:
5340  *
5341  * login    [in]     - The login string.
5342  * len      [in]     - The length of the login string.
5343  * userp    [in/out] - The address where a pointer to newly allocated memory
5344  *                     holding the user will be stored upon completion.
5345  * passdwp  [in/out] - The address where a pointer to newly allocated memory
5346  *                     holding the password will be stored upon completion.
5347  * optionsp [in/out] - The address where a pointer to newly allocated memory
5348  *                     holding the options will be stored upon completion.
5349  *
5350  * Returns CURLE_OK on success.
5351  */
5352 static CURLcode parse_login_details(const char *login, const size_t len,
5353                                     char **userp, char **passwdp,
5354                                     char **optionsp)
5355 {
5356   CURLcode result = CURLE_OK;
5357   char *ubuf = NULL;
5358   char *pbuf = NULL;
5359   char *obuf = NULL;
5360   const char *psep = NULL;
5361   const char *osep = NULL;
5362   size_t ulen;
5363   size_t plen;
5364   size_t olen;
5365
5366   /* Attempt to find the password separator */
5367   if(passwdp) {
5368     psep = strchr(login, ':');
5369
5370     /* Within the constraint of the login string */
5371     if(psep >= login + len)
5372       psep = NULL;
5373   }
5374
5375   /* Attempt to find the options separator */
5376   if(optionsp) {
5377     osep = strchr(login, ';');
5378
5379     /* Within the constraint of the login string */
5380     if(osep >= login + len)
5381       osep = NULL;
5382   }
5383
5384   /* Calculate the portion lengths */
5385   ulen = (psep ?
5386           (size_t)(osep && psep > osep ? osep - login : psep - login) :
5387           (osep ? (size_t)(osep - login) : len));
5388   plen = (psep ?
5389           (osep && osep > psep ? (size_t)(osep - psep) :
5390                                  (size_t)(login + len - psep)) - 1 : 0);
5391   olen = (osep ?
5392           (psep && psep > osep ? (size_t)(psep - osep) :
5393                                  (size_t)(login + len - osep)) - 1 : 0);
5394
5395   /* Allocate the user portion buffer */
5396   if(userp && ulen) {
5397     ubuf = malloc(ulen + 1);
5398     if(!ubuf)
5399       result = CURLE_OUT_OF_MEMORY;
5400   }
5401
5402   /* Allocate the password portion buffer */
5403   if(!result && passwdp && plen) {
5404     pbuf = malloc(plen + 1);
5405     if(!pbuf) {
5406       free(ubuf);
5407       result = CURLE_OUT_OF_MEMORY;
5408     }
5409   }
5410
5411   /* Allocate the options portion buffer */
5412   if(!result && optionsp && olen) {
5413     obuf = malloc(olen + 1);
5414     if(!obuf) {
5415       free(pbuf);
5416       free(ubuf);
5417       result = CURLE_OUT_OF_MEMORY;
5418     }
5419   }
5420
5421   if(!result) {
5422     /* Store the user portion if necessary */
5423     if(ubuf) {
5424       memcpy(ubuf, login, ulen);
5425       ubuf[ulen] = '\0';
5426       Curl_safefree(*userp);
5427       *userp = ubuf;
5428     }
5429
5430     /* Store the password portion if necessary */
5431     if(pbuf) {
5432       memcpy(pbuf, psep + 1, plen);
5433       pbuf[plen] = '\0';
5434       Curl_safefree(*passwdp);
5435       *passwdp = pbuf;
5436     }
5437
5438     /* Store the options portion if necessary */
5439     if(obuf) {
5440       memcpy(obuf, osep + 1, olen);
5441       obuf[olen] = '\0';
5442       Curl_safefree(*optionsp);
5443       *optionsp = obuf;
5444     }
5445   }
5446
5447   return result;
5448 }
5449
5450 /*************************************************************
5451  * Figure out the remote port number and fix it in the URL
5452  *
5453  * No matter if we use a proxy or not, we have to figure out the remote
5454  * port number of various reasons.
5455  *
5456  * To be able to detect port number flawlessly, we must not confuse them
5457  * IPv6-specified addresses in the [0::1] style. (RFC2732)
5458  *
5459  * The conn->host.name is currently [user:passwd@]host[:port] where host
5460  * could be a hostname, IPv4 address or IPv6 address.
5461  *
5462  * The port number embedded in the URL is replaced, if necessary.
5463  *************************************************************/
5464 static CURLcode parse_remote_port(struct Curl_easy *data,
5465                                   struct connectdata *conn)
5466 {
5467   char *portptr;
5468   char endbracket;
5469
5470   /* Note that at this point, the IPv6 address cannot contain any scope
5471      suffix as that has already been removed in the parseurlandfillconn()
5472      function */
5473   if((1 == sscanf(conn->host.name, "[%*45[0123456789abcdefABCDEF:.]%c",
5474                   &endbracket)) &&
5475      (']' == endbracket)) {
5476     /* this is a RFC2732-style specified IP-address */
5477     conn->bits.ipv6_ip = TRUE;
5478
5479     conn->host.name++; /* skip over the starting bracket */
5480     portptr = strchr(conn->host.name, ']');
5481     if(portptr) {
5482       *portptr++ = '\0'; /* zero terminate, killing the bracket */
5483       if(':' != *portptr)
5484         portptr = NULL; /* no port number available */
5485     }
5486   }
5487   else {
5488 #ifdef ENABLE_IPV6
5489     struct in6_addr in6;
5490     if(Curl_inet_pton(AF_INET6, conn->host.name, &in6) > 0) {
5491       /* This is a numerical IPv6 address, meaning this is a wrongly formatted
5492          URL */
5493       failf(data, "IPv6 numerical address used in URL without brackets");
5494       return CURLE_URL_MALFORMAT;
5495     }
5496 #endif
5497
5498     portptr = strrchr(conn->host.name, ':');
5499   }
5500
5501   if(data->set.use_port && data->state.allow_port) {
5502     /* if set, we use this and ignore the port possibly given in the URL */
5503     conn->remote_port = (unsigned short)data->set.use_port;
5504     if(portptr)
5505       *portptr = '\0'; /* cut off the name there anyway - if there was a port
5506                       number - since the port number is to be ignored! */
5507     if(conn->bits.httpproxy) {
5508       /* we need to create new URL with the new port number */
5509       char *url;
5510       char type[12]="";
5511
5512       if(conn->bits.type_set)
5513         snprintf(type, sizeof(type), ";type=%c",
5514                  data->set.prefer_ascii?'A':
5515                  (data->set.ftp_list_only?'D':'I'));
5516
5517       /*
5518        * This synthesized URL isn't always right--suffixes like ;type=A are
5519        * stripped off. It would be better to work directly from the original
5520        * URL and simply replace the port part of it.
5521        */
5522       url = aprintf("%s://%s%s%s:%hu%s%s%s", conn->given->scheme,
5523                     conn->bits.ipv6_ip?"[":"", conn->host.name,
5524                     conn->bits.ipv6_ip?"]":"", conn->remote_port,
5525                     data->state.slash_removed?"/":"", data->state.path,
5526                     type);
5527       if(!url)
5528         return CURLE_OUT_OF_MEMORY;
5529
5530       if(data->change.url_alloc) {
5531         Curl_safefree(data->change.url);
5532         data->change.url_alloc = FALSE;
5533       }
5534
5535       data->change.url = url;
5536       data->change.url_alloc = TRUE;
5537     }
5538   }
5539   else if(portptr) {
5540     /* no CURLOPT_PORT given, extract the one from the URL */
5541
5542     char *rest;
5543     long port;
5544
5545     port=strtol(portptr+1, &rest, 10);  /* Port number must be decimal */
5546
5547     if((port < 0) || (port > 0xffff)) {
5548       /* Single unix standard says port numbers are 16 bits long */
5549       failf(data, "Port number out of range");
5550       return CURLE_URL_MALFORMAT;
5551     }
5552
5553     else if(rest != &portptr[1]) {
5554       *portptr = '\0'; /* cut off the name there */
5555       conn->remote_port = curlx_ultous(port);
5556     }
5557     else {
5558       if(rest[0]) {
5559         failf(data, "Illegal port number");
5560         return CURLE_URL_MALFORMAT;
5561       }
5562       /* Browser behavior adaptation. If there's a colon with no digits after,
5563          just cut off the name there which makes us ignore the colon and just
5564          use the default port. Firefox and Chrome both do that. */
5565       *portptr = '\0';
5566     }
5567   }
5568
5569   /* only if remote_port was not already parsed off the URL we use the
5570      default port number */
5571   if(conn->remote_port < 0)
5572     conn->remote_port = (unsigned short)conn->given->defport;
5573
5574   return CURLE_OK;
5575 }
5576
5577 /*
5578  * Override the login details from the URL with that in the CURLOPT_USERPWD
5579  * option or a .netrc file, if applicable.
5580  */
5581 static CURLcode override_login(struct Curl_easy *data,
5582                                struct connectdata *conn,
5583                                char **userp, char **passwdp, char **optionsp)
5584 {
5585   if(data->set.str[STRING_USERNAME]) {
5586     free(*userp);
5587     *userp = strdup(data->set.str[STRING_USERNAME]);
5588     if(!*userp)
5589       return CURLE_OUT_OF_MEMORY;
5590   }
5591
5592   if(data->set.str[STRING_PASSWORD]) {
5593     free(*passwdp);
5594     *passwdp = strdup(data->set.str[STRING_PASSWORD]);
5595     if(!*passwdp)
5596       return CURLE_OUT_OF_MEMORY;
5597   }
5598
5599   if(data->set.str[STRING_OPTIONS]) {
5600     free(*optionsp);
5601     *optionsp = strdup(data->set.str[STRING_OPTIONS]);
5602     if(!*optionsp)
5603       return CURLE_OUT_OF_MEMORY;
5604   }
5605
5606   conn->bits.netrc = FALSE;
5607   if(data->set.use_netrc != CURL_NETRC_IGNORED) {
5608     int ret = Curl_parsenetrc(conn->host.name,
5609                               userp, passwdp,
5610                               data->set.str[STRING_NETRC_FILE]);
5611     if(ret > 0) {
5612       infof(data, "Couldn't find host %s in the "
5613             DOT_CHAR "netrc file; using defaults\n",
5614             conn->host.name);
5615     }
5616     else if(ret < 0) {
5617       return CURLE_OUT_OF_MEMORY;
5618     }
5619     else {
5620       /* set bits.netrc TRUE to remember that we got the name from a .netrc
5621          file, so that it is safe to use even if we followed a Location: to a
5622          different host or similar. */
5623       conn->bits.netrc = TRUE;
5624
5625       conn->bits.user_passwd = TRUE; /* enable user+password */
5626     }
5627   }
5628
5629   return CURLE_OK;
5630 }
5631
5632 /*
5633  * Set the login details so they're available in the connection
5634  */
5635 static CURLcode set_login(struct connectdata *conn,
5636                           const char *user, const char *passwd,
5637                           const char *options)
5638 {
5639   CURLcode result = CURLE_OK;
5640
5641   /* If our protocol needs a password and we have none, use the defaults */
5642   if((conn->handler->flags & PROTOPT_NEEDSPWD) && !conn->bits.user_passwd) {
5643     /* Store the default user */
5644     conn->user = strdup(CURL_DEFAULT_USER);
5645
5646     /* Store the default password */
5647     if(conn->user)
5648       conn->passwd = strdup(CURL_DEFAULT_PASSWORD);
5649     else
5650       conn->passwd = NULL;
5651
5652     /* This is the default password, so DON'T set conn->bits.user_passwd */
5653   }
5654   else {
5655     /* Store the user, zero-length if not set */
5656     conn->user = strdup(user);
5657
5658     /* Store the password (only if user is present), zero-length if not set */
5659     if(conn->user)
5660       conn->passwd = strdup(passwd);
5661     else
5662       conn->passwd = NULL;
5663   }
5664
5665   if(!conn->user || !conn->passwd)
5666     result = CURLE_OUT_OF_MEMORY;
5667
5668   /* Store the options, null if not set */
5669   if(!result && options[0]) {
5670     conn->options = strdup(options);
5671
5672     if(!conn->options)
5673       result = CURLE_OUT_OF_MEMORY;
5674   }
5675
5676   return result;
5677 }
5678
5679 /*
5680  * Parses a "host:port" string to connect to.
5681  * The hostname and the port may be empty; in this case, NULL is returned for
5682  * the hostname and -1 for the port.
5683  */
5684 static CURLcode parse_connect_to_host_port(struct Curl_easy *data,
5685                                            const char *host,
5686                                            char **hostname_result,
5687                                            int *port_result)
5688 {
5689   char *host_dup;
5690   char *hostptr;
5691   char *host_portno;
5692   char *portptr;
5693   int port = -1;
5694
5695 #if defined(CURL_DISABLE_VERBOSE_STRINGS)
5696   (void) data;
5697 #endif
5698
5699   *hostname_result = NULL;
5700   *port_result = -1;
5701
5702   if(!host || !*host)
5703     return CURLE_OK;
5704
5705   host_dup = strdup(host);
5706   if(!host_dup)
5707     return CURLE_OUT_OF_MEMORY;
5708
5709   hostptr = host_dup;
5710
5711   /* start scanning for port number at this point */
5712   portptr = hostptr;
5713
5714   /* detect and extract RFC6874-style IPv6-addresses */
5715   if(*hostptr == '[') {
5716     char *ptr = ++hostptr; /* advance beyond the initial bracket */
5717     while(*ptr && (ISXDIGIT(*ptr) || (*ptr == ':') || (*ptr == '.')))
5718       ptr++;
5719     if(*ptr == '%') {
5720       /* There might be a zone identifier */
5721       if(strncmp("%25", ptr, 3))
5722         infof(data, "Please URL encode %% as %%25, see RFC 6874.\n");
5723       ptr++;
5724       /* Allow unreserved characters as defined in RFC 3986 */
5725       while(*ptr && (ISALPHA(*ptr) || ISXDIGIT(*ptr) || (*ptr == '-') ||
5726                      (*ptr == '.') || (*ptr == '_') || (*ptr == '~')))
5727         ptr++;
5728     }
5729     if(*ptr == ']')
5730       /* yeps, it ended nicely with a bracket as well */
5731       *ptr++ = '\0';
5732     else
5733       infof(data, "Invalid IPv6 address format\n");
5734     portptr = ptr;
5735     /* Note that if this didn't end with a bracket, we still advanced the
5736      * hostptr first, but I can't see anything wrong with that as no host
5737      * name nor a numeric can legally start with a bracket.
5738      */
5739   }
5740
5741   /* Get port number off server.com:1080 */
5742   host_portno = strchr(portptr, ':');
5743   if(host_portno) {
5744     char *endp = NULL;
5745     *host_portno = '\0'; /* cut off number from host name */
5746     host_portno++;
5747     if(*host_portno) {
5748       long portparse = strtol(host_portno, &endp, 10);
5749       if((endp && *endp) || (portparse < 0) || (portparse > 65535)) {
5750         infof(data, "No valid port number in connect to host string (%s)\n",
5751               host_portno);
5752         hostptr = NULL;
5753         port = -1;
5754       }
5755       else
5756         port = (int)portparse; /* we know it will fit */
5757     }
5758   }
5759
5760   /* now, clone the cleaned host name */
5761   if(hostptr) {
5762     *hostname_result = strdup(hostptr);
5763     if(!*hostname_result) {
5764       free(host_dup);
5765       return CURLE_OUT_OF_MEMORY;
5766     }
5767   }
5768
5769   *port_result = port;
5770
5771   free(host_dup);
5772   return CURLE_OK;
5773 }
5774
5775 /*
5776  * Parses one "connect to" string in the form:
5777  * "HOST:PORT:CONNECT-TO-HOST:CONNECT-TO-PORT".
5778  */
5779 static CURLcode parse_connect_to_string(struct Curl_easy *data,
5780                                         struct connectdata *conn,
5781                                         const char *conn_to_host,
5782                                         char **host_result,
5783                                         int *port_result)
5784 {
5785   CURLcode result = CURLE_OK;
5786   const char *ptr = conn_to_host;
5787   int host_match = FALSE;
5788   int port_match = FALSE;
5789
5790   *host_result = NULL;
5791   *port_result = -1;
5792
5793   if(*ptr == ':') {
5794     /* an empty hostname always matches */
5795     host_match = TRUE;
5796     ptr++;
5797   }
5798   else {
5799     /* check whether the URL's hostname matches */
5800     size_t hostname_to_match_len;
5801     char *hostname_to_match = aprintf("%s%s%s",
5802                                       conn->bits.ipv6_ip ? "[" : "",
5803                                       conn->host.name,
5804                                       conn->bits.ipv6_ip ? "]" : "");
5805     if(!hostname_to_match)
5806       return CURLE_OUT_OF_MEMORY;
5807     hostname_to_match_len = strlen(hostname_to_match);
5808     host_match = strncasecompare(ptr, hostname_to_match,
5809                                  hostname_to_match_len);
5810     free(hostname_to_match);
5811     ptr += hostname_to_match_len;
5812
5813     host_match = host_match && *ptr == ':';
5814     ptr++;
5815   }
5816
5817   if(host_match) {
5818     if(*ptr == ':') {
5819       /* an empty port always matches */
5820       port_match = TRUE;
5821       ptr++;
5822     }
5823     else {
5824       /* check whether the URL's port matches */
5825       char *ptr_next = strchr(ptr, ':');
5826       if(ptr_next) {
5827         char *endp = NULL;
5828         long port_to_match = strtol(ptr, &endp, 10);
5829         if((endp == ptr_next) && (port_to_match == conn->remote_port)) {
5830           port_match = TRUE;
5831           ptr = ptr_next + 1;
5832         }
5833       }
5834     }
5835   }
5836
5837   if(host_match && port_match) {
5838     /* parse the hostname and port to connect to */
5839     result = parse_connect_to_host_port(data, ptr, host_result, port_result);
5840   }
5841
5842   return result;
5843 }
5844
5845 /*
5846  * Processes all strings in the "connect to" slist, and uses the "connect
5847  * to host" and "connect to port" of the first string that matches.
5848  */
5849 static CURLcode parse_connect_to_slist(struct Curl_easy *data,
5850                                        struct connectdata *conn,
5851                                        struct curl_slist *conn_to_host)
5852 {
5853   CURLcode result = CURLE_OK;
5854   char *host = NULL;
5855   int port = -1;
5856
5857   while(conn_to_host && !host && port == -1) {
5858     result = parse_connect_to_string(data, conn, conn_to_host->data,
5859                                      &host, &port);
5860     if(result)
5861       return result;
5862
5863     if(host && *host) {
5864       conn->conn_to_host.rawalloc = host;
5865       conn->conn_to_host.name = host;
5866       conn->bits.conn_to_host = TRUE;
5867
5868       infof(data, "Connecting to hostname: %s\n", host);
5869     }
5870     else {
5871       /* no "connect to host" */
5872       conn->bits.conn_to_host = FALSE;
5873       Curl_safefree(host);
5874     }
5875
5876     if(port >= 0) {
5877       conn->conn_to_port = port;
5878       conn->bits.conn_to_port = TRUE;
5879       infof(data, "Connecting to port: %d\n", port);
5880     }
5881     else {
5882       /* no "connect to port" */
5883       conn->bits.conn_to_port = FALSE;
5884       port = -1;
5885     }
5886
5887     conn_to_host = conn_to_host->next;
5888   }
5889
5890   return result;
5891 }
5892
5893 /*************************************************************
5894  * Resolve the address of the server or proxy
5895  *************************************************************/
5896 static CURLcode resolve_server(struct Curl_easy *data,
5897                                struct connectdata *conn,
5898                                bool *async)
5899 {
5900   CURLcode result=CURLE_OK;
5901   time_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
5902
5903   /*************************************************************
5904    * Resolve the name of the server or proxy
5905    *************************************************************/
5906   if(conn->bits.reuse)
5907     /* We're reusing the connection - no need to resolve anything, and
5908        fix_hostname() was called already in create_conn() for the re-use
5909        case. */
5910     *async = FALSE;
5911
5912   else {
5913     /* this is a fresh connect */
5914     int rc;
5915     struct Curl_dns_entry *hostaddr;
5916
5917 #ifdef USE_UNIX_SOCKETS
5918     if(conn->unix_domain_socket) {
5919       /* Unix domain sockets are local. The host gets ignored, just use the
5920        * specified domain socket address. Do not cache "DNS entries". There is
5921        * no DNS involved and we already have the filesystem path available */
5922       const char *path = conn->unix_domain_socket;
5923
5924       hostaddr = calloc(1, sizeof(struct Curl_dns_entry));
5925       if(!hostaddr)
5926         result = CURLE_OUT_OF_MEMORY;
5927       else {
5928         bool longpath = FALSE;
5929         hostaddr->addr = Curl_unix2addr(path, &longpath,
5930                                         conn->abstract_unix_socket);
5931         if(hostaddr->addr)
5932           hostaddr->inuse++;
5933         else {
5934           /* Long paths are not supported for now */
5935           if(longpath) {
5936             failf(data, "Unix socket path too long: '%s'", path);
5937             result = CURLE_COULDNT_RESOLVE_HOST;
5938           }
5939           else
5940             result = CURLE_OUT_OF_MEMORY;
5941           free(hostaddr);
5942           hostaddr = NULL;
5943         }
5944       }
5945     }
5946     else
5947 #endif
5948     if(!conn->bits.proxy) {
5949       struct hostname *connhost;
5950       if(conn->bits.conn_to_host)
5951         connhost = &conn->conn_to_host;
5952       else
5953         connhost = &conn->host;
5954
5955       /* If not connecting via a proxy, extract the port from the URL, if it is
5956        * there, thus overriding any defaults that might have been set above. */
5957       if(conn->bits.conn_to_port)
5958         conn->port = conn->conn_to_port;
5959       else
5960         conn->port = conn->remote_port;
5961
5962       /* Resolve target host right on */
5963       rc = Curl_resolv_timeout(conn, connhost->name, (int)conn->port,
5964                                &hostaddr, timeout_ms);
5965       if(rc == CURLRESOLV_PENDING)
5966         *async = TRUE;
5967
5968       else if(rc == CURLRESOLV_TIMEDOUT)
5969         result = CURLE_OPERATION_TIMEDOUT;
5970
5971       else if(!hostaddr) {
5972         failf(data, "Couldn't resolve host '%s'", connhost->dispname);
5973         result =  CURLE_COULDNT_RESOLVE_HOST;
5974         /* don't return yet, we need to clean up the timeout first */
5975       }
5976     }
5977     else {
5978       /* This is a proxy that hasn't been resolved yet. */
5979
5980       struct hostname * const host = conn->bits.socksproxy ?
5981         &conn->socks_proxy.host : &conn->http_proxy.host;
5982
5983       /* resolve proxy */
5984       rc = Curl_resolv_timeout(conn, host->name, (int)conn->port,
5985                                &hostaddr, timeout_ms);
5986
5987       if(rc == CURLRESOLV_PENDING)
5988         *async = TRUE;
5989
5990       else if(rc == CURLRESOLV_TIMEDOUT)
5991         result = CURLE_OPERATION_TIMEDOUT;
5992
5993       else if(!hostaddr) {
5994         failf(data, "Couldn't resolve proxy '%s'", host->dispname);
5995         result = CURLE_COULDNT_RESOLVE_PROXY;
5996         /* don't return yet, we need to clean up the timeout first */
5997       }
5998     }
5999     DEBUGASSERT(conn->dns_entry == NULL);
6000     conn->dns_entry = hostaddr;
6001   }
6002
6003   return result;
6004 }
6005
6006 /*
6007  * Cleanup the connection just allocated before we can move along and use the
6008  * previously existing one.  All relevant data is copied over and old_conn is
6009  * ready for freeing once this function returns.
6010  */
6011 static void reuse_conn(struct connectdata *old_conn,
6012                        struct connectdata *conn)
6013 {
6014   free_fixed_hostname(&old_conn->http_proxy.host);
6015   free_fixed_hostname(&old_conn->socks_proxy.host);
6016
6017   free(old_conn->http_proxy.host.rawalloc);
6018   free(old_conn->socks_proxy.host.rawalloc);
6019
6020   /* free the SSL config struct from this connection struct as this was
6021      allocated in vain and is targeted for destruction */
6022   Curl_free_primary_ssl_config(&old_conn->ssl_config);
6023   Curl_free_primary_ssl_config(&old_conn->proxy_ssl_config);
6024
6025   conn->data = old_conn->data;
6026
6027   /* get the user+password information from the old_conn struct since it may
6028    * be new for this request even when we re-use an existing connection */
6029   conn->bits.user_passwd = old_conn->bits.user_passwd;
6030   if(conn->bits.user_passwd) {
6031     /* use the new user name and password though */
6032     Curl_safefree(conn->user);
6033     Curl_safefree(conn->passwd);
6034     conn->user = old_conn->user;
6035     conn->passwd = old_conn->passwd;
6036     old_conn->user = NULL;
6037     old_conn->passwd = NULL;
6038   }
6039
6040   conn->bits.proxy_user_passwd = old_conn->bits.proxy_user_passwd;
6041   if(conn->bits.proxy_user_passwd) {
6042     /* use the new proxy user name and proxy password though */
6043     Curl_safefree(conn->http_proxy.user);
6044     Curl_safefree(conn->socks_proxy.user);
6045     Curl_safefree(conn->http_proxy.passwd);
6046     Curl_safefree(conn->socks_proxy.passwd);
6047     conn->http_proxy.user = old_conn->http_proxy.user;
6048     conn->socks_proxy.user = old_conn->socks_proxy.user;
6049     conn->http_proxy.passwd = old_conn->http_proxy.passwd;
6050     conn->socks_proxy.passwd = old_conn->socks_proxy.passwd;
6051     old_conn->http_proxy.user = NULL;
6052     old_conn->socks_proxy.user = NULL;
6053     old_conn->http_proxy.passwd = NULL;
6054     old_conn->socks_proxy.passwd = NULL;
6055   }
6056
6057   /* host can change, when doing keepalive with a proxy or if the case is
6058      different this time etc */
6059   free_fixed_hostname(&conn->host);
6060   free_fixed_hostname(&conn->conn_to_host);
6061   Curl_safefree(conn->host.rawalloc);
6062   Curl_safefree(conn->conn_to_host.rawalloc);
6063   conn->host=old_conn->host;
6064   conn->bits.conn_to_host = old_conn->bits.conn_to_host;
6065   conn->conn_to_host = old_conn->conn_to_host;
6066   conn->bits.conn_to_port = old_conn->bits.conn_to_port;
6067   conn->conn_to_port = old_conn->conn_to_port;
6068
6069   /* persist connection info in session handle */
6070   Curl_persistconninfo(conn);
6071
6072   conn_reset_all_postponed_data(old_conn); /* free buffers */
6073   conn_reset_all_postponed_data(conn);     /* reset unprocessed data */
6074
6075   /* re-use init */
6076   conn->bits.reuse = TRUE; /* yes, we're re-using here */
6077
6078   Curl_safefree(old_conn->user);
6079   Curl_safefree(old_conn->passwd);
6080   Curl_safefree(old_conn->http_proxy.user);
6081   Curl_safefree(old_conn->socks_proxy.user);
6082   Curl_safefree(old_conn->http_proxy.passwd);
6083   Curl_safefree(old_conn->socks_proxy.passwd);
6084   Curl_safefree(old_conn->localdev);
6085
6086   Curl_llist_destroy(old_conn->send_pipe, NULL);
6087   Curl_llist_destroy(old_conn->recv_pipe, NULL);
6088
6089   old_conn->send_pipe = NULL;
6090   old_conn->recv_pipe = NULL;
6091
6092   Curl_safefree(old_conn->master_buffer);
6093
6094 #ifdef USE_UNIX_SOCKETS
6095   Curl_safefree(old_conn->unix_domain_socket);
6096 #endif
6097 }
6098
6099 /**
6100  * create_conn() sets up a new connectdata struct, or re-uses an already
6101  * existing one, and resolves host name.
6102  *
6103  * if this function returns CURLE_OK and *async is set to TRUE, the resolve
6104  * response will be coming asynchronously. If *async is FALSE, the name is
6105  * already resolved.
6106  *
6107  * @param data The sessionhandle pointer
6108  * @param in_connect is set to the next connection data pointer
6109  * @param async is set TRUE when an async DNS resolution is pending
6110  * @see Curl_setup_conn()
6111  *
6112  * *NOTE* this function assigns the conn->data pointer!
6113  */
6114
6115 static CURLcode create_conn(struct Curl_easy *data,
6116                             struct connectdata **in_connect,
6117                             bool *async)
6118 {
6119   CURLcode result = CURLE_OK;
6120   struct connectdata *conn;
6121   struct connectdata *conn_temp = NULL;
6122   size_t urllen;
6123   char *user = NULL;
6124   char *passwd = NULL;
6125   char *options = NULL;
6126   bool reuse;
6127   char *proxy = NULL;
6128   char *socksproxy = NULL;
6129   char *no_proxy = NULL;
6130   bool prot_missing = FALSE;
6131   bool connections_available = TRUE;
6132   bool force_reuse = FALSE;
6133   bool waitpipe = FALSE;
6134   size_t max_host_connections = Curl_multi_max_host_connections(data->multi);
6135   size_t max_total_connections = Curl_multi_max_total_connections(data->multi);
6136
6137   *async = FALSE;
6138
6139   /*************************************************************
6140    * Check input data
6141    *************************************************************/
6142
6143   if(!data->change.url) {
6144     result = CURLE_URL_MALFORMAT;
6145     goto out;
6146   }
6147
6148   /* First, split up the current URL in parts so that we can use the
6149      parts for checking against the already present connections. In order
6150      to not have to modify everything at once, we allocate a temporary
6151      connection data struct and fill in for comparison purposes. */
6152   conn = allocate_conn(data);
6153
6154   if(!conn) {
6155     result = CURLE_OUT_OF_MEMORY;
6156     goto out;
6157   }
6158
6159   /* We must set the return variable as soon as possible, so that our
6160      parent can cleanup any possible allocs we may have done before
6161      any failure */
6162   *in_connect = conn;
6163
6164   /* This initing continues below, see the comment "Continue connectdata
6165    * initialization here" */
6166
6167   /***********************************************************
6168    * We need to allocate memory to store the path in. We get the size of the
6169    * full URL to be sure, and we need to make it at least 256 bytes since
6170    * other parts of the code will rely on this fact
6171    ***********************************************************/
6172 #define LEAST_PATH_ALLOC 256
6173   urllen=strlen(data->change.url);
6174   if(urllen < LEAST_PATH_ALLOC)
6175     urllen=LEAST_PATH_ALLOC;
6176
6177   /*
6178    * We malloc() the buffers below urllen+2 to make room for 2 possibilities:
6179    * 1 - an extra terminating zero
6180    * 2 - an extra slash (in case a syntax like "www.host.com?moo" is used)
6181    */
6182
6183   Curl_safefree(data->state.pathbuffer);
6184   data->state.path = NULL;
6185
6186   data->state.pathbuffer = malloc(urllen+2);
6187   if(NULL == data->state.pathbuffer) {
6188     result = CURLE_OUT_OF_MEMORY; /* really bad error */
6189     goto out;
6190   }
6191   data->state.path = data->state.pathbuffer;
6192
6193   conn->host.rawalloc = malloc(urllen+2);
6194   if(NULL == conn->host.rawalloc) {
6195     Curl_safefree(data->state.pathbuffer);
6196     data->state.path = NULL;
6197     result = CURLE_OUT_OF_MEMORY;
6198     goto out;
6199   }
6200
6201   conn->host.name = conn->host.rawalloc;
6202   conn->host.name[0] = 0;
6203
6204   user = strdup("");
6205   passwd = strdup("");
6206   options = strdup("");
6207   if(!user || !passwd || !options) {
6208     result = CURLE_OUT_OF_MEMORY;
6209     goto out;
6210   }
6211
6212   result = parseurlandfillconn(data, conn, &prot_missing, &user, &passwd,
6213                                &options);
6214   if(result)
6215     goto out;
6216
6217   /*************************************************************
6218    * No protocol part in URL was used, add it!
6219    *************************************************************/
6220   if(prot_missing) {
6221     /* We're guessing prefixes here and if we're told to use a proxy or if
6222        we're gonna follow a Location: later or... then we need the protocol
6223        part added so that we have a valid URL. */
6224     char *reurl;
6225     char *ch_lower;
6226
6227     reurl = aprintf("%s://%s", conn->handler->scheme, data->change.url);
6228
6229     if(!reurl) {
6230       result = CURLE_OUT_OF_MEMORY;
6231       goto out;
6232     }
6233
6234     /* Change protocol prefix to lower-case */
6235     for(ch_lower = reurl; *ch_lower != ':'; ch_lower++)
6236       *ch_lower = (char)TOLOWER(*ch_lower);
6237
6238     if(data->change.url_alloc) {
6239       Curl_safefree(data->change.url);
6240       data->change.url_alloc = FALSE;
6241     }
6242
6243     data->change.url = reurl;
6244     data->change.url_alloc = TRUE; /* free this later */
6245   }
6246
6247   /*************************************************************
6248    * If the protocol can't handle url query strings, then cut
6249    * off the unhandable part
6250    *************************************************************/
6251   if((conn->given->flags&PROTOPT_NOURLQUERY)) {
6252     char *path_q_sep = strchr(conn->data->state.path, '?');
6253     if(path_q_sep) {
6254       /* according to rfc3986, allow the query (?foo=bar)
6255          also on protocols that can't handle it.
6256
6257          cut the string-part after '?'
6258       */
6259
6260       /* terminate the string */
6261       path_q_sep[0] = 0;
6262     }
6263   }
6264
6265   if(data->set.str[STRING_BEARER]) {
6266     conn->oauth_bearer = strdup(data->set.str[STRING_BEARER]);
6267     if(!conn->oauth_bearer) {
6268       result = CURLE_OUT_OF_MEMORY;
6269       goto out;
6270     }
6271   }
6272
6273 #ifndef CURL_DISABLE_PROXY
6274   /*************************************************************
6275    * Extract the user and password from the authentication string
6276    *************************************************************/
6277   if(conn->bits.proxy_user_passwd) {
6278     result = parse_proxy_auth(data, conn);
6279     if(result)
6280       goto out;
6281   }
6282
6283   /*************************************************************
6284    * Detect what (if any) proxy to use
6285    *************************************************************/
6286   if(data->set.str[STRING_PROXY]) {
6287     proxy = strdup(data->set.str[STRING_PROXY]);
6288     /* if global proxy is set, this is it */
6289     if(NULL == proxy) {
6290       failf(data, "memory shortage");
6291       result = CURLE_OUT_OF_MEMORY;
6292       goto out;
6293     }
6294   }
6295
6296   if(data->set.str[STRING_PRE_PROXY]) {
6297     socksproxy = strdup(data->set.str[STRING_PRE_PROXY]);
6298     /* if global socks proxy is set, this is it */
6299     if(NULL == socksproxy) {
6300       failf(data, "memory shortage");
6301       result = CURLE_OUT_OF_MEMORY;
6302       goto out;
6303     }
6304   }
6305
6306   no_proxy = curl_getenv("no_proxy");
6307   if(!no_proxy)
6308     no_proxy = curl_getenv("NO_PROXY");
6309
6310   if(check_noproxy(conn->host.name, data->set.str[STRING_NOPROXY]) ||
6311      (!data->set.str[STRING_NOPROXY] &&
6312       check_noproxy(conn->host.name, no_proxy))) {
6313     Curl_safefree(proxy);
6314     Curl_safefree(socksproxy);
6315   }
6316   else if(!proxy && !socksproxy)
6317 #ifndef CURL_DISABLE_HTTP
6318     /* if the host is not in the noproxy list, detect proxy. */
6319     proxy = detect_proxy(conn);
6320 #else  /* !CURL_DISABLE_HTTP */
6321     proxy = NULL;
6322 #endif /* CURL_DISABLE_HTTP */
6323
6324   Curl_safefree(no_proxy);
6325
6326 #ifdef USE_UNIX_SOCKETS
6327   if(data->set.str[STRING_UNIX_SOCKET_PATH]) {
6328     if(proxy) {
6329       free(proxy); /* Unix domain sockets cannot be proxied, so disable it */
6330       proxy = NULL;
6331     }
6332     conn->unix_domain_socket = strdup(data->set.str[STRING_UNIX_SOCKET_PATH]);
6333     if(conn->unix_domain_socket == NULL) {
6334       result = CURLE_OUT_OF_MEMORY;
6335       goto out;
6336     }
6337     conn->abstract_unix_socket = data->set.abstract_unix_socket;
6338   }
6339 #endif
6340
6341   if(proxy && (!*proxy || (conn->handler->flags & PROTOPT_NONETWORK))) {
6342     free(proxy);  /* Don't bother with an empty proxy string or if the
6343                      protocol doesn't work with network */
6344     proxy = NULL;
6345   }
6346   if(socksproxy && (!*socksproxy ||
6347                     (conn->handler->flags & PROTOPT_NONETWORK))) {
6348     free(socksproxy);  /* Don't bother with an empty socks proxy string or if
6349                           the protocol doesn't work with network */
6350     socksproxy = NULL;
6351   }
6352
6353   /***********************************************************************
6354    * If this is supposed to use a proxy, we need to figure out the proxy host
6355    * name, proxy type and port number, so that we can re-use an existing
6356    * connection that may exist registered to the same proxy host.
6357    ***********************************************************************/
6358   if(proxy || socksproxy) {
6359     if(proxy) {
6360       result = parse_proxy(data, conn, proxy, conn->http_proxy.proxytype);
6361       Curl_safefree(proxy); /* parse_proxy copies the proxy string */
6362       if(result)
6363         goto out;
6364     }
6365
6366     if(socksproxy) {
6367       result = parse_proxy(data, conn, socksproxy,
6368                            conn->socks_proxy.proxytype);
6369       /* parse_proxy copies the socks proxy string */
6370       Curl_safefree(socksproxy);
6371       if(result)
6372         goto out;
6373     }
6374
6375     if(conn->http_proxy.host.rawalloc) {
6376 #ifdef CURL_DISABLE_HTTP
6377       /* asking for a HTTP proxy is a bit funny when HTTP is disabled... */
6378       result = CURLE_UNSUPPORTED_PROTOCOL;
6379       goto out;
6380 #else
6381       /* force this connection's protocol to become HTTP if not already
6382          compatible - if it isn't tunneling through */
6383       if(!(conn->handler->protocol & PROTO_FAMILY_HTTP) &&
6384          !conn->bits.tunnel_proxy)
6385         conn->handler = &Curl_handler_http;
6386
6387       conn->bits.httpproxy = TRUE;
6388 #endif
6389     }
6390     else {
6391       conn->bits.httpproxy = FALSE; /* not a HTTP proxy */
6392       conn->bits.tunnel_proxy = FALSE; /* no tunneling if not HTTP */
6393     }
6394
6395     if(conn->socks_proxy.host.rawalloc) {
6396       if(!conn->http_proxy.host.rawalloc) {
6397         /* once a socks proxy */
6398         if(!conn->socks_proxy.user) {
6399           conn->socks_proxy.user = conn->http_proxy.user;
6400           conn->http_proxy.user = NULL;
6401           Curl_safefree(conn->socks_proxy.passwd);
6402           conn->socks_proxy.passwd = conn->http_proxy.passwd;
6403           conn->http_proxy.passwd = NULL;
6404         }
6405       }
6406       conn->bits.socksproxy = TRUE;
6407     }
6408     else
6409       conn->bits.socksproxy = FALSE; /* not a socks proxy */
6410   }
6411   else {
6412     conn->bits.socksproxy = FALSE;
6413     conn->bits.httpproxy = FALSE;
6414   }
6415   conn->bits.proxy = conn->bits.httpproxy || conn->bits.socksproxy;
6416
6417   if(!conn->bits.proxy) {
6418     /* we aren't using the proxy after all... */
6419     conn->bits.proxy = FALSE;
6420     conn->bits.httpproxy = FALSE;
6421     conn->bits.socksproxy = FALSE;
6422     conn->bits.proxy_user_passwd = FALSE;
6423     conn->bits.tunnel_proxy = FALSE;
6424   }
6425
6426 #endif /* CURL_DISABLE_PROXY */
6427
6428   /*************************************************************
6429    * If the protocol is using SSL and HTTP proxy is used, we set
6430    * the tunnel_proxy bit.
6431    *************************************************************/
6432   if((conn->given->flags&PROTOPT_SSL) && conn->bits.httpproxy)
6433     conn->bits.tunnel_proxy = TRUE;
6434
6435   /*************************************************************
6436    * Figure out the remote port number and fix it in the URL
6437    *************************************************************/
6438   result = parse_remote_port(data, conn);
6439   if(result)
6440     goto out;
6441
6442   /* Check for overridden login details and set them accordingly so they
6443      they are known when protocol->setup_connection is called! */
6444   result = override_login(data, conn, &user, &passwd, &options);
6445   if(result)
6446     goto out;
6447   result = set_login(conn, user, passwd, options);
6448   if(result)
6449     goto out;
6450
6451   /*************************************************************
6452    * Process the "connect to" linked list of hostname/port mappings.
6453    * Do this after the remote port number has been fixed in the URL.
6454    *************************************************************/
6455   result = parse_connect_to_slist(data, conn, data->set.connect_to);
6456   if(result)
6457     goto out;
6458
6459   /*************************************************************
6460    * IDN-fix the hostnames
6461    *************************************************************/
6462   fix_hostname(conn, &conn->host);
6463   if(conn->bits.conn_to_host)
6464     fix_hostname(conn, &conn->conn_to_host);
6465   if(conn->bits.httpproxy)
6466     fix_hostname(conn, &conn->http_proxy.host);
6467   if(conn->bits.socksproxy)
6468     fix_hostname(conn, &conn->socks_proxy.host);
6469
6470   /*************************************************************
6471    * Check whether the host and the "connect to host" are equal.
6472    * Do this after the hostnames have been IDN-fixed.
6473    *************************************************************/
6474   if(conn->bits.conn_to_host &&
6475      strcasecompare(conn->conn_to_host.name, conn->host.name)) {
6476     conn->bits.conn_to_host = FALSE;
6477   }
6478
6479   /*************************************************************
6480    * Check whether the port and the "connect to port" are equal.
6481    * Do this after the remote port number has been fixed in the URL.
6482    *************************************************************/
6483   if(conn->bits.conn_to_port && conn->conn_to_port == conn->remote_port) {
6484     conn->bits.conn_to_port = FALSE;
6485   }
6486
6487   /*************************************************************
6488    * If the "connect to" feature is used with an HTTP proxy,
6489    * we set the tunnel_proxy bit.
6490    *************************************************************/
6491   if((conn->bits.conn_to_host || conn->bits.conn_to_port) &&
6492       conn->bits.httpproxy)
6493     conn->bits.tunnel_proxy = TRUE;
6494
6495   /*************************************************************
6496    * Setup internals depending on protocol. Needs to be done after
6497    * we figured out what/if proxy to use.
6498    *************************************************************/
6499   result = setup_connection_internals(conn);
6500   if(result)
6501     goto out;
6502
6503   conn->recv[FIRSTSOCKET] = Curl_recv_plain;
6504   conn->send[FIRSTSOCKET] = Curl_send_plain;
6505   conn->recv[SECONDARYSOCKET] = Curl_recv_plain;
6506   conn->send[SECONDARYSOCKET] = Curl_send_plain;
6507
6508   conn->bits.tcp_fastopen = data->set.tcp_fastopen;
6509
6510   /***********************************************************************
6511    * file: is a special case in that it doesn't need a network connection
6512    ***********************************************************************/
6513 #ifndef CURL_DISABLE_FILE
6514   if(conn->handler->flags & PROTOPT_NONETWORK) {
6515     bool done;
6516     /* this is supposed to be the connect function so we better at least check
6517        that the file is present here! */
6518     DEBUGASSERT(conn->handler->connect_it);
6519     result = conn->handler->connect_it(conn, &done);
6520
6521     /* Setup a "faked" transfer that'll do nothing */
6522     if(!result) {
6523       conn->data = data;
6524       conn->bits.tcpconnect[FIRSTSOCKET] = TRUE; /* we are "connected */
6525
6526       Curl_conncache_add_conn(data->state.conn_cache, conn);
6527
6528       /*
6529        * Setup whatever necessary for a resumed transfer
6530        */
6531       result = setup_range(data);
6532       if(result) {
6533         DEBUGASSERT(conn->handler->done);
6534         /* we ignore the return code for the protocol-specific DONE */
6535         (void)conn->handler->done(conn, result, FALSE);
6536         goto out;
6537       }
6538
6539       Curl_setup_transfer(conn, -1, -1, FALSE, NULL, /* no download */
6540                           -1, NULL); /* no upload */
6541     }
6542
6543     /* since we skip do_init() */
6544     Curl_init_do(data, conn);
6545
6546     goto out;
6547   }
6548 #endif
6549
6550   /* Get a cloned copy of the SSL config situation stored in the
6551      connection struct. But to get this going nicely, we must first make
6552      sure that the strings in the master copy are pointing to the correct
6553      strings in the session handle strings array!
6554
6555      Keep in mind that the pointers in the master copy are pointing to strings
6556      that will be freed as part of the Curl_easy struct, but all cloned
6557      copies will be separately allocated.
6558   */
6559   data->set.ssl.primary.CApath = data->set.str[STRING_SSL_CAPATH_ORIG];
6560   data->set.proxy_ssl.primary.CApath = data->set.str[STRING_SSL_CAPATH_PROXY];
6561   data->set.ssl.primary.CAfile = data->set.str[STRING_SSL_CAFILE_ORIG];
6562   data->set.proxy_ssl.primary.CAfile = data->set.str[STRING_SSL_CAFILE_PROXY];
6563   data->set.ssl.primary.random_file = data->set.str[STRING_SSL_RANDOM_FILE];
6564   data->set.proxy_ssl.primary.random_file =
6565     data->set.str[STRING_SSL_RANDOM_FILE];
6566   data->set.ssl.primary.egdsocket = data->set.str[STRING_SSL_EGDSOCKET];
6567   data->set.proxy_ssl.primary.egdsocket = data->set.str[STRING_SSL_EGDSOCKET];
6568   data->set.ssl.primary.cipher_list =
6569     data->set.str[STRING_SSL_CIPHER_LIST_ORIG];
6570   data->set.proxy_ssl.primary.cipher_list =
6571     data->set.str[STRING_SSL_CIPHER_LIST_PROXY];
6572
6573   data->set.ssl.CRLfile = data->set.str[STRING_SSL_CRLFILE_ORIG];
6574   data->set.proxy_ssl.CRLfile = data->set.str[STRING_SSL_CRLFILE_PROXY];
6575   data->set.ssl.issuercert = data->set.str[STRING_SSL_ISSUERCERT_ORIG];
6576   data->set.proxy_ssl.issuercert = data->set.str[STRING_SSL_ISSUERCERT_PROXY];
6577   data->set.ssl.cert = data->set.str[STRING_CERT_ORIG];
6578   data->set.proxy_ssl.cert = data->set.str[STRING_CERT_PROXY];
6579   data->set.ssl.cert_type = data->set.str[STRING_CERT_TYPE_ORIG];
6580   data->set.proxy_ssl.cert_type = data->set.str[STRING_CERT_TYPE_PROXY];
6581   data->set.ssl.key = data->set.str[STRING_KEY_ORIG];
6582   data->set.proxy_ssl.key = data->set.str[STRING_KEY_PROXY];
6583   data->set.ssl.key_type = data->set.str[STRING_KEY_TYPE_ORIG];
6584   data->set.proxy_ssl.key_type = data->set.str[STRING_KEY_TYPE_PROXY];
6585   data->set.ssl.key_passwd = data->set.str[STRING_KEY_PASSWD_ORIG];
6586   data->set.proxy_ssl.key_passwd = data->set.str[STRING_KEY_PASSWD_PROXY];
6587   data->set.ssl.primary.clientcert = data->set.str[STRING_CERT_ORIG];
6588   data->set.proxy_ssl.primary.clientcert = data->set.str[STRING_CERT_PROXY];
6589 #ifdef USE_TLS_SRP
6590   data->set.ssl.username = data->set.str[STRING_TLSAUTH_USERNAME_ORIG];
6591   data->set.proxy_ssl.username = data->set.str[STRING_TLSAUTH_USERNAME_PROXY];
6592   data->set.ssl.password = data->set.str[STRING_TLSAUTH_PASSWORD_ORIG];
6593   data->set.proxy_ssl.password = data->set.str[STRING_TLSAUTH_PASSWORD_PROXY];
6594 #endif
6595
6596   if(!Curl_clone_primary_ssl_config(&data->set.ssl.primary,
6597      &conn->ssl_config)) {
6598     result = CURLE_OUT_OF_MEMORY;
6599     goto out;
6600   }
6601
6602   if(!Curl_clone_primary_ssl_config(&data->set.proxy_ssl.primary,
6603                                     &conn->proxy_ssl_config)) {
6604     result = CURLE_OUT_OF_MEMORY;
6605     goto out;
6606   }
6607
6608   prune_dead_connections(data);
6609
6610   /*************************************************************
6611    * Check the current list of connections to see if we can
6612    * re-use an already existing one or if we have to create a
6613    * new one.
6614    *************************************************************/
6615
6616   /* reuse_fresh is TRUE if we are told to use a new connection by force, but
6617      we only acknowledge this option if this is not a re-used connection
6618      already (which happens due to follow-location or during a HTTP
6619      authentication phase). */
6620   if(data->set.reuse_fresh && !data->state.this_is_a_follow)
6621     reuse = FALSE;
6622   else
6623     reuse = ConnectionExists(data, conn, &conn_temp, &force_reuse, &waitpipe);
6624
6625   /* If we found a reusable connection, we may still want to
6626      open a new connection if we are pipelining. */
6627   if(reuse && !force_reuse && IsPipeliningPossible(data, conn_temp)) {
6628     size_t pipelen = conn_temp->send_pipe->size + conn_temp->recv_pipe->size;
6629     if(pipelen > 0) {
6630       infof(data, "Found connection %ld, with requests in the pipe (%zu)\n",
6631             conn_temp->connection_id, pipelen);
6632
6633       if(conn_temp->bundle->num_connections < max_host_connections &&
6634          data->state.conn_cache->num_connections < max_total_connections) {
6635         /* We want a new connection anyway */
6636         reuse = FALSE;
6637
6638         infof(data, "We can reuse, but we want a new connection anyway\n");
6639       }
6640     }
6641   }
6642
6643   if(reuse) {
6644     /*
6645      * We already have a connection for this, we got the former connection
6646      * in the conn_temp variable and thus we need to cleanup the one we
6647      * just allocated before we can move along and use the previously
6648      * existing one.
6649      */
6650     conn_temp->inuse = TRUE; /* mark this as being in use so that no other
6651                                 handle in a multi stack may nick it */
6652     reuse_conn(conn, conn_temp);
6653     free(conn);          /* we don't need this anymore */
6654     conn = conn_temp;
6655     *in_connect = conn;
6656
6657     infof(data, "Re-using existing connection! (#%ld) with %s %s\n",
6658           conn->connection_id,
6659           conn->bits.proxy?"proxy":"host",
6660           conn->socks_proxy.host.name ? conn->socks_proxy.host.dispname :
6661           conn->http_proxy.host.name ? conn->http_proxy.host.dispname :
6662                                        conn->host.dispname);
6663   }
6664   else {
6665     /* We have decided that we want a new connection. However, we may not
6666        be able to do that if we have reached the limit of how many
6667        connections we are allowed to open. */
6668     struct connectbundle *bundle = NULL;
6669
6670     if(conn->handler->flags & PROTOPT_ALPN_NPN) {
6671       /* The protocol wants it, so set the bits if enabled in the easy handle
6672          (default) */
6673       if(data->set.ssl_enable_alpn)
6674         conn->bits.tls_enable_alpn = TRUE;
6675       if(data->set.ssl_enable_npn)
6676         conn->bits.tls_enable_npn = TRUE;
6677     }
6678
6679     if(waitpipe)
6680       /* There is a connection that *might* become usable for pipelining
6681          "soon", and we wait for that */
6682       connections_available = FALSE;
6683     else
6684       bundle = Curl_conncache_find_bundle(conn, data->state.conn_cache);
6685
6686     if(max_host_connections > 0 && bundle &&
6687        (bundle->num_connections >= max_host_connections)) {
6688       struct connectdata *conn_candidate;
6689
6690       /* The bundle is full. Let's see if we can kill a connection. */
6691       conn_candidate = find_oldest_idle_connection_in_bundle(data, bundle);
6692
6693       if(conn_candidate) {
6694         /* Set the connection's owner correctly, then kill it */
6695         conn_candidate->data = data;
6696         (void)Curl_disconnect(conn_candidate, /* dead_connection */ FALSE);
6697       }
6698       else {
6699         infof(data, "No more connections allowed to host: %d\n",
6700               max_host_connections);
6701         connections_available = FALSE;
6702       }
6703     }
6704
6705     if(connections_available &&
6706        (max_total_connections > 0) &&
6707        (data->state.conn_cache->num_connections >= max_total_connections)) {
6708       struct connectdata *conn_candidate;
6709
6710       /* The cache is full. Let's see if we can kill a connection. */
6711       conn_candidate = Curl_oldest_idle_connection(data);
6712
6713       if(conn_candidate) {
6714         /* Set the connection's owner correctly, then kill it */
6715         conn_candidate->data = data;
6716         (void)Curl_disconnect(conn_candidate, /* dead_connection */ FALSE);
6717       }
6718       else {
6719         infof(data, "No connections available in cache\n");
6720         connections_available = FALSE;
6721       }
6722     }
6723
6724     if(!connections_available) {
6725       infof(data, "No connections available.\n");
6726
6727       conn_free(conn);
6728       *in_connect = NULL;
6729
6730       result = CURLE_NO_CONNECTION_AVAILABLE;
6731       goto out;
6732     }
6733     else {
6734       /*
6735        * This is a brand new connection, so let's store it in the connection
6736        * cache of ours!
6737        */
6738       Curl_conncache_add_conn(data->state.conn_cache, conn);
6739     }
6740
6741 #if defined(USE_NTLM)
6742     /* If NTLM is requested in a part of this connection, make sure we don't
6743        assume the state is fine as this is a fresh connection and NTLM is
6744        connection based. */
6745     if((data->state.authhost.picked & (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
6746        data->state.authhost.done) {
6747       infof(data, "NTLM picked AND auth done set, clear picked!\n");
6748       data->state.authhost.picked = CURLAUTH_NONE;
6749       data->state.authhost.done = FALSE;
6750     }
6751
6752     if((data->state.authproxy.picked & (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
6753        data->state.authproxy.done) {
6754       infof(data, "NTLM-proxy picked AND auth done set, clear picked!\n");
6755       data->state.authproxy.picked = CURLAUTH_NONE;
6756       data->state.authproxy.done = FALSE;
6757     }
6758 #endif
6759   }
6760
6761   /* Mark the connection as used */
6762   conn->inuse = TRUE;
6763
6764   /* Setup and init stuff before DO starts, in preparing for the transfer. */
6765   Curl_init_do(data, conn);
6766
6767   /*
6768    * Setup whatever necessary for a resumed transfer
6769    */
6770   result = setup_range(data);
6771   if(result)
6772     goto out;
6773
6774   /* Continue connectdata initialization here. */
6775
6776   /*
6777    * Inherit the proper values from the urldata struct AFTER we have arranged
6778    * the persistent connection stuff
6779    */
6780   conn->seek_func = data->set.seek_func;
6781   conn->seek_client = data->set.seek_client;
6782
6783   /*************************************************************
6784    * Resolve the address of the server or proxy
6785    *************************************************************/
6786   result = resolve_server(data, conn, async);
6787
6788   out:
6789
6790   free(options);
6791   free(passwd);
6792   free(user);
6793   free(socksproxy);
6794   free(proxy);
6795   return result;
6796 }
6797
6798 /* Curl_setup_conn() is called after the name resolve initiated in
6799  * create_conn() is all done.
6800  *
6801  * Curl_setup_conn() also handles reused connections
6802  *
6803  * conn->data MUST already have been setup fine (in create_conn)
6804  */
6805
6806 CURLcode Curl_setup_conn(struct connectdata *conn,
6807                          bool *protocol_done)
6808 {
6809   CURLcode result = CURLE_OK;
6810   struct Curl_easy *data = conn->data;
6811
6812   Curl_pgrsTime(data, TIMER_NAMELOOKUP);
6813
6814   if(conn->handler->flags & PROTOPT_NONETWORK) {
6815     /* nothing to setup when not using a network */
6816     *protocol_done = TRUE;
6817     return result;
6818   }
6819   *protocol_done = FALSE; /* default to not done */
6820
6821   /* set proxy_connect_closed to false unconditionally already here since it
6822      is used strictly to provide extra information to a parent function in the
6823      case of proxy CONNECT failures and we must make sure we don't have it
6824      lingering set from a previous invoke */
6825   conn->bits.proxy_connect_closed = FALSE;
6826
6827   /*
6828    * Set user-agent. Used for HTTP, but since we can attempt to tunnel
6829    * basically anything through a http proxy we can't limit this based on
6830    * protocol.
6831    */
6832   if(data->set.str[STRING_USERAGENT]) {
6833     Curl_safefree(conn->allocptr.uagent);
6834     conn->allocptr.uagent =
6835       aprintf("User-Agent: %s\r\n", data->set.str[STRING_USERAGENT]);
6836     if(!conn->allocptr.uagent)
6837       return CURLE_OUT_OF_MEMORY;
6838   }
6839
6840   data->req.headerbytecount = 0;
6841
6842 #ifdef CURL_DO_LINEEND_CONV
6843   data->state.crlf_conversions = 0; /* reset CRLF conversion counter */
6844 #endif /* CURL_DO_LINEEND_CONV */
6845
6846   /* set start time here for timeout purposes in the connect procedure, it
6847      is later set again for the progress meter purpose */
6848   conn->now = Curl_tvnow();
6849
6850   if(CURL_SOCKET_BAD == conn->sock[FIRSTSOCKET]) {
6851     conn->bits.tcpconnect[FIRSTSOCKET] = FALSE;
6852     result = Curl_connecthost(conn, conn->dns_entry);
6853     if(result)
6854       return result;
6855   }
6856   else {
6857     Curl_pgrsTime(data, TIMER_CONNECT);    /* we're connected already */
6858     Curl_pgrsTime(data, TIMER_APPCONNECT); /* we're connected already */
6859     conn->bits.tcpconnect[FIRSTSOCKET] = TRUE;
6860     *protocol_done = TRUE;
6861     Curl_updateconninfo(conn, conn->sock[FIRSTSOCKET]);
6862     Curl_verboseconnect(conn);
6863   }
6864
6865   conn->now = Curl_tvnow(); /* time this *after* the connect is done, we
6866                                set this here perhaps a second time */
6867
6868 #ifdef __EMX__
6869   /*
6870    * This check is quite a hack. We're calling _fsetmode to fix the problem
6871    * with fwrite converting newline characters (you get mangled text files,
6872    * and corrupted binary files when you download to stdout and redirect it to
6873    * a file).
6874    */
6875
6876   if((data->set.out)->_handle == NULL) {
6877     _fsetmode(stdout, "b");
6878   }
6879 #endif
6880
6881   return result;
6882 }
6883
6884 CURLcode Curl_connect(struct Curl_easy *data,
6885                       struct connectdata **in_connect,
6886                       bool *asyncp,
6887                       bool *protocol_done)
6888 {
6889   CURLcode result;
6890
6891   *asyncp = FALSE; /* assume synchronous resolves by default */
6892
6893   /* call the stuff that needs to be called */
6894   result = create_conn(data, in_connect, asyncp);
6895
6896   if(!result) {
6897     /* no error */
6898     if((*in_connect)->send_pipe->size || (*in_connect)->recv_pipe->size)
6899       /* pipelining */
6900       *protocol_done = TRUE;
6901     else if(!*asyncp) {
6902       /* DNS resolution is done: that's either because this is a reused
6903          connection, in which case DNS was unnecessary, or because DNS
6904          really did finish already (synch resolver/fast async resolve) */
6905       result = Curl_setup_conn(*in_connect, protocol_done);
6906     }
6907   }
6908
6909   if(result == CURLE_NO_CONNECTION_AVAILABLE) {
6910     *in_connect = NULL;
6911     return result;
6912   }
6913
6914   if(result && *in_connect) {
6915     /* We're not allowed to return failure with memory left allocated
6916        in the connectdata struct, free those here */
6917     Curl_disconnect(*in_connect, FALSE); /* close the connection */
6918     *in_connect = NULL;           /* return a NULL */
6919   }
6920
6921   return result;
6922 }
6923
6924 /*
6925  * Curl_init_do() inits the readwrite session. This is inited each time (in
6926  * the DO function before the protocol-specific DO functions are invoked) for
6927  * a transfer, sometimes multiple times on the same Curl_easy. Make sure
6928  * nothing in here depends on stuff that are setup dynamically for the
6929  * transfer.
6930  *
6931  * Allow this function to get called with 'conn' set to NULL.
6932  */
6933
6934 CURLcode Curl_init_do(struct Curl_easy *data, struct connectdata *conn)
6935 {
6936   struct SingleRequest *k = &data->req;
6937
6938   if(conn)
6939     conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to
6940                                  * use */
6941
6942   data->state.done = FALSE; /* *_done() is not called yet */
6943   data->state.expect100header = FALSE;
6944
6945   if(data->set.opt_no_body)
6946     /* in HTTP lingo, no body means using the HEAD request... */
6947     data->set.httpreq = HTTPREQ_HEAD;
6948   else if(HTTPREQ_HEAD == data->set.httpreq)
6949     /* ... but if unset there really is no perfect method that is the
6950        "opposite" of HEAD but in reality most people probably think GET
6951        then. The important thing is that we can't let it remain HEAD if the
6952        opt_no_body is set FALSE since then we'll behave wrong when getting
6953        HTTP. */
6954     data->set.httpreq = HTTPREQ_GET;
6955
6956   k->start = Curl_tvnow(); /* start time */
6957   k->now = k->start;   /* current time is now */
6958   k->header = TRUE; /* assume header */
6959
6960   k->bytecount = 0;
6961
6962   k->buf = data->state.buffer;
6963   k->uploadbuf = data->state.uploadbuffer;
6964   k->hbufp = data->state.headerbuff;
6965   k->ignorebody=FALSE;
6966
6967   Curl_speedinit(data);
6968
6969   Curl_pgrsSetUploadCounter(data, 0);
6970   Curl_pgrsSetDownloadCounter(data, 0);
6971
6972   return CURLE_OK;
6973 }
6974
6975 /*
6976 * get_protocol_family()
6977 *
6978 * This is used to return the protocol family for a given protocol.
6979 *
6980 * Parameters:
6981 *
6982 * protocol  [in]  - A single bit protocol identifier such as HTTP or HTTPS.
6983 *
6984 * Returns the family as a single bit protocol identifier.
6985 */
6986
6987 unsigned int get_protocol_family(unsigned int protocol)
6988 {
6989   unsigned int family;
6990
6991   switch(protocol) {
6992   case CURLPROTO_HTTP:
6993   case CURLPROTO_HTTPS:
6994     family = CURLPROTO_HTTP;
6995     break;
6996
6997   case CURLPROTO_FTP:
6998   case CURLPROTO_FTPS:
6999     family = CURLPROTO_FTP;
7000     break;
7001
7002   case CURLPROTO_SCP:
7003     family = CURLPROTO_SCP;
7004     break;
7005
7006   case CURLPROTO_SFTP:
7007     family = CURLPROTO_SFTP;
7008     break;
7009
7010   case CURLPROTO_TELNET:
7011     family = CURLPROTO_TELNET;
7012     break;
7013
7014   case CURLPROTO_LDAP:
7015   case CURLPROTO_LDAPS:
7016     family = CURLPROTO_LDAP;
7017     break;
7018
7019   case CURLPROTO_DICT:
7020     family = CURLPROTO_DICT;
7021     break;
7022
7023   case CURLPROTO_FILE:
7024     family = CURLPROTO_FILE;
7025     break;
7026
7027   case CURLPROTO_TFTP:
7028     family = CURLPROTO_TFTP;
7029     break;
7030
7031   case CURLPROTO_IMAP:
7032   case CURLPROTO_IMAPS:
7033     family = CURLPROTO_IMAP;
7034     break;
7035
7036   case CURLPROTO_POP3:
7037   case CURLPROTO_POP3S:
7038     family = CURLPROTO_POP3;
7039     break;
7040
7041   case CURLPROTO_SMTP:
7042   case CURLPROTO_SMTPS:
7043       family = CURLPROTO_SMTP;
7044       break;
7045
7046   case CURLPROTO_RTSP:
7047     family = CURLPROTO_RTSP;
7048     break;
7049
7050   case CURLPROTO_RTMP:
7051   case CURLPROTO_RTMPS:
7052     family = CURLPROTO_RTMP;
7053     break;
7054
7055   case CURLPROTO_RTMPT:
7056   case CURLPROTO_RTMPTS:
7057     family = CURLPROTO_RTMPT;
7058     break;
7059
7060   case CURLPROTO_RTMPE:
7061     family = CURLPROTO_RTMPE;
7062     break;
7063
7064   case CURLPROTO_RTMPTE:
7065     family = CURLPROTO_RTMPTE;
7066     break;
7067
7068   case CURLPROTO_GOPHER:
7069     family = CURLPROTO_GOPHER;
7070     break;
7071
7072   case CURLPROTO_SMB:
7073   case CURLPROTO_SMBS:
7074     family = CURLPROTO_SMB;
7075     break;
7076
7077   default:
7078       family = 0;
7079       break;
7080   }
7081
7082   return family;
7083 }