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