lib/url.c

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