lib/url.c

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