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