lib/url.c

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