lib/url.c

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