lib/url.c

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