lib/url.c

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