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