lib/url.c

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