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