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