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