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