3 /*****************************************************************************
5 * Project ___| | | | _ \| |
7 * | (__| |_| | _ <| |___
8 * \___|\___/|_| \_\_____|
10 * Copyright (C) 1998 - 2002, Daniel Stenberg, <daniel@haxx.se>, et al.
12 * In order to be useful for every potential user, curl and libcurl are
13 * dual-licensed under the MPL and the MIT/X-derivate licenses.
15 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
16 * copies of the Software, and permit persons to whom the Software is
17 * furnished to do so, under the terms of the MPL or the MIT/X-derivate
18 * licenses. You may pick one of these licenses.
20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 * KIND, either express or implied.
24 *****************************************************************************/
26 /* This file is for lib internal stuff */
33 #define PORT_TELNET 23
34 #define PORT_GOPHER 70
36 #define PORT_HTTPS 443
37 #define PORT_DICT 2628
40 #define DICT_MATCH "/MATCH:"
41 #define DICT_MATCH2 "/M:"
42 #define DICT_MATCH3 "/FIND:"
43 #define DICT_DEFINE "/DEFINE:"
44 #define DICT_DEFINE2 "/D:"
45 #define DICT_DEFINE3 "/LOOKUP:"
47 #define CURL_DEFAULT_USER "anonymous"
48 #define CURL_DEFAULT_PASSWORD "curl_by_daniel@haxx.se"
54 /* SSLeay stuff usually in /usr/local/ssl/include */
56 #include "openssl/rsa.h"
57 #include "openssl/crypto.h"
58 #include "openssl/x509.h"
59 #include "openssl/pem.h"
60 #include "openssl/ssl.h"
61 #include "openssl/err.h"
62 #ifdef HAVE_OPENSSL_ENGINE_H
63 #include <openssl/engine.h>
75 #ifdef HAVE_NETINET_IN_H
76 #include <netinet/in.h>
81 #include <curl/curl.h>
83 #include "http_chunks.h" /* for the structs and enum stuff */
85 /* Download buffer size, keep it fairly big for speed reasons */
86 #define BUFSIZE (1024*20)
88 /* Initial size of the buffer to store headers in, it'll be enlarged in case
90 #define HEADERSIZE 256
92 /* Just a convenience macro to get the larger value out of two given */
94 #define MAX(x,y) ((x)>(y)?(x):(y))
98 /* Types needed for krb4-ftp connections */
105 enum protection_level {
113 #ifndef HAVE_OPENSSL_ENGINE_H
116 /* struct for data related to SSL and SSL connections */
117 struct ssl_connect_data {
118 bool use; /* use ssl encrypted communications TRUE/FALSE */
120 /* these ones requires specific SSL-types */
124 #endif /* USE_SSLEAY */
127 /* information about one single SSL session */
128 struct curl_ssl_session {
129 char *name; /* host name for which this ID was used */
130 void *sessionid; /* as returned from the SSL layer */
131 long age; /* just a number, the higher the more recent */
132 unsigned short remote_port; /* remote port to connect to */
135 struct ssl_config_data {
136 long version; /* what version the client wants to use */
137 long certverifyresult; /* result from the certificate verification */
138 long verifypeer; /* set TRUE if this is desired */
139 long verifyhost; /* 0: no verif, 1: check that CN exists, 2: CN must match hostname */
140 char *CApath; /* DOES NOT WORK ON WINDOWS */
141 char *CAfile; /* cerficate to verify peer against */
142 char *random_file; /* path to file containing "random" data */
143 char *egdsocket; /* path to file containing the EGD daemon socket */
144 char *cipher_list; /* list of ciphers to use */
146 long numsessions; /* SSL session id cache size */
149 /****************************************************************************
151 ***************************************************************************/
153 struct FormData *sendit;
155 const char *p_pragma; /* Pragma: string */
156 const char *p_accept; /* Accept: string */
160 /* For FORM posting */
162 curl_read_callback storefread;
165 struct Curl_chunker chunk;
168 /****************************************************************************
170 ***************************************************************************/
173 char *user; /* user name string */
174 char *passwd; /* password string */
175 char *urlpath; /* the originally given path part of the URL */
176 char *dir; /* decoded directory */
177 char *file; /* decoded file */
179 char *entrypath; /* the PWD reply when we logged on */
181 char *cache; /* data cache between getresponse()-calls */
182 size_t cache_size; /* size of cache in bytes */
185 /****************************************************************************
187 ***************************************************************************/
189 int fd; /* open file descriptor to read from! */
193 * Boolean values that concerns this connection.
196 bool close; /* if set, we close the connection after this request */
197 bool reuse; /* if set, this is a re-used connection */
198 bool chunk; /* if set, this is a chunked transfer-encoding */
199 bool httpproxy; /* if set, this transfer is done through a http proxy */
200 bool user_passwd; /* do we use user+password for this connection? */
201 bool proxy_user_passwd; /* user+password for the proxy? */
204 bool rangestringalloc; /* the range string is malloc()'ed */
206 bool resume_done; /* nothing was transfered, resumed transfer already
211 * This struct is all the previously local variables from Curl_perform() moved
212 * to struct to allow the function to return and get re-invoked better without
216 struct Curl_transfer_keeper {
217 int bytecount; /* total number of bytes read */
218 int writebytecount; /* number of bytes written */
219 long contentlength; /* size of incoming data */
220 struct timeval start; /* transfer started at this time */
221 struct timeval now; /* current time */
222 bool header; /* incoming data has HTTP header */
223 int headerline; /* counts header lines to better track the
225 char *hbufp; /* points at *end* of header line */
227 char *str; /* within buf */
228 char *str_start; /* within buf */
229 char *end_ptr; /* within buf */
230 char *p; /* within headerbuff */
231 bool content_range; /* set TRUE if Content-Range: was found */
232 int offset; /* possible resume offset read from the
233 Content-Range: header */
234 int httpcode; /* error code from the 'HTTP/1.? XXX' line */
235 int httpversion; /* the HTTP version*10 */
236 bool write_after_100_header; /* should we enable the write after
237 we received a 100-continue/timeout
240 /* for the low speed checks: */
245 /* the highest fd we use + 1 */
246 struct SessionHandle *data;
247 struct connectdata *conn;
252 /* the file descriptors to play with */
263 * The connectdata struct contains all fields and variables that should be
264 * unique for an entire connection.
267 /**** Fields set when inited and not modified again */
268 struct SessionHandle *data; /* link to the root CURL struct */
269 int connectindex; /* what index in the connects index this particular
272 long protocol; /* PROT_* flags concerning the protocol set */
273 #define PROT_MISSING (1<<0)
274 #define PROT_GOPHER (1<<1)
275 #define PROT_HTTP (1<<2)
276 #define PROT_HTTPS (1<<3)
277 #define PROT_FTP (1<<4)
278 #define PROT_TELNET (1<<5)
279 #define PROT_DICT (1<<6)
280 #define PROT_LDAP (1<<7)
281 #define PROT_FILE (1<<8)
282 #define PROT_FTPS (1<<9)
283 #define PROT_SSL (1<<10) /* protocol requires SSL */
285 Curl_addrinfo *hostaddr; /* IP-protocol independent host info pointer list */
286 char *hostent_buf; /* pointer to allocated memory for name info */
289 struct addrinfo *serv_addr; /* the particular host we use */
291 struct sockaddr_in serv_addr;
293 char protostr[64]; /* store the protocol string in this buffer */
294 char gname[513]; /* store the hostname in this buffer */
295 char *name; /* host name pointer to fool around with */
296 char *path; /* allocated buffer to store the URL's path part in */
297 char *hostname; /* hostname to connect, as parsed from url */
298 long port; /* which port to use locally */
299 unsigned short remote_port; /* what remote port to connect to,
300 not the proxy port! */
303 long headerbytecount; /* only count received headers */
305 char *range; /* range, if used. See README for detailed specification on
307 ssize_t resume_from; /* continue [ftp] transfer from here */
309 char *proxyhost; /* name of the http proxy host */
311 struct timeval now; /* "current" time */
312 struct timeval created; /* creation time */
313 int firstsocket; /* the main socket to use */
314 int secondarysocket; /* for i.e ftp transfers */
315 long maxdownload; /* in bytes, the maximum amount of data to fetch, 0
318 struct ssl_connect_data ssl; /* this is for ssl-stuff */
320 struct ConnectBits bits; /* various state-flags for this connection */
322 /* These two functions MUST be set by the curl_connect() function to be
323 be protocol dependent */
324 CURLcode (*curl_do)(struct connectdata *connect);
325 CURLcode (*curl_done)(struct connectdata *connect);
327 /* This function *MAY* be set to a protocol-dependent function that is run
328 * after the connect() and everything is done, as a step in the connection.
330 CURLcode (*curl_connect)(struct connectdata *connect);
332 /* This function *MAY* be set to a protocol-dependent function that is run
333 * by the curl_disconnect(), as a step in the disconnection.
335 CURLcode (*curl_disconnect)(struct connectdata *connect);
337 /* This function *MAY* be set to a protocol-dependent function that is run
338 * in the curl_close() function if protocol-specific cleanups are required.
340 CURLcode (*curl_close)(struct connectdata *connect);
342 /**** curl_get() phase fields */
345 int sockfd; /* socket to read from or -1 */
346 int size; /* -1 if unknown at this point */
347 bool getheader; /* TRUE if header parsing is wanted */
348 long *bytecountp; /* return number of bytes read or NULL */
351 int writesockfd; /* socket to write to, it may very well be
352 the same we read from. -1 disables */
353 long *writebytecountp; /* return number of bytes written or NULL */
355 /** Dynamicly allocated strings, may need to be freed before this **/
356 /** struct is killed. **/
357 struct dynamically_allocated_data {
358 char *proxyuserpwd; /* free later if not NULL! */
359 char *uagent; /* free later if not NULL! */
360 char *userpwd; /* free later if not NULL! */
361 char *rangeline; /* free later if not NULL! */
362 char *ref; /* free later if not NULL! */
363 char *cookie; /* free later if not NULL! */
364 char *host; /* free later if not NULL */
367 char *newurl; /* This can only be set if a Location: was in the
371 enum protection_level command_prot;
372 enum protection_level data_prot;
373 enum protection_level request_data_prot;
377 struct krb4buffer in_buffer, out_buffer;
381 struct Curl_sec_client_mech *mech;
382 struct sockaddr_in local_addr;
386 /*************** Request - specific items ************/
387 /* previously this was in the urldata struct */
390 struct HTTP *gopher; /* alias, just for the sake of being more readable */
391 struct HTTP *https; /* alias, just for the sake of being more readable */
394 void *telnet; /* private for telnet.c-eyes only */
395 #if 0 /* no need for special ones for these: */
402 /* This struct is inited when needed */
403 struct Curl_transfer_keeper keep;
405 /* 'upload_present' is used to keep a byte counter of how much data there is
406 still left in the buffer, aimed for upload. */
409 /* 'upload_fromhere' is used as a read-pointer when we uploaded parts of a
410 buffer, so the next read should read from where this pointer points to,
411 and the 'upload_present' contains the number of bytes available at this
413 char *upload_fromhere;
417 * Struct to keep statistical and informational data.
422 long filetime; /* If requested, this is might get set. Set to -1 if
423 the time was unretrievable */
424 long header_size; /* size of read header(s) in bytes */
425 long request_size; /* the amount of bytes sent in the request(s) */
427 char *contenttype; /* the content type of the object */
432 long lastshow; /* time() of the last displayed progress meter or NULL to
433 force redraw at next call */
439 double current_speed; /* uses the currently fastest transfer */
441 bool callback; /* set when progress callback is used */
442 int width; /* screen width at download start */
443 int flags; /* see progress.h */
452 double t_pretransfer;
453 double t_starttransfer;
455 struct timeval start;
456 struct timeval t_startsingle;
457 #define CURR_TIME (5+1) /* 6 entries for 5 seconds */
459 double speeder[ CURR_TIME ];
460 struct timeval speeder_time[ CURR_TIME ];
465 HTTPREQ_NONE, /* first in list */
468 HTTPREQ_POST_FORM, /* we make a difference internally */
471 HTTPREQ_LAST /* last in list */
475 * Values that are generated, temporary or calculated internally for a
476 * "session handle" must be defined within the 'struct urlstate'. This struct
477 * will be used within the SessionHandle struct. When the 'SessionHandle'
478 * struct is cloned, this data MUST NOT be copied.
480 * Remember that any "state" information goes globally for the curl handle.
481 * Session-data MUST be put in the connectdata struct and here. */
482 #define MAX_CURL_USER_LENGTH 256
483 #define MAX_CURL_PASSWORD_LENGTH 256
486 /* buffers to store authentication data in, as parsed from input options */
487 char user[MAX_CURL_USER_LENGTH];
488 char passwd[MAX_CURL_PASSWORD_LENGTH];
489 char proxyuser[MAX_CURL_USER_LENGTH];
490 char proxypasswd[MAX_CURL_PASSWORD_LENGTH];
492 struct timeval keeps_speed; /* for the progress meter really */
494 /* 'connects' will be an allocated array with pointers. If the pointer is
495 set, it holds an allocated connection. */
496 struct connectdata **connects;
497 long numconnects; /* size of the 'connects' array */
499 char *headerbuff; /* allocated buffer to store headers in */
500 int headersize; /* size of the allocation */
502 char buffer[BUFSIZE+1]; /* download buffer */
503 char uploadbuffer[BUFSIZE+1]; /* upload buffer */
504 double current_speed; /* the ProgressShow() funcion sets this */
506 bool this_is_a_follow; /* this is a followed Location: request */
508 char *auth_host; /* if set, this should be the host name that we will
509 sent authorization to, no else. Used to make Location:
510 following not keep sending user+password... This is
514 struct curl_ssl_session *session; /* array of 'numsessions' size */
515 long sessionage; /* number of the most recent session */
517 char scratch[BUFSIZE*2]; /* huge buffer when doing upload CRLF replacing */
518 bool errorbuf; /* Set to TRUE if the error buffer is already filled in.
519 This must be set to FALSE every time _easy_perform() is
523 /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */
524 void (*prev_signal)(int sig);
526 bool allow_port; /* Is set.use_port allowed to take effect or not. This
527 is always set TRUE when curl_easy_perform() is called. */
532 * This 'DynamicStatic' struct defines dynamic states that actually change
533 * values in the 'UserDefined' area, which MUST be taken into consideration
534 * if the UserDefined struct is cloned or similar. You can probably just
535 * copy these, but each one indicate a special action on other data.
538 struct DynamicStatic {
539 char *url; /* work URL, copied from UserDefined */
540 bool url_alloc; /* URL string is malloc()'ed */
541 char *proxy; /* work proxy, copied from UserDefined */
542 bool proxy_alloc; /* http proxy string is malloc()'ed */
543 char *referer; /* referer string */
544 bool referer_alloc; /* referer sting is malloc()ed */
548 * This 'UserDefined' struct must only contain data that is set once to go
549 * for many (perhaps) independent connections. Values that are generated or
550 * calculated internally for the "session handle" MUST be defined within the
551 * 'struct urlstate' instead. The only exceptions MUST note the changes in
552 * the 'DynamicStatic' struct.
556 FILE *err; /* the stderr user data goes here */
557 void *debugdata; /* the data that will be passed to fdebug */
558 char *errorbuffer; /* store failure messages in here */
559 char *proxyuserpwd; /* Proxy <user:password>, if used */
560 long proxyport; /* If non-zero, use this port number by default. If the
561 proxy string features a ":[port]" that one will override
563 void *out; /* the fetched file goes here */
564 void *in; /* the uploaded file is read from here */
565 void *writeheader; /* write the header to this is non-NULL */
566 char *set_url; /* what original URL to work on */
567 char *set_proxy; /* proxy to use */
568 long use_port; /* which port to use (when not using default) */
569 char *userpwd; /* <user:password>, if used */
570 char *set_range; /* range, if used. See README for detailed specification
572 long followlocation; /* as in HTTP Location: */
573 long maxredirs; /* maximum no. of http(s) redirects to follow */
574 char *set_referer; /* custom string */
575 bool free_referer; /* set TRUE if 'referer' points to a string we
577 char *useragent; /* User-Agent string */
578 char *postfields; /* if POST, set the fields' values here */
579 size_t postfieldsize; /* if POST, this might have a size to use instead of
580 strlen(), and then the data *may* be binary (contain
582 char *ftpport; /* port to send with the FTP PORT command */
583 char *device; /* network interface to use */
584 curl_write_callback fwrite; /* function that stores the output */
585 curl_write_callback fwrite_header; /* function that stores headers */
586 curl_read_callback fread; /* function that reads the input */
587 curl_progress_callback fprogress; /* function for progress information */
588 curl_debug_callback fdebug; /* function that write informational data */
589 void *progress_client; /* pointer to pass to the progress callback */
590 curl_passwd_callback fpasswd; /* call for password */
591 void *passwd_client; /* pass to the passwd callback */
592 long timeout; /* in seconds, 0 means no timeout */
593 long connecttimeout; /* in seconds, 0 means no timeout */
594 long infilesize; /* size of file to upload, -1 means unknown */
595 long low_speed_limit; /* bytes/second */
596 long low_speed_time; /* number of seconds */
597 int set_resume_from; /* continue [ftp] transfer from here */
598 char *cookie; /* HTTP cookie string to send */
599 struct curl_slist *headers; /* linked list of extra headers */
600 struct HttpPost *httppost; /* linked list of POST data */
601 char *cert; /* certificate */
602 char *cert_type; /* format for certificate (default: PEM) */
603 char *key; /* private key */
604 char *key_type; /* format for private key (default: PEM) */
605 char *key_passwd; /* plain text private key password */
606 char *crypto_engine; /* name of the crypto engine to use */
607 char *cookiejar; /* dump all cookies to this file */
608 bool crlf; /* convert crlf on ftp upload(?) */
609 struct curl_slist *quote; /* after connection is established */
610 struct curl_slist *postquote; /* after the transfer */
611 struct curl_slist *prequote; /* before the transfer, after type (Wesley Laxton)*/
612 struct curl_slist *telnet_options; /* linked list of telnet options */
613 curl_TimeCond timecondition; /* kind of time/date comparison */
614 time_t timevalue; /* what time to compare with */
615 curl_closepolicy closepolicy; /* connection cache close concept */
616 Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */
617 char *customrequest; /* HTTP/FTP request to use */
618 long httpversion; /* when non-zero, a specific HTTP version requested to
619 be used in the library's request(s) */
620 char *auth_host; /* if set, this is the allocated string to the host name
621 * to which to send the authorization data to, and no other
622 * host (which location-following otherwise could lead to)
624 char *krb4_level; /* what security level */
625 struct ssl_config_data ssl; /* user defined SSL stuff */
627 int dns_cache_timeout; /* DNS cache timeout */
629 /* Here follows boolean settings that define how to behave during
630 this session. They are STATIC, set by libcurl users or at least initially
631 and they don't change during operations. */
634 bool tunnel_thru_httpproxy;
640 bool http_fail_on_error;
641 bool http_follow_location;
643 #define http_include_header include_header /* former name */
645 bool http_set_referer;
646 bool http_auto_referer; /* set "correct" referer when following location: */
652 bool krb4; /* kerberos4 connection requested */
653 bool reuse_forbid; /* forbidden to be reused, close after use */
654 bool reuse_fresh; /* do not re-use an existing connection */
655 bool expect100header; /* TRUE if we added Expect: 100-continue */
656 bool ftp_use_epsv; /* if EPSV is to be attempted or not */
658 bool global_dns_cache;
662 * In August 2001, this struct was redesigned and is since stricter than
663 * before. The 'connectdata' struct MUST have all the connection oriented
664 * stuff as we may now have several simultaneous connections and connection
667 * From now on, the 'SessionHandle' must only contain data that is set once to
668 * go for many (perhaps) independent connections. Values that are generated or
669 * calculated internally for the "session handle" must be defined within the
670 * 'struct urlstate' instead. */
672 struct SessionHandle {
673 curl_hash *hostcache;
674 struct UserDefined set; /* values set by the libcurl user */
675 struct DynamicStatic change; /* possibly modified userdefined data */
677 struct CookieInfo *cookies; /* the cookies, read from files and servers */
678 struct Progress progress; /* for all the progress meter data */
679 struct UrlState state; /* struct for fields used for state info and
680 other dynamic purposes */
681 struct PureInfo info; /* stats, reports and info data */
684 #endif /* USE_SSLEAY */
687 #define LIBCURL_NAME "libcurl"