25 #ifdef HAVE_NETINET_IN_H 26 #include <netinet/in.h> 31 #ifdef HAVE_ARPA_INET_H 32 #include <arpa/inet.h> 37 #ifdef HAVE_SYS_IOCTL_H 38 #include <sys/ioctl.h> 41 #ifdef HAVE_SYS_PARAM_H 42 #include <sys/param.h> 55 #error "We can't compile without socket() support!" 65 #elif defined(USE_WIN32_IDN) 67 bool curl_win32_idn_to_ascii(
const char *in,
char **out);
137 char **userptr,
char **passwdptr,
140 char **userptr,
char **passwdptr,
144 #define READBUFFER_SIZE CURL_MAX_WRITE_SIZE 145 #define READBUFFER_MAX CURL_MAX_READ_SIZE 146 #define READBUFFER_MIN 1024 152 #if READBUFFER_SIZE < READBUFFER_MIN 153 # error READBUFFER_SIZE is too small 163 #ifndef CURL_DISABLE_HTTP 167 #if defined(USE_SSL) && !defined(CURL_DISABLE_HTTP) 171 #ifndef CURL_DISABLE_FTP 175 #if defined(USE_SSL) && !defined(CURL_DISABLE_FTP) 179 #ifndef CURL_DISABLE_TELNET 183 #ifndef CURL_DISABLE_DICT 187 #ifndef CURL_DISABLE_LDAP 189 #if !defined(CURL_DISABLE_LDAPS) && \ 190 ((defined(USE_OPENLDAP) && defined(USE_SSL)) || \ 191 (!defined(USE_OPENLDAP) && defined(HAVE_LDAP_SSL))) 196 #ifndef CURL_DISABLE_FILE 200 #ifndef CURL_DISABLE_TFTP 209 #ifndef CURL_DISABLE_IMAP 216 #ifndef CURL_DISABLE_POP3 223 #if !defined(CURL_DISABLE_SMB) && defined(USE_NTLM) && \ 224 (CURL_SIZEOF_CURL_OFF_T > 4) && \ 225 (!defined(USE_WINDOWS_SSPI) || defined(USE_WIN32_CRYPTO)) 232 #ifndef CURL_DISABLE_SMTP 239 #ifndef CURL_DISABLE_RTSP 243 #ifndef CURL_DISABLE_GOPHER 251 &Curl_handler_rtmpte,
253 &Curl_handler_rtmpts,
333 (userp ? &user : NULL),
334 (passwdp ? &passwd : NULL),
341 if(!user && option && option[0] ==
':') {
520 set->is_fread_set = 0;
521 set->is_fwrite_set = 0;
532 set->postfieldsize = -1;
537 set->ftp_use_epsv =
TRUE;
538 set->ftp_use_eprt =
TRUE;
539 set->ftp_use_pret =
FALSE;
542 set->dns_cache_timeout = 60;
545 set->general_ssl.max_ssl_sessions = 5;
556 set->hide_progress =
TRUE;
562 set->ssl.primary.verifypeer =
TRUE;
563 set->ssl.primary.verifyhost =
TRUE;
569 set->ssl.primary.sessionid =
TRUE;
571 set->proxy_ssl =
set->ssl;
573 set->new_file_perms = 0644;
574 set->new_directory_perms = 0755;
584 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) 589 set->socks5_gssapi_nec =
FALSE;
593 #if defined(CURL_CA_BUNDLE) 602 #if defined(CURL_CA_PATH) 612 set->wildcardmatch =
FALSE;
619 set->tcp_keepalive =
FALSE;
620 set->tcp_keepintvl = 60;
621 set->tcp_keepidle = 60;
622 set->tcp_fastopen =
FALSE;
623 set->tcp_nodelay =
TRUE;
625 set->ssl_enable_npn =
TRUE;
626 set->ssl_enable_alpn =
TRUE;
628 set->expect_100_timeout = 1000L;
629 set->sep_headers =
TRUE;
653 DEBUGF(
fprintf(stderr,
"Error: calloc of Curl_easy failed\n"));
678 DEBUGF(
fprintf(stderr,
"Error: malloc of headerbuff failed\n"));
715 #define C_SSLVERSION_VALUE(x) (x & 0xffff) 716 #define C_SSLVERSION_MAX_VALUE(x) (x & 0xffff0000) 724 #ifndef CURL_DISABLE_HTTP 729 case CURLOPT_DNS_CACHE_TIMEOUT:
732 case CURLOPT_DNS_USE_GLOBAL_CACHE:
734 arg = va_arg(param,
long);
737 case CURLOPT_SSL_CIPHER_LIST:
740 va_arg(param,
char *));
742 case CURLOPT_PROXY_SSL_CIPHER_LIST:
745 va_arg(param,
char *));
748 case CURLOPT_RANDOM_FILE:
754 va_arg(param,
char *));
756 case CURLOPT_EGDSOCKET:
761 va_arg(param,
char *));
763 case CURLOPT_MAXCONNECTS:
770 case CURLOPT_FORBID_REUSE:
777 case CURLOPT_FRESH_CONNECT:
784 case CURLOPT_VERBOSE:
797 case CURLOPT_NOPROGRESS:
813 case CURLOPT_FAILONERROR:
820 case CURLOPT_KEEP_SENDING_ON_ERROR:
841 case CURLOPT_REQUEST_TARGET:
843 va_arg(param,
char *));
845 case CURLOPT_FILETIME:
852 case CURLOPT_FTP_CREATE_MISSING_DIRS:
857 switch(va_arg(param,
long)) {
880 case CURLOPT_TFTP_NO_OPTIONS:
887 case CURLOPT_TFTP_BLKSIZE:
893 case CURLOPT_DIRLISTONLY:
906 case CURLOPT_FTP_FILEMETHOD:
918 case CURLOPT_NETRC_FILE:
923 va_arg(param,
char *));
925 case CURLOPT_TRANSFERTEXT:
934 case CURLOPT_TIMECONDITION:
941 case CURLOPT_TIMEVALUE:
948 case CURLOPT_SSLVERSION:
954 arg = va_arg(param,
long);
961 case CURLOPT_PROXY_SSLVERSION:
967 arg = va_arg(param,
long);
975 #ifndef CURL_DISABLE_HTTP 976 case CURLOPT_AUTOREFERER:
983 case CURLOPT_ACCEPT_ENCODING:
993 argptr = va_arg(param,
char *);
995 (argptr && !*argptr)?
999 case CURLOPT_TRANSFER_ENCODING:
1004 case CURLOPT_FOLLOWLOCATION:
1011 case CURLOPT_UNRESTRICTED_AUTH:
1017 (0 != va_arg(param,
long)) ?
TRUE :
FALSE;
1020 case CURLOPT_MAXREDIRS:
1028 case CURLOPT_POSTREDIR:
1039 arg = va_arg(param,
long);
1048 if(va_arg(param,
long)) {
1056 case CURLOPT_COPYPOSTFIELDS:
1062 argptr = va_arg(param,
char *);
1103 case CURLOPT_POSTFIELDS:
1113 case CURLOPT_POSTFIELDSIZE:
1118 bigsize = va_arg(param,
long);
1130 case CURLOPT_POSTFIELDSIZE_LARGE:
1147 case CURLOPT_HTTPPOST:
1157 case CURLOPT_MIMEPOST:
1170 case CURLOPT_REFERER:
1179 va_arg(param,
char *));
1183 case CURLOPT_USERAGENT:
1188 va_arg(param,
char *));
1191 case CURLOPT_HTTPHEADER:
1198 #ifndef CURL_DISABLE_HTTP 1199 case CURLOPT_PROXYHEADER:
1213 case CURLOPT_HEADEROPT:
1217 arg = va_arg(param,
long);
1221 case CURLOPT_HTTP200ALIASES:
1228 #if !defined(CURL_DISABLE_COOKIES) 1229 case CURLOPT_COOKIE:
1234 va_arg(param,
char *));
1237 case CURLOPT_COOKIEFILE:
1241 argptr = (
char *)va_arg(param,
void *);
1256 case CURLOPT_COOKIEJAR:
1263 va_arg(param,
char *));
1277 case CURLOPT_COOKIESESSION:
1296 case CURLOPT_COOKIELIST:
1297 argptr = va_arg(param,
char *);
1329 if(!argptr || !data->
cookies) {
1352 case CURLOPT_HTTPGET:
1356 if(va_arg(param,
long)) {
1363 case CURLOPT_HTTP_VERSION:
1368 arg = va_arg(param,
long);
1376 case CURLOPT_EXPECT_100_TIMEOUT_MS:
1386 case CURLOPT_HTTPAUTH:
1393 unsigned long auth = va_arg(param,
unsigned long);
1406 auth &= ~CURLAUTH_DIGEST_IE;
1413 #elif !defined(NTLM_WB_ENABLED) 1424 while(bitcheck < 31) {
1425 if(auth & (1UL << bitcheck++)) {
1437 case CURLOPT_CUSTOMREQUEST:
1442 va_arg(param,
char *));
1450 #ifndef CURL_DISABLE_PROXY 1451 case CURLOPT_HTTPPROXYTUNNEL:
1459 case CURLOPT_PROXYPORT:
1466 case CURLOPT_PROXYAUTH:
1473 unsigned long auth = va_arg(param,
unsigned long);
1486 auth &= ~CURLAUTH_DIGEST_IE;
1492 #elif !defined(NTLM_WB_ENABLED) 1503 while(bitcheck < 31) {
1504 if(auth & (1UL << bitcheck++)) {
1528 va_arg(param,
char *));
1531 case CURLOPT_PRE_PROXY:
1539 va_arg(param,
char *));
1542 case CURLOPT_PROXYTYPE:
1549 case CURLOPT_PROXY_TRANSFER_MODE:
1553 switch(va_arg(param,
long)) {
1568 case CURLOPT_SOCKS5_AUTH:
1573 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) 1574 case CURLOPT_SOCKS5_GSSAPI_NEC:
1578 data->
set.socks5_gssapi_nec = (0 != va_arg(param,
long)) ?
TRUE :
FALSE;
1581 case CURLOPT_SOCKS5_GSSAPI_SERVICE:
1582 case CURLOPT_PROXY_SERVICE_NAME:
1587 va_arg(param,
char *));
1591 #if !defined(CURL_DISABLE_CRYPTO_AUTH) || defined(USE_KERBEROS5) || \ 1593 case CURLOPT_SERVICE_NAME:
1598 va_arg(param,
char *));
1603 case CURLOPT_HEADERDATA:
1609 case CURLOPT_ERRORBUFFER:
1616 case CURLOPT_WRITEDATA:
1621 data->
set.
out = va_arg(param,
void *);
1623 case CURLOPT_FTPPORT:
1628 va_arg(param,
char *));
1632 case CURLOPT_FTP_USE_EPRT:
1636 case CURLOPT_FTP_USE_EPSV:
1640 case CURLOPT_FTP_USE_PRET:
1644 case CURLOPT_FTP_SSL_CCC:
1648 case CURLOPT_FTP_SKIP_PASV_IP:
1656 case CURLOPT_READDATA:
1661 data->
set.
in_set = va_arg(param,
void *);
1663 case CURLOPT_INFILESIZE:
1670 case CURLOPT_INFILESIZE_LARGE:
1677 case CURLOPT_LOW_SPEED_LIMIT:
1684 case CURLOPT_MAX_SEND_SPEED_LARGE:
1691 case CURLOPT_MAX_RECV_SPEED_LARGE:
1698 case CURLOPT_LOW_SPEED_TIME:
1715 va_arg(param,
char *));
1724 case CURLOPT_TIMEOUT:
1729 data->
set.
timeout = va_arg(param,
long) * 1000L;
1732 case CURLOPT_TIMEOUT_MS:
1736 case CURLOPT_CONNECTTIMEOUT:
1743 case CURLOPT_CONNECTTIMEOUT_MS:
1747 case CURLOPT_ACCEPTTIMEOUT_MS:
1754 case CURLOPT_USERPWD:
1763 case CURLOPT_USERNAME:
1768 va_arg(param,
char *));
1771 case CURLOPT_PASSWORD:
1776 va_arg(param,
char *));
1779 case CURLOPT_LOGIN_OPTIONS:
1784 va_arg(param,
char *));
1787 case CURLOPT_XOAUTH2_BEARER:
1792 va_arg(param,
char *));
1795 case CURLOPT_POSTQUOTE:
1801 case CURLOPT_PREQUOTE:
1813 case CURLOPT_RESOLVE:
1827 case CURLOPT_PROGRESSFUNCTION:
1838 case CURLOPT_XFERINFOFUNCTION:
1850 case CURLOPT_PROGRESSDATA:
1857 #ifndef CURL_DISABLE_PROXY 1858 case CURLOPT_PROXYUSERPWD:
1866 case CURLOPT_PROXYUSERNAME:
1871 va_arg(param,
char *));
1873 case CURLOPT_PROXYPASSWORD:
1878 va_arg(param,
char *));
1880 case CURLOPT_NOPROXY:
1885 va_arg(param,
char *));
1894 va_arg(param,
char *));
1896 case CURLOPT_RESUME_FROM:
1902 case CURLOPT_RESUME_FROM_LARGE:
1908 case CURLOPT_DEBUGFUNCTION:
1917 case CURLOPT_DEBUGDATA:
1924 case CURLOPT_STDERR:
1929 data->
set.
err = va_arg(param, FILE *);
1933 case CURLOPT_HEADERFUNCTION:
1939 case CURLOPT_WRITEFUNCTION:
1952 case CURLOPT_READFUNCTION:
1965 case CURLOPT_SEEKFUNCTION:
1971 case CURLOPT_SEEKDATA:
1977 case CURLOPT_CONV_FROM_NETWORK_FUNCTION:
1983 case CURLOPT_CONV_TO_NETWORK_FUNCTION:
1989 case CURLOPT_CONV_FROM_UTF8_FUNCTION:
1995 case CURLOPT_IOCTLFUNCTION:
2001 case CURLOPT_IOCTLDATA:
2007 case CURLOPT_SSLCERT:
2012 va_arg(param,
char *));
2014 case CURLOPT_PROXY_SSLCERT:
2019 va_arg(param,
char *));
2021 case CURLOPT_SSLCERTTYPE:
2026 va_arg(param,
char *));
2028 case CURLOPT_PROXY_SSLCERTTYPE:
2033 va_arg(param,
char *));
2035 case CURLOPT_SSLKEY:
2040 va_arg(param,
char *));
2042 case CURLOPT_PROXY_SSLKEY:
2047 va_arg(param,
char *));
2049 case CURLOPT_SSLKEYTYPE:
2054 va_arg(param,
char *));
2056 case CURLOPT_PROXY_SSLKEYTYPE:
2061 va_arg(param,
char *));
2063 case CURLOPT_KEYPASSWD:
2068 va_arg(param,
char *));
2070 case CURLOPT_PROXY_KEYPASSWD:
2075 va_arg(param,
char *));
2077 case CURLOPT_SSLENGINE:
2081 argptr = va_arg(param,
char *);
2082 if(argptr && argptr[0])
2086 case CURLOPT_SSLENGINE_DEFAULT:
2099 case CURLOPT_INTERFACE:
2105 va_arg(param,
char *));
2107 case CURLOPT_LOCALPORT:
2111 arg = va_arg(param,
long);
2112 if((arg < 0) || (arg > 65535))
2116 case CURLOPT_LOCALPORTRANGE:
2120 arg = va_arg(param,
long);
2121 if((arg < 0) || (arg > 65535))
2125 case CURLOPT_KRBLEVEL:
2130 va_arg(param,
char *));
2133 case CURLOPT_GSSAPI_DELEGATION:
2139 case CURLOPT_SSL_VERIFYPEER:
2146 case CURLOPT_PROXY_SSL_VERIFYPEER:
2153 case CURLOPT_SSL_VERIFYHOST:
2157 arg = va_arg(param,
long);
2165 failf(data,
"CURLOPT_SSL_VERIFYHOST no longer supports 1 as value!");
2171 case CURLOPT_PROXY_SSL_VERIFYHOST:
2175 arg = va_arg(param,
long);
2183 failf(data,
"CURLOPT_SSL_VERIFYHOST no longer supports 1 as value!");
2189 case CURLOPT_SSL_VERIFYSTATUS:
2201 case CURLOPT_SSL_CTX_FUNCTION:
2212 case CURLOPT_SSL_CTX_DATA:
2223 case CURLOPT_SSL_FALSESTART:
2234 case CURLOPT_CERTINFO:
2242 case CURLOPT_PINNEDPUBLICKEY:
2250 va_arg(param,
char *));
2255 case CURLOPT_PROXY_PINNEDPUBLICKEY:
2263 va_arg(param,
char *));
2268 case CURLOPT_CAINFO:
2273 va_arg(param,
char *));
2275 case CURLOPT_PROXY_CAINFO:
2281 va_arg(param,
char *));
2283 case CURLOPT_CAPATH:
2292 va_arg(param,
char *));
2297 case CURLOPT_PROXY_CAPATH:
2306 va_arg(param,
char *));
2311 case CURLOPT_CRLFILE:
2317 va_arg(param,
char *));
2319 case CURLOPT_PROXY_CRLFILE:
2325 va_arg(param,
char *));
2327 case CURLOPT_ISSUERCERT:
2333 va_arg(param,
char *));
2335 case CURLOPT_TELNETOPTIONS:
2342 case CURLOPT_BUFFERSIZE:
2347 arg = va_arg(param,
long);
2360 DEBUGF(
fprintf(stderr,
"Error: realloc of buffer failed\n"));
2370 case CURLOPT_NOSIGNAL:
2392 #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES) 2419 #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES) 2439 case CURLOPT_PRIVATE:
2446 case CURLOPT_MAXFILESIZE:
2454 case CURLOPT_USE_SSL:
2461 case CURLOPT_SSL_OPTIONS:
2462 arg = va_arg(param,
long);
2467 case CURLOPT_PROXY_SSL_OPTIONS:
2468 arg = va_arg(param,
long);
2474 case CURLOPT_FTPSSLAUTH:
2481 case CURLOPT_IPRESOLVE:
2482 data->
set.
ipver = va_arg(param,
long);
2485 case CURLOPT_MAXFILESIZE_LARGE:
2492 case CURLOPT_TCP_NODELAY:
2500 case CURLOPT_FTP_ACCOUNT:
2502 va_arg(param,
char *));
2505 case CURLOPT_IGNORE_CONTENT_LENGTH:
2509 case CURLOPT_CONNECT_ONLY:
2516 case CURLOPT_FTP_ALTERNATIVE_TO_USER:
2518 va_arg(param,
char *));
2521 case CURLOPT_SOCKOPTFUNCTION:
2528 case CURLOPT_SOCKOPTDATA:
2535 case CURLOPT_OPENSOCKETFUNCTION:
2543 case CURLOPT_OPENSOCKETDATA:
2550 case CURLOPT_CLOSESOCKETFUNCTION:
2558 case CURLOPT_CLOSESOCKETDATA:
2565 case CURLOPT_SSL_SESSIONID_CACHE:
2573 case CURLOPT_SSH_AUTH_TYPES:
2577 case CURLOPT_SSH_PUBLIC_KEYFILE:
2582 va_arg(param,
char *));
2585 case CURLOPT_SSH_PRIVATE_KEYFILE:
2590 va_arg(param,
char *));
2592 case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
2598 va_arg(param,
char *));
2600 #ifdef HAVE_LIBSSH2_KNOWNHOST_API 2601 case CURLOPT_SSH_KNOWNHOSTS:
2606 va_arg(param,
char *));
2609 case CURLOPT_SSH_KEYFUNCTION:
2615 case CURLOPT_SSH_KEYDATA:
2625 case CURLOPT_HTTP_TRANSFER_DECODING:
2632 case CURLOPT_HTTP_CONTENT_DECODING:
2639 case CURLOPT_NEW_FILE_PERMS:
2646 case CURLOPT_NEW_DIRECTORY_PERMS:
2653 case CURLOPT_ADDRESS_SCOPE:
2659 arg = va_arg(param,
long);
2660 if((arg < 0) || (arg > 0xf))
2665 case CURLOPT_PROTOCOLS:
2673 case CURLOPT_REDIR_PROTOCOLS:
2681 case CURLOPT_DEFAULT_PROTOCOL:
2684 va_arg(param,
char *));
2687 case CURLOPT_MAIL_FROM:
2690 va_arg(param,
char *));
2693 case CURLOPT_MAIL_AUTH:
2696 va_arg(param,
char *));
2699 case CURLOPT_MAIL_RCPT:
2704 case CURLOPT_SASL_IR:
2709 case CURLOPT_RTSP_REQUEST:
2715 long curl_rtspreq = va_arg(param,
long);
2717 switch(curl_rtspreq) {
2770 case CURLOPT_RTSP_SESSION_ID:
2776 va_arg(param,
char *));
2779 case CURLOPT_RTSP_STREAM_URI:
2785 va_arg(param,
char *));
2788 case CURLOPT_RTSP_TRANSPORT:
2793 va_arg(param,
char *));
2796 case CURLOPT_RTSP_CLIENT_CSEQ:
2805 case CURLOPT_RTSP_SERVER_CSEQ:
2810 case CURLOPT_INTERLEAVEDATA:
2813 case CURLOPT_INTERLEAVEFUNCTION:
2818 case CURLOPT_WILDCARDMATCH:
2821 case CURLOPT_CHUNK_BGN_FUNCTION:
2824 case CURLOPT_CHUNK_END_FUNCTION:
2827 case CURLOPT_FNMATCH_FUNCTION:
2830 case CURLOPT_CHUNK_DATA:
2833 case CURLOPT_FNMATCH_DATA:
2837 case CURLOPT_TLSAUTH_USERNAME:
2839 va_arg(param,
char *));
2840 if(data->
set.
str[STRING_TLSAUTH_USERNAME_ORIG] && !data->
set.
ssl.authtype)
2843 case CURLOPT_PROXY_TLSAUTH_USERNAME:
2845 va_arg(param,
char *));
2846 if(data->
set.
str[STRING_TLSAUTH_USERNAME_PROXY] &&
2850 case CURLOPT_TLSAUTH_PASSWORD:
2852 va_arg(param,
char *));
2853 if(data->
set.
str[STRING_TLSAUTH_USERNAME_ORIG] && !data->
set.
ssl.authtype)
2856 case CURLOPT_PROXY_TLSAUTH_PASSWORD:
2858 va_arg(param,
char *));
2859 if(data->
set.
str[STRING_TLSAUTH_USERNAME_PROXY] &&
2863 case CURLOPT_TLSAUTH_TYPE:
2864 argptr = va_arg(param,
char *);
2871 case CURLOPT_PROXY_TLSAUTH_TYPE:
2872 argptr = va_arg(param,
char *);
2880 case CURLOPT_DNS_SERVERS:
2883 case CURLOPT_DNS_INTERFACE:
2886 case CURLOPT_DNS_LOCAL_IP4:
2889 case CURLOPT_DNS_LOCAL_IP6:
2893 case CURLOPT_TCP_KEEPALIVE:
2896 case CURLOPT_TCP_KEEPIDLE:
2899 case CURLOPT_TCP_KEEPINTVL:
2902 case CURLOPT_TCP_FASTOPEN:
2903 #if defined(CONNECT_DATA_IDEMPOTENT) || defined(MSG_FASTOPEN) 2909 case CURLOPT_SSL_ENABLE_NPN:
2912 case CURLOPT_SSL_ENABLE_ALPN:
2916 #ifdef USE_UNIX_SOCKETS 2917 case CURLOPT_UNIX_SOCKET_PATH:
2920 va_arg(param,
char *));
2922 case CURLOPT_ABSTRACT_UNIX_SOCKET:
2925 va_arg(param,
char *));
2929 case CURLOPT_PATH_AS_IS:
2932 case CURLOPT_PIPEWAIT:
2935 case CURLOPT_STREAM_WEIGHT:
2939 arg = va_arg(param,
long);
2940 if((arg >= 1) && (arg <= 256))
2944 case CURLOPT_STREAM_DEPENDS:
2945 case CURLOPT_STREAM_DEPENDS_E:
2960 case CURLOPT_CONNECT_TO:
2963 case CURLOPT_SUPPRESS_CONNECT_HEADERS:
2966 case CURLOPT_SSH_COMPRESSION:
2978 #ifdef USE_RECV_BEFORE_SEND_WORKAROUND 2979 static void conn_reset_postponed_data(
struct connectdata *conn,
int num)
2981 struct postponed_data *
const psnd = &(conn->postponed[num]);
2984 DEBUGASSERT(psnd->recv_size <= psnd->allocated_size);
2986 (psnd->recv_processed < psnd->recv_size) :
2987 (psnd->recv_processed == 0));
2990 psnd->buffer = NULL;
2991 psnd->allocated_size = 0;
2992 psnd->recv_size = 0;
2993 psnd->recv_processed = 0;
3008 conn_reset_postponed_data(conn, 0);
3009 conn_reset_postponed_data(conn, 1);
3013 #define conn_reset_all_postponed_data(c) do {} WHILE_FALSE 3039 #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) && \ 3040 defined(NTLM_WB_ENABLED) 3041 Curl_ntlm_wb_cleanup(conn);
3080 #ifdef USE_UNIX_SOCKETS 3105 DEBUGF(
fprintf(stderr,
"DISCONNECT without easy handle, ignoring\n"));
3115 DEBUGF(
infof(data,
"Curl_disconnect, usecounter: %d\n",
3127 #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) 3129 Curl_http_ntlm_cleanup(conn);
3166 bool ret_val =
TRUE;
3212 curr = pipeline->
head;
3214 if(curr->
ptr == handle) {
3226 static void Curl_printPipeline(
struct curl_llist *pipeline)
3230 curr = pipeline->
head;
3272 curr = pipeline->
head;
3280 infof(data,
"signalPipeClose() found BAAD easy handle\n");
3306 time_t highscore =- 1;
3330 if(score > highscore) {
3332 conn_candidate = conn;
3341 return conn_candidate;
3369 time_t highscore = -1;
3387 if(score > highscore) {
3389 conn_candidate = conn;
3395 return conn_candidate;
3408 if(!pipeLen && !conn->
inuse) {
3462 if(elapsed >= 1000L) {
3497 bool foundPendingCandidate =
FALSE;
3511 *force_reuse =
FALSE;
3517 canpipe &= ~ CURLPIPE_HTTP1;
3526 size_t best_pipe_len = max_pipe_len;
3529 infof(data,
"Found bundle for host %s: %p [%s]\n",
3531 needle->
host.
name), (
void *)bundle,
3535 "can multiplex" :
"serially")));
3541 infof(data,
"Server doesn't support multi-use yet, wait\n");
3546 infof(data,
"Server doesn't support multi-use (yet)\n");
3552 infof(data,
"Could pipeline, but not asked to!\n");
3557 infof(data,
"Could multiplex, but not asked to!\n");
3610 "Connection #%ld is still name resolving, can't reuse\n",
3619 foundPendingCandidate =
TRUE;
3622 infof(data,
"Connection #%ld isn't open enough, can't reuse\n",
3627 "BAD! Unconnected #%ld has a non-empty recv pipeline!\n",
3635 #ifdef USE_UNIX_SOCKETS 3636 if(needle->unix_domain_socket) {
3637 if(!check->unix_domain_socket)
3639 if(strcmp(needle->unix_domain_socket, check->unix_domain_socket))
3641 if(needle->abstract_unix_socket != check->abstract_unix_socket)
3644 else if(check->unix_domain_socket)
3701 if(!canpipe && check->
inuse)
3728 if(strcmp(needle->
user, check->
user) ||
3759 "Connection #%ld has different SSL parameters, " 3765 foundPendingCandidate =
TRUE;
3767 "Connection #%ld has not started SSL connect, " 3783 #if defined(USE_NTLM) 3790 if(strcmp(needle->
user, check->
user) ||
3800 if(wantProxyNTLMhttp) {
3815 if(wantNTLMhttp || wantProxyNTLMhttp) {
3821 (wantProxyNTLMhttp &&
3824 *force_reuse =
TRUE;
3844 if(max_pipe_len && (pipeLen >= max_pipe_len)) {
3845 infof(data,
"Pipe is full, skip (%zu)\n", pipeLen);
3853 if(pipeLen >= httpc->settings.max_concurrent_streams) {
3854 infof(data,
"MAX_CONCURRENT_STREAMS reached, skip (%zu)\n",
3862 infof(data,
"Penalized, skip\n");
3867 if(pipeLen < best_pipe_len) {
3871 best_pipe_len = pipeLen;
3878 infof(data,
"Multiplexed connection found!\n");
3898 "Found pending candidate for reuse and CURLOPT_PIPEWAIT is set\n");
3916 #ifndef CURL_DISABLE_PROXY 3935 host, port, sockindex, conn);
3945 failf(conn->
data,
"unknown proxytype option given");
3960 #ifndef CURL_DISABLE_VERBOSE_STRINGS 3964 infof(conn->
data,
"Connected to %s (%s) port %ld (#%ld)\n",
4037 bool *protocol_done)
4041 *protocol_done =
FALSE;
4051 *protocol_done =
TRUE;
4079 *protocol_done =
TRUE;
4095 const unsigned char *ch = (
const unsigned char *)hostname;
4115 #elif defined(CURL_DISABLE_VERBOSE_STRINGS) 4122 len = strlen(host->
name);
4123 if(len && (host->
name[len-1] ==
'.'))
4126 host->
name[len-1] = 0;
4131 if(idn2_check_version(IDN2_VERSION)) {
4132 char *ace_hostname = NULL;
4133 #if IDN2_VERSION_NUMBER >= 0x00140000 4137 int flags = IDN2_NFC_INPUT | IDN2_NONTRANSITIONAL;
4139 int flags = IDN2_NFC_INPUT;
4141 int rc = idn2_lookup_ul((
const char *)host->
name, &ace_hostname, flags);
4143 host->
encalloc = (
char *)ace_hostname;
4148 infof(data,
"Failed to convert %s to ACE; %s\n", host->
name,
4151 #elif defined(USE_WIN32_IDN) 4152 char *ace_hostname = NULL;
4154 if(curl_win32_idn_to_ascii(host->
name, &ace_hostname)) {
4160 infof(data,
"Failed to convert %s to ACE;\n", host->
name);
4162 infof(data,
"IDN support not present, can't parse Unicode domains\n");
4172 #if defined(USE_LIBIDN2) 4178 #elif defined(USE_WIN32_IDN) 4200 #define SSL_EXTRA + 4 * Curl_ssl->sizeof_ssl_backend_data - sizeof(long long) 4221 #if defined(USE_RECV_BEFORE_SEND_WORKAROUND) && defined(DEBUGBUILD) 4229 connclose(conn,
"Default to force-close");
4240 #ifdef CURL_DISABLE_PROXY 4293 char *
p = (
char *)&conn->align_data__do_not_use;
4294 conn->
ssl[0].backend = (
struct ssl_backend_data *)
p;
4295 conn->
ssl[1].backend =
4304 #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) && \ 4305 defined(NTLM_WB_ENABLED) 4307 conn->ntlm_auth_hlpr_pid = 0;
4308 conn->challenge_header = NULL;
4309 conn->response_header = NULL;
4325 conn->data_prot = PROT_CLEAR;
4356 const char *protostr)
4364 for(pp = protocols; (p = *pp) != NULL; pp++) {
4402 char **userp,
char **passwdp,
4411 const char *protop =
"";
4413 bool rebuild_url =
FALSE;
4414 bool url_has_scheme =
FALSE;
4417 *prot_missing =
FALSE;
4422 failf(data,
"Illegal characters found in URL");
4435 failf(data,
"Bad URL, colon is first character");
4440 #define STARTS_WITH_DRIVE_PREFIX(str) \ 4441 ((('a' <= str[0] && str[0] <= 'z') || \ 4442 ('A' <= str[0] && str[0] <= 'Z')) && \ 4457 url_has_scheme =
TRUE;
4468 rc = sscanf(data->
change.
url,
"%*15[^\n/:]:%[^\n]", path);
4470 rc = sscanf(data->
change.
url,
"%[^\n]", path);
4473 failf(data,
"Bad URL");
4477 if(url_has_scheme && path[0] ==
'/' && path[1] ==
'/') {
4485 memmove(path, path + 2, strlen(path + 2) + 1);
4499 failf(data,
"Invalid file://hostname/, " 4500 "expected localhost or 127.0.0.1 or none");
4526 memmove(path, ptr, strlen(ptr) + 1);
4529 #if !defined(MSDOS) && !defined(WIN32) && !defined(__CYGWIN__) 4531 failf(data,
"File drive letters are only accepted in MSDOS/Windows.");
4537 *prot_missing = !url_has_scheme;
4545 "%15[^\n/:]:%3[/]%[^\n/?#]%[^\n]",
4546 protobuf, slashbuf, conn->
host.
name, path);
4548 failf(data,
"Bad URL");
4564 #if defined(__DJGPP__) && (DJGPP_MINOR == 4) 4565 if(!(rc == -1 && *conn->
host.
name))
4568 failf(data,
"<url> malformed");
4600 *prot_missing =
TRUE;
4603 size_t s = strlen(slashbuf);
4606 infof(data,
"Unwillingly accepted illegal URL using %d slash%s!\n",
4627 query = strchr(at + 1,
'?');
4629 query = strchr(conn->
host.
name,
'?');
4640 size_t hostlen = strlen(query);
4641 size_t pathlen = strlen(path);
4645 memmove(path + hostlen + 1, path, pathlen + 1);
4648 memcpy(path + 1, query, hostlen);
4665 if(path[0] !=
'/') {
4669 memmove(&path[1], path, strlen(path) + 1);
4679 if(strcmp(newp, path)) {
4699 size_t plen = strlen(path);
4701 size_t prefixlen = strlen(conn->
host.
name);
4703 if(!*prot_missing) {
4704 size_t protolen = strlen(protop);
4707 prefixlen += protolen;
4709 failf(data,
"<url> malformed");
4717 prefixlen += 1 + (data->
change.
url[5] ==
'/');
4719 failf(data,
"<url> malformed");
4724 reurl =
malloc(prefixlen + plen + 1);
4732 memcpy(&reurl[prefixlen], path, plen + 1);
4740 infof(data,
"Rebuilt URL to: %s\n", reurl);
4761 char *percent = strchr(conn->
host.
name,
'%');
4763 unsigned int identifier_offset = 3;
4765 unsigned long scope;
4766 if(strncmp(
"%25", percent, 3) != 0) {
4768 "Please URL encode %% as %%25, see RFC 6874.\n");
4769 identifier_offset = 1;
4771 scope = strtoul(percent + identifier_offset, &endp, 10);
4775 memmove(percent, endp, strlen(endp) + 1);
4776 conn->
scope_id = (
unsigned int)scope;
4780 #if defined(HAVE_NET_IF_H) && defined(IFNAMSIZ) && defined(HAVE_IF_NAMETOINDEX) 4781 char ifname[IFNAMSIZ + 2];
4782 char *square_bracket;
4783 unsigned int scopeidx = 0;
4784 strncpy(ifname, percent + identifier_offset, IFNAMSIZ + 2);
4786 ifname[IFNAMSIZ + 1] =
'\0';
4787 square_bracket = strchr(ifname,
']');
4788 if(square_bracket) {
4790 *square_bracket =
'\0';
4791 scopeidx = if_nametoindex(ifname);
4793 infof(data,
"Invalid network interface: %s; %s\n", ifname,
4798 char *
p = percent + identifier_offset + strlen(ifname);
4801 memmove(percent, p, strlen(p) + 1);
4806 infof(data,
"Invalid IPv6 address format\n");
4818 fragment = strchr(path,
'#');
4825 fragment = strchr(data->
change.
url,
'#');
4930 #ifndef CURL_DISABLE_PROXY 4944 const char *separator =
", ";
4945 size_t no_proxy_len;
4949 if(no_proxy && no_proxy[0]) {
4956 no_proxy_len = strlen(no_proxy);
4957 endptr = strchr(name,
':');
4959 namelen = endptr -
name;
4961 namelen = strlen(name);
4963 for(tok_start = 0; tok_start < no_proxy_len; tok_start = tok_end + 1) {
4964 while(tok_start < no_proxy_len &&
4965 strchr(separator, no_proxy[tok_start]) != NULL) {
4970 if(tok_start == no_proxy_len)
4973 for(tok_end = tok_start; tok_end < no_proxy_len &&
4974 strchr(separator, no_proxy[tok_end]) == NULL; ++tok_end)
4982 if(no_proxy[tok_start] ==
'.')
4985 if((tok_end - tok_start) <= namelen) {
4987 const char *checkn = name + namelen - (tok_end - tok_start);
4989 tok_end - tok_start)) {
4990 if((tok_end - tok_start) == namelen || *(checkn - 1) ==
'.') {
5005 #ifndef CURL_DISABLE_HTTP 5032 char proxy_env[128];
5034 char *envp = proxy_env;
5039 *envp++ = (char)tolower((
int)*protop++);
5042 strcpy(envp,
"_proxy");
5094 char *proxyuser = NULL;
5095 char *proxypasswd = NULL;
5103 endofprot = strstr(proxy,
"://");
5105 proxyptr = endofprot + 3;
5120 failf(data,
"Unsupported proxy scheme for \'%s\'", proxy);
5131 failf(data,
"Unsupported proxy \'%s\', libcurl is built without the " 5132 "HTTPS-proxy support.", proxy);
5142 atsign = strchr(proxyptr,
'@');
5146 &proxyuser, &proxypasswd, NULL);
5149 proxyptr = atsign + 1;
5156 if(*proxyptr ==
'[') {
5157 char *
ptr = ++proxyptr;
5158 while(*ptr && (
ISXDIGIT(*ptr) || (*ptr ==
':') || (*ptr ==
'.')))
5162 if(strncmp(
"%25", ptr, 3))
5163 infof(data,
"Please URL encode %% as %%25, see RFC 6874.\n");
5167 (*ptr ==
'.') || (*ptr ==
'_') || (*ptr ==
'~')))
5174 infof(data,
"Invalid IPv6 address format\n");
5183 prox_portno = strchr(portptr,
':');
5190 port = strtol(prox_portno, &endp, 10);
5191 if((endp && *endp && (*endp !=
'/') && (*endp !=
' ')) ||
5192 (port < 0) || (port > 65535)) {
5198 infof(data,
"No valid port number in proxy string (%s)\n",
5205 if(proxyptr[0]==
'/') {
5216 atsign = strchr(proxyptr,
'/');
5245 if(!proxyinfo->
user) {
5318 char *socksproxy = NULL;
5319 char *no_proxy = NULL;
5339 failf(data,
"memory shortage");
5348 if(NULL == socksproxy) {
5349 failf(data,
"memory shortage");
5366 #ifndef CURL_DISABLE_HTTP 5367 else if(!proxy && !socksproxy)
5374 #ifdef USE_UNIX_SOCKETS 5376 if(proxy && conn->unix_domain_socket) {
5387 if(socksproxy && (!*socksproxy ||
5399 if(proxy || socksproxy) {
5417 #ifdef CURL_DISABLE_HTTP 5496 char **user,
char **passwd,
char **options)
5500 char *passwdp = NULL;
5501 char *optionsp = NULL;
5570 *passwd = newpasswd;
5582 *options = newoptions;
5625 char **userp,
char **passwdp,
5632 const char *psep = NULL;
5633 const char *osep = NULL;
5640 psep = strchr(login,
':');
5643 if(psep >= login + len)
5649 osep = strchr(login,
';');
5652 if(osep >= login + len)
5658 (
size_t)(osep && psep > osep ? osep - login : psep - login) :
5661 (osep && osep > psep ? (
size_t)(osep - psep) :
5662 (
size_t)(login + len - psep)) - 1 : 0);
5664 (psep && psep > osep ? (
size_t)(psep - osep) :
5665 (
size_t)(login + len - osep)) - 1 : 0);
5675 if(!result && passwdp && plen) {
5684 if(!result && optionsp && olen) {
5696 memcpy(ubuf, login, ulen);
5704 memcpy(pbuf, psep + 1, plen);
5712 memcpy(obuf, osep + 1, olen);
5745 if((1 == sscanf(conn->
host.
name,
"[%*45[0123456789abcdefABCDEF:.]%c",
5747 (
']' == endbracket)) {
5752 portptr = strchr(conn->
host.
name,
']');
5761 struct in6_addr in6;
5765 failf(data,
"IPv6 numerical address used in URL without brackets");
5770 portptr = strchr(conn->
host.
name,
':');
5785 snprintf(type,
sizeof(type),
";type=%c",
5817 port = strtol(portptr + 1, &rest, 10);
5819 if((port < 0) || (port > 0xffff)) {
5821 failf(data,
"Port number out of range");
5826 failf(data,
"Port number ended with '%c'", rest[0]);
5830 if(rest != &portptr[1]) {
5856 char **userp,
char **passwdp,
char **optionsp)
5885 infof(data,
"Couldn't find host %s in the " 5886 DOT_CHAR "netrc file; using defaults\n",
5909 const char *user,
const char *passwd,
5910 const char *options)
5942 if(!result && options[0]) {
5959 char **hostname_result,
5968 #if defined(CURL_DISABLE_VERBOSE_STRINGS) 5972 *hostname_result = NULL;
5988 if(*hostptr ==
'[') {
5989 char *
ptr = ++hostptr;
5990 while(*ptr && (
ISXDIGIT(*ptr) || (*ptr ==
':') || (*ptr ==
'.')))
5994 if(strncmp(
"%25", ptr, 3))
5995 infof(data,
"Please URL encode %% as %%25, see RFC 6874.\n");
5999 (*ptr ==
'.') || (*ptr ==
'_') || (*ptr ==
'~')))
6006 infof(data,
"Invalid IPv6 address format\n");
6015 host_portno = strchr(portptr,
':');
6018 *host_portno =
'\0';
6021 long portparse = strtol(host_portno, &endp, 10);
6022 if((endp && *endp) || (portparse < 0) || (portparse > 65535)) {
6023 infof(data,
"No valid port number in connect to host string (%s)\n",
6029 port = (int)portparse;
6035 *hostname_result =
strdup(hostptr);
6036 if(!*hostname_result) {
6042 *port_result =
port;
6054 const char *conn_to_host,
6059 const char *
ptr = conn_to_host;
6060 int host_match =
FALSE;
6061 int port_match =
FALSE;
6063 *host_result = NULL;
6073 size_t hostname_to_match_len;
6074 char *hostname_to_match =
aprintf(
"%s%s%s",
6078 if(!hostname_to_match)
6080 hostname_to_match_len = strlen(hostname_to_match);
6082 hostname_to_match_len);
6083 free(hostname_to_match);
6084 ptr += hostname_to_match_len;
6086 host_match = host_match && *ptr ==
':';
6098 char *ptr_next = strchr(ptr,
':');
6101 long port_to_match = strtol(ptr, &endp, 10);
6102 if((endp == ptr_next) && (port_to_match == conn->
remote_port)) {
6110 if(host_match && port_match) {
6130 while(conn_to_host && !host && port == -1) {
6141 infof(data,
"Connecting to hostname: %s\n", host);
6152 infof(data,
"Connecting to port: %d\n", port);
6160 conn_to_host = conn_to_host->
next;
6190 #ifdef USE_UNIX_SOCKETS 6191 if(conn->unix_domain_socket) {
6195 const char *
path = conn->unix_domain_socket;
6201 bool longpath =
FALSE;
6202 hostaddr->
addr = Curl_unix2addr(path, &longpath,
6203 conn->abstract_unix_socket);
6209 failf(data,
"Unix socket path too long: '%s'", path);
6226 connhost = &conn->
host;
6237 &hostaddr, timeout_ms);
6244 else if(!hostaddr) {
6245 failf(data,
"Couldn't resolve host '%s'", connhost->
dispname);
6258 &hostaddr, timeout_ms);
6266 else if(!hostaddr) {
6309 old_conn->
user = NULL;
6362 #ifdef USE_UNIX_SOCKETS 6395 bool prot_missing =
FALSE;
6396 bool connections_available =
TRUE;
6397 bool force_reuse =
FALSE;
6398 bool waitpipe =
FALSE;
6437 #define LEAST_PATH_ALLOC 256 6472 if(!user || !passwd || !options) {
6500 for(ch_lower = reurl; *ch_lower !=
':'; ch_lower++)
6501 *ch_lower = (
char)
TOLOWER(*ch_lower);
6538 #ifdef USE_UNIX_SOCKETS 6539 if(data->
set.
str[STRING_UNIX_SOCKET_PATH]) {
6540 conn->unix_domain_socket =
strdup(data->
set.
str[STRING_UNIX_SOCKET_PATH]);
6541 if(conn->unix_domain_socket == NULL) {
6551 #ifndef CURL_DISABLE_PROXY 6576 result =
set_login(conn, user, passwd, options);
6642 #ifndef CURL_DISABLE_FILE 6719 data->
set.
ssl.username = data->
set.
str[STRING_TLSAUTH_USERNAME_ORIG];
6721 data->
set.
ssl.password = data->
set.
str[STRING_TLSAUTH_PASSWORD_ORIG];
6759 infof(data,
"Found connection %ld, with requests in the pipe (%zu)\n",
6767 infof(data,
"We can reuse, but we want a new connection anyway\n");
6786 infof(data,
"Re-using existing connection! (#%ld) with %s %s\n",
6811 connections_available =
FALSE;
6815 if(max_host_connections > 0 && bundle &&
6822 if(conn_candidate) {
6828 infof(data,
"No more connections allowed to host: %d\n",
6829 max_host_connections);
6830 connections_available =
FALSE;
6834 if(connections_available &&
6835 (max_total_connections > 0) &&
6842 if(conn_candidate) {
6848 infof(data,
"No connections available in cache\n");
6849 connections_available =
FALSE;
6853 if(!connections_available) {
6854 infof(data,
"No connections available.\n");
6870 #if defined(USE_NTLM) 6876 infof(data,
"NTLM picked AND auth done set, clear picked!\n");
6883 infof(data,
"NTLM-proxy picked AND auth done set, clear picked!\n");
6934 bool *protocol_done)
6943 *protocol_done =
TRUE;
6946 *protocol_done =
FALSE;
6969 #ifdef CURL_DO_LINEEND_CONV 6987 *protocol_done =
TRUE;
7003 if((data->
set.
out)->_handle == NULL) {
7004 _fsetmode(stdout,
"b");
7014 bool *protocol_done)
7025 if((*in_connect)->send_pipe.size || (*in_connect)->recv_pipe.size)
7027 *protocol_done =
TRUE;
7041 if(result && *in_connect) {
7115 unsigned int family;
struct CookieInfo * Curl_cookie_init(struct Curl_easy *data, const char *file, struct CookieInfo *inc, bool newsession)
CURLcode Curl_connect(struct Curl_easy *data, struct connectdata **in_connect, bool *asyncp, bool *protocol_done)
struct ssl_connect_data ssl[2]
#define CURLAUTH_DIGEST_IE
struct curl_llist recv_pipe
#define CONNECT_FIRSTSOCKET_PROXY_SSL()
static struct connectdata * allocate_conn(struct Curl_easy *data)
struct connectdata * lastconnect
#define CURL_REDIR_POST_ALL
bool Curl_ssl_config_matches(struct ssl_primary_config *data, struct ssl_primary_config *needle)
int(* curl_fnmatch_callback)(void *ptr, const char *pattern, const char *string)
struct Curl_easy * stream_depends_on
CURLcode Curl_conncache_add_conn(struct conncache *connc, struct connectdata *conn)
CURLcode Curl_open(struct Curl_easy **curl)
Curl_open()
CURLcode Curl_urldecode(struct Curl_easy *data, const char *string, size_t length, char **ostring, size_t *olen, bool reject_ctrl)
int Curl_removeHandleFromPipeline(struct Curl_easy *handle, struct curl_llist *pipeline)
CURL_VOLATILE unsigned int dirty
curl_write_callback fwrite_rtp
void Curl_multi_handlePipeBreak(struct Curl_easy *data)
static bool is_ASCII_name(const char *hostname)
static bool check_noproxy(const char *name, const char *no_proxy)
CURLcode Curl_setup_conn(struct connectdata *conn, bool *protocol_done)
unsigned have_pinnedpubkey
#define Curl_http2_init_userset(x)
void Curl_pgrsSetUploadCounter(struct Curl_easy *data, curl_off_t size)
bool socksproxy_connecting
CURLcode(* disconnect)(struct connectdata *, bool dead_connection)
void Curl_hostcache_prune(struct Curl_easy *data)
CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data, const char *local_ip4)
struct curl_slist * prequote
curl_opensocket_callback fopensocket
bool Curl_pipeline_site_blacklisted(struct Curl_easy *handle, struct connectdata *conn)
void Curl_wildcard_dtor(struct WildcardData *wc)
void(* curl_llist_dtor)(void *, void *)
int(* curl_xferinfo_callback)(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
int curlx_sltosi(long slnum)
void Curl_conncache_foreach(struct conncache *connc, void *param, int(*func)(struct connectdata *conn, void *param))
#define CURL_FORMAT_CURL_OFF_TU
void Curl_pgrsTime(struct Curl_easy *data, timerid timer)
#define PROTOPT_NOURLQUERY
struct curl_llist send_pipe
struct Curl_multi * multi_easy
static CURLcode resolve_server(struct Curl_easy *data, struct connectdata *conn, bool *async)
long server_response_timeout
CURLcode Curl_disconnect(struct connectdata *conn, bool dead_connection)
CURLcode Curl_SOCKS5(const char *proxy_user, const char *proxy_password, const char *hostname, int remote_port, int sockindex, struct connectdata *conn)
int(* proto_getsock)(struct connectdata *conn, curl_socket_t *socks, int numsocks)
struct curl_llist timeoutlist
static CURLcode parseurlandfillconn(struct Curl_easy *data, struct connectdata *conn, bool *prot_missing, char **userp, char **passwdp, char **optionsp)
const struct Curl_handler Curl_handler_smtps
int Curl_parsenetrc(const char *host, char **loginp, char **passwordp, char *netrcfile)
long rtsp_next_client_CSeq
curl_off_t set_resume_from
bool http_keep_sending_on_error
bool tunnel_thru_httpproxy
void Curl_mime_cleanpart(curl_mimepart *part)
struct curl_slist * postquote
struct ssl_config_data proxy_ssl
#define CURLSSLOPT_NO_REVOKE
curl_xferinfo_callback fxferinfo
const struct Curl_handler Curl_handler_telnet
#define CURLOPT_SERVER_RESPONSE_TIMEOUT
const struct Curl_handler * handler
unsigned int(* connection_check)(struct connectdata *conn, unsigned int checks_to_perform)
struct Curl_multi * multi
const struct Curl_handler Curl_handler_gopher
#define CURLRESOLV_PENDING
UNITTEST_START char * ptr
#define Curl_ssl_close(x, y)
static const struct Curl_handler Curl_handler_dummy
#define Curl_ssl_set_engine_default(x)
#define C_SSLVERSION_VALUE(x)
static const struct Curl_handler *const protocols[]
CURLcode Curl_initinfo(struct Curl_easy *data)
#define MAX_CURL_PASSWORD_LENGTH
CURLcode(* curl_conv_callback)(char *buffer, size_t length)
int(* curl_closesocket_callback)(void *clientp, curl_socket_t item)
struct Curl_dns_entry * dns_entry
void * Curl_memdup(const void *src, size_t length)
bool http_transfer_encoding
CURLcode(* connect_it)(struct connectdata *, bool *done)
struct curl_slist * connect_to
const struct Curl_handler Curl_handler_smtp
int Curl_protocol_getsock(struct connectdata *conn, curl_socket_t *socks, int numsocks)
void Curl_llist_init(struct curl_llist *l, curl_llist_dtor dtor)
CURLcode Curl_resolver_init(void **resolver)
#define CURLEASY_MAGIC_NUMBER
int Curl_closesocket(struct connectdata *conn, curl_socket_t sock)
static struct Curl_easy * gethandleathead(struct curl_llist *pipeline)
bool Curl_pipeline_wanted(const struct Curl_multi *multi, int bits)
curl_socket_t tempsock[2]
#define realloc(ptr, size)
static CURLcode set_login(struct connectdata *conn, const char *user, const char *passwd, const char *options)
struct curl_slist * telnet_options
struct curl_slist * headers
#define strcasecompare(a, b)
curl_conv_callback convtonetwork
CURL_EXTERN char * curl_getenv(const char *variable)
struct curl_slist * resolve
curl_fnmatch_callback fnmatch
curl_sshkeycallback ssh_keyfunc
const struct Curl_handler Curl_handler_dict
const struct Curl_handler Curl_handler_tftp
#define CURL_DEFAULT_PASSWORD
static bool SocketIsDead(curl_socket_t sock)
struct curl_slist * quote
size_t Curl_multi_max_total_connections(struct Curl_multi *multi)
UNITTEST_START int result
static void free_fixed_hostname(struct hostname *host)
struct curl_ssl_session * sslsession
#define STARTS_WITH_DRIVE_PREFIX(str)
void Curl_digest_cleanup(struct Curl_easy *data)
static CURLcode parse_proxy_auth(struct Curl_easy *data, struct connectdata *conn)
void Curl_cookie_loadfiles(struct Curl_easy *data)
struct curl_hash * hostcache
static size_t max_pipeline_length(struct Curl_multi *multi)
int(* curl_seek_callback)(void *instream, curl_off_t offset, int origin)
struct Curl_share * share
CURLcode(* doing)(struct connectdata *, bool *done)
struct ssl_config_data ssl
char ip_addr_str[MAX_IPADR_LEN]
void Curl_cookie_clearsess(struct CookieInfo *cookies)
void Curl_strntoupper(char *dest, const char *src, size_t n)
CURLcode Curl_connecthost(struct connectdata *conn, const struct Curl_dns_entry *remotehost)
void Curl_resolver_cancel(struct connectdata *conn)
void Curl_conncache_remove_conn(struct conncache *connc, struct connectdata *conn)
struct DynamicStatic change
CURLcode Curl_SOCKS4(const char *proxy_user, const char *hostname, int remote_port, int sockindex, struct connectdata *conn)
bool Curl_recvpipe_head(struct Curl_easy *data, struct connectdata *conn)
int(* curl_debug_callback)(CURL *handle, curl_infotype type, char *data, size_t size, void *userptr)
void Curl_verboseconnect(struct connectdata *conn)
struct proxy_info http_proxy
struct ssl_primary_config primary
curl_seek_callback seek_func
void Curl_hash_start_iterate(struct curl_hash *hash, struct curl_hash_iterator *iter)
curl_chunk_end_callback chunk_end
unsigned short curlx_ultous(unsigned long ulnum)
unsigned short curlx_sltous(long slnum)
ssl_connection_state state
#define Curl_http2_cleanup_dependencies(x)
bool suppress_connect_headers
curl_sockopt_callback fsockopt
CURLcode Curl_protocol_doing(struct connectdata *conn, bool *done)
int Curl_doing_getsock(struct connectdata *conn, curl_socket_t *socks, int numsocks)
bool Curl_sendpipe_head(struct Curl_easy *data, struct connectdata *conn)
memcpy(filename, filename1, strlen(filename1))
CURLcode Curl_connected_proxy(struct connectdata *conn, int sockindex)
#define CURLAUTH_NEGOTIATE
static CURLcode create_conn_helper_init_proxy(struct connectdata *conn)
ROSCPP_DECL void set(const std::string &key, const XmlRpc::XmlRpcValue &v)
const struct Curl_handler Curl_handler_rtsp
static void conn_free(struct connectdata *conn)
#define CURL_DEFAULT_HTTPS_PROXY_PORT
CURLcode(* connecting)(struct connectdata *, bool *done)
bool http_follow_location
CURLSHcode Curl_share_unlock(struct Curl_easy *data, curl_lock_data type)
curl_ftpfile ftp_filemethod
static CURLcode setup_range(struct Curl_easy *data)
curl_closesocket_callback fclosesocket
static CURLcode parse_connect_to_slist(struct Curl_easy *data, struct connectdata *conn, struct curl_slist *conn_to_host)
void Curl_setup_transfer(struct connectdata *conn, int sockindex, curl_off_t size, bool getheader, curl_off_t *bytecountp, int writesockindex, curl_off_t *writecountp)
static CURLcode parse_connect_to_host_port(struct Curl_easy *data, const char *host, char **hostname_result, int *port_result)
CURLcode(* setup_connection)(struct connectdata *)
static unsigned int get_protocol_family(unsigned int protocol)
time_t Curl_timeleft(struct Curl_easy *data, struct curltime *nowp, bool duringconnect)
static bool proxy_info_matches(const struct proxy_info *data, const struct proxy_info *needle)
struct connectbundle * Curl_conncache_find_bundle(struct connectdata *conn, struct conncache *connc)
curl_easy_setopt expects a curl_off_t argument for this option curl_easy_setopt expects a curl_write_callback argument for this option curl_easy_setopt expects a curl_ioctl_callback argument for this option curl_easy_setopt expects a curl_opensocket_callback argument for this option curl_easy_setopt expects a curl_debug_callback argument for this option curl_easy_setopt expects a curl_conv_callback argument for this option curl_easy_setopt expects a private data pointer as argument for this option curl_easy_setopt expects a FILE *argument for this option curl_easy_setopt expects a struct curl_httppost *argument for this option curl_easy_setopt expects a struct curl_slist *argument for this option curl_easy_getinfo expects a pointer to char *for this info curl_easy_getinfo expects a pointer to double for this info curl_easy_getinfo expects a pointer to struct curl_tlssessioninfo *for this info curl_easy_getinfo expects a pointer to curl_socket_t for this info size_t
#define CURLSSH_AUTH_DEFAULT
struct curl_slist * mail_rcpt
CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data, const char *local_ip6)
static void reuse_conn(struct connectdata *old_conn, struct connectdata *conn)
bool abstract_unix_socket
struct curl_slist * http200aliases
int(* curl_sockopt_callback)(void *clientp, curl_socket_t curlfd, curlsocktype purpose)
CURL_EXTERN struct curl_slist * curl_slist_append(struct curl_slist *, const char *)
#define SOCKET_READABLE(x, z)
void Curl_updateconninfo(struct connectdata *conn, curl_socket_t sockfd)
void Curl_flush_cookies(struct Curl_easy *data, int cleanup)
CURLcode Curl_set_dns_servers(struct Curl_easy *data, char *servers)
curl_socket_t(* curl_opensocket_callback)(void *clientp, curlsocktype purpose, struct curl_sockaddr *address)
bool http_disable_hostname_check_before_authentication
CURLcode(* curl_ssl_ctx_callback)(CURL *curl, void *ssl_ctx, void *userptr)
UNITTEST_START struct Curl_easy data
#define strncasecompare(a, b, c)
struct CookieInfo * cookies
int Curl_safe_strcasecompare(const char *first, const char *second)
static void signalPipeClose(struct curl_llist *pipeline, bool pipe_broke)
bool Curl_clone_primary_ssl_config(struct ssl_primary_config *source, struct ssl_primary_config *dest)
struct http_connect_state * connect_state
void Curl_pipeline_leave_read(struct connectdata *conn)
#define CURLHEADER_SEPARATE
static int IsPipeliningPossible(const struct Curl_easy *handle, const struct connectdata *conn)
curlioerr(* curl_ioctl_callback)(CURL *handle, int cmd, void *clientp)
const struct Curl_handler Curl_handler_imap
char * Curl_dedotdotify(const char *input)
#define BUNDLE_PIPELINING
void Curl_free_primary_ssl_config(struct ssl_primary_config *sslc)
void * closesocket_client
#define PROTOPT_PROXY_AS_HTTP
curl_free_callback freefunc
static void fix_hostname(struct connectdata *conn, struct hostname *host)
int(* doing_getsock)(struct connectdata *conn, curl_socket_t *socks, int numsocks)
CURL_TYPEOF_CURL_OFF_T curl_off_t
struct curltime last_cleanup
struct curl_httppost * httppost
static CURLcode create_conn(struct Curl_easy *data, struct connectdata **in_connect, bool *async)
create_conn() sets up a new connectdata struct, or re-uses an already existing one, and resolves host name.
void Curl_resolv_unlock(struct Curl_easy *data, struct Curl_dns_entry *dns)
struct CookieInfo * cookies
size_t(* curl_read_callback)(char *buffer, size_t size, size_t nitems, void *instream)
void Curl_speedinit(struct Curl_easy *data)
curl_ssl_ctx_callback fsslctx
void Curl_getoff_all_pipelines(struct Curl_easy *data, struct connectdata *conn)
#define CURLPIPE_MULTIPLEX
struct curl_hash hostcache
const struct Curl_handler * given
void Curl_resolver_cleanup(void *resolver)
CURLcode Curl_init_do(struct Curl_easy *data, struct connectdata *conn)
static bool disconnect_if_dead(struct connectdata *conn, struct Curl_easy *data)
#define CURL_DEFAULT_PROXY_PORT
#define C_SSLVERSION_MAX_VALUE(x)
size_t Curl_multi_max_host_connections(struct Curl_multi *multi)
static CURLcode setstropt(char **charp, const char *s)
void Curl_pipeline_leave_write(struct connectdata *conn)
struct proxy_info socks_proxy
#define CURL_DEFAULT_USER
struct curl_slist * cookielist
int Curl_inet_pton(int af, const char *src, void *dst)
struct curl_llist_element * head
CURLcode Curl_init_userdefined(struct UserDefined *set)
curl_conv_callback convfromutf8
static unsigned short port
#define ALL_CONTENT_ENCODINGS
bool Curl_connect_ongoing(struct connectdata *conn)
CURLcode Curl_protocol_connect(struct connectdata *conn, bool *protocol_done)
struct Cookie * Curl_cookie_add(struct Curl_easy *data, struct CookieInfo *c, bool httpheader, char *lineptr, const char *domain, const char *path)
#define Curl_safefree(ptr)
static CURLcode parse_proxy(struct Curl_easy *data, struct connectdata *conn, char *proxy, curl_proxytype proxytype)
curl_ioctl_callback ioctl_func
unsigned support_https_proxy
void * closesocket_client
#define PROTOPT_NONETWORK
#define Curl_http2_add_child(x, y, z)
unsigned short secondary_port
void Curl_llist_remove(struct curl_llist *list, struct curl_llist_element *e, void *user)
#define DEFAULT_CONNCACHE_SIZE
static int call_disconnect_if_dead(struct connectdata *conn, void *param)
CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle, CURL *curl_handle)
const struct Curl_handler Curl_handler_ftp
#define Curl_http2_init_state(x)
int(* curl_progress_callback)(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow)
curl_off_t max_send_speed
#define MAX_CURL_USER_LENGTH
curl_write_callback fwrite_func
ssize_t Curl_send_plain(struct connectdata *conn, int num, const void *mem, size_t len, CURLcode *code)
struct curl_slist * proxyheaders
long(* curl_chunk_end_callback)(void *ptr)
size_t(* curl_write_callback)(char *buffer, size_t size, size_t nitems, void *outstream)
curl_progress_callback fprogress
const struct Curl_handler Curl_handler_file
struct curl_ssl_session * session
void Curl_free_request_state(struct Curl_easy *data)
void Curl_pgrsSetDownloadCounter(struct Curl_easy *data, curl_off_t size)
#define Curl_ssl_set_engine(x, y)
curl_closesocket_callback fclosesocket
void Curl_mime_initpart(curl_mimepart *part, struct Curl_easy *easy)
curl_chunk_bgn_callback chunk_bgn
int(* curl_sshkeycallback)(CURL *easy, const struct curl_khkey *knownkey, const struct curl_khkey *foundkey, enum curl_khmatch, void *clientp)
curl_TimeCond timecondition
curl_read_callback fread_func_set
struct hostname conn_to_host
int Curl_resolv_timeout(struct connectdata *conn, const char *hostname, int port, struct Curl_dns_entry **entry, time_t timeoutms)
void Curl_freeset(struct Curl_easy *data)
struct ssl_primary_config ssl_config
void Curl_persistconninfo(struct connectdata *conn)
static char * detect_proxy(struct connectdata *conn)
curl_off_t max_recv_speed
struct curl_slist * resolve
#define conn_reset_all_postponed_data(c)
CURLcode Curl_dupset(struct Curl_easy *dst, struct Curl_easy *src)
void Curl_llist_destroy(struct curl_llist *list, void *user)
struct connectbundle * bundle
struct connectdata * Curl_oldest_idle_connection(struct Curl_easy *data)
struct ssl_primary_config proxy_ssl_config
#define Curl_tvdiff(x, y)
curl_off_t crlf_conversions
static CURLcode override_login(struct Curl_easy *data, struct connectdata *conn, char **userp, char **passwdp, char **optionsp)
CURLSHcode Curl_share_lock(struct Curl_easy *data, curl_lock_data type, curl_lock_access accesstype)
ssize_t Curl_recv_plain(struct connectdata *conn, int num, char *buf, size_t len, CURLcode *code)
curl_write_callback fwrite_header
static CURLcode setup_connection_internals(struct connectdata *conn)
#define PROTOPT_URLOPTIONS
static CURLcode setstropt_userpwd(char *option, char **userp, char **passwdp)
#define Curl_ssl_cert_status_request()
enum Names::@35 hostcachetype
struct ssl_connect_data proxy_ssl[2]
CURLcode Curl_setopt(struct Curl_easy *data, CURLoption option, va_list param)
#define checkprefix(a, b)
curl_debug_callback fdebug
#define CURLRESOLV_TIMEDOUT
#define CURL_HTTP_VERSION_2
static CURLcode parse_connect_to_string(struct Curl_easy *data, struct connectdata *conn, const char *conn_to_host, char **host_result, int *port_result)
void Curl_cookie_cleanup(struct CookieInfo *c)
struct curl_hash_element * Curl_hash_next_element(struct curl_hash_iterator *iter)
union connectdata::@34 proto
static void prune_dead_connections(struct Curl_easy *data)
curl_seek_callback seek_func
const struct Curl_handler Curl_handler_ldap
#define PROTOPT_CREDSPERREQUEST
#define GOOD_EASY_HANDLE(x)
CURLcode Curl_close(struct Curl_easy *data)
#define Curl_convert_close(x)
struct curl_llist conn_list
const struct Curl_handler Curl_handler_imaps
static CURLcode findprotocol(struct Curl_easy *data, struct connectdata *conn, const char *protostr)
size_t sizeof_ssl_backend_data
unsigned int curlx_sltoui(long slnum)
struct WildcardData wildcard
struct connectdata::dynamically_allocated_data allocptr
static CURLcode parse_url_login(struct Curl_easy *data, struct connectdata *conn, char **userptr, char **passwdptr, char **optionsptr)
const struct Curl_handler Curl_handler_http
static CURLcode parse_login_details(const char *login, const size_t len, char **userptr, char **passwdptr, char **optionsptr)
#define Curl_ssl_free_certinfo(x)
#define Curl_ssl_false_start()
size_t curlx_sotouz(curl_off_t sonum)
CURL_EXTERN char * curl_easy_unescape(CURL *handle, const char *string, int length, int *outlength)
struct ssl_general_config general_ssl
CURLcode Curl_protocol_connecting(struct connectdata *conn, bool *done)
static void llist_dtor(void *user, void *element)
CURL_EXTERN void curl_slist_free_all(struct curl_slist *)
#define Curl_http2_remove_child(x, y)
#define PROTO_FAMILY_HTTP
struct conncache * conn_cache
#define CURLSSLOPT_ALLOW_BEAST
#define Curl_convert_init(x)
long(* curl_chunk_bgn_callback)(const void *transfer_info, void *ptr, int remains)
bool Curl_pipeline_penalized(struct Curl_easy *data, struct connectdata *conn)
enum CURL_NETRC_OPTION use_netrc
CURL_EXTERN int curl_strnequal(const char *s1, const char *s2, size_t n)
#define Curl_resolver_asynch()
const struct Curl_handler Curl_handler_pop3
CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle)
CURLcode Curl_set_dns_interface(struct Curl_easy *data, const char *interf)
static CURLcode parse_remote_port(struct Curl_easy *data, struct connectdata *conn)
void Curl_expire_clear(struct Curl_easy *data)
const struct Curl_handler Curl_handler_pop3s
static bool ConnectionExists(struct Curl_easy *data, struct connectdata *needle, struct connectdata **usethis, bool *force_reuse, bool *waitpipe)
#define calloc(nbelem, size)
curl_conv_callback convfromnetwork
static struct connectdata * find_oldest_idle_connection_in_bundle(struct Curl_easy *data, struct connectbundle *bundle)
bool proxy_connect_closed
#define Curl_ssl_close_all(x)
void Curl_cookie_clearall(struct CookieInfo *cookies)
int ftp_create_missing_dirs
struct curl_llist_element * next
CURL_EXTERN CURLcode curl_mime_subparts(curl_mimepart *part, curl_mime *subparts)
CURLcode Curl_proxy_connect(struct connectdata *conn, int sockindex)