lib/url.c

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