1 /***************************************************************************
3 * Project ___| | | | _ \| |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
8 * Copyright (C) 1998 - 2013, Daniel Stenberg, <daniel@haxx.se>, et al.
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.
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.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 ***************************************************************************/
23 #include "curl_setup.h"
25 #ifdef HAVE_NETINET_IN_H
26 #include <netinet/in.h>
31 #ifdef HAVE_ARPA_INET_H
32 #include <arpa/inet.h>
37 #ifdef HAVE_SYS_IOCTL_H
38 #include <sys/ioctl.h>
41 #ifdef HAVE_SYS_PARAM_H
42 #include <sys/param.h>
51 #error "We can't compile without socket() support!"
61 #include <stringprep.h>
62 #ifdef HAVE_IDN_FREE_H
65 /* prototype from idn-free.h, not provided by libidn 0.4.5's make install! */
66 void idn_free (void *ptr);
69 /* if idn_free() was not found in this version of libidn use free() instead */
70 #define idn_free(x) (free)(x)
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 */
92 #include "content_encoding.h"
93 #include "http_digest.h"
94 #include "http_negotiate.h"
98 #include "speedcheck.h"
100 #include "warnless.h"
101 #include "non-ascii.h"
102 #include "inet_pton.h"
104 /* And now for the protocols */
111 #include "curl_ldap.h"
116 #include "inet_ntop.h"
117 #include "curl_ntlm.h"
118 #include "curl_ntlm_wb.h"
120 #include "curl_rtmp.h"
122 #include "http_proxy.h"
124 #include "conncache.h"
125 #include "multihandle.h"
126 #include "pipeline.h"
129 #define _MPRINTF_REPLACE /* use our functions only */
130 #include <curl/mprintf.h>
132 #include "curl_memory.h"
133 /* The last #include file should be: */
134 #include "memdebug.h"
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,
149 static CURLcode parse_login_details(const char *login, const size_t len,
150 char **userptr, char **passwdptr,
156 static const struct Curl_handler * const protocols[] = {
158 #ifndef CURL_DISABLE_HTTP
162 #if defined(USE_SSL) && !defined(CURL_DISABLE_HTTP)
166 #ifndef CURL_DISABLE_FTP
170 #if defined(USE_SSL) && !defined(CURL_DISABLE_FTP)
174 #ifndef CURL_DISABLE_TELNET
175 &Curl_handler_telnet,
178 #ifndef CURL_DISABLE_DICT
182 #ifndef CURL_DISABLE_LDAP
184 #if !defined(CURL_DISABLE_LDAPS) && \
185 ((defined(USE_OPENLDAP) && defined(USE_SSL)) || \
186 (!defined(USE_OPENLDAP) && defined(HAVE_LDAP_SSL)))
191 #ifndef CURL_DISABLE_FILE
195 #ifndef CURL_DISABLE_TFTP
204 #ifndef CURL_DISABLE_IMAP
211 #ifndef CURL_DISABLE_POP3
218 #ifndef CURL_DISABLE_SMTP
225 #ifndef CURL_DISABLE_RTSP
229 #ifndef CURL_DISABLE_GOPHER
230 &Curl_handler_gopher,
237 &Curl_handler_rtmpte,
239 &Curl_handler_rtmpts,
242 (struct Curl_handler *) NULL
246 * Dummy handler for undefined protocol schemes.
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 */
266 PROTOPT_NONE /* flags */
269 void Curl_freeset(struct SessionHandle *data)
271 /* Free all dynamic strings stored in the data->set substructure. */
273 for(i=(enum dupstring)0; i < STRING_LAST; i++)
274 Curl_safefree(data->set.str[i]);
276 if(data->change.referer_alloc) {
277 Curl_safefree(data->change.referer);
278 data->change.referer_alloc = FALSE;
280 data->change.referer = NULL;
283 static CURLcode setstropt(char **charp, char *s)
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. */
288 Curl_safefree(*charp);
294 return CURLE_OUT_OF_MEMORY;
302 static CURLcode setstropt_userpwd(char *option, char **userp, char **passwdp,
305 CURLcode result = CURLE_OK;
308 char *options = NULL;
310 /* Parse the login details if specified. It not then we treat NULL as a hint
311 to clear the existing data */
313 result = parse_login_details(option, strlen(option),
314 (userp ? &user : NULL),
315 (passwdp ? &passwd : NULL),
316 (optionsp ? &options : NULL));
320 /* Store the username part of option if required */
322 if(!user && option && option[0] == ':') {
323 /* Allocate an empty string instead of returning NULL as user name */
326 result = CURLE_OUT_OF_MEMORY;
329 Curl_safefree(*userp);
333 /* Store the password part of option if required */
335 Curl_safefree(*passwdp);
339 /* Store the options part of option if required */
341 Curl_safefree(*optionsp);
349 CURLcode Curl_dupset(struct SessionHandle *dst, struct SessionHandle *src)
351 CURLcode r = CURLE_OK;
354 /* Copy src->set into dst->set first, then deal with the strings
358 /* clear all string pointers first */
359 memset(dst->set.str, 0, STRING_LAST * sizeof(char *));
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]);
368 /* If a failure occurred, freeing has to be performed externally. */
373 * This is the internal function curl_easy_cleanup() calls. This should
374 * cleanup and free all resources associated with this sessionhandle.
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.
381 CURLcode Curl_close(struct SessionHandle *data)
383 struct Curl_multi *m;
388 Curl_expire(data, 0); /* shut off timers */
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);
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);
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
405 if(data->state.timeoutlist) {
406 Curl_llist_destroy(data->state.timeoutlist, NULL);
407 data->state.timeoutlist = NULL;
410 data->magic = 0; /* force a clear AFTER the possibly enforced removal from
411 the multi handle, since that function uses the magic
414 if(data->state.rangestringalloc)
415 free(data->state.range);
417 /* Free the pathbuffer */
418 Curl_safefree(data->state.pathbuffer);
419 data->state.path = NULL;
421 /* freed here just in case DONE wasn't called */
422 Curl_free_request_state(data);
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);
430 if(data->change.referer_alloc) {
431 Curl_safefree(data->change.referer);
432 data->change.referer_alloc = FALSE;
434 data->change.referer = NULL;
436 if(data->change.url_alloc) {
437 Curl_safefree(data->change.url);
438 data->change.url_alloc = FALSE;
440 data->change.url = NULL;
442 Curl_safefree(data->state.headerbuff);
444 Curl_flush_cookies(data, 1);
446 Curl_digest_cleanup(data);
448 Curl_safefree(data->info.contenttype);
449 Curl_safefree(data->info.wouldredirect);
451 /* this destroys the channel and we cannot use it anymore after this */
452 Curl_resolver_cleanup(data->state.resolver);
454 Curl_convert_close(data);
456 /* No longer a dirty share, if it exists */
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);
469 * Initialize the UserDefined fields within a SessionHandle.
470 * This may be safely called on a new or existing SessionHandle.
472 CURLcode Curl_init_userdefined(struct UserDefined *set)
474 CURLcode res = CURLE_OK;
476 set->out = stdout; /* default output to stdout */
477 set->in = stdin; /* default input from stdin */
478 set->err = stderr; /* default stderr to stderr */
480 /* use fwrite as default function to store output */
481 set->fwrite_func = (curl_write_callback)fwrite;
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;
488 set->seek_func = ZERO_NULL;
489 set->seek_client = ZERO_NULL;
491 /* conversion callbacks for non-ASCII hosts */
492 set->convfromnetwork = ZERO_NULL;
493 set->convtonetwork = ZERO_NULL;
494 set->convfromutf8 = ZERO_NULL;
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 */
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;
507 set->dns_cache_timeout = 60; /* Timeout every 60 seconds by default */
509 /* Set the default size of the SSL session ID cache */
510 set->ssl.max_ssl_sessions = 5;
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 */
517 /* make libcurl quiet by default: */
518 set->hide_progress = TRUE; /* CURLOPT_NOPROGRESS changes these */
521 * libcurl 7.10 introduced SSL verification *by default*! This needs to be
522 * switched off unless wanted.
524 set->ssl.verifypeer = TRUE;
525 set->ssl.verifyhost = TRUE;
527 set->ssl.authtype = CURL_TLSAUTH_NONE;
529 set->ssh_auth_types = CURLSSH_AUTH_DEFAULT; /* defaults to any auth
531 set->ssl.sessionid = TRUE; /* session ID caching enabled by default */
533 set->new_file_perms = 0644; /* Default permissions */
534 set->new_directory_perms = 0755; /* Default permissions */
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 */
543 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
545 * disallow unprotected protection negotiation NEC reference implementation
546 * seem not to follow rfc1961 section 4.3/4.4
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);
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);
563 set->wildcardmatch = FALSE;
564 set->chunk_bgn = ZERO_NULL;
565 set->chunk_end = ZERO_NULL;
567 /* tcp keepalives are disabled by default, but provide reasonable values for
568 * the interval and idle times.
570 set->tcp_keepalive = FALSE;
571 set->tcp_keepintvl = 60;
572 set->tcp_keepidle = 60;
580 * @param curl is a pointer to a sessionhandle pointer that gets set by this
585 CURLcode Curl_open(struct SessionHandle **curl)
587 CURLcode res = CURLE_OK;
588 struct SessionHandle *data;
591 /* Very simple start-up: alloc the struct, init it with zeroes and return */
592 data = calloc(1, sizeof(struct SessionHandle));
594 /* this is a very serious error */
595 DEBUGF(fprintf(stderr, "Error: calloc of SessionHandle failed\n"));
596 return CURLE_OUT_OF_MEMORY;
599 data->magic = CURLEASY_MAGIC_NUMBER;
601 status = Curl_resolver_init(&data->state.resolver);
603 DEBUGF(fprintf(stderr, "Error: resolver_init failed\n"));
608 /* We do some initial setup here, all those fields that can't be just 0 */
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;
616 res = Curl_init_userdefined(&data->set);
618 data->state.headersize=HEADERSIZE;
620 Curl_convert_init(data);
622 /* most recent connection is not yet defined */
623 data->state.lastconnect = NULL;
625 data->progress.flags |= PGRS_HIDE;
626 data->state.current_speed = -1; /* init to negative == impossible */
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 */
635 Curl_resolver_cleanup(data->state.resolver);
636 if(data->state.headerbuff)
637 free(data->state.headerbuff);
648 CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
652 CURLcode result = CURLE_OK;
654 #ifndef CURL_DISABLE_HTTP
659 case CURLOPT_DNS_CACHE_TIMEOUT:
660 data->set.dns_cache_timeout = va_arg(param, long);
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;
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 *));
673 case CURLOPT_RANDOM_FILE:
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.
678 result = setstropt(&data->set.str[STRING_SSL_RANDOM_FILE],
679 va_arg(param, char *));
681 case CURLOPT_EGDSOCKET:
683 * The Entropy Gathering Daemon socket pathname
685 result = setstropt(&data->set.str[STRING_SSL_EGDSOCKET],
686 va_arg(param, char *));
688 case CURLOPT_MAXCONNECTS:
690 * Set the absolute number of maximum simultaneous alive connection that
691 * libcurl is allowed to have.
693 data->set.maxconnects = va_arg(param, long);
695 case CURLOPT_FORBID_REUSE:
697 * When this transfer is done, it must not be left to be reused by a
698 * subsequent transfer but shall be closed immediately.
700 data->set.reuse_forbid = (0 != va_arg(param, long))?TRUE:FALSE;
702 case CURLOPT_FRESH_CONNECT:
704 * This transfer shall not use a previously cached connection but
705 * should be made with a fresh new connect!
707 data->set.reuse_fresh = (0 != va_arg(param, long))?TRUE:FALSE;
709 case CURLOPT_VERBOSE:
711 * Verbose means infof() calls that give a lot of information about
712 * the connection and transfer procedures as well as internal choices.
714 data->set.verbose = (0 != va_arg(param, long))?TRUE:FALSE;
718 * Set to include the header in the general data output stream.
720 data->set.include_header = (0 != va_arg(param, long))?TRUE:FALSE;
722 case CURLOPT_NOPROGRESS:
724 * Shut off the internal supported progress meter
726 data->set.hide_progress = (0 != va_arg(param, long))?TRUE:FALSE;
727 if(data->set.hide_progress)
728 data->progress.flags |= PGRS_HIDE;
730 data->progress.flags &= ~PGRS_HIDE;
734 * Do not include the body part in the output data stream.
736 data->set.opt_no_body = (0 != va_arg(param, long))?TRUE:FALSE;
738 case CURLOPT_FAILONERROR:
740 * Don't output the >=300 error code HTML-page, but instead only
743 data->set.http_fail_on_error = (0 != va_arg(param, long))?TRUE:FALSE;
748 * We want to sent data to the remote host. If this is HTTP, that equals
749 * using the PUT request.
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 */
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;
762 case CURLOPT_FILETIME:
764 * Try to get the file time of the remote document. The time will
765 * later (possibly) become available using curl_easy_getinfo().
767 data->set.get_filetime = (0 != va_arg(param, long))?TRUE:FALSE;
769 case CURLOPT_FTP_CREATE_MISSING_DIRS:
771 * An FTP option that modifies an upload to create missing directories on
774 switch(va_arg(param, long)) {
776 data->set.ftp_create_missing_dirs = 0;
779 data->set.ftp_create_missing_dirs = 1;
782 data->set.ftp_create_missing_dirs = 2;
785 /* reserve other values for future use */
786 result = CURLE_UNKNOWN_OPTION;
790 case CURLOPT_SERVER_RESPONSE_TIMEOUT:
792 * Option that specifies how quickly an server response must be obtained
793 * before it is considered failure. For pingpong protocols.
795 data->set.server_response_timeout = va_arg( param , long ) * 1000;
797 case CURLOPT_TFTP_BLKSIZE:
799 * TFTP option that specifies the block size to use for data transmission
801 data->set.tftp_blksize = va_arg(param, long);
803 case CURLOPT_DIRLISTONLY:
805 * An option that changes the command to one that asks for a list
806 * only, no file info details.
808 data->set.ftp_list_only = (0 != va_arg(param, long))?TRUE:FALSE;
812 * We want to upload and append to an existing file.
814 data->set.ftp_append = (0 != va_arg(param, long))?TRUE:FALSE;
816 case CURLOPT_FTP_FILEMETHOD:
818 * How do access files over FTP.
820 data->set.ftp_filemethod = (curl_ftpfile)va_arg(param, long);
824 * Parse the $HOME/.netrc file
826 data->set.use_netrc = (enum CURL_NETRC_OPTION)va_arg(param, long);
828 case CURLOPT_NETRC_FILE:
830 * Use this file instead of the $HOME/.netrc file
832 result = setstropt(&data->set.str[STRING_NETRC_FILE],
833 va_arg(param, char *));
835 case CURLOPT_TRANSFERTEXT:
837 * This option was previously named 'FTPASCII'. Renamed to work with
838 * more protocols than merely FTP.
840 * Transfer using ASCII (instead of BINARY).
842 data->set.prefer_ascii = (0 != va_arg(param, long))?TRUE:FALSE;
844 case CURLOPT_TIMECONDITION:
846 * Set HTTP time condition. This must be one of the defines in the
847 * curl/curl.h header file.
849 data->set.timecondition = (curl_TimeCond)va_arg(param, long);
851 case CURLOPT_TIMEVALUE:
853 * This is the value to compare with the remote document with the
854 * method set with CURLOPT_TIMECONDITION
856 data->set.timevalue = (time_t)va_arg(param, long);
858 case CURLOPT_SSLVERSION:
860 * Set explicit SSL version to try to connect with, as some SSL
861 * implementations are lame.
863 data->set.ssl.version = va_arg(param, long);
866 #ifndef CURL_DISABLE_HTTP
867 case CURLOPT_AUTOREFERER:
869 * Switch on automatic referer that gets set if curl follows locations.
871 data->set.http_auto_referer = (0 != va_arg(param, long))?TRUE:FALSE;
874 case CURLOPT_ACCEPT_ENCODING:
876 * String to use at the value of Accept-Encoding header.
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.
884 argptr = va_arg(param, char *);
885 result = setstropt(&data->set.str[STRING_ENCODING],
886 (argptr && !*argptr)?
887 (char *) ALL_CONTENT_ENCODINGS: argptr);
890 case CURLOPT_TRANSFER_ENCODING:
891 data->set.http_transfer_encoding = (0 != va_arg(param, long))?TRUE:FALSE;
894 case CURLOPT_FOLLOWLOCATION:
896 * Follow Location: header hints on a HTTP-server.
898 data->set.http_follow_location = (0 != va_arg(param, long))?TRUE:FALSE;
901 case CURLOPT_UNRESTRICTED_AUTH:
903 * Send authentication (user+password) when following locations, even when
906 data->set.http_disable_hostname_check_before_authentication =
907 (0 != va_arg(param, long))?TRUE:FALSE;
910 case CURLOPT_MAXREDIRS:
912 * The maximum amount of hops you allow curl to follow Location:
913 * headers. This should mostly be used to detect never-ending loops.
915 data->set.maxredirs = va_arg(param, long);
918 case CURLOPT_POSTREDIR:
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
929 int postRedir = curlx_sltosi(va_arg(param, long));
930 data->set.keep_post = postRedir & CURL_REDIR_POST_ALL;
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
938 if(va_arg(param, long)) {
939 data->set.httpreq = HTTPREQ_POST;
940 data->set.opt_no_body = FALSE; /* this is implied */
943 data->set.httpreq = HTTPREQ_GET;
946 case CURLOPT_COPYPOSTFIELDS:
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.
952 argptr = va_arg(param, char *);
954 if(!argptr || data->set.postfieldsize == -1)
955 result = setstropt(&data->set.str[STRING_COPYPOSTFIELDS], argptr);
958 * Check that requested length does not overflow the size_t type.
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;
968 (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
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
975 p = malloc((size_t)(data->set.postfieldsize?
976 data->set.postfieldsize:1));
979 result = CURLE_OUT_OF_MEMORY;
981 if(data->set.postfieldsize)
982 memcpy(p, argptr, (size_t)data->set.postfieldsize);
984 data->set.str[STRING_COPYPOSTFIELDS] = p;
989 data->set.postfields = data->set.str[STRING_COPYPOSTFIELDS];
990 data->set.httpreq = HTTPREQ_POST;
993 case CURLOPT_POSTFIELDS:
995 * Like above, but use static data instead of copying it.
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;
1003 case CURLOPT_POSTFIELDSIZE:
1005 * The size of the POSTFIELD data to prevent libcurl to do strlen() to
1006 * figure it out. Enables binary posts.
1008 bigsize = va_arg(param, long);
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;
1017 data->set.postfieldsize = bigsize;
1020 case CURLOPT_POSTFIELDSIZE_LARGE:
1022 * The size of the POSTFIELD data to prevent libcurl to do strlen() to
1023 * figure it out. Enables binary posts.
1025 bigsize = va_arg(param, curl_off_t);
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;
1034 data->set.postfieldsize = bigsize;
1037 case CURLOPT_HTTPPOST:
1039 * Set to make us do HTTP POST
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 */
1046 case CURLOPT_REFERER:
1048 * String to set in the HTTP Referer: field.
1050 if(data->change.referer_alloc) {
1051 Curl_safefree(data->change.referer);
1052 data->change.referer_alloc = FALSE;
1054 result = setstropt(&data->set.str[STRING_SET_REFERER],
1055 va_arg(param, char *));
1056 data->change.referer = data->set.str[STRING_SET_REFERER];
1059 case CURLOPT_USERAGENT:
1061 * String to use in the HTTP User-Agent field
1063 result = setstropt(&data->set.str[STRING_USERAGENT],
1064 va_arg(param, char *));
1067 case CURLOPT_HTTPHEADER:
1069 * Set a list with HTTP headers to use (or replace internals with)
1071 data->set.headers = va_arg(param, struct curl_slist *);
1074 case CURLOPT_HTTP200ALIASES:
1076 * Set a list of aliases for HTTP 200 in response header
1078 data->set.http200aliases = va_arg(param, struct curl_slist *);
1081 #if !defined(CURL_DISABLE_COOKIES)
1082 case CURLOPT_COOKIE:
1084 * Cookie string to send to the remote server in the request.
1086 result = setstropt(&data->set.str[STRING_COOKIE],
1087 va_arg(param, char *));
1090 case CURLOPT_COOKIEFILE:
1092 * Set cookie file to read and parse. Can be used multiple times.
1094 argptr = (char *)va_arg(param, void *);
1096 struct curl_slist *cl;
1097 /* append the cookie file name to the list of file names, and deal with
1099 cl = curl_slist_append(data->change.cookielist, argptr);
1101 curl_slist_free_all(data->change.cookielist);
1102 data->change.cookielist = NULL;
1103 return CURLE_OUT_OF_MEMORY;
1105 data->change.cookielist = cl; /* store the list for later use */
1109 case CURLOPT_COOKIEJAR:
1111 * Set cookie file name to dump all cookies to when we're done.
1113 result = setstropt(&data->set.str[STRING_COOKIEJAR],
1114 va_arg(param, char *));
1117 * Activate the cookie parser. This may or may not already
1120 data->cookies = Curl_cookie_init(data, NULL, data->cookies,
1121 data->set.cookiesession);
1124 case CURLOPT_COOKIESESSION:
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
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
1137 * We run mostly with the original cookie spec, as hardly anyone implements
1140 data->set.cookiesession = (0 != va_arg(param, long))?TRUE:FALSE;
1143 case CURLOPT_COOKIELIST:
1144 argptr = va_arg(param, char *);
1149 Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
1151 if(Curl_raw_equal(argptr, "ALL")) {
1152 /* clear all cookies */
1153 Curl_cookie_clearall(data->cookies);
1155 else if(Curl_raw_equal(argptr, "SESS")) {
1156 /* clear session cookies */
1157 Curl_cookie_clearsess(data->cookies);
1159 else if(Curl_raw_equal(argptr, "FLUSH")) {
1160 /* flush cookies to file */
1161 Curl_flush_cookies(data, 0);
1165 /* if cookie engine was not running, activate it */
1166 data->cookies = Curl_cookie_init(data, NULL, NULL, TRUE);
1168 argptr = strdup(argptr);
1170 result = CURLE_OUT_OF_MEMORY;
1174 if(checkprefix("Set-Cookie:", argptr))
1175 /* HTTP Header format line */
1176 Curl_cookie_add(data, data->cookies, TRUE, argptr + 11, NULL, NULL);
1179 /* Netscape format line */
1180 Curl_cookie_add(data, data->cookies, FALSE, argptr, NULL, NULL);
1185 Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
1188 #endif /* CURL_DISABLE_COOKIES */
1190 case CURLOPT_HTTPGET:
1192 * Set to force us do HTTP GET
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 */
1201 case CURLOPT_HTTP_VERSION:
1203 * This sets a requested HTTP version to be used. The value is one of
1204 * the listed enums in curl/curl.h.
1206 arg = va_arg(param, long);
1208 if(arg == CURL_HTTP_VERSION_2_0)
1209 return CURLE_UNSUPPORTED_PROTOCOL;
1211 data->set.httpversion = arg;
1214 case CURLOPT_HTTPAUTH:
1216 * Set HTTP Authentication type BITMASK.
1221 unsigned long auth = va_arg(param, unsigned long);
1223 if(auth == CURLAUTH_NONE) {
1224 data->set.httpauth = auth;
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;
1232 if(auth & CURLAUTH_DIGEST_IE) {
1233 auth |= CURLAUTH_DIGEST; /* set standard digest bit */
1234 auth &= ~CURLAUTH_DIGEST_IE; /* unset ie digest bit */
1237 /* switch off bits we can't support */
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 */
1244 #ifndef USE_HTTP_NEGOTIATE
1245 auth &= ~CURLAUTH_GSSNEGOTIATE; /* no GSS-Negotiate without GSSAPI or
1249 /* check if any auth bit lower than CURLAUTH_ONLY is still set */
1252 while(bitcheck < 31) {
1253 if(auth & (1UL << bitcheck++)) {
1259 return CURLE_NOT_BUILT_IN; /* no supported types left! */
1261 data->set.httpauth = auth;
1265 #endif /* CURL_DISABLE_HTTP */
1267 case CURLOPT_CUSTOMREQUEST:
1269 * Set a custom string to use as request
1271 result = setstropt(&data->set.str[STRING_CUSTOMREQUEST],
1272 va_arg(param, char *));
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 */
1280 #ifndef CURL_DISABLE_PROXY
1281 case CURLOPT_HTTPPROXYTUNNEL:
1283 * Tunnel operations through the proxy instead of normal proxy use
1285 data->set.tunnel_thru_httpproxy = (0 != va_arg(param, long))?TRUE:FALSE;
1288 case CURLOPT_PROXYPORT:
1290 * Explicitly set HTTP proxy port number.
1292 data->set.proxyport = va_arg(param, long);
1295 case CURLOPT_PROXYAUTH:
1297 * Set HTTP Authentication type BITMASK.
1302 unsigned long auth = va_arg(param, unsigned long);
1304 if(auth == CURLAUTH_NONE) {
1305 data->set.proxyauth = auth;
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;
1313 if(auth & CURLAUTH_DIGEST_IE) {
1314 auth |= CURLAUTH_DIGEST; /* set standard digest bit */
1315 auth &= ~CURLAUTH_DIGEST_IE; /* unset ie digest bit */
1317 /* switch off bits we can't support */
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 */
1324 #ifndef USE_HTTP_NEGOTIATE
1325 auth &= ~CURLAUTH_GSSNEGOTIATE; /* no GSS-Negotiate without GSSAPI or
1329 /* check if any auth bit lower than CURLAUTH_ONLY is still set */
1332 while(bitcheck < 31) {
1333 if(auth & (1UL << bitcheck++)) {
1339 return CURLE_NOT_BUILT_IN; /* no supported types left! */
1341 data->set.proxyauth = auth;
1347 * Set proxy server:port to use as HTTP proxy.
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).
1352 * Setting it to NULL, means no proxy but allows the environment variables
1355 result = setstropt(&data->set.str[STRING_PROXY],
1356 va_arg(param, char *));
1359 case CURLOPT_PROXYTYPE:
1361 * Set proxy type. HTTP/HTTP_1_0/SOCKS4/SOCKS4a/SOCKS5/SOCKS5_HOSTNAME
1363 data->set.proxytype = (curl_proxytype)va_arg(param, long);
1366 case CURLOPT_PROXY_TRANSFER_MODE:
1368 * set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy
1370 switch (va_arg(param, long)) {
1372 data->set.proxy_transfer_mode = FALSE;
1375 data->set.proxy_transfer_mode = TRUE;
1378 /* reserve other values for future use */
1379 result = CURLE_UNKNOWN_OPTION;
1383 #endif /* CURL_DISABLE_PROXY */
1385 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
1386 case CURLOPT_SOCKS5_GSSAPI_SERVICE:
1388 * Set gssapi service name
1390 result = setstropt(&data->set.str[STRING_SOCKS5_GSSAPI_SERVICE],
1391 va_arg(param, char *));
1394 case CURLOPT_SOCKS5_GSSAPI_NEC:
1396 * set flag for nec socks5 support
1398 data->set.socks5_gssapi_nec = (0 != va_arg(param, long))?TRUE:FALSE;
1402 case CURLOPT_WRITEHEADER:
1404 * Custom pointer to pass the header write callback function
1406 data->set.writeheader = (void *)va_arg(param, void *);
1408 case CURLOPT_ERRORBUFFER:
1410 * Error buffer provided by the caller to get the human readable
1413 data->set.errorbuffer = va_arg(param, char *);
1417 * FILE pointer to write to. Or possibly
1418 * used as argument to the write callback.
1420 data->set.out = va_arg(param, void *);
1422 case CURLOPT_FTPPORT:
1424 * Use FTP PORT, this also specifies which IP address to use
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]) ?
1432 case CURLOPT_FTP_USE_EPRT:
1433 data->set.ftp_use_eprt = (0 != va_arg(param, long))?TRUE:FALSE;
1436 case CURLOPT_FTP_USE_EPSV:
1437 data->set.ftp_use_epsv = (0 != va_arg(param, long))?TRUE:FALSE;
1440 case CURLOPT_FTP_USE_PRET:
1441 data->set.ftp_use_pret = (0 != va_arg(param, long))?TRUE:FALSE;
1444 case CURLOPT_FTP_SSL_CCC:
1445 data->set.ftp_ccc = (curl_ftpccc)va_arg(param, long);
1448 case CURLOPT_FTP_SKIP_PASV_IP:
1450 * Enable or disable FTP_SKIP_PASV_IP, which will disable/enable the
1451 * bypass of the IP address in PASV responses.
1453 data->set.ftp_skip_ip = (0 != va_arg(param, long))?TRUE:FALSE;
1456 case CURLOPT_INFILE:
1458 * FILE pointer to read the file to be uploaded from. Or possibly
1459 * used as argument to the read callback.
1461 data->set.in = va_arg(param, void *);
1463 case CURLOPT_INFILESIZE:
1465 * If known, this should inform curl about the file size of the
1466 * to-be-uploaded file.
1468 data->set.infilesize = va_arg(param, long);
1470 case CURLOPT_INFILESIZE_LARGE:
1472 * If known, this should inform curl about the file size of the
1473 * to-be-uploaded file.
1475 data->set.infilesize = va_arg(param, curl_off_t);
1477 case CURLOPT_LOW_SPEED_LIMIT:
1479 * The low speed limit that if transfers are below this for
1480 * CURLOPT_LOW_SPEED_TIME, the transfer is aborted.
1482 data->set.low_speed_limit=va_arg(param, long);
1484 case CURLOPT_MAX_SEND_SPEED_LARGE:
1486 * When transfer uploads are faster then CURLOPT_MAX_SEND_SPEED_LARGE
1487 * bytes per second the transfer is throttled..
1489 data->set.max_send_speed=va_arg(param, curl_off_t);
1491 case CURLOPT_MAX_RECV_SPEED_LARGE:
1493 * When receiving data faster than CURLOPT_MAX_RECV_SPEED_LARGE bytes per
1494 * second the transfer is throttled..
1496 data->set.max_recv_speed=va_arg(param, curl_off_t);
1498 case CURLOPT_LOW_SPEED_TIME:
1500 * The low speed time that if transfers are below the set
1501 * CURLOPT_LOW_SPEED_LIMIT during this time, the transfer is aborted.
1503 data->set.low_speed_time=va_arg(param, long);
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;
1514 result = setstropt(&data->set.str[STRING_SET_URL],
1515 va_arg(param, char *));
1516 data->change.url = data->set.str[STRING_SET_URL];
1520 * The port number to use when getting the URL
1522 data->set.use_port = va_arg(param, long);
1524 case CURLOPT_TIMEOUT:
1526 * The maximum time you allow curl to use for a single transfer
1529 data->set.timeout = va_arg(param, long) * 1000L;
1532 case CURLOPT_TIMEOUT_MS:
1533 data->set.timeout = va_arg(param, long);
1536 case CURLOPT_CONNECTTIMEOUT:
1538 * The maximum time you allow curl to use to connect.
1540 data->set.connecttimeout = va_arg(param, long) * 1000L;
1543 case CURLOPT_CONNECTTIMEOUT_MS:
1544 data->set.connecttimeout = va_arg(param, long);
1547 case CURLOPT_ACCEPTTIMEOUT_MS:
1549 * The maximum time you allow curl to wait for server connect
1551 data->set.accepttimeout = va_arg(param, long);
1554 case CURLOPT_USERPWD:
1556 * user:password;options to use in the operation
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]);
1563 case CURLOPT_USERNAME:
1565 * authentication user name to use in the operation
1567 result = setstropt(&data->set.str[STRING_USERNAME],
1568 va_arg(param, char *));
1570 case CURLOPT_PASSWORD:
1572 * authentication password to use in the operation
1574 result = setstropt(&data->set.str[STRING_PASSWORD],
1575 va_arg(param, char *));
1577 case CURLOPT_XOAUTH2_BEARER:
1579 * XOAUTH2 bearer token to use in the operation
1581 result = setstropt(&data->set.str[STRING_BEARER],
1582 va_arg(param, char *));
1584 case CURLOPT_POSTQUOTE:
1586 * List of RAW FTP commands to use after a transfer
1588 data->set.postquote = va_arg(param, struct curl_slist *);
1590 case CURLOPT_PREQUOTE:
1592 * List of RAW FTP commands to use prior to RETR (Wesley Laxton)
1594 data->set.prequote = va_arg(param, struct curl_slist *);
1598 * List of RAW FTP commands to use before a transfer
1600 data->set.quote = va_arg(param, struct curl_slist *);
1602 case CURLOPT_RESOLVE:
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.
1607 * Names added with this API will remain in the cache until explicitly
1608 * removed or the handle is cleaned up.
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.
1613 data->set.resolve = va_arg(param, struct curl_slist *);
1614 data->change.resolve = data->set.resolve;
1616 case CURLOPT_PROGRESSFUNCTION:
1618 * Progress callback function
1620 data->set.fprogress = va_arg(param, curl_progress_callback);
1621 if(data->set.fprogress)
1622 data->progress.callback = TRUE; /* no longer internal */
1624 data->progress.callback = FALSE; /* NULL enforces internal */
1627 case CURLOPT_XFERINFOFUNCTION:
1629 * Transfer info callback function
1631 data->set.fxferinfo = va_arg(param, curl_xferinfo_callback);
1632 if(data->set.fxferinfo)
1633 data->progress.callback = TRUE; /* no longer internal */
1635 data->progress.callback = FALSE; /* NULL enforces internal */
1639 case CURLOPT_PROGRESSDATA:
1641 * Custom client data to pass to the progress callback
1643 data->set.progress_client = va_arg(param, void *);
1646 #ifndef CURL_DISABLE_PROXY
1647 case CURLOPT_PROXYUSERPWD:
1649 * user:password needed to use the proxy
1651 result = setstropt_userpwd(va_arg(param, char *),
1652 &data->set.str[STRING_PROXYUSERNAME],
1653 &data->set.str[STRING_PROXYPASSWORD], NULL);
1655 case CURLOPT_PROXYUSERNAME:
1657 * authentication user name to use in the operation
1659 result = setstropt(&data->set.str[STRING_PROXYUSERNAME],
1660 va_arg(param, char *));
1662 case CURLOPT_PROXYPASSWORD:
1664 * authentication password to use in the operation
1666 result = setstropt(&data->set.str[STRING_PROXYPASSWORD],
1667 va_arg(param, char *));
1669 case CURLOPT_NOPROXY:
1671 * proxy exception list
1673 result = setstropt(&data->set.str[STRING_NOPROXY],
1674 va_arg(param, char *));
1680 * What range of the file you want to transfer
1682 result = setstropt(&data->set.str[STRING_SET_RANGE],
1683 va_arg(param, char *));
1685 case CURLOPT_RESUME_FROM:
1687 * Resume transfer at the give file position
1689 data->set.set_resume_from = va_arg(param, long);
1691 case CURLOPT_RESUME_FROM_LARGE:
1693 * Resume transfer at the give file position
1695 data->set.set_resume_from = va_arg(param, curl_off_t);
1697 case CURLOPT_DEBUGFUNCTION:
1699 * stderr write callback.
1701 data->set.fdebug = va_arg(param, curl_debug_callback);
1703 * if the callback provided is NULL, it'll use the default callback
1706 case CURLOPT_DEBUGDATA:
1708 * Set to a void * that should receive all error writes. This
1709 * defaults to CURLOPT_STDERR for normal operations.
1711 data->set.debugdata = va_arg(param, void *);
1713 case CURLOPT_STDERR:
1715 * Set to a FILE * that should receive all error writes. This
1716 * defaults to stderr for normal operations.
1718 data->set.err = va_arg(param, FILE *);
1720 data->set.err = stderr;
1722 case CURLOPT_HEADERFUNCTION:
1724 * Set header write callback
1726 data->set.fwrite_header = va_arg(param, curl_write_callback);
1728 case CURLOPT_WRITEFUNCTION:
1730 * Set data write callback
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;
1739 data->set.is_fwrite_set = 1;
1741 case CURLOPT_READFUNCTION:
1743 * Read data callback
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;
1752 data->set.is_fread_set = 1;
1754 case CURLOPT_SEEKFUNCTION:
1756 * Seek callback. Might be NULL.
1758 data->set.seek_func = va_arg(param, curl_seek_callback);
1760 case CURLOPT_SEEKDATA:
1762 * Seek control callback. Might be NULL.
1764 data->set.seek_client = va_arg(param, void *);
1766 case CURLOPT_CONV_FROM_NETWORK_FUNCTION:
1768 * "Convert from network encoding" callback
1770 data->set.convfromnetwork = va_arg(param, curl_conv_callback);
1772 case CURLOPT_CONV_TO_NETWORK_FUNCTION:
1774 * "Convert to network encoding" callback
1776 data->set.convtonetwork = va_arg(param, curl_conv_callback);
1778 case CURLOPT_CONV_FROM_UTF8_FUNCTION:
1780 * "Convert from UTF-8 encoding" callback
1782 data->set.convfromutf8 = va_arg(param, curl_conv_callback);
1784 case CURLOPT_IOCTLFUNCTION:
1786 * I/O control callback. Might be NULL.
1788 data->set.ioctl_func = va_arg(param, curl_ioctl_callback);
1790 case CURLOPT_IOCTLDATA:
1792 * I/O control data pointer. Might be NULL.
1794 data->set.ioctl_client = va_arg(param, void *);
1796 case CURLOPT_SSLCERT:
1798 * String that holds file name of the SSL certificate to use
1800 result = setstropt(&data->set.str[STRING_CERT],
1801 va_arg(param, char *));
1803 case CURLOPT_SSLCERTTYPE:
1805 * String that holds file type of the SSL certificate to use
1807 result = setstropt(&data->set.str[STRING_CERT_TYPE],
1808 va_arg(param, char *));
1810 case CURLOPT_SSLKEY:
1812 * String that holds file name of the SSL key to use
1814 result = setstropt(&data->set.str[STRING_KEY],
1815 va_arg(param, char *));
1817 case CURLOPT_SSLKEYTYPE:
1819 * String that holds file type of the SSL key to use
1821 result = setstropt(&data->set.str[STRING_KEY_TYPE],
1822 va_arg(param, char *));
1824 case CURLOPT_KEYPASSWD:
1826 * String that holds the SSL or SSH private key password.
1828 result = setstropt(&data->set.str[STRING_KEY_PASSWD],
1829 va_arg(param, char *));
1831 case CURLOPT_SSLENGINE:
1833 * String that holds the SSL crypto engine.
1835 argptr = va_arg(param, char *);
1836 if(argptr && argptr[0])
1837 result = Curl_ssl_set_engine(data, argptr);
1840 case CURLOPT_SSLENGINE_DEFAULT:
1842 * flag to set engine as default.
1844 result = Curl_ssl_set_engine_default(data);
1848 * Kludgy option to enable CRLF conversions. Subject for removal.
1850 data->set.crlf = (0 != va_arg(param, long))?TRUE:FALSE;
1853 case CURLOPT_INTERFACE:
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.
1858 result = setstropt(&data->set.str[STRING_DEVICE],
1859 va_arg(param, char *));
1861 case CURLOPT_LOCALPORT:
1863 * Set what local port to bind the socket to when performing an operation.
1865 data->set.localport = curlx_sltous(va_arg(param, long));
1867 case CURLOPT_LOCALPORTRANGE:
1869 * Set number of local ports to try, starting with CURLOPT_LOCALPORT.
1871 data->set.localportrange = curlx_sltosi(va_arg(param, long));
1873 case CURLOPT_KRBLEVEL:
1875 * A string that defines the kerberos security level.
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;
1881 case CURLOPT_GSSAPI_DELEGATION:
1883 * GSSAPI credential delegation
1885 data->set.gssapi_delegation = va_arg(param, long);
1887 case CURLOPT_SSL_VERIFYPEER:
1889 * Enable peer SSL verifying.
1891 data->set.ssl.verifypeer = (0 != va_arg(param, long))?TRUE:FALSE;
1893 case CURLOPT_SSL_VERIFYHOST:
1895 * Enable verification of the host name in the peer certificate
1897 arg = va_arg(param, long);
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. */
1905 failf(data, "CURLOPT_SSL_VERIFYHOST no longer supports 1 as value!");
1906 return CURLE_BAD_FUNCTION_ARGUMENT;
1909 data->set.ssl.verifyhost = (0 != arg)?TRUE:FALSE;
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:
1918 * Set a SSL_CTX callback
1920 data->set.ssl.fsslctx = va_arg(param, curl_ssl_ctx_callback);
1922 case CURLOPT_SSL_CTX_DATA:
1924 * Set a SSL_CTX callback parameter pointer
1926 data->set.ssl.fsslctxp = va_arg(param, void *);
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;
1934 case CURLOPT_CAINFO:
1936 * Set CA info for SSL connection. Specify file name of the CA certificate
1938 result = setstropt(&data->set.str[STRING_SSL_CAFILE],
1939 va_arg(param, char *));
1941 case CURLOPT_CAPATH:
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.
1946 /* This does not work on windows. */
1947 result = setstropt(&data->set.str[STRING_SSL_CAPATH],
1948 va_arg(param, char *));
1950 case CURLOPT_CRLFILE:
1952 * Set CRL file info for SSL connection. Specify file name of the CRL
1953 * to check certificates revocation
1955 result = setstropt(&data->set.str[STRING_SSL_CRLFILE],
1956 va_arg(param, char *));
1958 case CURLOPT_ISSUERCERT:
1960 * Set Issuer certificate file
1961 * to check certificates issuer
1963 result = setstropt(&data->set.str[STRING_SSL_ISSUERCERT],
1964 va_arg(param, char *));
1966 case CURLOPT_TELNETOPTIONS:
1968 * Set a linked list of telnet options
1970 data->set.telnet_options = va_arg(param, struct curl_slist *);
1973 case CURLOPT_BUFFERSIZE:
1975 * The application kindly asks for a differently sized receive buffer.
1976 * If it seems reasonable, we'll use it.
1978 data->set.buffer_size = va_arg(param, long);
1980 if((data->set.buffer_size> (BUFSIZE -1 )) ||
1981 (data->set.buffer_size < 1))
1982 data->set.buffer_size = 0; /* huge internal default */
1986 case CURLOPT_NOSIGNAL:
1988 * The application asks not to set any signal() or alarm() handlers,
1989 * even when using a timeout.
1991 data->set.no_signal = (0 != va_arg(param, long))?TRUE:FALSE;
1996 struct Curl_share *set;
1997 set = va_arg(param, struct Curl_share *);
1999 /* disconnect from old share, if any */
2001 Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
2003 if(data->dns.hostcachetype == HCACHE_SHARED) {
2004 data->dns.hostcache = NULL;
2005 data->dns.hostcachetype = HCACHE_NONE;
2008 #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
2009 if(data->share->cookies == data->cookies)
2010 data->cookies = NULL;
2013 if(data->share->sslsession == data->state.session)
2014 data->state.session = NULL;
2016 data->share->dirty--;
2018 Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
2022 /* use new share if it set */
2026 Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
2028 data->share->dirty++;
2030 if(data->share->hostcache) {
2031 /* use shared host cache */
2032 data->dns.hostcache = data->share->hostcache;
2033 data->dns.hostcachetype = HCACHE_SHARED;
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 */
2039 Curl_cookie_cleanup(data->cookies);
2040 /* enable cookies since we now use a share that uses cookies! */
2041 data->cookies = data->share->cookies;
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;
2048 Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
2051 /* check for host cache not needed,
2052 * it will be done by curl_easy_perform */
2056 case CURLOPT_PRIVATE:
2058 * Set private data pointer.
2060 data->set.private_data = va_arg(param, void *);
2063 case CURLOPT_MAXFILESIZE:
2065 * Set the maximum size of a file to download.
2067 data->set.max_filesize = va_arg(param, long);
2071 case CURLOPT_USE_SSL:
2073 * Make transfers attempt to use SSL/TLS.
2075 data->set.use_ssl = (curl_usessl)va_arg(param, long);
2078 case CURLOPT_SSL_OPTIONS:
2079 arg = va_arg(param, long);
2080 data->set.ssl_enable_beast = arg&CURLSSLOPT_ALLOW_BEAST?TRUE:FALSE;
2084 case CURLOPT_FTPSSLAUTH:
2086 * Set a specific auth for FTP-SSL transfers.
2088 data->set.ftpsslauth = (curl_ftpauth)va_arg(param, long);
2091 case CURLOPT_IPRESOLVE:
2092 data->set.ipver = va_arg(param, long);
2095 case CURLOPT_MAXFILESIZE_LARGE:
2097 * Set the maximum size of a file to download.
2099 data->set.max_filesize = va_arg(param, curl_off_t);
2102 case CURLOPT_TCP_NODELAY:
2104 * Enable or disable TCP_NODELAY, which will disable/enable the Nagle
2107 data->set.tcp_nodelay = (0 != va_arg(param, long))?TRUE:FALSE;
2110 case CURLOPT_FTP_ACCOUNT:
2111 result = setstropt(&data->set.str[STRING_FTP_ACCOUNT],
2112 va_arg(param, char *));
2115 case CURLOPT_IGNORE_CONTENT_LENGTH:
2116 data->set.ignorecl = (0 != va_arg(param, long))?TRUE:FALSE;
2119 case CURLOPT_CONNECT_ONLY:
2121 * No data transfer, set up connection and let application use the socket
2123 data->set.connect_only = (0 != va_arg(param, long))?TRUE:FALSE;
2126 case CURLOPT_FTP_ALTERNATIVE_TO_USER:
2127 result = setstropt(&data->set.str[STRING_FTP_ALTERNATIVE_TO_USER],
2128 va_arg(param, char *));
2131 case CURLOPT_SOCKOPTFUNCTION:
2133 * socket callback function: called after socket() but before connect()
2135 data->set.fsockopt = va_arg(param, curl_sockopt_callback);
2138 case CURLOPT_SOCKOPTDATA:
2140 * socket callback data pointer. Might be NULL.
2142 data->set.sockopt_client = va_arg(param, void *);
2145 case CURLOPT_OPENSOCKETFUNCTION:
2147 * open/create socket callback function: called instead of socket(),
2150 data->set.fopensocket = va_arg(param, curl_opensocket_callback);
2153 case CURLOPT_OPENSOCKETDATA:
2155 * socket callback data pointer. Might be NULL.
2157 data->set.opensocket_client = va_arg(param, void *);
2160 case CURLOPT_CLOSESOCKETFUNCTION:
2162 * close socket callback function: called instead of close()
2163 * when shutting down a connection
2165 data->set.fclosesocket = va_arg(param, curl_closesocket_callback);
2168 case CURLOPT_CLOSESOCKETDATA:
2170 * socket callback data pointer. Might be NULL.
2172 data->set.closesocket_client = va_arg(param, void *);
2175 case CURLOPT_SSL_SESSIONID_CACHE:
2176 data->set.ssl.sessionid = (0 != va_arg(param, long))?TRUE:FALSE;
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);
2185 case CURLOPT_SSH_PUBLIC_KEYFILE:
2187 * Use this file instead of the $HOME/.ssh/id_dsa.pub file
2189 result = setstropt(&data->set.str[STRING_SSH_PUBLIC_KEY],
2190 va_arg(param, char *));
2193 case CURLOPT_SSH_PRIVATE_KEYFILE:
2195 * Use this file instead of the $HOME/.ssh/id_dsa file
2197 result = setstropt(&data->set.str[STRING_SSH_PRIVATE_KEY],
2198 va_arg(param, char *));
2200 case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
2202 * Option to allow for the MD5 of the host public key to be checked
2203 * for validation purposes.
2205 result = setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5],
2206 va_arg(param, char *));
2208 #ifdef HAVE_LIBSSH2_KNOWNHOST_API
2209 case CURLOPT_SSH_KNOWNHOSTS:
2211 * Store the file name to read known hosts from.
2213 result = setstropt(&data->set.str[STRING_SSH_KNOWNHOSTS],
2214 va_arg(param, char *));
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);
2223 case CURLOPT_SSH_KEYDATA:
2225 * Custom client data to pass to the SSH keyfunc callback
2227 data->set.ssh_keyfunc_userp = va_arg(param, void *);
2229 #endif /* HAVE_LIBSSH2_KNOWNHOST_API */
2231 #endif /* USE_LIBSSH2 */
2233 case CURLOPT_HTTP_TRANSFER_DECODING:
2235 * disable libcurl transfer encoding is used
2237 data->set.http_te_skip = (0 == va_arg(param, long))?TRUE:FALSE;
2240 case CURLOPT_HTTP_CONTENT_DECODING:
2242 * raw data passed to the application when content encoding is used
2244 data->set.http_ce_skip = (0 == va_arg(param, long))?TRUE:FALSE;
2247 case CURLOPT_NEW_FILE_PERMS:
2249 * Uses these permissions instead of 0644
2251 data->set.new_file_perms = va_arg(param, long);
2254 case CURLOPT_NEW_DIRECTORY_PERMS:
2256 * Uses these permissions instead of 0755
2258 data->set.new_directory_perms = va_arg(param, long);
2261 case CURLOPT_ADDRESS_SCOPE:
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
2267 data->set.scope = curlx_sltoui(va_arg(param, long));
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);
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);
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 *));
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 *));
2298 case CURLOPT_MAIL_RCPT:
2299 /* Set the list of mail recipients */
2300 data->set.mail_rcpt = va_arg(param, struct curl_slist *);
2303 case CURLOPT_SASL_IR:
2304 /* Enable/disable SASL initial response */
2305 data->set.sasl_ir = (0 != va_arg(param, long)) ? TRUE : FALSE;
2308 case CURLOPT_RTSP_REQUEST:
2311 * Set the RTSP request method (OPTIONS, SETUP, PLAY, etc...)
2312 * Would this be better if the RTSPREQ_* were just moved into here?
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;
2321 case CURL_RTSPREQ_DESCRIBE:
2322 rtspreq = RTSPREQ_DESCRIBE;
2325 case CURL_RTSPREQ_ANNOUNCE:
2326 rtspreq = RTSPREQ_ANNOUNCE;
2329 case CURL_RTSPREQ_SETUP:
2330 rtspreq = RTSPREQ_SETUP;
2333 case CURL_RTSPREQ_PLAY:
2334 rtspreq = RTSPREQ_PLAY;
2337 case CURL_RTSPREQ_PAUSE:
2338 rtspreq = RTSPREQ_PAUSE;
2341 case CURL_RTSPREQ_TEARDOWN:
2342 rtspreq = RTSPREQ_TEARDOWN;
2345 case CURL_RTSPREQ_GET_PARAMETER:
2346 rtspreq = RTSPREQ_GET_PARAMETER;
2349 case CURL_RTSPREQ_SET_PARAMETER:
2350 rtspreq = RTSPREQ_SET_PARAMETER;
2353 case CURL_RTSPREQ_RECORD:
2354 rtspreq = RTSPREQ_RECORD;
2357 case CURL_RTSPREQ_RECEIVE:
2358 rtspreq = RTSPREQ_RECEIVE;
2361 rtspreq = RTSPREQ_NONE;
2364 data->set.rtspreq = rtspreq;
2369 case CURLOPT_RTSP_SESSION_ID:
2371 * Set the RTSP Session ID manually. Useful if the application is
2372 * resuming a previously established RTSP session
2374 result = setstropt(&data->set.str[STRING_RTSP_SESSION_ID],
2375 va_arg(param, char *));
2378 case CURLOPT_RTSP_STREAM_URI:
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.
2383 result = setstropt(&data->set.str[STRING_RTSP_STREAM_URI],
2384 va_arg(param, char *));
2387 case CURLOPT_RTSP_TRANSPORT:
2389 * The content of the Transport: header for the RTSP request
2391 result = setstropt(&data->set.str[STRING_RTSP_TRANSPORT],
2392 va_arg(param, char *));
2395 case CURLOPT_RTSP_CLIENT_CSEQ:
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.
2401 data->state.rtsp_next_client_CSeq = va_arg(param, long);
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);
2409 case CURLOPT_INTERLEAVEDATA:
2410 data->set.rtp_out = va_arg(param, void *);
2412 case CURLOPT_INTERLEAVEFUNCTION:
2413 /* Set the user defined RTP write function */
2414 data->set.fwrite_rtp = va_arg(param, curl_write_callback);
2417 case CURLOPT_WILDCARDMATCH:
2418 data->set.wildcardmatch = (0 != va_arg(param, long))?TRUE:FALSE;
2420 case CURLOPT_CHUNK_BGN_FUNCTION:
2421 data->set.chunk_bgn = va_arg(param, curl_chunk_bgn_callback);
2423 case CURLOPT_CHUNK_END_FUNCTION:
2424 data->set.chunk_end = va_arg(param, curl_chunk_end_callback);
2426 case CURLOPT_FNMATCH_FUNCTION:
2427 data->set.fnmatch = va_arg(param, curl_fnmatch_callback);
2429 case CURLOPT_CHUNK_DATA:
2430 data->wildcard.customptr = va_arg(param, void *);
2432 case CURLOPT_FNMATCH_DATA:
2433 data->set.fnmatch_data = va_arg(param, void *);
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 */
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 */
2448 case CURLOPT_TLSAUTH_TYPE:
2449 if(strnequal((char *)va_arg(param, char *), "SRP", strlen("SRP")))
2450 data->set.ssl.authtype = CURL_TLSAUTH_SRP;
2452 data->set.ssl.authtype = CURL_TLSAUTH_NONE;
2455 case CURLOPT_DNS_SERVERS:
2456 result = Curl_set_dns_servers(data, va_arg(param, char *));
2458 case CURLOPT_DNS_INTERFACE:
2459 result = Curl_set_dns_interface(data, va_arg(param, char *));
2461 case CURLOPT_DNS_LOCAL_IP4:
2462 result = Curl_set_dns_local_ip4(data, va_arg(param, char *));
2464 case CURLOPT_DNS_LOCAL_IP6:
2465 result = Curl_set_dns_local_ip6(data, va_arg(param, char *));
2468 case CURLOPT_TCP_KEEPALIVE:
2469 data->set.tcp_keepalive = (0 != va_arg(param, long))?TRUE:FALSE;
2471 case CURLOPT_TCP_KEEPIDLE:
2472 data->set.tcp_keepidle = va_arg(param, long);
2474 case CURLOPT_TCP_KEEPINTVL:
2475 data->set.tcp_keepintvl = va_arg(param, long);
2479 /* unknown tag and its companion, just ignore: */
2480 result = CURLE_UNKNOWN_OPTION;
2487 static void conn_free(struct connectdata *conn)
2492 /* possible left-overs from the async name resolvers */
2493 Curl_resolver_cancel(conn);
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);
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]);
2506 #if defined(USE_NTLM) && defined(NTLM_WB_ENABLED)
2507 Curl_ntlm_wb_cleanup(conn);
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);
2531 Curl_llist_destroy(conn->send_pipe, NULL);
2532 Curl_llist_destroy(conn->recv_pipe, NULL);
2534 conn->send_pipe = NULL;
2535 conn->recv_pipe = NULL;
2537 Curl_safefree(conn->localdev);
2538 Curl_free_ssl_config(&conn->ssl_config);
2540 free(conn); /* free all the connection oriented data */
2543 CURLcode Curl_disconnect(struct connectdata *conn, bool dead_connection)
2545 struct SessionHandle *data;
2547 return CURLE_OK; /* this is closed and fine already */
2551 DEBUGF(fprintf(stderr, "DISCONNECT without easy handle, ignoring\n"));
2555 if(conn->dns_entry != NULL) {
2556 Curl_resolv_unlock(data, conn->dns_entry);
2557 conn->dns_entry = NULL;
2560 Curl_hostcache_prune(data); /* kill old DNS cache entries */
2563 int has_host_ntlm = (conn->ntlm.state != NTLMSTATE_NONE);
2564 int has_proxy_ntlm = (conn->proxyntlm.state != NTLMSTATE_NONE);
2566 /* Authentication data is a mix of connection-related and sessionhandle-
2567 related stuff. NTLM is connection-related so when we close the shop
2571 data->state.authhost.done = FALSE;
2572 data->state.authhost.picked =
2573 data->state.authhost.want;
2576 if(has_proxy_ntlm) {
2577 data->state.authproxy.done = FALSE;
2578 data->state.authproxy.picked =
2579 data->state.authproxy.want;
2582 if(has_host_ntlm || has_proxy_ntlm)
2583 data->state.authproblem = FALSE;
2586 /* Cleanup NTLM connection-related data */
2587 Curl_http_ntlm_cleanup(conn);
2589 /* Cleanup possible redirect junk */
2590 if(data->req.newurl) {
2591 free(data->req.newurl);
2592 data->req.newurl = NULL;
2595 if(conn->handler->disconnect)
2596 /* This is set if protocol-specific cleanups should be made */
2597 conn->handler->disconnect(conn, dead_connection);
2599 /* unlink ourselves! */
2600 infof(data, "Closing connection %ld\n", conn->connection_id);
2601 Curl_conncache_remove_conn(data->state.conn_cache, conn);
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
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 */
2622 Curl_ssl_close(conn, FIRSTSOCKET);
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);
2632 Curl_speedinit(data);
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.
2642 static bool SocketIsDead(curl_socket_t sock)
2645 bool ret_val = TRUE;
2647 sval = Curl_socket_ready(sock, CURL_SOCKET_BAD, 0);
2655 static bool IsPipeliningPossible(const struct SessionHandle *handle,
2656 const struct connectdata *conn)
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)
2668 bool Curl_isPipeliningEnabled(const struct SessionHandle *handle)
2670 return Curl_multi_pipeline_enabled(handle->multi);
2673 CURLcode Curl_addHandleToPipeline(struct SessionHandle *data,
2674 struct curl_llist *pipeline)
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);
2682 int Curl_removeHandleFromPipeline(struct SessionHandle *handle,
2683 struct curl_llist *pipeline)
2685 struct curl_llist_element *curr;
2687 curr = pipeline->head;
2689 if(curr->ptr == handle) {
2690 Curl_llist_remove(pipeline, curr, NULL);
2691 return 1; /* we removed a handle */
2699 #if 0 /* this code is saved here as it is useful for debugging purposes */
2700 static void Curl_printPipeline(struct curl_llist *pipeline)
2702 struct curl_llist_element *curr;
2704 curr = pipeline->head;
2706 struct SessionHandle *data = (struct SessionHandle *) curr->ptr;
2707 infof(data, "Handle in pipeline: %s\n", data->state.path);
2713 static struct SessionHandle* gethandleathead(struct curl_llist *pipeline)
2715 struct curl_llist_element *curr = pipeline->head;
2717 return (struct SessionHandle *) curr->ptr;
2723 /* remove the specified connection from all (possible) pipelines and related
2725 void Curl_getoff_all_pipelines(struct SessionHandle *data,
2726 struct connectdata *conn)
2728 bool recv_head = (conn->readchannel_inuse &&
2729 (gethandleathead(conn->recv_pipe) == data)) ? TRUE : FALSE;
2731 bool send_head = (conn->writechannel_inuse &&
2732 (gethandleathead(conn->send_pipe) == data)) ? TRUE : FALSE;
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;
2740 static void signalPipeClose(struct curl_llist *pipeline, bool pipe_broke)
2742 struct curl_llist_element *curr;
2747 curr = pipeline->head;
2749 struct curl_llist_element *next = curr->next;
2750 struct SessionHandle *data = (struct SessionHandle *) curr->ptr;
2752 #ifdef DEBUGBUILD /* debug-only code */
2753 if(data->magic != CURLEASY_MAGIC_NUMBER) {
2755 infof(data, "signalPipeClose() found BAAD easy handle\n");
2760 data->state.pipe_broke = TRUE;
2761 Curl_multi_handlePipeBreak(data);
2762 Curl_llist_remove(pipeline, curr, NULL);
2768 * This function finds the connection in the connection
2769 * cache that has been unused for the longest time.
2771 * Returns the pointer to the oldest idle connection, or NULL if none was
2774 static struct connectdata *
2775 find_oldest_idle_connection(struct SessionHandle *data)
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;
2784 struct connectdata *conn_candidate = NULL;
2785 struct connectbundle *bundle;
2789 Curl_hash_start_iterate(bc->hash, &iter);
2791 he = Curl_hash_next_element(&iter);
2793 struct connectdata *conn;
2797 curr = bundle->conn_list->head;
2802 /* Set higher score for the age passed since the connection was used */
2803 score = Curl_tvdiff(now, conn->now);
2805 if(score > highscore) {
2807 conn_candidate = conn;
2813 he = Curl_hash_next_element(&iter);
2816 return conn_candidate;
2820 * This function finds the connection in the connection
2821 * bundle that has been unused for the longest time.
2823 * Returns the pointer to the oldest idle connection, or NULL if none was
2826 static struct connectdata *
2827 find_oldest_idle_connection_in_bundle(struct SessionHandle *data,
2828 struct connectbundle *bundle)
2830 struct curl_llist_element *curr;
2834 struct connectdata *conn_candidate = NULL;
2835 struct connectdata *conn;
2841 curr = bundle->conn_list->head;
2846 /* Set higher score for the age passed since the connection was used */
2847 score = Curl_tvdiff(now, conn->now);
2849 if(score > highscore) {
2851 conn_candidate = conn;
2857 return conn_candidate;
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.
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.
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.
2873 ConnectionExists(struct SessionHandle *data,
2874 struct connectdata *needle,
2875 struct connectdata **usethis,
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;
2885 *force_reuse = FALSE;
2887 /* We can't pipe if the site is blacklisted */
2888 if(canPipeline && Curl_pipeline_site_blacklisted(data, needle)) {
2889 canPipeline = FALSE;
2892 /* Look up the bundle with all the connections to this
2894 bundle = Curl_conncache_find_bundle(data->state.conn_cache,
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;
2901 infof(data, "Found bundle for host %s: %p\n",
2902 needle->host.name, (void *)bundle);
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;
2910 curr = bundle->conn_list->head;
2913 bool credentialsMatch = FALSE;
2917 * Note that if we use a HTTP proxy, we check connections to that
2918 * proxy and not to the actual remote server.
2923 pipeLen = check->send_pipe->size + check->recv_pipe->size;
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
2930 if(check->handler->protocol & CURLPROTO_RTSP)
2931 /* RTSP is a special case due to RTP interleaving */
2932 dead = Curl_rtsp_connisdead(check);
2934 dead = SocketIsDead(check->sock[FIRSTSOCKET]);
2938 infof(data, "Connection %ld seems to be dead!\n",
2939 check->connection_id);
2941 /* disconnect resources */
2942 Curl_disconnect(check, /* dead_connection */ TRUE);
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);
2952 if(!IsPipeliningPossible(sh, check))
2956 if(!IsPipeliningPossible(rh, check))
2962 /* can only happen within multi handles, and means that another easy
2963 handle is using this connection */
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]) {
2972 "Connection #%ld is still name resolving, can't reuse\n",
2973 check->connection_id);
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
2982 infof(data, "Connection #%ld isn't open enough, can't reuse\n",
2983 check->connection_id);
2985 if(check->recv_pipe->size > 0) {
2987 "BAD! Unconnected #%ld has a non-empty recv pipeline!\n",
2988 check->connection_id);
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 */
3002 if(needle->handler->flags&PROTOPT_SSL) {
3003 if((data->set.ssl.verifypeer != check->verifypeer) ||
3004 (data->set.ssl.verifyhost != check->verifyhost))
3008 if(needle->bits.proxy != check->bits.proxy)
3009 /* don't do mixed proxy and non-proxy connections */
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 */
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.
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.
3029 if((check->localport != needle->localport) ||
3030 (check->localportrange != needle->localportrange) ||
3032 !needle->localdev ||
3033 strcmp(check->localdev, needle->localdev))
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 */
3046 credentialsMatch = TRUE;
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
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)) {
3069 "Connection #%ld has different SSL parameters, "
3071 check->connection_id));
3074 else if(check->ssl[FIRSTSOCKET].state != ssl_connection_complete) {
3076 "Connection #%ld has not started SSL connect, "
3078 check->connection_id));
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! */
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
3104 if(credentialsMatch && check->ntlm.state != NTLMSTATE_NONE) {
3107 /* We must use this connection, no other */
3108 *force_reuse = TRUE;
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
3121 /* We have the optimal connection. Let's stop looking. */
3126 /* We can't use the connection if the pipe is full */
3127 if(pipeLen >= max_pipe_len)
3130 /* We can't use the connection if the pipe is penalized */
3131 if(Curl_pipeline_penalized(data, check))
3134 if(pipeLen < best_pipe_len) {
3135 /* This connection has a shorter pipe so far. We'll pick this
3136 and continue searching */
3138 best_pipe_len = pipeLen;
3143 /* We have found a connection. Let's stop searching. */
3153 return TRUE; /* yes, we found one to use! */
3156 return FALSE; /* no matching connecting exists */
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. */
3162 ConnectionDone(struct SessionHandle *data, struct connectdata *conn)
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;
3169 /* Mark the current connection as 'unused' */
3170 conn->inuse = FALSE;
3172 if(maxconnects > 0 &&
3173 data->state.conn_cache->num_connections > maxconnects) {
3174 infof(data, "Connection cache is full, closing the oldest one.\n");
3176 conn_candidate = find_oldest_idle_connection(data);
3178 if(conn_candidate) {
3179 /* Set the connection's owner correctly */
3180 conn_candidate->data = data;
3182 /* the winner gets the honour of being disconnected */
3183 (void)Curl_disconnect(conn_candidate, /* dead_connection */ FALSE);
3187 return (conn_candidate == conn) ? FALSE : TRUE;
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.
3195 * The given connection should be unique. That must've been checked prior to
3198 static CURLcode ConnectionStore(struct SessionHandle *data,
3199 struct connectdata *conn)
3201 static int connection_id_counter = 0;
3205 /* Assign a number to the connection for easier tracking in the log
3207 conn->connection_id = connection_id_counter++;
3209 result = Curl_conncache_add_conn(data->state.conn_cache, conn);
3210 if(result != CURLE_OK)
3211 conn->connection_id = -1;
3216 /* after a TCP connection to the proxy has been verified, this function does
3217 the next magic step.
3219 Note: this function's sub-functions call failf()
3222 CURLcode Curl_connected_proxy(struct connectdata *conn,
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 */
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,
3238 case CURLPROXY_SOCKS4:
3239 return Curl_SOCKS4(conn->proxyuser, conn->host.name,
3240 conn->remote_port, FIRSTSOCKET, conn, FALSE);
3242 case CURLPROXY_SOCKS4A:
3243 return Curl_SOCKS4(conn->proxyuser, conn->host.name,
3244 conn->remote_port, FIRSTSOCKET, conn, TRUE);
3246 #endif /* CURL_DISABLE_PROXY */
3247 case CURLPROXY_HTTP:
3248 case CURLPROXY_HTTP_1_0:
3249 /* do nothing here. handled later. */
3253 } /* switch proxytype */
3258 static CURLcode ConnectPlease(struct SessionHandle *data,
3259 struct connectdata *conn,
3263 Curl_addrinfo *addr;
3264 #ifndef CURL_DISABLE_VERBOSE_STRINGS
3265 char *hostname = conn->bits.proxy?conn->proxy.name:conn->host.name;
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);
3274 /*************************************************************
3275 * Connect to server/proxy
3276 *************************************************************/
3277 result= Curl_connecthost(conn,
3279 &conn->sock[FIRSTSOCKET],
3282 if(CURLE_OK == result) {
3283 /* All is cool, we store the current information */
3284 conn->ip_addr = addr;
3287 result = Curl_connected_proxy(conn, FIRSTSOCKET);
3289 conn->bits.tcpconnect[FIRSTSOCKET] = TRUE;
3290 Curl_pgrsTime(data, TIMER_CONNECT); /* connect done */
3296 *connected = FALSE; /* mark it as not connected */
3302 * verboseconnect() displays verbose information after a connect
3304 #ifndef CURL_DISABLE_VERBOSE_STRINGS
3305 void Curl_verboseconnect(struct connectdata *conn)
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);
3314 int Curl_protocol_getsock(struct connectdata *conn,
3315 curl_socket_t *socks,
3318 if(conn->handler->proto_getsock)
3319 return conn->handler->proto_getsock(conn, socks, numsocks);
3320 return GETSOCK_BLANK;
3323 int Curl_doing_getsock(struct connectdata *conn,
3324 curl_socket_t *socks,
3327 if(conn && conn->handler->doing_getsock)
3328 return conn->handler->doing_getsock(conn, socks, numsocks);
3329 return GETSOCK_BLANK;
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
3338 CURLcode Curl_protocol_connecting(struct connectdata *conn,
3341 CURLcode result=CURLE_OK;
3343 if(conn && conn->handler->connecting) {
3345 result = conn->handler->connecting(conn, done);
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.
3358 CURLcode Curl_protocol_doing(struct connectdata *conn, bool *done)
3360 CURLcode result=CURLE_OK;
3362 if(conn && conn->handler->doing) {
3364 result = conn->handler->doing(conn, done);
3373 * We have discovered that the TCP connection has been successful, we can now
3374 * proceed with some action.
3377 CURLcode Curl_protocol_connect(struct connectdata *conn,
3378 bool *protocol_done)
3380 CURLcode result=CURLE_OK;
3382 *protocol_done = FALSE;
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.
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;
3397 if(!conn->bits.protoconnstart) {
3399 result = Curl_proxy_connect(conn);
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 */
3409 if(conn->handler->connect_it) {
3410 /* is there a protocol-specific connect() procedure? */
3412 /* Call the protocol-specific connect function */
3413 result = conn->handler->connect_it(conn, protocol_done);
3416 *protocol_done = TRUE;
3418 /* it has started, possibly even completed but that knowledge isn't stored
3421 conn->bits.protoconnstart = TRUE;
3424 return result; /* pass back status */
3428 * Helpers for IDNA convertions.
3430 static bool is_ASCII_name(const char *hostname)
3432 const unsigned char *ch = (const unsigned char*)hostname;
3443 * Check if characters in hostname is allowed in Top Level Domain.
3445 static bool tld_check_name(struct SessionHandle *data,
3446 const char *ace_hostname)
3449 char *uc_name = NULL;
3451 #ifndef CURL_DISABLE_VERBOSE_STRINGS
3452 const char *tld_errmsg = "<no msg>";
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)
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);
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 */
3478 if(rc != TLD_SUCCESS)
3486 * Perform any necessary IDN conversion of hostname
3488 static void fix_hostname(struct SessionHandle *data,
3489 struct connectdata *conn, struct hostname *host)
3494 #elif defined(CURL_DISABLE_VERBOSE_STRINGS)
3498 /* set the name we use to display the host name */
3499 host->dispname = host->name;
3500 if(!is_ASCII_name(host->name)) {
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));
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);
3518 host->encalloc = ace_hostname;
3519 /* change the name pointer to point to the encoded hostname */
3520 host->name = host->encalloc;
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);
3530 infof(data, "Failed to convert %s to ACE;\n",
3533 host->encalloc = ace_hostname;
3534 /* change the name pointer to point to the encoded hostname */
3535 host->name = host->encalloc;
3538 infof(data, "IDN support not present, can't parse Unicode domains\n");
3543 static void llist_dtor(void *user, void *element)
3551 * Allocate and initialize a new connectdata object.
3553 static struct connectdata *allocate_conn(struct SessionHandle *data)
3555 struct connectdata *conn = calloc(1, sizeof(struct connectdata));
3559 conn->handler = &Curl_handler_dummy; /* Be sure we have a handler defined
3560 already from start to avoid NULL
3561 situations and checks */
3563 /* and we setup a few fields in case we end up actually using this struct */
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 */
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;
3575 /* Store creation time to help future close decision making */
3576 conn->created = Curl_tvnow();
3578 conn->data = data; /* Setup the association between this connection
3579 and the SessionHandle */
3581 conn->proxytype = data->set.proxytype; /* type */
3583 #ifdef CURL_DISABLE_PROXY
3585 conn->bits.proxy = FALSE;
3586 conn->bits.httpproxy = FALSE;
3587 conn->bits.proxy_user_passwd = FALSE;
3588 conn->bits.tunnel_proxy = FALSE;
3590 #else /* CURL_DISABLE_PROXY */
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;
3603 #endif /* CURL_DISABLE_PROXY */
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;
3609 conn->verifypeer = data->set.ssl.verifypeer;
3610 conn->verifyhost = data->set.ssl.verifyhost;
3612 conn->ip_version = data->set.ipver;
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;
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)
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)
3636 conn->data_prot = PROT_CLEAR;
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]);
3645 conn->localportrange = data->set.localportrange;
3646 conn->localport = data->set.localport;
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;
3656 Curl_llist_destroy(conn->send_pipe, NULL);
3657 Curl_llist_destroy(conn->recv_pipe, NULL);
3659 conn->send_pipe = NULL;
3660 conn->recv_pipe = NULL;
3662 Curl_safefree(conn->master_buffer);
3663 Curl_safefree(conn->localdev);
3664 Curl_safefree(conn);
3668 static CURLcode findprotocol(struct SessionHandle *data,
3669 struct connectdata *conn,
3670 const char *protostr)
3672 const struct Curl_handler * const *pp;
3673 const struct Curl_handler *p;
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))
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))
3692 /* Perform setup complement if some. */
3693 conn->handler = conn->given = p;
3695 /* 'port' and 'remote_port' are set in setup_connection_internals() */
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,
3707 return CURLE_UNSUPPORTED_PROTOCOL;
3711 * Parse URL and fill in the relevant members of the connection struct.
3713 static CURLcode parseurlandfillconn(struct SessionHandle *data,
3714 struct connectdata *conn,
3716 char **userp, char **passwdp,
3721 char *path = data->state.path;
3727 bool rebuild_url = FALSE;
3729 *prot_missing = FALSE;
3731 /*************************************************************
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
3738 ************************************************************/
3739 if((2 == sscanf(data->change.url, "%15[^:]:%[^\n]",
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. */
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);
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
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, '/');
3762 /* there was a slash present
3764 RFC1738 (section 3.1, page 5) says:
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.
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.
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 */
3782 /* This cannot be made with strcpy, as the memory chunks overlap! */
3783 memmove(path, ptr, strlen(ptr)+1);
3787 protop = "file"; /* protocol string */
3793 if(2 > sscanf(data->change.url,
3794 "%15[^\n:]://%[^\n/?]%[^\n]",
3796 conn->host.name, path)) {
3799 * The URL was badly formatted, let's try the browser-style _without_
3800 * protocol specified like 'http://'.
3802 rc = sscanf(data->change.url, "%[^\n/?]%[^\n]", conn->host.name, path);
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!
3809 #if defined(__DJGPP__) && (DJGPP_MINOR == 4)
3810 if(!(rc == -1 && *conn->host.name))
3813 failf(data, "<url> malformed");
3814 return CURLE_URL_MALFORMAT;
3819 * Since there was no protocol part specified, we guess what protocol it
3820 * is based on the first letters of the server name.
3823 /* Note: if you add a new protocol, please update the list in
3824 * lib/version.c too! */
3826 if(checkprefix("FTP.", conn->host.name))
3828 else if(checkprefix("DICT.", conn->host.name))
3830 else if(checkprefix("LDAP.", conn->host.name))
3832 else if(checkprefix("IMAP.", conn->host.name))
3834 else if(checkprefix("SMTP.", conn->host.name))
3836 else if(checkprefix("POP3.", conn->host.name))
3842 *prot_missing = TRUE; /* not given in URL */
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 '/').
3852 at = strchr(conn->host.name, '@');
3854 query = strchr(at+1, '?');
3856 query = strchr(conn->host.name, '?');
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.
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.
3867 size_t hostlen = strlen(query);
3868 size_t pathlen = strlen(path);
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);
3874 /* now copy the trailing host part in front of the existing path */
3875 memcpy(path+1, query, hostlen);
3877 path[0]='/'; /* prepend the missing slash */
3880 *query=0; /* now cut off the hostname at the ? */
3883 /* if there's no path set, use a single slash */
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
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);
3901 /* sanitise paths and remove ../ and ./ sequences according to RFC3986 */
3902 char *newp = Curl_dedotdotify(path);
3904 return CURLE_OUT_OF_MEMORY;
3906 if(strcmp(newp, path)) {
3908 free(data->state.pathbuffer);
3909 data->state.pathbuffer = newp;
3910 data->state.path = newp;
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.
3926 size_t plen = strlen(path); /* new path, should be 1 byte longer than
3928 size_t urllen = strlen(data->change.url); /* original URL length */
3930 size_t prefixlen = strlen(conn->host.name);
3933 prefixlen += strlen(protop) + strlen("://");
3935 reurl = malloc(urllen + 2); /* 2 for zerobyte + slash */
3937 return CURLE_OUT_OF_MEMORY;
3939 /* copy the prefix */
3940 memcpy(reurl, data->change.url, prefixlen);
3942 /* append the trailing piece + zerobyte */
3943 memcpy(&reurl[prefixlen], path, plen + 1);
3945 /* possible free the old one */
3946 if(data->change.url_alloc) {
3947 Curl_safefree(data->change.url);
3948 data->change.url_alloc = FALSE;
3951 infof(data, "Rebuilt URL to: %s\n", reurl);
3953 data->change.url = reurl;
3954 data->change.url_alloc = TRUE; /* free this later */
3958 * Parse the login details from the URL and strip them out of
3961 result = parse_url_login(data, conn, userp, passwdp, optionsp);
3962 if(result != CURLE_OK)
3965 if(conn->host.name[0] == '[') {
3966 /* This looks like an IPv6 address literal. See if there is an address
3968 char *percent = strstr (conn->host.name, "%25");
3971 unsigned long scope = strtoul (percent + 3, &endp, 10);
3973 /* The address scope was well formed. Knock it out of the
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;
3981 infof(data, "Invalid IPv6 address format\n");
3986 /* Override any scope that was set above. */
3987 conn->scope = data->set.scope;
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, '#');
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
3999 fragment = strchr(data->change.url, '#');
4005 * So if the URL was A://B/C#D,
4007 * conn->host.name is B
4008 * data->state.path is /C
4011 return findprotocol(data, conn, protop);
4015 * If we're doing a resumed transfer, we need to setup our stuff
4018 static CURLcode setup_range(struct SessionHandle *data)
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)
4027 s->range = aprintf("%" FORMAT_OFF_TU "-", s->resume_from);
4029 s->range = strdup(data->set.str[STRING_SET_RANGE]);
4031 s->rangestringalloc = (s->range)?TRUE:FALSE;
4034 return CURLE_OUT_OF_MEMORY;
4036 /* tell ourselves to fetch this range */
4037 s->use_range = TRUE; /* enable range download */
4040 s->use_range = FALSE; /* disable range download */
4047 * setup_connection_internals() -
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.
4053 * This MUST get called after proxy magic has been figured out.
4055 static CURLcode setup_connection_internals(struct connectdata *conn)
4057 const struct Curl_handler * p;
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);
4067 memset(&conn->data->req, 0, sizeof(struct SingleRequest));
4068 conn->data->req.maxdownload = -1;
4070 conn->socktype = SOCK_STREAM; /* most of them are TCP streams */
4072 /* Perform setup complement if some. */
4075 if(p->setup_connection) {
4076 result = (*p->setup_connection)(conn);
4078 if(result != CURLE_OK)
4081 p = conn->handler; /* May have changed. */
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;
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;
4098 * Curl_free_request_state() should free temp data that was allocated in the
4099 * SessionHandle for this single request.
4102 void Curl_free_request_state(struct SessionHandle *data)
4104 Curl_safefree(data->req.protop);
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)
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)
4122 const char* separator = ", ";
4123 size_t no_proxy_len;
4127 if(no_proxy && no_proxy[0]) {
4128 if(Curl_raw_equal("*", no_proxy)) {
4132 /* NO_PROXY was specified and it wasn't just an asterisk */
4134 no_proxy_len = strlen(no_proxy);
4135 endptr = strchr(name, ':');
4137 namelen = endptr - name;
4139 namelen = strlen(name);
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. */
4148 if(tok_start == no_proxy_len)
4149 break; /* It was all trailing separator chars, no more tokens. */
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. */
4156 /* To match previous behaviour, where it was necessary to specify
4157 * ".local.com" to prevent matching "notlocal.com", we will leave
4160 if(no_proxy[tok_start] == '.')
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.
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 */
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)
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:
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.)
4207 * For compatibility, the all-uppercase versions of these variables are
4208 * checked if the lowercase versions don't exist.
4210 char *no_proxy=NULL;
4211 char proxy_env[128];
4213 no_proxy=curl_getenv("no_proxy");
4215 no_proxy=curl_getenv("NO_PROXY");
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;
4223 /* Now, build <protocol>_proxy and check for such a one to use */
4225 *envp++ = (char)tolower((int)*protop++);
4228 strcpy(envp, "_proxy");
4230 /* read the protocol proxy: */
4231 prox=curl_getenv(proxy_env);
4234 * We don't try the uppercase version of HTTP_PROXY because of
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.
4242 * This can cause 'internal' http/ftp requests to be
4243 * arbitrarily redirected by any external attacker.
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);
4251 if(prox && *prox) { /* don't count "" strings */
4252 proxy = prox; /* use this */
4255 proxy = curl_getenv("all_proxy"); /* default proxy to use */
4257 proxy=curl_getenv("ALL_PROXY");
4259 } /* if(!check_noproxy(conn->host.name, no_proxy)) - it wasn't specified
4264 #else /* !CURL_DISABLE_HTTP */
4267 #endif /* CURL_DISABLE_HTTP */
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.
4278 static CURLcode parse_proxy(struct SessionHandle *data,
4279 struct connectdata *conn, char *proxy)
4284 /* We use 'proxyptr' to point to the proxy name from now on... */
4289 /* We do the proxy host string parsing here. We want the host name and the
4290 * port name. Accept a protocol:// prefix
4293 /* Parse the protocol part if present */
4294 endofprot = strstr(proxy, "://");
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 */
4308 proxyptr = proxy; /* No xxx:// head: It's a HTTP proxy */
4310 /* Is there a username and password given in this proxy url? */
4311 atsign = strchr(proxyptr, '@');
4313 CURLcode res = CURLE_OK;
4314 char *proxyuser = NULL;
4315 char *proxypasswd = NULL;
4317 res = parse_login_details(proxyptr, atsign - proxyptr,
4318 &proxyuser, &proxypasswd, NULL);
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
4324 Curl_safefree(conn->proxyuser);
4325 if(proxyuser && strlen(proxyuser) < MAX_CURL_USER_LENGTH)
4326 conn->proxyuser = curl_easy_unescape(data, proxyuser, 0, NULL);
4328 conn->proxyuser = strdup("");
4330 if(!conn->proxyuser)
4331 res = CURLE_OUT_OF_MEMORY;
4333 Curl_safefree(conn->proxypasswd);
4334 if(proxypasswd && strlen(proxypasswd) < MAX_CURL_PASSWORD_LENGTH)
4335 conn->proxypasswd = curl_easy_unescape(data, proxypasswd, 0, NULL);
4337 conn->proxypasswd = strdup("");
4339 if(!conn->proxypasswd)
4340 res = CURLE_OUT_OF_MEMORY;
4344 conn->bits.proxy_user_passwd = TRUE; /* enable it */
4345 atsign++; /* the right side of the @-letter */
4348 proxyptr = atsign; /* now use this instead */
4350 res = CURLE_OUT_OF_MEMORY;
4354 Curl_safefree(proxyuser);
4355 Curl_safefree(proxypasswd);
4361 /* start scanning for port number at this point */
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 == '%') ||
4371 /* yeps, it ended nicely with a bracket as well */
4374 infof(data, "Invalid IPv6 address format\n");
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.
4382 /* Get port number off proxy.server.com:1080 */
4383 prox_portno = strchr(portptr, ':');
4385 *prox_portno = 0x0; /* cut off number from host name */
4387 /* now set the local port number */
4388 conn->port = strtol(prox_portno, NULL, 10);
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;
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, '/');
4401 *atsign = 0x0; /* cut off path part from host name */
4403 if(data->set.proxyport)
4404 /* None given in the proxy string, then get the default one if it is
4406 conn->port = data->set.proxyport;
4409 /* now, clone the cleaned proxy host name */
4410 conn->proxy.rawalloc = strdup(proxyptr);
4411 conn->proxy.name = conn->proxy.rawalloc;
4413 if(!conn->proxy.rawalloc)
4414 return CURLE_OUT_OF_MEMORY;
4420 * Extract the user and password from the authentication string
4422 static CURLcode parse_proxy_auth(struct SessionHandle *data,
4423 struct connectdata *conn)
4425 char proxyuser[MAX_CURL_USER_LENGTH]="";
4426 char proxypasswd[MAX_CURL_PASSWORD_LENGTH]="";
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*/
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*/
4439 conn->proxyuser = curl_easy_unescape(data, proxyuser, 0, NULL);
4440 if(!conn->proxyuser)
4441 return CURLE_OUT_OF_MEMORY;
4443 conn->proxypasswd = curl_easy_unescape(data, proxypasswd, 0, NULL);
4444 if(!conn->proxypasswd)
4445 return CURLE_OUT_OF_MEMORY;
4449 #endif /* CURL_DISABLE_PROXY */
4454 * Parse the login details (user name, password and options) from the URL and
4455 * strip them out of the host name
4457 * Inputs: data->set.use_netrc (CURLOPT_NETRC)
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
4467 static CURLcode parse_url_login(struct SessionHandle *data,
4468 struct connectdata *conn,
4469 char **user, char **passwd, char **options)
4471 CURLcode result = CURLE_OK;
4473 char *passwdp = NULL;
4474 char *optionsp = NULL;
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
4480 * We need somewhere to put the embedded details, so do that first.
4483 char *ptr = strchr(conn->host.name, '@');
4484 char *login = conn->host.name;
4486 DEBUGASSERT(!**user);
4487 DEBUGASSERT(!**passwd);
4488 DEBUGASSERT(!**options);
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;
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 :-(
4504 if(data->set.use_netrc == CURL_NETRC_REQUIRED)
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)
4516 /* We have a user in the URL */
4517 conn->bits.userpwd_in_url = TRUE;
4518 conn->bits.user_passwd = TRUE; /* enable user+password */
4520 /* Decode the user */
4521 newname = curl_easy_unescape(data, userp, 0, NULL);
4523 result = CURLE_OUT_OF_MEMORY;
4532 /* We have a password in the URL so decode it */
4533 char *newpasswd = curl_easy_unescape(data, passwdp, 0, NULL);
4535 result = CURLE_OUT_OF_MEMORY;
4540 *passwd = newpasswd;
4544 /* We have an options list in the URL so decode it */
4545 char *newoptions = curl_easy_unescape(data, optionsp, 0, NULL);
4547 result = CURLE_OUT_OF_MEMORY;
4552 *options = newoptions;
4558 Curl_safefree(userp);
4559 Curl_safefree(passwdp);
4560 Curl_safefree(optionsp);
4566 * parse_login_details()
4568 * This is used to parse a login string for user name, password and options in
4569 * the following formats:
4573 * user:password;options
4575 * user;options:password
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.
4592 * Returns CURLE_OK on success.
4594 static CURLcode parse_login_details(const char *login, const size_t len,
4595 char **userp, char **passwdp,
4598 CURLcode result = CURLE_OK;
4602 const char *psep = NULL;
4603 const char *osep = NULL;
4608 /* Attempt to find the password separator */
4610 psep = strchr(login, ':');
4612 /* Within the constraint of the login string */
4613 if(psep >= login + len)
4617 /* Attempt to find the options separator */
4619 osep = strchr(login, ';');
4621 /* Within the constraint of the login string */
4622 if(osep >= login + len)
4626 /* Calculate the portion lengths */
4628 (size_t)(osep && psep > osep ? osep - login : psep - login) :
4629 (osep ? (size_t)(osep - login) : len));
4631 (osep && osep > psep ? (size_t)(osep - psep) :
4632 (size_t)(login + len - psep)) - 1 : 0);
4634 (psep && psep > osep ? (size_t)(psep - osep) :
4635 (size_t)(login + len - osep)) - 1 : 0);
4637 /* Allocate the user portion buffer */
4639 ubuf = malloc(ulen + 1);
4641 result = CURLE_OUT_OF_MEMORY;
4644 /* Allocate the password portion buffer */
4645 if(!result && passwdp && plen) {
4646 pbuf = malloc(plen + 1);
4648 Curl_safefree(ubuf);
4649 result = CURLE_OUT_OF_MEMORY;
4653 /* Allocate the options portion buffer */
4654 if(!result && optionsp && olen) {
4655 obuf = malloc(olen + 1);
4657 Curl_safefree(pbuf);
4658 Curl_safefree(ubuf);
4659 result = CURLE_OUT_OF_MEMORY;
4664 /* Store the user portion if necessary */
4666 memcpy(ubuf, login, ulen);
4668 Curl_safefree(*userp);
4672 /* Store the password portion if necessary */
4674 memcpy(pbuf, psep + 1, plen);
4676 Curl_safefree(*passwdp);
4680 /* Store the options portion if necessary */
4682 memcpy(obuf, osep + 1, olen);
4684 Curl_safefree(*optionsp);
4692 /*************************************************************
4693 * Figure out the remote port number and fix it in the URL
4695 * No matter if we use a proxy or not, we have to figure out the remote
4696 * port number of various reasons.
4698 * To be able to detect port number flawlessly, we must not confuse them
4699 * IPv6-specified addresses in the [0::1] style. (RFC2732)
4701 * The conn->host.name is currently [user:passwd@]host[:port] where host
4702 * could be a hostname, IPv4 address or IPv6 address.
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)
4712 /* Note that at this point, the IPv6 address cannot contain any scope
4713 suffix as that has already been removed in the parseurlandfillconn()
4715 if((1 == sscanf(conn->host.name, "[%*45[0123456789abcdefABCDEF:.]%c",
4717 (']' == endbracket)) {
4718 /* this is a RFC2732-style specified IP-address */
4719 conn->bits.ipv6_ip = TRUE;
4721 conn->host.name++; /* skip over the starting bracket */
4722 portptr = strchr(conn->host.name, ']');
4724 *portptr++ = '\0'; /* zero terminate, killing the bracket */
4726 portptr = NULL; /* no port number available */
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
4735 failf(data, "IPv6 numerical address used in URL without brackets");
4736 return CURLE_URL_MALFORMAT;
4740 portptr = strrchr(conn->host.name, ':');
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;
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 */
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'));
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.
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,
4770 return CURLE_OUT_OF_MEMORY;
4772 if(data->change.url_alloc) {
4773 Curl_safefree(data->change.url);
4774 data->change.url_alloc = FALSE;
4777 data->change.url = url;
4778 data->change.url_alloc = TRUE;
4782 /* no CURLOPT_PORT given, extract the one from the URL */
4787 port=strtoul(portptr+1, &rest, 10); /* Port number must be decimal */
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 */
4793 if(port > 0xffff) { /* Single unix standard says port numbers are
4795 failf(data, "Port number too large: %lu", port);
4796 return CURLE_URL_MALFORMAT;
4799 *portptr = '\0'; /* cut off the name there */
4800 conn->remote_port = curlx_ultous(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. */
4812 * Override the login details from the URL with that in the CURLOPT_USERPWD
4813 * option or a .netrc file, if applicable.
4815 static CURLcode override_login(struct SessionHandle *data,
4816 struct connectdata *conn,
4817 char **userp, char **passwdp, char **optionsp)
4819 if(data->set.str[STRING_USERNAME]) {
4821 *userp = strdup(data->set.str[STRING_USERNAME]);
4823 return CURLE_OUT_OF_MEMORY;
4826 if(data->set.str[STRING_PASSWORD]) {
4828 *passwdp = strdup(data->set.str[STRING_PASSWORD]);
4830 return CURLE_OUT_OF_MEMORY;
4833 if(data->set.str[STRING_OPTIONS]) {
4835 *optionsp = strdup(data->set.str[STRING_OPTIONS]);
4837 return CURLE_OUT_OF_MEMORY;
4840 conn->bits.netrc = FALSE;
4841 if(data->set.use_netrc != CURL_NETRC_IGNORED) {
4842 if(Curl_parsenetrc(conn->host.name,
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",
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;
4855 conn->bits.user_passwd = TRUE; /* enable user+password */
4863 * Set password so it's available in the connection.
4865 static CURLcode set_login(struct connectdata *conn,
4866 const char *user, const char *passwd,
4867 const char *options)
4869 CURLcode result = CURLE_OK;
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);
4876 /* Store the default password */
4878 conn->passwd = strdup(CURL_DEFAULT_PASSWORD);
4880 conn->passwd = NULL;
4882 /* This is the default password, so DON'T set conn->bits.user_passwd */
4885 /* Store the user, zero-length if not set */
4886 conn->user = strdup(user);
4888 /* Store the password (only if user is present), zero-length if not set */
4890 conn->passwd = strdup(passwd);
4892 conn->passwd = NULL;
4895 if(!conn->user || !conn->passwd)
4896 result = CURLE_OUT_OF_MEMORY;
4898 /* Store the options, null if not set */
4899 if(!result && options[0]) {
4900 conn->options = strdup(options);
4903 result = CURLE_OUT_OF_MEMORY;
4909 /*************************************************************
4910 * Resolve the address of the server or proxy
4911 *************************************************************/
4912 static CURLcode resolve_server(struct SessionHandle *data,
4913 struct connectdata *conn,
4916 CURLcode result=CURLE_OK;
4917 long timeout_ms = Curl_timeleft(data, NULL, TRUE);
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
4929 /* this is a fresh connect */
4931 struct Curl_dns_entry *hostaddr;
4933 /* set a pointer to the hostname we display */
4934 fix_hostname(data, conn, &conn->host);
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 */
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)
4947 else if(rc == CURLRESOLV_TIMEDOUT)
4948 result = CURLE_OPERATION_TIMEDOUT;
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 */
4957 /* This is a proxy that hasn't been resolved yet. */
4959 /* IDN-fix the proxy name */
4960 fix_hostname(data, conn, &conn->proxy);
4963 rc = Curl_resolv_timeout(conn, conn->proxy.name, (int)conn->port,
4964 &hostaddr, timeout_ms);
4966 if(rc == CURLRESOLV_PENDING)
4969 else if(rc == CURLRESOLV_TIMEDOUT)
4970 result = CURLE_OPERATION_TIMEDOUT;
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 */
4978 DEBUGASSERT(conn->dns_entry == NULL);
4979 conn->dns_entry = hostaddr;
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.
4990 static void reuse_conn(struct connectdata *old_conn,
4991 struct connectdata *conn)
4993 if(old_conn->proxy.rawalloc)
4994 free(old_conn->proxy.rawalloc);
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);
5000 conn->data = old_conn->data;
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;
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;
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;
5031 /* persist connection info in session handle */
5032 Curl_persistconninfo(conn);
5035 conn->bits.reuse = TRUE; /* yes, we're re-using here */
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);
5043 Curl_llist_destroy(old_conn->send_pipe, NULL);
5044 Curl_llist_destroy(old_conn->recv_pipe, NULL);
5046 old_conn->send_pipe = NULL;
5047 old_conn->recv_pipe = NULL;
5049 Curl_safefree(old_conn->master_buffer);
5053 * create_conn() sets up a new connectdata struct, or re-uses an already
5054 * existing one, and resolves host name.
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
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()
5065 * *NOTE* this function assigns the conn->data pointer!
5068 static CURLcode create_conn(struct SessionHandle *data,
5069 struct connectdata **in_connect,
5072 CURLcode result = CURLE_OK;
5073 struct connectdata *conn;
5074 struct connectdata *conn_temp = NULL;
5077 char *passwd = NULL;
5078 char *options = NULL;
5081 bool prot_missing = FALSE;
5082 bool no_connections_available = FALSE;
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);
5089 /*************************************************************
5091 *************************************************************/
5093 if(!data->change.url) {
5094 result = CURLE_URL_MALFORMAT;
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);
5105 result = CURLE_OUT_OF_MEMORY;
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
5114 /* This initing continues below, see the comment "Continue connectdata
5115 * initialization here" */
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;
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)
5133 Curl_safefree(data->state.pathbuffer);
5134 data->state.path = NULL;
5136 data->state.pathbuffer = malloc(urllen+2);
5137 if(NULL == data->state.pathbuffer) {
5138 result = CURLE_OUT_OF_MEMORY; /* really bad error */
5141 data->state.path = data->state.pathbuffer;
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;
5151 conn->host.name = conn->host.rawalloc;
5152 conn->host.name[0] = 0;
5155 passwd = strdup("");
5156 options = strdup("");
5157 if(!user || !passwd || !options) {
5158 result = CURLE_OUT_OF_MEMORY;
5162 result = parseurlandfillconn(data, conn, &prot_missing, &user, &passwd,
5164 if(result != CURLE_OK)
5167 /*************************************************************
5168 * No protocol part in URL was used, add it!
5169 *************************************************************/
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. */
5176 reurl = aprintf("%s://%s", conn->handler->scheme, data->change.url);
5179 result = CURLE_OUT_OF_MEMORY;
5183 if(data->change.url_alloc) {
5184 Curl_safefree(data->change.url);
5185 data->change.url_alloc = FALSE;
5188 data->change.url = reurl;
5189 data->change.url_alloc = TRUE; /* free this later */
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, '?');
5199 /* according to rfc3986, allow the query (?foo=bar)
5200 also on protocols that can't handle it.
5202 cut the string-part after '?'
5205 /* terminate the string */
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;
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)
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 */
5234 failf(data, "memory shortage");
5235 result = CURLE_OUT_OF_MEMORY;
5240 if(data->set.str[STRING_NOPROXY] &&
5241 check_noproxy(conn->host.name, data->set.str[STRING_NOPROXY])) {
5243 free(proxy); /* proxy is in exception list */
5248 proxy = detect_proxy(conn);
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 */
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 ***********************************************************************/
5262 result = parse_proxy(data, conn, proxy);
5264 Curl_safefree(proxy); /* parse_proxy copies the proxy string */
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;
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;
5282 conn->bits.httpproxy = TRUE;
5286 conn->bits.httpproxy = FALSE; /* not a HTTP proxy */
5287 conn->bits.proxy = TRUE;
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;
5297 #endif /* CURL_DISABLE_PROXY */
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;
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)
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)
5318 result = set_login(conn, user, passwd, options);
5319 if(result != CURLE_OK)
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)
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;
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) {
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);
5346 /* Setup a "faked" transfer that'll do nothing */
5347 if(CURLE_OK == result) {
5349 conn->bits.tcpconnect[FIRSTSOCKET] = TRUE; /* we are "connected */
5351 ConnectionStore(data, conn);
5354 * Setup whatever necessary for a resumed transfer
5356 result = setup_range(data);
5358 DEBUGASSERT(conn->handler->done);
5359 /* we ignore the return code for the protocol-specific DONE */
5360 (void)conn->handler->done(conn, result, FALSE);
5364 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, /* no download */
5365 -1, NULL); /* no upload */
5368 /* since we skip do_init() */
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!
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.
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];
5392 data->set.ssl.username = data->set.str[STRING_TLSAUTH_USERNAME];
5393 data->set.ssl.password = data->set.str[STRING_TLSAUTH_PASSWORD];
5396 if(!Curl_clone_ssl_config(&data->set.ssl, &conn->ssl_config)) {
5397 result = CURLE_OUT_OF_MEMORY;
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
5405 *************************************************************/
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)
5414 reuse = ConnectionExists(data, conn, &conn_temp, &force_reuse);
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;
5421 infof(data, "Found connection %ld, with requests in the pipe (%zu)\n",
5422 conn_temp->connection_id, pipelen);
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 */
5429 infof(data, "We can reuse, but we want a new connection anyway\n");
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
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 */
5448 /* set a pointer to the hostname we display */
5449 fix_hostname(data, conn, &conn->host);
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);
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;
5461 bundle = Curl_conncache_find_bundle(data->state.conn_cache,
5463 if(max_host_connections > 0 && bundle &&
5464 (bundle->num_connections >= max_host_connections)) {
5465 struct connectdata *conn_candidate;
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);
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);
5476 no_connections_available = TRUE;
5479 if(max_total_connections > 0 &&
5480 (data->state.conn_cache->num_connections >= max_total_connections)) {
5481 struct connectdata *conn_candidate;
5483 /* The cache is full. Let's see if we can kill a connection. */
5484 conn_candidate = find_oldest_idle_connection(data);
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);
5492 no_connections_available = TRUE;
5496 if(no_connections_available) {
5497 infof(data, "No connections available.\n");
5502 result = CURLE_NO_CONNECTION_AVAILABLE;
5507 * This is a brand new connection, so let's store it in the connection
5510 ConnectionStore(data, conn);
5514 /* Mark the connection as used */
5517 /* Setup and init stuff before DO starts, in preparing for the transfer. */
5521 * Setup whatever necessary for a resumed transfer
5523 result = setup_range(data);
5527 /* Continue connectdata initialization here. */
5530 * Inherit the proper values from the urldata struct AFTER we have arranged
5531 * the persistent connection stuff
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;
5538 /*************************************************************
5539 * Resolve the address of the server or proxy
5540 *************************************************************/
5541 result = resolve_server(data, conn, async);
5545 Curl_safefree(options);
5546 Curl_safefree(passwd);
5547 Curl_safefree(user);
5548 Curl_safefree(proxy);
5552 /* Curl_setup_conn() is called after the name resolve initiated in
5553 * create_conn() is all done.
5555 * Curl_setup_conn() also handles reused connections
5557 * conn->data MUST already have been setup fine (in create_conn)
5560 CURLcode Curl_setup_conn(struct connectdata *conn,
5561 bool *protocol_done)
5563 CURLcode result = CURLE_OK;
5564 struct SessionHandle *data = conn->data;
5566 Curl_pgrsTime(data, TIMER_NAMELOOKUP);
5568 if(conn->handler->flags & PROTOPT_NONETWORK) {
5569 /* nothing to setup when not using a network */
5570 *protocol_done = TRUE;
5573 *protocol_done = FALSE; /* default to not done */
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;
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
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;
5594 data->req.headerbytecount = 0;
5596 #ifdef CURL_DO_LINEEND_CONV
5597 data->state.crlf_conversions = 0; /* reset CRLF conversion counter */
5598 #endif /* CURL_DO_LINEEND_CONV */
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();
5605 /* loop for CURL_SERVER_CLOSED_CONNECTION */
5607 if(CURL_SOCKET_BAD == conn->sock[FIRSTSOCKET]) {
5608 /* Try to connect only if not already connected */
5609 bool connected = FALSE;
5611 result = ConnectPlease(data, conn, &connected);
5613 if(result && !conn->ip_addr) {
5614 /* transport connection failure not related with authentication */
5615 conn->bits.tcpconnect[FIRSTSOCKET] = FALSE;
5620 result = Curl_protocol_connect(conn, protocol_done);
5621 if(CURLE_OK == result)
5622 conn->bits.tcpconnect[FIRSTSOCKET] = TRUE;
5625 conn->bits.tcpconnect[FIRSTSOCKET] = FALSE;
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;
5638 if(CURLE_OK != result)
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]);
5649 /* Stop the loop now */
5653 conn->now = Curl_tvnow(); /* time this *after* the connect is done, we
5654 set this here perhaps a second time */
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
5664 if((data->set.out)->_handle == NULL) {
5665 _fsetmode(stdout, "b");
5672 CURLcode Curl_connect(struct SessionHandle *data,
5673 struct connectdata **in_connect,
5675 bool *protocol_done)
5679 *asyncp = FALSE; /* assume synchronous resolves by default */
5681 /* call the stuff that needs to be called */
5682 code = create_conn(data, in_connect, asyncp);
5684 if(CURLE_OK == code) {
5686 if((*in_connect)->send_pipe->size || (*in_connect)->recv_pipe->size)
5688 *protocol_done = TRUE;
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);
5697 if(code == CURLE_NO_CONNECTION_AVAILABLE) {
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 */
5712 CURLcode Curl_done(struct connectdata **connp,
5713 CURLcode status, /* an error if this is called after an
5714 error was detected */
5718 struct connectdata *conn;
5719 struct SessionHandle *data;
5721 DEBUGASSERT(*connp);
5727 /* Stop if Curl_done() has already been called */
5730 Curl_getoff_all_pipelines(data, conn);
5732 if((conn->send_pipe->size + conn->recv_pipe->size != 0 &&
5733 !data->set.reuse_forbid &&
5735 /* Stop if pipeline is not empty and we do not have to close
5739 conn->bits.done = TRUE; /* called just now! */
5741 /* Cleanup possible redirect junk */
5742 if(data->req.newurl) {
5743 free(data->req.newurl);
5744 data->req.newurl = NULL;
5746 if(data->req.location) {
5747 free(data->req.location);
5748 data->req.location = NULL;
5751 Curl_resolver_cancel(conn);
5753 if(conn->dns_entry) {
5754 Curl_resolv_unlock(data, conn->dns_entry); /* done with this */
5755 conn->dns_entry = NULL;
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. */
5771 /* this calls the protocol-specific function pointer previously set */
5772 if(conn->handler->done)
5773 result = conn->handler->done(conn, status, premature);
5777 if(Curl_pgrsDone(conn) && !result)
5778 result = CURLE_ABORTED_BY_CALLBACK;
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;
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.
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
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.
5800 if(data->set.reuse_forbid || conn->bits.close || premature) {
5801 CURLcode res2 = Curl_disconnect(conn, premature); /* close connection */
5803 /* If we had an error already, make sure we return that one. But
5804 if we got a new error, return that. */
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;
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);
5819 data->state.lastconnect = NULL;
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
5826 Curl_free_request_state(data);
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
5839 static CURLcode do_init(struct connectdata *conn)
5841 struct SessionHandle *data = conn->data;
5842 struct SingleRequest *k = &data->req;
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;
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
5857 data->set.httpreq = HTTPREQ_GET;
5859 k->start = Curl_tvnow(); /* start time */
5860 k->now = k->start; /* current time is now */
5861 k->header = TRUE; /* assume header */
5865 k->buf = data->state.buffer;
5866 k->uploadbuf = data->state.uploadbuffer;
5867 k->hbufp = data->state.headerbuff;
5868 k->ignorebody=FALSE;
5870 Curl_speedinit(data);
5872 Curl_pgrsSetUploadCounter(data, 0);
5873 Curl_pgrsSetDownloadCounter(data, 0);
5879 * do_complete is called when the DO actions are complete.
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.
5884 static void do_complete(struct connectdata *conn)
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);
5892 CURLcode Curl_do(struct connectdata **connp, bool *done)
5894 CURLcode result=CURLE_OK;
5895 struct connectdata *conn = *connp;
5896 struct SessionHandle *data = conn->data;
5898 if(conn->handler->do_it) {
5899 /* generic protocol-specific function pointer set in curl_connect() */
5900 result = conn->handler->do_it(conn, done);
5902 /* This was formerly done in transfer.c, but we better do it here */
5903 if((CURLE_SEND_ERROR == result) && conn->bits.reuse) {
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.
5910 result = Curl_reconnect_request(connp);
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);
5923 if((result == CURLE_OK) && *done)
5924 /* do_complete must be called after the protocol-specific DO function */
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.
5935 * TODO: A future libcurl should be able to work away this state.
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!
5941 CURLcode Curl_do_more(struct connectdata *conn, int *complete)
5943 CURLcode result=CURLE_OK;
5947 if(conn->handler->do_more)
5948 result = conn->handler->do_more(conn, complete);
5950 if(!result && (*complete == 1))
5951 /* do_complete must be called after the protocol-specific DO function */