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