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
3506   /* set the name we use to display the host name */
3507   host->dispname = host->name;
3508   if(!is_ASCII_name(host->name)) {
3509 #ifdef USE_LIBIDN
3510   /*************************************************************
3511    * Check name for non-ASCII and convert hostname to ACE form.
3512    *************************************************************/
3513   if(stringprep_check_version(LIBIDN_REQUIRED_VERSION)) {
3514     char *ace_hostname = NULL;
3515     int rc = idna_to_ascii_lz(host->name, &ace_hostname, 0);
3516     infof (data, "Input domain encoded as `%s'\n",
3517            stringprep_locale_charset ());
3518     if(rc != IDNA_SUCCESS)
3519       infof(data, "Failed to convert %s to ACE; %s\n",
3520             host->name, Curl_idn_strerror(conn,rc));
3521     else {
3522       /* tld_check_name() displays a warning if the host name contains
3523          "illegal" characters for this TLD */
3524       (void)tld_check_name(data, ace_hostname);
3525
3526       host->encalloc = ace_hostname;
3527       /* change the name pointer to point to the encoded hostname */
3528       host->name = host->encalloc;
3529     }
3530   }
3531 #elif defined(USE_WIN32_IDN)
3532   /*************************************************************
3533    * Check name for non-ASCII and convert hostname to ACE form.
3534    *************************************************************/
3535     char *ace_hostname = NULL;
3536     int rc = curl_win32_idn_to_ascii(host->name, &ace_hostname);
3537     if(rc == 0)
3538       infof(data, "Failed to convert %s to ACE;\n",
3539             host->name);
3540     else {
3541       host->encalloc = ace_hostname;
3542       /* change the name pointer to point to the encoded hostname */
3543       host->name = host->encalloc;
3544     }
3545 #else
3546     infof(data, "IDN support not present, can't parse Unicode domains\n");
3547 #endif
3548   }
3549 }
3550
3551 static void llist_dtor(void *user, void *element)
3552 {
3553   (void)user;
3554   (void)element;
3555   /* Do nothing */
3556 }
3557
3558 /*
3559  * Allocate and initialize a new connectdata object.
3560  */
3561 static struct connectdata *allocate_conn(struct SessionHandle *data)
3562 {
3563   struct connectdata *conn = calloc(1, sizeof(struct connectdata));
3564   if(!conn)
3565     return NULL;
3566
3567   conn->handler = &Curl_handler_dummy;  /* Be sure we have a handler defined
3568                                            already from start to avoid NULL
3569                                            situations and checks */
3570
3571   /* and we setup a few fields in case we end up actually using this struct */
3572
3573   conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD;     /* no file descriptor */
3574   conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
3575   conn->tempsock[0] = CURL_SOCKET_BAD; /* no file descriptor */
3576   conn->tempsock[1] = CURL_SOCKET_BAD; /* no file descriptor */
3577   conn->connection_id = -1;    /* no ID */
3578   conn->port = -1; /* unknown at this point */
3579   conn->remote_port = -1; /* unknown */
3580
3581   /* Default protocol-independent behavior doesn't support persistent
3582      connections, so we set this to force-close. Protocols that support
3583      this need to set this to FALSE in their "curl_do" functions. */
3584   conn->bits.close = TRUE;
3585
3586   /* Store creation time to help future close decision making */
3587   conn->created = Curl_tvnow();
3588
3589   conn->data = data; /* Setup the association between this connection
3590                         and the SessionHandle */
3591
3592   conn->proxytype = data->set.proxytype; /* type */
3593
3594 #ifdef CURL_DISABLE_PROXY
3595
3596   conn->bits.proxy = FALSE;
3597   conn->bits.httpproxy = FALSE;
3598   conn->bits.proxy_user_passwd = FALSE;
3599   conn->bits.tunnel_proxy = FALSE;
3600
3601 #else /* CURL_DISABLE_PROXY */
3602
3603   /* note that these two proxy bits are now just on what looks to be
3604      requested, they may be altered down the road */
3605   conn->bits.proxy = (data->set.str[STRING_PROXY] &&
3606                       *data->set.str[STRING_PROXY])?TRUE:FALSE;
3607   conn->bits.httpproxy = (conn->bits.proxy &&
3608                           (conn->proxytype == CURLPROXY_HTTP ||
3609                            conn->proxytype == CURLPROXY_HTTP_1_0))?TRUE:FALSE;
3610   conn->bits.proxy_user_passwd =
3611     (NULL != data->set.str[STRING_PROXYUSERNAME])?TRUE:FALSE;
3612   conn->bits.tunnel_proxy = data->set.tunnel_thru_httpproxy;
3613
3614 #endif /* CURL_DISABLE_PROXY */
3615
3616   conn->bits.user_passwd = (NULL != data->set.str[STRING_USERNAME])?TRUE:FALSE;
3617   conn->bits.ftp_use_epsv = data->set.ftp_use_epsv;
3618   conn->bits.ftp_use_eprt = data->set.ftp_use_eprt;
3619
3620   conn->verifypeer = data->set.ssl.verifypeer;
3621   conn->verifyhost = data->set.ssl.verifyhost;
3622
3623   conn->ip_version = data->set.ipver;
3624
3625 #if defined(USE_NTLM) && defined(NTLM_WB_ENABLED)
3626   conn->ntlm_auth_hlpr_socket = CURL_SOCKET_BAD;
3627   conn->ntlm_auth_hlpr_pid = 0;
3628   conn->challenge_header = NULL;
3629   conn->response_header = NULL;
3630 #endif
3631
3632   if(Curl_multi_pipeline_enabled(data->multi) &&
3633       !conn->master_buffer) {
3634     /* Allocate master_buffer to be used for pipelining */
3635     conn->master_buffer = calloc(BUFSIZE, sizeof (char));
3636     if(!conn->master_buffer)
3637       goto error;
3638   }
3639
3640   /* Initialize the pipeline lists */
3641   conn->send_pipe = Curl_llist_alloc((curl_llist_dtor) llist_dtor);
3642   conn->recv_pipe = Curl_llist_alloc((curl_llist_dtor) llist_dtor);
3643   if(!conn->send_pipe || !conn->recv_pipe)
3644     goto error;
3645
3646 #ifdef HAVE_GSSAPI
3647   conn->data_prot = PROT_CLEAR;
3648 #endif
3649
3650   /* Store the local bind parameters that will be used for this connection */
3651   if(data->set.str[STRING_DEVICE]) {
3652     conn->localdev = strdup(data->set.str[STRING_DEVICE]);
3653     if(!conn->localdev)
3654       goto error;
3655   }
3656   conn->localportrange = data->set.localportrange;
3657   conn->localport = data->set.localport;
3658
3659   /* the close socket stuff needs to be copied to the connection struct as
3660      it may live on without (this specific) SessionHandle */
3661   conn->fclosesocket = data->set.fclosesocket;
3662   conn->closesocket_client = data->set.closesocket_client;
3663
3664   return conn;
3665   error:
3666
3667   Curl_llist_destroy(conn->send_pipe, NULL);
3668   Curl_llist_destroy(conn->recv_pipe, NULL);
3669
3670   conn->send_pipe = NULL;
3671   conn->recv_pipe = NULL;
3672
3673   Curl_safefree(conn->master_buffer);
3674   Curl_safefree(conn->localdev);
3675   Curl_safefree(conn);
3676   return NULL;
3677 }
3678
3679 static CURLcode findprotocol(struct SessionHandle *data,
3680                              struct connectdata *conn,
3681                              const char *protostr)
3682 {
3683   const struct Curl_handler * const *pp;
3684   const struct Curl_handler *p;
3685
3686   /* Scan protocol handler table and match against 'protostr' to set a few
3687      variables based on the URL. Now that the handler may be changed later
3688      when the protocol specific setup function is called. */
3689   for(pp = protocols; (p = *pp) != NULL; pp++) {
3690     if(Curl_raw_equal(p->scheme, protostr)) {
3691       /* Protocol found in table. Check if allowed */
3692       if(!(data->set.allowed_protocols & p->protocol))
3693         /* nope, get out */
3694         break;
3695
3696       /* it is allowed for "normal" request, now do an extra check if this is
3697          the result of a redirect */
3698       if(data->state.this_is_a_follow &&
3699          !(data->set.redir_protocols & p->protocol))
3700         /* nope, get out */
3701         break;
3702
3703       /* Perform setup complement if some. */
3704       conn->handler = conn->given = p;
3705
3706       /* 'port' and 'remote_port' are set in setup_connection_internals() */
3707       return CURLE_OK;
3708     }
3709   }
3710
3711
3712   /* The protocol was not found in the table, but we don't have to assign it
3713      to anything since it is already assigned to a dummy-struct in the
3714      create_conn() function when the connectdata struct is allocated. */
3715   failf(data, "Protocol %s not supported or disabled in " LIBCURL_NAME,
3716         protostr);
3717
3718   return CURLE_UNSUPPORTED_PROTOCOL;
3719 }
3720
3721 /*
3722  * Parse URL and fill in the relevant members of the connection struct.
3723  */
3724 static CURLcode parseurlandfillconn(struct SessionHandle *data,
3725                                     struct connectdata *conn,
3726                                     bool *prot_missing,
3727                                     char **userp, char **passwdp,
3728                                     char **optionsp)
3729 {
3730   char *at;
3731   char *fragment;
3732   char *path = data->state.path;
3733   char *query;
3734   int rc;
3735   char protobuf[16] = "";
3736   const char *protop = "";
3737   CURLcode result;
3738   bool rebuild_url = FALSE;
3739
3740   *prot_missing = FALSE;
3741
3742   /*************************************************************
3743    * Parse the URL.
3744    *
3745    * We need to parse the url even when using the proxy, because we will need
3746    * the hostname and port in case we are trying to SSL connect through the
3747    * proxy -- and we don't know if we will need to use SSL until we parse the
3748    * url ...
3749    ************************************************************/
3750   if((2 == sscanf(data->change.url, "%15[^:]:%[^\n]",
3751                   protobuf, path)) &&
3752      Curl_raw_equal(protobuf, "file")) {
3753     if(path[0] == '/' && path[1] == '/') {
3754       /* Allow omitted hostname (e.g. file:/<path>).  This is not strictly
3755        * speaking a valid file: URL by RFC 1738, but treating file:/<path> as
3756        * file://localhost/<path> is similar to how other schemes treat missing
3757        * hostnames.  See RFC 1808. */
3758
3759       /* This cannot be done with strcpy() in a portable manner, since the
3760          memory areas overlap! */
3761       memmove(path, path + 2, strlen(path + 2)+1);
3762     }
3763     /*
3764      * we deal with file://<host>/<path> differently since it supports no
3765      * hostname other than "localhost" and "127.0.0.1", which is unique among
3766      * the URL protocols specified in RFC 1738
3767      */
3768     if(path[0] != '/') {
3769       /* the URL included a host name, we ignore host names in file:// URLs
3770          as the standards don't define what to do with them */
3771       char *ptr=strchr(path, '/');
3772       if(ptr) {
3773         /* there was a slash present
3774
3775            RFC1738 (section 3.1, page 5) says:
3776
3777            The rest of the locator consists of data specific to the scheme,
3778            and is known as the "url-path". It supplies the details of how the
3779            specified resource can be accessed. Note that the "/" between the
3780            host (or port) and the url-path is NOT part of the url-path.
3781
3782            As most agents use file://localhost/foo to get '/foo' although the
3783            slash preceding foo is a separator and not a slash for the path,
3784            a URL as file://localhost//foo must be valid as well, to refer to
3785            the same file with an absolute path.
3786         */
3787
3788         if(ptr[1] && ('/' == ptr[1]))
3789           /* if there was two slashes, we skip the first one as that is then
3790              used truly as a separator */
3791           ptr++;
3792
3793         /* This cannot be made with strcpy, as the memory chunks overlap! */
3794         memmove(path, ptr, strlen(ptr)+1);
3795       }
3796     }
3797
3798     protop = "file"; /* protocol string */
3799   }
3800   else {
3801     /* clear path */
3802     path[0]=0;
3803
3804     if(2 > sscanf(data->change.url,
3805                    "%15[^\n:]://%[^\n/?]%[^\n]",
3806                    protobuf,
3807                    conn->host.name, path)) {
3808
3809       /*
3810        * The URL was badly formatted, let's try the browser-style _without_
3811        * protocol specified like 'http://'.
3812        */
3813       rc = sscanf(data->change.url, "%[^\n/?]%[^\n]", conn->host.name, path);
3814       if(1 > rc) {
3815         /*
3816          * We couldn't even get this format.
3817          * djgpp 2.04 has a sscanf() bug where 'conn->host.name' is
3818          * assigned, but the return value is EOF!
3819          */
3820 #if defined(__DJGPP__) && (DJGPP_MINOR == 4)
3821         if(!(rc == -1 && *conn->host.name))
3822 #endif
3823         {
3824           failf(data, "<url> malformed");
3825           return CURLE_URL_MALFORMAT;
3826         }
3827       }
3828
3829       /*
3830        * Since there was no protocol part specified, we guess what protocol it
3831        * is based on the first letters of the server name.
3832        */
3833
3834       /* Note: if you add a new protocol, please update the list in
3835        * lib/version.c too! */
3836
3837       if(checkprefix("FTP.", conn->host.name))
3838         protop = "ftp";
3839       else if(checkprefix("DICT.", conn->host.name))
3840         protop = "DICT";
3841       else if(checkprefix("LDAP.", conn->host.name))
3842         protop = "LDAP";
3843       else if(checkprefix("IMAP.", conn->host.name))
3844         protop = "IMAP";
3845       else if(checkprefix("SMTP.", conn->host.name))
3846         protop = "smtp";
3847       else if(checkprefix("POP3.", conn->host.name))
3848         protop = "pop3";
3849       else {
3850         protop = "http";
3851       }
3852
3853       *prot_missing = TRUE; /* not given in URL */
3854     }
3855     else
3856       protop = protobuf;
3857   }
3858
3859   /* We search for '?' in the host name (but only on the right side of a
3860    * @-letter to allow ?-letters in username and password) to handle things
3861    * like http://example.com?param= (notice the missing '/').
3862    */
3863   at = strchr(conn->host.name, '@');
3864   if(at)
3865     query = strchr(at+1, '?');
3866   else
3867     query = strchr(conn->host.name, '?');
3868
3869   if(query) {
3870     /* We must insert a slash before the '?'-letter in the URL. If the URL had
3871        a slash after the '?', that is where the path currently begins and the
3872        '?string' is still part of the host name.
3873
3874        We must move the trailing part from the host name and put it first in
3875        the path. And have it all prefixed with a slash.
3876     */
3877
3878     size_t hostlen = strlen(query);
3879     size_t pathlen = strlen(path);
3880
3881     /* move the existing path plus the zero byte forward, to make room for
3882        the host-name part */
3883     memmove(path+hostlen+1, path, pathlen+1);
3884
3885      /* now copy the trailing host part in front of the existing path */
3886     memcpy(path+1, query, hostlen);
3887
3888     path[0]='/'; /* prepend the missing slash */
3889     rebuild_url = TRUE;
3890
3891     *query=0; /* now cut off the hostname at the ? */
3892   }
3893   else if(!path[0]) {
3894     /* if there's no path set, use a single slash */
3895     strcpy(path, "/");
3896     rebuild_url = TRUE;
3897   }
3898
3899   /* If the URL is malformatted (missing a '/' after hostname before path) we
3900    * insert a slash here. The only letter except '/' we accept to start a path
3901    * is '?'.
3902    */
3903   if(path[0] == '?') {
3904     /* We need this function to deal with overlapping memory areas. We know
3905        that the memory area 'path' points to is 'urllen' bytes big and that
3906        is bigger than the path. Use +1 to move the zero byte too. */
3907     memmove(&path[1], path, strlen(path)+1);
3908     path[0] = '/';
3909     rebuild_url = TRUE;
3910   }
3911   else {
3912     /* sanitise paths and remove ../ and ./ sequences according to RFC3986 */
3913     char *newp = Curl_dedotdotify(path);
3914     if(!newp)
3915       return CURLE_OUT_OF_MEMORY;
3916
3917     if(strcmp(newp, path)) {
3918       rebuild_url = TRUE;
3919       free(data->state.pathbuffer);
3920       data->state.pathbuffer = newp;
3921       data->state.path = newp;
3922       path = newp;
3923     }
3924     else
3925       free(newp);
3926   }
3927
3928   /*
3929    * "rebuild_url" means that one or more URL components have been modified so
3930    * we need to generate an updated full version.  We need the corrected URL
3931    * when communicating over HTTP proxy and we don't know at this point if
3932    * we're using a proxy or not.
3933    */
3934   if(rebuild_url) {
3935     char *reurl;
3936
3937     size_t plen = strlen(path); /* new path, should be 1 byte longer than
3938                                    the original */
3939     size_t urllen = strlen(data->change.url); /* original URL length */
3940
3941     size_t prefixlen = strlen(conn->host.name);
3942
3943     if(!*prot_missing)
3944       prefixlen += strlen(protop) + strlen("://");
3945
3946     reurl = malloc(urllen + 2); /* 2 for zerobyte + slash */
3947     if(!reurl)
3948       return CURLE_OUT_OF_MEMORY;
3949
3950     /* copy the prefix */
3951     memcpy(reurl, data->change.url, prefixlen);
3952
3953     /* append the trailing piece + zerobyte */
3954     memcpy(&reurl[prefixlen], path, plen + 1);
3955
3956     /* possible free the old one */
3957     if(data->change.url_alloc) {
3958       Curl_safefree(data->change.url);
3959       data->change.url_alloc = FALSE;
3960     }
3961
3962     infof(data, "Rebuilt URL to: %s\n", reurl);
3963
3964     data->change.url = reurl;
3965     data->change.url_alloc = TRUE; /* free this later */
3966   }
3967
3968   /*
3969    * Parse the login details from the URL and strip them out of
3970    * the host name
3971    */
3972   result = parse_url_login(data, conn, userp, passwdp, optionsp);
3973   if(result != CURLE_OK)
3974     return result;
3975
3976   if(conn->host.name[0] == '[') {
3977     /* This looks like an IPv6 address literal.  See if there is an address
3978        scope if there is no location header */
3979     char *percent = strchr(conn->host.name, '%');
3980     if(percent) {
3981       unsigned int identifier_offset = 3;
3982       char *endp;
3983       unsigned long scope;
3984       if(strncmp("%25", percent, 3) != 0) {
3985         infof(data,
3986               "Please URL encode %% as %%25, see RFC 6874.\n");
3987         identifier_offset = 1;
3988       }
3989       scope = strtoul(percent + identifier_offset, &endp, 10);
3990       if(*endp == ']') {
3991         /* The address scope was well formed.  Knock it out of the
3992            hostname. */
3993         memmove(percent, endp, strlen(endp)+1);
3994         conn->scope = (unsigned int)scope;
3995       }
3996       else {
3997         /* Zone identifier is not numeric */
3998 #if defined(HAVE_NET_IF_H) && defined(IFNAMSIZ)
3999         char ifname[IFNAMSIZ + 2];
4000         char *square_bracket;
4001         unsigned int scopeidx = 0;
4002         strncpy(ifname, percent + identifier_offset, IFNAMSIZ + 2);
4003         /* Ensure nullbyte termination */
4004         ifname[IFNAMSIZ + 1] = '\0';
4005         square_bracket = strchr(ifname, ']');
4006         if(square_bracket) {
4007           /* Remove ']' */
4008           *square_bracket = '\0';
4009           scopeidx = if_nametoindex(ifname);
4010           if(scopeidx == 0) {
4011             infof(data, "Invalid network interface: %s; %s\n", ifname,
4012                   strerror(errno));
4013           }
4014         }
4015         if(scopeidx > 0) {
4016           /* Remove zone identifier from hostname */
4017           memmove(percent,
4018                   percent + identifier_offset + strlen(ifname),
4019                   identifier_offset + strlen(ifname));
4020           conn->scope = scopeidx;
4021         }
4022         else
4023 #endif /* HAVE_NET_IF_H && IFNAMSIZ */
4024           infof(data, "Invalid IPv6 address format\n");
4025       }
4026     }
4027   }
4028
4029   if(data->set.scope)
4030     /* Override any scope that was set above.  */
4031     conn->scope = data->set.scope;
4032
4033   /* Remove the fragment part of the path. Per RFC 2396, this is always the
4034      last part of the URI. We are looking for the first '#' so that we deal
4035      gracefully with non conformant URI such as http://example.com#foo#bar. */
4036   fragment = strchr(path, '#');
4037   if(fragment) {
4038     *fragment = 0;
4039
4040     /* we know the path part ended with a fragment, so we know the full URL
4041        string does too and we need to cut it off from there so it isn't used
4042        over proxy */
4043     fragment = strchr(data->change.url, '#');
4044     if(fragment)
4045       *fragment = 0;
4046   }
4047
4048   /*
4049    * So if the URL was A://B/C#D,
4050    *   protop is A
4051    *   conn->host.name is B
4052    *   data->state.path is /C
4053    */
4054
4055   return findprotocol(data, conn, protop);
4056 }
4057
4058 /*
4059  * If we're doing a resumed transfer, we need to setup our stuff
4060  * properly.
4061  */
4062 static CURLcode setup_range(struct SessionHandle *data)
4063 {
4064   struct UrlState *s = &data->state;
4065   s->resume_from = data->set.set_resume_from;
4066   if(s->resume_from || data->set.str[STRING_SET_RANGE]) {
4067     if(s->rangestringalloc)
4068       free(s->range);
4069
4070     if(s->resume_from)
4071       s->range = aprintf("%" CURL_FORMAT_CURL_OFF_TU "-", s->resume_from);
4072     else
4073       s->range = strdup(data->set.str[STRING_SET_RANGE]);
4074
4075     s->rangestringalloc = (s->range)?TRUE:FALSE;
4076
4077     if(!s->range)
4078       return CURLE_OUT_OF_MEMORY;
4079
4080     /* tell ourselves to fetch this range */
4081     s->use_range = TRUE;        /* enable range download */
4082   }
4083   else
4084     s->use_range = FALSE; /* disable range download */
4085
4086   return CURLE_OK;
4087 }
4088
4089
4090 /*
4091  * setup_connection_internals() -
4092  *
4093  * Setup connection internals specific to the requested protocol in the
4094  * SessionHandle. This is inited and setup before the connection is made but
4095  * is about the particular protocol that is to be used.
4096  *
4097  * This MUST get called after proxy magic has been figured out.
4098  */
4099 static CURLcode setup_connection_internals(struct connectdata *conn)
4100 {
4101   const struct Curl_handler * p;
4102   CURLcode result;
4103   struct SessionHandle *data = conn->data;
4104
4105   /* in some case in the multi state-machine, we go back to the CONNECT state
4106      and then a second (or third or...) call to this function will be made
4107      without doing a DISCONNECT or DONE in between (since the connection is
4108      yet in place) and therefore this function needs to first make sure
4109      there's no lingering previous data allocated. */
4110   Curl_free_request_state(data);
4111
4112   memset(&data->req, 0, sizeof(struct SingleRequest));
4113   data->req.maxdownload = -1;
4114
4115   conn->socktype = SOCK_STREAM; /* most of them are TCP streams */
4116
4117   /* Perform setup complement if some. */
4118   p = conn->handler;
4119
4120   if(p->setup_connection) {
4121     result = (*p->setup_connection)(conn);
4122
4123     if(result != CURLE_OK)
4124       return result;
4125
4126     p = conn->handler;              /* May have changed. */
4127   }
4128
4129   if(conn->port < 0)
4130     /* we check for -1 here since if proxy was detected already, this
4131        was very likely already set to the proxy port */
4132     conn->port = p->defport;
4133
4134   /* only if remote_port was not already parsed off the URL we use the
4135      default port number */
4136   if(conn->remote_port < 0)
4137     conn->remote_port = (unsigned short)conn->given->defport;
4138
4139   return CURLE_OK;
4140 }
4141
4142 /*
4143  * Curl_free_request_state() should free temp data that was allocated in the
4144  * SessionHandle for this single request.
4145  */
4146
4147 void Curl_free_request_state(struct SessionHandle *data)
4148 {
4149   Curl_safefree(data->req.protop);
4150 }
4151
4152
4153 #ifndef CURL_DISABLE_PROXY
4154 /****************************************************************
4155 * Checks if the host is in the noproxy list. returns true if it matches
4156 * and therefore the proxy should NOT be used.
4157 ****************************************************************/
4158 static bool check_noproxy(const char* name, const char* no_proxy)
4159 {
4160   /* no_proxy=domain1.dom,host.domain2.dom
4161    *   (a comma-separated list of hosts which should
4162    *   not be proxied, or an asterisk to override
4163    *   all proxy variables)
4164    */
4165   size_t tok_start;
4166   size_t tok_end;
4167   const char* separator = ", ";
4168   size_t no_proxy_len;
4169   size_t namelen;
4170   char *endptr;
4171
4172   if(no_proxy && no_proxy[0]) {
4173     if(Curl_raw_equal("*", no_proxy)) {
4174       return TRUE;
4175     }
4176
4177     /* NO_PROXY was specified and it wasn't just an asterisk */
4178
4179     no_proxy_len = strlen(no_proxy);
4180     endptr = strchr(name, ':');
4181     if(endptr)
4182       namelen = endptr - name;
4183     else
4184       namelen = strlen(name);
4185
4186     for(tok_start = 0; tok_start < no_proxy_len; tok_start = tok_end + 1) {
4187       while(tok_start < no_proxy_len &&
4188             strchr(separator, no_proxy[tok_start]) != NULL) {
4189         /* Look for the beginning of the token. */
4190         ++tok_start;
4191       }
4192
4193       if(tok_start == no_proxy_len)
4194         break; /* It was all trailing separator chars, no more tokens. */
4195
4196       for(tok_end = tok_start; tok_end < no_proxy_len &&
4197             strchr(separator, no_proxy[tok_end]) == NULL; ++tok_end)
4198         /* Look for the end of the token. */
4199         ;
4200
4201       /* To match previous behaviour, where it was necessary to specify
4202        * ".local.com" to prevent matching "notlocal.com", we will leave
4203        * the '.' off.
4204        */
4205       if(no_proxy[tok_start] == '.')
4206         ++tok_start;
4207
4208       if((tok_end - tok_start) <= namelen) {
4209         /* Match the last part of the name to the domain we are checking. */
4210         const char *checkn = name + namelen - (tok_end - tok_start);
4211         if(Curl_raw_nequal(no_proxy + tok_start, checkn,
4212                            tok_end - tok_start)) {
4213           if((tok_end - tok_start) == namelen || *(checkn - 1) == '.') {
4214             /* We either have an exact match, or the previous character is a .
4215              * so it is within the same domain, so no proxy for this host.
4216              */
4217             return TRUE;
4218           }
4219         }
4220       } /* if((tok_end - tok_start) <= namelen) */
4221     } /* for(tok_start = 0; tok_start < no_proxy_len;
4222          tok_start = tok_end + 1) */
4223   } /* NO_PROXY was specified and it wasn't just an asterisk */
4224
4225   return FALSE;
4226 }
4227
4228 /****************************************************************
4229 * Detect what (if any) proxy to use. Remember that this selects a host
4230 * name and is not limited to HTTP proxies only.
4231 * The returned pointer must be freed by the caller (unless NULL)
4232 ****************************************************************/
4233 static char *detect_proxy(struct connectdata *conn)
4234 {
4235   char *proxy = NULL;
4236
4237 #ifndef CURL_DISABLE_HTTP
4238   /* If proxy was not specified, we check for default proxy environment
4239    * variables, to enable i.e Lynx compliance:
4240    *
4241    * http_proxy=http://some.server.dom:port/
4242    * https_proxy=http://some.server.dom:port/
4243    * ftp_proxy=http://some.server.dom:port/
4244    * no_proxy=domain1.dom,host.domain2.dom
4245    *   (a comma-separated list of hosts which should
4246    *   not be proxied, or an asterisk to override
4247    *   all proxy variables)
4248    * all_proxy=http://some.server.dom:port/
4249    *   (seems to exist for the CERN www lib. Probably
4250    *   the first to check for.)
4251    *
4252    * For compatibility, the all-uppercase versions of these variables are
4253    * checked if the lowercase versions don't exist.
4254    */
4255   char *no_proxy=NULL;
4256   char proxy_env[128];
4257
4258   no_proxy=curl_getenv("no_proxy");
4259   if(!no_proxy)
4260     no_proxy=curl_getenv("NO_PROXY");
4261
4262   if(!check_noproxy(conn->host.name, no_proxy)) {
4263     /* It was not listed as without proxy */
4264     const char *protop = conn->handler->scheme;
4265     char *envp = proxy_env;
4266     char *prox;
4267
4268     /* Now, build <protocol>_proxy and check for such a one to use */
4269     while(*protop)
4270       *envp++ = (char)tolower((int)*protop++);
4271
4272     /* append _proxy */
4273     strcpy(envp, "_proxy");
4274
4275     /* read the protocol proxy: */
4276     prox=curl_getenv(proxy_env);
4277
4278     /*
4279      * We don't try the uppercase version of HTTP_PROXY because of
4280      * security reasons:
4281      *
4282      * When curl is used in a webserver application
4283      * environment (cgi or php), this environment variable can
4284      * be controlled by the web server user by setting the
4285      * http header 'Proxy:' to some value.
4286      *
4287      * This can cause 'internal' http/ftp requests to be
4288      * arbitrarily redirected by any external attacker.
4289      */
4290     if(!prox && !Curl_raw_equal("http_proxy", proxy_env)) {
4291       /* There was no lowercase variable, try the uppercase version: */
4292       Curl_strntoupper(proxy_env, proxy_env, sizeof(proxy_env));
4293       prox=curl_getenv(proxy_env);
4294     }
4295
4296     if(prox && *prox) { /* don't count "" strings */
4297       proxy = prox; /* use this */
4298     }
4299     else {
4300       proxy = curl_getenv("all_proxy"); /* default proxy to use */
4301       if(!proxy)
4302         proxy=curl_getenv("ALL_PROXY");
4303     }
4304   } /* if(!check_noproxy(conn->host.name, no_proxy)) - it wasn't specified
4305        non-proxy */
4306   if(no_proxy)
4307     free(no_proxy);
4308
4309 #else /* !CURL_DISABLE_HTTP */
4310
4311   (void)conn;
4312 #endif /* CURL_DISABLE_HTTP */
4313
4314   return proxy;
4315 }
4316
4317 /*
4318  * If this is supposed to use a proxy, we need to figure out the proxy
4319  * host name, so that we can re-use an existing connection
4320  * that may exist registered to the same proxy host.
4321  * proxy will be freed before this function returns.
4322  */
4323 static CURLcode parse_proxy(struct SessionHandle *data,
4324                             struct connectdata *conn, char *proxy)
4325 {
4326   char *prox_portno;
4327   char *endofprot;
4328
4329   /* We use 'proxyptr' to point to the proxy name from now on... */
4330   char *proxyptr;
4331   char *portptr;
4332   char *atsign;
4333
4334   /* We do the proxy host string parsing here. We want the host name and the
4335    * port name. Accept a protocol:// prefix
4336    */
4337
4338   /* Parse the protocol part if present */
4339   endofprot = strstr(proxy, "://");
4340   if(endofprot) {
4341     proxyptr = endofprot+3;
4342     if(checkprefix("socks5h", proxy))
4343       conn->proxytype = CURLPROXY_SOCKS5_HOSTNAME;
4344     else if(checkprefix("socks5", proxy))
4345       conn->proxytype = CURLPROXY_SOCKS5;
4346     else if(checkprefix("socks4a", proxy))
4347       conn->proxytype = CURLPROXY_SOCKS4A;
4348     else if(checkprefix("socks4", proxy) || checkprefix("socks", proxy))
4349       conn->proxytype = CURLPROXY_SOCKS4;
4350     /* Any other xxx:// : change to http proxy */
4351   }
4352   else
4353     proxyptr = proxy; /* No xxx:// head: It's a HTTP proxy */
4354
4355   /* Is there a username and password given in this proxy url? */
4356   atsign = strchr(proxyptr, '@');
4357   if(atsign) {
4358     CURLcode res = CURLE_OK;
4359     char *proxyuser = NULL;
4360     char *proxypasswd = NULL;
4361
4362     res = parse_login_details(proxyptr, atsign - proxyptr,
4363                               &proxyuser, &proxypasswd, NULL);
4364     if(!res) {
4365       /* found user and password, rip them out.  note that we are
4366          unescaping them, as there is otherwise no way to have a
4367          username or password with reserved characters like ':' in
4368          them. */
4369       Curl_safefree(conn->proxyuser);
4370       if(proxyuser && strlen(proxyuser) < MAX_CURL_USER_LENGTH)
4371         conn->proxyuser = curl_easy_unescape(data, proxyuser, 0, NULL);
4372       else
4373         conn->proxyuser = strdup("");
4374
4375       if(!conn->proxyuser)
4376         res = CURLE_OUT_OF_MEMORY;
4377       else {
4378         Curl_safefree(conn->proxypasswd);
4379         if(proxypasswd && strlen(proxypasswd) < MAX_CURL_PASSWORD_LENGTH)
4380           conn->proxypasswd = curl_easy_unescape(data, proxypasswd, 0, NULL);
4381         else
4382           conn->proxypasswd = strdup("");
4383
4384         if(!conn->proxypasswd)
4385           res = CURLE_OUT_OF_MEMORY;
4386       }
4387
4388       if(!res) {
4389         conn->bits.proxy_user_passwd = TRUE; /* enable it */
4390         atsign++; /* the right side of the @-letter */
4391
4392         if(atsign)
4393           proxyptr = atsign; /* now use this instead */
4394         else
4395           res = CURLE_OUT_OF_MEMORY;
4396       }
4397     }
4398
4399     Curl_safefree(proxyuser);
4400     Curl_safefree(proxypasswd);
4401
4402     if(res)
4403       return res;
4404   }
4405
4406   /* start scanning for port number at this point */
4407   portptr = proxyptr;
4408
4409   /* detect and extract RFC6874-style IPv6-addresses */
4410   if(*proxyptr == '[') {
4411     char *ptr = ++proxyptr; /* advance beyond the initial bracket */
4412     while(*ptr && (ISXDIGIT(*ptr) || (*ptr == ':') || (*ptr == '.')))
4413       ptr++;
4414     if(*ptr == '%') {
4415       /* There might be a zone identifier */
4416       if(strncmp("%25", ptr, 3))
4417         infof(data, "Please URL encode %% as %%25, see RFC 6874.\n");
4418       ptr++;
4419       /* Allow unresered characters as defined in RFC 3986 */
4420       while(*ptr && (ISALPHA(*ptr) || ISXDIGIT(*ptr) || (*ptr == '-') ||
4421                      (*ptr == '.') || (*ptr == '_') || (*ptr == '~')))
4422         ptr++;
4423     }
4424     if(*ptr == ']')
4425       /* yeps, it ended nicely with a bracket as well */
4426       *ptr++ = 0;
4427     else
4428       infof(data, "Invalid IPv6 address format\n");
4429     portptr = ptr;
4430     /* Note that if this didn't end with a bracket, we still advanced the
4431      * proxyptr first, but I can't see anything wrong with that as no host
4432      * name nor a numeric can legally start with a bracket.
4433      */
4434   }
4435
4436   /* Get port number off proxy.server.com:1080 */
4437   prox_portno = strchr(portptr, ':');
4438   if(prox_portno) {
4439     *prox_portno = 0x0; /* cut off number from host name */
4440     prox_portno ++;
4441     /* now set the local port number */
4442     conn->port = strtol(prox_portno, NULL, 10);
4443   }
4444   else {
4445     if(proxyptr[0]=='/')
4446       /* If the first character in the proxy string is a slash, fail
4447          immediately. The following code will otherwise clear the string which
4448          will lead to code running as if no proxy was set! */
4449       return CURLE_COULDNT_RESOLVE_PROXY;
4450
4451     /* without a port number after the host name, some people seem to use
4452        a slash so we strip everything from the first slash */
4453     atsign = strchr(proxyptr, '/');
4454     if(atsign)
4455       *atsign = 0x0; /* cut off path part from host name */
4456
4457     if(data->set.proxyport)
4458       /* None given in the proxy string, then get the default one if it is
4459          given */
4460       conn->port = data->set.proxyport;
4461   }
4462
4463   /* now, clone the cleaned proxy host name */
4464   conn->proxy.rawalloc = strdup(proxyptr);
4465   conn->proxy.name = conn->proxy.rawalloc;
4466
4467   if(!conn->proxy.rawalloc)
4468     return CURLE_OUT_OF_MEMORY;
4469
4470   return CURLE_OK;
4471 }
4472
4473 /*
4474  * Extract the user and password from the authentication string
4475  */
4476 static CURLcode parse_proxy_auth(struct SessionHandle *data,
4477                                  struct connectdata *conn)
4478 {
4479   char proxyuser[MAX_CURL_USER_LENGTH]="";
4480   char proxypasswd[MAX_CURL_PASSWORD_LENGTH]="";
4481
4482   if(data->set.str[STRING_PROXYUSERNAME] != NULL) {
4483     strncpy(proxyuser, data->set.str[STRING_PROXYUSERNAME],
4484             MAX_CURL_USER_LENGTH);
4485     proxyuser[MAX_CURL_USER_LENGTH-1] = '\0';   /*To be on safe side*/
4486   }
4487   if(data->set.str[STRING_PROXYPASSWORD] != NULL) {
4488     strncpy(proxypasswd, data->set.str[STRING_PROXYPASSWORD],
4489             MAX_CURL_PASSWORD_LENGTH);
4490     proxypasswd[MAX_CURL_PASSWORD_LENGTH-1] = '\0'; /*To be on safe side*/
4491   }
4492
4493   conn->proxyuser = curl_easy_unescape(data, proxyuser, 0, NULL);
4494   if(!conn->proxyuser)
4495     return CURLE_OUT_OF_MEMORY;
4496
4497   conn->proxypasswd = curl_easy_unescape(data, proxypasswd, 0, NULL);
4498   if(!conn->proxypasswd)
4499     return CURLE_OUT_OF_MEMORY;
4500
4501   return CURLE_OK;
4502 }
4503 #endif /* CURL_DISABLE_PROXY */
4504
4505 /*
4506  * parse_url_login()
4507  *
4508  * Parse the login details (user name, password and options) from the URL and
4509  * strip them out of the host name
4510  *
4511  * Inputs: data->set.use_netrc (CURLOPT_NETRC)
4512  *         conn->host.name
4513  *
4514  * Outputs: (almost :- all currently undefined)
4515  *          conn->bits.user_passwd  - non-zero if non-default passwords exist
4516  *          user                    - non-zero length if defined
4517  *          passwd                  - non-zero length if defined
4518  *          options                 - non-zero length if defined
4519  *          conn->host.name         - remove user name and password
4520  */
4521 static CURLcode parse_url_login(struct SessionHandle *data,
4522                                 struct connectdata *conn,
4523                                 char **user, char **passwd, char **options)
4524 {
4525   CURLcode result = CURLE_OK;
4526   char *userp = NULL;
4527   char *passwdp = NULL;
4528   char *optionsp = NULL;
4529
4530   /* At this point, we're hoping all the other special cases have
4531    * been taken care of, so conn->host.name is at most
4532    *    [user[:password][;options]]@]hostname
4533    *
4534    * We need somewhere to put the embedded details, so do that first.
4535    */
4536
4537   char *ptr = strchr(conn->host.name, '@');
4538   char *login = conn->host.name;
4539
4540   DEBUGASSERT(!**user);
4541   DEBUGASSERT(!**passwd);
4542   DEBUGASSERT(!**options);
4543
4544   if(!ptr)
4545     goto out;
4546
4547   /* We will now try to extract the
4548    * possible login information in a string like:
4549    * ftp://user:password@ftp.my.site:8021/README */
4550   conn->host.name = ++ptr;
4551
4552   /* So the hostname is sane.  Only bother interpreting the
4553    * results if we could care.  It could still be wasted
4554    * work because it might be overtaken by the programmatically
4555    * set user/passwd, but doing that first adds more cases here :-(
4556    */
4557
4558   if(data->set.use_netrc == CURL_NETRC_REQUIRED)
4559     goto out;
4560
4561   /* We could use the login information in the URL so extract it */
4562   result = parse_login_details(login, ptr - login - 1,
4563                                &userp, &passwdp, &optionsp);
4564   if(result != CURLE_OK)
4565     goto out;
4566
4567   if(userp) {
4568     char *newname;
4569
4570     /* We have a user in the URL */
4571     conn->bits.userpwd_in_url = TRUE;
4572     conn->bits.user_passwd = TRUE; /* enable user+password */
4573
4574     /* Decode the user */
4575     newname = curl_easy_unescape(data, userp, 0, NULL);
4576     if(!newname) {
4577       result = CURLE_OUT_OF_MEMORY;
4578       goto out;
4579     }
4580
4581     free(*user);
4582     *user = newname;
4583   }
4584
4585   if(passwdp) {
4586     /* We have a password in the URL so decode it */
4587     char *newpasswd = curl_easy_unescape(data, passwdp, 0, NULL);
4588     if(!newpasswd) {
4589       result = CURLE_OUT_OF_MEMORY;
4590       goto out;
4591     }
4592
4593     free(*passwd);
4594     *passwd = newpasswd;
4595   }
4596
4597   if(optionsp) {
4598     /* We have an options list in the URL so decode it */
4599     char *newoptions = curl_easy_unescape(data, optionsp, 0, NULL);
4600     if(!newoptions) {
4601       result = CURLE_OUT_OF_MEMORY;
4602       goto out;
4603     }
4604
4605     free(*options);
4606     *options = newoptions;
4607   }
4608
4609
4610   out:
4611
4612   Curl_safefree(userp);
4613   Curl_safefree(passwdp);
4614   Curl_safefree(optionsp);
4615
4616   return result;
4617 }
4618
4619 /*
4620  * parse_login_details()
4621  *
4622  * This is used to parse a login string for user name, password and options in
4623  * the following formats:
4624  *
4625  *   user
4626  *   user:password
4627  *   user:password;options
4628  *   user;options
4629  *   user;options:password
4630  *   :password
4631  *   :password;options
4632  *   ;options
4633  *   ;options:password
4634  *
4635  * Parameters:
4636  *
4637  * login    [in]     - The login string.
4638  * len      [in]     - The length of the login string.
4639  * userp    [in/out] - The address where a pointer to newly allocated memory
4640  *                     holding the user will be stored upon completion.
4641  * passdwp  [in/out] - The address where a pointer to newly allocated memory
4642  *                     holding the password will be stored upon completion.
4643  * optionsp [in/out] - The address where a pointer to newly allocated memory
4644  *                     holding the options will be stored upon completion.
4645  *
4646  * Returns CURLE_OK on success.
4647  */
4648 static CURLcode parse_login_details(const char *login, const size_t len,
4649                                     char **userp, char **passwdp,
4650                                     char **optionsp)
4651 {
4652   CURLcode result = CURLE_OK;
4653   char *ubuf = NULL;
4654   char *pbuf = NULL;
4655   char *obuf = NULL;
4656   const char *psep = NULL;
4657   const char *osep = NULL;
4658   size_t ulen;
4659   size_t plen;
4660   size_t olen;
4661
4662   /* Attempt to find the password separator */
4663   if(passwdp) {
4664     psep = strchr(login, ':');
4665
4666     /* Within the constraint of the login string */
4667     if(psep >= login + len)
4668       psep = NULL;
4669   }
4670
4671   /* Attempt to find the options separator */
4672   if(optionsp) {
4673     osep = strchr(login, ';');
4674
4675     /* Within the constraint of the login string */
4676     if(osep >= login + len)
4677       osep = NULL;
4678   }
4679
4680   /* Calculate the portion lengths */
4681   ulen = (psep ?
4682           (size_t)(osep && psep > osep ? osep - login : psep - login) :
4683           (osep ? (size_t)(osep - login) : len));
4684   plen = (psep ?
4685           (osep && osep > psep ? (size_t)(osep - psep) :
4686                                  (size_t)(login + len - psep)) - 1 : 0);
4687   olen = (osep ?
4688           (psep && psep > osep ? (size_t)(psep - osep) :
4689                                  (size_t)(login + len - osep)) - 1 : 0);
4690
4691   /* Allocate the user portion buffer */
4692   if(userp && ulen) {
4693     ubuf = malloc(ulen + 1);
4694     if(!ubuf)
4695       result = CURLE_OUT_OF_MEMORY;
4696   }
4697
4698   /* Allocate the password portion buffer */
4699   if(!result && passwdp && plen) {
4700     pbuf = malloc(plen + 1);
4701     if(!pbuf) {
4702       Curl_safefree(ubuf);
4703       result = CURLE_OUT_OF_MEMORY;
4704     }
4705   }
4706
4707   /* Allocate the options portion buffer */
4708   if(!result && optionsp && olen) {
4709     obuf = malloc(olen + 1);
4710     if(!obuf) {
4711       Curl_safefree(pbuf);
4712       Curl_safefree(ubuf);
4713       result = CURLE_OUT_OF_MEMORY;
4714     }
4715   }
4716
4717   if(!result) {
4718     /* Store the user portion if necessary */
4719     if(ubuf) {
4720       memcpy(ubuf, login, ulen);
4721       ubuf[ulen] = '\0';
4722       Curl_safefree(*userp);
4723       *userp = ubuf;
4724     }
4725
4726     /* Store the password portion if necessary */
4727     if(pbuf) {
4728       memcpy(pbuf, psep + 1, plen);
4729       pbuf[plen] = '\0';
4730       Curl_safefree(*passwdp);
4731       *passwdp = pbuf;
4732     }
4733
4734     /* Store the options portion if necessary */
4735     if(obuf) {
4736       memcpy(obuf, osep + 1, olen);
4737       obuf[olen] = '\0';
4738       Curl_safefree(*optionsp);
4739       *optionsp = obuf;
4740     }
4741   }
4742
4743   return result;
4744 }
4745
4746 /*************************************************************
4747  * Figure out the remote port number and fix it in the URL
4748  *
4749  * No matter if we use a proxy or not, we have to figure out the remote
4750  * port number of various reasons.
4751  *
4752  * To be able to detect port number flawlessly, we must not confuse them
4753  * IPv6-specified addresses in the [0::1] style. (RFC2732)
4754  *
4755  * The conn->host.name is currently [user:passwd@]host[:port] where host
4756  * could be a hostname, IPv4 address or IPv6 address.
4757  *
4758  * The port number embedded in the URL is replaced, if necessary.
4759  *************************************************************/
4760 static CURLcode parse_remote_port(struct SessionHandle *data,
4761                                   struct connectdata *conn)
4762 {
4763   char *portptr;
4764   char endbracket;
4765
4766   /* Note that at this point, the IPv6 address cannot contain any scope
4767      suffix as that has already been removed in the parseurlandfillconn()
4768      function */
4769   if((1 == sscanf(conn->host.name, "[%*45[0123456789abcdefABCDEF:.]%c",
4770                   &endbracket)) &&
4771      (']' == endbracket)) {
4772     /* this is a RFC2732-style specified IP-address */
4773     conn->bits.ipv6_ip = TRUE;
4774
4775     conn->host.name++; /* skip over the starting bracket */
4776     portptr = strchr(conn->host.name, ']');
4777     if(portptr) {
4778       *portptr++ = '\0'; /* zero terminate, killing the bracket */
4779       if(':' != *portptr)
4780         portptr = NULL; /* no port number available */
4781     }
4782   }
4783   else {
4784 #ifdef ENABLE_IPV6
4785     struct in6_addr in6;
4786     if(Curl_inet_pton(AF_INET6, conn->host.name, &in6) > 0) {
4787       /* This is a numerical IPv6 address, meaning this is a wrongly formatted
4788          URL */
4789       failf(data, "IPv6 numerical address used in URL without brackets");
4790       return CURLE_URL_MALFORMAT;
4791     }
4792 #endif
4793
4794     portptr = strrchr(conn->host.name, ':');
4795   }
4796
4797   if(data->set.use_port && data->state.allow_port) {
4798     /* if set, we use this and ignore the port possibly given in the URL */
4799     conn->remote_port = (unsigned short)data->set.use_port;
4800     if(portptr)
4801       *portptr = '\0'; /* cut off the name there anyway - if there was a port
4802                       number - since the port number is to be ignored! */
4803     if(conn->bits.httpproxy) {
4804       /* we need to create new URL with the new port number */
4805       char *url;
4806       char type[12]="";
4807
4808       if(conn->bits.type_set)
4809         snprintf(type, sizeof(type), ";type=%c",
4810                  data->set.prefer_ascii?'A':
4811                  (data->set.ftp_list_only?'D':'I'));
4812
4813       /*
4814        * This synthesized URL isn't always right--suffixes like ;type=A are
4815        * stripped off. It would be better to work directly from the original
4816        * URL and simply replace the port part of it.
4817        */
4818       url = aprintf("%s://%s%s%s:%hu%s%s%s", conn->given->scheme,
4819                     conn->bits.ipv6_ip?"[":"", conn->host.name,
4820                     conn->bits.ipv6_ip?"]":"", conn->remote_port,
4821                     data->state.slash_removed?"/":"", data->state.path,
4822                     type);
4823       if(!url)
4824         return CURLE_OUT_OF_MEMORY;
4825
4826       if(data->change.url_alloc) {
4827         Curl_safefree(data->change.url);
4828         data->change.url_alloc = FALSE;
4829       }
4830
4831       data->change.url = url;
4832       data->change.url_alloc = TRUE;
4833     }
4834   }
4835   else if(portptr) {
4836     /* no CURLOPT_PORT given, extract the one from the URL */
4837
4838     char *rest;
4839     long port;
4840
4841     port=strtol(portptr+1, &rest, 10);  /* Port number must be decimal */
4842
4843     if((port < 0) || (port > 0xffff)) {
4844       /* Single unix standard says port numbers are 16 bits long */
4845       failf(data, "Port number out of range");
4846       return CURLE_URL_MALFORMAT;
4847     }
4848
4849     else if(rest != &portptr[1]) {
4850       *portptr = '\0'; /* cut off the name there */
4851       conn->remote_port = curlx_ultous(port);
4852     }
4853     else
4854       /* Browser behavior adaptation. If there's a colon with no digits after,
4855          just cut off the name there which makes us ignore the colon and just
4856          use the default port. Firefox and Chrome both do that. */
4857       *portptr = '\0';
4858   }
4859   return CURLE_OK;
4860 }
4861
4862 /*
4863  * Override the login details from the URL with that in the CURLOPT_USERPWD
4864  * option or a .netrc file, if applicable.
4865  */
4866 static CURLcode override_login(struct SessionHandle *data,
4867                                struct connectdata *conn,
4868                                char **userp, char **passwdp, char **optionsp)
4869 {
4870   if(data->set.str[STRING_USERNAME]) {
4871     free(*userp);
4872     *userp = strdup(data->set.str[STRING_USERNAME]);
4873     if(!*userp)
4874       return CURLE_OUT_OF_MEMORY;
4875   }
4876
4877   if(data->set.str[STRING_PASSWORD]) {
4878     free(*passwdp);
4879     *passwdp = strdup(data->set.str[STRING_PASSWORD]);
4880     if(!*passwdp)
4881       return CURLE_OUT_OF_MEMORY;
4882   }
4883
4884   if(data->set.str[STRING_OPTIONS]) {
4885     free(*optionsp);
4886     *optionsp = strdup(data->set.str[STRING_OPTIONS]);
4887     if(!*optionsp)
4888       return CURLE_OUT_OF_MEMORY;
4889   }
4890
4891   conn->bits.netrc = FALSE;
4892   if(data->set.use_netrc != CURL_NETRC_IGNORED) {
4893     int ret = Curl_parsenetrc(conn->host.name,
4894                               userp, passwdp,
4895                               data->set.str[STRING_NETRC_FILE]);
4896     if(ret > 0) {
4897       infof(data, "Couldn't find host %s in the "
4898             DOT_CHAR "netrc file; using defaults\n",
4899             conn->host.name);
4900     }
4901     else if(ret < 0 ) {
4902       return CURLE_OUT_OF_MEMORY;
4903     }
4904     else {
4905       /* set bits.netrc TRUE to remember that we got the name from a .netrc
4906          file, so that it is safe to use even if we followed a Location: to a
4907          different host or similar. */
4908       conn->bits.netrc = TRUE;
4909
4910       conn->bits.user_passwd = TRUE; /* enable user+password */
4911     }
4912   }
4913
4914   return CURLE_OK;
4915 }
4916
4917 /*
4918  * Set the login details so they're available in the connection
4919  */
4920 static CURLcode set_login(struct connectdata *conn,
4921                           const char *user, const char *passwd,
4922                           const char *options)
4923 {
4924   CURLcode result = CURLE_OK;
4925
4926   /* If our protocol needs a password and we have none, use the defaults */
4927   if((conn->handler->flags & PROTOPT_NEEDSPWD) && !conn->bits.user_passwd) {
4928     /* Store the default user */
4929     conn->user = strdup(CURL_DEFAULT_USER);
4930
4931     /* Store the default password */
4932     if(conn->user)
4933       conn->passwd = strdup(CURL_DEFAULT_PASSWORD);
4934     else
4935       conn->passwd = NULL;
4936
4937     /* This is the default password, so DON'T set conn->bits.user_passwd */
4938   }
4939   else {
4940     /* Store the user, zero-length if not set */
4941     conn->user = strdup(user);
4942
4943     /* Store the password (only if user is present), zero-length if not set */
4944     if(conn->user)
4945       conn->passwd = strdup(passwd);
4946     else
4947       conn->passwd = NULL;
4948   }
4949
4950   if(!conn->user || !conn->passwd)
4951     result = CURLE_OUT_OF_MEMORY;
4952
4953   /* Store the options, null if not set */
4954   if(!result && options[0]) {
4955     conn->options = strdup(options);
4956
4957     if(!conn->options)
4958       result = CURLE_OUT_OF_MEMORY;
4959   }
4960
4961   return result;
4962 }
4963
4964 /*************************************************************
4965  * Resolve the address of the server or proxy
4966  *************************************************************/
4967 static CURLcode resolve_server(struct SessionHandle *data,
4968                                struct connectdata *conn,
4969                                bool *async)
4970 {
4971   CURLcode result=CURLE_OK;
4972   long timeout_ms = Curl_timeleft(data, NULL, TRUE);
4973
4974   /*************************************************************
4975    * Resolve the name of the server or proxy
4976    *************************************************************/
4977   if(conn->bits.reuse)
4978     /* We're reusing the connection - no need to resolve anything, and
4979        fix_hostname() was called already in create_conn() for the re-use
4980        case. */
4981     *async = FALSE;
4982
4983   else {
4984     /* this is a fresh connect */
4985     int rc;
4986     struct Curl_dns_entry *hostaddr;
4987
4988     /* set a pointer to the hostname we display */
4989     fix_hostname(data, conn, &conn->host);
4990
4991     if(!conn->proxy.name || !*conn->proxy.name) {
4992       /* If not connecting via a proxy, extract the port from the URL, if it is
4993        * there, thus overriding any defaults that might have been set above. */
4994       conn->port =  conn->remote_port; /* it is the same port */
4995
4996       /* Resolve target host right on */
4997       rc = Curl_resolv_timeout(conn, conn->host.name, (int)conn->port,
4998                                &hostaddr, timeout_ms);
4999       if(rc == CURLRESOLV_PENDING)
5000         *async = TRUE;
5001
5002       else if(rc == CURLRESOLV_TIMEDOUT)
5003         result = CURLE_OPERATION_TIMEDOUT;
5004
5005       else if(!hostaddr) {
5006         failf(data, "Couldn't resolve host '%s'", conn->host.dispname);
5007         result =  CURLE_COULDNT_RESOLVE_HOST;
5008         /* don't return yet, we need to clean up the timeout first */
5009       }
5010     }
5011     else {
5012       /* This is a proxy that hasn't been resolved yet. */
5013
5014       /* IDN-fix the proxy name */
5015       fix_hostname(data, conn, &conn->proxy);
5016
5017       /* resolve proxy */
5018       rc = Curl_resolv_timeout(conn, conn->proxy.name, (int)conn->port,
5019                                &hostaddr, timeout_ms);
5020
5021       if(rc == CURLRESOLV_PENDING)
5022         *async = TRUE;
5023
5024       else if(rc == CURLRESOLV_TIMEDOUT)
5025         result = CURLE_OPERATION_TIMEDOUT;
5026
5027       else if(!hostaddr) {
5028         failf(data, "Couldn't resolve proxy '%s'", conn->proxy.dispname);
5029         result = CURLE_COULDNT_RESOLVE_PROXY;
5030         /* don't return yet, we need to clean up the timeout first */
5031       }
5032     }
5033     DEBUGASSERT(conn->dns_entry == NULL);
5034     conn->dns_entry = hostaddr;
5035   }
5036
5037   return result;
5038 }
5039
5040 /*
5041  * Cleanup the connection just allocated before we can move along and use the
5042  * previously existing one.  All relevant data is copied over and old_conn is
5043  * ready for freeing once this function returns.
5044  */
5045 static void reuse_conn(struct connectdata *old_conn,
5046                        struct connectdata *conn)
5047 {
5048   if(old_conn->proxy.rawalloc)
5049     free(old_conn->proxy.rawalloc);
5050
5051   /* free the SSL config struct from this connection struct as this was
5052      allocated in vain and is targeted for destruction */
5053   Curl_free_ssl_config(&old_conn->ssl_config);
5054
5055   conn->data = old_conn->data;
5056
5057   /* get the user+password information from the old_conn struct since it may
5058    * be new for this request even when we re-use an existing connection */
5059   conn->bits.user_passwd = old_conn->bits.user_passwd;
5060   if(conn->bits.user_passwd) {
5061     /* use the new user name and password though */
5062     Curl_safefree(conn->user);
5063     Curl_safefree(conn->passwd);
5064     conn->user = old_conn->user;
5065     conn->passwd = old_conn->passwd;
5066     old_conn->user = NULL;
5067     old_conn->passwd = NULL;
5068   }
5069
5070   conn->bits.proxy_user_passwd = old_conn->bits.proxy_user_passwd;
5071   if(conn->bits.proxy_user_passwd) {
5072     /* use the new proxy user name and proxy password though */
5073     Curl_safefree(conn->proxyuser);
5074     Curl_safefree(conn->proxypasswd);
5075     conn->proxyuser = old_conn->proxyuser;
5076     conn->proxypasswd = old_conn->proxypasswd;
5077     old_conn->proxyuser = NULL;
5078     old_conn->proxypasswd = NULL;
5079   }
5080
5081   /* host can change, when doing keepalive with a proxy or if the case is
5082      different this time etc */
5083   Curl_safefree(conn->host.rawalloc);
5084   conn->host=old_conn->host;
5085
5086   /* persist connection info in session handle */
5087   Curl_persistconninfo(conn);
5088
5089   /* re-use init */
5090   conn->bits.reuse = TRUE; /* yes, we're re-using here */
5091
5092   Curl_safefree(old_conn->user);
5093   Curl_safefree(old_conn->passwd);
5094   Curl_safefree(old_conn->proxyuser);
5095   Curl_safefree(old_conn->proxypasswd);
5096   Curl_safefree(old_conn->localdev);
5097
5098   Curl_llist_destroy(old_conn->send_pipe, NULL);
5099   Curl_llist_destroy(old_conn->recv_pipe, NULL);
5100
5101   old_conn->send_pipe = NULL;
5102   old_conn->recv_pipe = NULL;
5103
5104   Curl_safefree(old_conn->master_buffer);
5105 }
5106
5107 /**
5108  * create_conn() sets up a new connectdata struct, or re-uses an already
5109  * existing one, and resolves host name.
5110  *
5111  * if this function returns CURLE_OK and *async is set to TRUE, the resolve
5112  * response will be coming asynchronously. If *async is FALSE, the name is
5113  * already resolved.
5114  *
5115  * @param data The sessionhandle pointer
5116  * @param in_connect is set to the next connection data pointer
5117  * @param async is set TRUE when an async DNS resolution is pending
5118  * @see Curl_setup_conn()
5119  *
5120  * *NOTE* this function assigns the conn->data pointer!
5121  */
5122
5123 static CURLcode create_conn(struct SessionHandle *data,
5124                             struct connectdata **in_connect,
5125                             bool *async)
5126 {
5127   CURLcode result = CURLE_OK;
5128   struct connectdata *conn;
5129   struct connectdata *conn_temp = NULL;
5130   size_t urllen;
5131   char *user = NULL;
5132   char *passwd = NULL;
5133   char *options = NULL;
5134   bool reuse;
5135   char *proxy = NULL;
5136   bool prot_missing = FALSE;
5137   bool no_connections_available = FALSE;
5138   bool force_reuse;
5139   size_t max_host_connections = Curl_multi_max_host_connections(data->multi);
5140   size_t max_total_connections = Curl_multi_max_total_connections(data->multi);
5141
5142   *async = FALSE;
5143
5144   /*************************************************************
5145    * Check input data
5146    *************************************************************/
5147
5148   if(!data->change.url) {
5149     result = CURLE_URL_MALFORMAT;
5150     goto out;
5151   }
5152
5153   /* First, split up the current URL in parts so that we can use the
5154      parts for checking against the already present connections. In order
5155      to not have to modify everything at once, we allocate a temporary
5156      connection data struct and fill in for comparison purposes. */
5157   conn = allocate_conn(data);
5158
5159   if(!conn) {
5160     result = CURLE_OUT_OF_MEMORY;
5161     goto out;
5162   }
5163
5164   /* We must set the return variable as soon as possible, so that our
5165      parent can cleanup any possible allocs we may have done before
5166      any failure */
5167   *in_connect = conn;
5168
5169   /* This initing continues below, see the comment "Continue connectdata
5170    * initialization here" */
5171
5172   /***********************************************************
5173    * We need to allocate memory to store the path in. We get the size of the
5174    * full URL to be sure, and we need to make it at least 256 bytes since
5175    * other parts of the code will rely on this fact
5176    ***********************************************************/
5177 #define LEAST_PATH_ALLOC 256
5178   urllen=strlen(data->change.url);
5179   if(urllen < LEAST_PATH_ALLOC)
5180     urllen=LEAST_PATH_ALLOC;
5181
5182   /*
5183    * We malloc() the buffers below urllen+2 to make room for 2 possibilities:
5184    * 1 - an extra terminating zero
5185    * 2 - an extra slash (in case a syntax like "www.host.com?moo" is used)
5186    */
5187
5188   Curl_safefree(data->state.pathbuffer);
5189   data->state.path = NULL;
5190
5191   data->state.pathbuffer = malloc(urllen+2);
5192   if(NULL == data->state.pathbuffer) {
5193     result = CURLE_OUT_OF_MEMORY; /* really bad error */
5194     goto out;
5195   }
5196   data->state.path = data->state.pathbuffer;
5197
5198   conn->host.rawalloc = malloc(urllen+2);
5199   if(NULL == conn->host.rawalloc) {
5200     Curl_safefree(data->state.pathbuffer);
5201     data->state.path = NULL;
5202     result = CURLE_OUT_OF_MEMORY;
5203     goto out;
5204   }
5205
5206   conn->host.name = conn->host.rawalloc;
5207   conn->host.name[0] = 0;
5208
5209   user = strdup("");
5210   passwd = strdup("");
5211   options = strdup("");
5212   if(!user || !passwd || !options) {
5213     result = CURLE_OUT_OF_MEMORY;
5214     goto out;
5215   }
5216
5217   result = parseurlandfillconn(data, conn, &prot_missing, &user, &passwd,
5218                                &options);
5219   if(result != CURLE_OK)
5220     goto out;
5221
5222   /*************************************************************
5223    * No protocol part in URL was used, add it!
5224    *************************************************************/
5225   if(prot_missing) {
5226     /* We're guessing prefixes here and if we're told to use a proxy or if
5227        we're gonna follow a Location: later or... then we need the protocol
5228        part added so that we have a valid URL. */
5229     char *reurl;
5230
5231     reurl = aprintf("%s://%s", conn->handler->scheme, data->change.url);
5232
5233     if(!reurl) {
5234       result = CURLE_OUT_OF_MEMORY;
5235       goto out;
5236     }
5237
5238     if(data->change.url_alloc) {
5239       Curl_safefree(data->change.url);
5240       data->change.url_alloc = FALSE;
5241     }
5242
5243     data->change.url = reurl;
5244     data->change.url_alloc = TRUE; /* free this later */
5245   }
5246
5247   /*************************************************************
5248    * If the protocol can't handle url query strings, then cut
5249    * off the unhandable part
5250    *************************************************************/
5251   if((conn->given->flags&PROTOPT_NOURLQUERY)) {
5252     char *path_q_sep = strchr(conn->data->state.path, '?');
5253     if(path_q_sep) {
5254       /* according to rfc3986, allow the query (?foo=bar)
5255          also on protocols that can't handle it.
5256
5257          cut the string-part after '?'
5258       */
5259
5260       /* terminate the string */
5261       path_q_sep[0] = 0;
5262     }
5263   }
5264
5265   if(data->set.str[STRING_BEARER]) {
5266     conn->xoauth2_bearer = strdup(data->set.str[STRING_BEARER]);
5267     if(!conn->xoauth2_bearer) {
5268       result = CURLE_OUT_OF_MEMORY;
5269       goto out;
5270     }
5271   }
5272
5273 #ifndef CURL_DISABLE_PROXY
5274   /*************************************************************
5275    * Extract the user and password from the authentication string
5276    *************************************************************/
5277   if(conn->bits.proxy_user_passwd) {
5278     result = parse_proxy_auth(data, conn);
5279     if(result != CURLE_OK)
5280       goto out;
5281   }
5282
5283   /*************************************************************
5284    * Detect what (if any) proxy to use
5285    *************************************************************/
5286   if(data->set.str[STRING_PROXY]) {
5287     proxy = strdup(data->set.str[STRING_PROXY]);
5288     /* if global proxy is set, this is it */
5289     if(NULL == proxy) {
5290       failf(data, "memory shortage");
5291       result = CURLE_OUT_OF_MEMORY;
5292       goto out;
5293     }
5294   }
5295
5296   if(data->set.str[STRING_NOPROXY] &&
5297      check_noproxy(conn->host.name, data->set.str[STRING_NOPROXY])) {
5298     if(proxy) {
5299       free(proxy);  /* proxy is in exception list */
5300       proxy = NULL;
5301     }
5302   }
5303   else if(!proxy)
5304     proxy = detect_proxy(conn);
5305
5306   if(proxy && (!*proxy || (conn->handler->flags & PROTOPT_NONETWORK))) {
5307     free(proxy);  /* Don't bother with an empty proxy string or if the
5308                      protocol doesn't work with network */
5309     proxy = NULL;
5310   }
5311
5312   /***********************************************************************
5313    * If this is supposed to use a proxy, we need to figure out the proxy host
5314    * name, proxy type and port number, so that we can re-use an existing
5315    * connection that may exist registered to the same proxy host.
5316    ***********************************************************************/
5317   if(proxy) {
5318     result = parse_proxy(data, conn, proxy);
5319
5320     Curl_safefree(proxy); /* parse_proxy copies the proxy string */
5321
5322     if(result)
5323       goto out;
5324
5325     if((conn->proxytype == CURLPROXY_HTTP) ||
5326        (conn->proxytype == CURLPROXY_HTTP_1_0)) {
5327 #ifdef CURL_DISABLE_HTTP
5328       /* asking for a HTTP proxy is a bit funny when HTTP is disabled... */
5329       result = CURLE_UNSUPPORTED_PROTOCOL;
5330       goto out;
5331 #else
5332       /* force this connection's protocol to become HTTP if not already
5333          compatible - if it isn't tunneling through */
5334       if(!(conn->handler->protocol & PROTO_FAMILY_HTTP) &&
5335          !conn->bits.tunnel_proxy)
5336         conn->handler = &Curl_handler_http;
5337
5338       conn->bits.httpproxy = TRUE;
5339 #endif
5340     }
5341     else
5342       conn->bits.httpproxy = FALSE; /* not a HTTP proxy */
5343     conn->bits.proxy = TRUE;
5344   }
5345   else {
5346     /* we aren't using the proxy after all... */
5347     conn->bits.proxy = FALSE;
5348     conn->bits.httpproxy = FALSE;
5349     conn->bits.proxy_user_passwd = FALSE;
5350     conn->bits.tunnel_proxy = FALSE;
5351   }
5352
5353 #endif /* CURL_DISABLE_PROXY */
5354
5355   /*************************************************************
5356    * If the protocol is using SSL and HTTP proxy is used, we set
5357    * the tunnel_proxy bit.
5358    *************************************************************/
5359   if((conn->given->flags&PROTOPT_SSL) && conn->bits.httpproxy)
5360     conn->bits.tunnel_proxy = TRUE;
5361
5362   /*************************************************************
5363    * Figure out the remote port number and fix it in the URL
5364    *************************************************************/
5365   result = parse_remote_port(data, conn);
5366   if(result != CURLE_OK)
5367     goto out;
5368
5369   /* Check for overridden login details and set them accordingly so they
5370      they are known when protocol->setup_connection is called! */
5371   result = override_login(data, conn, &user, &passwd, &options);
5372   if(result != CURLE_OK)
5373     goto out;
5374   result = set_login(conn, user, passwd, options);
5375   if(result != CURLE_OK)
5376     goto out;
5377
5378   /*************************************************************
5379    * Setup internals depending on protocol. Needs to be done after
5380    * we figured out what/if proxy to use.
5381    *************************************************************/
5382   result = setup_connection_internals(conn);
5383   if(result != CURLE_OK)
5384     goto out;
5385
5386   conn->recv[FIRSTSOCKET] = Curl_recv_plain;
5387   conn->send[FIRSTSOCKET] = Curl_send_plain;
5388   conn->recv[SECONDARYSOCKET] = Curl_recv_plain;
5389   conn->send[SECONDARYSOCKET] = Curl_send_plain;
5390
5391   /***********************************************************************
5392    * file: is a special case in that it doesn't need a network connection
5393    ***********************************************************************/
5394 #ifndef CURL_DISABLE_FILE
5395   if(conn->handler->flags & PROTOPT_NONETWORK) {
5396     bool done;
5397     /* this is supposed to be the connect function so we better at least check
5398        that the file is present here! */
5399     DEBUGASSERT(conn->handler->connect_it);
5400     result = conn->handler->connect_it(conn, &done);
5401
5402     /* Setup a "faked" transfer that'll do nothing */
5403     if(CURLE_OK == result) {
5404       conn->data = data;
5405       conn->bits.tcpconnect[FIRSTSOCKET] = TRUE; /* we are "connected */
5406
5407       ConnectionStore(data, conn);
5408
5409       /*
5410        * Setup whatever necessary for a resumed transfer
5411        */
5412       result = setup_range(data);
5413       if(result) {
5414         DEBUGASSERT(conn->handler->done);
5415         /* we ignore the return code for the protocol-specific DONE */
5416         (void)conn->handler->done(conn, result, FALSE);
5417         goto out;
5418       }
5419
5420       Curl_setup_transfer(conn, -1, -1, FALSE, NULL, /* no download */
5421                           -1, NULL); /* no upload */
5422     }
5423
5424     /* since we skip do_init() */
5425     do_init(conn);
5426
5427     goto out;
5428   }
5429 #endif
5430
5431   /* Get a cloned copy of the SSL config situation stored in the
5432      connection struct. But to get this going nicely, we must first make
5433      sure that the strings in the master copy are pointing to the correct
5434      strings in the session handle strings array!
5435
5436      Keep in mind that the pointers in the master copy are pointing to strings
5437      that will be freed as part of the SessionHandle struct, but all cloned
5438      copies will be separately allocated.
5439   */
5440   data->set.ssl.CApath = data->set.str[STRING_SSL_CAPATH];
5441   data->set.ssl.CAfile = data->set.str[STRING_SSL_CAFILE];
5442   data->set.ssl.CRLfile = data->set.str[STRING_SSL_CRLFILE];
5443   data->set.ssl.issuercert = data->set.str[STRING_SSL_ISSUERCERT];
5444   data->set.ssl.random_file = data->set.str[STRING_SSL_RANDOM_FILE];
5445   data->set.ssl.egdsocket = data->set.str[STRING_SSL_EGDSOCKET];
5446   data->set.ssl.cipher_list = data->set.str[STRING_SSL_CIPHER_LIST];
5447 #ifdef USE_TLS_SRP
5448   data->set.ssl.username = data->set.str[STRING_TLSAUTH_USERNAME];
5449   data->set.ssl.password = data->set.str[STRING_TLSAUTH_PASSWORD];
5450 #endif
5451
5452   if(!Curl_clone_ssl_config(&data->set.ssl, &conn->ssl_config)) {
5453     result = CURLE_OUT_OF_MEMORY;
5454     goto out;
5455   }
5456
5457   /*************************************************************
5458    * Check the current list of connections to see if we can
5459    * re-use an already existing one or if we have to create a
5460    * new one.
5461    *************************************************************/
5462
5463   /* reuse_fresh is TRUE if we are told to use a new connection by force, but
5464      we only acknowledge this option if this is not a re-used connection
5465      already (which happens due to follow-location or during a HTTP
5466      authentication phase). */
5467   if(data->set.reuse_fresh && !data->state.this_is_a_follow)
5468     reuse = FALSE;
5469   else
5470     reuse = ConnectionExists(data, conn, &conn_temp, &force_reuse);
5471
5472   /* If we found a reusable connection, we may still want to
5473      open a new connection if we are pipelining. */
5474   if(reuse && !force_reuse && IsPipeliningPossible(data, conn_temp)) {
5475     size_t pipelen = conn_temp->send_pipe->size + conn_temp->recv_pipe->size;
5476     if(pipelen > 0) {
5477       infof(data, "Found connection %ld, with requests in the pipe (%zu)\n",
5478             conn_temp->connection_id, pipelen);
5479
5480       if(conn_temp->bundle->num_connections < max_host_connections &&
5481          data->state.conn_cache->num_connections < max_total_connections) {
5482         /* We want a new connection anyway */
5483         reuse = FALSE;
5484
5485         infof(data, "We can reuse, but we want a new connection anyway\n");
5486       }
5487     }
5488   }
5489
5490   if(reuse) {
5491     /*
5492      * We already have a connection for this, we got the former connection
5493      * in the conn_temp variable and thus we need to cleanup the one we
5494      * just allocated before we can move along and use the previously
5495      * existing one.
5496      */
5497     conn_temp->inuse = TRUE; /* mark this as being in use so that no other
5498                                 handle in a multi stack may nick it */
5499     reuse_conn(conn, conn_temp);
5500     free(conn);          /* we don't need this anymore */
5501     conn = conn_temp;
5502     *in_connect = conn;
5503
5504     /* set a pointer to the hostname we display */
5505     fix_hostname(data, conn, &conn->host);
5506
5507     infof(data, "Re-using existing connection! (#%ld) with host %s\n",
5508           conn->connection_id,
5509           conn->proxy.name?conn->proxy.dispname:conn->host.dispname);
5510   }
5511   else {
5512     /* We have decided that we want a new connection. However, we may not
5513        be able to do that if we have reached the limit of how many
5514        connections we are allowed to open. */
5515     struct connectbundle *bundle;
5516
5517     bundle = Curl_conncache_find_bundle(data->state.conn_cache,
5518                                         conn->host.name);
5519     if(max_host_connections > 0 && bundle &&
5520        (bundle->num_connections >= max_host_connections)) {
5521       struct connectdata *conn_candidate;
5522
5523       /* The bundle is full. Let's see if we can kill a connection. */
5524       conn_candidate = find_oldest_idle_connection_in_bundle(data, bundle);
5525
5526       if(conn_candidate) {
5527         /* Set the connection's owner correctly, then kill it */
5528         conn_candidate->data = data;
5529         (void)Curl_disconnect(conn_candidate, /* dead_connection */ FALSE);
5530       }
5531       else
5532         no_connections_available = TRUE;
5533     }
5534
5535     if(max_total_connections > 0 &&
5536        (data->state.conn_cache->num_connections >= max_total_connections)) {
5537       struct connectdata *conn_candidate;
5538
5539       /* The cache is full. Let's see if we can kill a connection. */
5540       conn_candidate = find_oldest_idle_connection(data);
5541
5542       if(conn_candidate) {
5543         /* Set the connection's owner correctly, then kill it */
5544         conn_candidate->data = data;
5545         (void)Curl_disconnect(conn_candidate, /* dead_connection */ FALSE);
5546       }
5547       else
5548         no_connections_available = TRUE;
5549     }
5550
5551
5552     if(no_connections_available) {
5553       infof(data, "No connections available.\n");
5554
5555       conn_free(conn);
5556       *in_connect = NULL;
5557
5558       result = CURLE_NO_CONNECTION_AVAILABLE;
5559       goto out;
5560     }
5561     else {
5562       /*
5563        * This is a brand new connection, so let's store it in the connection
5564        * cache of ours!
5565        */
5566       ConnectionStore(data, conn);
5567     }
5568   }
5569
5570   /* Mark the connection as used */
5571   conn->inuse = TRUE;
5572
5573   /* Setup and init stuff before DO starts, in preparing for the transfer. */
5574   do_init(conn);
5575
5576   /*
5577    * Setup whatever necessary for a resumed transfer
5578    */
5579   result = setup_range(data);
5580   if(result)
5581     goto out;
5582
5583   /* Continue connectdata initialization here. */
5584
5585   /*
5586    * Inherit the proper values from the urldata struct AFTER we have arranged
5587    * the persistent connection stuff
5588    */
5589   conn->fread_func = data->set.fread_func;
5590   conn->fread_in = data->set.in;
5591   conn->seek_func = data->set.seek_func;
5592   conn->seek_client = data->set.seek_client;
5593
5594   /*************************************************************
5595    * Resolve the address of the server or proxy
5596    *************************************************************/
5597   result = resolve_server(data, conn, async);
5598
5599   out:
5600
5601   Curl_safefree(options);
5602   Curl_safefree(passwd);
5603   Curl_safefree(user);
5604   Curl_safefree(proxy);
5605   return result;
5606 }
5607
5608 /* Curl_setup_conn() is called after the name resolve initiated in
5609  * create_conn() is all done.
5610  *
5611  * Curl_setup_conn() also handles reused connections
5612  *
5613  * conn->data MUST already have been setup fine (in create_conn)
5614  */
5615
5616 CURLcode Curl_setup_conn(struct connectdata *conn,
5617                          bool *protocol_done)
5618 {
5619   CURLcode result = CURLE_OK;
5620   struct SessionHandle *data = conn->data;
5621
5622   Curl_pgrsTime(data, TIMER_NAMELOOKUP);
5623
5624   if(conn->handler->flags & PROTOPT_NONETWORK) {
5625     /* nothing to setup when not using a network */
5626     *protocol_done = TRUE;
5627     return result;
5628   }
5629   *protocol_done = FALSE; /* default to not done */
5630
5631   /* set proxy_connect_closed to false unconditionally already here since it
5632      is used strictly to provide extra information to a parent function in the
5633      case of proxy CONNECT failures and we must make sure we don't have it
5634      lingering set from a previous invoke */
5635   conn->bits.proxy_connect_closed = FALSE;
5636
5637   /*
5638    * Set user-agent. Used for HTTP, but since we can attempt to tunnel
5639    * basically anything through a http proxy we can't limit this based on
5640    * protocol.
5641    */
5642   if(data->set.str[STRING_USERAGENT]) {
5643     Curl_safefree(conn->allocptr.uagent);
5644     conn->allocptr.uagent =
5645       aprintf("User-Agent: %s\r\n", data->set.str[STRING_USERAGENT]);
5646     if(!conn->allocptr.uagent)
5647       return CURLE_OUT_OF_MEMORY;
5648   }
5649
5650   data->req.headerbytecount = 0;
5651
5652 #ifdef CURL_DO_LINEEND_CONV
5653   data->state.crlf_conversions = 0; /* reset CRLF conversion counter */
5654 #endif /* CURL_DO_LINEEND_CONV */
5655
5656   /* set start time here for timeout purposes in the connect procedure, it
5657      is later set again for the progress meter purpose */
5658   conn->now = Curl_tvnow();
5659
5660   if(CURL_SOCKET_BAD == conn->sock[FIRSTSOCKET]) {
5661     conn->bits.tcpconnect[FIRSTSOCKET] = FALSE;
5662     result = Curl_connecthost(conn, conn->dns_entry);
5663     if(result)
5664       return result;
5665   }
5666   else {
5667     Curl_pgrsTime(data, TIMER_CONNECT);    /* we're connected already */
5668     Curl_pgrsTime(data, TIMER_APPCONNECT); /* we're connected already */
5669     conn->bits.tcpconnect[FIRSTSOCKET] = TRUE;
5670     *protocol_done = TRUE;
5671     Curl_updateconninfo(conn, conn->sock[FIRSTSOCKET]);
5672     Curl_verboseconnect(conn);
5673   }
5674
5675   conn->now = Curl_tvnow(); /* time this *after* the connect is done, we
5676                                set this here perhaps a second time */
5677
5678 #ifdef __EMX__
5679   /*
5680    * This check is quite a hack. We're calling _fsetmode to fix the problem
5681    * with fwrite converting newline characters (you get mangled text files,
5682    * and corrupted binary files when you download to stdout and redirect it to
5683    * a file).
5684    */
5685
5686   if((data->set.out)->_handle == NULL) {
5687     _fsetmode(stdout, "b");
5688   }
5689 #endif
5690
5691   return result;
5692 }
5693
5694 CURLcode Curl_connect(struct SessionHandle *data,
5695                       struct connectdata **in_connect,
5696                       bool *asyncp,
5697                       bool *protocol_done)
5698 {
5699   CURLcode code;
5700
5701   *asyncp = FALSE; /* assume synchronous resolves by default */
5702
5703   /* call the stuff that needs to be called */
5704   code = create_conn(data, in_connect, asyncp);
5705
5706   if(CURLE_OK == code) {
5707     /* no error */
5708     if((*in_connect)->send_pipe->size || (*in_connect)->recv_pipe->size)
5709       /* pipelining */
5710       *protocol_done = TRUE;
5711     else if(!*asyncp) {
5712       /* DNS resolution is done: that's either because this is a reused
5713          connection, in which case DNS was unnecessary, or because DNS
5714          really did finish already (synch resolver/fast async resolve) */
5715       code = Curl_setup_conn(*in_connect, protocol_done);
5716     }
5717   }
5718
5719   if(code == CURLE_NO_CONNECTION_AVAILABLE) {
5720     *in_connect = NULL;
5721     return code;
5722   }
5723
5724   if(code && *in_connect) {
5725     /* We're not allowed to return failure with memory left allocated
5726        in the connectdata struct, free those here */
5727     Curl_disconnect(*in_connect, FALSE); /* close the connection */
5728     *in_connect = NULL;           /* return a NULL */
5729   }
5730
5731   return code;
5732 }
5733
5734 CURLcode Curl_done(struct connectdata **connp,
5735                    CURLcode status,  /* an error if this is called after an
5736                                         error was detected */
5737                    bool premature)
5738 {
5739   CURLcode result;
5740   struct connectdata *conn;
5741   struct SessionHandle *data;
5742
5743   DEBUGASSERT(*connp);
5744
5745   conn = *connp;
5746   data = conn->data;
5747
5748   if(conn->bits.done)
5749     /* Stop if Curl_done() has already been called */
5750     return CURLE_OK;
5751
5752   Curl_getoff_all_pipelines(data, conn);
5753
5754   if((conn->send_pipe->size + conn->recv_pipe->size != 0 &&
5755       !data->set.reuse_forbid &&
5756       !conn->bits.close))
5757     /* Stop if pipeline is not empty and we do not have to close
5758        connection. */
5759     return CURLE_OK;
5760
5761   conn->bits.done = TRUE; /* called just now! */
5762
5763   /* Cleanup possible redirect junk */
5764   if(data->req.newurl) {
5765     free(data->req.newurl);
5766     data->req.newurl = NULL;
5767   }
5768   if(data->req.location) {
5769     free(data->req.location);
5770     data->req.location = NULL;
5771   }
5772
5773   Curl_resolver_cancel(conn);
5774
5775   if(conn->dns_entry) {
5776     Curl_resolv_unlock(data, conn->dns_entry); /* done with this */
5777     conn->dns_entry = NULL;
5778   }
5779
5780   switch(status) {
5781   case CURLE_ABORTED_BY_CALLBACK:
5782   case CURLE_READ_ERROR:
5783   case CURLE_WRITE_ERROR:
5784     /* When we're aborted due to a callback return code it basically have to
5785        be counted as premature as there is trouble ahead if we don't. We have
5786        many callbacks and protocols work differently, we could potentially do
5787        this more fine-grained in the future. */
5788     premature = TRUE;
5789   default:
5790     break;
5791   }
5792
5793   /* this calls the protocol-specific function pointer previously set */
5794   if(conn->handler->done)
5795     result = conn->handler->done(conn, status, premature);
5796   else
5797     result = CURLE_OK;
5798
5799   if(Curl_pgrsDone(conn) && !result)
5800     result = CURLE_ABORTED_BY_CALLBACK;
5801
5802   /* if the transfer was completed in a paused state there can be buffered
5803      data left to write and then kill */
5804   if(data->state.tempwrite) {
5805     free(data->state.tempwrite);
5806     data->state.tempwrite = NULL;
5807   }
5808
5809   /* if data->set.reuse_forbid is TRUE, it means the libcurl client has
5810      forced us to close this no matter what we think.
5811
5812      if conn->bits.close is TRUE, it means that the connection should be
5813      closed in spite of all our efforts to be nice, due to protocol
5814      restrictions in our or the server's end
5815
5816      if premature is TRUE, it means this connection was said to be DONE before
5817      the entire request operation is complete and thus we can't know in what
5818      state it is for re-using, so we're forced to close it. In a perfect world
5819      we can add code that keep track of if we really must close it here or not,
5820      but currently we have no such detail knowledge.
5821   */
5822   if(data->set.reuse_forbid || conn->bits.close || premature) {
5823     CURLcode res2 = Curl_disconnect(conn, premature); /* close connection */
5824
5825     /* If we had an error already, make sure we return that one. But
5826        if we got a new error, return that. */
5827     if(!result && res2)
5828       result = res2;
5829   }
5830   else {
5831     /* the connection is no longer in use */
5832     if(ConnectionDone(data, conn)) {
5833       /* remember the most recently used connection */
5834       data->state.lastconnect = conn;
5835
5836       infof(data, "Connection #%ld to host %s left intact\n",
5837             conn->connection_id,
5838             conn->bits.httpproxy?conn->proxy.dispname:conn->host.dispname);
5839     }
5840     else
5841       data->state.lastconnect = NULL;
5842   }
5843
5844   *connp = NULL; /* to make the caller of this function better detect that
5845                     this was either closed or handed over to the connection
5846                     cache here, and therefore cannot be used from this point on
5847                  */
5848   Curl_free_request_state(data);
5849
5850   return result;
5851 }
5852
5853 /*
5854  * do_init() inits the readwrite session. This is inited each time (in the DO
5855  * function before the protocol-specific DO functions are invoked) for a
5856  * transfer, sometimes multiple times on the same SessionHandle. Make sure
5857  * nothing in here depends on stuff that are setup dynamically for the
5858  * transfer.
5859  */
5860
5861 static CURLcode do_init(struct connectdata *conn)
5862 {
5863   struct SessionHandle *data = conn->data;
5864   struct SingleRequest *k = &data->req;
5865
5866   conn->bits.done = FALSE; /* Curl_done() is not called yet */
5867   conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to use */
5868   data->state.expect100header = FALSE;
5869
5870   if(data->set.opt_no_body)
5871     /* in HTTP lingo, no body means using the HEAD request... */
5872     data->set.httpreq = HTTPREQ_HEAD;
5873   else if(HTTPREQ_HEAD == data->set.httpreq)
5874     /* ... but if unset there really is no perfect method that is the
5875        "opposite" of HEAD but in reality most people probably think GET
5876        then. The important thing is that we can't let it remain HEAD if the
5877        opt_no_body is set FALSE since then we'll behave wrong when getting
5878        HTTP. */
5879     data->set.httpreq = HTTPREQ_GET;
5880
5881   k->start = Curl_tvnow(); /* start time */
5882   k->now = k->start;   /* current time is now */
5883   k->header = TRUE; /* assume header */
5884
5885   k->bytecount = 0;
5886
5887   k->buf = data->state.buffer;
5888   k->uploadbuf = data->state.uploadbuffer;
5889   k->hbufp = data->state.headerbuff;
5890   k->ignorebody=FALSE;
5891
5892   Curl_speedinit(data);
5893
5894   Curl_pgrsSetUploadCounter(data, 0);
5895   Curl_pgrsSetDownloadCounter(data, 0);
5896
5897   return CURLE_OK;
5898 }
5899
5900 /*
5901  * do_complete is called when the DO actions are complete.
5902  *
5903  * We init chunking and trailer bits to their default values here immediately
5904  * before receiving any header data for the current request in the pipeline.
5905  */
5906 static void do_complete(struct connectdata *conn)
5907 {
5908   conn->data->req.chunk=FALSE;
5909   conn->data->req.maxfd = (conn->sockfd>conn->writesockfd?
5910                            conn->sockfd:conn->writesockfd)+1;
5911   Curl_pgrsTime(conn->data, TIMER_PRETRANSFER);
5912 }
5913
5914 CURLcode Curl_do(struct connectdata **connp, bool *done)
5915 {
5916   CURLcode result=CURLE_OK;
5917   struct connectdata *conn = *connp;
5918   struct SessionHandle *data = conn->data;
5919
5920   if(conn->handler->do_it) {
5921     /* generic protocol-specific function pointer set in curl_connect() */
5922     result = conn->handler->do_it(conn, done);
5923
5924     /* This was formerly done in transfer.c, but we better do it here */
5925     if((CURLE_SEND_ERROR == result) && conn->bits.reuse) {
5926       /*
5927        * If the connection is using an easy handle, call reconnect
5928        * to re-establish the connection.  Otherwise, let the multi logic
5929        * figure out how to re-establish the connection.
5930        */
5931       if(!data->multi) {
5932         result = Curl_reconnect_request(connp);
5933
5934         if(result == CURLE_OK) {
5935           /* ... finally back to actually retry the DO phase */
5936           conn = *connp; /* re-assign conn since Curl_reconnect_request
5937                             creates a new connection */
5938           result = conn->handler->do_it(conn, done);
5939         }
5940       }
5941       else
5942         return result;
5943     }
5944
5945     if((result == CURLE_OK) && *done)
5946       /* do_complete must be called after the protocol-specific DO function */
5947       do_complete(conn);
5948   }
5949   return result;
5950 }
5951
5952 /*
5953  * Curl_do_more() is called during the DO_MORE multi state. It is basically a
5954  * second stage DO state which (wrongly) was introduced to support FTP's
5955  * second connection.
5956  *
5957  * TODO: A future libcurl should be able to work away this state.
5958  *
5959  * 'complete' can return 0 for incomplete, 1 for done and -1 for go back to
5960  * DOING state there's more work to do!
5961  */
5962
5963 CURLcode Curl_do_more(struct connectdata *conn, int *complete)
5964 {
5965   CURLcode result=CURLE_OK;
5966
5967   *complete = 0;
5968
5969   if(conn->handler->do_more)
5970     result = conn->handler->do_more(conn, complete);
5971
5972   if(!result && (*complete == 1))
5973     /* do_complete must be called after the protocol-specific DO function */
5974     do_complete(conn);
5975
5976   return result;
5977 }
5978