Annotation of embedaddon/curl/lib/urldata.h, revision 1.1.1.1
1.1 misho 1: #ifndef HEADER_CURL_URLDATA_H
2: #define HEADER_CURL_URLDATA_H
3: /***************************************************************************
4: * _ _ ____ _
5: * Project ___| | | | _ \| |
6: * / __| | | | |_) | |
7: * | (__| |_| | _ <| |___
8: * \___|\___/|_| \_\_____|
9: *
10: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
11: *
12: * This software is licensed as described in the file COPYING, which
13: * you should have received as part of this distribution. The terms
14: * are also available at https://curl.haxx.se/docs/copyright.html.
15: *
16: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
17: * copies of the Software, and permit persons to whom the Software is
18: * furnished to do so, under the terms of the COPYING file.
19: *
20: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21: * KIND, either express or implied.
22: *
23: ***************************************************************************/
24:
25: /* This file is for lib internal stuff */
26:
27: #include "curl_setup.h"
28:
29: #define PORT_FTP 21
30: #define PORT_FTPS 990
31: #define PORT_TELNET 23
32: #define PORT_HTTP 80
33: #define PORT_HTTPS 443
34: #define PORT_DICT 2628
35: #define PORT_LDAP 389
36: #define PORT_LDAPS 636
37: #define PORT_TFTP 69
38: #define PORT_SSH 22
39: #define PORT_IMAP 143
40: #define PORT_IMAPS 993
41: #define PORT_POP3 110
42: #define PORT_POP3S 995
43: #define PORT_SMB 445
44: #define PORT_SMBS 445
45: #define PORT_SMTP 25
46: #define PORT_SMTPS 465 /* sometimes called SSMTP */
47: #define PORT_RTSP 554
48: #define PORT_RTMP 1935
49: #define PORT_RTMPT PORT_HTTP
50: #define PORT_RTMPS PORT_HTTPS
51: #define PORT_GOPHER 70
52: #define PORT_MQTT 1883
53:
54: #define DICT_MATCH "/MATCH:"
55: #define DICT_MATCH2 "/M:"
56: #define DICT_MATCH3 "/FIND:"
57: #define DICT_DEFINE "/DEFINE:"
58: #define DICT_DEFINE2 "/D:"
59: #define DICT_DEFINE3 "/LOOKUP:"
60:
61: #define CURL_DEFAULT_USER "anonymous"
62: #define CURL_DEFAULT_PASSWORD "ftp@example.com"
63:
64: /* Convenience defines for checking protocols or their SSL based version. Each
65: protocol handler should only ever have a single CURLPROTO_ in its protocol
66: field. */
67: #define PROTO_FAMILY_HTTP (CURLPROTO_HTTP|CURLPROTO_HTTPS)
68: #define PROTO_FAMILY_FTP (CURLPROTO_FTP|CURLPROTO_FTPS)
69: #define PROTO_FAMILY_POP3 (CURLPROTO_POP3|CURLPROTO_POP3S)
70: #define PROTO_FAMILY_SMB (CURLPROTO_SMB|CURLPROTO_SMBS)
71: #define PROTO_FAMILY_SMTP (CURLPROTO_SMTP|CURLPROTO_SMTPS)
72: #define PROTO_FAMILY_SSH (CURLPROTO_SCP|CURLPROTO_SFTP)
73:
74: #define DEFAULT_CONNCACHE_SIZE 5
75:
76: /* length of longest IPv6 address string including the trailing null */
77: #define MAX_IPADR_LEN sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")
78:
79: /* Default FTP/IMAP etc response timeout in milliseconds.
80: Symbian OS panics when given a timeout much greater than 1/2 hour.
81: */
82: #define RESP_TIMEOUT (120*1000)
83:
84: /* Max string intput length is a precaution against abuse and to detect junk
85: input easier and better. */
86: #define CURL_MAX_INPUT_LENGTH 8000000
87:
88: #include "cookie.h"
89: #include "psl.h"
90: #include "formdata.h"
91:
92: #ifdef HAVE_NETINET_IN_H
93: #include <netinet/in.h>
94: #endif
95: #ifdef HAVE_NETINET_IN6_H
96: #include <netinet/in6.h>
97: #endif
98:
99: #include "timeval.h"
100:
101: #include <curl/curl.h>
102:
103: #include "http_chunks.h" /* for the structs and enum stuff */
104: #include "hostip.h"
105: #include "hash.h"
106: #include "splay.h"
107:
108: /* return the count of bytes sent, or -1 on error */
109: typedef ssize_t (Curl_send)(struct connectdata *conn, /* connection data */
110: int sockindex, /* socketindex */
111: const void *buf, /* data to write */
112: size_t len, /* max amount to write */
113: CURLcode *err); /* error to return */
114:
115: /* return the count of bytes read, or -1 on error */
116: typedef ssize_t (Curl_recv)(struct connectdata *conn, /* connection data */
117: int sockindex, /* socketindex */
118: char *buf, /* store data here */
119: size_t len, /* max amount to read */
120: CURLcode *err); /* error to return */
121:
122: #include "mime.h"
123: #include "imap.h"
124: #include "pop3.h"
125: #include "smtp.h"
126: #include "ftp.h"
127: #include "file.h"
128: #include "vssh/ssh.h"
129: #include "http.h"
130: #include "rtsp.h"
131: #include "smb.h"
132: #include "mqtt.h"
133: #include "wildcard.h"
134: #include "multihandle.h"
135: #include "quic.h"
136:
137: #ifdef HAVE_GSSAPI
138: # ifdef HAVE_GSSGNU
139: # include <gss.h>
140: # elif defined HAVE_GSSAPI_GSSAPI_H
141: # include <gssapi/gssapi.h>
142: # else
143: # include <gssapi.h>
144: # endif
145: # ifdef HAVE_GSSAPI_GSSAPI_GENERIC_H
146: # include <gssapi/gssapi_generic.h>
147: # endif
148: #endif
149:
150: #ifdef HAVE_LIBSSH2_H
151: #include <libssh2.h>
152: #include <libssh2_sftp.h>
153: #endif /* HAVE_LIBSSH2_H */
154:
155: /* Initial size of the buffer to store headers in, it'll be enlarged in case
156: of need. */
157: #define HEADERSIZE 256
158:
159: #define CURLEASY_MAGIC_NUMBER 0xc0dedbadU
160: #define GOOD_EASY_HANDLE(x) \
161: ((x) && ((x)->magic == CURLEASY_MAGIC_NUMBER))
162:
163: /* the type we use for storing a single boolean bit */
164: #ifdef _MSC_VER
165: typedef bool bit;
166: #define BIT(x) bool x
167: #else
168: typedef unsigned int bit;
169: #define BIT(x) bit x:1
170: #endif
171:
172: #ifdef HAVE_GSSAPI
173: /* Types needed for krb5-ftp connections */
174: struct krb5buffer {
175: void *data;
176: size_t size;
177: size_t index;
178: BIT(eof_flag);
179: };
180:
181: enum protection_level {
182: PROT_NONE, /* first in list */
183: PROT_CLEAR,
184: PROT_SAFE,
185: PROT_CONFIDENTIAL,
186: PROT_PRIVATE,
187: PROT_CMD,
188: PROT_LAST /* last in list */
189: };
190: #endif
191:
192: /* enum for the nonblocking SSL connection state machine */
193: typedef enum {
194: ssl_connect_1,
195: ssl_connect_2,
196: ssl_connect_2_reading,
197: ssl_connect_2_writing,
198: ssl_connect_3,
199: ssl_connect_done
200: } ssl_connect_state;
201:
202: typedef enum {
203: ssl_connection_none,
204: ssl_connection_negotiating,
205: ssl_connection_complete
206: } ssl_connection_state;
207:
208: /* SSL backend-specific data; declared differently by each SSL backend */
209: struct ssl_backend_data;
210:
211: /* struct for data related to each SSL connection */
212: struct ssl_connect_data {
213: /* Use ssl encrypted communications TRUE/FALSE, not necessarily using it atm
214: but at least asked to or meaning to use it. See 'state' for the exact
215: current state of the connection. */
216: ssl_connection_state state;
217: ssl_connect_state connecting_state;
218: #if defined(USE_SSL)
219: struct ssl_backend_data *backend;
220: #endif
221: BIT(use);
222: };
223:
224: struct ssl_primary_config {
225: long version; /* what version the client wants to use */
226: long version_max; /* max supported version the client wants to use*/
227: char *CApath; /* certificate dir (doesn't work on windows) */
228: char *CAfile; /* certificate to verify peer against */
229: char *clientcert;
230: char *random_file; /* path to file containing "random" data */
231: char *egdsocket; /* path to file containing the EGD daemon socket */
232: char *cipher_list; /* list of ciphers to use */
233: char *cipher_list13; /* list of TLS 1.3 cipher suites to use */
234: char *pinned_key;
235: BIT(verifypeer); /* set TRUE if this is desired */
236: BIT(verifyhost); /* set TRUE if CN/SAN must match hostname */
237: BIT(verifystatus); /* set TRUE if certificate status must be checked */
238: BIT(sessionid); /* cache session IDs or not */
239: };
240:
241: struct ssl_config_data {
242: struct ssl_primary_config primary;
243: long certverifyresult; /* result from the certificate verification */
244: char *CRLfile; /* CRL to check certificate revocation */
245: char *issuercert;/* optional issuer certificate filename */
246: curl_ssl_ctx_callback fsslctx; /* function to initialize ssl ctx */
247: void *fsslctxp; /* parameter for call back */
248: char *cert; /* client certificate file name */
249: char *cert_type; /* format for certificate (default: PEM)*/
250: char *key; /* private key file name */
251: char *key_type; /* format for private key (default: PEM) */
252: char *key_passwd; /* plain text private key password */
253: #ifdef USE_TLS_SRP
254: char *username; /* TLS username (for, e.g., SRP) */
255: char *password; /* TLS password (for, e.g., SRP) */
256: enum CURL_TLSAUTH authtype; /* TLS authentication type (default SRP) */
257: #endif
258: BIT(certinfo); /* gather lots of certificate info */
259: BIT(falsestart);
260: BIT(enable_beast); /* allow this flaw for interoperability's sake*/
261: BIT(no_revoke); /* disable SSL certificate revocation checks */
262: BIT(no_partialchain); /* don't accept partial certificate chains */
263: BIT(revoke_best_effort); /* ignore SSL revocation offline/missing revocation
264: list errors */
265: };
266:
267: struct ssl_general_config {
268: size_t max_ssl_sessions; /* SSL session id cache size */
269: };
270:
271: /* information stored about one single SSL session */
272: struct curl_ssl_session {
273: char *name; /* host name for which this ID was used */
274: char *conn_to_host; /* host name for the connection (may be NULL) */
275: const char *scheme; /* protocol scheme used */
276: void *sessionid; /* as returned from the SSL layer */
277: size_t idsize; /* if known, otherwise 0 */
278: long age; /* just a number, the higher the more recent */
279: int remote_port; /* remote port */
280: int conn_to_port; /* remote port for the connection (may be -1) */
281: struct ssl_primary_config ssl_config; /* setup for this session */
282: };
283:
284: #ifdef USE_WINDOWS_SSPI
285: #include "curl_sspi.h"
286: #endif
287:
288: /* Struct used for Digest challenge-response authentication */
289: struct digestdata {
290: #if defined(USE_WINDOWS_SSPI)
291: BYTE *input_token;
292: size_t input_token_len;
293: CtxtHandle *http_context;
294: /* copy of user/passwd used to make the identity for http_context.
295: either may be NULL. */
296: char *user;
297: char *passwd;
298: #else
299: char *nonce;
300: char *cnonce;
301: char *realm;
302: int algo;
303: char *opaque;
304: char *qop;
305: char *algorithm;
306: int nc; /* nounce count */
307: BIT(stale); /* set true for re-negotiation */
308: BIT(userhash);
309: #endif
310: };
311:
312: typedef enum {
313: NTLMSTATE_NONE,
314: NTLMSTATE_TYPE1,
315: NTLMSTATE_TYPE2,
316: NTLMSTATE_TYPE3,
317: NTLMSTATE_LAST
318: } curlntlm;
319:
320: typedef enum {
321: GSS_AUTHNONE,
322: GSS_AUTHRECV,
323: GSS_AUTHSENT,
324: GSS_AUTHDONE,
325: GSS_AUTHSUCC
326: } curlnegotiate;
327:
328: #if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV)
329: #include <iconv.h>
330: #endif
331:
332: /* Struct used for GSSAPI (Kerberos V5) authentication */
333: #if defined(USE_KERBEROS5)
334: struct kerberos5data {
335: #if defined(USE_WINDOWS_SSPI)
336: CredHandle *credentials;
337: CtxtHandle *context;
338: TCHAR *spn;
339: SEC_WINNT_AUTH_IDENTITY identity;
340: SEC_WINNT_AUTH_IDENTITY *p_identity;
341: size_t token_max;
342: BYTE *output_token;
343: #else
344: gss_ctx_id_t context;
345: gss_name_t spn;
346: #endif
347: };
348: #endif
349:
350: /* Struct used for NTLM challenge-response authentication */
351: #if defined(USE_NTLM)
352: struct ntlmdata {
353: #ifdef USE_WINDOWS_SSPI
354: /* The sslContext is used for the Schannel bindings. The
355: * api is available on the Windows 7 SDK and later.
356: */
357: #ifdef SECPKG_ATTR_ENDPOINT_BINDINGS
358: CtxtHandle *sslContext;
359: #endif
360: CredHandle *credentials;
361: CtxtHandle *context;
362: SEC_WINNT_AUTH_IDENTITY identity;
363: SEC_WINNT_AUTH_IDENTITY *p_identity;
364: size_t token_max;
365: BYTE *output_token;
366: BYTE *input_token;
367: size_t input_token_len;
368: TCHAR *spn;
369: #else
370: unsigned int flags;
371: unsigned char nonce[8];
372: void *target_info; /* TargetInfo received in the ntlm type-2 message */
373: unsigned int target_info_len;
374:
375: #if defined(NTLM_WB_ENABLED)
376: /* used for communication with Samba's winbind daemon helper ntlm_auth */
377: curl_socket_t ntlm_auth_hlpr_socket;
378: pid_t ntlm_auth_hlpr_pid;
379: char *challenge; /* The received base64 encoded ntlm type-2 message */
380: char *response; /* The generated base64 ntlm type-1/type-3 message */
381: #endif
382: #endif
383: };
384: #endif
385:
386: /* Struct used for Negotiate (SPNEGO) authentication */
387: #ifdef USE_SPNEGO
388: struct negotiatedata {
389: #ifdef HAVE_GSSAPI
390: OM_uint32 status;
391: gss_ctx_id_t context;
392: gss_name_t spn;
393: gss_buffer_desc output_token;
394: #else
395: #ifdef USE_WINDOWS_SSPI
396: #ifdef SECPKG_ATTR_ENDPOINT_BINDINGS
397: CtxtHandle *sslContext;
398: #endif
399: DWORD status;
400: CredHandle *credentials;
401: CtxtHandle *context;
402: SEC_WINNT_AUTH_IDENTITY identity;
403: SEC_WINNT_AUTH_IDENTITY *p_identity;
404: TCHAR *spn;
405: size_t token_max;
406: BYTE *output_token;
407: size_t output_token_length;
408: #endif
409: #endif
410: BIT(noauthpersist);
411: BIT(havenoauthpersist);
412: BIT(havenegdata);
413: BIT(havemultiplerequests);
414: };
415: #endif
416:
417:
418: /*
419: * Boolean values that concerns this connection.
420: */
421: struct ConnectBits {
422: /* always modify bits.close with the connclose() and connkeep() macros! */
423: bool proxy_ssl_connected[2]; /* TRUE when SSL initialization for HTTPS proxy
424: is complete */
425: bool tcpconnect[2]; /* the TCP layer (or similar) is connected, this is set
426: the first time on the first connect function call */
427: BIT(close); /* if set, we close the connection after this request */
428: BIT(reuse); /* if set, this is a re-used connection */
429: BIT(altused); /* this is an alt-svc "redirect" */
430: BIT(conn_to_host); /* if set, this connection has a "connect to host"
431: that overrides the host in the URL */
432: BIT(conn_to_port); /* if set, this connection has a "connect to port"
433: that overrides the port in the URL (remote port) */
434: BIT(proxy); /* if set, this transfer is done through a proxy - any type */
435: BIT(httpproxy); /* if set, this transfer is done through a http proxy */
436: BIT(socksproxy); /* if set, this transfer is done through a socks proxy */
437: BIT(user_passwd); /* do we use user+password for this connection? */
438: BIT(proxy_user_passwd); /* user+password for the proxy? */
439: BIT(ipv6_ip); /* we communicate with a remote site specified with pure IPv6
440: IP address */
441: BIT(ipv6); /* we communicate with a site using an IPv6 address */
442: BIT(do_more); /* this is set TRUE if the ->curl_do_more() function is
443: supposed to be called, after ->curl_do() */
444: BIT(protoconnstart);/* the protocol layer has STARTED its operation after
445: the TCP layer connect */
446: BIT(retry); /* this connection is about to get closed and then
447: re-attempted at another connection. */
448: BIT(tunnel_proxy); /* if CONNECT is used to "tunnel" through the proxy.
449: This is implicit when SSL-protocols are used through
450: proxies, but can also be enabled explicitly by
451: apps */
452: BIT(authneg); /* TRUE when the auth phase has started, which means
453: that we are creating a request with an auth header,
454: but it is not the final request in the auth
455: negotiation. */
456: BIT(rewindaftersend);/* TRUE when the sending couldn't be stopped even
457: though it will be discarded. When the whole send
458: operation is done, we must call the data rewind
459: callback. */
460: #ifndef CURL_DISABLE_FTP
461: BIT(ftp_use_epsv); /* As set with CURLOPT_FTP_USE_EPSV, but if we find out
462: EPSV doesn't work we disable it for the forthcoming
463: requests */
464: BIT(ftp_use_eprt); /* As set with CURLOPT_FTP_USE_EPRT, but if we find out
465: EPRT doesn't work we disable it for the forthcoming
466: requests */
467: BIT(ftp_use_data_ssl); /* Enabled SSL for the data connection */
468: #endif
469: BIT(netrc); /* name+password provided by netrc */
470: BIT(userpwd_in_url); /* name+password found in url */
471: BIT(proxy_connect_closed); /* TRUE if a proxy disconnected the connection
472: in a CONNECT request with auth, so that
473: libcurl should reconnect and continue. */
474: BIT(bound); /* set true if bind() has already been done on this socket/
475: connection */
476: BIT(type_set); /* type= was used in the URL */
477: BIT(multiplex); /* connection is multiplexed */
478: BIT(tcp_fastopen); /* use TCP Fast Open */
479: BIT(tls_enable_npn); /* TLS NPN extension? */
480: BIT(tls_enable_alpn); /* TLS ALPN extension? */
481: BIT(connect_only);
482: };
483:
484: struct hostname {
485: char *rawalloc; /* allocated "raw" version of the name */
486: char *encalloc; /* allocated IDN-encoded version of the name */
487: char *name; /* name to use internally, might be encoded, might be raw */
488: const char *dispname; /* name to display, as 'name' might be encoded */
489: };
490:
491: /*
492: * Flags on the keepon member of the Curl_transfer_keeper
493: */
494:
495: #define KEEP_NONE 0
496: #define KEEP_RECV (1<<0) /* there is or may be data to read */
497: #define KEEP_SEND (1<<1) /* there is or may be data to write */
498: #define KEEP_RECV_HOLD (1<<2) /* when set, no reading should be done but there
499: might still be data to read */
500: #define KEEP_SEND_HOLD (1<<3) /* when set, no writing should be done but there
501: might still be data to write */
502: #define KEEP_RECV_PAUSE (1<<4) /* reading is paused */
503: #define KEEP_SEND_PAUSE (1<<5) /* writing is paused */
504:
505: #define KEEP_RECVBITS (KEEP_RECV | KEEP_RECV_HOLD | KEEP_RECV_PAUSE)
506: #define KEEP_SENDBITS (KEEP_SEND | KEEP_SEND_HOLD | KEEP_SEND_PAUSE)
507:
508: struct Curl_async {
509: char *hostname;
510: int port;
511: struct Curl_dns_entry *dns;
512: int status; /* if done is TRUE, this is the status from the callback */
513: void *os_specific; /* 'struct thread_data' for Windows */
514: BIT(done); /* set TRUE when the lookup is complete */
515: };
516:
517: #define FIRSTSOCKET 0
518: #define SECONDARYSOCKET 1
519:
520: /* These function pointer types are here only to allow easier typecasting
521: within the source when we need to cast between data pointers (such as NULL)
522: and function pointers. */
523: typedef CURLcode (*Curl_do_more_func)(struct connectdata *, int *);
524: typedef CURLcode (*Curl_done_func)(struct connectdata *, CURLcode, bool);
525:
526: enum expect100 {
527: EXP100_SEND_DATA, /* enough waiting, just send the body now */
528: EXP100_AWAITING_CONTINUE, /* waiting for the 100 Continue header */
529: EXP100_SENDING_REQUEST, /* still sending the request but will wait for
530: the 100 header once done with the request */
531: EXP100_FAILED /* used on 417 Expectation Failed */
532: };
533:
534: enum upgrade101 {
535: UPGR101_INIT, /* default state */
536: UPGR101_REQUESTED, /* upgrade requested */
537: UPGR101_RECEIVED, /* response received */
538: UPGR101_WORKING /* talking upgraded protocol */
539: };
540:
541: enum doh_slots {
542: /* Explicit values for first two symbols so as to match hard-coded
543: * constants in existing code
544: */
545: DOH_PROBE_SLOT_IPADDR_V4 = 0, /* make 'V4' stand out for readability */
546: DOH_PROBE_SLOT_IPADDR_V6 = 1, /* 'V6' likewise */
547:
548: /* Space here for (possibly build-specific) additional slot definitions */
549:
550: /* for example */
551: /* #ifdef WANT_DOH_FOOBAR_TXT */
552: /* DOH_PROBE_SLOT_FOOBAR_TXT, */
553: /* #endif */
554:
555: /* AFTER all slot definitions, establish how many we have */
556: DOH_PROBE_SLOTS
557: };
558:
559: struct dohresponse {
560: unsigned char *memory;
561: size_t size;
562: };
563:
564: /* one of these for each DoH request */
565: struct dnsprobe {
566: CURL *easy;
567: int dnstype;
568: unsigned char dohbuffer[512];
569: size_t dohlen;
570: struct dohresponse serverdoh;
571: };
572:
573: struct dohdata {
574: struct curl_slist *headers;
575: struct dnsprobe probe[DOH_PROBE_SLOTS];
576: unsigned int pending; /* still outstanding requests */
577: const char *host;
578: int port;
579: };
580:
581: /*
582: * Request specific data in the easy handle (Curl_easy). Previously,
583: * these members were on the connectdata struct but since a conn struct may
584: * now be shared between different Curl_easys, we store connection-specific
585: * data here. This struct only keeps stuff that's interesting for *this*
586: * request, as it will be cleared between multiple ones
587: */
588: struct SingleRequest {
589: curl_off_t size; /* -1 if unknown at this point */
590: curl_off_t maxdownload; /* in bytes, the maximum amount of data to fetch,
591: -1 means unlimited */
592: curl_off_t bytecount; /* total number of bytes read */
593: curl_off_t writebytecount; /* number of bytes written */
594:
595: curl_off_t headerbytecount; /* only count received headers */
596: curl_off_t deductheadercount; /* this amount of bytes doesn't count when we
597: check if anything has been transferred at
598: the end of a connection. We use this
599: counter to make only a 100 reply (without a
600: following second response code) result in a
601: CURLE_GOT_NOTHING error code */
602:
603: struct curltime start; /* transfer started at this time */
604: struct curltime now; /* current time */
605: enum {
606: HEADER_NORMAL, /* no bad header at all */
607: HEADER_PARTHEADER, /* part of the chunk is a bad header, the rest
608: is normal data */
609: HEADER_ALLBAD /* all was believed to be header */
610: } badheader; /* the header was deemed bad and will be
611: written as body */
612: int headerline; /* counts header lines to better track the
613: first one */
614: char *hbufp; /* points at *end* of header line */
615: size_t hbuflen;
616: char *str; /* within buf */
617: char *str_start; /* within buf */
618: char *end_ptr; /* within buf */
619: char *p; /* within headerbuff */
620: curl_off_t offset; /* possible resume offset read from the
621: Content-Range: header */
622: int httpcode; /* error code from the 'HTTP/1.? XXX' or
623: 'RTSP/1.? XXX' line */
624: struct curltime start100; /* time stamp to wait for the 100 code from */
625: enum expect100 exp100; /* expect 100 continue state */
626: enum upgrade101 upgr101; /* 101 upgrade state */
627:
628: struct contenc_writer_s *writer_stack; /* Content unencoding stack. */
629: /* See sec 3.5, RFC2616. */
630: time_t timeofdoc;
631: long bodywrites;
632: char *buf;
633: int keepon;
634: char *location; /* This points to an allocated version of the Location:
635: header data */
636: char *newurl; /* Set to the new URL to use when a redirect or a retry is
637: wanted */
638:
639: /* 'upload_present' is used to keep a byte counter of how much data there is
640: still left in the buffer, aimed for upload. */
641: ssize_t upload_present;
642:
643: /* 'upload_fromhere' is used as a read-pointer when we uploaded parts of a
644: buffer, so the next read should read from where this pointer points to,
645: and the 'upload_present' contains the number of bytes available at this
646: position */
647: char *upload_fromhere;
648: void *protop; /* Allocated protocol-specific data. Each protocol
649: handler makes sure this points to data it needs. */
650: #ifndef CURL_DISABLE_DOH
651: struct dohdata doh; /* DoH specific data for this request */
652: #endif
653: BIT(header); /* incoming data has HTTP header */
654: BIT(content_range); /* set TRUE if Content-Range: was found */
655: BIT(upload_done); /* set to TRUE when doing chunked transfer-encoding
656: upload and we're uploading the last chunk */
657: BIT(ignorebody); /* we read a response-body but we ignore it! */
658: BIT(http_bodyless); /* HTTP response status code is between 100 and 199,
659: 204 or 304 */
660: BIT(chunk); /* if set, this is a chunked transfer-encoding */
661: BIT(upload_chunky); /* set TRUE if we are doing chunked transfer-encoding
662: on upload */
663: BIT(getheader); /* TRUE if header parsing is wanted */
664: BIT(forbidchunk); /* used only to explicitly forbid chunk-upload for
665: specific upload buffers. See readmoredata() in http.c
666: for details. */
667: };
668:
669: /*
670: * Specific protocol handler.
671: */
672:
673: struct Curl_handler {
674: const char *scheme; /* URL scheme name. */
675:
676: /* Complement to setup_connection_internals(). */
677: CURLcode (*setup_connection)(struct connectdata *);
678:
679: /* These two functions MUST be set to be protocol dependent */
680: CURLcode (*do_it)(struct connectdata *, bool *done);
681: Curl_done_func done;
682:
683: /* If the curl_do() function is better made in two halves, this
684: * curl_do_more() function will be called afterwards, if set. For example
685: * for doing the FTP stuff after the PASV/PORT command.
686: */
687: Curl_do_more_func do_more;
688:
689: /* This function *MAY* be set to a protocol-dependent function that is run
690: * after the connect() and everything is done, as a step in the connection.
691: * The 'done' pointer points to a bool that should be set to TRUE if the
692: * function completes before return. If it doesn't complete, the caller
693: * should call the curl_connecting() function until it is.
694: */
695: CURLcode (*connect_it)(struct connectdata *, bool *done);
696:
697: /* See above. */
698: CURLcode (*connecting)(struct connectdata *, bool *done);
699: CURLcode (*doing)(struct connectdata *, bool *done);
700:
701: /* Called from the multi interface during the PROTOCONNECT phase, and it
702: should then return a proper fd set */
703: int (*proto_getsock)(struct connectdata *conn,
704: curl_socket_t *socks);
705:
706: /* Called from the multi interface during the DOING phase, and it should
707: then return a proper fd set */
708: int (*doing_getsock)(struct connectdata *conn,
709: curl_socket_t *socks);
710:
711: /* Called from the multi interface during the DO_MORE phase, and it should
712: then return a proper fd set */
713: int (*domore_getsock)(struct connectdata *conn,
714: curl_socket_t *socks);
715:
716: /* Called from the multi interface during the DO_DONE, PERFORM and
717: WAITPERFORM phases, and it should then return a proper fd set. Not setting
718: this will make libcurl use the generic default one. */
719: int (*perform_getsock)(const struct connectdata *conn,
720: curl_socket_t *socks);
721:
722: /* This function *MAY* be set to a protocol-dependent function that is run
723: * by the curl_disconnect(), as a step in the disconnection. If the handler
724: * is called because the connection has been considered dead, dead_connection
725: * is set to TRUE.
726: */
727: CURLcode (*disconnect)(struct connectdata *, bool dead_connection);
728:
729: /* If used, this function gets called from transfer.c:readwrite_data() to
730: allow the protocol to do extra reads/writes */
731: CURLcode (*readwrite)(struct Curl_easy *data, struct connectdata *conn,
732: ssize_t *nread, bool *readmore);
733:
734: /* This function can perform various checks on the connection. See
735: CONNCHECK_* for more information about the checks that can be performed,
736: and CONNRESULT_* for the results that can be returned. */
737: unsigned int (*connection_check)(struct connectdata *conn,
738: unsigned int checks_to_perform);
739:
740: long defport; /* Default port. */
741: unsigned int protocol; /* See CURLPROTO_* - this needs to be the single
742: specific protocol bit */
743: unsigned int flags; /* Extra particular characteristics, see PROTOPT_* */
744: };
745:
746: #define PROTOPT_NONE 0 /* nothing extra */
747: #define PROTOPT_SSL (1<<0) /* uses SSL */
748: #define PROTOPT_DUAL (1<<1) /* this protocol uses two connections */
749: #define PROTOPT_CLOSEACTION (1<<2) /* need action before socket close */
750: /* some protocols will have to call the underlying functions without regard to
751: what exact state the socket signals. IE even if the socket says "readable",
752: the send function might need to be called while uploading, or vice versa.
753: */
754: #define PROTOPT_DIRLOCK (1<<3)
755: #define PROTOPT_NONETWORK (1<<4) /* protocol doesn't use the network! */
756: #define PROTOPT_NEEDSPWD (1<<5) /* needs a password, and if none is set it
757: gets a default */
758: #define PROTOPT_NOURLQUERY (1<<6) /* protocol can't handle
759: url query strings (?foo=bar) ! */
760: #define PROTOPT_CREDSPERREQUEST (1<<7) /* requires login credentials per
761: request instead of per connection */
762: #define PROTOPT_ALPN_NPN (1<<8) /* set ALPN and/or NPN for this */
763: #define PROTOPT_STREAM (1<<9) /* a protocol with individual logical streams */
764: #define PROTOPT_URLOPTIONS (1<<10) /* allow options part in the userinfo field
765: of the URL */
766: #define PROTOPT_PROXY_AS_HTTP (1<<11) /* allow this non-HTTP scheme over a
767: HTTP proxy as HTTP proxies may know
768: this protocol and act as a gateway */
769: #define PROTOPT_WILDCARD (1<<12) /* protocol supports wildcard matching */
770:
771: #define CONNCHECK_NONE 0 /* No checks */
772: #define CONNCHECK_ISDEAD (1<<0) /* Check if the connection is dead. */
773: #define CONNCHECK_KEEPALIVE (1<<1) /* Perform any keepalive function. */
774:
775: #define CONNRESULT_NONE 0 /* No extra information. */
776: #define CONNRESULT_DEAD (1<<0) /* The connection is dead. */
777:
778: #ifdef USE_RECV_BEFORE_SEND_WORKAROUND
779: struct postponed_data {
780: char *buffer; /* Temporal store for received data during
781: sending, must be freed */
782: size_t allocated_size; /* Size of temporal store */
783: size_t recv_size; /* Size of received data during sending */
784: size_t recv_processed; /* Size of processed part of postponed data */
785: #ifdef DEBUGBUILD
786: curl_socket_t bindsock;/* Structure must be bound to specific socket,
787: used only for DEBUGASSERT */
788: #endif /* DEBUGBUILD */
789: };
790: #endif /* USE_RECV_BEFORE_SEND_WORKAROUND */
791:
792: struct proxy_info {
793: struct hostname host;
794: long port;
795: curl_proxytype proxytype; /* what kind of proxy that is in use */
796: char *user; /* proxy user name string, allocated */
797: char *passwd; /* proxy password string, allocated */
798: };
799:
800: #define CONNECT_BUFFER_SIZE 16384
801:
802: /* struct for HTTP CONNECT state data */
803: struct http_connect_state {
804: char connect_buffer[CONNECT_BUFFER_SIZE];
805: int perline; /* count bytes per line */
806: int keepon;
807: char *line_start;
808: char *ptr; /* where to store more data */
809: curl_off_t cl; /* size of content to read and ignore */
810: enum {
811: TUNNEL_INIT, /* init/default/no tunnel state */
812: TUNNEL_CONNECT, /* CONNECT has been sent off */
813: TUNNEL_COMPLETE /* CONNECT response received completely */
814: } tunnel_state;
815: BIT(chunked_encoding);
816: BIT(close_connection);
817: };
818:
819: struct ldapconninfo;
820:
821: /* for the (SOCKS) connect state machine */
822: enum connect_t {
823: CONNECT_INIT,
824: CONNECT_SOCKS_INIT, /* 1 */
825: CONNECT_SOCKS_SEND, /* 2 waiting to send more first data */
826: CONNECT_SOCKS_READ_INIT, /* 3 set up read */
827: CONNECT_SOCKS_READ, /* 4 read server response */
828: CONNECT_GSSAPI_INIT, /* 5 */
829: CONNECT_AUTH_INIT, /* 6 setup outgoing auth buffer */
830: CONNECT_AUTH_SEND, /* 7 send auth */
831: CONNECT_AUTH_READ, /* 8 read auth response */
832: CONNECT_REQ_INIT, /* 9 init SOCKS "request" */
833: CONNECT_RESOLVING, /* 10 */
834: CONNECT_RESOLVED, /* 11 */
835: CONNECT_RESOLVE_REMOTE, /* 12 */
836: CONNECT_REQ_SEND, /* 13 */
837: CONNECT_REQ_SENDING, /* 14 */
838: CONNECT_REQ_READ, /* 15 */
839: CONNECT_REQ_READ_MORE, /* 16 */
840: CONNECT_DONE /* 17 connected fine to the remote or the SOCKS proxy */
841: };
842:
843: #define SOCKS_STATE(x) (((x) >= CONNECT_SOCKS_INIT) && \
844: ((x) < CONNECT_DONE))
845: #define SOCKS_REQUEST_BUFSIZE 600 /* room for large user/pw (255 max each) */
846:
847: struct connstate {
848: enum connect_t state;
849: unsigned char socksreq[SOCKS_REQUEST_BUFSIZE];
850:
851: /* CONNECT_SOCKS_SEND */
852: ssize_t outstanding; /* send this many bytes more */
853: unsigned char *outp; /* send from this pointer */
854: };
855:
856: /*
857: * The connectdata struct contains all fields and variables that should be
858: * unique for an entire connection.
859: */
860: struct connectdata {
861: /* 'data' is the CURRENT Curl_easy using this connection -- take great
862: caution that this might very well vary between different times this
863: connection is used! */
864: struct Curl_easy *data;
865: struct connstate cnnct;
866: struct curl_llist_element bundle_node; /* conncache */
867:
868: /* chunk is for HTTP chunked encoding, but is in the general connectdata
869: struct only because we can do just about any protocol through a HTTP proxy
870: and a HTTP proxy may in fact respond using chunked encoding */
871: struct Curl_chunker chunk;
872:
873: curl_closesocket_callback fclosesocket; /* function closing the socket(s) */
874: void *closesocket_client;
875:
876: /* This is used by the connection cache logic. If this returns TRUE, this
877: handle is still used by one or more easy handles and can only used by any
878: other easy handle without careful consideration (== only for
879: multiplexing) and it cannot be used by another multi handle! */
880: #define CONN_INUSE(c) ((c)->easyq.size)
881:
882: /**** Fields set when inited and not modified again */
883: long connection_id; /* Contains a unique number to make it easier to
884: track the connections in the log output */
885:
886: /* 'dns_entry' is the particular host we use. This points to an entry in the
887: DNS cache and it will not get pruned while locked. It gets unlocked in
888: Curl_done(). This entry will be NULL if the connection is re-used as then
889: there is no name resolve done. */
890: struct Curl_dns_entry *dns_entry;
891:
892: /* 'ip_addr' is the particular IP we connected to. It points to a struct
893: within the DNS cache, so this pointer is only valid as long as the DNS
894: cache entry remains locked. It gets unlocked in Curl_done() */
895: Curl_addrinfo *ip_addr;
896: Curl_addrinfo *tempaddr[2]; /* for happy eyeballs */
897:
898: /* 'ip_addr_str' is the ip_addr data as a human readable string.
899: It remains available as long as the connection does, which is longer than
900: the ip_addr itself. */
901: char ip_addr_str[MAX_IPADR_LEN];
902:
903: unsigned int scope_id; /* Scope id for IPv6 */
904:
905: enum {
906: TRNSPRT_TCP = 3,
907: TRNSPRT_UDP = 4,
908: TRNSPRT_QUIC = 5
909: } transport;
910:
911: #ifdef ENABLE_QUIC
912: struct quicsocket hequic[2]; /* two, for happy eyeballs! */
913: struct quicsocket *quic;
914: #endif
915:
916: struct hostname host;
917: char *hostname_resolve; /* host name to resolve to address, allocated */
918: char *secondaryhostname; /* secondary socket host name (ftp) */
919: struct hostname conn_to_host; /* the host to connect to. valid only if
920: bits.conn_to_host is set */
921:
922: struct proxy_info socks_proxy;
923: struct proxy_info http_proxy;
924:
925: long port; /* which port to use locally */
926: int remote_port; /* the remote port, not the proxy port! */
927: int conn_to_port; /* the remote port to connect to. valid only if
928: bits.conn_to_port is set */
929: unsigned short secondary_port; /* secondary socket remote port to connect to
930: (ftp) */
931:
932: /* 'primary_ip' and 'primary_port' get filled with peer's numerical
933: ip address and port number whenever an outgoing connection is
934: *attempted* from the primary socket to a remote address. When more
935: than one address is tried for a connection these will hold data
936: for the last attempt. When the connection is actually established
937: these are updated with data which comes directly from the socket. */
938:
939: char primary_ip[MAX_IPADR_LEN];
940: long primary_port;
941:
942: /* 'local_ip' and 'local_port' get filled with local's numerical
943: ip address and port number whenever an outgoing connection is
944: **established** from the primary socket to a remote address. */
945:
946: char local_ip[MAX_IPADR_LEN];
947: long local_port;
948:
949: char *user; /* user name string, allocated */
950: char *passwd; /* password string, allocated */
951: char *options; /* options string, allocated */
952:
953: char *sasl_authzid; /* authorisation identity string, allocated */
954:
955: int httpversion; /* the HTTP version*10 reported by the server */
956: int rtspversion; /* the RTSP version*10 reported by the server */
957:
958: struct curltime now; /* "current" time */
959: struct curltime created; /* creation time */
960: struct curltime lastused; /* when returned to the connection cache */
961: curl_socket_t sock[2]; /* two sockets, the second is used for the data
962: transfer when doing FTP */
963: curl_socket_t tempsock[2]; /* temporary sockets for happy eyeballs */
964: int tempfamily[2]; /* family used for the temp sockets */
965: Curl_recv *recv[2];
966: Curl_send *send[2];
967:
968: #ifdef USE_RECV_BEFORE_SEND_WORKAROUND
969: struct postponed_data postponed[2]; /* two buffers for two sockets */
970: #endif /* USE_RECV_BEFORE_SEND_WORKAROUND */
971: struct ssl_connect_data ssl[2]; /* this is for ssl-stuff */
972: struct ssl_connect_data proxy_ssl[2]; /* this is for proxy ssl-stuff */
973: #ifdef USE_SSL
974: void *ssl_extra; /* separately allocated backend-specific data */
975: #endif
976: struct ssl_primary_config ssl_config;
977: struct ssl_primary_config proxy_ssl_config;
978: struct ConnectBits bits; /* various state-flags for this connection */
979:
980: /* connecttime: when connect() is called on the current IP address. Used to
981: be able to track when to move on to try next IP - but only when the multi
982: interface is used. */
983: struct curltime connecttime;
984: /* The two fields below get set in Curl_connecthost */
985: int num_addr; /* number of addresses to try to connect to */
986: timediff_t timeoutms_per_addr; /* how long time in milliseconds to spend on
987: trying to connect to each IP address */
988:
989: const struct Curl_handler *handler; /* Connection's protocol handler */
990: const struct Curl_handler *given; /* The protocol first given */
991:
992: long ip_version; /* copied from the Curl_easy at creation time */
993:
994: /* Protocols can use a custom keepalive mechanism to keep connections alive.
995: This allows those protocols to track the last time the keepalive mechanism
996: was used on this connection. */
997: struct curltime keepalive;
998:
999: long upkeep_interval_ms; /* Time between calls for connection upkeep. */
1000:
1001: /**** curl_get() phase fields */
1002:
1003: curl_socket_t sockfd; /* socket to read from or CURL_SOCKET_BAD */
1004: curl_socket_t writesockfd; /* socket to write to, it may very
1005: well be the same we read from.
1006: CURL_SOCKET_BAD disables */
1007:
1008: /** Dynamically allocated strings, MUST be freed before this **/
1009: /** struct is killed. **/
1010: struct dynamically_allocated_data {
1011: char *proxyuserpwd;
1012: char *uagent;
1013: char *accept_encoding;
1014: char *userpwd;
1015: char *rangeline;
1016: char *ref;
1017: char *host;
1018: char *cookiehost;
1019: char *rtsp_transport;
1020: char *te; /* TE: request header */
1021: } allocptr;
1022:
1023: #ifdef HAVE_GSSAPI
1024: BIT(sec_complete); /* if Kerberos is enabled for this connection */
1025: enum protection_level command_prot;
1026: enum protection_level data_prot;
1027: enum protection_level request_data_prot;
1028: size_t buffer_size;
1029: struct krb5buffer in_buffer;
1030: void *app_data;
1031: const struct Curl_sec_client_mech *mech;
1032: struct sockaddr_in local_addr;
1033: #endif
1034:
1035: #if defined(USE_KERBEROS5) /* Consider moving some of the above GSS-API */
1036: struct kerberos5data krb5; /* variables into the structure definition, */
1037: #endif /* however, some of them are ftp specific. */
1038:
1039: struct curl_llist easyq; /* List of easy handles using this connection */
1040: curl_seek_callback seek_func; /* function that seeks the input */
1041: void *seek_client; /* pointer to pass to the seek() above */
1042:
1043: /*************** Request - specific items ************/
1044: #if defined(USE_WINDOWS_SSPI) && defined(SECPKG_ATTR_ENDPOINT_BINDINGS)
1045: CtxtHandle *sslContext;
1046: #endif
1047:
1048: #if defined(USE_NTLM)
1049: curlntlm http_ntlm_state;
1050: curlntlm proxy_ntlm_state;
1051:
1052: struct ntlmdata ntlm; /* NTLM differs from other authentication schemes
1053: because it authenticates connections, not
1054: single requests! */
1055: struct ntlmdata proxyntlm; /* NTLM data for proxy */
1056: #endif
1057:
1058: #ifdef USE_SPNEGO
1059: curlnegotiate http_negotiate_state;
1060: curlnegotiate proxy_negotiate_state;
1061:
1062: struct negotiatedata negotiate; /* state data for host Negotiate auth */
1063: struct negotiatedata proxyneg; /* state data for proxy Negotiate auth */
1064: #endif
1065:
1066: /* data used for the asynch name resolve callback */
1067: struct Curl_async async;
1068:
1069: /* These three are used for chunked-encoding trailer support */
1070: char *trailer; /* allocated buffer to store trailer in */
1071: int trlMax; /* allocated buffer size */
1072: int trlPos; /* index of where to store data */
1073:
1074: union {
1075: struct ftp_conn ftpc;
1076: struct http_conn httpc;
1077: struct ssh_conn sshc;
1078: struct tftp_state_data *tftpc;
1079: struct imap_conn imapc;
1080: struct pop3_conn pop3c;
1081: struct smtp_conn smtpc;
1082: struct rtsp_conn rtspc;
1083: struct smb_conn smbc;
1084: void *rtmp;
1085: struct ldapconninfo *ldapc;
1086: struct mqtt_conn mqtt;
1087: } proto;
1088:
1089: int cselect_bits; /* bitmask of socket events */
1090: int waitfor; /* current READ/WRITE bits to wait for */
1091:
1092: #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
1093: int socks5_gssapi_enctype;
1094: #endif
1095:
1096: /* When this connection is created, store the conditions for the local end
1097: bind. This is stored before the actual bind and before any connection is
1098: made and will serve the purpose of being used for comparison reasons so
1099: that subsequent bound-requested connections aren't accidentally re-using
1100: wrong connections. */
1101: char *localdev;
1102: unsigned short localport;
1103: int localportrange;
1104: struct http_connect_state *connect_state; /* for HTTP CONNECT */
1105: struct connectbundle *bundle; /* The bundle we are member of */
1106: int negnpn; /* APLN or NPN TLS negotiated protocol, CURL_HTTP_VERSION* */
1107: int retrycount; /* number of retries on a new connection */
1108: #ifdef USE_UNIX_SOCKETS
1109: char *unix_domain_socket;
1110: BIT(abstract_unix_socket);
1111: #endif
1112: BIT(tls_upgraded);
1113: /* the two following *_inuse fields are only flags, not counters in any way.
1114: If TRUE it means the channel is in use, and if FALSE it means the channel
1115: is up for grabs by one. */
1116: BIT(readchannel_inuse); /* whether the read channel is in use by an easy
1117: handle */
1118: BIT(writechannel_inuse); /* whether the write channel is in use by an easy
1119: handle */
1120: BIT(sock_accepted); /* TRUE if the SECONDARYSOCKET was created with
1121: accept() */
1122: BIT(parallel_connect); /* set TRUE when a parallel connect attempt has
1123: started (happy eyeballs) */
1124: };
1125:
1126: /* The end of connectdata. */
1127:
1128: /*
1129: * Struct to keep statistical and informational data.
1130: * All variables in this struct must be initialized/reset in Curl_initinfo().
1131: */
1132: struct PureInfo {
1133: int httpcode; /* Recent HTTP, FTP, RTSP or SMTP response code */
1134: int httpproxycode; /* response code from proxy when received separate */
1135: int httpversion; /* the http version number X.Y = X*10+Y */
1136: time_t filetime; /* If requested, this is might get set. Set to -1 if the
1137: time was unretrievable. */
1138: curl_off_t header_size; /* size of read header(s) in bytes */
1139: curl_off_t request_size; /* the amount of bytes sent in the request(s) */
1140: unsigned long proxyauthavail; /* what proxy auth types were announced */
1141: unsigned long httpauthavail; /* what host auth types were announced */
1142: long numconnects; /* how many new connection did libcurl created */
1143: char *contenttype; /* the content type of the object */
1144: char *wouldredirect; /* URL this would've been redirected to if asked to */
1145: curl_off_t retry_after; /* info from Retry-After: header */
1146:
1147: /* PureInfo members 'conn_primary_ip', 'conn_primary_port', 'conn_local_ip'
1148: and, 'conn_local_port' are copied over from the connectdata struct in
1149: order to allow curl_easy_getinfo() to return this information even when
1150: the session handle is no longer associated with a connection, and also
1151: allow curl_easy_reset() to clear this information from the session handle
1152: without disturbing information which is still alive, and that might be
1153: reused, in the connection cache. */
1154:
1155: char conn_primary_ip[MAX_IPADR_LEN];
1156: long conn_primary_port;
1157: char conn_local_ip[MAX_IPADR_LEN];
1158: long conn_local_port;
1159: const char *conn_scheme;
1160: unsigned int conn_protocol;
1161: struct curl_certinfo certs; /* info about the certs, only populated in
1162: OpenSSL, GnuTLS, Schannel, NSS and GSKit
1163: builds. Asked for with CURLOPT_CERTINFO
1164: / CURLINFO_CERTINFO */
1165: BIT(timecond); /* set to TRUE if the time condition didn't match, which
1166: thus made the document NOT get fetched */
1167: };
1168:
1169:
1170: struct Progress {
1171: time_t lastshow; /* time() of the last displayed progress meter or NULL to
1172: force redraw at next call */
1173: curl_off_t size_dl; /* total expected size */
1174: curl_off_t size_ul; /* total expected size */
1175: curl_off_t downloaded; /* transferred so far */
1176: curl_off_t uploaded; /* transferred so far */
1177:
1178: curl_off_t current_speed; /* uses the currently fastest transfer */
1179:
1180: int width; /* screen width at download start */
1181: int flags; /* see progress.h */
1182:
1183: timediff_t timespent;
1184:
1185: curl_off_t dlspeed;
1186: curl_off_t ulspeed;
1187:
1188: timediff_t t_nslookup;
1189: timediff_t t_connect;
1190: timediff_t t_appconnect;
1191: timediff_t t_pretransfer;
1192: timediff_t t_starttransfer;
1193: timediff_t t_redirect;
1194:
1195: struct curltime start;
1196: struct curltime t_startsingle;
1197: struct curltime t_startop;
1198: struct curltime t_acceptdata;
1199:
1200:
1201: /* upload speed limit */
1202: struct curltime ul_limit_start;
1203: curl_off_t ul_limit_size;
1204: /* download speed limit */
1205: struct curltime dl_limit_start;
1206: curl_off_t dl_limit_size;
1207:
1208: #define CURR_TIME (5 + 1) /* 6 entries for 5 seconds */
1209:
1210: curl_off_t speeder[ CURR_TIME ];
1211: struct curltime speeder_time[ CURR_TIME ];
1212: int speeder_c;
1213: BIT(callback); /* set when progress callback is used */
1214: BIT(is_t_startransfer_set);
1215: };
1216:
1217: typedef enum {
1218: HTTPREQ_NONE, /* first in list */
1219: HTTPREQ_GET,
1220: HTTPREQ_POST,
1221: HTTPREQ_POST_FORM, /* we make a difference internally */
1222: HTTPREQ_POST_MIME, /* we make a difference internally */
1223: HTTPREQ_PUT,
1224: HTTPREQ_HEAD,
1225: HTTPREQ_OPTIONS,
1226: HTTPREQ_LAST /* last in list */
1227: } Curl_HttpReq;
1228:
1229: typedef enum {
1230: RTSPREQ_NONE, /* first in list */
1231: RTSPREQ_OPTIONS,
1232: RTSPREQ_DESCRIBE,
1233: RTSPREQ_ANNOUNCE,
1234: RTSPREQ_SETUP,
1235: RTSPREQ_PLAY,
1236: RTSPREQ_PAUSE,
1237: RTSPREQ_TEARDOWN,
1238: RTSPREQ_GET_PARAMETER,
1239: RTSPREQ_SET_PARAMETER,
1240: RTSPREQ_RECORD,
1241: RTSPREQ_RECEIVE,
1242: RTSPREQ_LAST /* last in list */
1243: } Curl_RtspReq;
1244:
1245: /*
1246: * Values that are generated, temporary or calculated internally for a
1247: * "session handle" must be defined within the 'struct UrlState'. This struct
1248: * will be used within the Curl_easy struct. When the 'Curl_easy'
1249: * struct is cloned, this data MUST NOT be copied.
1250: *
1251: * Remember that any "state" information goes globally for the curl handle.
1252: * Session-data MUST be put in the connectdata struct and here. */
1253: #define MAX_CURL_USER_LENGTH 256
1254: #define MAX_CURL_PASSWORD_LENGTH 256
1255:
1256: struct auth {
1257: unsigned long want; /* Bitmask set to the authentication methods wanted by
1258: app (with CURLOPT_HTTPAUTH or CURLOPT_PROXYAUTH). */
1259: unsigned long picked;
1260: unsigned long avail; /* Bitmask for what the server reports to support for
1261: this resource */
1262: BIT(done); /* TRUE when the auth phase is done and ready to do the
1263: actual request */
1264: BIT(multipass); /* TRUE if this is not yet authenticated but within the
1265: auth multipass negotiation */
1266: BIT(iestyle); /* TRUE if digest should be done IE-style or FALSE if it
1267: should be RFC compliant */
1268: };
1269:
1270: struct Curl_http2_dep {
1271: struct Curl_http2_dep *next;
1272: struct Curl_easy *data;
1273: };
1274:
1275: /*
1276: * This struct is for holding data that was attempted to get sent to the user's
1277: * callback but is held due to pausing. One instance per type (BOTH, HEADER,
1278: * BODY).
1279: */
1280: struct tempbuf {
1281: char *buf; /* allocated buffer to keep data in when a write callback
1282: returns to make the connection paused */
1283: size_t len; /* size of the 'tempwrite' allocated buffer */
1284: int type; /* type of the 'tempwrite' buffer as a bitmask that is used with
1285: Curl_client_write() */
1286: };
1287:
1288: /* Timers */
1289: typedef enum {
1290: EXPIRE_100_TIMEOUT,
1291: EXPIRE_ASYNC_NAME,
1292: EXPIRE_CONNECTTIMEOUT,
1293: EXPIRE_DNS_PER_NAME,
1294: EXPIRE_HAPPY_EYEBALLS_DNS, /* See asyn-ares.c */
1295: EXPIRE_HAPPY_EYEBALLS,
1296: EXPIRE_MULTI_PENDING,
1297: EXPIRE_RUN_NOW,
1298: EXPIRE_SPEEDCHECK,
1299: EXPIRE_TIMEOUT,
1300: EXPIRE_TOOFAST,
1301: EXPIRE_QUIC,
1302: EXPIRE_LAST /* not an actual timer, used as a marker only */
1303: } expire_id;
1304:
1305:
1306: typedef enum {
1307: TRAILERS_NONE,
1308: TRAILERS_INITIALIZED,
1309: TRAILERS_SENDING,
1310: TRAILERS_DONE
1311: } trailers_state;
1312:
1313:
1314: /*
1315: * One instance for each timeout an easy handle can set.
1316: */
1317: struct time_node {
1318: struct curl_llist_element list;
1319: struct curltime time;
1320: expire_id eid;
1321: };
1322:
1323: /* individual pieces of the URL */
1324: struct urlpieces {
1325: char *scheme;
1326: char *hostname;
1327: char *port;
1328: char *user;
1329: char *password;
1330: char *options;
1331: char *path;
1332: char *query;
1333: };
1334:
1335: struct UrlState {
1336: /* Points to the connection cache */
1337: struct conncache *conn_cache;
1338:
1339: /* buffers to store authentication data in, as parsed from input options */
1340: struct curltime keeps_speed; /* for the progress meter really */
1341:
1342: struct connectdata *lastconnect; /* The last connection, NULL if undefined */
1343:
1344: char *headerbuff; /* allocated buffer to store headers in */
1345: size_t headersize; /* size of the allocation */
1346:
1347: char *buffer; /* download buffer */
1348: char *ulbuf; /* allocated upload buffer or NULL */
1349: curl_off_t current_speed; /* the ProgressShow() function sets this,
1350: bytes / second */
1351: char *first_host; /* host name of the first (not followed) request.
1352: if set, this should be the host name that we will
1353: sent authorization to, no else. Used to make Location:
1354: following not keep sending user+password... This is
1355: strdup() data.
1356: */
1357: int first_remote_port; /* remote port of the first (not followed) request */
1358: struct curl_ssl_session *session; /* array of 'max_ssl_sessions' size */
1359: long sessionage; /* number of the most recent session */
1360: unsigned int tempcount; /* number of entries in use in tempwrite, 0 - 3 */
1361: struct tempbuf tempwrite[3]; /* BOTH, HEADER, BODY */
1362: char *scratch; /* huge buffer[set.buffer_size*2] for upload CRLF replacing */
1363: int os_errno; /* filled in with errno whenever an error occurs */
1364: #ifdef HAVE_SIGNAL
1365: /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */
1366: void (*prev_signal)(int sig);
1367: #endif
1368: struct digestdata digest; /* state data for host Digest auth */
1369: struct digestdata proxydigest; /* state data for proxy Digest auth */
1370:
1371: struct auth authhost; /* auth details for host */
1372: struct auth authproxy; /* auth details for proxy */
1373: void *resolver; /* resolver state, if it is used in the URL state -
1374: ares_channel f.e. */
1375:
1376: #if defined(USE_OPENSSL)
1377: /* void instead of ENGINE to avoid bleeding OpenSSL into this header */
1378: void *engine;
1379: #endif /* USE_OPENSSL */
1380: struct curltime expiretime; /* set this with Curl_expire() only */
1381: struct Curl_tree timenode; /* for the splay stuff */
1382: struct curl_llist timeoutlist; /* list of pending timeouts */
1383: struct time_node expires[EXPIRE_LAST]; /* nodes for each expire type */
1384:
1385: /* a place to store the most recently set FTP entrypath */
1386: char *most_recent_ftp_entrypath;
1387:
1388: int httpversion; /* the lowest HTTP version*10 reported by any server
1389: involved in this request */
1390:
1391: #if !defined(WIN32) && !defined(MSDOS) && !defined(__EMX__) && \
1392: !defined(__SYMBIAN32__)
1393: /* do FTP line-end conversions on most platforms */
1394: #define CURL_DO_LINEEND_CONV
1395: /* for FTP downloads: track CRLF sequences that span blocks */
1396: BIT(prev_block_had_trailing_cr);
1397: /* for FTP downloads: how many CRLFs did we converted to LFs? */
1398: curl_off_t crlf_conversions;
1399: #endif
1400: char *range; /* range, if used. See README for detailed specification on
1401: this syntax. */
1402: curl_off_t resume_from; /* continue [ftp] transfer from here */
1403:
1404: /* This RTSP state information survives requests and connections */
1405: long rtsp_next_client_CSeq; /* the session's next client CSeq */
1406: long rtsp_next_server_CSeq; /* the session's next server CSeq */
1407: long rtsp_CSeq_recv; /* most recent CSeq received */
1408:
1409: curl_off_t infilesize; /* size of file to upload, -1 means unknown.
1410: Copied from set.filesize at start of operation */
1411:
1412: size_t drain; /* Increased when this stream has data to read, even if its
1413: socket is not necessarily is readable. Decreased when
1414: checked. */
1415:
1416: curl_read_callback fread_func; /* read callback/function */
1417: void *in; /* CURLOPT_READDATA */
1418:
1419: struct Curl_easy *stream_depends_on;
1420: int stream_weight;
1421: CURLU *uh; /* URL handle for the current parsed URL */
1422: struct urlpieces up;
1423: #ifndef CURL_DISABLE_HTTP
1424: size_t trailers_bytes_sent;
1425: Curl_send_buffer *trailers_buf; /* a buffer containing the compiled trailing
1426: headers */
1427: #endif
1428: trailers_state trailers_state; /* whether we are sending trailers
1429: and what stage are we at */
1430: #ifdef CURLDEBUG
1431: BIT(conncache_lock);
1432: #endif
1433: /* when curl_easy_perform() is called, the multi handle is "owned" by
1434: the easy handle so curl_easy_cleanup() on such an easy handle will
1435: also close the multi handle! */
1436: BIT(multi_owned_by_easy);
1437:
1438: BIT(this_is_a_follow); /* this is a followed Location: request */
1439: BIT(refused_stream); /* this was refused, try again */
1440: BIT(errorbuf); /* Set to TRUE if the error buffer is already filled in.
1441: This must be set to FALSE every time _easy_perform() is
1442: called. */
1443: BIT(allow_port); /* Is set.use_port allowed to take effect or not. This
1444: is always set TRUE when curl_easy_perform() is called. */
1445: BIT(authproblem); /* TRUE if there's some problem authenticating */
1446: /* set after initial USER failure, to prevent an authentication loop */
1447: BIT(ftp_trying_alternative);
1448: BIT(wildcardmatch); /* enable wildcard matching */
1449: BIT(expect100header); /* TRUE if we added Expect: 100-continue */
1450: BIT(disableexpect); /* TRUE if Expect: is disabled due to a previous
1451: 417 response */
1452: BIT(use_range);
1453: BIT(rangestringalloc); /* the range string is malloc()'ed */
1454: BIT(done); /* set to FALSE when Curl_init_do() is called and set to TRUE
1455: when multi_done() is called, to prevent multi_done() to get
1456: invoked twice when the multi interface is used. */
1457: BIT(stream_depends_e); /* set or don't set the Exclusive bit */
1458: BIT(previouslypending); /* this transfer WAS in the multi->pending queue */
1459: BIT(cookie_engine);
1460: };
1461:
1462:
1463: /*
1464: * This 'DynamicStatic' struct defines dynamic states that actually change
1465: * values in the 'UserDefined' area, which MUST be taken into consideration
1466: * if the UserDefined struct is cloned or similar. You can probably just
1467: * copy these, but each one indicate a special action on other data.
1468: */
1469:
1470: struct DynamicStatic {
1471: char *url; /* work URL, copied from UserDefined */
1472: char *referer; /* referer string */
1473: struct curl_slist *cookielist; /* list of cookie files set by
1474: curl_easy_setopt(COOKIEFILE) calls */
1475: struct curl_slist *resolve; /* set to point to the set.resolve list when
1476: this should be dealt with in pretransfer */
1477: BIT(url_alloc); /* URL string is malloc()'ed */
1478: BIT(referer_alloc); /* referer string is malloc()ed */
1479: BIT(wildcard_resolve); /* Set to true if any resolve change is a
1480: wildcard */
1481: };
1482:
1483: /*
1484: * This 'UserDefined' struct must only contain data that is set once to go
1485: * for many (perhaps) independent connections. Values that are generated or
1486: * calculated internally for the "session handle" MUST be defined within the
1487: * 'struct UrlState' instead. The only exceptions MUST note the changes in
1488: * the 'DynamicStatic' struct.
1489: * Character pointer fields point to dynamic storage, unless otherwise stated.
1490: */
1491:
1492: struct Curl_multi; /* declared and used only in multi.c */
1493:
1494: /*
1495: * This enumeration MUST not use conditional directives (#ifdefs), new
1496: * null terminated strings MUST be added to the enumeration immediately
1497: * before STRING_LASTZEROTERMINATED, binary fields immediately before
1498: * STRING_LAST. When doing so, ensure that the packages/OS400/chkstring.c
1499: * test is updated and applicable changes for EBCDIC to ASCII conversion
1500: * are catered for in curl_easy_setopt_ccsid()
1501: */
1502: enum dupstring {
1503: STRING_CERT_ORIG, /* client certificate file name */
1504: STRING_CERT_PROXY, /* client certificate file name */
1505: STRING_CERT_TYPE_ORIG, /* format for certificate (default: PEM)*/
1506: STRING_CERT_TYPE_PROXY, /* format for certificate (default: PEM)*/
1507: STRING_COOKIE, /* HTTP cookie string to send */
1508: STRING_COOKIEJAR, /* dump all cookies to this file */
1509: STRING_CUSTOMREQUEST, /* HTTP/FTP/RTSP request/method to use */
1510: STRING_DEFAULT_PROTOCOL, /* Protocol to use when the URL doesn't specify */
1511: STRING_DEVICE, /* local network interface/address to use */
1512: STRING_ENCODING, /* Accept-Encoding string */
1513: STRING_FTP_ACCOUNT, /* ftp account data */
1514: STRING_FTP_ALTERNATIVE_TO_USER, /* command to send if USER/PASS fails */
1515: STRING_FTPPORT, /* port to send with the FTP PORT command */
1516: STRING_KEY_ORIG, /* private key file name */
1517: STRING_KEY_PROXY, /* private key file name */
1518: STRING_KEY_PASSWD_ORIG, /* plain text private key password */
1519: STRING_KEY_PASSWD_PROXY, /* plain text private key password */
1520: STRING_KEY_TYPE_ORIG, /* format for private key (default: PEM) */
1521: STRING_KEY_TYPE_PROXY, /* format for private key (default: PEM) */
1522: STRING_KRB_LEVEL, /* krb security level */
1523: STRING_NETRC_FILE, /* if not NULL, use this instead of trying to find
1524: $HOME/.netrc */
1525: STRING_PROXY, /* proxy to use */
1526: STRING_PRE_PROXY, /* pre socks proxy to use */
1527: STRING_SET_RANGE, /* range, if used */
1528: STRING_SET_REFERER, /* custom string for the HTTP referer field */
1529: STRING_SET_URL, /* what original URL to work on */
1530: STRING_SSL_CAPATH_ORIG, /* CA directory name (doesn't work on windows) */
1531: STRING_SSL_CAPATH_PROXY, /* CA directory name (doesn't work on windows) */
1532: STRING_SSL_CAFILE_ORIG, /* certificate file to verify peer against */
1533: STRING_SSL_CAFILE_PROXY, /* certificate file to verify peer against */
1534: STRING_SSL_PINNEDPUBLICKEY_ORIG, /* public key file to verify peer against */
1535: STRING_SSL_PINNEDPUBLICKEY_PROXY, /* public key file to verify proxy */
1536: STRING_SSL_CIPHER_LIST_ORIG, /* list of ciphers to use */
1537: STRING_SSL_CIPHER_LIST_PROXY, /* list of ciphers to use */
1538: STRING_SSL_CIPHER13_LIST_ORIG, /* list of TLS 1.3 ciphers to use */
1539: STRING_SSL_CIPHER13_LIST_PROXY, /* list of TLS 1.3 ciphers to use */
1540: STRING_SSL_EGDSOCKET, /* path to file containing the EGD daemon socket */
1541: STRING_SSL_RANDOM_FILE, /* path to file containing "random" data */
1542: STRING_USERAGENT, /* User-Agent string */
1543: STRING_SSL_CRLFILE_ORIG, /* crl file to check certificate */
1544: STRING_SSL_CRLFILE_PROXY, /* crl file to check certificate */
1545: STRING_SSL_ISSUERCERT_ORIG, /* issuer cert file to check certificate */
1546: STRING_SSL_ISSUERCERT_PROXY, /* issuer cert file to check certificate */
1547: STRING_SSL_ENGINE, /* name of ssl engine */
1548: STRING_USERNAME, /* <username>, if used */
1549: STRING_PASSWORD, /* <password>, if used */
1550: STRING_OPTIONS, /* <options>, if used */
1551: STRING_PROXYUSERNAME, /* Proxy <username>, if used */
1552: STRING_PROXYPASSWORD, /* Proxy <password>, if used */
1553: STRING_NOPROXY, /* List of hosts which should not use the proxy, if
1554: used */
1555: STRING_RTSP_SESSION_ID, /* Session ID to use */
1556: STRING_RTSP_STREAM_URI, /* Stream URI for this request */
1557: STRING_RTSP_TRANSPORT, /* Transport for this session */
1558:
1559: STRING_SSH_PRIVATE_KEY, /* path to the private key file for auth */
1560: STRING_SSH_PUBLIC_KEY, /* path to the public key file for auth */
1561: STRING_SSH_HOST_PUBLIC_KEY_MD5, /* md5 of host public key in ascii hex */
1562: STRING_SSH_KNOWNHOSTS, /* file name of knownhosts file */
1563:
1564: STRING_PROXY_SERVICE_NAME, /* Proxy service name */
1565: STRING_SERVICE_NAME, /* Service name */
1566: STRING_MAIL_FROM,
1567: STRING_MAIL_AUTH,
1568:
1569: STRING_TLSAUTH_USERNAME_ORIG, /* TLS auth <username> */
1570: STRING_TLSAUTH_USERNAME_PROXY, /* TLS auth <username> */
1571: STRING_TLSAUTH_PASSWORD_ORIG, /* TLS auth <password> */
1572: STRING_TLSAUTH_PASSWORD_PROXY, /* TLS auth <password> */
1573:
1574: STRING_BEARER, /* <bearer>, if used */
1575:
1576: STRING_UNIX_SOCKET_PATH, /* path to Unix socket, if used */
1577:
1578: STRING_TARGET, /* CURLOPT_REQUEST_TARGET */
1579: STRING_DOH, /* CURLOPT_DOH_URL */
1580:
1581: STRING_ALTSVC, /* CURLOPT_ALTSVC */
1582:
1583: STRING_SASL_AUTHZID, /* CURLOPT_SASL_AUTHZID */
1584:
1585: STRING_TEMP_URL, /* temp URL storage for proxy use */
1586:
1587: STRING_DNS_SERVERS,
1588: STRING_DNS_INTERFACE,
1589: STRING_DNS_LOCAL_IP4,
1590: STRING_DNS_LOCAL_IP6,
1591:
1592: /* -- end of zero-terminated strings -- */
1593:
1594: STRING_LASTZEROTERMINATED,
1595:
1596: /* -- below this are pointers to binary data that cannot be strdup'ed. --- */
1597:
1598: STRING_COPYPOSTFIELDS, /* if POST, set the fields' values here */
1599:
1600:
1601: STRING_LAST /* not used, just an end-of-list marker */
1602: };
1603:
1604: /* callback that gets called when this easy handle is completed within a multi
1605: handle. Only used for internally created transfers, like for example
1606: DoH. */
1607: typedef int (*multidone_func)(struct Curl_easy *easy, CURLcode result);
1608:
1609: struct UserDefined {
1610: FILE *err; /* the stderr user data goes here */
1611: void *debugdata; /* the data that will be passed to fdebug */
1612: char *errorbuffer; /* (Static) store failure messages in here */
1613: long proxyport; /* If non-zero, use this port number by default. If the
1614: proxy string features a ":[port]" that one will override
1615: this. */
1616: void *out; /* CURLOPT_WRITEDATA */
1617: void *in_set; /* CURLOPT_READDATA */
1618: void *writeheader; /* write the header to this if non-NULL */
1619: void *rtp_out; /* write RTP to this if non-NULL */
1620: long use_port; /* which port to use (when not using default) */
1621: unsigned long httpauth; /* kind of HTTP authentication to use (bitmask) */
1622: unsigned long proxyauth; /* kind of proxy authentication to use (bitmask) */
1623: unsigned long socks5auth;/* kind of SOCKS5 authentication to use (bitmask) */
1624: long followlocation; /* as in HTTP Location: */
1625: long maxredirs; /* maximum no. of http(s) redirects to follow, set to -1
1626: for infinity */
1627:
1628: int keep_post; /* keep POSTs as POSTs after a 30x request; each
1629: bit represents a request, from 301 to 303 */
1630: void *postfields; /* if POST, set the fields' values here */
1631: curl_seek_callback seek_func; /* function that seeks the input */
1632: curl_off_t postfieldsize; /* if POST, this might have a size to use instead
1633: of strlen(), and then the data *may* be binary
1634: (contain zero bytes) */
1635: unsigned short localport; /* local port number to bind to */
1636: int localportrange; /* number of additional port numbers to test in case the
1637: 'localport' one can't be bind()ed */
1638: curl_write_callback fwrite_func; /* function that stores the output */
1639: curl_write_callback fwrite_header; /* function that stores headers */
1640: curl_write_callback fwrite_rtp; /* function that stores interleaved RTP */
1641: curl_read_callback fread_func_set; /* function that reads the input */
1642: curl_progress_callback fprogress; /* OLD and deprecated progress callback */
1643: curl_xferinfo_callback fxferinfo; /* progress callback */
1644: curl_debug_callback fdebug; /* function that write informational data */
1645: curl_ioctl_callback ioctl_func; /* function for I/O control */
1646: curl_sockopt_callback fsockopt; /* function for setting socket options */
1647: void *sockopt_client; /* pointer to pass to the socket options callback */
1648: curl_opensocket_callback fopensocket; /* function for checking/translating
1649: the address and opening the
1650: socket */
1651: void *opensocket_client;
1652: curl_closesocket_callback fclosesocket; /* function for closing the
1653: socket */
1654: void *closesocket_client;
1655:
1656: void *seek_client; /* pointer to pass to the seek callback */
1657: /* the 3 curl_conv_callback functions below are used on non-ASCII hosts */
1658: /* function to convert from the network encoding: */
1659: curl_conv_callback convfromnetwork;
1660: /* function to convert to the network encoding: */
1661: curl_conv_callback convtonetwork;
1662: /* function to convert from UTF-8 encoding: */
1663: curl_conv_callback convfromutf8;
1664:
1665: void *progress_client; /* pointer to pass to the progress callback */
1666: void *ioctl_client; /* pointer to pass to the ioctl callback */
1667: long timeout; /* in milliseconds, 0 means no timeout */
1668: long connecttimeout; /* in milliseconds, 0 means no timeout */
1669: long accepttimeout; /* in milliseconds, 0 means no timeout */
1670: long happy_eyeballs_timeout; /* in milliseconds, 0 is a valid value */
1671: long server_response_timeout; /* in milliseconds, 0 means no timeout */
1672: long maxage_conn; /* in seconds, max idle time to allow a connection that
1673: is to be reused */
1674: long tftp_blksize; /* in bytes, 0 means use default */
1675: curl_off_t filesize; /* size of file to upload, -1 means unknown */
1676: long low_speed_limit; /* bytes/second */
1677: long low_speed_time; /* number of seconds */
1678: curl_off_t max_send_speed; /* high speed limit in bytes/second for upload */
1679: curl_off_t max_recv_speed; /* high speed limit in bytes/second for
1680: download */
1681: curl_off_t set_resume_from; /* continue [ftp] transfer from here */
1682: struct curl_slist *headers; /* linked list of extra headers */
1683: struct curl_slist *proxyheaders; /* linked list of extra CONNECT headers */
1684: struct curl_httppost *httppost; /* linked list of old POST data */
1685: curl_mimepart mimepost; /* MIME/POST data. */
1686: struct curl_slist *quote; /* after connection is established */
1687: struct curl_slist *postquote; /* after the transfer */
1688: struct curl_slist *prequote; /* before the transfer, after type */
1689: struct curl_slist *source_quote; /* 3rd party quote */
1690: struct curl_slist *source_prequote; /* in 3rd party transfer mode - before
1691: the transfer on source host */
1692: struct curl_slist *source_postquote; /* in 3rd party transfer mode - after
1693: the transfer on source host */
1694: struct curl_slist *telnet_options; /* linked list of telnet options */
1695: struct curl_slist *resolve; /* list of names to add/remove from
1696: DNS cache */
1697: struct curl_slist *connect_to; /* list of host:port mappings to override
1698: the hostname and port to connect to */
1699: curl_TimeCond timecondition; /* kind of time/date comparison */
1700: time_t timevalue; /* what time to compare with */
1701: Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */
1702: long httpversion; /* when non-zero, a specific HTTP version requested to
1703: be used in the library's request(s) */
1704: struct ssl_config_data ssl; /* user defined SSL stuff */
1705: struct ssl_config_data proxy_ssl; /* user defined SSL stuff for proxy */
1706: struct ssl_general_config general_ssl; /* general user defined SSL stuff */
1707: curl_proxytype proxytype; /* what kind of proxy that is in use */
1708: long dns_cache_timeout; /* DNS cache timeout */
1709: long buffer_size; /* size of receive buffer to use */
1710: size_t upload_buffer_size; /* size of upload buffer to use,
1711: keep it >= CURL_MAX_WRITE_SIZE */
1712: void *private_data; /* application-private data */
1713: struct curl_slist *http200aliases; /* linked list of aliases for http200 */
1714: long ipver; /* the CURL_IPRESOLVE_* defines in the public header file
1715: 0 - whatever, 1 - v2, 2 - v6 */
1716: curl_off_t max_filesize; /* Maximum file size to download */
1717: #ifndef CURL_DISABLE_FTP
1718: curl_ftpfile ftp_filemethod; /* how to get to a file when FTP is used */
1719: curl_ftpauth ftpsslauth; /* what AUTH XXX to be attempted */
1720: curl_ftpccc ftp_ccc; /* FTP CCC options */
1721: #endif
1722: int ftp_create_missing_dirs; /* 1 - create directories that don't exist
1723: 2 - the same but also allow MKD to fail once
1724: */
1725: curl_sshkeycallback ssh_keyfunc; /* key matching callback */
1726: void *ssh_keyfunc_userp; /* custom pointer to callback */
1727: enum CURL_NETRC_OPTION
1728: use_netrc; /* defined in include/curl.h */
1729: curl_usessl use_ssl; /* if AUTH TLS is to be attempted etc, for FTP or
1730: IMAP or POP3 or others! */
1731: long new_file_perms; /* Permissions to use when creating remote files */
1732: long new_directory_perms; /* Permissions to use when creating remote dirs */
1733: long ssh_auth_types; /* allowed SSH auth types */
1734: char *str[STRING_LAST]; /* array of strings, pointing to allocated memory */
1735: unsigned int scope_id; /* Scope id for IPv6 */
1736: long allowed_protocols;
1737: long redir_protocols;
1738: struct curl_slist *mail_rcpt; /* linked list of mail recipients */
1739: /* Common RTSP header options */
1740: Curl_RtspReq rtspreq; /* RTSP request type */
1741: long rtspversion; /* like httpversion, for RTSP */
1742: curl_chunk_bgn_callback chunk_bgn; /* called before part of transfer
1743: starts */
1744: curl_chunk_end_callback chunk_end; /* called after part transferring
1745: stopped */
1746: curl_fnmatch_callback fnmatch; /* callback to decide which file corresponds
1747: to pattern (e.g. if WILDCARDMATCH is on) */
1748: void *fnmatch_data;
1749:
1750: long gssapi_delegation; /* GSS-API credential delegation, see the
1751: documentation of CURLOPT_GSSAPI_DELEGATION */
1752:
1753: long tcp_keepidle; /* seconds in idle before sending keepalive probe */
1754: long tcp_keepintvl; /* seconds between TCP keepalive probes */
1755:
1756: size_t maxconnects; /* Max idle connections in the connection cache */
1757:
1758: long expect_100_timeout; /* in milliseconds */
1759: struct Curl_easy *stream_depends_on;
1760: int stream_weight;
1761: struct Curl_http2_dep *stream_dependents;
1762:
1763: curl_resolver_start_callback resolver_start; /* optional callback called
1764: before resolver start */
1765: void *resolver_start_client; /* pointer to pass to resolver start callback */
1766: long upkeep_interval_ms; /* Time between calls for connection upkeep. */
1767: multidone_func fmultidone;
1768: struct Curl_easy *dohfor; /* this is a DoH request for that transfer */
1769: CURLU *uh; /* URL handle for the current parsed URL */
1770: void *trailer_data; /* pointer to pass to trailer data callback */
1771: curl_trailer_callback trailer_callback; /* trailing data callback */
1772: BIT(is_fread_set); /* has read callback been set to non-NULL? */
1773: BIT(is_fwrite_set); /* has write callback been set to non-NULL? */
1774: BIT(free_referer); /* set TRUE if 'referer' points to a string we
1775: allocated */
1776: BIT(tftp_no_options); /* do not send TFTP options requests */
1777: BIT(sep_headers); /* handle host and proxy headers separately */
1778: BIT(cookiesession); /* new cookie session? */
1779: BIT(crlf); /* convert crlf on ftp upload(?) */
1780: BIT(strip_path_slash); /* strip off initial slash from path */
1781: BIT(ssh_compression); /* enable SSH compression */
1782:
1783: /* Here follows boolean settings that define how to behave during
1784: this session. They are STATIC, set by libcurl users or at least initially
1785: and they don't change during operations. */
1786: BIT(get_filetime); /* get the time and get of the remote file */
1787: BIT(tunnel_thru_httpproxy); /* use CONNECT through a HTTP proxy */
1788: BIT(prefer_ascii); /* ASCII rather than binary */
1789: BIT(ftp_append); /* append, not overwrite, on upload */
1790: BIT(ftp_list_only); /* switch FTP command for listing directories */
1791: #ifndef CURL_DISABLE_FTP
1792: BIT(ftp_use_port); /* use the FTP PORT command */
1793: BIT(ftp_use_epsv); /* if EPSV is to be attempted or not */
1794: BIT(ftp_use_eprt); /* if EPRT is to be attempted or not */
1795: BIT(ftp_use_pret); /* if PRET is to be used before PASV or not */
1796: BIT(ftp_skip_ip); /* skip the IP address the FTP server passes on to
1797: us */
1798: #endif
1799: BIT(hide_progress); /* don't use the progress meter */
1800: BIT(http_fail_on_error); /* fail on HTTP error codes >= 400 */
1801: BIT(http_keep_sending_on_error); /* for HTTP status codes >= 300 */
1802: BIT(http_follow_location); /* follow HTTP redirects */
1803: BIT(http_transfer_encoding); /* request compressed HTTP transfer-encoding */
1804: BIT(allow_auth_to_other_hosts);
1805: BIT(include_header); /* include received protocol headers in data output */
1806: BIT(http_set_referer); /* is a custom referer used */
1807: BIT(http_auto_referer); /* set "correct" referer when following
1808: location: */
1809: BIT(opt_no_body); /* as set with CURLOPT_NOBODY */
1810: BIT(upload); /* upload request */
1811: BIT(verbose); /* output verbosity */
1812: BIT(krb); /* Kerberos connection requested */
1813: BIT(reuse_forbid); /* forbidden to be reused, close after use */
1814: BIT(reuse_fresh); /* do not re-use an existing connection */
1815: BIT(no_signal); /* do not use any signal/alarm handler */
1816: BIT(tcp_nodelay); /* whether to enable TCP_NODELAY or not */
1817: BIT(ignorecl); /* ignore content length */
1818: BIT(connect_only); /* make connection, let application use the socket */
1819: BIT(http_te_skip); /* pass the raw body data to the user, even when
1820: transfer-encoded (chunked, compressed) */
1821: BIT(http_ce_skip); /* pass the raw body data to the user, even when
1822: content-encoded (chunked, compressed) */
1823: BIT(proxy_transfer_mode); /* set transfer mode (;type=<a|i>) when doing
1824: FTP via an HTTP proxy */
1825: #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
1826: BIT(socks5_gssapi_nec); /* Flag to support NEC SOCKS5 server */
1827: #endif
1828: BIT(sasl_ir); /* Enable/disable SASL initial response */
1829: BIT(wildcard_enabled); /* enable wildcard matching */
1830: BIT(tcp_keepalive); /* use TCP keepalives */
1831: BIT(tcp_fastopen); /* use TCP Fast Open */
1832: BIT(ssl_enable_npn); /* TLS NPN extension? */
1833: BIT(ssl_enable_alpn);/* TLS ALPN extension? */
1834: BIT(path_as_is); /* allow dotdots? */
1835: BIT(pipewait); /* wait for multiplex status before starting a new
1836: connection */
1837: BIT(suppress_connect_headers); /* suppress proxy CONNECT response headers
1838: from user callbacks */
1839: BIT(dns_shuffle_addresses); /* whether to shuffle addresses before use */
1840: BIT(stream_depends_e); /* set or don't set the Exclusive bit */
1841: BIT(haproxyprotocol); /* whether to send HAProxy PROXY protocol v1
1842: header */
1843: BIT(abstract_unix_socket);
1844: BIT(disallow_username_in_url); /* disallow username in url */
1845: BIT(doh); /* DNS-over-HTTPS enabled */
1846: BIT(doh_get); /* use GET for DoH requests, instead of POST */
1847: BIT(http09_allowed); /* allow HTTP/0.9 responses */
1848: BIT(mail_rcpt_allowfails); /* allow RCPT TO command to fail for some
1849: recipients */
1850: };
1851:
1852: struct Names {
1853: struct curl_hash *hostcache;
1854: enum {
1855: HCACHE_NONE, /* not pointing to anything */
1856: HCACHE_MULTI, /* points to a shared one in the multi handle */
1857: HCACHE_SHARED /* points to a shared one in a shared object */
1858: } hostcachetype;
1859: };
1860:
1861: /*
1862: * The 'connectdata' struct MUST have all the connection oriented stuff as we
1863: * may have several simultaneous connections and connection structs in memory.
1864: *
1865: * The 'struct UserDefined' must only contain data that is set once to go for
1866: * many (perhaps) independent connections. Values that are generated or
1867: * calculated internally for the "session handle" must be defined within the
1868: * 'struct UrlState' instead.
1869: */
1870:
1871: struct Curl_easy {
1872: /* first, two fields for the linked list of these */
1873: struct Curl_easy *next;
1874: struct Curl_easy *prev;
1875:
1876: struct connectdata *conn;
1877: struct curl_llist_element connect_queue;
1878: struct curl_llist_element conn_queue; /* list per connectdata */
1879:
1880: CURLMstate mstate; /* the handle's state */
1881: CURLcode result; /* previous result */
1882:
1883: struct Curl_message msg; /* A single posted message. */
1884:
1885: /* Array with the plain socket numbers this handle takes care of, in no
1886: particular order. Note that all sockets are added to the sockhash, where
1887: the state etc are also kept. This array is mostly used to detect when a
1888: socket is to be removed from the hash. See singlesocket(). */
1889: curl_socket_t sockets[MAX_SOCKSPEREASYHANDLE];
1890: int actions[MAX_SOCKSPEREASYHANDLE]; /* action for each socket in
1891: sockets[] */
1892: int numsocks;
1893:
1894: struct Names dns;
1895: struct Curl_multi *multi; /* if non-NULL, points to the multi handle
1896: struct to which this "belongs" when used by
1897: the multi interface */
1898: struct Curl_multi *multi_easy; /* if non-NULL, points to the multi handle
1899: struct to which this "belongs" when used
1900: by the easy interface */
1901: struct Curl_share *share; /* Share, handles global variable mutexing */
1902: #ifdef USE_LIBPSL
1903: struct PslCache *psl; /* The associated PSL cache. */
1904: #endif
1905: struct SingleRequest req; /* Request-specific data */
1906: struct UserDefined set; /* values set by the libcurl user */
1907: struct DynamicStatic change; /* possibly modified userdefined data */
1908: struct CookieInfo *cookies; /* the cookies, read from files and servers.
1909: NOTE that the 'cookie' field in the
1910: UserDefined struct defines if the "engine"
1911: is to be used or not. */
1912: #ifdef USE_ALTSVC
1913: struct altsvcinfo *asi; /* the alt-svc cache */
1914: #endif
1915: struct Progress progress; /* for all the progress meter data */
1916: struct UrlState state; /* struct for fields used for state info and
1917: other dynamic purposes */
1918: #ifndef CURL_DISABLE_FTP
1919: struct WildcardData wildcard; /* wildcard download state info */
1920: #endif
1921: struct PureInfo info; /* stats, reports and info data */
1922: struct curl_tlssessioninfo tsi; /* Information about the TLS session, only
1923: valid after a client has asked for it */
1924: #if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV)
1925: iconv_t outbound_cd; /* for translating to the network encoding */
1926: iconv_t inbound_cd; /* for translating from the network encoding */
1927: iconv_t utf8_cd; /* for translating to UTF8 */
1928: #endif /* CURL_DOES_CONVERSIONS && HAVE_ICONV */
1929: unsigned int magic; /* set to a CURLEASY_MAGIC_NUMBER */
1930: };
1931:
1932: #define LIBCURL_NAME "libcurl"
1933:
1934: #endif /* HEADER_CURL_URLDATA_H */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to urldata.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib