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