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