lib/url.c

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