lib/url.c

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