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