| /*************************************************************************** |
| * _ _ ____ _ |
| * Project ___| | | | _ \| | |
| * / __| | | | |_) | | |
| * | (__| |_| | _ <| |___ |
| * \___|\___/|_| \_\_____| |
| * |
| * Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al. |
| * |
| * This software is licensed as described in the file COPYING, which |
| * you should have received as part of this distribution. The terms |
| * are also available at https://curl.haxx.se/docs/copyright.html. |
| * |
| * You may opt to use, copy, modify, merge, publish, distribute and/or sell |
| * copies of the Software, and permit persons to whom the Software is |
| * furnished to do so, under the terms of the COPYING file. |
| * |
| * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| * KIND, either express or implied. |
| * |
| ***************************************************************************/ |
| |
| #include "curl_setup.h" |
| |
| #ifdef HAVE_NETINET_IN_H |
| #include <netinet/in.h> |
| #endif |
| #ifdef HAVE_NETDB_H |
| #include <netdb.h> |
| #endif |
| #ifdef HAVE_ARPA_INET_H |
| #include <arpa/inet.h> |
| #endif |
| #ifdef HAVE_NET_IF_H |
| #include <net/if.h> |
| #endif |
| #ifdef HAVE_SYS_IOCTL_H |
| #include <sys/ioctl.h> |
| #endif |
| |
| #ifdef HAVE_SYS_PARAM_H |
| #include <sys/param.h> |
| #endif |
| |
| #ifdef __VMS |
| #include <in.h> |
| #include <inet.h> |
| #endif |
| |
| #ifdef HAVE_SYS_UN_H |
| #include <sys/un.h> |
| #endif |
| |
| #ifndef HAVE_SOCKET |
| #error "We can't compile without socket() support!" |
| #endif |
| |
| #include <limits.h> |
| |
| #ifdef USE_LIBIDN2 |
| #include <idn2.h> |
| |
| #elif defined(USE_WIN32_IDN) |
| /* prototype for curl_win32_idn_to_ascii() */ |
| bool curl_win32_idn_to_ascii(const char *in, char **out); |
| #endif /* USE_LIBIDN2 */ |
| |
| #include "urldata.h" |
| #include "netrc.h" |
| |
| #include "formdata.h" |
| #include "mime.h" |
| #include "vtls/vtls.h" |
| #include "hostip.h" |
| #include "transfer.h" |
| #include "sendf.h" |
| #include "progress.h" |
| #include "cookie.h" |
| #include "strcase.h" |
| #include "strerror.h" |
| #include "escape.h" |
| #include "strtok.h" |
| #include "share.h" |
| #include "content_encoding.h" |
| #include "http_digest.h" |
| #include "http_negotiate.h" |
| #include "select.h" |
| #include "multiif.h" |
| #include "easyif.h" |
| #include "speedcheck.h" |
| #include "warnless.h" |
| #include "non-ascii.h" |
| #include "inet_pton.h" |
| #include "getinfo.h" |
| |
| /* And now for the protocols */ |
| #include "ftp.h" |
| #include "dict.h" |
| #include "telnet.h" |
| #include "tftp.h" |
| #include "http.h" |
| #include "http2.h" |
| #include "file.h" |
| #include "curl_ldap.h" |
| #include "ssh.h" |
| #include "imap.h" |
| #include "url.h" |
| #include "connect.h" |
| #include "inet_ntop.h" |
| #include "http_ntlm.h" |
| #include "curl_ntlm_wb.h" |
| #include "socks.h" |
| #include "curl_rtmp.h" |
| #include "gopher.h" |
| #include "http_proxy.h" |
| #include "conncache.h" |
| #include "multihandle.h" |
| #include "pipeline.h" |
| #include "dotdot.h" |
| #include "strdup.h" |
| #include "setopt.h" |
| |
| /* The last 3 #include files should be in this order */ |
| #include "curl_printf.h" |
| #include "curl_memory.h" |
| #include "memdebug.h" |
| |
| static void conn_free(struct connectdata *conn); |
| static void free_fixed_hostname(struct hostname *host); |
| static void signalPipeClose(struct curl_llist *pipeline, bool pipe_broke); |
| static CURLcode parse_url_login(struct Curl_easy *data, |
| struct connectdata *conn, |
| char **userptr, char **passwdptr, |
| char **optionsptr); |
| static unsigned int get_protocol_family(unsigned int protocol); |
| |
| /* Some parts of the code (e.g. chunked encoding) assume this buffer has at |
| * more than just a few bytes to play with. Don't let it become too small or |
| * bad things will happen. |
| */ |
| #if READBUFFER_SIZE < READBUFFER_MIN |
| # error READBUFFER_SIZE is too small |
| #endif |
| |
| |
| /* |
| * Protocol table. |
| */ |
| |
| static const struct Curl_handler * const protocols[] = { |
| |
| #ifndef CURL_DISABLE_HTTP |
| &Curl_handler_http, |
| #endif |
| |
| #if defined(USE_SSL) && !defined(CURL_DISABLE_HTTP) |
| &Curl_handler_https, |
| #endif |
| |
| #ifndef CURL_DISABLE_FTP |
| &Curl_handler_ftp, |
| #endif |
| |
| #if defined(USE_SSL) && !defined(CURL_DISABLE_FTP) |
| &Curl_handler_ftps, |
| #endif |
| |
| #ifndef CURL_DISABLE_TELNET |
| &Curl_handler_telnet, |
| #endif |
| |
| #ifndef CURL_DISABLE_DICT |
| &Curl_handler_dict, |
| #endif |
| |
| #ifndef CURL_DISABLE_LDAP |
| &Curl_handler_ldap, |
| #if !defined(CURL_DISABLE_LDAPS) && \ |
| ((defined(USE_OPENLDAP) && defined(USE_SSL)) || \ |
| (!defined(USE_OPENLDAP) && defined(HAVE_LDAP_SSL))) |
| &Curl_handler_ldaps, |
| #endif |
| #endif |
| |
| #ifndef CURL_DISABLE_FILE |
| &Curl_handler_file, |
| #endif |
| |
| #ifndef CURL_DISABLE_TFTP |
| &Curl_handler_tftp, |
| #endif |
| |
| #if defined(USE_LIBSSH2) || defined(USE_LIBSSH) |
| &Curl_handler_scp, |
| #endif |
| |
| #if defined(USE_LIBSSH2) || defined(USE_LIBSSH) |
| &Curl_handler_sftp, |
| #endif |
| |
| #ifndef CURL_DISABLE_IMAP |
| &Curl_handler_imap, |
| #ifdef USE_SSL |
| &Curl_handler_imaps, |
| #endif |
| #endif |
| |
| #ifndef CURL_DISABLE_POP3 |
| &Curl_handler_pop3, |
| #ifdef USE_SSL |
| &Curl_handler_pop3s, |
| #endif |
| #endif |
| |
| #if !defined(CURL_DISABLE_SMB) && defined(USE_NTLM) && \ |
| (CURL_SIZEOF_CURL_OFF_T > 4) && \ |
| (!defined(USE_WINDOWS_SSPI) || defined(USE_WIN32_CRYPTO)) |
| &Curl_handler_smb, |
| #ifdef USE_SSL |
| &Curl_handler_smbs, |
| #endif |
| #endif |
| |
| #ifndef CURL_DISABLE_SMTP |
| &Curl_handler_smtp, |
| #ifdef USE_SSL |
| &Curl_handler_smtps, |
| #endif |
| #endif |
| |
| #ifndef CURL_DISABLE_RTSP |
| &Curl_handler_rtsp, |
| #endif |
| |
| #ifndef CURL_DISABLE_GOPHER |
| &Curl_handler_gopher, |
| #endif |
| |
| #ifdef USE_LIBRTMP |
| &Curl_handler_rtmp, |
| &Curl_handler_rtmpt, |
| &Curl_handler_rtmpe, |
| &Curl_handler_rtmpte, |
| &Curl_handler_rtmps, |
| &Curl_handler_rtmpts, |
| #endif |
| |
| (struct Curl_handler *) NULL |
| }; |
| |
| /* |
| * Dummy handler for undefined protocol schemes. |
| */ |
| |
| static const struct Curl_handler Curl_handler_dummy = { |
| "<no protocol>", /* scheme */ |
| ZERO_NULL, /* setup_connection */ |
| ZERO_NULL, /* do_it */ |
| ZERO_NULL, /* done */ |
| ZERO_NULL, /* do_more */ |
| ZERO_NULL, /* connect_it */ |
| ZERO_NULL, /* connecting */ |
| ZERO_NULL, /* doing */ |
| ZERO_NULL, /* proto_getsock */ |
| ZERO_NULL, /* doing_getsock */ |
| ZERO_NULL, /* domore_getsock */ |
| ZERO_NULL, /* perform_getsock */ |
| ZERO_NULL, /* disconnect */ |
| ZERO_NULL, /* readwrite */ |
| ZERO_NULL, /* connection_check */ |
| 0, /* defport */ |
| 0, /* protocol */ |
| PROTOPT_NONE /* flags */ |
| }; |
| |
| void Curl_freeset(struct Curl_easy *data) |
| { |
| /* Free all dynamic strings stored in the data->set substructure. */ |
| enum dupstring i; |
| for(i = (enum dupstring)0; i < STRING_LAST; i++) { |
| Curl_safefree(data->set.str[i]); |
| } |
| |
| if(data->change.referer_alloc) { |
| Curl_safefree(data->change.referer); |
| data->change.referer_alloc = FALSE; |
| } |
| data->change.referer = NULL; |
| if(data->change.url_alloc) { |
| Curl_safefree(data->change.url); |
| data->change.url_alloc = FALSE; |
| } |
| data->change.url = NULL; |
| |
| Curl_mime_cleanpart(&data->set.mimepost); |
| } |
| |
| /* |
| * This is the internal function curl_easy_cleanup() calls. This should |
| * cleanup and free all resources associated with this sessionhandle. |
| * |
| * NOTE: if we ever add something that attempts to write to a socket or |
| * similar here, we must ignore SIGPIPE first. It is currently only done |
| * when curl_easy_perform() is invoked. |
| */ |
| |
| CURLcode Curl_close(struct Curl_easy *data) |
| { |
| struct Curl_multi *m; |
| |
| if(!data) |
| return CURLE_OK; |
| |
| Curl_expire_clear(data); /* shut off timers */ |
| |
| m = data->multi; |
| |
| if(m) |
| /* This handle is still part of a multi handle, take care of this first |
| and detach this handle from there. */ |
| curl_multi_remove_handle(data->multi, data); |
| |
| if(data->multi_easy) |
| /* when curl_easy_perform() is used, it creates its own multi handle to |
| use and this is the one */ |
| curl_multi_cleanup(data->multi_easy); |
| |
| /* Destroy the timeout list that is held in the easy handle. It is |
| /normally/ done by curl_multi_remove_handle() but this is "just in |
| case" */ |
| Curl_llist_destroy(&data->state.timeoutlist, NULL); |
| |
| data->magic = 0; /* force a clear AFTER the possibly enforced removal from |
| the multi handle, since that function uses the magic |
| field! */ |
| |
| if(data->state.rangestringalloc) |
| free(data->state.range); |
| |
| /* Free the pathbuffer */ |
| Curl_safefree(data->state.pathbuffer); |
| data->state.path = NULL; |
| |
| /* freed here just in case DONE wasn't called */ |
| Curl_free_request_state(data); |
| |
| /* Close down all open SSL info and sessions */ |
| Curl_ssl_close_all(data); |
| Curl_safefree(data->state.first_host); |
| Curl_safefree(data->state.scratch); |
| Curl_ssl_free_certinfo(data); |
| |
| /* Cleanup possible redirect junk */ |
| free(data->req.newurl); |
| data->req.newurl = NULL; |
| |
| if(data->change.referer_alloc) { |
| Curl_safefree(data->change.referer); |
| data->change.referer_alloc = FALSE; |
| } |
| data->change.referer = NULL; |
| |
| if(data->change.url_alloc) { |
| Curl_safefree(data->change.url); |
| data->change.url_alloc = FALSE; |
| } |
| data->change.url = NULL; |
| |
| Curl_safefree(data->state.buffer); |
| Curl_safefree(data->state.headerbuff); |
| |
| Curl_flush_cookies(data, 1); |
| |
| Curl_digest_cleanup(data); |
| |
| Curl_safefree(data->info.contenttype); |
| Curl_safefree(data->info.wouldredirect); |
| |
| /* this destroys the channel and we cannot use it anymore after this */ |
| Curl_resolver_cleanup(data->state.resolver); |
| |
| Curl_http2_cleanup_dependencies(data); |
| Curl_convert_close(data); |
| |
| /* No longer a dirty share, if it exists */ |
| if(data->share) { |
| Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE); |
| data->share->dirty--; |
| Curl_share_unlock(data, CURL_LOCK_DATA_SHARE); |
| } |
| |
| /* destruct wildcard structures if it is needed */ |
| Curl_wildcard_dtor(&data->wildcard); |
| Curl_freeset(data); |
| free(data); |
| return CURLE_OK; |
| } |
| |
| /* |
| * Initialize the UserDefined fields within a Curl_easy. |
| * This may be safely called on a new or existing Curl_easy. |
| */ |
| CURLcode Curl_init_userdefined(struct Curl_easy *data) |
| { |
| struct UserDefined *set = &data->set; |
| CURLcode result = CURLE_OK; |
| |
| set->out = stdout; /* default output to stdout */ |
| set->in_set = stdin; /* default input from stdin */ |
| set->err = stderr; /* default stderr to stderr */ |
| |
| /* use fwrite as default function to store output */ |
| set->fwrite_func = (curl_write_callback)fwrite; |
| |
| /* use fread as default function to read input */ |
| set->fread_func_set = (curl_read_callback)fread; |
| set->is_fread_set = 0; |
| set->is_fwrite_set = 0; |
| |
| set->seek_func = ZERO_NULL; |
| set->seek_client = ZERO_NULL; |
| |
| /* conversion callbacks for non-ASCII hosts */ |
| set->convfromnetwork = ZERO_NULL; |
| set->convtonetwork = ZERO_NULL; |
| set->convfromutf8 = ZERO_NULL; |
| |
| set->filesize = -1; /* we don't know the size */ |
| set->postfieldsize = -1; /* unknown size */ |
| set->maxredirs = -1; /* allow any amount by default */ |
| |
| set->httpreq = HTTPREQ_GET; /* Default HTTP request */ |
| set->rtspreq = RTSPREQ_OPTIONS; /* Default RTSP request */ |
| set->ftp_use_epsv = TRUE; /* FTP defaults to EPSV operations */ |
| set->ftp_use_eprt = TRUE; /* FTP defaults to EPRT operations */ |
| set->ftp_use_pret = FALSE; /* mainly useful for drftpd servers */ |
| set->ftp_filemethod = FTPFILE_MULTICWD; |
| |
| set->dns_cache_timeout = 60; /* Timeout every 60 seconds by default */ |
| |
| /* Set the default size of the SSL session ID cache */ |
| set->general_ssl.max_ssl_sessions = 5; |
| |
| set->proxyport = 0; |
| set->proxytype = CURLPROXY_HTTP; /* defaults to HTTP proxy */ |
| set->httpauth = CURLAUTH_BASIC; /* defaults to basic */ |
| set->proxyauth = CURLAUTH_BASIC; /* defaults to basic */ |
| |
| /* SOCKS5 proxy auth defaults to username/password + GSS-API */ |
| set->socks5auth = CURLAUTH_BASIC | CURLAUTH_GSSAPI; |
| |
| /* make libcurl quiet by default: */ |
| set->hide_progress = TRUE; /* CURLOPT_NOPROGRESS changes these */ |
| |
| Curl_mime_initpart(&set->mimepost, data); |
| |
| /* |
| * libcurl 7.10 introduced SSL verification *by default*! This needs to be |
| * switched off unless wanted. |
| */ |
| set->ssl.primary.verifypeer = TRUE; |
| set->ssl.primary.verifyhost = TRUE; |
| #ifdef USE_TLS_SRP |
| set->ssl.authtype = CURL_TLSAUTH_NONE; |
| #endif |
| set->ssh_auth_types = CURLSSH_AUTH_DEFAULT; /* defaults to any auth |
| type */ |
| set->ssl.primary.sessionid = TRUE; /* session ID caching enabled by |
| default */ |
| set->proxy_ssl = set->ssl; |
| |
| set->new_file_perms = 0644; /* Default permissions */ |
| set->new_directory_perms = 0755; /* Default permissions */ |
| |
| /* for the *protocols fields we don't use the CURLPROTO_ALL convenience |
| define since we internally only use the lower 16 bits for the passed |
| in bitmask to not conflict with the private bits */ |
| set->allowed_protocols = CURLPROTO_ALL; |
| set->redir_protocols = CURLPROTO_ALL & /* All except FILE, SCP and SMB */ |
| ~(CURLPROTO_FILE | CURLPROTO_SCP | CURLPROTO_SMB | |
| CURLPROTO_SMBS); |
| |
| #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) |
| /* |
| * disallow unprotected protection negotiation NEC reference implementation |
| * seem not to follow rfc1961 section 4.3/4.4 |
| */ |
| set->socks5_gssapi_nec = FALSE; |
| #endif |
| |
| /* This is our preferred CA cert bundle/path since install time */ |
| #if defined(CURL_CA_BUNDLE) |
| result = Curl_setstropt(&set->str[STRING_SSL_CAFILE_ORIG], CURL_CA_BUNDLE); |
| if(result) |
| return result; |
| |
| result = Curl_setstropt(&set->str[STRING_SSL_CAFILE_PROXY], CURL_CA_BUNDLE); |
| if(result) |
| return result; |
| #endif |
| #if defined(CURL_CA_PATH) |
| result = Curl_setstropt(&set->str[STRING_SSL_CAPATH_ORIG], CURL_CA_PATH); |
| if(result) |
| return result; |
| |
| result = Curl_setstropt(&set->str[STRING_SSL_CAPATH_PROXY], CURL_CA_PATH); |
| if(result) |
| return result; |
| #endif |
| |
| set->wildcard_enabled = FALSE; |
| set->chunk_bgn = ZERO_NULL; |
| set->chunk_end = ZERO_NULL; |
| |
| /* tcp keepalives are disabled by default, but provide reasonable values for |
| * the interval and idle times. |
| */ |
| set->tcp_keepalive = FALSE; |
| set->tcp_keepintvl = 60; |
| set->tcp_keepidle = 60; |
| set->tcp_fastopen = FALSE; |
| set->tcp_nodelay = TRUE; |
| |
| set->ssl_enable_npn = TRUE; |
| set->ssl_enable_alpn = TRUE; |
| |
| set->expect_100_timeout = 1000L; /* Wait for a second by default. */ |
| set->sep_headers = TRUE; /* separated header lists by default */ |
| set->buffer_size = READBUFFER_SIZE; |
| |
| Curl_http2_init_userset(set); |
| return result; |
| } |
| |
| /** |
| * Curl_open() |
| * |
| * @param curl is a pointer to a sessionhandle pointer that gets set by this |
| * function. |
| * @return CURLcode |
| */ |
| |
| CURLcode Curl_open(struct Curl_easy **curl) |
| { |
| CURLcode result; |
| struct Curl_easy *data; |
| |
| /* Very simple start-up: alloc the struct, init it with zeroes and return */ |
| data = calloc(1, sizeof(struct Curl_easy)); |
| if(!data) { |
| /* this is a very serious error */ |
| DEBUGF(fprintf(stderr, "Error: calloc of Curl_easy failed\n")); |
| return CURLE_OUT_OF_MEMORY; |
| } |
| |
| data->magic = CURLEASY_MAGIC_NUMBER; |
| |
| result = Curl_resolver_init(&data->state.resolver); |
| if(result) { |
| DEBUGF(fprintf(stderr, "Error: resolver_init failed\n")); |
| free(data); |
| return result; |
| } |
| |
| /* We do some initial setup here, all those fields that can't be just 0 */ |
| |
| data->state.buffer = malloc(READBUFFER_SIZE + 1); |
| if(!data->state.buffer) { |
| DEBUGF(fprintf(stderr, "Error: malloc of buffer failed\n")); |
| result = CURLE_OUT_OF_MEMORY; |
| } |
| else { |
| data->state.headerbuff = malloc(HEADERSIZE); |
| if(!data->state.headerbuff) { |
| DEBUGF(fprintf(stderr, "Error: malloc of headerbuff failed\n")); |
| result = CURLE_OUT_OF_MEMORY; |
| } |
| else { |
| result = Curl_init_userdefined(data); |
| |
| data->state.headersize = HEADERSIZE; |
| Curl_convert_init(data); |
| Curl_initinfo(data); |
| |
| /* most recent connection is not yet defined */ |
| data->state.lastconnect = NULL; |
| |
| data->progress.flags |= PGRS_HIDE; |
| data->state.current_speed = -1; /* init to negative == impossible */ |
| data->set.fnmatch = ZERO_NULL; |
| data->set.maxconnects = DEFAULT_CONNCACHE_SIZE; /* for easy handles */ |
| |
| Curl_http2_init_state(&data->state); |
| } |
| } |
| |
| if(result) { |
| Curl_resolver_cleanup(data->state.resolver); |
| free(data->state.buffer); |
| free(data->state.headerbuff); |
| Curl_freeset(data); |
| free(data); |
| data = NULL; |
| } |
| else |
| *curl = data; |
| |
| return result; |
| } |
| |
| #ifdef USE_RECV_BEFORE_SEND_WORKAROUND |
| static void conn_reset_postponed_data(struct connectdata *conn, int num) |
| { |
| struct postponed_data * const psnd = &(conn->postponed[num]); |
| if(psnd->buffer) { |
| DEBUGASSERT(psnd->allocated_size > 0); |
| DEBUGASSERT(psnd->recv_size <= psnd->allocated_size); |
| DEBUGASSERT(psnd->recv_size ? |
| (psnd->recv_processed < psnd->recv_size) : |
| (psnd->recv_processed == 0)); |
| DEBUGASSERT(psnd->bindsock != CURL_SOCKET_BAD); |
| free(psnd->buffer); |
| psnd->buffer = NULL; |
| psnd->allocated_size = 0; |
| psnd->recv_size = 0; |
| psnd->recv_processed = 0; |
| #ifdef DEBUGBUILD |
| psnd->bindsock = CURL_SOCKET_BAD; /* used only for DEBUGASSERT */ |
| #endif /* DEBUGBUILD */ |
| } |
| else { |
| DEBUGASSERT(psnd->allocated_size == 0); |
| DEBUGASSERT(psnd->recv_size == 0); |
| DEBUGASSERT(psnd->recv_processed == 0); |
| DEBUGASSERT(psnd->bindsock == CURL_SOCKET_BAD); |
| } |
| } |
| |
| static void conn_reset_all_postponed_data(struct connectdata *conn) |
| { |
| conn_reset_postponed_data(conn, 0); |
| conn_reset_postponed_data(conn, 1); |
| } |
| #else /* ! USE_RECV_BEFORE_SEND_WORKAROUND */ |
| /* Use "do-nothing" macro instead of function when workaround not used */ |
| #define conn_reset_all_postponed_data(c) do {} WHILE_FALSE |
| #endif /* ! USE_RECV_BEFORE_SEND_WORKAROUND */ |
| |
| static void conn_free(struct connectdata *conn) |
| { |
| if(!conn) |
| return; |
| |
| /* possible left-overs from the async name resolvers */ |
| Curl_resolver_cancel(conn); |
| |
| /* close the SSL stuff before we close any sockets since they will/may |
| write to the sockets */ |
| Curl_ssl_close(conn, FIRSTSOCKET); |
| Curl_ssl_close(conn, SECONDARYSOCKET); |
| |
| /* close possibly still open sockets */ |
| if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET]) |
| Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]); |
| if(CURL_SOCKET_BAD != conn->sock[FIRSTSOCKET]) |
| Curl_closesocket(conn, conn->sock[FIRSTSOCKET]); |
| if(CURL_SOCKET_BAD != conn->tempsock[0]) |
| Curl_closesocket(conn, conn->tempsock[0]); |
| if(CURL_SOCKET_BAD != conn->tempsock[1]) |
| Curl_closesocket(conn, conn->tempsock[1]); |
| |
| #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) && \ |
| defined(NTLM_WB_ENABLED) |
| Curl_ntlm_wb_cleanup(conn); |
| #endif |
| |
| Curl_safefree(conn->user); |
| Curl_safefree(conn->passwd); |
| Curl_safefree(conn->oauth_bearer); |
| Curl_safefree(conn->options); |
| Curl_safefree(conn->http_proxy.user); |
| Curl_safefree(conn->socks_proxy.user); |
| Curl_safefree(conn->http_proxy.passwd); |
| Curl_safefree(conn->socks_proxy.passwd); |
| Curl_safefree(conn->allocptr.proxyuserpwd); |
| Curl_safefree(conn->allocptr.uagent); |
| Curl_safefree(conn->allocptr.userpwd); |
| Curl_safefree(conn->allocptr.accept_encoding); |
| Curl_safefree(conn->allocptr.te); |
| Curl_safefree(conn->allocptr.rangeline); |
| Curl_safefree(conn->allocptr.ref); |
| Curl_safefree(conn->allocptr.host); |
| Curl_safefree(conn->allocptr.cookiehost); |
| Curl_safefree(conn->allocptr.rtsp_transport); |
| Curl_safefree(conn->trailer); |
| Curl_safefree(conn->host.rawalloc); /* host name buffer */ |
| Curl_safefree(conn->conn_to_host.rawalloc); /* host name buffer */ |
| Curl_safefree(conn->secondaryhostname); |
| Curl_safefree(conn->http_proxy.host.rawalloc); /* http proxy name buffer */ |
| Curl_safefree(conn->socks_proxy.host.rawalloc); /* socks proxy name buffer */ |
| Curl_safefree(conn->master_buffer); |
| Curl_safefree(conn->connect_state); |
| |
| conn_reset_all_postponed_data(conn); |
| |
| Curl_llist_destroy(&conn->send_pipe, NULL); |
| Curl_llist_destroy(&conn->recv_pipe, NULL); |
| |
| Curl_safefree(conn->localdev); |
| Curl_free_primary_ssl_config(&conn->ssl_config); |
| Curl_free_primary_ssl_config(&conn->proxy_ssl_config); |
| |
| #ifdef USE_UNIX_SOCKETS |
| Curl_safefree(conn->unix_domain_socket); |
| #endif |
| |
| #ifdef USE_SSL |
| Curl_safefree(conn->ssl_extra); |
| #endif |
| free(conn); /* free all the connection oriented data */ |
| } |
| |
| /* |
| * Disconnects the given connection. Note the connection may not be the |
| * primary connection, like when freeing room in the connection cache or |
| * killing of a dead old connection. |
| * |
| * This function MUST NOT reset state in the Curl_easy struct if that |
| * isn't strictly bound to the life-time of *this* particular connection. |
| * |
| */ |
| |
| CURLcode Curl_disconnect(struct connectdata *conn, bool dead_connection) |
| { |
| struct Curl_easy *data; |
| if(!conn) |
| return CURLE_OK; /* this is closed and fine already */ |
| data = conn->data; |
| |
| if(!data) { |
| DEBUGF(fprintf(stderr, "DISCONNECT without easy handle, ignoring\n")); |
| return CURLE_OK; |
| } |
| |
| /* |
| * If this connection isn't marked to force-close, leave it open if there |
| * are other users of it |
| */ |
| if(!conn->bits.close && |
| (conn->send_pipe.size + conn->recv_pipe.size)) { |
| DEBUGF(infof(data, "Curl_disconnect, usecounter: %d\n", |
| conn->send_pipe.size + conn->recv_pipe.size)); |
| return CURLE_OK; |
| } |
| |
| if(conn->dns_entry != NULL) { |
| Curl_resolv_unlock(data, conn->dns_entry); |
| conn->dns_entry = NULL; |
| } |
| |
| Curl_hostcache_prune(data); /* kill old DNS cache entries */ |
| |
| #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) |
| /* Cleanup NTLM connection-related data */ |
| Curl_http_ntlm_cleanup(conn); |
| #endif |
| |
| if(conn->handler->disconnect) |
| /* This is set if protocol-specific cleanups should be made */ |
| conn->handler->disconnect(conn, dead_connection); |
| |
| /* unlink ourselves! */ |
| infof(data, "Closing connection %ld\n", conn->connection_id); |
| Curl_conncache_remove_conn(conn, TRUE); |
| |
| free_fixed_hostname(&conn->host); |
| free_fixed_hostname(&conn->conn_to_host); |
| free_fixed_hostname(&conn->http_proxy.host); |
| free_fixed_hostname(&conn->socks_proxy.host); |
| |
| Curl_ssl_close(conn, FIRSTSOCKET); |
| |
| /* Indicate to all handles on the pipe that we're dead */ |
| if(Curl_pipeline_wanted(data->multi, CURLPIPE_ANY)) { |
| signalPipeClose(&conn->send_pipe, TRUE); |
| signalPipeClose(&conn->recv_pipe, TRUE); |
| } |
| |
| conn_free(conn); |
| |
| return CURLE_OK; |
| } |
| |
| /* |
| * This function should return TRUE if the socket is to be assumed to |
| * be dead. Most commonly this happens when the server has closed the |
| * connection due to inactivity. |
| */ |
| static bool SocketIsDead(curl_socket_t sock) |
| { |
| int sval; |
| bool ret_val = TRUE; |
| |
| sval = SOCKET_READABLE(sock, 0); |
| if(sval == 0) |
| /* timeout */ |
| ret_val = FALSE; |
| |
| return ret_val; |
| } |
| |
| /* |
| * IsPipeliningPossible() |
| * |
| * Return a bitmask with the available pipelining and multiplexing options for |
| * the given requested connection. |
| */ |
| static int IsPipeliningPossible(const struct Curl_easy *handle, |
| const struct connectdata *conn) |
| { |
| int avail = 0; |
| |
| /* If a HTTP protocol and pipelining is enabled */ |
| if((conn->handler->protocol & PROTO_FAMILY_HTTP) && |
| (!conn->bits.protoconnstart || !conn->bits.close)) { |
| |
| if(Curl_pipeline_wanted(handle->multi, CURLPIPE_HTTP1) && |
| (handle->set.httpversion != CURL_HTTP_VERSION_1_0) && |
| (handle->set.httpreq == HTTPREQ_GET || |
| handle->set.httpreq == HTTPREQ_HEAD)) |
| /* didn't ask for HTTP/1.0 and a GET or HEAD */ |
| avail |= CURLPIPE_HTTP1; |
| |
| if(Curl_pipeline_wanted(handle->multi, CURLPIPE_MULTIPLEX) && |
| (handle->set.httpversion >= CURL_HTTP_VERSION_2)) |
| /* allows HTTP/2 */ |
| avail |= CURLPIPE_MULTIPLEX; |
| } |
| return avail; |
| } |
| |
| int Curl_removeHandleFromPipeline(struct Curl_easy *handle, |
| struct curl_llist *pipeline) |
| { |
| if(pipeline) { |
| struct curl_llist_element *curr; |
| |
| curr = pipeline->head; |
| while(curr) { |
| if(curr->ptr == handle) { |
| Curl_llist_remove(pipeline, curr, NULL); |
| return 1; /* we removed a handle */ |
| } |
| curr = curr->next; |
| } |
| } |
| |
| return 0; |
| } |
| |
| #if 0 /* this code is saved here as it is useful for debugging purposes */ |
| static void Curl_printPipeline(struct curl_llist *pipeline) |
| { |
| struct curl_llist_element *curr; |
| |
| curr = pipeline->head; |
| while(curr) { |
| struct Curl_easy *data = (struct Curl_easy *) curr->ptr; |
| infof(data, "Handle in pipeline: %s\n", data->state.path); |
| curr = curr->next; |
| } |
| } |
| #endif |
| |
| static struct Curl_easy* gethandleathead(struct curl_llist *pipeline) |
| { |
| struct curl_llist_element *curr = pipeline->head; |
| if(curr) { |
| return (struct Curl_easy *) curr->ptr; |
| } |
| |
| return NULL; |
| } |
| |
| /* remove the specified connection from all (possible) pipelines and related |
| queues */ |
| void Curl_getoff_all_pipelines(struct Curl_easy *data, |
| struct connectdata *conn) |
| { |
| bool recv_head = (conn->readchannel_inuse && |
| Curl_recvpipe_head(data, conn)); |
| bool send_head = (conn->writechannel_inuse && |
| Curl_sendpipe_head(data, conn)); |
| |
| if(Curl_removeHandleFromPipeline(data, &conn->recv_pipe) && recv_head) |
| Curl_pipeline_leave_read(conn); |
| if(Curl_removeHandleFromPipeline(data, &conn->send_pipe) && send_head) |
| Curl_pipeline_leave_write(conn); |
| } |
| |
| static void signalPipeClose(struct curl_llist *pipeline, bool pipe_broke) |
| { |
| struct curl_llist_element *curr; |
| |
| if(!pipeline) |
| return; |
| |
| curr = pipeline->head; |
| while(curr) { |
| struct curl_llist_element *next = curr->next; |
| struct Curl_easy *data = (struct Curl_easy *) curr->ptr; |
| |
| #ifdef DEBUGBUILD /* debug-only code */ |
| if(data->magic != CURLEASY_MAGIC_NUMBER) { |
| /* MAJOR BADNESS */ |
| infof(data, "signalPipeClose() found BAAD easy handle\n"); |
| } |
| #endif |
| |
| if(pipe_broke) |
| data->state.pipe_broke = TRUE; |
| Curl_multi_handlePipeBreak(data); |
| Curl_llist_remove(pipeline, curr, NULL); |
| curr = next; |
| } |
| } |
| |
| static bool |
| proxy_info_matches(const struct proxy_info* data, |
| const struct proxy_info* needle) |
| { |
| if((data->proxytype == needle->proxytype) && |
| (data->port == needle->port) && |
| Curl_safe_strcasecompare(data->host.name, needle->host.name)) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| /* |
| * This function checks if the given connection is dead and extracts it from |
| * the connection cache if so. |
| * |
| * When this is called as a Curl_conncache_foreach() callback, the connection |
| * cache lock is held! |
| * |
| * Returns TRUE if the connection was dead and extracted. |
| */ |
| static bool extract_if_dead(struct connectdata *conn, |
| struct Curl_easy *data) |
| { |
| size_t pipeLen = conn->send_pipe.size + conn->recv_pipe.size; |
| if(!pipeLen && !conn->inuse) { |
| /* The check for a dead socket makes sense only if there are no |
| handles in pipeline and the connection isn't already marked in |
| use */ |
| bool dead; |
| |
| if(conn->handler->connection_check) { |
| /* The protocol has a special method for checking the state of the |
| connection. Use it to check if the connection is dead. */ |
| unsigned int state; |
| |
| state = conn->handler->connection_check(conn, CONNCHECK_ISDEAD); |
| dead = (state & CONNRESULT_DEAD); |
| } |
| else { |
| /* Use the general method for determining the death of a connection */ |
| dead = SocketIsDead(conn->sock[FIRSTSOCKET]); |
| } |
| |
| if(dead) { |
| conn->data = data; |
| infof(data, "Connection %ld seems to be dead!\n", conn->connection_id); |
| Curl_conncache_remove_conn(conn, FALSE); |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| |
| struct prunedead { |
| struct Curl_easy *data; |
| struct connectdata *extracted; |
| }; |
| |
| /* |
| * Wrapper to use extract_if_dead() function in Curl_conncache_foreach() |
| * |
| */ |
| static int call_extract_if_dead(struct connectdata *conn, void *param) |
| { |
| struct prunedead *p = (struct prunedead *)param; |
| if(extract_if_dead(conn, p->data)) { |
| /* stop the iteration here, pass back the connection that was extracted */ |
| p->extracted = conn; |
| return 1; |
| } |
| return 0; /* continue iteration */ |
| } |
| |
| /* |
| * This function scans the connection cache for half-open/dead connections, |
| * closes and removes them. |
| * The cleanup is done at most once per second. |
| */ |
| static void prune_dead_connections(struct Curl_easy *data) |
| { |
| struct curltime now = Curl_now(); |
| time_t elapsed = Curl_timediff(now, data->state.conn_cache->last_cleanup); |
| |
| if(elapsed >= 1000L) { |
| struct prunedead prune; |
| prune.data = data; |
| prune.extracted = NULL; |
| while(Curl_conncache_foreach(data, data->state.conn_cache, &prune, |
| call_extract_if_dead)) { |
| /* disconnect it */ |
| (void)Curl_disconnect(prune.extracted, /* dead_connection */TRUE); |
| } |
| data->state.conn_cache->last_cleanup = now; |
| } |
| } |
| |
| |
| static size_t max_pipeline_length(struct Curl_multi *multi) |
| { |
| return multi ? multi->max_pipeline_length : 0; |
| } |
| |
| |
| /* |
| * Given one filled in connection struct (named needle), this function should |
| * detect if there already is one that has all the significant details |
| * exactly the same and thus should be used instead. |
| * |
| * If there is a match, this function returns TRUE - and has marked the |
| * connection as 'in-use'. It must later be called with ConnectionDone() to |
| * return back to 'idle' (unused) state. |
| * |
| * The force_reuse flag is set if the connection must be used, even if |
| * the pipelining strategy wants to open a new connection instead of reusing. |
| */ |
| static bool |
| ConnectionExists(struct Curl_easy *data, |
| struct connectdata *needle, |
| struct connectdata **usethis, |
| bool *force_reuse, |
| bool *waitpipe) |
| { |
| struct connectdata *check; |
| struct connectdata *chosen = 0; |
| bool foundPendingCandidate = FALSE; |
| int canpipe = IsPipeliningPossible(data, needle); |
| struct connectbundle *bundle; |
| |
| #ifdef USE_NTLM |
| bool wantNTLMhttp = ((data->state.authhost.want & |
| (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) && |
| (needle->handler->protocol & PROTO_FAMILY_HTTP)); |
| bool wantProxyNTLMhttp = (needle->bits.proxy_user_passwd && |
| ((data->state.authproxy.want & |
| (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) && |
| (needle->handler->protocol & PROTO_FAMILY_HTTP))); |
| #endif |
| |
| *force_reuse = FALSE; |
| *waitpipe = FALSE; |
| |
| /* We can't pipeline if the site is blacklisted */ |
| if((canpipe & CURLPIPE_HTTP1) && |
| Curl_pipeline_site_blacklisted(data, needle)) |
| canpipe &= ~ CURLPIPE_HTTP1; |
| |
| /* Look up the bundle with all the connections to this particular host. |
| Locks the connection cache, beware of early returns! */ |
| bundle = Curl_conncache_find_bundle(needle, data->state.conn_cache); |
| if(bundle) { |
| /* Max pipe length is zero (unlimited) for multiplexed connections */ |
| size_t max_pipe_len = (bundle->multiuse != BUNDLE_MULTIPLEX)? |
| max_pipeline_length(data->multi):0; |
| size_t best_pipe_len = max_pipe_len; |
| struct curl_llist_element *curr; |
| |
| infof(data, "Found bundle for host %s: %p [%s]\n", |
| (needle->bits.conn_to_host ? needle->conn_to_host.name : |
| needle->host.name), (void *)bundle, |
| (bundle->multiuse == BUNDLE_PIPELINING ? |
| "can pipeline" : |
| (bundle->multiuse == BUNDLE_MULTIPLEX ? |
| "can multiplex" : "serially"))); |
| |
| /* We can't pipeline if we don't know anything about the server */ |
| if(canpipe) { |
| if(bundle->multiuse <= BUNDLE_UNKNOWN) { |
| if((bundle->multiuse == BUNDLE_UNKNOWN) && data->set.pipewait) { |
| infof(data, "Server doesn't support multi-use yet, wait\n"); |
| *waitpipe = TRUE; |
| Curl_conncache_unlock(needle); |
| return FALSE; /* no re-use */ |
| } |
| |
| infof(data, "Server doesn't support multi-use (yet)\n"); |
| canpipe = 0; |
| } |
| if((bundle->multiuse == BUNDLE_PIPELINING) && |
| !Curl_pipeline_wanted(data->multi, CURLPIPE_HTTP1)) { |
| /* not asked for, switch off */ |
| infof(data, "Could pipeline, but not asked to!\n"); |
| canpipe = 0; |
| } |
| else if((bundle->multiuse == BUNDLE_MULTIPLEX) && |
| !Curl_pipeline_wanted(data->multi, CURLPIPE_MULTIPLEX)) { |
| infof(data, "Could multiplex, but not asked to!\n"); |
| canpipe = 0; |
| } |
| } |
| |
| curr = bundle->conn_list.head; |
| while(curr) { |
| bool match = FALSE; |
| size_t pipeLen; |
| |
| /* |
| * Note that if we use a HTTP proxy in normal mode (no tunneling), we |
| * check connections to that proxy and not to the actual remote server. |
| */ |
| check = curr->ptr; |
| curr = curr->next; |
| |
| if(extract_if_dead(check, data)) { |
| /* disconnect it */ |
| (void)Curl_disconnect(check, /* dead_connection */TRUE); |
| continue; |
| } |
| |
| pipeLen = check->send_pipe.size + check->recv_pipe.size; |
| |
| if(canpipe) { |
| if(check->bits.protoconnstart && check->bits.close) |
| continue; |
| |
| if(!check->bits.multiplex) { |
| /* If not multiplexing, make sure the connection is fine for HTTP/1 |
| pipelining */ |
| struct Curl_easy* sh = gethandleathead(&check->send_pipe); |
| struct Curl_easy* rh = gethandleathead(&check->recv_pipe); |
| if(sh) { |
| if(!(IsPipeliningPossible(sh, check) & CURLPIPE_HTTP1)) |
| continue; |
| } |
| else if(rh) { |
| if(!(IsPipeliningPossible(rh, check) & CURLPIPE_HTTP1)) |
| continue; |
| } |
| } |
| } |
| else { |
| if(pipeLen > 0) { |
| /* can only happen within multi handles, and means that another easy |
| handle is using this connection */ |
| continue; |
| } |
| |
| if(Curl_resolver_asynch()) { |
| /* ip_addr_str[0] is NUL only if the resolving of the name hasn't |
| completed yet and until then we don't re-use this connection */ |
| if(!check->ip_addr_str[0]) { |
| infof(data, |
| "Connection #%ld is still name resolving, can't reuse\n", |
| check->connection_id); |
| continue; |
| } |
| } |
| |
| if((check->sock[FIRSTSOCKET] == CURL_SOCKET_BAD) || |
| check->bits.close) { |
| if(!check->bits.close) |
| foundPendingCandidate = TRUE; |
| /* Don't pick a connection that hasn't connected yet or that is going |
| to get closed. */ |
| infof(data, "Connection #%ld isn't open enough, can't reuse\n", |
| check->connection_id); |
| #ifdef DEBUGBUILD |
| if(check->recv_pipe.size > 0) { |
| infof(data, |
| "BAD! Unconnected #%ld has a non-empty recv pipeline!\n", |
| check->connection_id); |
| } |
| #endif |
| continue; |
| } |
| } |
| |
| #ifdef USE_UNIX_SOCKETS |
| if(needle->unix_domain_socket) { |
| if(!check->unix_domain_socket) |
| continue; |
| if(strcmp(needle->unix_domain_socket, check->unix_domain_socket)) |
| continue; |
| if(needle->abstract_unix_socket != check->abstract_unix_socket) |
| continue; |
| } |
| else if(check->unix_domain_socket) |
| continue; |
| #endif |
| |
| if((needle->handler->flags&PROTOPT_SSL) != |
| (check->handler->flags&PROTOPT_SSL)) |
| /* don't do mixed SSL and non-SSL connections */ |
| if(get_protocol_family(check->handler->protocol) != |
| needle->handler->protocol || !check->tls_upgraded) |
| /* except protocols that have been upgraded via TLS */ |
| continue; |
| |
| if(needle->bits.httpproxy != check->bits.httpproxy || |
| needle->bits.socksproxy != check->bits.socksproxy) |
| continue; |
| |
| if(needle->bits.socksproxy && !proxy_info_matches(&needle->socks_proxy, |
| &check->socks_proxy)) |
| continue; |
| |
| if(needle->bits.conn_to_host != check->bits.conn_to_host) |
| /* don't mix connections that use the "connect to host" feature and |
| * connections that don't use this feature */ |
| continue; |
| |
| if(needle->bits.conn_to_port != check->bits.conn_to_port) |
| /* don't mix connections that use the "connect to port" feature and |
| * connections that don't use this feature */ |
| continue; |
| |
| if(needle->bits.httpproxy) { |
| if(!proxy_info_matches(&needle->http_proxy, &check->http_proxy)) |
| continue; |
| |
| if(needle->bits.tunnel_proxy != check->bits.tunnel_proxy) |
| continue; |
| |
| if(needle->http_proxy.proxytype == CURLPROXY_HTTPS) { |
| /* use https proxy */ |
| if(needle->handler->flags&PROTOPT_SSL) { |
| /* use double layer ssl */ |
| if(!Curl_ssl_config_matches(&needle->proxy_ssl_config, |
| &check->proxy_ssl_config)) |
| continue; |
| if(check->proxy_ssl[FIRSTSOCKET].state != ssl_connection_complete) |
| continue; |
| } |
| else { |
| if(!Curl_ssl_config_matches(&needle->ssl_config, |
| &check->ssl_config)) |
| continue; |
| if(check->ssl[FIRSTSOCKET].state != ssl_connection_complete) |
| continue; |
| } |
| } |
| } |
| |
| if(!canpipe && check->inuse) |
| /* this request can't be pipelined but the checked connection is |
| already in use so we skip it */ |
| continue; |
| |
| if((check->inuse) && (check->data->multi != needle->data->multi)) |
| /* this could be subject for pipeline/multiplex use, but only |
| if they belong to the same multi handle */ |
| continue; |
| |
| if(needle->localdev || needle->localport) { |
| /* If we are bound to a specific local end (IP+port), we must not |
| re-use a random other one, although if we didn't ask for a |
| particular one we can reuse one that was bound. |
| |
| This comparison is a bit rough and too strict. Since the input |
| parameters can be specified in numerous ways and still end up the |
| same it would take a lot of processing to make it really accurate. |
| Instead, this matching will assume that re-uses of bound connections |
| will most likely also re-use the exact same binding parameters and |
| missing out a few edge cases shouldn't hurt anyone very much. |
| */ |
| if((check->localport != needle->localport) || |
| (check->localportrange != needle->localportrange) || |
| (needle->localdev && |
| (!check->localdev || strcmp(check->localdev, needle->localdev)))) |
| continue; |
| } |
| |
| if(!(needle->handler->flags & PROTOPT_CREDSPERREQUEST)) { |
| /* This protocol requires credentials per connection, |
| so verify that we're using the same name and password as well */ |
| if(strcmp(needle->user, check->user) || |
| strcmp(needle->passwd, check->passwd)) { |
| /* one of them was different */ |
| continue; |
| } |
| } |
| |
| if(!needle->bits.httpproxy || (needle->handler->flags&PROTOPT_SSL) || |
| needle->bits.tunnel_proxy) { |
| /* The requested connection does not use a HTTP proxy or it uses SSL or |
| it is a non-SSL protocol tunneled or it is a non-SSL protocol which |
| is allowed to be upgraded via TLS */ |
| |
| if((strcasecompare(needle->handler->scheme, check->handler->scheme) || |
| (get_protocol_family(check->handler->protocol) == |
| needle->handler->protocol && check->tls_upgraded)) && |
| (!needle->bits.conn_to_host || strcasecompare( |
| needle->conn_to_host.name, check->conn_to_host.name)) && |
| (!needle->bits.conn_to_port || |
| needle->conn_to_port == check->conn_to_port) && |
| strcasecompare(needle->host.name, check->host.name) && |
| needle->remote_port == check->remote_port) { |
| /* The schemes match or the the protocol family is the same and the |
| previous connection was TLS upgraded, and the hostname and host |
| port match */ |
| if(needle->handler->flags & PROTOPT_SSL) { |
| /* This is a SSL connection so verify that we're using the same |
| SSL options as well */ |
| if(!Curl_ssl_config_matches(&needle->ssl_config, |
| &check->ssl_config)) { |
| DEBUGF(infof(data, |
| "Connection #%ld has different SSL parameters, " |
| "can't reuse\n", |
| check->connection_id)); |
| continue; |
| } |
| if(check->ssl[FIRSTSOCKET].state != ssl_connection_complete) { |
| foundPendingCandidate = TRUE; |
| DEBUGF(infof(data, |
| "Connection #%ld has not started SSL connect, " |
| "can't reuse\n", |
| check->connection_id)); |
| continue; |
| } |
| } |
| match = TRUE; |
| } |
| } |
| else { |
| /* The requested connection is using the same HTTP proxy in normal |
| mode (no tunneling) */ |
| match = TRUE; |
| } |
| |
| if(match) { |
| #if defined(USE_NTLM) |
| /* If we are looking for an HTTP+NTLM connection, check if this is |
| already authenticating with the right credentials. If not, keep |
| looking so that we can reuse NTLM connections if |
| possible. (Especially we must not reuse the same connection if |
| partway through a handshake!) */ |
| if(wantNTLMhttp) { |
| if(strcmp(needle->user, check->user) || |
| strcmp(needle->passwd, check->passwd)) |
| continue; |
| } |
| else if(check->ntlm.state != NTLMSTATE_NONE) { |
| /* Connection is using NTLM auth but we don't want NTLM */ |
| continue; |
| } |
| |
| /* Same for Proxy NTLM authentication */ |
| if(wantProxyNTLMhttp) { |
| /* Both check->http_proxy.user and check->http_proxy.passwd can be |
| * NULL */ |
| if(!check->http_proxy.user || !check->http_proxy.passwd) |
| continue; |
| |
| if(strcmp(needle->http_proxy.user, check->http_proxy.user) || |
| strcmp(needle->http_proxy.passwd, check->http_proxy.passwd)) |
| continue; |
| } |
| else if(check->proxyntlm.state != NTLMSTATE_NONE) { |
| /* Proxy connection is using NTLM auth but we don't want NTLM */ |
| continue; |
| } |
| |
| if(wantNTLMhttp || wantProxyNTLMhttp) { |
| /* Credentials are already checked, we can use this connection */ |
| chosen = check; |
| |
| if((wantNTLMhttp && |
| (check->ntlm.state != NTLMSTATE_NONE)) || |
| (wantProxyNTLMhttp && |
| (check->proxyntlm.state != NTLMSTATE_NONE))) { |
| /* We must use this connection, no other */ |
| *force_reuse = TRUE; |
| break; |
| } |
| |
| /* Continue look up for a better connection */ |
| continue; |
| } |
| #endif |
| if(canpipe) { |
| /* We can pipeline if we want to. Let's continue looking for |
| the optimal connection to use, i.e the shortest pipe that is not |
| blacklisted. */ |
| |
| if(pipeLen == 0) { |
| /* We have the optimal connection. Let's stop looking. */ |
| chosen = check; |
| break; |
| } |
| |
| /* We can't use the connection if the pipe is full */ |
| if(max_pipe_len && (pipeLen >= max_pipe_len)) { |
| infof(data, "Pipe is full, skip (%zu)\n", pipeLen); |
| continue; |
| } |
| #ifdef USE_NGHTTP2 |
| /* If multiplexed, make sure we don't go over concurrency limit */ |
| if(check->bits.multiplex) { |
| /* Multiplexed connections can only be HTTP/2 for now */ |
| struct http_conn *httpc = &check->proto.httpc; |
| if(pipeLen >= httpc->settings.max_concurrent_streams) { |
| infof(data, "MAX_CONCURRENT_STREAMS reached, skip (%zu)\n", |
| pipeLen); |
| continue; |
| } |
| } |
| #endif |
| /* We can't use the connection if the pipe is penalized */ |
| if(Curl_pipeline_penalized(data, check)) { |
| infof(data, "Penalized, skip\n"); |
| continue; |
| } |
| |
| if(max_pipe_len) { |
| if(pipeLen < best_pipe_len) { |
| /* This connection has a shorter pipe so far. We'll pick this |
| and continue searching */ |
| chosen = check; |
| best_pipe_len = pipeLen; |
| continue; |
| } |
| } |
| else { |
| /* When not pipelining (== multiplexed), we have a match here! */ |
| chosen = check; |
| infof(data, "Multiplexed connection found!\n"); |
| break; |
| } |
| } |
| else { |
| /* We have found a connection. Let's stop searching. */ |
| chosen = check; |
| break; |
| } |
| } |
| } |
| } |
| |
| if(chosen) { |
| /* mark it as used before releasing the lock */ |
| chosen->inuse = TRUE; |
| Curl_conncache_unlock(needle); |
| *usethis = chosen; |
| return TRUE; /* yes, we found one to use! */ |
| } |
| Curl_conncache_unlock(needle); |
| |
| if(foundPendingCandidate && data->set.pipewait) { |
| infof(data, |
| "Found pending candidate for reuse and CURLOPT_PIPEWAIT is set\n"); |
| *waitpipe = TRUE; |
| } |
| |
| return FALSE; /* no matching connecting exists */ |
| } |
| |
| /* after a TCP connection to the proxy has been verified, this function does |
| the next magic step. |
| |
| Note: this function's sub-functions call failf() |
| |
| */ |
| CURLcode Curl_connected_proxy(struct connectdata *conn, int sockindex) |
| { |
| CURLcode result = CURLE_OK; |
| |
| if(conn->bits.socksproxy) { |
| #ifndef CURL_DISABLE_PROXY |
| /* for the secondary socket (FTP), use the "connect to host" |
| * but ignore the "connect to port" (use the secondary port) |
| */ |
| const char * const host = conn->bits.httpproxy ? |
| conn->http_proxy.host.name : |
| conn->bits.conn_to_host ? |
| conn->conn_to_host.name : |
| sockindex == SECONDARYSOCKET ? |
| conn->secondaryhostname : conn->host.name; |
| const int port = conn->bits.httpproxy ? (int)conn->http_proxy.port : |
| sockindex == SECONDARYSOCKET ? conn->secondary_port : |
| conn->bits.conn_to_port ? conn->conn_to_port : |
| conn->remote_port; |
| conn->bits.socksproxy_connecting = TRUE; |
| switch(conn->socks_proxy.proxytype) { |
| case CURLPROXY_SOCKS5: |
| case CURLPROXY_SOCKS5_HOSTNAME: |
| result = Curl_SOCKS5(conn->socks_proxy.user, conn->socks_proxy.passwd, |
| host, port, sockindex, conn); |
| break; |
| |
| case CURLPROXY_SOCKS4: |
| case CURLPROXY_SOCKS4A: |
| result = Curl_SOCKS4(conn->socks_proxy.user, host, port, sockindex, |
| conn); |
| break; |
| |
| default: |
| failf(conn->data, "unknown proxytype option given"); |
| result = CURLE_COULDNT_CONNECT; |
| } /* switch proxytype */ |
| conn->bits.socksproxy_connecting = FALSE; |
| #else |
| (void)sockindex; |
| #endif /* CURL_DISABLE_PROXY */ |
| } |
| |
| return result; |
| } |
| |
| /* |
| * verboseconnect() displays verbose information after a connect |
| */ |
| #ifndef CURL_DISABLE_VERBOSE_STRINGS |
| void Curl_verboseconnect(struct connectdata *conn) |
| { |
| if(conn->data->set.verbose) |
| infof(conn->data, "Connected to %s (%s) port %ld (#%ld)\n", |
| conn->bits.socksproxy ? conn->socks_proxy.host.dispname : |
| conn->bits.httpproxy ? conn->http_proxy.host.dispname : |
| conn->bits.conn_to_host ? conn->conn_to_host.dispname : |
| conn->host.dispname, |
| conn->ip_addr_str, conn->port, conn->connection_id); |
| } |
| #endif |
| |
| int Curl_protocol_getsock(struct connectdata *conn, |
| curl_socket_t *socks, |
| int numsocks) |
| { |
| if(conn->handler->proto_getsock) |
| return conn->handler->proto_getsock(conn, socks, numsocks); |
| return GETSOCK_BLANK; |
| } |
| |
| int Curl_doing_getsock(struct connectdata *conn, |
| curl_socket_t *socks, |
| int numsocks) |
| { |
| if(conn && conn->handler->doing_getsock) |
| return conn->handler->doing_getsock(conn, socks, numsocks); |
| return GETSOCK_BLANK; |
| } |
| |
| /* |
| * We are doing protocol-specific connecting and this is being called over and |
| * over from the multi interface until the connection phase is done on |
| * protocol layer. |
| */ |
| |
| CURLcode Curl_protocol_connecting(struct connectdata *conn, |
| bool *done) |
| { |
| CURLcode result = CURLE_OK; |
| |
| if(conn && conn->handler->connecting) { |
| *done = FALSE; |
| result = conn->handler->connecting(conn, done); |
| } |
| else |
| *done = TRUE; |
| |
| return result; |
| } |
| |
| /* |
| * We are DOING this is being called over and over from the multi interface |
| * until the DOING phase is done on protocol layer. |
| */ |
| |
| CURLcode Curl_protocol_doing(struct connectdata *conn, bool *done) |
| { |
| CURLcode result = CURLE_OK; |
| |
| if(conn && conn->handler->doing) { |
| *done = FALSE; |
| result = conn->handler->doing(conn, done); |
| } |
| else |
| *done = TRUE; |
| |
| return result; |
| } |
| |
| /* |
| * We have discovered that the TCP connection has been successful, we can now |
| * proceed with some action. |
| * |
| */ |
| CURLcode Curl_protocol_connect(struct connectdata *conn, |
| bool *protocol_done) |
| { |
| CURLcode result = CURLE_OK; |
| |
| *protocol_done = FALSE; |
| |
| if(conn->bits.tcpconnect[FIRSTSOCKET] && conn->bits.protoconnstart) { |
| /* We already are connected, get back. This may happen when the connect |
| worked fine in the first call, like when we connect to a local server |
| or proxy. Note that we don't know if the protocol is actually done. |
| |
| Unless this protocol doesn't have any protocol-connect callback, as |
| then we know we're done. */ |
| if(!conn->handler->connecting) |
| *protocol_done = TRUE; |
| |
| return CURLE_OK; |
| } |
| |
| if(!conn->bits.protoconnstart) { |
| |
| result = Curl_proxy_connect(conn, FIRSTSOCKET); |
| if(result) |
| return result; |
| |
| if(CONNECT_FIRSTSOCKET_PROXY_SSL()) |
| /* wait for HTTPS proxy SSL initialization to complete */ |
| return CURLE_OK; |
| |
| if(conn->bits.tunnel_proxy && conn->bits.httpproxy && |
| Curl_connect_ongoing(conn)) |
| /* when using an HTTP tunnel proxy, await complete tunnel establishment |
| before proceeding further. Return CURLE_OK so we'll be called again */ |
| return CURLE_OK; |
| |
| if(conn->handler->connect_it) { |
| /* is there a protocol-specific connect() procedure? */ |
| |
| /* Call the protocol-specific connect function */ |
| result = conn->handler->connect_it(conn, protocol_done); |
| } |
| else |
| *protocol_done = TRUE; |
| |
| /* it has started, possibly even completed but that knowledge isn't stored |
| in this bit! */ |
| if(!result) |
| conn->bits.protoconnstart = TRUE; |
| } |
| |
| return result; /* pass back status */ |
| } |
| |
| /* |
| * Helpers for IDNA conversions. |
| */ |
| static bool is_ASCII_name(const char *hostname) |
| { |
| const unsigned char *ch = (const unsigned char *)hostname; |
| |
| while(*ch) { |
| if(*ch++ & 0x80) |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| /* |
| * Perform any necessary IDN conversion of hostname |
| */ |
| static CURLcode fix_hostname(struct connectdata *conn, struct hostname *host) |
| { |
| size_t len; |
| struct Curl_easy *data = conn->data; |
| |
| #ifndef USE_LIBIDN2 |
| (void)data; |
| (void)conn; |
| #elif defined(CURL_DISABLE_VERBOSE_STRINGS) |
| (void)conn; |
| #endif |
| |
| /* set the name we use to display the host name */ |
| host->dispname = host->name; |
| |
| len = strlen(host->name); |
| if(len && (host->name[len-1] == '.')) |
| /* strip off a single trailing dot if present, primarily for SNI but |
| there's no use for it */ |
| host->name[len-1] = 0; |
| |
| /* Check name for non-ASCII and convert hostname to ACE form if we can */ |
| if(!is_ASCII_name(host->name)) { |
| #ifdef USE_LIBIDN2 |
| if(idn2_check_version(IDN2_VERSION)) { |
| char *ace_hostname = NULL; |
| #if IDN2_VERSION_NUMBER >= 0x00140000 |
| /* IDN2_NFC_INPUT: Normalize input string using normalization form C. |
| IDN2_NONTRANSITIONAL: Perform Unicode TR46 non-transitional |
| processing. */ |
| int flags = IDN2_NFC_INPUT | IDN2_NONTRANSITIONAL; |
| #else |
| int flags = IDN2_NFC_INPUT; |
| #endif |
| int rc = idn2_lookup_ul((const char *)host->name, &ace_hostname, flags); |
| if(rc == IDN2_OK) { |
| host->encalloc = (char *)ace_hostname; |
| /* change the name pointer to point to the encoded hostname */ |
| host->name = host->encalloc; |
| } |
| else { |
| failf(data, "Failed to convert %s to ACE; %s\n", host->name, |
| idn2_strerror(rc)); |
| return CURLE_URL_MALFORMAT; |
| } |
| } |
| #elif defined(USE_WIN32_IDN) |
| char *ace_hostname = NULL; |
| |
| if(curl_win32_idn_to_ascii(host->name, &ace_hostname)) { |
| host->encalloc = ace_hostname; |
| /* change the name pointer to point to the encoded hostname */ |
| host->name = host->encalloc; |
| } |
| else { |
| failf(data, "Failed to convert %s to ACE;\n", host->name); |
| return CURLE_URL_MALFORMAT; |
| } |
| #else |
| infof(data, "IDN support not present, can't parse Unicode domains\n"); |
| #endif |
| } |
| { |
| char *hostp; |
| for(hostp = host->name; *hostp; hostp++) { |
| if(*hostp <= 32) { |
| failf(data, "Host name '%s' contains bad letter", host->name); |
| return CURLE_URL_MALFORMAT; |
| } |
| } |
| } |
| return CURLE_OK; |
| } |
| |
| /* |
| * Frees data allocated by fix_hostname() |
| */ |
| static void free_fixed_hostname(struct hostname *host) |
| { |
| #if defined(USE_LIBIDN2) |
| if(host->encalloc) { |
| idn2_free(host->encalloc); /* must be freed with idn2_free() since this was |
| allocated by libidn */ |
| host->encalloc = NULL; |
| } |
| #elif defined(USE_WIN32_IDN) |
| free(host->encalloc); /* must be freed with free() since this was |
| allocated by curl_win32_idn_to_ascii */ |
| host->encalloc = NULL; |
| #else |
| (void)host; |
| #endif |
| } |
| |
| static void llist_dtor(void *user, void *element) |
| { |
| (void)user; |
| (void)element; |
| /* Do nothing */ |
| } |
| |
| /* |
| * Allocate and initialize a new connectdata object. |
| */ |
| static struct connectdata *allocate_conn(struct Curl_easy *data) |
| { |
| struct connectdata *conn = calloc(1, sizeof(struct connectdata)); |
| if(!conn) |
| return NULL; |
| |
| #ifdef USE_SSL |
| /* The SSL backend-specific data (ssl_backend_data) objects are allocated as |
| a separate array to ensure suitable alignment. |
| Note that these backend pointers can be swapped by vtls (eg ssl backend |
| data becomes proxy backend data). */ |
| { |
| size_t sslsize = Curl_ssl->sizeof_ssl_backend_data; |
| char *ssl = calloc(4, sslsize); |
| if(!ssl) { |
| free(conn); |
| return NULL; |
| } |
| conn->ssl_extra = ssl; |
| conn->ssl[0].backend = (void *)ssl; |
| conn->ssl[1].backend = (void *)(ssl + sslsize); |
| conn->proxy_ssl[0].backend = (void *)(ssl + 2 * sslsize); |
| conn->proxy_ssl[1].backend = (void *)(ssl + 3 * sslsize); |
| } |
| #endif |
| |
| conn->handler = &Curl_handler_dummy; /* Be sure we have a handler defined |
| already from start to avoid NULL |
| situations and checks */ |
| |
| /* and we setup a few fields in case we end up actually using this struct */ |
| |
| conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */ |
| conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */ |
| conn->tempsock[0] = CURL_SOCKET_BAD; /* no file descriptor */ |
| conn->tempsock[1] = CURL_SOCKET_BAD; /* no file descriptor */ |
| conn->connection_id = -1; /* no ID */ |
| conn->port = -1; /* unknown at this point */ |
| conn->remote_port = -1; /* unknown at this point */ |
| #if defined(USE_RECV_BEFORE_SEND_WORKAROUND) && defined(DEBUGBUILD) |
| conn->postponed[0].bindsock = CURL_SOCKET_BAD; /* no file descriptor */ |
| conn->postponed[1].bindsock = CURL_SOCKET_BAD; /* no file descriptor */ |
| #endif /* USE_RECV_BEFORE_SEND_WORKAROUND && DEBUGBUILD */ |
| |
| /* Default protocol-independent behavior doesn't support persistent |
| connections, so we set this to force-close. Protocols that support |
| this need to set this to FALSE in their "curl_do" functions. */ |
| connclose(conn, "Default to force-close"); |
| |
| /* Store creation time to help future close decision making */ |
| conn->created = Curl_now(); |
| |
| conn->data = data; /* Setup the association between this connection |
| and the Curl_easy */ |
| |
| conn->http_proxy.proxytype = data->set.proxytype; |
| conn->socks_proxy.proxytype = CURLPROXY_SOCKS4; |
| |
| #ifdef CURL_DISABLE_PROXY |
| |
| conn->bits.proxy = FALSE; |
| conn->bits.httpproxy = FALSE; |
| conn->bits.socksproxy = FALSE; |
| conn->bits.proxy_user_passwd = FALSE; |
| conn->bits.tunnel_proxy = FALSE; |
| |
| #else /* CURL_DISABLE_PROXY */ |
| |
| /* note that these two proxy bits are now just on what looks to be |
| requested, they may be altered down the road */ |
| conn->bits.proxy = (data->set.str[STRING_PROXY] && |
| *data->set.str[STRING_PROXY]) ? TRUE : FALSE; |
| conn->bits.httpproxy = (conn->bits.proxy && |
| (conn->http_proxy.proxytype == CURLPROXY_HTTP || |
| conn->http_proxy.proxytype == CURLPROXY_HTTP_1_0 || |
| conn->http_proxy.proxytype == CURLPROXY_HTTPS)) ? |
| TRUE : FALSE; |
| conn->bits.socksproxy = (conn->bits.proxy && |
| !conn->bits.httpproxy) ? TRUE : FALSE; |
| |
| if(data->set.str[STRING_PRE_PROXY] && *data->set.str[STRING_PRE_PROXY]) { |
| conn->bits.proxy = TRUE; |
| conn->bits.socksproxy = TRUE; |
| } |
| |
| conn->bits.proxy_user_passwd = |
| (data->set.str[STRING_PROXYUSERNAME]) ? TRUE : FALSE; |
| conn->bits.tunnel_proxy = data->set.tunnel_thru_httpproxy; |
| |
| #endif /* CURL_DISABLE_PROXY */ |
| |
| conn->bits.user_passwd = (data->set.str[STRING_USERNAME]) ? TRUE : FALSE; |
| conn->bits.ftp_use_epsv = data->set.ftp_use_epsv; |
| conn->bits.ftp_use_eprt = data->set.ftp_use_eprt; |
| |
| conn->ssl_config.verifystatus = data->set.ssl.primary.verifystatus; |
| conn->ssl_config.verifypeer = data->set.ssl.primary.verifypeer; |
| conn->ssl_config.verifyhost = data->set.ssl.primary.verifyhost; |
| conn->proxy_ssl_config.verifystatus = |
| data->set.proxy_ssl.primary.verifystatus; |
| conn->proxy_ssl_config.verifypeer = data->set.proxy_ssl.primary.verifypeer; |
| conn->proxy_ssl_config.verifyhost = data->set.proxy_ssl.primary.verifyhost; |
| |
| conn->ip_version = data->set.ipver; |
| |
| #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) && \ |
| defined(NTLM_WB_ENABLED) |
| conn->ntlm_auth_hlpr_socket = CURL_SOCKET_BAD; |
| conn->ntlm_auth_hlpr_pid = 0; |
| conn->challenge_header = NULL; |
| conn->response_header = NULL; |
| #endif |
| |
| if(Curl_pipeline_wanted(data->multi, CURLPIPE_HTTP1) && |
| !conn->master_buffer) { |
| /* Allocate master_buffer to be used for HTTP/1 pipelining */ |
| conn->master_buffer = calloc(MASTERBUF_SIZE, sizeof(char)); |
| if(!conn->master_buffer) |
| goto error; |
| } |
| |
| /* Initialize the pipeline lists */ |
| Curl_llist_init(&conn->send_pipe, (curl_llist_dtor) llist_dtor); |
| Curl_llist_init(&conn->recv_pipe, (curl_llist_dtor) llist_dtor); |
| |
| #ifdef HAVE_GSSAPI |
| conn->data_prot = PROT_CLEAR; |
| #endif |
| |
| /* Store the local bind parameters that will be used for this connection */ |
| if(data->set.str[STRING_DEVICE]) { |
| conn->localdev = strdup(data->set.str[STRING_DEVICE]); |
| if(!conn->localdev) |
| goto error; |
| } |
| conn->localportrange = data->set.localportrange; |
| conn->localport = data->set.localport; |
| |
| /* the close socket stuff needs to be copied to the connection struct as |
| it may live on without (this specific) Curl_easy */ |
| conn->fclosesocket = data->set.fclosesocket; |
| conn->closesocket_client = data->set.closesocket_client; |
| |
| return conn; |
| error: |
| |
| Curl_llist_destroy(&conn->send_pipe, NULL); |
| Curl_llist_destroy(&conn->recv_pipe, NULL); |
| |
| free(conn->master_buffer); |
| free(conn->localdev); |
| #ifdef USE_SSL |
| free(conn->ssl_extra); |
| #endif |
| free(conn); |
| return NULL; |
| } |
| |
| static CURLcode findprotocol(struct Curl_easy *data, |
| struct connectdata *conn, |
| const char *protostr) |
| { |
| const struct Curl_handler * const *pp; |
| const struct Curl_handler *p; |
| |
| /* Scan protocol handler table and match against 'protostr' to set a few |
| variables based on the URL. Now that the handler may be changed later |
| when the protocol specific setup function is called. */ |
| for(pp = protocols; (p = *pp) != NULL; pp++) { |
| if(strcasecompare(p->scheme, protostr)) { |
| /* Protocol found in table. Check if allowed */ |
| if(!(data->set.allowed_protocols & p->protocol)) |
| /* nope, get out */ |
| break; |
| |
| /* it is allowed for "normal" request, now do an extra check if this is |
| the result of a redirect */ |
| if(data->state.this_is_a_follow && |
| !(data->set.redir_protocols & p->protocol)) |
| /* nope, get out */ |
| break; |
| |
| /* Perform setup complement if some. */ |
| conn->handler = conn->given = p; |
| |
| /* 'port' and 'remote_port' are set in setup_connection_internals() */ |
| return CURLE_OK; |
| } |
| } |
| |
| |
| /* The protocol was not found in the table, but we don't have to assign it |
| to anything since it is already assigned to a dummy-struct in the |
| create_conn() function when the connectdata struct is allocated. */ |
| failf(data, "Protocol \"%s\" not supported or disabled in " LIBCURL_NAME, |
| protostr); |
| |
| return CURLE_UNSUPPORTED_PROTOCOL; |
| } |
| |
| /* |
| * Parse URL and fill in the relevant members of the connection struct. |
| */ |
| static CURLcode parseurlandfillconn(struct Curl_easy *data, |
| struct connectdata *conn, |
| bool *prot_missing, |
| char **userp, char **passwdp, |
| char **optionsp) |
| { |
| char *at; |
| char *fragment; |
| char *path = data->state.path; |
| char *query; |
| int i; |
| int rc; |
| const char *protop = ""; |
| CURLcode result; |
| bool rebuild_url = FALSE; |
| bool url_has_scheme = FALSE; |
| char protobuf[16]; |
| |
| *prot_missing = FALSE; |
| |
| /* We might pass the entire URL into the request so we need to make sure |
| * there are no bad characters in there.*/ |
| if(strpbrk(data->change.url, "\r\n")) { |
| failf(data, "Illegal characters found in URL"); |
| return CURLE_URL_MALFORMAT; |
| } |
| |
| /************************************************************* |
| * Parse the URL. |
| * |
| * We need to parse the url even when using the proxy, because we will need |
| * the hostname and port in case we are trying to SSL connect through the |
| * proxy -- and we don't know if we will need to use SSL until we parse the |
| * url ... |
| ************************************************************/ |
| if(data->change.url[0] == ':') { |
| failf(data, "Bad URL, colon is first character"); |
| return CURLE_URL_MALFORMAT; |
| } |
| |
| /* MSDOS/Windows style drive prefix, eg c: in c:foo */ |
| #define STARTS_WITH_DRIVE_PREFIX(str) \ |
| ((('a' <= str[0] && str[0] <= 'z') || \ |
| ('A' <= str[0] && str[0] <= 'Z')) && \ |
| (str[1] == ':')) |
| |
| /* MSDOS/Windows style drive prefix, optionally with |
| * a '|' instead of ':', followed by a slash or NUL */ |
| #define STARTS_WITH_URL_DRIVE_PREFIX(str) \ |
| ((('a' <= (str)[0] && (str)[0] <= 'z') || \ |
| ('A' <= (str)[0] && (str)[0] <= 'Z')) && \ |
| ((str)[1] == ':' || (str)[1] == '|') && \ |
| ((str)[2] == '/' || (str)[2] == '\\' || (str)[2] == 0)) |
| |
| /* Don't mistake a drive letter for a scheme if the default protocol is file. |
| curld --proto-default file c:/foo/bar.txt */ |
| if(STARTS_WITH_DRIVE_PREFIX(data->change.url) && |
| data->set.str[STRING_DEFAULT_PROTOCOL] && |
| strcasecompare(data->set.str[STRING_DEFAULT_PROTOCOL], "file")) { |
| ; /* do nothing */ |
| } |
| else { /* check for a scheme */ |
| for(i = 0; i < 16 && data->change.url[i]; ++i) { |
| if(data->change.url[i] == '/') |
| break; |
| if(data->change.url[i] == ':') { |
| url_has_scheme = TRUE; |
| break; |
| } |
| } |
| } |
| |
| /* handle the file: scheme */ |
| if((url_has_scheme && strncasecompare(data->change.url, "file:", 5)) || |
| (!url_has_scheme && data->set.str[STRING_DEFAULT_PROTOCOL] && |
| strcasecompare(data->set.str[STRING_DEFAULT_PROTOCOL], "file"))) { |
| if(url_has_scheme) |
| rc = sscanf(data->change.url, "%*15[^\n/:]:%[^\n]", path); |
| else |
| rc = sscanf(data->change.url, "%[^\n]", path); |
| |
| if(rc != 1) { |
| failf(data, "Bad URL"); |
| return CURLE_URL_MALFORMAT; |
| } |
| |
| if(url_has_scheme && path[0] == '/' && path[1] == '/' && |
| path[2] == '/' && path[3] == '/') { |
| /* This appears to be a UNC string (usually indicating a SMB share). |
| * We don't do SMB in file: URLs. (TODO?) |
| */ |
| failf(data, "SMB shares are not supported in file: URLs."); |
| return CURLE_URL_MALFORMAT; |
| } |
| |
| /* Extra handling URLs with an authority component (i.e. that start with |
| * "file://") |
| * |
| * We allow omitted hostname (e.g. file:/<path>) -- valid according to |
| * RFC 8089, but not the (current) WHAT-WG URL spec. |
| */ |
| if(url_has_scheme && path[0] == '/' && path[1] == '/') { |
| /* swallow the two slashes */ |
| char *ptr = &path[2]; |
| |
| /* |
| * According to RFC 8089, a file: URL can be reliably dereferenced if: |
| * |
| * o it has no/blank hostname, or |
| * |
| * o the hostname matches "localhost" (case-insensitively), or |
| * |
| * o the hostname is a FQDN that resolves to this machine. |
| * |
| * For brevity, we only consider URLs with empty, "localhost", or |
| * "127.0.0.1" hostnames as local. |
| * |
| * Additionally, there is an exception for URLs with a Windows drive |
| * letter in the authority (which was accidentally omitted from RFC 8089 |
| * Appendix E, but believe me, it was meant to be there. --MK) |
| */ |
| if(ptr[0] != '/' && !STARTS_WITH_URL_DRIVE_PREFIX(ptr)) { |
| /* the URL includes a host name, it must match "localhost" or |
| "127.0.0.1" to be valid */ |
| if(!checkprefix("localhost/", ptr) && |
| !checkprefix("127.0.0.1/", ptr)) { |
| failf(data, "Invalid file://hostname/, " |
| "expected localhost or 127.0.0.1 or none"); |
| return CURLE_URL_MALFORMAT; |
| } |
| ptr += 9; /* now points to the slash after the host */ |
| } |
| |
| /* |
| * RFC 8089, Appendix D, Section D.1, says: |
| * |
| * > In a POSIX file system, the root of the file system is represented |
| * > as a directory with a zero-length name, usually written as "/"; the |
| * > presence of this root in a file URI can be taken as given by the |
| * > initial slash in the "path-absolute" rule. |
| * |
| * i.e. the first slash is part of the path. |
| * |
| * However in RFC 1738 the "/" between the host (or port) and the |
| * URL-path was NOT part of the URL-path. Any agent that followed the |
| * older spec strictly, and wanted to refer to a file with an absolute |
| * path, would have included a second slash. So if there are two |
| * slashes, swallow one. |
| */ |
| if('/' == ptr[1]) /* note: the only way ptr[0]!='/' is if ptr[1]==':' */ |
| ptr++; |
| |
| /* This cannot be done with strcpy, as the memory chunks overlap! */ |
| memmove(path, ptr, strlen(ptr) + 1); |
| } |
| |
| #if !defined(MSDOS) && !defined(WIN32) && !defined(__CYGWIN__) |
| /* Don't allow Windows drive letters when not in Windows. |
| * This catches both "file:/c:" and "file:c:" */ |
| if(('/' == path[0] && STARTS_WITH_URL_DRIVE_PREFIX(&path[1])) || |
| STARTS_WITH_URL_DRIVE_PREFIX(path)) { |
| failf(data, "File drive letters are only accepted in MSDOS/Windows."); |
| return CURLE_URL_MALFORMAT; |
| } |
| #else |
| /* If the path starts with a slash and a drive letter, ditch the slash */ |
| if('/' == path[0] && STARTS_WITH_URL_DRIVE_PREFIX(&path[1])) { |
| /* This cannot be done with strcpy, as the memory chunks overlap! */ |
| memmove(path, &path[1], strlen(&path[1]) + 1); |
| } |
| #endif |
| |
| protop = "file"; /* protocol string */ |
| *prot_missing = !url_has_scheme; |
| } |
| else { |
| /* clear path */ |
| char slashbuf[4]; |
| path[0] = 0; |
| |
| rc = sscanf(data->change.url, |
| "%15[^\n/:]:%3[/]%[^\n/?#]%[^\n]", |
| protobuf, slashbuf, conn->host.name, path); |
| if(2 == rc) { |
| failf(data, "Bad URL"); |
| return CURLE_URL_MALFORMAT; |
| } |
| if(3 > rc) { |
| |
| /* |
| * The URL was badly formatted, let's try the browser-style _without_ |
| * protocol specified like 'http://'. |
| */ |
| rc = sscanf(data->change.url, "%[^\n/?#]%[^\n]", conn->host.name, path); |
| if(1 > rc) { |
| /* |
| * We couldn't even get this format. |
| * djgpp 2.04 has a sscanf() bug where 'conn->host.name' is |
| * assigned, but the return value is EOF! |
| */ |
| #if defined(__DJGPP__) && (DJGPP_MINOR == 4) |
| if(!(rc == -1 && *conn->host.name)) |
| #endif |
| { |
| failf(data, "<url> malformed"); |
| return CURLE_URL_MALFORMAT; |
| } |
| } |
| |
| /* |
| * Since there was no protocol part specified in the URL use the |
| * user-specified default protocol. If we weren't given a default make a |
| * guess by matching some protocols against the host's outermost |
| * sub-domain name. Finally if there was no match use HTTP. |
| */ |
| |
| protop = data->set.str[STRING_DEFAULT_PROTOCOL]; |
| if(!protop) { |
| /* Note: if you add a new protocol, please update the list in |
| * lib/version.c too! */ |
| if(checkprefix("FTP.", conn->host.name)) |
| protop = "ftp"; |
| else if(checkprefix("DICT.", conn->host.name)) |
| protop = "DICT"; |
| else if(checkprefix("LDAP.", conn->host.name)) |
| protop = "LDAP"; |
| else if(checkprefix("IMAP.", conn->host.name)) |
| protop = "IMAP"; |
| else if(checkprefix("SMTP.", conn->host.name)) |
| protop = "smtp"; |
| else if(checkprefix("POP3.", conn->host.name)) |
| protop = "pop3"; |
| else |
| protop = "http"; |
| } |
| |
| *prot_missing = TRUE; /* not given in URL */ |
| } |
| else { |
| size_t s = strlen(slashbuf); |
| protop = protobuf; |
| if(s != 2) { |
| infof(data, "Unwillingly accepted illegal URL using %d slash%s!\n", |
| s, s>1?"es":""); |
| |
| if(data->change.url_alloc) |
| free(data->change.url); |
| /* repair the URL to use two slashes */ |
| data->change.url = aprintf("%s://%s%s", |
| protobuf, conn->host.name, path); |
| if(!data->change.url) |
| return CURLE_OUT_OF_MEMORY; |
| data->change.url_alloc = TRUE; |
| } |
| } |
| } |
| |
| /* We search for '?' in the host name (but only on the right side of a |
| * @-letter to allow ?-letters in username and password) to handle things |
| * like http://example.com?param= (notice the missing '/'). |
| */ |
| at = strchr(conn->host.name, '@'); |
| if(at) |
| query = strchr(at + 1, '?'); |
| else |
| query = strchr(conn->host.name, '?'); |
| |
| if(query) { |
| /* We must insert a slash before the '?'-letter in the URL. If the URL had |
| a slash after the '?', that is where the path currently begins and the |
| '?string' is still part of the host name. |
| |
| We must move the trailing part from the host name and put it first in |
| the path. And have it all prefixed with a slash. |
| */ |
| |
| size_t hostlen = strlen(query); |
| size_t pathlen = strlen(path); |
| |
| /* move the existing path plus the zero byte forward, to make room for |
| the host-name part */ |
| memmove(path + hostlen + 1, path, pathlen + 1); |
| |
| /* now copy the trailing host part in front of the existing path */ |
| memcpy(path + 1, query, hostlen); |
| |
| path[0]='/'; /* prepend the missing slash */ |
| rebuild_url = TRUE; |
| |
| *query = 0; /* now cut off the hostname at the ? */ |
| } |
| else if(!path[0]) { |
| /* if there's no path set, use a single slash */ |
| strcpy(path, "/"); |
| rebuild_url = TRUE; |
| } |
| |
| /* If the URL is malformatted (missing a '/' after hostname before path) we |
| * insert a slash here. The only letters except '/' that can start a path is |
| * '?' and '#' - as controlled by the two sscanf() patterns above. |
| */ |
| if(path[0] != '/') { |
| /* We need this function to deal with overlapping memory areas. We know |
| that the memory area 'path' points to is 'urllen' bytes big and that |
| is bigger than the path. Use +1 to move the zero byte too. */ |
| memmove(&path[1], path, strlen(path) + 1); |
| path[0] = '/'; |
| rebuild_url = TRUE; |
| } |
| else if(!data->set.path_as_is) { |
| /* sanitise paths and remove ../ and ./ sequences according to RFC3986 */ |
| char *newp = Curl_dedotdotify(path); |
| if(!newp) |
| return CURLE_OUT_OF_MEMORY; |
| |
| if(strcmp(newp, path)) { |
| rebuild_url = TRUE; |
| free(data->state.pathbuffer); |
| data->state.pathbuffer = newp; |
| data->state.path = newp; |
| path = newp; |
| } |
| else |
| free(newp); |
| } |
| |
| /* |
| * "rebuild_url" means that one or more URL components have been modified so |
| * we need to generate an updated full version. We need the corrected URL |
| * when communicating over HTTP proxy and we don't know at this point if |
| * we're using a proxy or not. |
| */ |
| if(rebuild_url) { |
| char *reurl; |
| |
| size_t plen = strlen(path); /* new path, should be 1 byte longer than |
| the original */ |
| size_t prefixlen = strlen(conn->host.name); |
| |
| if(!*prot_missing) { |
| size_t protolen = strlen(protop); |
| |
| if(curl_strnequal(protop, data->change.url, protolen)) |
| prefixlen += protolen; |
| else { |
| failf(data, "<url> malformed"); |
| return CURLE_URL_MALFORMAT; |
| } |
| |
| if(curl_strnequal("://", &data->change.url[protolen], 3)) |
| prefixlen += 3; |
| /* only file: is allowed to omit one or both slashes */ |
| else if(curl_strnequal("file:", data->change.url, 5)) |
| prefixlen += 1 + (data->change.url[5] == '/'); |
| else { |
| failf(data, "<url> malformed"); |
| return CURLE_URL_MALFORMAT; |
| } |
| } |
| |
| reurl = malloc(prefixlen + plen + 1); |
| if(!reurl) |
| return CURLE_OUT_OF_MEMORY; |
| |
| /* copy the prefix */ |
| memcpy(reurl, data->change.url, prefixlen); |
| |
| /* append the trailing piece + zerobyte */ |
| memcpy(&reurl[prefixlen], path, plen + 1); |
| |
| /* possible free the old one */ |
| if(data->change.url_alloc) { |
| Curl_safefree(data->change.url); |
| data->change.url_alloc = FALSE; |
| } |
| |
| infof(data, "Rebuilt URL to: %s\n", reurl); |
| |
| data->change.url = reurl; |
| data->change.url_alloc = TRUE; /* free this later */ |
| } |
| |
| result = findprotocol(data, conn, protop); |
| if(result) |
| return result; |
| |
| /* |
| * Parse the login details from the URL and strip them out of |
| * the host name |
| */ |
| result = parse_url_login(data, conn, userp, passwdp, optionsp); |
| if(result) |
| return result; |
| |
| if(conn->host.name[0] == '[') { |
| /* This looks like an IPv6 address literal. See if there is an address |
| scope if there is no location header */ |
| char *percent = strchr(conn->host.name, '%'); |
| if(percent) { |
| unsigned int identifier_offset = 3; |
| char *endp; |
| unsigned long scope; |
| if(strncmp("%25", percent, 3) != 0) { |
| infof(data, |
| "Please URL encode %% as %%25, see RFC 6874.\n"); |
| identifier_offset = 1; |
| } |
| scope = strtoul(percent + identifier_offset, &endp, 10); |
| if(*endp == ']') { |
| /* The address scope was well formed. Knock it out of the |
| hostname. */ |
| memmove(percent, endp, strlen(endp) + 1); |
| conn->scope_id = (unsigned int)scope; |
| } |
| else { |
| /* Zone identifier is not numeric */ |
| #if defined(HAVE_NET_IF_H) && defined(IFNAMSIZ) && defined(HAVE_IF_NAMETOINDEX) |
| char ifname[IFNAMSIZ + 2]; |
| char *square_bracket; |
| unsigned int scopeidx = 0; |
| strncpy(ifname, percent + identifier_offset, IFNAMSIZ + 2); |
| /* Ensure nullbyte termination */ |
| ifname[IFNAMSIZ + 1] = '\0'; |
| square_bracket = strchr(ifname, ']'); |
| if(square_bracket) { |
| /* Remove ']' */ |
| *square_bracket = '\0'; |
| scopeidx = if_nametoindex(ifname); |
| if(scopeidx == 0) { |
| infof(data, "Invalid network interface: %s; %s\n", ifname, |
| strerror(errno)); |
| } |
| } |
| if(scopeidx > 0) { |
| char *p = percent + identifier_offset + strlen(ifname); |
| |
| /* Remove zone identifier from hostname */ |
| memmove(percent, p, strlen(p) + 1); |
| conn->scope_id = scopeidx; |
| } |
| else |
| #endif /* HAVE_NET_IF_H && IFNAMSIZ */ |
| infof(data, "Invalid IPv6 address format\n"); |
| } |
| } |
| } |
| |
| if(data->set.scope_id) |
| /* Override any scope that was set above. */ |
| conn->scope_id = data->set.scope_id; |
| |
| /* Remove the fragment part of the path. Per RFC 2396, this is always the |
| last part of the URI. We are looking for the first '#' so that we deal |
| gracefully with non conformant URI such as http://example.com#foo#bar. */ |
| fragment = strchr(path, '#'); |
| if(fragment) { |
| *fragment = 0; |
| |
| /* we know the path part ended with a fragment, so we know the full URL |
| string does too and we need to cut it off from there so it isn't used |
| over proxy */ |
| fragment = strchr(data->change.url, '#'); |
| if(fragment) |
| *fragment = 0; |
| } |
| |
| /* |
| * So if the URL was A://B/C#D, |
| * protop is A |
| * conn->host.name is B |
| * data->state.path is /C |
| */ |
| return CURLE_OK; |
| } |
| |
| /* |
| * If we're doing a resumed transfer, we need to setup our stuff |
| * properly. |
| */ |
| static CURLcode setup_range(struct Curl_easy *data) |
| { |
| struct UrlState *s = &data->state; |
| s->resume_from = data->set.set_resume_from; |
| if(s->resume_from || data->set.str[STRING_SET_RANGE]) { |
| if(s->rangestringalloc) |
| free(s->range); |
| |
| if(s->resume_from) |
| s->range = aprintf("%" CURL_FORMAT_CURL_OFF_TU "-", s->resume_from); |
| else |
| s->range = strdup(data->set.str[STRING_SET_RANGE]); |
| |
| s->rangestringalloc = (s->range) ? TRUE : FALSE; |
| |
| if(!s->range) |
| return CURLE_OUT_OF_MEMORY; |
| |
| /* tell ourselves to fetch this range */ |
| s->use_range = TRUE; /* enable range download */ |
| } |
| else |
| s->use_range = FALSE; /* disable range download */ |
| |
| return CURLE_OK; |
| } |
| |
| |
| /* |
| * setup_connection_internals() - |
| * |
| * Setup connection internals specific to the requested protocol in the |
| * Curl_easy. This is inited and setup before the connection is made but |
| * is about the particular protocol that is to be used. |
| * |
| * This MUST get called after proxy magic has been figured out. |
| */ |
| static CURLcode setup_connection_internals(struct connectdata *conn) |
| { |
| const struct Curl_handler * p; |
| CURLcode result; |
| struct Curl_easy *data = conn->data; |
| |
| /* in some case in the multi state-machine, we go back to the CONNECT state |
| and then a second (or third or...) call to this function will be made |
| without doing a DISCONNECT or DONE in between (since the connection is |
| yet in place) and therefore this function needs to first make sure |
| there's no lingering previous data allocated. */ |
| Curl_free_request_state(data); |
| |
| memset(&data->req, 0, sizeof(struct SingleRequest)); |
| data->req.maxdownload = -1; |
| |
| conn->socktype = SOCK_STREAM; /* most of them are TCP streams */ |
| |
| /* Perform setup complement if some. */ |
| p = conn->handler; |
| |
| if(p->setup_connection) { |
| result = (*p->setup_connection)(conn); |
| |
| if(result) |
| return result; |
| |
| p = conn->handler; /* May have changed. */ |
| } |
| |
| if(conn->port < 0) |
| /* we check for -1 here since if proxy was detected already, this |
| was very likely already set to the proxy port */ |
| conn->port = p->defport; |
| |
| return CURLE_OK; |
| } |
| |
| /* |
| * Curl_free_request_state() should free temp data that was allocated in the |
| * Curl_easy for this single request. |
| */ |
| |
| void Curl_free_request_state(struct Curl_easy *data) |
| { |
| Curl_safefree(data->req.protop); |
| Curl_safefree(data->req.newurl); |
| } |
| |
| |
| #ifndef CURL_DISABLE_PROXY |
| /**************************************************************** |
| * Checks if the host is in the noproxy list. returns true if it matches |
| * and therefore the proxy should NOT be used. |
| ****************************************************************/ |
| static bool check_noproxy(const char *name, const char *no_proxy) |
| { |
| /* no_proxy=domain1.dom,host.domain2.dom |
| * (a comma-separated list of hosts which should |
| * not be proxied, or an asterisk to override |
| * all proxy variables) |
| */ |
| size_t tok_start; |
| size_t tok_end; |
| const char *separator = ", "; |
| size_t no_proxy_len; |
| size_t namelen; |
| char *endptr; |
| |
| if(no_proxy && no_proxy[0]) { |
| if(strcasecompare("*", no_proxy)) { |
| return TRUE; |
| } |
| |
| /* NO_PROXY was specified and it wasn't just an asterisk */ |
| |
| no_proxy_len = strlen(no_proxy); |
| endptr = strchr(name, ':'); |
| if(endptr) |
| namelen = endptr - name; |
| else |
| namelen = strlen(name); |
| |
| for(tok_start = 0; tok_start < no_proxy_len; tok_start = tok_end + 1) { |
| while(tok_start < no_proxy_len && |
| strchr(separator, no_proxy[tok_start]) != NULL) { |
| /* Look for the beginning of the token. */ |
| ++tok_start; |
| } |
| |
| if(tok_start == no_proxy_len) |
| break; /* It was all trailing separator chars, no more tokens. */ |
| |
| for(tok_end = tok_start; tok_end < no_proxy_len && |
| strchr(separator, no_proxy[tok_end]) == NULL; ++tok_end) |
| /* Look for the end of the token. */ |
| ; |
| |
| /* To match previous behaviour, where it was necessary to specify |
| * ".local.com" to prevent matching "notlocal.com", we will leave |
| * the '.' off. |
| */ |
| if(no_proxy[tok_start] == '.') |
| ++tok_start; |
| |
| if((tok_end - tok_start) <= namelen) { |
| /* Match the last part of the name to the domain we are checking. */ |
| const char *checkn = name + namelen - (tok_end - tok_start); |
| if(strncasecompare(no_proxy + tok_start, checkn, |
| tok_end - tok_start)) { |
| if((tok_end - tok_start) == namelen || *(checkn - 1) == '.') { |
| /* We either have an exact match, or the previous character is a . |
| * so it is within the same domain, so no proxy for this host. |
| */ |
| return TRUE; |
| } |
| } |
| } /* if((tok_end - tok_start) <= namelen) */ |
| } /* for(tok_start = 0; tok_start < no_proxy_len; |
| tok_start = tok_end + 1) */ |
| } /* NO_PROXY was specified and it wasn't just an asterisk */ |
| |
| return FALSE; |
| } |
| |
| #ifndef CURL_DISABLE_HTTP |
| /**************************************************************** |
| * Detect what (if any) proxy to use. Remember that this selects a host |
| * name and is not limited to HTTP proxies only. |
| * The returned pointer must be freed by the caller (unless NULL) |
| ****************************************************************/ |
| static char *detect_proxy(struct connectdata *conn) |
| { |
| char *proxy = NULL; |
| |
| /* If proxy was not specified, we check for default proxy environment |
| * variables, to enable i.e Lynx compliance: |
| * |
| * http_proxy=http://some.server.dom:port/ |
| * https_proxy=http://some.server.dom:port/ |
| * ftp_proxy=http://some.server.dom:port/ |
| * no_proxy=domain1.dom,host.domain2.dom |
| * (a comma-separated list of hosts which should |
| * not be proxied, or an asterisk to override |
| * all proxy variables) |
| * all_proxy=http://some.server.dom:port/ |
| * (seems to exist for the CERN www lib. Probably |
| * the first to check for.) |
| * |
| * For compatibility, the all-uppercase versions of these variables are |
| * checked if the lowercase versions don't exist. |
| */ |
| char proxy_env[128]; |
| const char *protop = conn->handler->scheme; |
| char *envp = proxy_env; |
| char *prox; |
| |
| /* Now, build <protocol>_proxy and check for such a one to use */ |
| while(*protop) |
| *envp++ = (char)tolower((int)*protop++); |
| |
| /* append _proxy */ |
| strcpy(envp, "_proxy"); |
| |
| /* read the protocol proxy: */ |
| prox = curl_getenv(proxy_env); |
| |
| /* |
| * We don't try the uppercase version of HTTP_PROXY because of |
| * security reasons: |
| * |
| * When curl is used in a webserver application |
| * environment (cgi or php), this environment variable can |
| * be controlled by the web server user by setting the |
| * http header 'Proxy:' to some value. |
| * |
| * This can cause 'internal' http/ftp requests to be |
| * arbitrarily redirected by any external attacker. |
| */ |
| if(!prox && !strcasecompare("http_proxy", proxy_env)) { |
| /* There was no lowercase variable, try the uppercase version: */ |
| Curl_strntoupper(proxy_env, proxy_env, sizeof(proxy_env)); |
| prox = curl_getenv(proxy_env); |
| } |
| |
| if(prox) |
| proxy = prox; /* use this */ |
| else { |
| proxy = curl_getenv("all_proxy"); /* default proxy to use */ |
| if(!proxy) |
| proxy = curl_getenv("ALL_PROXY"); |
| } |
| |
| return proxy; |
| } |
| #endif /* CURL_DISABLE_HTTP */ |
| |
| /* |
| * If this is supposed to use a proxy, we need to figure out the proxy |
| * host name, so that we can re-use an existing connection |
| * that may exist registered to the same proxy host. |
| */ |
| static CURLcode parse_proxy(struct Curl_easy *data, |
| struct connectdata *conn, char *proxy, |
| curl_proxytype proxytype) |
| { |
| char *prox_portno; |
| char *endofprot; |
| |
| /* We use 'proxyptr' to point to the proxy name from now on... */ |
| char *proxyptr; |
| char *portptr; |
| char *atsign; |
| long port = -1; |
| char *proxyuser = NULL; |
| char *proxypasswd = NULL; |
| bool sockstype; |
| |
| /* We do the proxy host string parsing here. We want the host name and the |
| * port name. Accept a protocol:// prefix |
| */ |
| |
| /* Parse the protocol part if present */ |
| endofprot = strstr(proxy, "://"); |
| if(endofprot) { |
| proxyptr = endofprot + 3; |
| if(checkprefix("https", proxy)) |
| proxytype = CURLPROXY_HTTPS; |
| else if(checkprefix("socks5h", proxy)) |
| proxytype = CURLPROXY_SOCKS5_HOSTNAME; |
| else if(checkprefix("socks5", proxy)) |
| proxytype = CURLPROXY_SOCKS5; |
| else if(checkprefix("socks4a", proxy)) |
| proxytype = CURLPROXY_SOCKS4A; |
| else if(checkprefix("socks4", proxy) || checkprefix("socks", proxy)) |
| proxytype = CURLPROXY_SOCKS4; |
| else if(checkprefix("http:", proxy)) |
| ; /* leave it as HTTP or HTTP/1.0 */ |
| else { |
| /* Any other xxx:// reject! */ |
| failf(data, "Unsupported proxy scheme for \'%s\'", proxy); |
| return CURLE_COULDNT_CONNECT; |
| } |
| } |
| else |
| proxyptr = proxy; /* No xxx:// head: It's a HTTP proxy */ |
| |
| #ifdef USE_SSL |
| if(!Curl_ssl->support_https_proxy) |
| #endif |
| if(proxytype == CURLPROXY_HTTPS) { |
| failf(data, "Unsupported proxy \'%s\', libcurl is built without the " |
| "HTTPS-proxy support.", proxy); |
| return CURLE_NOT_BUILT_IN; |
| } |
| |
| sockstype = proxytype == CURLPROXY_SOCKS5_HOSTNAME || |
| proxytype == CURLPROXY_SOCKS5 || |
| proxytype == CURLPROXY_SOCKS4A || |
| proxytype == CURLPROXY_SOCKS4; |
| |
| /* Is there a username and password given in this proxy url? */ |
| atsign = strchr(proxyptr, '@'); |
| if(atsign) { |
| CURLcode result = |
| Curl_parse_login_details(proxyptr, atsign - proxyptr, |
| &proxyuser, &proxypasswd, NULL); |
| if(result) |
| return result; |
| proxyptr = atsign + 1; |
| } |
| |
| /* start scanning for port number at this point */ |
| portptr = proxyptr; |
| |
| /* detect and extract RFC6874-style IPv6-addresses */ |
| if(*proxyptr == '[') { |
| char *ptr = ++proxyptr; /* advance beyond the initial bracket */ |
| while(*ptr && (ISXDIGIT(*ptr) || (*ptr == ':') || (*ptr == '.'))) |
| ptr++; |
| if(*ptr == '%') { |
| /* There might be a zone identifier */ |
| if(strncmp("%25", ptr, 3)) |
| infof(data, "Please URL encode %% as %%25, see RFC 6874.\n"); |
| ptr++; |
| /* Allow unreserved characters as defined in RFC 3986 */ |
| while(*ptr && (ISALPHA(*ptr) || ISXDIGIT(*ptr) || (*ptr == '-') || |
| (*ptr == '.') || (*ptr == '_') || (*ptr == '~'))) |
| ptr++; |
| } |
| if(*ptr == ']') |
| /* yeps, it ended nicely with a bracket as well */ |
| *ptr++ = 0; |
| else |
| infof(data, "Invalid IPv6 address format\n"); |
| portptr = ptr; |
| /* Note that if this didn't end with a bracket, we still advanced the |
| * proxyptr first, but I can't see anything wrong with that as no host |
| * name nor a numeric can legally start with a bracket. |
| */ |
| } |
| |
| /* Get port number off proxy.server.com:1080 */ |
| prox_portno = strchr(portptr, ':'); |
| if(prox_portno) { |
| char *endp = NULL; |
| |
| *prox_portno = 0x0; /* cut off number from host name */ |
| prox_portno ++; |
| /* now set the local port number */ |
| port = strtol(prox_portno, &endp, 10); |
| if((endp && *endp && (*endp != '/') && (*endp != ' ')) || |
| (port < 0) || (port > 65535)) { |
| /* meant to detect for example invalid IPv6 numerical addresses without |
| brackets: "2a00:fac0:a000::7:13". Accept a trailing slash only |
| because we then allow "URL style" with the number followed by a |
| slash, used in curl test cases already. Space is also an acceptable |
| terminating symbol. */ |
| infof(data, "No valid port number in proxy string (%s)\n", |
| prox_portno); |
| } |
| else |
| conn->port = port; |
| } |
| else { |
| if(proxyptr[0]=='/') { |
| /* If the first character in the proxy string is a slash, fail |
| immediately. The following code will otherwise clear the string which |
| will lead to code running as if no proxy was set! */ |
| Curl_safefree(proxyuser); |
| Curl_safefree(proxypasswd); |
| return CURLE_COULDNT_RESOLVE_PROXY; |
| } |
| |
| /* without a port number after the host name, some people seem to use |
| a slash so we strip everything from the first slash */ |
| atsign = strchr(proxyptr, '/'); |
| if(atsign) |
| *atsign = '\0'; /* cut off path part from host name */ |
| |
| if(data->set.proxyport) |
| /* None given in the proxy string, then get the default one if it is |
| given */ |
| port = data->set.proxyport; |
| else { |
| if(proxytype == CURLPROXY_HTTPS) |
| port = CURL_DEFAULT_HTTPS_PROXY_PORT; |
| else |
| port = CURL_DEFAULT_PROXY_PORT; |
| } |
| } |
| |
| if(*proxyptr) { |
| struct proxy_info *proxyinfo = |
| sockstype ? &conn->socks_proxy : &conn->http_proxy; |
| proxyinfo->proxytype = proxytype; |
| |
| if(proxyuser) { |
| /* found user and password, rip them out. note that we are unescaping |
| them, as there is otherwise no way to have a username or password |
| with reserved characters like ':' in them. */ |
| Curl_safefree(proxyinfo->user); |
| proxyinfo->user = curl_easy_unescape(data, proxyuser, 0, NULL); |
| Curl_safefree(proxyuser); |
| |
| if(!proxyinfo->user) { |
| Curl_safefree(proxypasswd); |
| return CURLE_OUT_OF_MEMORY; |
| } |
| |
| Curl_safefree(proxyinfo->passwd); |
| if(proxypasswd && strlen(proxypasswd) < MAX_CURL_PASSWORD_LENGTH) |
| proxyinfo->passwd = curl_easy_unescape(data, proxypasswd, 0, NULL); |
| else |
| proxyinfo->passwd = strdup(""); |
| Curl_safefree(proxypasswd); |
| |
| if(!proxyinfo->passwd) |
| return CURLE_OUT_OF_MEMORY; |
| |
| conn->bits.proxy_user_passwd = TRUE; /* enable it */ |
| } |
| |
| if(port >= 0) { |
| proxyinfo->port = port; |
| if(conn->port < 0 || sockstype || !conn->socks_proxy.host.rawalloc) |
| conn->port = port; |
| } |
| |
| /* now, clone the cleaned proxy host name */ |
| Curl_safefree(proxyinfo->host.rawalloc); |
| proxyinfo->host.rawalloc = strdup(proxyptr); |
| proxyinfo->host.name = proxyinfo->host.rawalloc; |
| |
| if(!proxyinfo->host.rawalloc) |
| return CURLE_OUT_OF_MEMORY; |
| } |
| |
| Curl_safefree(proxyuser); |
| Curl_safefree(proxypasswd); |
| |
| return CURLE_OK; |
| } |
| |
| /* |
| * Extract the user and password from the authentication string |
| */ |
| static CURLcode parse_proxy_auth(struct Curl_easy *data, |
| struct connectdata *conn) |
| { |
| char proxyuser[MAX_CURL_USER_LENGTH]=""; |
| char proxypasswd[MAX_CURL_PASSWORD_LENGTH]=""; |
| CURLcode result; |
| |
| if(data->set.str[STRING_PROXYUSERNAME] != NULL) { |
| strncpy(proxyuser, data->set.str[STRING_PROXYUSERNAME], |
| MAX_CURL_USER_LENGTH); |
| proxyuser[MAX_CURL_USER_LENGTH-1] = '\0'; /*To be on safe side*/ |
| } |
| if(data->set.str[STRING_PROXYPASSWORD] != NULL) { |
| strncpy(proxypasswd, data->set.str[STRING_PROXYPASSWORD], |
| MAX_CURL_PASSWORD_LENGTH); |
| proxypasswd[MAX_CURL_PASSWORD_LENGTH-1] = '\0'; /*To be on safe side*/ |
| } |
| |
| result = Curl_urldecode(data, proxyuser, 0, &conn->http_proxy.user, NULL, |
| FALSE); |
| if(!result) |
| result = Curl_urldecode(data, proxypasswd, 0, &conn->http_proxy.passwd, |
| NULL, FALSE); |
| return result; |
| } |
| |
| /* create_conn helper to parse and init proxy values. to be called after unix |
| socket init but before any proxy vars are evaluated. */ |
| static CURLcode create_conn_helper_init_proxy(struct connectdata *conn) |
| { |
| char *proxy = NULL; |
| char *socksproxy = NULL; |
| char *no_proxy = NULL; |
| CURLcode result = CURLE_OK; |
| struct Curl_easy *data = conn->data; |
| |
| /************************************************************* |
| * Extract the user and password from the authentication string |
| *************************************************************/ |
| if(conn->bits.proxy_user_passwd) { |
| result = parse_proxy_auth(data, conn); |
| if(result) |
| goto out; |
| } |
| |
| /************************************************************* |
| * Detect what (if any) proxy to use |
| *************************************************************/ |
| if(data->set.str[STRING_PROXY]) { |
| proxy = strdup(data->set.str[STRING_PROXY]); |
| /* if global proxy is set, this is it */ |
| if(NULL == proxy) { |
| failf(data, "memory shortage"); |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| } |
| |
| if(data->set.str[STRING_PRE_PROXY]) { |
| socksproxy = strdup(data->set.str[STRING_PRE_PROXY]); |
| /* if global socks proxy is set, this is it */ |
| if(NULL == socksproxy) { |
| failf(data, "memory shortage"); |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| } |
| |
| if(!data->set.str[STRING_NOPROXY]) { |
| no_proxy = curl_getenv("no_proxy"); |
| if(!no_proxy) |
| no_proxy = curl_getenv("NO_PROXY"); |
| } |
| |
| if(check_noproxy(conn->host.name, data->set.str[STRING_NOPROXY] ? |
| data->set.str[STRING_NOPROXY] : no_proxy)) { |
| Curl_safefree(proxy); |
| Curl_safefree(socksproxy); |
| } |
| #ifndef CURL_DISABLE_HTTP |
| else if(!proxy && !socksproxy) |
| /* if the host is not in the noproxy list, detect proxy. */ |
| proxy = detect_proxy(conn); |
| #endif /* CURL_DISABLE_HTTP */ |
| |
| Curl_safefree(no_proxy); |
| |
| #ifdef USE_UNIX_SOCKETS |
| /* For the time being do not mix proxy and unix domain sockets. See #1274 */ |
| if(proxy && conn->unix_domain_socket) { |
| free(proxy); |
| proxy = NULL; |
| } |
| #endif |
| |
| if(proxy && (!*proxy || (conn->handler->flags & PROTOPT_NONETWORK))) { |
| free(proxy); /* Don't bother with an empty proxy string or if the |
| protocol doesn't work with network */ |
| proxy = NULL; |
| } |
| if(socksproxy && (!*socksproxy || |
| (conn->handler->flags & PROTOPT_NONETWORK))) { |
| free(socksproxy); /* Don't bother with an empty socks proxy string or if |
| the protocol doesn't work with network */ |
| socksproxy = NULL; |
| } |
| |
| /*********************************************************************** |
| * If this is supposed to use a proxy, we need to figure out the proxy host |
| * name, proxy type and port number, so that we can re-use an existing |
| * connection that may exist registered to the same proxy host. |
| ***********************************************************************/ |
| if(proxy || socksproxy) { |
| if(proxy) { |
| result = parse_proxy(data, conn, proxy, conn->http_proxy.proxytype); |
| Curl_safefree(proxy); /* parse_proxy copies the proxy string */ |
| if(result) |
| goto out; |
| } |
| |
| if(socksproxy) { |
| result = parse_proxy(data, conn, socksproxy, |
| conn->socks_proxy.proxytype); |
| /* parse_proxy copies the socks proxy string */ |
| Curl_safefree(socksproxy); |
| if(result) |
| goto out; |
| } |
| |
| if(conn->http_proxy.host.rawalloc) { |
| #ifdef CURL_DISABLE_HTTP |
| /* asking for a HTTP proxy is a bit funny when HTTP is disabled... */ |
| result = CURLE_UNSUPPORTED_PROTOCOL; |
| goto out; |
| #else |
| /* force this connection's protocol to become HTTP if compatible */ |
| if(!(conn->handler->protocol & PROTO_FAMILY_HTTP)) { |
| if((conn->handler->flags & PROTOPT_PROXY_AS_HTTP) && |
| !conn->bits.tunnel_proxy) |
| conn->handler = &Curl_handler_http; |
| else |
| /* if not converting to HTTP over the proxy, enforce tunneling */ |
| conn->bits.tunnel_proxy = TRUE; |
| } |
| conn->bits.httpproxy = TRUE; |
| #endif |
| } |
| else { |
| conn->bits.httpproxy = FALSE; /* not a HTTP proxy */ |
| conn->bits.tunnel_proxy = FALSE; /* no tunneling if not HTTP */ |
| } |
| |
| if(conn->socks_proxy.host.rawalloc) { |
| if(!conn->http_proxy.host.rawalloc) { |
| /* once a socks proxy */ |
| if(!conn->socks_proxy.user) { |
| conn->socks_proxy.user = conn->http_proxy.user; |
| conn->http_proxy.user = NULL; |
| Curl_safefree(conn->socks_proxy.passwd); |
| conn->socks_proxy.passwd = conn->http_proxy.passwd; |
| conn->http_proxy.passwd = NULL; |
| } |
| } |
| conn->bits.socksproxy = TRUE; |
| } |
| else |
| conn->bits.socksproxy = FALSE; /* not a socks proxy */ |
| } |
| else { |
| conn->bits.socksproxy = FALSE; |
| conn->bits.httpproxy = FALSE; |
| } |
| conn->bits.proxy = conn->bits.httpproxy || conn->bits.socksproxy; |
| |
| if(!conn->bits.proxy) { |
| /* we aren't using the proxy after all... */ |
| conn->bits.proxy = FALSE; |
| conn->bits.httpproxy = FALSE; |
| conn->bits.socksproxy = FALSE; |
| conn->bits.proxy_user_passwd = FALSE; |
| conn->bits.tunnel_proxy = FALSE; |
| } |
| |
| out: |
| |
| free(socksproxy); |
| free(proxy); |
| return result; |
| } |
| #endif /* CURL_DISABLE_PROXY */ |
| |
| /* |
| * parse_url_login() |
| * |
| * Parse the login details (user name, password and options) from the URL and |
| * strip them out of the host name |
| * |
| * Inputs: data->set.use_netrc (CURLOPT_NETRC) |
| * conn->host.name |
| * |
| * Outputs: (almost :- all currently undefined) |
| * conn->bits.user_passwd - non-zero if non-default passwords exist |
| * user - non-zero length if defined |
| * passwd - non-zero length if defined |
| * options - non-zero length if defined |
| * conn->host.name - remove user name and password |
| */ |
| static CURLcode parse_url_login(struct Curl_easy *data, |
| struct connectdata *conn, |
| char **user, char **passwd, char **options) |
| { |
| CURLcode result = CURLE_OK; |
| char *userp = NULL; |
| char *passwdp = NULL; |
| char *optionsp = NULL; |
| |
| /* At this point, we're hoping all the other special cases have |
| * been taken care of, so conn->host.name is at most |
| * [user[:password][;options]]@]hostname |
| * |
| * We need somewhere to put the embedded details, so do that first. |
| */ |
| |
| char *ptr = strchr(conn->host.name, '@'); |
| char *login = conn->host.name; |
| |
| DEBUGASSERT(!**user); |
| DEBUGASSERT(!**passwd); |
| DEBUGASSERT(!**options); |
| DEBUGASSERT(conn->handler); |
| |
| if(!ptr) |
| goto out; |
| |
| /* We will now try to extract the |
| * possible login information in a string like: |
| * ftp://user:password@ftp.my.site:8021/README */ |
| conn->host.name = ++ptr; |
| |
| /* So the hostname is sane. Only bother interpreting the |
| * results if we could care. It could still be wasted |
| * work because it might be overtaken by the programmatically |
| * set user/passwd, but doing that first adds more cases here :-( |
| */ |
| |
| if(data->set.use_netrc == CURL_NETRC_REQUIRED) |
| goto out; |
| |
| /* We could use the login information in the URL so extract it. Only parse |
| options if the handler says we should. */ |
| result = |
| Curl_parse_login_details(login, ptr - login - 1, |
| &userp, &passwdp, |
| (conn->handler->flags & PROTOPT_URLOPTIONS)? |
| &optionsp:NULL); |
| if(result) |
| goto out; |
| |
| if(userp) { |
| char *newname; |
| |
| /* We have a user in the URL */ |
| conn->bits.userpwd_in_url = TRUE; |
| conn->bits.user_passwd = TRUE; /* enable user+password */ |
| |
| /* Decode the user */ |
| result = Curl_urldecode(data, userp, 0, &newname, NULL, FALSE); |
| if(result) { |
| goto out; |
| } |
| |
| free(*user); |
| *user = newname; |
| } |
| |
| if(passwdp) { |
| /* We have a password in the URL so decode it */ |
| char *newpasswd; |
| result = Curl_urldecode(data, passwdp, 0, &newpasswd, NULL, FALSE); |
| if(result) { |
| goto out; |
| } |
| |
| free(*passwd); |
| *passwd = newpasswd; |
| } |
| |
| if(optionsp) { |
| /* We have an options list in the URL so decode it */ |
| char *newoptions; |
| result = Curl_urldecode(data, optionsp, 0, &newoptions, NULL, FALSE); |
| if(result) { |
| goto out; |
| } |
| |
| free(*options); |
| *options = newoptions; |
| } |
| |
| |
| out: |
| |
| free(userp); |
| free(passwdp); |
| free(optionsp); |
| |
| return result; |
| } |
| |
| /* |
| * Curl_parse_login_details() |
| * |
| * This is used to parse a login string for user name, password and options in |
| * the following formats: |
| * |
| * user |
| * user:password |
| * user:password;options |
| * user;options |
| * user;options:password |
| * :password |
| * :password;options |
| * ;options |
| * ;options:password |
| * |
| * Parameters: |
| * |
| * login [in] - The login string. |
| * len [in] - The length of the login string. |
| * userp [in/out] - The address where a pointer to newly allocated memory |
| * holding the user will be stored upon completion. |
| * passdwp [in/out] - The address where a pointer to newly allocated memory |
| * holding the password will be stored upon completion. |
| * optionsp [in/out] - The address where a pointer to newly allocated memory |
| * holding the options will be stored upon completion. |
| * |
| * Returns CURLE_OK on success. |
| */ |
| CURLcode Curl_parse_login_details(const char *login, const size_t len, |
| char **userp, char **passwdp, |
| char **optionsp) |
| { |
| CURLcode result = CURLE_OK; |
| char *ubuf = NULL; |
| char *pbuf = NULL; |
| char *obuf = NULL; |
| const char *psep = NULL; |
| const char *osep = NULL; |
| size_t ulen; |
| size_t plen; |
| size_t olen; |
| |
| /* Attempt to find the password separator */ |
| if(passwdp) { |
| psep = strchr(login, ':'); |
| |
| /* Within the constraint of the login string */ |
| if(psep >= login + len) |
| psep = NULL; |
| } |
| |
| /* Attempt to find the options separator */ |
| if(optionsp) { |
| osep = strchr(login, ';'); |
| |
| /* Within the constraint of the login string */ |
| if(osep >= login + len) |
| osep = NULL; |
| } |
| |
| /* Calculate the portion lengths */ |
| ulen = (psep ? |
| (size_t)(osep && psep > osep ? osep - login : psep - login) : |
| (osep ? (size_t)(osep - login) : len)); |
| plen = (psep ? |
| (osep && osep > psep ? (size_t)(osep - psep) : |
| (size_t)(login + len - psep)) - 1 : 0); |
| olen = (osep ? |
| (psep && psep > osep ? (size_t)(psep - osep) : |
| (size_t)(login + len - osep)) - 1 : 0); |
| |
| /* Allocate the user portion buffer */ |
| if(userp && ulen) { |
| ubuf = malloc(ulen + 1); |
| if(!ubuf) |
| result = CURLE_OUT_OF_MEMORY; |
| } |
| |
| /* Allocate the password portion buffer */ |
| if(!result && passwdp && plen) { |
| pbuf = malloc(plen + 1); |
| if(!pbuf) { |
| free(ubuf); |
| result = CURLE_OUT_OF_MEMORY; |
| } |
| } |
| |
| /* Allocate the options portion buffer */ |
| if(!result && optionsp && olen) { |
| obuf = malloc(olen + 1); |
| if(!obuf) { |
| free(pbuf); |
| free(ubuf); |
| result = CURLE_OUT_OF_MEMORY; |
| } |
| } |
| |
| if(!result) { |
| /* Store the user portion if necessary */ |
| if(ubuf) { |
| memcpy(ubuf, login, ulen); |
| ubuf[ulen] = '\0'; |
| Curl_safefree(*userp); |
| *userp = ubuf; |
| } |
| |
| /* Store the password portion if necessary */ |
| if(pbuf) { |
| memcpy(pbuf, psep + 1, plen); |
| pbuf[plen] = '\0'; |
| Curl_safefree(*passwdp); |
| *passwdp = pbuf; |
| } |
| |
| /* Store the options portion if necessary */ |
| if(obuf) { |
| memcpy(obuf, osep + 1, olen); |
| obuf[olen] = '\0'; |
| Curl_safefree(*optionsp); |
| *optionsp = obuf; |
| } |
| } |
| |
| return result; |
| } |
| |
| /************************************************************* |
| * Figure out the remote port number and fix it in the URL |
| * |
| * No matter if we use a proxy or not, we have to figure out the remote |
| * port number of various reasons. |
| * |
| * To be able to detect port number flawlessly, we must not confuse them |
| * IPv6-specified addresses in the [0::1] style. (RFC2732) |
| * |
| * The conn->host.name is currently [user:passwd@]host[:port] where host |
| * could be a hostname, IPv4 address or IPv6 address. |
| * |
| * The port number embedded in the URL is replaced, if necessary. |
| *************************************************************/ |
| static CURLcode parse_remote_port(struct Curl_easy *data, |
| struct connectdata *conn) |
| { |
| char *portptr; |
| char endbracket; |
| |
| /* Note that at this point, the IPv6 address cannot contain any scope |
| suffix as that has already been removed in the parseurlandfillconn() |
| function */ |
| if((1 == sscanf(conn->host.name, "[%*45[0123456789abcdefABCDEF:.]%c", |
| &endbracket)) && |
| (']' == endbracket)) { |
| /* this is a RFC2732-style specified IP-address */ |
| conn->bits.ipv6_ip = TRUE; |
| |
| conn->host.name++; /* skip over the starting bracket */ |
| portptr = strchr(conn->host.name, ']'); |
| if(portptr) { |
| *portptr++ = '\0'; /* zero terminate, killing the bracket */ |
| if(*portptr) { |
| if (*portptr != ':') { |
| failf(data, "IPv6 closing bracket followed by '%c'", *portptr); |
| return CURLE_URL_MALFORMAT; |
| } |
| } |
| else |
| portptr = NULL; /* no port number available */ |
| } |
| } |
| else { |
| #ifdef ENABLE_IPV6 |
| struct in6_addr in6; |
| if(Curl_inet_pton(AF_INET6, conn->host.name, &in6) > 0) { |
| /* This is a numerical IPv6 address, meaning this is a wrongly formatted |
| URL */ |
| failf(data, "IPv6 numerical address used in URL without brackets"); |
| return CURLE_URL_MALFORMAT; |
| } |
| #endif |
| |
| portptr = strchr(conn->host.name, ':'); |
| } |
| |
| if(data->set.use_port && data->state.allow_port) { |
| /* if set, we use this and ignore the port possibly given in the URL */ |
| conn->remote_port = (unsigned short)data->set.use_port; |
| if(portptr) |
| *portptr = '\0'; /* cut off the name there anyway - if there was a port |
| number - since the port number is to be ignored! */ |
| if(conn->bits.httpproxy) { |
| /* we need to create new URL with the new port number */ |
| char *url; |
| char type[12]=""; |
| |
| if(conn->bits.type_set) |
| snprintf(type, sizeof(type), ";type=%c", |
| data->set.prefer_ascii?'A': |
| (data->set.ftp_list_only?'D':'I')); |
| |
| /* |
| * This synthesized URL isn't always right--suffixes like ;type=A are |
| * stripped off. It would be better to work directly from the original |
| * URL and simply replace the port part of it. |
| */ |
| url = aprintf("%s://%s%s%s:%hu%s%s%s", conn->given->scheme, |
| conn->bits.ipv6_ip?"[":"", conn->host.name, |
| conn->bits.ipv6_ip?"]":"", conn->remote_port, |
| data->state.slash_removed?"/":"", data->state.path, |
| type); |
| if(!url) |
| return CURLE_OUT_OF_MEMORY; |
| |
| if(data->change.url_alloc) { |
| Curl_safefree(data->change.url); |
| data->change.url_alloc = FALSE; |
| } |
| |
| data->change.url = url; |
| data->change.url_alloc = TRUE; |
| } |
| } |
| else if(portptr) { |
| /* no CURLOPT_PORT given, extract the one from the URL */ |
| |
| char *rest; |
| long port; |
| |
| port = strtol(portptr + 1, &rest, 10); /* Port number must be decimal */ |
| |
| if((port < 0) || (port > 0xffff)) { |
| /* Single unix standard says port numbers are 16 bits long */ |
| failf(data, "Port number out of range"); |
| return CURLE_URL_MALFORMAT; |
| } |
| |
| if(rest[0]) { |
| failf(data, "Port number ended with '%c'", rest[0]); |
| return CURLE_URL_MALFORMAT; |
| } |
| |
| if(rest != &portptr[1]) { |
| *portptr = '\0'; /* cut off the name there */ |
| conn->remote_port = curlx_ultous(port); |
| } |
| else { |
| /* Browser behavior adaptation. If there's a colon with no digits after, |
| just cut off the name there which makes us ignore the colon and just |
| use the default port. Firefox and Chrome both do that. */ |
| *portptr = '\0'; |
| } |
| } |
| |
| /* only if remote_port was not already parsed off the URL we use the |
| default port number */ |
| if(conn->remote_port < 0) |
| conn->remote_port = (unsigned short)conn->given->defport; |
| |
| return CURLE_OK; |
| } |
| |
| /* |
| * Override the login details from the URL with that in the CURLOPT_USERPWD |
| * option or a .netrc file, if applicable. |
| */ |
| static CURLcode override_login(struct Curl_easy *data, |
| struct connectdata *conn, |
| char **userp, char **passwdp, char **optionsp) |
| { |
| if(data->set.str[STRING_USERNAME]) { |
| free(*userp); |
| *userp = strdup(data->set.str[STRING_USERNAME]); |
| if(!*userp) |
| return CURLE_OUT_OF_MEMORY; |
| } |
| |
| if(data->set.str[STRING_PASSWORD]) { |
| free(*passwdp); |
| *passwdp = strdup(data->set.str[STRING_PASSWORD]); |
| if(!*passwdp) |
| return CURLE_OUT_OF_MEMORY; |
| } |
| |
| if(data->set.str[STRING_OPTIONS]) { |
| free(*optionsp); |
| *optionsp = strdup(data->set.str[STRING_OPTIONS]); |
| if(!*optionsp) |
| return CURLE_OUT_OF_MEMORY; |
| } |
| |
| conn->bits.netrc = FALSE; |
| if(data->set.use_netrc != CURL_NETRC_IGNORED) { |
| int ret = Curl_parsenetrc(conn->host.name, |
| userp, passwdp, |
| data->set.str[STRING_NETRC_FILE]); |
| if(ret > 0) { |
| infof(data, "Couldn't find host %s in the " |
| DOT_CHAR "netrc file; using defaults\n", |
| conn->host.name); |
| } |
| else if(ret < 0) { |
| return CURLE_OUT_OF_MEMORY; |
| } |
| else { |
| /* set bits.netrc TRUE to remember that we got the name from a .netrc |
| file, so that it is safe to use even if we followed a Location: to a |
| different host or similar. */ |
| conn->bits.netrc = TRUE; |
| |
| conn->bits.user_passwd = TRUE; /* enable user+password */ |
| } |
| } |
| |
| return CURLE_OK; |
| } |
| |
| /* |
| * Set the login details so they're available in the connection |
| */ |
| static CURLcode set_login(struct connectdata *conn, |
| const char *user, const char *passwd, |
| const char *options) |
| { |
| CURLcode result = CURLE_OK; |
| |
| /* If our protocol needs a password and we have none, use the defaults */ |
| if((conn->handler->flags & PROTOPT_NEEDSPWD) && !conn->bits.user_passwd) { |
| /* Store the default user */ |
| conn->user = strdup(CURL_DEFAULT_USER); |
| |
| /* Store the default password */ |
| if(conn->user) |
| conn->passwd = strdup(CURL_DEFAULT_PASSWORD); |
| else |
| conn->passwd = NULL; |
| |
| /* This is the default password, so DON'T set conn->bits.user_passwd */ |
| } |
| else { |
| /* Store the user, zero-length if not set */ |
| conn->user = strdup(user); |
| |
| /* Store the password (only if user is present), zero-length if not set */ |
| if(conn->user) |
| conn->passwd = strdup(passwd); |
| else |
| conn->passwd = NULL; |
| } |
| |
| if(!conn->user || !conn->passwd) |
| result = CURLE_OUT_OF_MEMORY; |
| |
| /* Store the options, null if not set */ |
| if(!result && options[0]) { |
| conn->options = strdup(options); |
| |
| if(!conn->options) |
| result = CURLE_OUT_OF_MEMORY; |
| } |
| |
| return result; |
| } |
| |
| /* |
| * Parses a "host:port" string to connect to. |
| * The hostname and the port may be empty; in this case, NULL is returned for |
| * the hostname and -1 for the port. |
| */ |
| static CURLcode parse_connect_to_host_port(struct Curl_easy *data, |
| const char *host, |
| char **hostname_result, |
| int *port_result) |
| { |
| char *host_dup; |
| char *hostptr; |
| char *host_portno; |
| char *portptr; |
| int port = -1; |
| |
| #if defined(CURL_DISABLE_VERBOSE_STRINGS) |
| (void) data; |
| #endif |
| |
| *hostname_result = NULL; |
| *port_result = -1; |
| |
| if(!host || !*host) |
| return CURLE_OK; |
| |
| host_dup = strdup(host); |
| if(!host_dup) |
| return CURLE_OUT_OF_MEMORY; |
| |
| hostptr = host_dup; |
| |
| /* start scanning for port number at this point */ |
| portptr = hostptr; |
| |
| /* detect and extract RFC6874-style IPv6-addresses */ |
| if(*hostptr == '[') { |
| #ifdef ENABLE_IPV6 |
| char *ptr = ++hostptr; /* advance beyond the initial bracket */ |
| while(*ptr && (ISXDIGIT(*ptr) || (*ptr == ':') || (*ptr == '.'))) |
| ptr++; |
| if(*ptr == '%') { |
| /* There might be a zone identifier */ |
| if(strncmp("%25", ptr, 3)) |
| infof(data, "Please URL encode %% as %%25, see RFC 6874.\n"); |
| ptr++; |
| /* Allow unreserved characters as defined in RFC 3986 */ |
| while(*ptr && (ISALPHA(*ptr) || ISXDIGIT(*ptr) || (*ptr == '-') || |
| (*ptr == '.') || (*ptr == '_') || (*ptr == '~'))) |
| ptr++; |
| } |
| if(*ptr == ']') |
| /* yeps, it ended nicely with a bracket as well */ |
| *ptr++ = '\0'; |
| else |
| infof(data, "Invalid IPv6 address format\n"); |
| portptr = ptr; |
| /* Note that if this didn't end with a bracket, we still advanced the |
| * hostptr first, but I can't see anything wrong with that as no host |
| * name nor a numeric can legally start with a bracket. |
| */ |
| #else |
| failf(data, "Use of IPv6 in *_CONNECT_TO without IPv6 support built-in!"); |
| free(host_dup); |
| return CURLE_NOT_BUILT_IN; |
| #endif |
| } |
| |
| /* Get port number off server.com:1080 */ |
| host_portno = strchr(portptr, ':'); |
| if(host_portno) { |
| char *endp = NULL; |
| *host_portno = '\0'; /* cut off number from host name */ |
| host_portno++; |
| if(*host_portno) { |
| long portparse = strtol(host_portno, &endp, 10); |
| if((endp && *endp) || (portparse < 0) || (portparse > 65535)) { |
| infof(data, "No valid port number in connect to host string (%s)\n", |
| host_portno); |
| hostptr = NULL; |
| port = -1; |
| } |
| else |
| port = (int)portparse; /* we know it will fit */ |
| } |
| } |
| |
| /* now, clone the cleaned host name */ |
| if(hostptr) { |
| *hostname_result = strdup(hostptr); |
| if(!*hostname_result) { |
| free(host_dup); |
| return CURLE_OUT_OF_MEMORY; |
| } |
| } |
| |
| *port_result = port; |
| |
| free(host_dup); |
| return CURLE_OK; |
| } |
| |
| /* |
| * Parses one "connect to" string in the form: |
| * "HOST:PORT:CONNECT-TO-HOST:CONNECT-TO-PORT". |
| */ |
| static CURLcode parse_connect_to_string(struct Curl_easy *data, |
| struct connectdata *conn, |
| const char *conn_to_host, |
| char **host_result, |
| int *port_result) |
| { |
| CURLcode result = CURLE_OK; |
| const char *ptr = conn_to_host; |
| int host_match = FALSE; |
| int port_match = FALSE; |
| |
| *host_result = NULL; |
| *port_result = -1; |
| |
| if(*ptr == ':') { |
| /* an empty hostname always matches */ |
| host_match = TRUE; |
| ptr++; |
| } |
| else { |
| /* check whether the URL's hostname matches */ |
| size_t hostname_to_match_len; |
| char *hostname_to_match = aprintf("%s%s%s", |
| conn->bits.ipv6_ip ? "[" : "", |
| conn->host.name, |
| conn->bits.ipv6_ip ? "]" : ""); |
| if(!hostname_to_match) |
| return CURLE_OUT_OF_MEMORY; |
| hostname_to_match_len = strlen(hostname_to_match); |
| host_match = strncasecompare(ptr, hostname_to_match, |
| hostname_to_match_len); |
| free(hostname_to_match); |
| ptr += hostname_to_match_len; |
| |
| host_match = host_match && *ptr == ':'; |
| ptr++; |
| } |
| |
| if(host_match) { |
| if(*ptr == ':') { |
| /* an empty port always matches */ |
| port_match = TRUE; |
| ptr++; |
| } |
| else { |
| /* check whether the URL's port matches */ |
| char *ptr_next = strchr(ptr, ':'); |
| if(ptr_next) { |
| char *endp = NULL; |
| long port_to_match = strtol(ptr, &endp, 10); |
| if((endp == ptr_next) && (port_to_match == conn->remote_port)) { |
| port_match = TRUE; |
| ptr = ptr_next + 1; |
| } |
| } |
| } |
| } |
| |
| if(host_match && port_match) { |
| /* parse the hostname and port to connect to */ |
| result = parse_connect_to_host_port(data, ptr, host_result, port_result); |
| } |
| |
| return result; |
| } |
| |
| /* |
| * Processes all strings in the "connect to" slist, and uses the "connect |
| * to host" and "connect to port" of the first string that matches. |
| */ |
| static CURLcode parse_connect_to_slist(struct Curl_easy *data, |
| struct connectdata *conn, |
| struct curl_slist *conn_to_host) |
| { |
| CURLcode result = CURLE_OK; |
| char *host = NULL; |
| int port = -1; |
| |
| while(conn_to_host && !host && port == -1) { |
| result = parse_connect_to_string(data, conn, conn_to_host->data, |
| &host, &port); |
| if(result) |
| return result; |
| |
| if(host && *host) { |
| conn->conn_to_host.rawalloc = host; |
| conn->conn_to_host.name = host; |
| conn->bits.conn_to_host = TRUE; |
| |
| infof(data, "Connecting to hostname: %s\n", host); |
| } |
| else { |
| /* no "connect to host" */ |
| conn->bits.conn_to_host = FALSE; |
| Curl_safefree(host); |
| } |
| |
| if(port >= 0) { |
| conn->conn_to_port = port; |
| conn->bits.conn_to_port = TRUE; |
| infof(data, "Connecting to port: %d\n", port); |
| } |
| else { |
| /* no "connect to port" */ |
| conn->bits.conn_to_port = FALSE; |
| port = -1; |
| } |
| |
| conn_to_host = conn_to_host->next; |
| } |
| |
| return result; |
| } |
| |
| /************************************************************* |
| * Resolve the address of the server or proxy |
| *************************************************************/ |
| static CURLcode resolve_server(struct Curl_easy *data, |
| struct connectdata *conn, |
| bool *async) |
| { |
| CURLcode result = CURLE_OK; |
| timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE); |
| |
| /************************************************************* |
| * Resolve the name of the server or proxy |
| *************************************************************/ |
| if(conn->bits.reuse) |
| /* We're reusing the connection - no need to resolve anything, and |
| fix_hostname() was called already in create_conn() for the re-use |
| case. */ |
| *async = FALSE; |
| |
| else { |
| /* this is a fresh connect */ |
| int rc; |
| struct Curl_dns_entry *hostaddr; |
| |
| #ifdef USE_UNIX_SOCKETS |
| if(conn->unix_domain_socket) { |
| /* Unix domain sockets are local. The host gets ignored, just use the |
| * specified domain socket address. Do not cache "DNS entries". There is |
| * no DNS involved and we already have the filesystem path available */ |
| const char *path = conn->unix_domain_socket; |
| |
| hostaddr = calloc(1, sizeof(struct Curl_dns_entry)); |
| if(!hostaddr) |
| result = CURLE_OUT_OF_MEMORY; |
| else { |
| bool longpath = FALSE; |
| hostaddr->addr = Curl_unix2addr(path, &longpath, |
| conn->abstract_unix_socket); |
| if(hostaddr->addr) |
| hostaddr->inuse++; |
| else { |
| /* Long paths are not supported for now */ |
| if(longpath) { |
| failf(data, "Unix socket path too long: '%s'", path); |
| result = CURLE_COULDNT_RESOLVE_HOST; |
| } |
| else |
| result = CURLE_OUT_OF_MEMORY; |
| free(hostaddr); |
| hostaddr = NULL; |
| } |
| } |
| } |
| else |
| #endif |
| if(!conn->bits.proxy) { |
| struct hostname *connhost; |
| if(conn->bits.conn_to_host) |
| connhost = &conn->conn_to_host; |
| else |
| connhost = &conn->host; |
| |
| /* If not connecting via a proxy, extract the port from the URL, if it is |
| * there, thus overriding any defaults that might have been set above. */ |
| if(conn->bits.conn_to_port) |
| conn->port = conn->conn_to_port; |
| else |
| conn->port = conn->remote_port; |
| |
| /* Resolve target host right on */ |
| rc = Curl_resolv_timeout(conn, connhost->name, (int)conn->port, |
| &hostaddr, timeout_ms); |
| if(rc == CURLRESOLV_PENDING) |
| *async = TRUE; |
| |
| else if(rc == CURLRESOLV_TIMEDOUT) |
| result = CURLE_OPERATION_TIMEDOUT; |
| |
| else if(!hostaddr) { |
| failf(data, "Couldn't resolve host '%s'", connhost->dispname); |
| result = CURLE_COULDNT_RESOLVE_HOST; |
| /* don't return yet, we need to clean up the timeout first */ |
| } |
| } |
| else { |
| /* This is a proxy that hasn't been resolved yet. */ |
| |
| struct hostname * const host = conn->bits.socksproxy ? |
| &conn->socks_proxy.host : &conn->http_proxy.host; |
| |
| /* resolve proxy */ |
| rc = Curl_resolv_timeout(conn, host->name, (int)conn->port, |
| &hostaddr, timeout_ms); |
| |
| if(rc == CURLRESOLV_PENDING) |
| *async = TRUE; |
| |
| else if(rc == CURLRESOLV_TIMEDOUT) |
| result = CURLE_OPERATION_TIMEDOUT; |
| |
| else if(!hostaddr) { |
| failf(data, "Couldn't resolve proxy '%s'", host->dispname); |
| result = CURLE_COULDNT_RESOLVE_PROXY; |
| /* don't return yet, we need to clean up the timeout first */ |
| } |
| } |
| DEBUGASSERT(conn->dns_entry == NULL); |
| conn->dns_entry = hostaddr; |
| } |
| |
| return result; |
| } |
| |
| /* |
| * Cleanup the connection just allocated before we can move along and use the |
| * previously existing one. All relevant data is copied over and old_conn is |
| * ready for freeing once this function returns. |
| */ |
| static void reuse_conn(struct connectdata *old_conn, |
| struct connectdata *conn) |
| { |
| free_fixed_hostname(&old_conn->http_proxy.host); |
| free_fixed_hostname(&old_conn->socks_proxy.host); |
| |
| free(old_conn->http_proxy.host.rawalloc); |
| free(old_conn->socks_proxy.host.rawalloc); |
| |
| /* free the SSL config struct from this connection struct as this was |
| allocated in vain and is targeted for destruction */ |
| Curl_free_primary_ssl_config(&old_conn->ssl_config); |
| Curl_free_primary_ssl_config(&old_conn->proxy_ssl_config); |
| |
| conn->data = old_conn->data; |
| |
| /* get the user+password information from the old_conn struct since it may |
| * be new for this request even when we re-use an existing connection */ |
| conn->bits.user_passwd = old_conn->bits.user_passwd; |
| if(conn->bits.user_passwd) { |
| /* use the new user name and password though */ |
| Curl_safefree(conn->user); |
| Curl_safefree(conn->passwd); |
| conn->user = old_conn->user; |
| conn->passwd = old_conn->passwd; |
| old_conn->user = NULL; |
| old_conn->passwd = NULL; |
| } |
| |
| conn->bits.proxy_user_passwd = old_conn->bits.proxy_user_passwd; |
| if(conn->bits.proxy_user_passwd) { |
| /* use the new proxy user name and proxy password though */ |
| Curl_safefree(conn->http_proxy.user); |
| Curl_safefree(conn->socks_proxy.user); |
| Curl_safefree(conn->http_proxy.passwd); |
| Curl_safefree(conn->socks_proxy.passwd); |
| conn->http_proxy.user = old_conn->http_proxy.user; |
| conn->socks_proxy.user = old_conn->socks_proxy.user; |
| conn->http_proxy.passwd = old_conn->http_proxy.passwd; |
| conn->socks_proxy.passwd = old_conn->socks_proxy.passwd; |
| old_conn->http_proxy.user = NULL; |
| old_conn->socks_proxy.user = NULL; |
| old_conn->http_proxy.passwd = NULL; |
| old_conn->socks_proxy.passwd = NULL; |
| } |
| |
| /* host can change, when doing keepalive with a proxy or if the case is |
| different this time etc */ |
| free_fixed_hostname(&conn->host); |
| free_fixed_hostname(&conn->conn_to_host); |
| Curl_safefree(conn->host.rawalloc); |
| Curl_safefree(conn->conn_to_host.rawalloc); |
| conn->host = old_conn->host; |
| conn->conn_to_host = old_conn->conn_to_host; |
| conn->conn_to_port = old_conn->conn_to_port; |
| conn->remote_port = old_conn->remote_port; |
| |
| /* persist connection info in session handle */ |
| Curl_persistconninfo(conn); |
| |
| conn_reset_all_postponed_data(old_conn); /* free buffers */ |
| |
| /* re-use init */ |
| conn->bits.reuse = TRUE; /* yes, we're re-using here */ |
| |
| Curl_safefree(old_conn->user); |
| Curl_safefree(old_conn->passwd); |
| Curl_safefree(old_conn->http_proxy.user); |
| Curl_safefree(old_conn->socks_proxy.user); |
| Curl_safefree(old_conn->http_proxy.passwd); |
| Curl_safefree(old_conn->socks_proxy.passwd); |
| Curl_safefree(old_conn->localdev); |
| |
| Curl_llist_destroy(&old_conn->send_pipe, NULL); |
| Curl_llist_destroy(&old_conn->recv_pipe, NULL); |
| |
| Curl_safefree(old_conn->master_buffer); |
| |
| #ifdef USE_UNIX_SOCKETS |
| Curl_safefree(old_conn->unix_domain_socket); |
| #endif |
| } |
| |
| /** |
| * create_conn() sets up a new connectdata struct, or re-uses an already |
| * existing one, and resolves host name. |
| * |
| * if this function returns CURLE_OK and *async is set to TRUE, the resolve |
| * response will be coming asynchronously. If *async is FALSE, the name is |
| * already resolved. |
| * |
| * @param data The sessionhandle pointer |
| * @param in_connect is set to the next connection data pointer |
| * @param async is set TRUE when an async DNS resolution is pending |
| * @see Curl_setup_conn() |
| * |
| * *NOTE* this function assigns the conn->data pointer! |
| */ |
| |
| static CURLcode create_conn(struct Curl_easy *data, |
| struct connectdata **in_connect, |
| bool *async) |
| { |
| CURLcode result = CURLE_OK; |
| struct connectdata *conn; |
| struct connectdata *conn_temp = NULL; |
| size_t urllen; |
| char *user = NULL; |
| char *passwd = NULL; |
| char *options = NULL; |
| bool reuse; |
| bool prot_missing = FALSE; |
| bool connections_available = TRUE; |
| bool force_reuse = FALSE; |
| bool waitpipe = FALSE; |
| size_t max_host_connections = Curl_multi_max_host_connections(data->multi); |
| size_t max_total_connections = Curl_multi_max_total_connections(data->multi); |
| |
| *async = FALSE; |
| |
| /************************************************************* |
| * Check input data |
| *************************************************************/ |
| |
| if(!data->change.url) { |
| result = CURLE_URL_MALFORMAT; |
| goto out; |
| } |
| |
| /* First, split up the current URL in parts so that we can use the |
| parts for checking against the already present connections. In order |
| to not have to modify everything at once, we allocate a temporary |
| connection data struct and fill in for comparison purposes. */ |
| conn = allocate_conn(data); |
| |
| if(!conn) { |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| |
| /* We must set the return variable as soon as possible, so that our |
| parent can cleanup any possible allocs we may have done before |
| any failure */ |
| *in_connect = conn; |
| |
| /* This initing continues below, see the comment "Continue connectdata |
| * initialization here" */ |
| |
| /*********************************************************** |
| * We need to allocate memory to store the path in. We get the size of the |
| * full URL to be sure, and we need to make it at least 256 bytes since |
| * other parts of the code will rely on this fact |
| ***********************************************************/ |
| #define LEAST_PATH_ALLOC 256 |
| urllen = strlen(data->change.url); |
| if(urllen < LEAST_PATH_ALLOC) |
| urllen = LEAST_PATH_ALLOC; |
| |
| /* |
| * We malloc() the buffers below urllen+2 to make room for 2 possibilities: |
| * 1 - an extra terminating zero |
| * 2 - an extra slash (in case a syntax like "www.host.com?moo" is used) |
| */ |
| |
| Curl_safefree(data->state.pathbuffer); |
| data->state.path = NULL; |
| |
| data->state.pathbuffer = malloc(urllen + 2); |
| if(NULL == data->state.pathbuffer) { |
| result = CURLE_OUT_OF_MEMORY; /* really bad error */ |
| goto out; |
| } |
| data->state.path = data->state.pathbuffer; |
| |
| conn->host.rawalloc = malloc(urllen + 2); |
| if(NULL == conn->host.rawalloc) { |
| Curl_safefree(data->state.pathbuffer); |
| data->state.path = NULL; |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| |
| conn->host.name = conn->host.rawalloc; |
| conn->host.name[0] = 0; |
| |
| user = strdup(""); |
| passwd = strdup(""); |
| options = strdup(""); |
| if(!user || !passwd || !options) { |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| |
| result = parseurlandfillconn(data, conn, &prot_missing, &user, &passwd, |
| &options); |
| if(result) |
| goto out; |
| |
| /************************************************************* |
| * No protocol part in URL was used, add it! |
| *************************************************************/ |
| if(prot_missing) { |
| /* We're guessing prefixes here and if we're told to use a proxy or if |
| we're gonna follow a Location: later or... then we need the protocol |
| part added so that we have a valid URL. */ |
| char *reurl; |
| char *ch_lower; |
| |
| reurl = aprintf("%s://%s", conn->handler->scheme, data->change.url); |
| |
| if(!reurl) { |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| |
| /* Change protocol prefix to lower-case */ |
| for(ch_lower = reurl; *ch_lower != ':'; ch_lower++) |
| *ch_lower = (char)TOLOWER(*ch_lower); |
| |
| if(data->change.url_alloc) { |
| Curl_safefree(data->change.url); |
| data->change.url_alloc = FALSE; |
| } |
| |
| data->change.url = reurl; |
| data->change.url_alloc = TRUE; /* free this later */ |
| } |
| |
| /************************************************************* |
| * If the protocol can't handle url query strings, then cut |
| * off the unhandable part |
| *************************************************************/ |
| if((conn->given->flags&PROTOPT_NOURLQUERY)) { |
| char *path_q_sep = strchr(conn->data->state.path, '?'); |
| if(path_q_sep) { |
| /* according to rfc3986, allow the query (?foo=bar) |
| also on protocols that can't handle it. |
| |
| cut the string-part after '?' |
| */ |
| |
| /* terminate the string */ |
| path_q_sep[0] = 0; |
| } |
| } |
| |
| if(data->set.str[STRING_BEARER]) { |
| conn->oauth_bearer = strdup(data->set.str[STRING_BEARER]); |
| if(!conn->oauth_bearer) { |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| } |
| |
| #ifdef USE_UNIX_SOCKETS |
| if(data->set.str[STRING_UNIX_SOCKET_PATH]) { |
| conn->unix_domain_socket = strdup(data->set.str[STRING_UNIX_SOCKET_PATH]); |
| if(conn->unix_domain_socket == NULL) { |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| conn->abstract_unix_socket = data->set.abstract_unix_socket; |
| } |
| #endif |
| |
| /* After the unix socket init but before the proxy vars are used, parse and |
| initialize the proxy vars */ |
| #ifndef CURL_DISABLE_PROXY |
| result = create_conn_helper_init_proxy(conn); |
| if(result) |
| goto out; |
| #endif |
| |
| /************************************************************* |
| * If the protocol is using SSL and HTTP proxy is used, we set |
| * the tunnel_proxy bit. |
| *************************************************************/ |
| if((conn->given->flags&PROTOPT_SSL) && conn->bits.httpproxy) |
| conn->bits.tunnel_proxy = TRUE; |
| |
| /************************************************************* |
| * Figure out the remote port number and fix it in the URL |
| *************************************************************/ |
| result = parse_remote_port(data, conn); |
| if(result) |
| goto out; |
| |
| /* Check for overridden login details and set them accordingly so they |
| they are known when protocol->setup_connection is called! */ |
| result = override_login(data, conn, &user, &passwd, &options); |
| if(result) |
| goto out; |
| result = set_login(conn, user, passwd, options); |
| if(result) |
| goto out; |
| |
| /************************************************************* |
| * Process the "connect to" linked list of hostname/port mappings. |
| * Do this after the remote port number has been fixed in the URL. |
| *************************************************************/ |
| result = parse_connect_to_slist(data, conn, data->set.connect_to); |
| if(result) |
| goto out; |
| |
| /************************************************************* |
| * IDN-fix the hostnames |
| *************************************************************/ |
| result = fix_hostname(conn, &conn->host); |
| if(result) |
| goto out; |
| if(conn->bits.conn_to_host) { |
| result = fix_hostname(conn, &conn->conn_to_host); |
| if(result) |
| goto out; |
| } |
| if(conn->bits.httpproxy) { |
| result = fix_hostname(conn, &conn->http_proxy.host); |
| if(result) |
| goto out; |
| } |
| if(conn->bits.socksproxy) { |
| result = fix_hostname(conn, &conn->socks_proxy.host); |
| if(result) |
| goto out; |
| } |
| |
| /************************************************************* |
| * Check whether the host and the "connect to host" are equal. |
| * Do this after the hostnames have been IDN-fixed. |
| *************************************************************/ |
| if(conn->bits.conn_to_host && |
| strcasecompare(conn->conn_to_host.name, conn->host.name)) { |
| conn->bits.conn_to_host = FALSE; |
| } |
| |
| /************************************************************* |
| * Check whether the port and the "connect to port" are equal. |
| * Do this after the remote port number has been fixed in the URL. |
| *************************************************************/ |
| if(conn->bits.conn_to_port && conn->conn_to_port == conn->remote_port) { |
| conn->bits.conn_to_port = FALSE; |
| } |
| |
| /************************************************************* |
| * If the "connect to" feature is used with an HTTP proxy, |
| * we set the tunnel_proxy bit. |
| *************************************************************/ |
| if((conn->bits.conn_to_host || conn->bits.conn_to_port) && |
| conn->bits.httpproxy) |
| conn->bits.tunnel_proxy = TRUE; |
| |
| /************************************************************* |
| * Setup internals depending on protocol. Needs to be done after |
| * we figured out what/if proxy to use. |
| *************************************************************/ |
| result = setup_connection_internals(conn); |
| if(result) |
| goto out; |
| |
| conn->recv[FIRSTSOCKET] = Curl_recv_plain; |
| conn->send[FIRSTSOCKET] = Curl_send_plain; |
| conn->recv[SECONDARYSOCKET] = Curl_recv_plain; |
| conn->send[SECONDARYSOCKET] = Curl_send_plain; |
| |
| conn->bits.tcp_fastopen = data->set.tcp_fastopen; |
| |
| /*********************************************************************** |
| * file: is a special case in that it doesn't need a network connection |
| ***********************************************************************/ |
| #ifndef CURL_DISABLE_FILE |
| if(conn->handler->flags & PROTOPT_NONETWORK) { |
| bool done; |
| /* this is supposed to be the connect function so we better at least check |
| that the file is present here! */ |
| DEBUGASSERT(conn->handler->connect_it); |
| result = conn->handler->connect_it(conn, &done); |
| |
| /* Setup a "faked" transfer that'll do nothing */ |
| if(!result) { |
| conn->data = data; |
| conn->bits.tcpconnect[FIRSTSOCKET] = TRUE; /* we are "connected */ |
| |
| Curl_conncache_add_conn(data->state.conn_cache, conn); |
| |
| /* |
| * Setup whatever necessary for a resumed transfer |
| */ |
| result = setup_range(data); |
| if(result) { |
| DEBUGASSERT(conn->handler->done); |
| /* we ignore the return code for the protocol-specific DONE */ |
| (void)conn->handler->done(conn, result, FALSE); |
| goto out; |
| } |
| |
| Curl_setup_transfer(conn, -1, -1, FALSE, NULL, /* no download */ |
| -1, NULL); /* no upload */ |
| } |
| |
| /* since we skip do_init() */ |
| Curl_init_do(data, conn); |
| |
| goto out; |
| } |
| #endif |
| |
| /* Get a cloned copy of the SSL config situation stored in the |
| connection struct. But to get this going nicely, we must first make |
| sure that the strings in the master copy are pointing to the correct |
| strings in the session handle strings array! |
| |
| Keep in mind that the pointers in the master copy are pointing to strings |
| that will be freed as part of the Curl_easy struct, but all cloned |
| copies will be separately allocated. |
| */ |
| data->set.ssl.primary.CApath = data->set.str[STRING_SSL_CAPATH_ORIG]; |
| data->set.proxy_ssl.primary.CApath = data->set.str[STRING_SSL_CAPATH_PROXY]; |
| data->set.ssl.primary.CAfile = data->set.str[STRING_SSL_CAFILE_ORIG]; |
| data->set.proxy_ssl.primary.CAfile = data->set.str[STRING_SSL_CAFILE_PROXY]; |
| data->set.ssl.primary.random_file = data->set.str[STRING_SSL_RANDOM_FILE]; |
| data->set.proxy_ssl.primary.random_file = |
| data->set.str[STRING_SSL_RANDOM_FILE]; |
| data->set.ssl.primary.egdsocket = data->set.str[STRING_SSL_EGDSOCKET]; |
| data->set.proxy_ssl.primary.egdsocket = data->set.str[STRING_SSL_EGDSOCKET]; |
| data->set.ssl.primary.cipher_list = |
| data->set.str[STRING_SSL_CIPHER_LIST_ORIG]; |
| data->set.proxy_ssl.primary.cipher_list = |
| data->set.str[STRING_SSL_CIPHER_LIST_PROXY]; |
| |
| data->set.ssl.CRLfile = data->set.str[STRING_SSL_CRLFILE_ORIG]; |
| data->set.proxy_ssl.CRLfile = data->set.str[STRING_SSL_CRLFILE_PROXY]; |
| data->set.ssl.issuercert = data->set.str[STRING_SSL_ISSUERCERT_ORIG]; |
| data->set.proxy_ssl.issuercert = data->set.str[STRING_SSL_ISSUERCERT_PROXY]; |
| data->set.ssl.cert = data->set.str[STRING_CERT_ORIG]; |
| data->set.proxy_ssl.cert = data->set.str[STRING_CERT_PROXY]; |
| data->set.ssl.cert_type = data->set.str[STRING_CERT_TYPE_ORIG]; |
| data->set.proxy_ssl.cert_type = data->set.str[STRING_CERT_TYPE_PROXY]; |
| data->set.ssl.key = data->set.str[STRING_KEY_ORIG]; |
| data->set.proxy_ssl.key = data->set.str[STRING_KEY_PROXY]; |
| data->set.ssl.key_type = data->set.str[STRING_KEY_TYPE_ORIG]; |
| data->set.proxy_ssl.key_type = data->set.str[STRING_KEY_TYPE_PROXY]; |
| data->set.ssl.key_passwd = data->set.str[STRING_KEY_PASSWD_ORIG]; |
| data->set.proxy_ssl.key_passwd = data->set.str[STRING_KEY_PASSWD_PROXY]; |
| data->set.ssl.primary.clientcert = data->set.str[STRING_CERT_ORIG]; |
| data->set.proxy_ssl.primary.clientcert = data->set.str[STRING_CERT_PROXY]; |
| #ifdef USE_TLS_SRP |
| data->set.ssl.username = data->set.str[STRING_TLSAUTH_USERNAME_ORIG]; |
| data->set.proxy_ssl.username = data->set.str[STRING_TLSAUTH_USERNAME_PROXY]; |
| data->set.ssl.password = data->set.str[STRING_TLSAUTH_PASSWORD_ORIG]; |
| data->set.proxy_ssl.password = data->set.str[STRING_TLSAUTH_PASSWORD_PROXY]; |
| #endif |
| |
| if(!Curl_clone_primary_ssl_config(&data->set.ssl.primary, |
| &conn->ssl_config)) { |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| |
| if(!Curl_clone_primary_ssl_config(&data->set.proxy_ssl.primary, |
| &conn->proxy_ssl_config)) { |
| result = CURLE_OUT_OF_MEMORY; |
| goto out; |
| } |
| |
| prune_dead_connections(data); |
| |
| /************************************************************* |
| * Check the current list of connections to see if we can |
| * re-use an already existing one or if we have to create a |
| * new one. |
| *************************************************************/ |
| |
| /* reuse_fresh is TRUE if we are told to use a new connection by force, but |
| we only acknowledge this option if this is not a re-used connection |
| already (which happens due to follow-location or during a HTTP |
| authentication phase). */ |
| if(data->set.reuse_fresh && !data->state.this_is_a_follow) |
| reuse = FALSE; |
| else |
| reuse = ConnectionExists(data, conn, &conn_temp, &force_reuse, &waitpipe); |
| |
| /* If we found a reusable connection that is now marked as in use, we may |
| still want to open a new connection if we are pipelining. */ |
| if(reuse && !force_reuse && IsPipeliningPossible(data, conn_temp)) { |
| size_t pipelen = conn_temp->send_pipe.size + conn_temp->recv_pipe.size; |
| if(pipelen > 0) { |
| infof(data, "Found connection %ld, with requests in the pipe (%zu)\n", |
| conn_temp->connection_id, pipelen); |
| |
| if(Curl_conncache_bundle_size(conn_temp) < max_host_connections && |
| Curl_conncache_size(data) < max_total_connections) { |
| /* We want a new connection anyway */ |
| reuse = FALSE; |
| |
| infof(data, "We can reuse, but we want a new connection anyway\n"); |
| Curl_conncache_return_conn(conn_temp); |
| } |
| } |
| } |
| |
| if(reuse) { |
| /* |
| * We already have a connection for this, we got the former connection |
| * in the conn_temp variable and thus we need to cleanup the one we |
| * just allocated before we can move along and use the previously |
| * existing one. |
| */ |
| reuse_conn(conn, conn_temp); |
| #ifdef USE_SSL |
| free(conn->ssl_extra); |
| #endif |
| free(conn); /* we don't need this anymore */ |
| conn = conn_temp; |
| *in_connect = conn; |
| |
| infof(data, "Re-using existing connection! (#%ld) with %s %s\n", |
| conn->connection_id, |
| conn->bits.proxy?"proxy":"host", |
| conn->socks_proxy.host.name ? conn->socks_proxy.host.dispname : |
| conn->http_proxy.host.name ? conn->http_proxy.host.dispname : |
| conn->host.dispname); |
| } |
| else { |
| /* We have decided that we want a new connection. However, we may not |
| be able to do that if we have reached the limit of how many |
| connections we are allowed to open. */ |
| |
| if(conn->handler->flags & PROTOPT_ALPN_NPN) { |
| /* The protocol wants it, so set the bits if enabled in the easy handle |
| (default) */ |
| if(data->set.ssl_enable_alpn) |
| conn->bits.tls_enable_alpn = TRUE; |
| if(data->set.ssl_enable_npn) |
| conn->bits.tls_enable_npn = TRUE; |
| } |
| |
| if(waitpipe) |
| /* There is a connection that *might* become usable for pipelining |
| "soon", and we wait for that */ |
| connections_available = FALSE; |
| else { |
| /* this gets a lock on the conncache */ |
| struct connectbundle *bundle = |
| Curl_conncache_find_bundle(conn, data->state.conn_cache); |
| |
| if(max_host_connections > 0 && bundle && |
| (bundle->num_connections >= max_host_connections)) { |
| struct connectdata *conn_candidate; |
| |
| /* The bundle is full. Extract the oldest connection. */ |
| conn_candidate = Curl_conncache_extract_bundle(data, bundle); |
| Curl_conncache_unlock(conn); |
| |
| if(conn_candidate) { |
| /* Set the connection's owner correctly, then kill it */ |
| conn_candidate->data = data; |
| (void)Curl_disconnect(conn_candidate, /* dead_connection */ FALSE); |
| } |
| else { |
| infof(data, "No more connections allowed to host: %d\n", |
| max_host_connections); |
| connections_available = FALSE; |
| } |
| } |
| else |
| Curl_conncache_unlock(conn); |
| |
| } |
| |
| if(connections_available && |
| (max_total_connections > 0) && |
| (Curl_conncache_size(data) >= max_total_connections)) { |
| struct connectdata *conn_candidate; |
| |
| /* The cache is full. Let's see if we can kill a connection. */ |
| conn_candidate = Curl_conncache_extract_oldest(data); |
| |
| if(conn_candidate) { |
| /* Set the connection's owner correctly, then kill it */ |
| conn_candidate->data = data; |
| (void)Curl_disconnect(conn_candidate, /* dead_connection */ FALSE); |
| } |
| else { |
| infof(data, "No connections available in cache\n"); |
| connections_available = FALSE; |
| } |
| } |
| |
| if(!connections_available) { |
| infof(data, "No connections available.\n"); |
| |
| conn_free(conn); |
| *in_connect = NULL; |
| |
| result = CURLE_NO_CONNECTION_AVAILABLE; |
| goto out; |
| } |
| else { |
| /* Mark the connection as used, before we add it */ |
| conn->inuse = TRUE; |
| |
| /* |
| * This is a brand new connection, so let's store it in the connection |
| * cache of ours! |
| */ |
| Curl_conncache_add_conn(data->state.conn_cache, conn); |
| } |
| |
| #if defined(USE_NTLM) |
| /* If NTLM is requested in a part of this connection, make sure we don't |
| assume the state is fine as this is a fresh connection and NTLM is |
| connection based. */ |
| if((data->state.authhost.picked & (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) && |
| data->state.authhost.done) { |
| infof(data, "NTLM picked AND auth done set, clear picked!\n"); |
| data->state.authhost.picked = CURLAUTH_NONE; |
| data->state.authhost.done = FALSE; |
| } |
| |
| if((data->state.authproxy.picked & (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) && |
| data->state.authproxy.done) { |
| infof(data, "NTLM-proxy picked AND auth done set, clear picked!\n"); |
| data->state.authproxy.picked = CURLAUTH_NONE; |
| data->state.authproxy.done = FALSE; |
| } |
| #endif |
| } |
| |
| /* Setup and init stuff before DO starts, in preparing for the transfer. */ |
| Curl_init_do(data, conn); |
| |
| /* |
| * Setup whatever necessary for a resumed transfer |
| */ |
| result = setup_range(data); |
| if(result) |
| goto out; |
| |
| /* Continue connectdata initialization here. */ |
| |
| /* |
| * Inherit the proper values from the urldata struct AFTER we have arranged |
| * the persistent connection stuff |
| */ |
| conn->seek_func = data->set.seek_func; |
| conn->seek_client = data->set.seek_client; |
| |
| /************************************************************* |
| * Resolve the address of the server or proxy |
| *************************************************************/ |
| result = resolve_server(data, conn, async); |
| |
| out: |
| |
| free(options); |
| free(passwd); |
| free(user); |
| return result; |
| } |
| |
| /* Curl_setup_conn() is called after the name resolve initiated in |
| * create_conn() is all done. |
| * |
| * Curl_setup_conn() also handles reused connections |
| * |
| * conn->data MUST already have been setup fine (in create_conn) |
| */ |
| |
| CURLcode Curl_setup_conn(struct connectdata *conn, |
| bool *protocol_done) |
| { |
| CURLcode result = CURLE_OK; |
| struct Curl_easy *data = conn->data; |
| |
| Curl_pgrsTime(data, TIMER_NAMELOOKUP); |
| |
| if(conn->handler->flags & PROTOPT_NONETWORK) { |
| /* nothing to setup when not using a network */ |
| *protocol_done = TRUE; |
| return result; |
| } |
| *protocol_done = FALSE; /* default to not done */ |
| |
| /* set proxy_connect_closed to false unconditionally already here since it |
| is used strictly to provide extra information to a parent function in the |
| case of proxy CONNECT failures and we must make sure we don't have it |
| lingering set from a previous invoke */ |
| conn->bits.proxy_connect_closed = FALSE; |
| |
| /* |
| * Set user-agent. Used for HTTP, but since we can attempt to tunnel |
| * basically anything through a http proxy we can't limit this based on |
| * protocol. |
| */ |
| if(data->set.str[STRING_USERAGENT]) { |
| Curl_safefree(conn->allocptr.uagent); |
| conn->allocptr.uagent = |
| aprintf("User-Agent: %s\r\n", data->set.str[STRING_USERAGENT]); |
| if(!conn->allocptr.uagent) |
| return CURLE_OUT_OF_MEMORY; |
| } |
| |
| data->req.headerbytecount = 0; |
| |
| #ifdef CURL_DO_LINEEND_CONV |
| data->state.crlf_conversions = 0; /* reset CRLF conversion counter */ |
| #endif /* CURL_DO_LINEEND_CONV */ |
| |
| /* set start time here for timeout purposes in the connect procedure, it |
| is later set again for the progress meter purpose */ |
| conn->now = Curl_now(); |
| |
| if(CURL_SOCKET_BAD == conn->sock[FIRSTSOCKET]) { |
| conn->bits.tcpconnect[FIRSTSOCKET] = FALSE; |
| result = Curl_connecthost(conn, conn->dns_entry); |
| if(result) |
| return result; |
| } |
| else { |
| Curl_pgrsTime(data, TIMER_CONNECT); /* we're connected already */ |
| Curl_pgrsTime(data, TIMER_APPCONNECT); /* we're connected already */ |
| conn->bits.tcpconnect[FIRSTSOCKET] = TRUE; |
| *protocol_done = TRUE; |
| Curl_updateconninfo(conn, conn->sock[FIRSTSOCKET]); |
| Curl_verboseconnect(conn); |
| } |
| |
| conn->now = Curl_now(); /* time this *after* the connect is done, we set |
| this here perhaps a second time */ |
| return result; |
| } |
| |
| CURLcode Curl_connect(struct Curl_easy *data, |
| struct connectdata **in_connect, |
| bool *asyncp, |
| bool *protocol_done) |
| { |
| CURLcode result; |
| |
| *asyncp = FALSE; /* assume synchronous resolves by default */ |
| |
| /* call the stuff that needs to be called */ |
| result = create_conn(data, in_connect, asyncp); |
| |
| if(!result) { |
| /* no error */ |
| if((*in_connect)->send_pipe.size || (*in_connect)->recv_pipe.size) |
| /* pipelining */ |
| *protocol_done = TRUE; |
| else if(!*asyncp) { |
| /* DNS resolution is done: that's either because this is a reused |
| connection, in which case DNS was unnecessary, or because DNS |
| really did finish already (synch resolver/fast async resolve) */ |
| result = Curl_setup_conn(*in_connect, protocol_done); |
| } |
| } |
| |
| if(result == CURLE_NO_CONNECTION_AVAILABLE) { |
| *in_connect = NULL; |
| return result; |
| } |
| |
| if(result && *in_connect) { |
| /* We're not allowed to return failure with memory left allocated |
| in the connectdata struct, free those here */ |
| Curl_disconnect(*in_connect, FALSE); /* close the connection */ |
| *in_connect = NULL; /* return a NULL */ |
| } |
| |
| return result; |
| } |
| |
| /* |
| * Curl_init_do() inits the readwrite session. This is inited each time (in |
| * the DO function before the protocol-specific DO functions are invoked) for |
| * a transfer, sometimes multiple times on the same Curl_easy. Make sure |
| * nothing in here depends on stuff that are setup dynamically for the |
| * transfer. |
| * |
| * Allow this function to get called with 'conn' set to NULL. |
| */ |
| |
| CURLcode Curl_init_do(struct Curl_easy *data, struct connectdata *conn) |
| { |
| struct SingleRequest *k = &data->req; |
| |
| conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to |
| use */ |
| |
| data->state.done = FALSE; /* *_done() is not called yet */ |
| data->state.expect100header = FALSE; |
| |
| /* if the protocol used doesn't support wildcards, switch it off */ |
| if(data->state.wildcardmatch && |
| !(conn->handler->flags & PROTOPT_WILDCARD)) |
| data->state.wildcardmatch = FALSE; |
| |
| if(data->set.opt_no_body) |
| /* in HTTP lingo, no body means using the HEAD request... */ |
| data->set.httpreq = HTTPREQ_HEAD; |
| else if(HTTPREQ_HEAD == data->set.httpreq) |
| /* ... but if unset there really is no perfect method that is the |
| "opposite" of HEAD but in reality most people probably think GET |
| then. The important thing is that we can't let it remain HEAD if the |
| opt_no_body is set FALSE since then we'll behave wrong when getting |
| HTTP. */ |
| data->set.httpreq = HTTPREQ_GET; |
| |
| k->start = Curl_now(); /* start time */ |
| k->now = k->start; /* current time is now */ |
| k->header = TRUE; /* assume header */ |
| |
| k->bytecount = 0; |
| |
| k->buf = data->state.buffer; |
| k->hbufp = data->state.headerbuff; |
| k->ignorebody = FALSE; |
| |
| Curl_speedinit(data); |
| |
| Curl_pgrsSetUploadCounter(data, 0); |
| Curl_pgrsSetDownloadCounter(data, 0); |
| |
| return CURLE_OK; |
| } |
| |
| /* |
| * get_protocol_family() |
| * |
| * This is used to return the protocol family for a given protocol. |
| * |
| * Parameters: |
| * |
| * protocol [in] - A single bit protocol identifier such as HTTP or HTTPS. |
| * |
| * Returns the family as a single bit protocol identifier. |
| */ |
| |
| static unsigned int get_protocol_family(unsigned int protocol) |
| { |
| unsigned int family; |
| |
| switch(protocol) { |
| case CURLPROTO_HTTP: |
| case CURLPROTO_HTTPS: |
| family = CURLPROTO_HTTP; |
| break; |
| |
| case CURLPROTO_FTP: |
| case CURLPROTO_FTPS: |
| family = CURLPROTO_FTP; |
| break; |
| |
| case CURLPROTO_SCP: |
| family = CURLPROTO_SCP; |
| break; |
| |
| case CURLPROTO_SFTP: |
| family = CURLPROTO_SFTP; |
| break; |
| |
| case CURLPROTO_TELNET: |
| family = CURLPROTO_TELNET; |
| break; |
| |
| case CURLPROTO_LDAP: |
| case CURLPROTO_LDAPS: |
| family = CURLPROTO_LDAP; |
| break; |
| |
| case CURLPROTO_DICT: |
| family = CURLPROTO_DICT; |
| break; |
| |
| case CURLPROTO_FILE: |
| family = CURLPROTO_FILE; |
| break; |
| |
| case CURLPROTO_TFTP: |
| family = CURLPROTO_TFTP; |
| break; |
| |
| case CURLPROTO_IMAP: |
| case CURLPROTO_IMAPS: |
| family = CURLPROTO_IMAP; |
| break; |
| |
| case CURLPROTO_POP3: |
| case CURLPROTO_POP3S: |
| family = CURLPROTO_POP3; |
| break; |
| |
| case CURLPROTO_SMTP: |
| case CURLPROTO_SMTPS: |
| family = CURLPROTO_SMTP; |
| break; |
| |
| case CURLPROTO_RTSP: |
| family = CURLPROTO_RTSP; |
| break; |
| |
| case CURLPROTO_RTMP: |
| case CURLPROTO_RTMPS: |
| family = CURLPROTO_RTMP; |
| break; |
| |
| case CURLPROTO_RTMPT: |
| case CURLPROTO_RTMPTS: |
| family = CURLPROTO_RTMPT; |
| break; |
| |
| case CURLPROTO_RTMPE: |
| family = CURLPROTO_RTMPE; |
| break; |
| |
| case CURLPROTO_RTMPTE: |
| family = CURLPROTO_RTMPTE; |
| break; |
| |
| case CURLPROTO_GOPHER: |
| family = CURLPROTO_GOPHER; |
| break; |
| |
| case CURLPROTO_SMB: |
| case CURLPROTO_SMBS: |
| family = CURLPROTO_SMB; |
| break; |
| |
| default: |
| family = 0; |
| break; |
| } |
| |
| return family; |
| } |