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