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