lib/url.c

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