1 #ifndef HEADER_CURL_URLDATA_H 2 #define HEADER_CURL_URLDATA_H 3 /*************************************************************************** 4 * _ _ ____ _ 5 * Project ___| | | | _ \| | 6 * / __| | | | |_) | | 7 * | (__| |_| | _ <| |___ 8 * \___|\___/|_| \_\_____| 9 * 10 * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel (at) 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 http://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 (at) 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 72 #define DEFAULT_CONNCACHE_SIZE 5 73 74 /* length of longest IPv6 address string including the trailing null */ 75 #define MAX_IPADR_LEN sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255") 76 77 /* Default FTP/IMAP etc response timeout in milliseconds. 78 Symbian OS panics when given a timeout much greater than 1/2 hour. 79 */ 80 #define RESP_TIMEOUT (1800*1000) 81 82 #include "cookie.h" 83 #include "formdata.h" 84 85 #ifdef USE_OPENSSL 86 #include <openssl/ssl.h> 87 #ifdef HAVE_OPENSSL_ENGINE_H 88 #include <openssl/engine.h> 89 #endif 90 #endif /* USE_OPENSSL */ 91 92 #ifdef USE_GNUTLS 93 #include <gnutls/gnutls.h> 94 #endif 95 96 #ifdef USE_POLARSSL 97 #include <polarssl/ssl.h> 98 #include <polarssl/version.h> 99 #if POLARSSL_VERSION_NUMBER<0x01010000 100 #include <polarssl/havege.h> 101 #else 102 #include <polarssl/entropy.h> 103 #include <polarssl/ctr_drbg.h> 104 #endif /* POLARSSL_VERSION_NUMBER<0x01010000 */ 105 #endif /* USE_POLARSSL */ 106 107 #ifdef USE_CYASSL 108 #undef OCSP_REQUEST /* avoid cyassl/openssl/ssl.h clash with wincrypt.h */ 109 #undef OCSP_RESPONSE /* avoid cyassl/openssl/ssl.h clash with wincrypt.h */ 110 #include <cyassl/openssl/ssl.h> 111 #endif 112 113 #ifdef USE_NSS 114 #include <nspr.h> 115 #include <pk11pub.h> 116 #endif 117 118 #ifdef USE_GSKIT 119 #include <gskssl.h> 120 #endif 121 122 #ifdef USE_AXTLS 123 #include <axTLS/config.h> 124 #include <axTLS/ssl.h> 125 #undef malloc 126 #undef calloc 127 #undef realloc 128 #endif /* USE_AXTLS */ 129 130 #ifdef USE_SCHANNEL 131 #include "curl_sspi.h" 132 #include <schnlsp.h> 133 #include <schannel.h> 134 #endif 135 136 #ifdef USE_DARWINSSL 137 #include <Security/Security.h> 138 /* For some reason, when building for iOS, the omnibus header above does 139 * not include SecureTransport.h as of iOS SDK 5.1. */ 140 #include <Security/SecureTransport.h> 141 #endif 142 143 #ifdef HAVE_NETINET_IN_H 144 #include <netinet/in.h> 145 #endif 146 147 #include "timeval.h" 148 149 #ifdef HAVE_ZLIB_H 150 #include <zlib.h> /* for content-encoding */ 151 #ifdef __SYMBIAN32__ 152 /* zlib pollutes the namespace with this definition */ 153 #undef WIN32 154 #endif 155 #endif 156 157 #include <curl/curl.h> 158 159 #include "http_chunks.h" /* for the structs and enum stuff */ 160 #include "hostip.h" 161 #include "hash.h" 162 #include "splay.h" 163 164 #include "imap.h" 165 #include "pop3.h" 166 #include "smtp.h" 167 #include "ftp.h" 168 #include "file.h" 169 #include "ssh.h" 170 #include "http.h" 171 #include "rtsp.h" 172 #include "smb.h" 173 #include "wildcard.h" 174 #include "multihandle.h" 175 176 #ifdef HAVE_GSSAPI 177 # ifdef HAVE_GSSGNU 178 # include <gss.h> 179 # elif defined HAVE_GSSMIT 180 # include <gssapi/gssapi.h> 181 # include <gssapi/gssapi_generic.h> 182 # else 183 # include <gssapi.h> 184 # endif 185 #endif 186 187 #ifdef HAVE_LIBSSH2_H 188 #include <libssh2.h> 189 #include <libssh2_sftp.h> 190 #endif /* HAVE_LIBSSH2_H */ 191 192 /* Download buffer size, keep it fairly big for speed reasons */ 193 #undef BUFSIZE 194 #define BUFSIZE CURL_MAX_WRITE_SIZE 195 196 /* Initial size of the buffer to store headers in, it'll be enlarged in case 197 of need. */ 198 #define HEADERSIZE 256 199 200 #define CURLEASY_MAGIC_NUMBER 0xc0dedbadU 201 202 /* Some convenience macros to get the larger/smaller value out of two given. 203 We prefix with CURL to prevent name collisions. */ 204 #define CURLMAX(x,y) ((x)>(y)?(x):(y)) 205 #define CURLMIN(x,y) ((x)<(y)?(x):(y)) 206 207 208 #ifdef HAVE_GSSAPI 209 /* Types needed for krb5-ftp connections */ 210 struct krb5buffer { 211 void *data; 212 size_t size; 213 size_t index; 214 int eof_flag; 215 }; 216 217 enum protection_level { 218 PROT_NONE, /* first in list */ 219 PROT_CLEAR, 220 PROT_SAFE, 221 PROT_CONFIDENTIAL, 222 PROT_PRIVATE, 223 PROT_CMD, 224 PROT_LAST /* last in list */ 225 }; 226 #endif 227 228 #ifdef USE_SCHANNEL 229 /* Structs to store Schannel handles */ 230 struct curl_schannel_cred { 231 CredHandle cred_handle; 232 TimeStamp time_stamp; 233 int refcount; 234 bool cached; 235 }; 236 237 struct curl_schannel_ctxt { 238 CtxtHandle ctxt_handle; 239 TimeStamp time_stamp; 240 }; 241 #endif 242 243 /* enum for the nonblocking SSL connection state machine */ 244 typedef enum { 245 ssl_connect_1, 246 ssl_connect_2, 247 ssl_connect_2_reading, 248 ssl_connect_2_writing, 249 ssl_connect_3, 250 ssl_connect_done 251 } ssl_connect_state; 252 253 typedef enum { 254 ssl_connection_none, 255 ssl_connection_negotiating, 256 ssl_connection_complete 257 } ssl_connection_state; 258 259 /* struct for data related to each SSL connection */ 260 struct ssl_connect_data { 261 /* Use ssl encrypted communications TRUE/FALSE, not necessarily using it atm 262 but at least asked to or meaning to use it. See 'state' for the exact 263 current state of the connection. */ 264 bool use; 265 ssl_connection_state state; 266 #ifdef USE_OPENSSL 267 /* these ones requires specific SSL-types */ 268 SSL_CTX* ctx; 269 SSL* handle; 270 X509* server_cert; 271 ssl_connect_state connecting_state; 272 #endif /* USE_OPENSSL */ 273 #ifdef USE_GNUTLS 274 gnutls_session_t session; 275 gnutls_certificate_credentials_t cred; 276 #ifdef USE_TLS_SRP 277 gnutls_srp_client_credentials_t srp_client_cred; 278 #endif 279 ssl_connect_state connecting_state; 280 #endif /* USE_GNUTLS */ 281 #ifdef USE_POLARSSL 282 ctr_drbg_context ctr_drbg; 283 entropy_context entropy; 284 ssl_context ssl; 285 ssl_session ssn; 286 int server_fd; 287 x509_crt cacert; 288 x509_crt clicert; 289 x509_crl crl; 290 rsa_context rsa; 291 ssl_connect_state connecting_state; 292 #endif /* USE_POLARSSL */ 293 #ifdef USE_CYASSL 294 SSL_CTX* ctx; 295 SSL* handle; 296 ssl_connect_state connecting_state; 297 #endif /* USE_CYASSL */ 298 #ifdef USE_NSS 299 PRFileDesc *handle; 300 char *client_nickname; 301 struct SessionHandle *data; 302 struct curl_llist *obj_list; 303 PK11GenericObject *obj_clicert; 304 ssl_connect_state connecting_state; 305 #endif /* USE_NSS */ 306 #ifdef USE_GSKIT 307 gsk_handle handle; 308 int iocport; 309 ssl_connect_state connecting_state; 310 #endif 311 #ifdef USE_AXTLS 312 SSL_CTX* ssl_ctx; 313 SSL* ssl; 314 ssl_connect_state connecting_state; 315 #endif /* USE_AXTLS */ 316 #ifdef USE_SCHANNEL 317 struct curl_schannel_cred *cred; 318 struct curl_schannel_ctxt *ctxt; 319 SecPkgContext_StreamSizes stream_sizes; 320 ssl_connect_state connecting_state; 321 size_t encdata_length, decdata_length; 322 size_t encdata_offset, decdata_offset; 323 unsigned char *encdata_buffer, *decdata_buffer; 324 unsigned long req_flags, ret_flags; 325 CURLcode recv_unrecoverable_err; /* schannel_recv had an unrecoverable err */ 326 bool recv_sspi_close_notify; /* true if connection closed by close_notify */ 327 bool recv_connection_closed; /* true if connection closed, regardless how */ 328 #endif /* USE_SCHANNEL */ 329 #ifdef USE_DARWINSSL 330 SSLContextRef ssl_ctx; 331 curl_socket_t ssl_sockfd; 332 ssl_connect_state connecting_state; 333 bool ssl_direction; /* true if writing, false if reading */ 334 size_t ssl_write_buffered_length; 335 #endif /* USE_DARWINSSL */ 336 }; 337 338 struct ssl_config_data { 339 long version; /* what version the client wants to use */ 340 long certverifyresult; /* result from the certificate verification */ 341 342 bool verifypeer; /* set TRUE if this is desired */ 343 bool verifyhost; /* set TRUE if CN/SAN must match hostname */ 344 bool verifystatus; /* set TRUE if certificate status must be checked */ 345 char *CApath; /* certificate dir (doesn't work on windows) */ 346 char *CAfile; /* certificate to verify peer against */ 347 const char *CRLfile; /* CRL to check certificate revocation */ 348 const char *issuercert;/* optional issuer certificate filename */ 349 char *random_file; /* path to file containing "random" data */ 350 char *egdsocket; /* path to file containing the EGD daemon socket */ 351 char *cipher_list; /* list of ciphers to use */ 352 size_t max_ssl_sessions; /* SSL session id cache size */ 353 curl_ssl_ctx_callback fsslctx; /* function to initialize ssl ctx */ 354 void *fsslctxp; /* parameter for call back */ 355 bool sessionid; /* cache session IDs or not */ 356 bool certinfo; /* gather lots of certificate info */ 357 bool falsestart; 358 359 #ifdef USE_TLS_SRP 360 char *username; /* TLS username (for, e.g., SRP) */ 361 char *password; /* TLS password (for, e.g., SRP) */ 362 enum CURL_TLSAUTH authtype; /* TLS authentication type (default SRP) */ 363 #endif 364 }; 365 366 /* information stored about one single SSL session */ 367 struct curl_ssl_session { 368 char *name; /* host name for which this ID was used */ 369 void *sessionid; /* as returned from the SSL layer */ 370 size_t idsize; /* if known, otherwise 0 */ 371 long age; /* just a number, the higher the more recent */ 372 int remote_port; /* remote port to connect to */ 373 struct ssl_config_data ssl_config; /* setup for this session */ 374 }; 375 376 /* Struct used for Digest challenge-response authentication */ 377 struct digestdata { 378 #if defined(USE_WINDOWS_SSPI) 379 BYTE *input_token; 380 size_t input_token_len; 381 #else 382 char *nonce; 383 char *cnonce; 384 char *realm; 385 int algo; 386 bool stale; /* set true for re-negotiation */ 387 char *opaque; 388 char *qop; 389 char *algorithm; 390 int nc; /* nounce count */ 391 #endif 392 }; 393 394 typedef enum { 395 NTLMSTATE_NONE, 396 NTLMSTATE_TYPE1, 397 NTLMSTATE_TYPE2, 398 NTLMSTATE_TYPE3, 399 NTLMSTATE_LAST 400 } curlntlm; 401 402 #ifdef USE_WINDOWS_SSPI 403 #include "curl_sspi.h" 404 #endif 405 406 #if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV) 407 #include <iconv.h> 408 #endif 409 410 /* Struct used for GSSAPI (Kerberos V5) authentication */ 411 #if defined(USE_KERBEROS5) 412 struct kerberos5data { 413 #if defined(USE_WINDOWS_SSPI) 414 CredHandle *credentials; 415 CtxtHandle *context; 416 TCHAR *spn; 417 SEC_WINNT_AUTH_IDENTITY identity; 418 SEC_WINNT_AUTH_IDENTITY *p_identity; 419 size_t token_max; 420 BYTE *output_token; 421 #else 422 gss_ctx_id_t context; 423 gss_name_t spn; 424 #endif 425 }; 426 #endif 427 428 /* Struct used for NTLM challenge-response authentication */ 429 #if defined(USE_NTLM) 430 struct ntlmdata { 431 curlntlm state; 432 #ifdef USE_WINDOWS_SSPI 433 CredHandle *credentials; 434 CtxtHandle *context; 435 SEC_WINNT_AUTH_IDENTITY identity; 436 SEC_WINNT_AUTH_IDENTITY *p_identity; 437 size_t token_max; 438 BYTE *output_token; 439 BYTE *input_token; 440 size_t input_token_len; 441 #else 442 unsigned int flags; 443 unsigned char nonce[8]; 444 void* target_info; /* TargetInfo received in the ntlm type-2 message */ 445 unsigned int target_info_len; 446 #endif 447 }; 448 #endif 449 450 #ifdef USE_SPNEGO 451 struct negotiatedata { 452 /* When doing Negotiate (SPNEGO) auth, we first need to send a token 453 and then validate the received one. */ 454 enum { GSS_AUTHNONE, GSS_AUTHRECV, GSS_AUTHSENT } state; 455 #ifdef HAVE_GSSAPI 456 OM_uint32 status; 457 gss_ctx_id_t context; 458 gss_name_t server_name; 459 gss_buffer_desc output_token; 460 #else 461 #ifdef USE_WINDOWS_SSPI 462 DWORD status; 463 CredHandle *credentials; 464 CtxtHandle *context; 465 SEC_WINNT_AUTH_IDENTITY identity; 466 SEC_WINNT_AUTH_IDENTITY *p_identity; 467 TCHAR *server_name; 468 size_t token_max; 469 BYTE *output_token; 470 size_t output_token_length; 471 #endif 472 #endif 473 }; 474 #endif 475 476 477 /* 478 * Boolean values that concerns this connection. 479 */ 480 struct ConnectBits { 481 /* always modify bits.close with the connclose() and connkeep() macros! */ 482 bool close; /* if set, we close the connection after this request */ 483 bool reuse; /* if set, this is a re-used connection */ 484 bool proxy; /* if set, this transfer is done through a proxy - any type */ 485 bool httpproxy; /* if set, this transfer is done through a http proxy */ 486 bool user_passwd; /* do we use user+password for this connection? */ 487 bool proxy_user_passwd; /* user+password for the proxy? */ 488 bool ipv6_ip; /* we communicate with a remote site specified with pure IPv6 489 IP address */ 490 bool ipv6; /* we communicate with a site using an IPv6 address */ 491 492 bool do_more; /* this is set TRUE if the ->curl_do_more() function is 493 supposed to be called, after ->curl_do() */ 494 bool tcpconnect[2]; /* the TCP layer (or similar) is connected, this is set 495 the first time on the first connect function call */ 496 bool protoconnstart;/* the protocol layer has STARTED its operation after 497 the TCP layer connect */ 498 499 bool retry; /* this connection is about to get closed and then 500 re-attempted at another connection. */ 501 bool tunnel_proxy; /* if CONNECT is used to "tunnel" through the proxy. 502 This is implicit when SSL-protocols are used through 503 proxies, but can also be enabled explicitly by 504 apps */ 505 bool authneg; /* TRUE when the auth phase has started, which means 506 that we are creating a request with an auth header, 507 but it is not the final request in the auth 508 negotiation. */ 509 bool rewindaftersend;/* TRUE when the sending couldn't be stopped even 510 though it will be discarded. When the whole send 511 operation is done, we must call the data rewind 512 callback. */ 513 bool ftp_use_epsv; /* As set with CURLOPT_FTP_USE_EPSV, but if we find out 514 EPSV doesn't work we disable it for the forthcoming 515 requests */ 516 517 bool ftp_use_eprt; /* As set with CURLOPT_FTP_USE_EPRT, but if we find out 518 EPRT doesn't work we disable it for the forthcoming 519 requests */ 520 bool netrc; /* name+password provided by netrc */ 521 bool userpwd_in_url; /* name+password found in url */ 522 bool stream_was_rewound; /* Indicates that the stream was rewound after a 523 request read past the end of its response byte 524 boundary */ 525 bool proxy_connect_closed; /* set true if a proxy disconnected the 526 connection in a CONNECT request with auth, so 527 that libcurl should reconnect and continue. */ 528 bool bound; /* set true if bind() has already been done on this socket/ 529 connection */ 530 bool type_set; /* type= was used in the URL */ 531 bool multiplex; /* connection is multiplexed */ 532 }; 533 534 struct hostname { 535 char *rawalloc; /* allocated "raw" version of the name */ 536 char *encalloc; /* allocated IDN-encoded version of the name */ 537 char *name; /* name to use internally, might be encoded, might be raw */ 538 const char *dispname; /* name to display, as 'name' might be encoded */ 539 }; 540 541 /* 542 * Flags on the keepon member of the Curl_transfer_keeper 543 */ 544 545 #define KEEP_NONE 0 546 #define KEEP_RECV (1<<0) /* there is or may be data to read */ 547 #define KEEP_SEND (1<<1) /* there is or may be data to write */ 548 #define KEEP_RECV_HOLD (1<<2) /* when set, no reading should be done but there 549 might still be data to read */ 550 #define KEEP_SEND_HOLD (1<<3) /* when set, no writing should be done but there 551 might still be data to write */ 552 #define KEEP_RECV_PAUSE (1<<4) /* reading is paused */ 553 #define KEEP_SEND_PAUSE (1<<5) /* writing is paused */ 554 555 #define KEEP_RECVBITS (KEEP_RECV | KEEP_RECV_HOLD | KEEP_RECV_PAUSE) 556 #define KEEP_SENDBITS (KEEP_SEND | KEEP_SEND_HOLD | KEEP_SEND_PAUSE) 557 558 559 #ifdef HAVE_LIBZ 560 typedef enum { 561 ZLIB_UNINIT, /* uninitialized */ 562 ZLIB_INIT, /* initialized */ 563 ZLIB_GZIP_HEADER, /* reading gzip header */ 564 ZLIB_GZIP_INFLATING, /* inflating gzip stream */ 565 ZLIB_INIT_GZIP /* initialized in transparent gzip mode */ 566 } zlibInitState; 567 #endif 568 569 #ifdef CURLRES_ASYNCH 570 struct Curl_async { 571 char *hostname; 572 int port; 573 struct Curl_dns_entry *dns; 574 bool done; /* set TRUE when the lookup is complete */ 575 int status; /* if done is TRUE, this is the status from the callback */ 576 void *os_specific; /* 'struct thread_data' for Windows */ 577 }; 578 #endif 579 580 #define FIRSTSOCKET 0 581 #define SECONDARYSOCKET 1 582 583 /* These function pointer types are here only to allow easier typecasting 584 within the source when we need to cast between data pointers (such as NULL) 585 and function pointers. */ 586 typedef CURLcode (*Curl_do_more_func)(struct connectdata *, int *); 587 typedef CURLcode (*Curl_done_func)(struct connectdata *, CURLcode, bool); 588 589 enum expect100 { 590 EXP100_SEND_DATA, /* enough waiting, just send the body now */ 591 EXP100_AWAITING_CONTINUE, /* waiting for the 100 Continue header */ 592 EXP100_SENDING_REQUEST, /* still sending the request but will wait for 593 the 100 header once done with the request */ 594 EXP100_FAILED /* used on 417 Expectation Failed */ 595 }; 596 597 enum upgrade101 { 598 UPGR101_INIT, /* default state */ 599 UPGR101_REQUESTED, /* upgrade requested */ 600 UPGR101_RECEIVED, /* response received */ 601 UPGR101_WORKING /* talking upgraded protocol */ 602 }; 603 604 /* 605 * Request specific data in the easy handle (SessionHandle). Previously, 606 * these members were on the connectdata struct but since a conn struct may 607 * now be shared between different SessionHandles, we store connection-specific 608 * data here. This struct only keeps stuff that's interesting for *this* 609 * request, as it will be cleared between multiple ones 610 */ 611 struct SingleRequest { 612 curl_off_t size; /* -1 if unknown at this point */ 613 curl_off_t *bytecountp; /* return number of bytes read or NULL */ 614 615 curl_off_t maxdownload; /* in bytes, the maximum amount of data to fetch, 616 -1 means unlimited */ 617 curl_off_t *writebytecountp; /* return number of bytes written or NULL */ 618 619 curl_off_t bytecount; /* total number of bytes read */ 620 curl_off_t writebytecount; /* number of bytes written */ 621 622 long headerbytecount; /* only count received headers */ 623 long deductheadercount; /* this amount of bytes doesn't count when we check 624 if anything has been transferred at the end of a 625 connection. We use this counter to make only a 626 100 reply (without a following second response 627 code) result in a CURLE_GOT_NOTHING error code */ 628 629 struct timeval start; /* transfer started at this time */ 630 struct timeval now; /* current time */ 631 bool header; /* incoming data has HTTP header */ 632 enum { 633 HEADER_NORMAL, /* no bad header at all */ 634 HEADER_PARTHEADER, /* part of the chunk is a bad header, the rest 635 is normal data */ 636 HEADER_ALLBAD /* all was believed to be header */ 637 } badheader; /* the header was deemed bad and will be 638 written as body */ 639 int headerline; /* counts header lines to better track the 640 first one */ 641 char *hbufp; /* points at *end* of header line */ 642 size_t hbuflen; 643 char *str; /* within buf */ 644 char *str_start; /* within buf */ 645 char *end_ptr; /* within buf */ 646 char *p; /* within headerbuff */ 647 bool content_range; /* set TRUE if Content-Range: was found */ 648 curl_off_t offset; /* possible resume offset read from the 649 Content-Range: header */ 650 int httpcode; /* error code from the 'HTTP/1.? XXX' or 651 'RTSP/1.? XXX' line */ 652 struct timeval start100; /* time stamp to wait for the 100 code from */ 653 enum expect100 exp100; /* expect 100 continue state */ 654 enum upgrade101 upgr101; /* 101 upgrade state */ 655 656 int auto_decoding; /* What content encoding. sec 3.5, RFC2616. */ 657 658 #define IDENTITY 0 /* No encoding */ 659 #define DEFLATE 1 /* zlib deflate [RFC 1950 & 1951] */ 660 #define GZIP 2 /* gzip algorithm [RFC 1952] */ 661 #define COMPRESS 3 /* Not handled, added for completeness */ 662 663 #ifdef HAVE_LIBZ 664 zlibInitState zlib_init; /* possible zlib init state; 665 undefined if Content-Encoding header. */ 666 z_stream z; /* State structure for zlib. */ 667 #endif 668 669 time_t timeofdoc; 670 long bodywrites; 671 672 char *buf; 673 char *uploadbuf; 674 curl_socket_t maxfd; 675 676 int keepon; 677 678 bool upload_done; /* set to TRUE when doing chunked transfer-encoding upload 679 and we're uploading the last chunk */ 680 681 bool ignorebody; /* we read a response-body but we ignore it! */ 682 bool ignorecl; /* This HTTP response has no body so we ignore the Content- 683 Length: header */ 684 685 char *location; /* This points to an allocated version of the Location: 686 header data */ 687 char *newurl; /* Set to the new URL to use when a redirect or a retry is 688 wanted */ 689 690 /* 'upload_present' is used to keep a byte counter of how much data there is 691 still left in the buffer, aimed for upload. */ 692 ssize_t upload_present; 693 694 /* 'upload_fromhere' is used as a read-pointer when we uploaded parts of a 695 buffer, so the next read should read from where this pointer points to, 696 and the 'upload_present' contains the number of bytes available at this 697 position */ 698 char *upload_fromhere; 699 700 bool chunk; /* if set, this is a chunked transfer-encoding */ 701 bool upload_chunky; /* set TRUE if we are doing chunked transfer-encoding 702 on upload */ 703 bool getheader; /* TRUE if header parsing is wanted */ 704 705 bool forbidchunk; /* used only to explicitly forbid chunk-upload for 706 specific upload buffers. See readmoredata() in 707 http.c for details. */ 708 709 void *protop; /* Allocated protocol-specific data. Each protocol 710 handler makes sure this points to data it needs. */ 711 }; 712 713 /* 714 * Specific protocol handler. 715 */ 716 717 struct Curl_handler { 718 const char * scheme; /* URL scheme name. */ 719 720 /* Complement to setup_connection_internals(). */ 721 CURLcode (*setup_connection)(struct connectdata *); 722 723 /* These two functions MUST be set to be protocol dependent */ 724 CURLcode (*do_it)(struct connectdata *, bool *done); 725 Curl_done_func done; 726 727 /* If the curl_do() function is better made in two halves, this 728 * curl_do_more() function will be called afterwards, if set. For example 729 * for doing the FTP stuff after the PASV/PORT command. 730 */ 731 Curl_do_more_func do_more; 732 733 /* This function *MAY* be set to a protocol-dependent function that is run 734 * after the connect() and everything is done, as a step in the connection. 735 * The 'done' pointer points to a bool that should be set to TRUE if the 736 * function completes before return. If it doesn't complete, the caller 737 * should call the curl_connecting() function until it is. 738 */ 739 CURLcode (*connect_it)(struct connectdata *, bool *done); 740 741 /* See above. Currently only used for FTP. */ 742 CURLcode (*connecting)(struct connectdata *, bool *done); 743 CURLcode (*doing)(struct connectdata *, bool *done); 744 745 /* Called from the multi interface during the PROTOCONNECT phase, and it 746 should then return a proper fd set */ 747 int (*proto_getsock)(struct connectdata *conn, 748 curl_socket_t *socks, 749 int numsocks); 750 751 /* Called from the multi interface during the DOING phase, and it should 752 then return a proper fd set */ 753 int (*doing_getsock)(struct connectdata *conn, 754 curl_socket_t *socks, 755 int numsocks); 756 757 /* Called from the multi interface during the DO_MORE phase, and it should 758 then return a proper fd set */ 759 int (*domore_getsock)(struct connectdata *conn, 760 curl_socket_t *socks, 761 int numsocks); 762 763 /* Called from the multi interface during the DO_DONE, PERFORM and 764 WAITPERFORM phases, and it should then return a proper fd set. Not setting 765 this will make libcurl use the generic default one. */ 766 int (*perform_getsock)(const struct connectdata *conn, 767 curl_socket_t *socks, 768 int numsocks); 769 770 /* This function *MAY* be set to a protocol-dependent function that is run 771 * by the curl_disconnect(), as a step in the disconnection. If the handler 772 * is called because the connection has been considered dead, dead_connection 773 * is set to TRUE. 774 */ 775 CURLcode (*disconnect)(struct connectdata *, bool dead_connection); 776 777 /* If used, this function gets called from transfer.c:readwrite_data() to 778 allow the protocol to do extra reads/writes */ 779 CURLcode (*readwrite)(struct SessionHandle *data, struct connectdata *conn, 780 ssize_t *nread, bool *readmore); 781 782 long defport; /* Default port. */ 783 unsigned int protocol; /* See CURLPROTO_* - this needs to be the single 784 specific protocol bit */ 785 unsigned int flags; /* Extra particular characteristics, see PROTOPT_* */ 786 }; 787 788 #define PROTOPT_NONE 0 /* nothing extra */ 789 #define PROTOPT_SSL (1<<0) /* uses SSL */ 790 #define PROTOPT_DUAL (1<<1) /* this protocol uses two connections */ 791 #define PROTOPT_CLOSEACTION (1<<2) /* need action before socket close */ 792 /* some protocols will have to call the underlying functions without regard to 793 what exact state the socket signals. IE even if the socket says "readable", 794 the send function might need to be called while uploading, or vice versa. 795 */ 796 #define PROTOPT_DIRLOCK (1<<3) 797 #define PROTOPT_NONETWORK (1<<4) /* protocol doesn't use the network! */ 798 #define PROTOPT_NEEDSPWD (1<<5) /* needs a password, and if none is set it 799 gets a default */ 800 #define PROTOPT_NOURLQUERY (1<<6) /* protocol can't handle 801 url query strings (?foo=bar) ! */ 802 #define PROTOPT_CREDSPERREQUEST (1<<7) /* requires login credentials per 803 request instead of per connection */ 804 805 806 /* return the count of bytes sent, or -1 on error */ 807 typedef ssize_t (Curl_send)(struct connectdata *conn, /* connection data */ 808 int sockindex, /* socketindex */ 809 const void *buf, /* data to write */ 810 size_t len, /* max amount to write */ 811 CURLcode *err); /* error to return */ 812 813 /* return the count of bytes read, or -1 on error */ 814 typedef ssize_t (Curl_recv)(struct connectdata *conn, /* connection data */ 815 int sockindex, /* socketindex */ 816 char *buf, /* store data here */ 817 size_t len, /* max amount to read */ 818 CURLcode *err); /* error to return */ 819 820 /* 821 * The connectdata struct contains all fields and variables that should be 822 * unique for an entire connection. 823 */ 824 struct connectdata { 825 /* 'data' is the CURRENT SessionHandle using this connection -- take great 826 caution that this might very well vary between different times this 827 connection is used! */ 828 struct SessionHandle *data; 829 830 /* chunk is for HTTP chunked encoding, but is in the general connectdata 831 struct only because we can do just about any protocol through a HTTP proxy 832 and a HTTP proxy may in fact respond using chunked encoding */ 833 struct Curl_chunker chunk; 834 835 curl_closesocket_callback fclosesocket; /* function closing the socket(s) */ 836 void *closesocket_client; 837 838 bool inuse; /* This is a marker for the connection cache logic. If this is 839 TRUE this handle is being used by an easy handle and cannot 840 be used by any other easy handle without careful 841 consideration (== only for pipelining). */ 842 843 /**** Fields set when inited and not modified again */ 844 long connection_id; /* Contains a unique number to make it easier to 845 track the connections in the log output */ 846 847 /* 'dns_entry' is the particular host we use. This points to an entry in the 848 DNS cache and it will not get pruned while locked. It gets unlocked in 849 Curl_done(). This entry will be NULL if the connection is re-used as then 850 there is no name resolve done. */ 851 struct Curl_dns_entry *dns_entry; 852 853 /* 'ip_addr' is the particular IP we connected to. It points to a struct 854 within the DNS cache, so this pointer is only valid as long as the DNS 855 cache entry remains locked. It gets unlocked in Curl_done() */ 856 Curl_addrinfo *ip_addr; 857 Curl_addrinfo *tempaddr[2]; /* for happy eyeballs */ 858 859 /* 'ip_addr_str' is the ip_addr data as a human readable string. 860 It remains available as long as the connection does, which is longer than 861 the ip_addr itself. */ 862 char ip_addr_str[MAX_IPADR_LEN]; 863 864 unsigned int scope_id; /* Scope id for IPv6 */ 865 866 int socktype; /* SOCK_STREAM or SOCK_DGRAM */ 867 868 struct hostname host; 869 struct hostname proxy; 870 871 long port; /* which port to use locally */ 872 int remote_port; /* what remote port to connect to, not the proxy port! */ 873 874 /* 'primary_ip' and 'primary_port' get filled with peer's numerical 875 ip address and port number whenever an outgoing connection is 876 *attempted* from the primary socket to a remote address. When more 877 than one address is tried for a connection these will hold data 878 for the last attempt. When the connection is actually established 879 these are updated with data which comes directly from the socket. */ 880 881 char primary_ip[MAX_IPADR_LEN]; 882 long primary_port; 883 884 /* 'local_ip' and 'local_port' get filled with local's numerical 885 ip address and port number whenever an outgoing connection is 886 **established** from the primary socket to a remote address. */ 887 888 char local_ip[MAX_IPADR_LEN]; 889 long local_port; 890 891 char *user; /* user name string, allocated */ 892 char *passwd; /* password string, allocated */ 893 char *options; /* options string, allocated */ 894 895 char *xoauth2_bearer; /* bearer token for xoauth2, allocated */ 896 897 char *proxyuser; /* proxy user name string, allocated */ 898 char *proxypasswd; /* proxy password string, allocated */ 899 curl_proxytype proxytype; /* what kind of proxy that is in use */ 900 901 int httpversion; /* the HTTP version*10 reported by the server */ 902 int rtspversion; /* the RTSP version*10 reported by the server */ 903 904 struct timeval now; /* "current" time */ 905 struct timeval created; /* creation time */ 906 curl_socket_t sock[2]; /* two sockets, the second is used for the data 907 transfer when doing FTP */ 908 curl_socket_t tempsock[2]; /* temporary sockets for happy eyeballs */ 909 bool sock_accepted[2]; /* TRUE if the socket on this index was created with 910 accept() */ 911 Curl_recv *recv[2]; 912 Curl_send *send[2]; 913 914 struct ssl_connect_data ssl[2]; /* this is for ssl-stuff */ 915 struct ssl_config_data ssl_config; 916 917 struct ConnectBits bits; /* various state-flags for this connection */ 918 919 /* connecttime: when connect() is called on the current IP address. Used to 920 be able to track when to move on to try next IP - but only when the multi 921 interface is used. */ 922 struct timeval connecttime; 923 /* The two fields below get set in Curl_connecthost */ 924 int num_addr; /* number of addresses to try to connect to */ 925 long timeoutms_per_addr; /* how long time in milliseconds to spend on 926 trying to connect to each IP address */ 927 928 const struct Curl_handler *handler; /* Connection's protocol handler */ 929 const struct Curl_handler *given; /* The protocol first given */ 930 931 long ip_version; /* copied from the SessionHandle at creation time */ 932 933 /**** curl_get() phase fields */ 934 935 curl_socket_t sockfd; /* socket to read from or CURL_SOCKET_BAD */ 936 curl_socket_t writesockfd; /* socket to write to, it may very 937 well be the same we read from. 938 CURL_SOCKET_BAD disables */ 939 940 /** Dynamicly allocated strings, MUST be freed before this **/ 941 /** struct is killed. **/ 942 struct dynamically_allocated_data { 943 char *proxyuserpwd; 944 char *uagent; 945 char *accept_encoding; 946 char *userpwd; 947 char *rangeline; 948 char *ref; 949 char *host; 950 char *cookiehost; 951 char *rtsp_transport; 952 char *te; /* TE: request header */ 953 } allocptr; 954 955 #ifdef HAVE_GSSAPI 956 int sec_complete; /* if Kerberos is enabled for this connection */ 957 enum protection_level command_prot; 958 enum protection_level data_prot; 959 enum protection_level request_data_prot; 960 size_t buffer_size; 961 struct krb5buffer in_buffer; 962 void *app_data; 963 const struct Curl_sec_client_mech *mech; 964 struct sockaddr_in local_addr; 965 #endif 966 967 #if defined(USE_KERBEROS5) /* Consider moving some of the above GSS-API */ 968 struct kerberos5data krb5; /* variables into the structure definition, */ 969 #endif /* however, some of them are ftp specific. */ 970 971 /* the two following *_inuse fields are only flags, not counters in any way. 972 If TRUE it means the channel is in use, and if FALSE it means the channel 973 is up for grabs by one. */ 974 975 bool readchannel_inuse; /* whether the read channel is in use by an easy 976 handle */ 977 bool writechannel_inuse; /* whether the write channel is in use by an easy 978 handle */ 979 struct curl_llist *send_pipe; /* List of handles waiting to 980 send on this pipeline */ 981 struct curl_llist *recv_pipe; /* List of handles waiting to read 982 their responses on this pipeline */ 983 char* master_buffer; /* The master buffer allocated on-demand; 984 used for pipelining. */ 985 size_t read_pos; /* Current read position in the master buffer */ 986 size_t buf_len; /* Length of the buffer?? */ 987 988 989 curl_seek_callback seek_func; /* function that seeks the input */ 990 void *seek_client; /* pointer to pass to the seek() above */ 991 992 /*************** Request - specific items ************/ 993 994 #if defined(USE_NTLM) 995 struct ntlmdata ntlm; /* NTLM differs from other authentication schemes 996 because it authenticates connections, not 997 single requests! */ 998 struct ntlmdata proxyntlm; /* NTLM data for proxy */ 999 1000 #if defined(NTLM_WB_ENABLED) 1001 /* used for communication with Samba's winbind daemon helper ntlm_auth */ 1002 curl_socket_t ntlm_auth_hlpr_socket; 1003 pid_t ntlm_auth_hlpr_pid; 1004 char* challenge_header; 1005 char* response_header; 1006 #endif 1007 #endif 1008 1009 char syserr_buf [256]; /* buffer for Curl_strerror() */ 1010 1011 #ifdef CURLRES_ASYNCH 1012 /* data used for the asynch name resolve callback */ 1013 struct Curl_async async; 1014 #endif 1015 1016 /* These three are used for chunked-encoding trailer support */ 1017 char *trailer; /* allocated buffer to store trailer in */ 1018 int trlMax; /* allocated buffer size */ 1019 int trlPos; /* index of where to store data */ 1020 1021 union { 1022 struct ftp_conn ftpc; 1023 struct http_conn httpc; 1024 struct ssh_conn sshc; 1025 struct tftp_state_data *tftpc; 1026 struct imap_conn imapc; 1027 struct pop3_conn pop3c; 1028 struct smtp_conn smtpc; 1029 struct rtsp_conn rtspc; 1030 struct smb_conn smbc; 1031 void *generic; /* RTMP and LDAP use this */ 1032 } proto; 1033 1034 int cselect_bits; /* bitmask of socket events */ 1035 int waitfor; /* current READ/WRITE bits to wait for */ 1036 1037 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) 1038 int socks5_gssapi_enctype; 1039 #endif 1040 1041 bool verifypeer; 1042 bool verifyhost; 1043 1044 /* When this connection is created, store the conditions for the local end 1045 bind. This is stored before the actual bind and before any connection is 1046 made and will serve the purpose of being used for comparison reasons so 1047 that subsequent bound-requested connections aren't accidentally re-using 1048 wrong connections. */ 1049 char *localdev; 1050 unsigned short localport; 1051 int localportrange; 1052 1053 /* tunnel as in tunnel through a HTTP proxy with CONNECT */ 1054 enum { 1055 TUNNEL_INIT, /* init/default/no tunnel state */ 1056 TUNNEL_CONNECT, /* CONNECT has been sent off */ 1057 TUNNEL_COMPLETE /* CONNECT response received completely */ 1058 } tunnel_state[2]; /* two separate ones to allow FTP */ 1059 struct connectbundle *bundle; /* The bundle we are member of */ 1060 1061 int negnpn; /* APLN or NPN TLS negotiated protocol, CURL_HTTP_VERSION* */ 1062 }; 1063 1064 /* The end of connectdata. */ 1065 1066 /* 1067 * Struct to keep statistical and informational data. 1068 */ 1069 struct PureInfo { 1070 int httpcode; /* Recent HTTP, FTP, or RTSP response code */ 1071 int httpproxycode; /* response code from proxy when received separate */ 1072 int httpversion; /* the http version number X.Y = X*10+Y */ 1073 long filetime; /* If requested, this is might get set. Set to -1 if the time 1074 was unretrievable. We cannot have this of type time_t, 1075 since time_t is unsigned on several platforms such as 1076 OpenVMS. */ 1077 bool timecond; /* set to TRUE if the time condition didn't match, which 1078 thus made the document NOT get fetched */ 1079 long header_size; /* size of read header(s) in bytes */ 1080 long request_size; /* the amount of bytes sent in the request(s) */ 1081 unsigned long proxyauthavail; /* what proxy auth types were announced */ 1082 unsigned long httpauthavail; /* what host auth types were announced */ 1083 long numconnects; /* how many new connection did libcurl created */ 1084 char *contenttype; /* the content type of the object */ 1085 char *wouldredirect; /* URL this would've been redirected to if asked to */ 1086 1087 /* PureInfo members 'conn_primary_ip', 'conn_primary_port', 'conn_local_ip' 1088 and, 'conn_local_port' are copied over from the connectdata struct in 1089 order to allow curl_easy_getinfo() to return this information even when 1090 the session handle is no longer associated with a connection, and also 1091 allow curl_easy_reset() to clear this information from the session handle 1092 without disturbing information which is still alive, and that might be 1093 reused, in the connection cache. */ 1094 1095 char conn_primary_ip[MAX_IPADR_LEN]; 1096 long conn_primary_port; 1097 1098 char conn_local_ip[MAX_IPADR_LEN]; 1099 long conn_local_port; 1100 1101 struct curl_certinfo certs; /* info about the certs, only populated in 1102 OpenSSL builds. Asked for with 1103 CURLOPT_CERTINFO / CURLINFO_CERTINFO */ 1104 }; 1105 1106 1107 struct Progress { 1108 long lastshow; /* time() of the last displayed progress meter or NULL to 1109 force redraw at next call */ 1110 curl_off_t size_dl; /* total expected size */ 1111 curl_off_t size_ul; /* total expected size */ 1112 curl_off_t downloaded; /* transferred so far */ 1113 curl_off_t uploaded; /* transferred so far */ 1114 1115 curl_off_t current_speed; /* uses the currently fastest transfer */ 1116 1117 bool callback; /* set when progress callback is used */ 1118 int width; /* screen width at download start */ 1119 int flags; /* see progress.h */ 1120 1121 double timespent; 1122 1123 curl_off_t dlspeed; 1124 curl_off_t ulspeed; 1125 1126 double t_nslookup; 1127 double t_connect; 1128 double t_appconnect; 1129 double t_pretransfer; 1130 double t_starttransfer; 1131 double t_redirect; 1132 1133 struct timeval start; 1134 struct timeval t_startsingle; 1135 struct timeval t_startop; 1136 struct timeval t_acceptdata; 1137 #define CURR_TIME (5+1) /* 6 entries for 5 seconds */ 1138 1139 curl_off_t speeder[ CURR_TIME ]; 1140 struct timeval speeder_time[ CURR_TIME ]; 1141 int speeder_c; 1142 }; 1143 1144 typedef enum { 1145 HTTPREQ_NONE, /* first in list */ 1146 HTTPREQ_GET, 1147 HTTPREQ_POST, 1148 HTTPREQ_POST_FORM, /* we make a difference internally */ 1149 HTTPREQ_PUT, 1150 HTTPREQ_HEAD, 1151 HTTPREQ_CUSTOM, 1152 HTTPREQ_LAST /* last in list */ 1153 } Curl_HttpReq; 1154 1155 typedef enum { 1156 RTSPREQ_NONE, /* first in list */ 1157 RTSPREQ_OPTIONS, 1158 RTSPREQ_DESCRIBE, 1159 RTSPREQ_ANNOUNCE, 1160 RTSPREQ_SETUP, 1161 RTSPREQ_PLAY, 1162 RTSPREQ_PAUSE, 1163 RTSPREQ_TEARDOWN, 1164 RTSPREQ_GET_PARAMETER, 1165 RTSPREQ_SET_PARAMETER, 1166 RTSPREQ_RECORD, 1167 RTSPREQ_RECEIVE, 1168 RTSPREQ_LAST /* last in list */ 1169 } Curl_RtspReq; 1170 1171 /* 1172 * Values that are generated, temporary or calculated internally for a 1173 * "session handle" must be defined within the 'struct UrlState'. This struct 1174 * will be used within the SessionHandle struct. When the 'SessionHandle' 1175 * struct is cloned, this data MUST NOT be copied. 1176 * 1177 * Remember that any "state" information goes globally for the curl handle. 1178 * Session-data MUST be put in the connectdata struct and here. */ 1179 #define MAX_CURL_USER_LENGTH 256 1180 #define MAX_CURL_PASSWORD_LENGTH 256 1181 1182 struct auth { 1183 unsigned long want; /* Bitmask set to the authentication methods wanted by 1184 app (with CURLOPT_HTTPAUTH or CURLOPT_PROXYAUTH). */ 1185 unsigned long picked; 1186 unsigned long avail; /* Bitmask for what the server reports to support for 1187 this resource */ 1188 bool done; /* TRUE when the auth phase is done and ready to do the *actual* 1189 request */ 1190 bool multi; /* TRUE if this is not yet authenticated but within the auth 1191 multipass negotiation */ 1192 bool iestyle; /* TRUE if digest should be done IE-style or FALSE if it should 1193 be RFC compliant */ 1194 }; 1195 1196 struct UrlState { 1197 1198 /* Points to the connection cache */ 1199 struct conncache *conn_cache; 1200 1201 /* when curl_easy_perform() is called, the multi handle is "owned" by 1202 the easy handle so curl_easy_cleanup() on such an easy handle will 1203 also close the multi handle! */ 1204 bool multi_owned_by_easy; 1205 1206 /* buffers to store authentication data in, as parsed from input options */ 1207 struct timeval keeps_speed; /* for the progress meter really */ 1208 1209 struct connectdata *lastconnect; /* The last connection, NULL if undefined */ 1210 1211 char *headerbuff; /* allocated buffer to store headers in */ 1212 size_t headersize; /* size of the allocation */ 1213 1214 char buffer[BUFSIZE+1]; /* download buffer */ 1215 char uploadbuffer[BUFSIZE+1]; /* upload buffer */ 1216 curl_off_t current_speed; /* the ProgressShow() funcion sets this, 1217 bytes / second */ 1218 bool this_is_a_follow; /* this is a followed Location: request */ 1219 1220 char *first_host; /* if set, this should be the host name that we will 1221 sent authorization to, no else. Used to make Location: 1222 following not keep sending user+password... This is 1223 strdup() data. 1224 */ 1225 struct curl_ssl_session *session; /* array of 'max_ssl_sessions' size */ 1226 long sessionage; /* number of the most recent session */ 1227 char *tempwrite; /* allocated buffer to keep data in when a write 1228 callback returns to make the connection paused */ 1229 size_t tempwritesize; /* size of the 'tempwrite' allocated buffer */ 1230 int tempwritetype; /* type of the 'tempwrite' buffer as a bitmask that is 1231 used with Curl_client_write() */ 1232 char *scratch; /* huge buffer[BUFSIZE*2] when doing upload CRLF replacing */ 1233 bool errorbuf; /* Set to TRUE if the error buffer is already filled in. 1234 This must be set to FALSE every time _easy_perform() is 1235 called. */ 1236 int os_errno; /* filled in with errno whenever an error occurs */ 1237 #ifdef HAVE_SIGNAL 1238 /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */ 1239 void (*prev_signal)(int sig); 1240 #endif 1241 bool allow_port; /* Is set.use_port allowed to take effect or not. This 1242 is always set TRUE when curl_easy_perform() is called. */ 1243 struct digestdata digest; /* state data for host Digest auth */ 1244 struct digestdata proxydigest; /* state data for proxy Digest auth */ 1245 1246 #ifdef USE_SPNEGO 1247 struct negotiatedata negotiate; /* state data for host Negotiate auth */ 1248 struct negotiatedata proxyneg; /* state data for proxy Negotiate auth */ 1249 #endif 1250 1251 struct auth authhost; /* auth details for host */ 1252 struct auth authproxy; /* auth details for proxy */ 1253 1254 bool authproblem; /* TRUE if there's some problem authenticating */ 1255 1256 void *resolver; /* resolver state, if it is used in the URL state - 1257 ares_channel f.e. */ 1258 1259 #if defined(USE_OPENSSL) && defined(HAVE_OPENSSL_ENGINE_H) 1260 ENGINE *engine; 1261 #endif /* USE_OPENSSL */ 1262 struct timeval expiretime; /* set this with Curl_expire() only */ 1263 struct Curl_tree timenode; /* for the splay stuff */ 1264 struct curl_llist *timeoutlist; /* list of pending timeouts */ 1265 1266 /* a place to store the most recently set FTP entrypath */ 1267 char *most_recent_ftp_entrypath; 1268 1269 /* set after initial USER failure, to prevent an authentication loop */ 1270 bool ftp_trying_alternative; 1271 1272 int httpversion; /* the lowest HTTP version*10 reported by any server 1273 involved in this request */ 1274 bool expect100header; /* TRUE if we added Expect: 100-continue */ 1275 1276 bool pipe_broke; /* TRUE if the connection we were pipelined on broke 1277 and we need to restart from the beginning */ 1278 1279 #if !defined(WIN32) && !defined(MSDOS) && !defined(__EMX__) && \ 1280 !defined(__SYMBIAN32__) 1281 /* do FTP line-end conversions on most platforms */ 1282 #define CURL_DO_LINEEND_CONV 1283 /* for FTP downloads: track CRLF sequences that span blocks */ 1284 bool prev_block_had_trailing_cr; 1285 /* for FTP downloads: how many CRLFs did we converted to LFs? */ 1286 curl_off_t crlf_conversions; 1287 #endif 1288 char *pathbuffer;/* allocated buffer to store the URL's path part in */ 1289 char *path; /* path to use, points to somewhere within the pathbuffer 1290 area */ 1291 bool slash_removed; /* set TRUE if the 'path' points to a path where the 1292 initial URL slash separator has been taken off */ 1293 bool use_range; 1294 bool rangestringalloc; /* the range string is malloc()'ed */ 1295 1296 char *range; /* range, if used. See README for detailed specification on 1297 this syntax. */ 1298 curl_off_t resume_from; /* continue [ftp] transfer from here */ 1299 1300 /* This RTSP state information survives requests and connections */ 1301 long rtsp_next_client_CSeq; /* the session's next client CSeq */ 1302 long rtsp_next_server_CSeq; /* the session's next server CSeq */ 1303 long rtsp_CSeq_recv; /* most recent CSeq received */ 1304 1305 curl_off_t infilesize; /* size of file to upload, -1 means unknown. 1306 Copied from set.filesize at start of operation */ 1307 1308 int drain; /* Increased when this stream has data to read, even if its 1309 socket not necessarily is readable. Decreased when 1310 checked. */ 1311 bool done; /* set to FALSE when Curl_do() is called and set to TRUE when 1312 Curl_done() is called, to prevent Curl_done() to get invoked 1313 twice when the multi interface is used. */ 1314 }; 1315 1316 1317 /* 1318 * This 'DynamicStatic' struct defines dynamic states that actually change 1319 * values in the 'UserDefined' area, which MUST be taken into consideration 1320 * if the UserDefined struct is cloned or similar. You can probably just 1321 * copy these, but each one indicate a special action on other data. 1322 */ 1323 1324 struct DynamicStatic { 1325 char *url; /* work URL, copied from UserDefined */ 1326 bool url_alloc; /* URL string is malloc()'ed */ 1327 char *referer; /* referer string */ 1328 bool referer_alloc; /* referer sting is malloc()ed */ 1329 struct curl_slist *cookielist; /* list of cookie files set by 1330 curl_easy_setopt(COOKIEFILE) calls */ 1331 struct curl_slist *resolve; /* set to point to the set.resolve list when 1332 this should be dealt with in pretransfer */ 1333 }; 1334 1335 /* 1336 * This 'UserDefined' struct must only contain data that is set once to go 1337 * for many (perhaps) independent connections. Values that are generated or 1338 * calculated internally for the "session handle" MUST be defined within the 1339 * 'struct UrlState' instead. The only exceptions MUST note the changes in 1340 * the 'DynamicStatic' struct. 1341 * Character pointer fields point to dynamic storage, unless otherwise stated. 1342 */ 1343 1344 struct Curl_multi; /* declared and used only in multi.c */ 1345 1346 enum dupstring { 1347 STRING_CERT, /* client certificate file name */ 1348 STRING_CERT_TYPE, /* format for certificate (default: PEM)*/ 1349 STRING_COOKIE, /* HTTP cookie string to send */ 1350 STRING_COOKIEJAR, /* dump all cookies to this file */ 1351 STRING_CUSTOMREQUEST, /* HTTP/FTP/RTSP request/method to use */ 1352 STRING_DEVICE, /* local network interface/address to use */ 1353 STRING_ENCODING, /* Accept-Encoding string */ 1354 STRING_FTP_ACCOUNT, /* ftp account data */ 1355 STRING_FTP_ALTERNATIVE_TO_USER, /* command to send if USER/PASS fails */ 1356 STRING_FTPPORT, /* port to send with the FTP PORT command */ 1357 STRING_KEY, /* private key file name */ 1358 STRING_KEY_PASSWD, /* plain text private key password */ 1359 STRING_KEY_TYPE, /* format for private key (default: PEM) */ 1360 STRING_KRB_LEVEL, /* krb security level */ 1361 STRING_NETRC_FILE, /* if not NULL, use this instead of trying to find 1362 $HOME/.netrc */ 1363 STRING_PROXY, /* proxy to use */ 1364 STRING_SET_RANGE, /* range, if used */ 1365 STRING_SET_REFERER, /* custom string for the HTTP referer field */ 1366 STRING_SET_URL, /* what original URL to work on */ 1367 STRING_SSL_CAPATH, /* CA directory name (doesn't work on windows) */ 1368 STRING_SSL_CAFILE, /* certificate file to verify peer against */ 1369 STRING_SSL_PINNEDPUBLICKEY, /* public key file to verify peer against */ 1370 STRING_SSL_CIPHER_LIST, /* list of ciphers to use */ 1371 STRING_SSL_EGDSOCKET, /* path to file containing the EGD daemon socket */ 1372 STRING_SSL_RANDOM_FILE, /* path to file containing "random" data */ 1373 STRING_USERAGENT, /* User-Agent string */ 1374 STRING_SSL_CRLFILE, /* crl file to check certificate */ 1375 STRING_SSL_ISSUERCERT, /* issuer cert file to check certificate */ 1376 STRING_USERNAME, /* <username>, if used */ 1377 STRING_PASSWORD, /* <password>, if used */ 1378 STRING_OPTIONS, /* <options>, if used */ 1379 STRING_PROXYUSERNAME, /* Proxy <username>, if used */ 1380 STRING_PROXYPASSWORD, /* Proxy <password>, if used */ 1381 STRING_NOPROXY, /* List of hosts which should not use the proxy, if 1382 used */ 1383 STRING_RTSP_SESSION_ID, /* Session ID to use */ 1384 STRING_RTSP_STREAM_URI, /* Stream URI for this request */ 1385 STRING_RTSP_TRANSPORT, /* Transport for this session */ 1386 #ifdef USE_LIBSSH2 1387 STRING_SSH_PRIVATE_KEY, /* path to the private key file for auth */ 1388 STRING_SSH_PUBLIC_KEY, /* path to the public key file for auth */ 1389 STRING_SSH_HOST_PUBLIC_KEY_MD5, /* md5 of host public key in ascii hex */ 1390 STRING_SSH_KNOWNHOSTS, /* file name of knownhosts file */ 1391 #endif 1392 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) 1393 STRING_SOCKS5_GSSAPI_SERVICE, /* GSSAPI service name */ 1394 STRING_PROXY_SERVICE_NAME, /* Proxy service name */ 1395 STRING_SERVICE_NAME, /* Service name */ 1396 #endif 1397 STRING_MAIL_FROM, 1398 STRING_MAIL_AUTH, 1399 1400 #ifdef USE_TLS_SRP 1401 STRING_TLSAUTH_USERNAME, /* TLS auth <username> */ 1402 STRING_TLSAUTH_PASSWORD, /* TLS auth <password> */ 1403 #endif 1404 STRING_BEARER, /* <bearer>, if used */ 1405 #ifdef USE_UNIX_SOCKETS 1406 STRING_UNIX_SOCKET_PATH, /* path to Unix socket, if used */ 1407 #endif 1408 1409 /* -- end of zero-terminated strings -- */ 1410 1411 STRING_LASTZEROTERMINATED, 1412 1413 /* -- below this are pointers to binary data that cannot be strdup'ed. 1414 Each such pointer must be added manually to Curl_dupset() --- */ 1415 1416 STRING_COPYPOSTFIELDS, /* if POST, set the fields' values here */ 1417 1418 STRING_LAST /* not used, just an end-of-list marker */ 1419 }; 1420 1421 struct UserDefined { 1422 FILE *err; /* the stderr user data goes here */ 1423 void *debugdata; /* the data that will be passed to fdebug */ 1424 char *errorbuffer; /* (Static) store failure messages in here */ 1425 long proxyport; /* If non-zero, use this port number by default. If the 1426 proxy string features a ":[port]" that one will override 1427 this. */ 1428 void *out; /* CURLOPT_WRITEDATA */ 1429 void *in; /* CURLOPT_READDATA */ 1430 void *writeheader; /* write the header to this if non-NULL */ 1431 void *rtp_out; /* write RTP to this if non-NULL */ 1432 long use_port; /* which port to use (when not using default) */ 1433 unsigned long httpauth; /* kind of HTTP authentication to use (bitmask) */ 1434 unsigned long proxyauth; /* kind of proxy authentication to use (bitmask) */ 1435 long followlocation; /* as in HTTP Location: */ 1436 long maxredirs; /* maximum no. of http(s) redirects to follow, set to -1 1437 for infinity */ 1438 1439 int keep_post; /* keep POSTs as POSTs after a 30x request; each 1440 bit represents a request, from 301 to 303 */ 1441 bool free_referer; /* set TRUE if 'referer' points to a string we 1442 allocated */ 1443 void *postfields; /* if POST, set the fields' values here */ 1444 curl_seek_callback seek_func; /* function that seeks the input */ 1445 curl_off_t postfieldsize; /* if POST, this might have a size to use instead 1446 of strlen(), and then the data *may* be binary 1447 (contain zero bytes) */ 1448 unsigned short localport; /* local port number to bind to */ 1449 int localportrange; /* number of additional port numbers to test in case the 1450 'localport' one can't be bind()ed */ 1451 curl_write_callback fwrite_func; /* function that stores the output */ 1452 curl_write_callback fwrite_header; /* function that stores headers */ 1453 curl_write_callback fwrite_rtp; /* function that stores interleaved RTP */ 1454 curl_read_callback fread_func; /* function that reads the input */ 1455 int is_fread_set; /* boolean, has read callback been set to non-NULL? */ 1456 int is_fwrite_set; /* boolean, has write callback been set to non-NULL? */ 1457 curl_progress_callback fprogress; /* OLD and deprecated progress callback */ 1458 curl_xferinfo_callback fxferinfo; /* progress callback */ 1459 curl_debug_callback fdebug; /* function that write informational data */ 1460 curl_ioctl_callback ioctl_func; /* function for I/O control */ 1461 curl_sockopt_callback fsockopt; /* function for setting socket options */ 1462 void *sockopt_client; /* pointer to pass to the socket options callback */ 1463 curl_opensocket_callback fopensocket; /* function for checking/translating 1464 the address and opening the 1465 socket */ 1466 void* opensocket_client; 1467 curl_closesocket_callback fclosesocket; /* function for closing the 1468 socket */ 1469 void* closesocket_client; 1470 1471 void *seek_client; /* pointer to pass to the seek callback */ 1472 /* the 3 curl_conv_callback functions below are used on non-ASCII hosts */ 1473 /* function to convert from the network encoding: */ 1474 curl_conv_callback convfromnetwork; 1475 /* function to convert to the network encoding: */ 1476 curl_conv_callback convtonetwork; 1477 /* function to convert from UTF-8 encoding: */ 1478 curl_conv_callback convfromutf8; 1479 1480 void *progress_client; /* pointer to pass to the progress callback */ 1481 void *ioctl_client; /* pointer to pass to the ioctl callback */ 1482 long timeout; /* in milliseconds, 0 means no timeout */ 1483 long connecttimeout; /* in milliseconds, 0 means no timeout */ 1484 long accepttimeout; /* in milliseconds, 0 means no timeout */ 1485 long server_response_timeout; /* in milliseconds, 0 means no timeout */ 1486 long tftp_blksize ; /* in bytes, 0 means use default */ 1487 curl_off_t filesize; /* size of file to upload, -1 means unknown */ 1488 long low_speed_limit; /* bytes/second */ 1489 long low_speed_time; /* number of seconds */ 1490 curl_off_t max_send_speed; /* high speed limit in bytes/second for upload */ 1491 curl_off_t max_recv_speed; /* high speed limit in bytes/second for 1492 download */ 1493 curl_off_t set_resume_from; /* continue [ftp] transfer from here */ 1494 struct curl_slist *headers; /* linked list of extra headers */ 1495 struct curl_slist *proxyheaders; /* linked list of extra CONNECT headers */ 1496 struct curl_httppost *httppost; /* linked list of POST data */ 1497 bool sep_headers; /* handle host and proxy headers separately */ 1498 bool cookiesession; /* new cookie session? */ 1499 bool crlf; /* convert crlf on ftp upload(?) */ 1500 struct curl_slist *quote; /* after connection is established */ 1501 struct curl_slist *postquote; /* after the transfer */ 1502 struct curl_slist *prequote; /* before the transfer, after type */ 1503 struct curl_slist *source_quote; /* 3rd party quote */ 1504 struct curl_slist *source_prequote; /* in 3rd party transfer mode - before 1505 the transfer on source host */ 1506 struct curl_slist *source_postquote; /* in 3rd party transfer mode - after 1507 the transfer on source host */ 1508 struct curl_slist *telnet_options; /* linked list of telnet options */ 1509 struct curl_slist *resolve; /* list of names to add/remove from 1510 DNS cache */ 1511 curl_TimeCond timecondition; /* kind of time/date comparison */ 1512 time_t timevalue; /* what time to compare with */ 1513 Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */ 1514 long httpversion; /* when non-zero, a specific HTTP version requested to 1515 be used in the library's request(s) */ 1516 struct ssl_config_data ssl; /* user defined SSL stuff */ 1517 curl_proxytype proxytype; /* what kind of proxy that is in use */ 1518 long dns_cache_timeout; /* DNS cache timeout */ 1519 long buffer_size; /* size of receive buffer to use */ 1520 void *private_data; /* application-private data */ 1521 1522 struct curl_slist *http200aliases; /* linked list of aliases for http200 */ 1523 1524 long ipver; /* the CURL_IPRESOLVE_* defines in the public header file 1525 0 - whatever, 1 - v2, 2 - v6 */ 1526 1527 curl_off_t max_filesize; /* Maximum file size to download */ 1528 1529 curl_ftpfile ftp_filemethod; /* how to get to a file when FTP is used */ 1530 1531 int ftp_create_missing_dirs; /* 1 - create directories that don't exist 1532 2 - the same but also allow MKD to fail once 1533 */ 1534 1535 curl_sshkeycallback ssh_keyfunc; /* key matching callback */ 1536 void *ssh_keyfunc_userp; /* custom pointer to callback */ 1537 1538 /* Here follows boolean settings that define how to behave during 1539 this session. They are STATIC, set by libcurl users or at least initially 1540 and they don't change during operations. */ 1541 1542 bool printhost; /* printing host name in debug info */ 1543 bool get_filetime; /* get the time and get of the remote file */ 1544 bool tunnel_thru_httpproxy; /* use CONNECT through a HTTP proxy */ 1545 bool prefer_ascii; /* ASCII rather than binary */ 1546 bool ftp_append; /* append, not overwrite, on upload */ 1547 bool ftp_list_only; /* switch FTP command for listing directories */ 1548 bool ftp_use_port; /* use the FTP PORT command */ 1549 bool hide_progress; /* don't use the progress meter */ 1550 bool http_fail_on_error; /* fail on HTTP error codes >= 400 */ 1551 bool http_follow_location; /* follow HTTP redirects */ 1552 bool http_transfer_encoding; /* request compressed HTTP transfer-encoding */ 1553 bool http_disable_hostname_check_before_authentication; 1554 bool include_header; /* include received protocol headers in data output */ 1555 bool http_set_referer; /* is a custom referer used */ 1556 bool http_auto_referer; /* set "correct" referer when following location: */ 1557 bool opt_no_body; /* as set with CURLOPT_NOBODY */ 1558 bool set_port; /* custom port number used */ 1559 bool upload; /* upload request */ 1560 enum CURL_NETRC_OPTION 1561 use_netrc; /* defined in include/curl.h */ 1562 bool verbose; /* output verbosity */ 1563 bool krb; /* Kerberos connection requested */ 1564 bool reuse_forbid; /* forbidden to be reused, close after use */ 1565 bool reuse_fresh; /* do not re-use an existing connection */ 1566 bool ftp_use_epsv; /* if EPSV is to be attempted or not */ 1567 bool ftp_use_eprt; /* if EPRT is to be attempted or not */ 1568 bool ftp_use_pret; /* if PRET is to be used before PASV or not */ 1569 1570 curl_usessl use_ssl; /* if AUTH TLS is to be attempted etc, for FTP or 1571 IMAP or POP3 or others! */ 1572 curl_ftpauth ftpsslauth; /* what AUTH XXX to be attempted */ 1573 curl_ftpccc ftp_ccc; /* FTP CCC options */ 1574 bool no_signal; /* do not use any signal/alarm handler */ 1575 bool global_dns_cache; /* subject for future removal */ 1576 bool tcp_nodelay; /* whether to enable TCP_NODELAY or not */ 1577 bool ignorecl; /* ignore content length */ 1578 bool ftp_skip_ip; /* skip the IP address the FTP server passes on to 1579 us */ 1580 bool connect_only; /* make connection, let application use the socket */ 1581 bool ssl_enable_beast; /* especially allow this flaw for interoperability's 1582 sake*/ 1583 long ssh_auth_types; /* allowed SSH auth types */ 1584 bool http_te_skip; /* pass the raw body data to the user, even when 1585 transfer-encoded (chunked, compressed) */ 1586 bool http_ce_skip; /* pass the raw body data to the user, even when 1587 content-encoded (chunked, compressed) */ 1588 long new_file_perms; /* Permissions to use when creating remote files */ 1589 long new_directory_perms; /* Permissions to use when creating remote dirs */ 1590 bool proxy_transfer_mode; /* set transfer mode (;type=<a|i>) when doing FTP 1591 via an HTTP proxy */ 1592 char *str[STRING_LAST]; /* array of strings, pointing to allocated memory */ 1593 unsigned int scope_id; /* Scope id for IPv6 */ 1594 long allowed_protocols; 1595 long redir_protocols; 1596 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) 1597 long socks5_gssapi_nec; /* flag to support nec socks5 server */ 1598 #endif 1599 struct curl_slist *mail_rcpt; /* linked list of mail recipients */ 1600 bool sasl_ir; /* Enable/disable SASL initial response */ 1601 /* Common RTSP header options */ 1602 Curl_RtspReq rtspreq; /* RTSP request type */ 1603 long rtspversion; /* like httpversion, for RTSP */ 1604 bool wildcardmatch; /* enable wildcard matching */ 1605 curl_chunk_bgn_callback chunk_bgn; /* called before part of transfer 1606 starts */ 1607 curl_chunk_end_callback chunk_end; /* called after part transferring 1608 stopped */ 1609 curl_fnmatch_callback fnmatch; /* callback to decide which file corresponds 1610 to pattern (e.g. if WILDCARDMATCH is on) */ 1611 void *fnmatch_data; 1612 1613 long gssapi_delegation; /* GSS-API credential delegation, see the 1614 documentation of CURLOPT_GSSAPI_DELEGATION */ 1615 1616 bool tcp_keepalive; /* use TCP keepalives */ 1617 long tcp_keepidle; /* seconds in idle before sending keepalive probe */ 1618 long tcp_keepintvl; /* seconds between TCP keepalive probes */ 1619 1620 size_t maxconnects; /* Max idle connections in the connection cache */ 1621 1622 bool ssl_enable_npn; /* TLS NPN extension? */ 1623 bool ssl_enable_alpn; /* TLS ALPN extension? */ 1624 bool path_as_is; /* allow dotdots? */ 1625 bool pipewait; /* wait for pipe/multiplex status before starting a 1626 new connection */ 1627 long expect_100_timeout; /* in milliseconds */ 1628 }; 1629 1630 struct Names { 1631 struct curl_hash *hostcache; 1632 enum { 1633 HCACHE_NONE, /* not pointing to anything */ 1634 HCACHE_GLOBAL, /* points to the (shrug) global one */ 1635 HCACHE_MULTI, /* points to a shared one in the multi handle */ 1636 HCACHE_SHARED /* points to a shared one in a shared object */ 1637 } hostcachetype; 1638 }; 1639 1640 /* 1641 * The 'connectdata' struct MUST have all the connection oriented stuff as we 1642 * may have several simultaneous connections and connection structs in memory. 1643 * 1644 * The 'struct UserDefined' must only contain data that is set once to go for 1645 * many (perhaps) independent connections. Values that are generated or 1646 * calculated internally for the "session handle" must be defined within the 1647 * 'struct UrlState' instead. 1648 */ 1649 1650 struct SessionHandle { 1651 /* first, two fields for the linked list of these */ 1652 struct SessionHandle *next; 1653 struct SessionHandle *prev; 1654 1655 struct connectdata *easy_conn; /* the "unit's" connection */ 1656 1657 CURLMstate mstate; /* the handle's state */ 1658 CURLcode result; /* previous result */ 1659 1660 struct Curl_message msg; /* A single posted message. */ 1661 1662 /* Array with the plain socket numbers this handle takes care of, in no 1663 particular order. Note that all sockets are added to the sockhash, where 1664 the state etc are also kept. This array is mostly used to detect when a 1665 socket is to be removed from the hash. See singlesocket(). */ 1666 curl_socket_t sockets[MAX_SOCKSPEREASYHANDLE]; 1667 int numsocks; 1668 1669 struct Names dns; 1670 struct Curl_multi *multi; /* if non-NULL, points to the multi handle 1671 struct to which this "belongs" when used by 1672 the multi interface */ 1673 struct Curl_multi *multi_easy; /* if non-NULL, points to the multi handle 1674 struct to which this "belongs" when used 1675 by the easy interface */ 1676 struct Curl_share *share; /* Share, handles global variable mutexing */ 1677 struct SingleRequest req; /* Request-specific data */ 1678 struct UserDefined set; /* values set by the libcurl user */ 1679 struct DynamicStatic change; /* possibly modified userdefined data */ 1680 struct CookieInfo *cookies; /* the cookies, read from files and servers. 1681 NOTE that the 'cookie' field in the 1682 UserDefined struct defines if the "engine" 1683 is to be used or not. */ 1684 struct Progress progress; /* for all the progress meter data */ 1685 struct UrlState state; /* struct for fields used for state info and 1686 other dynamic purposes */ 1687 struct WildcardData wildcard; /* wildcard download state info */ 1688 struct PureInfo info; /* stats, reports and info data */ 1689 struct curl_tlssessioninfo tsi; /* Information about the TLS session, only 1690 valid after a client has asked for it */ 1691 #if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV) 1692 iconv_t outbound_cd; /* for translating to the network encoding */ 1693 iconv_t inbound_cd; /* for translating from the network encoding */ 1694 iconv_t utf8_cd; /* for translating to UTF8 */ 1695 #endif /* CURL_DOES_CONVERSIONS && HAVE_ICONV */ 1696 unsigned int magic; /* set to a CURLEASY_MAGIC_NUMBER */ 1697 }; 1698 1699 #define LIBCURL_NAME "libcurl" 1700 1701 #endif /* HEADER_CURL_URLDATA_H */ 1702
