3 /*****************************************************************************
5 * Project ___| | | | _ \| |
7 * | (__| |_| | _ <| |___
8 * \___|\___/|_| \_\_____|
10 * Copyright (C) 2001, 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 */
32 #define PORT_TELNET 23
33 #define PORT_GOPHER 70
35 #define PORT_HTTPS 443
36 #define PORT_DICT 2628
39 #define DICT_MATCH "/MATCH:"
40 #define DICT_MATCH2 "/M:"
41 #define DICT_MATCH3 "/FIND:"
42 #define DICT_DEFINE "/DEFINE:"
43 #define DICT_DEFINE2 "/D:"
44 #define DICT_DEFINE3 "/LOOKUP:"
46 #define CURL_DEFAULT_USER "anonymous"
47 #define CURL_DEFAULT_PASSWORD "curl_by_daniel@haxx.se"
53 /* SSLeay stuff usually in /usr/local/ssl/include */
55 #include "openssl/rsa.h"
56 #include "openssl/crypto.h"
57 #include "openssl/x509.h"
58 #include "openssl/pem.h"
59 #include "openssl/ssl.h"
60 #include "openssl/err.h"
71 #ifdef HAVE_NETINET_IN_H
72 #include <netinet/in.h>
77 #include <curl/curl.h>
79 #include "http_chunks.h" /* for the structs and enum stuff */
81 /* Download buffer size, keep it fairly big for speed reasons */
82 #define BUFSIZE (1024*50)
84 /* Defaul upload buffer size, keep it smallish to get faster progress meter
85 updates. This is just default, it is dynamic and adjusts to the upload
87 #define UPLOAD_BUFSIZE (1024*2)
89 /* Initial size of the buffer to store headers in, it'll be enlarged in case
91 #define HEADERSIZE 256
93 /* Just a convenience macro to get the larger value out of two given */
95 #define MAX(x,y) ((x)>(y)?(x):(y))
99 /* Types needed for krb4-ftp connections */
106 enum protection_level {
114 /* struct for data related to SSL and SSL connections */
115 struct ssl_connect_data {
116 bool use; /* use ssl encrypted communications TRUE/FALSE */
118 /* these ones requires specific SSL-types */
122 #endif /* USE_SSLEAY */
125 /* information about one single SSL session */
126 struct curl_ssl_session {
127 char *name; /* host name for which this ID was used */
128 void *sessionid; /* as returned from the SSL layer */
129 long age; /* just a number, the higher the more recent */
130 unsigned short remote_port; /* remote port to connect to */
133 struct ssl_config_data {
134 long version; /* what version the client wants to use */
135 long certverifyresult; /* result from the certificate verification */
136 long verifypeer; /* set TRUE if this is desired */
137 long verifyhost; /* 0: no verif, 1: check that CN exists, 2: CN must match hostname */
138 char *CApath; /* DOES NOT WORK ON WINDOWS */
139 char *CAfile; /* cerficate to verify peer against */
140 char *random_file; /* path to file containing "random" data */
141 char *egdsocket; /* path to file containing the EGD daemon socket */
142 char *cipher_list; /* list of ciphers to use */
144 long numsessions; /* SSL session id cache size */
147 /****************************************************************************
149 ***************************************************************************/
151 struct FormData *sendit;
153 const char *p_pragma; /* Pragma: string */
154 const char *p_accept; /* Accept: string */
158 /* For FORM posting */
160 curl_read_callback storefread;
163 struct Curl_chunker chunk;
166 /****************************************************************************
168 ***************************************************************************/
171 char *user; /* user name string */
172 char *passwd; /* password string */
173 char *urlpath; /* the originally given path part of the URL */
174 char *dir; /* decoded directory */
175 char *file; /* decoded file */
177 char *entrypath; /* the PWD reply when we logged on */
180 /****************************************************************************
182 ***************************************************************************/
184 int fd; /* open file descriptor to read from! */
188 * Boolean values that concerns this connection.
191 bool close; /* if set, we close the connection after this request */
192 bool reuse; /* if set, this is a re-used connection */
193 bool chunk; /* if set, this is a chunked transfer-encoding */
194 bool httpproxy; /* if set, this transfer is done through a http proxy */
195 bool user_passwd; /* do we use user+password for this connection? */
196 bool proxy_user_passwd; /* user+password for the proxy? */
199 bool rangestringalloc; /* the range string is malloc()'ed */
201 bool resume_done; /* nothing was transfered, resumed transfer already
206 * The connectdata struct contains all fields and variables that should be
207 * unique for an entire connection.
210 /**** Fields set when inited and not modified again */
211 struct SessionHandle *data; /* link to the root CURL struct */
212 int connectindex; /* what index in the connects index this particular
215 long protocol; /* PROT_* flags concerning the protocol set */
216 #define PROT_MISSING (1<<0)
217 #define PROT_GOPHER (1<<1)
218 #define PROT_HTTP (1<<2)
219 #define PROT_HTTPS (1<<3)
220 #define PROT_FTP (1<<4)
221 #define PROT_TELNET (1<<5)
222 #define PROT_DICT (1<<6)
223 #define PROT_LDAP (1<<7)
224 #define PROT_FILE (1<<8)
225 #define PROT_FTPS (1<<9)
227 Curl_addrinfo *hp; /* IP-protocol independent host info pointer list */
228 char *hostent_buf; /* pointer to allocated memory for name info */
231 struct addrinfo *ai; /* the particular host we use */
233 struct sockaddr_in serv_addr;
235 char protostr[64]; /* store the protocol string in this buffer */
236 char gname[257]; /* store the hostname in this buffer */
237 char *name; /* host name pointer to fool around with */
238 char *path; /* allocated buffer to store the URL's path part in */
239 char *hostname; /* hostname to connect, as parsed from url */
240 long port; /* which port to use locally */
241 unsigned short remote_port; /* what remote port to connect to,
242 not the proxy port! */
246 char *range; /* range, if used. See README for detailed specification on
248 int resume_from; /* continue [ftp] transfer from here */
250 char *proxyhost; /* name of the http proxy host */
252 struct timeval now; /* "current" time */
253 struct timeval created; /* creation time */
254 int firstsocket; /* the main socket to use */
255 int secondarysocket; /* for i.e ftp transfers */
257 long upload_bufsize; /* adjust as you see fit, never bigger than BUFSIZE
258 never smaller than UPLOAD_BUFSIZE */
260 long maxdownload; /* in bytes, the maximum amount of data to fetch, 0
263 struct ssl_connect_data ssl; /* this is for ssl-stuff */
265 struct ConnectBits bits; /* various state-flags for this connection */
267 /* These two functions MUST be set by the curl_connect() function to be
268 be protocol dependent */
269 CURLcode (*curl_do)(struct connectdata *connect);
270 CURLcode (*curl_done)(struct connectdata *connect);
272 /* This function *MAY* be set to a protocol-dependent function that is run
273 * after the connect() and everything is done, as a step in the connection.
275 CURLcode (*curl_connect)(struct connectdata *connect);
277 /* This function *MAY* be set to a protocol-dependent function that is run
278 * by the curl_disconnect(), as a step in the disconnection.
280 CURLcode (*curl_disconnect)(struct connectdata *connect);
282 /* This function *MAY* be set to a protocol-dependent function that is run
283 * in the curl_close() function if protocol-specific cleanups are required.
285 CURLcode (*curl_close)(struct connectdata *connect);
287 /**** curl_get() phase fields */
290 int sockfd; /* socket to read from or -1 */
291 int size; /* -1 if unknown at this point */
292 bool getheader; /* TRUE if header parsing is wanted */
293 long *bytecountp; /* return number of bytes read or NULL */
296 int writesockfd; /* socket to write to, it may very well be
297 the same we read from. -1 disables */
298 long *writebytecountp; /* return number of bytes written or NULL */
300 /** Dynamicly allocated strings, may need to be freed before this **/
301 /** struct is killed. **/
302 struct dynamically_allocated_data {
303 char *proxyuserpwd; /* free later if not NULL! */
304 char *uagent; /* free later if not NULL! */
305 char *userpwd; /* free later if not NULL! */
306 char *rangeline; /* free later if not NULL! */
307 char *ref; /* free later if not NULL! */
308 char *cookie; /* free later if not NULL! */
309 char *host; /* free later if not NULL */
312 char *newurl; /* This can only be set if a Location: was in the
316 enum protection_level command_prot;
317 enum protection_level data_prot;
318 enum protection_level request_data_prot;
322 struct krb4buffer in_buffer, out_buffer;
326 struct Curl_sec_client_mech *mech;
327 struct sockaddr_in local_addr;
331 /*************** Request - specific items ************/
332 /* previously this was in the urldata struct */
335 struct HTTP *gopher; /* alias, just for the sake of being more readable */
336 struct HTTP *https; /* alias, just for the sake of being more readable */
339 void *telnet; /* private for telnet.c-eyes only */
340 #if 0 /* no need for special ones for these: */
350 * Struct to keep statistical and informational data.
355 long filetime; /* If requested, this is might get set. Set to -1 if
356 the time was unretrievable */
357 long header_size; /* size of read header(s) in bytes */
358 long request_size; /* the amount of bytes sent in the request(s) */
363 long lastshow; /* time() of the last displayed progress meter or NULL to
364 force redraw at next call */
370 double current_speed; /* uses the currently fastest transfer */
372 bool callback; /* set when progress callback is used */
373 int width; /* screen width at download start */
374 int flags; /* see progress.h */
381 double t_pretransfer;
383 struct timeval start;
384 struct timeval t_startsingle;
387 double speeder[ CURR_TIME ];
392 HTTPREQ_NONE, /* first in list */
395 HTTPREQ_POST_FORM, /* we make a difference internally */
398 HTTPREQ_LAST /* last in list */
402 * Values that are generated, temporary or calculated internally for a
403 * "session handle" must be defined within the 'struct urlstate'. This struct
404 * will be used within the SessionHandle struct. When the 'SessionHandle'
405 * struct is cloned, this data MUST NOT be copied.
407 * Remember that any "state" information goes globally for the curl handle.
408 * Session-data MUST be put in the connectdata struct and here. */
409 #define MAX_CURL_USER_LENGTH 256
410 #define MAX_CURL_PASSWORD_LENGTH 256
413 /* buffers to store authentication data in, as parsed from input options */
414 char user[MAX_CURL_USER_LENGTH];
415 char passwd[MAX_CURL_PASSWORD_LENGTH];
416 char proxyuser[MAX_CURL_USER_LENGTH];
417 char proxypasswd[MAX_CURL_PASSWORD_LENGTH];
419 struct timeval keeps_speed; /* for the progress meter really */
421 /* 'connects' will be an allocated array with pointers. If the pointer is
422 set, it holds an allocated connection. */
423 struct connectdata **connects;
424 long numconnects; /* size of the 'connects' array */
426 char *headerbuff; /* allocated buffer to store headers in */
427 int headersize; /* size of the allocation */
429 char buffer[BUFSIZE+1]; /* buffer with size BUFSIZE */
431 double current_speed; /* the ProgressShow() funcion sets this */
433 bool this_is_a_follow; /* this is a followed Location: request */
435 char *auth_host; /* if set, this should be the host name that we will
436 sent authorization to, no else. Used to make Location:
437 following not keep sending user+password... This is
441 struct curl_ssl_session *session; /* array of 'numsessions' size */
442 long sessionage; /* number of the most recent session */
444 char scratch[BUFSIZE*2]; /* huge buffer when doing upload CRLF replacing */
449 * This 'DynamicStatic' struct defines dynamic states that actually change
450 * values in the 'UserDefined' area, which MUST be taken into consideration
451 * if the UserDefined struct is cloned or similar. You can probably just
452 * copy these, but each one indicate a special action on other data.
455 struct DynamicStatic {
456 char *url; /* work URL, copied from UserDefined */
457 bool url_alloc; /* URL string is malloc()'ed */
458 char *proxy; /* work proxy, copied from UserDefined */
459 bool proxy_alloc; /* http proxy string is malloc()'ed */
460 char *referer; /* referer string */
461 bool referer_alloc; /* referer sting is malloc()ed */
465 * This 'UserDefined' struct must only contain data that is set once to go
466 * for many (perhaps) independent connections. Values that are generated or
467 * calculated internally for the "session handle" MUST be defined within the
468 * 'struct urlstate' instead. The only exceptions MUST note the changes in
469 * the 'DynamicStatic' struct.
473 FILE *err; /* the stderr writes goes here */
474 char *errorbuffer; /* store failure messages in here */
475 char *proxyuserpwd; /* Proxy <user:password>, if used */
476 long proxyport; /* If non-zero, use this port number by default. If the
477 proxy string features a ":[port]" that one will override
479 void *out; /* the fetched file goes here */
480 void *in; /* the uploaded file is read from here */
481 void *writeheader; /* write the header to this is non-NULL */
482 char *set_url; /* what original URL to work on */
483 char *set_proxy; /* proxy to use */
484 long use_port; /* which port to use (when not using default) */
485 char *userpwd; /* <user:password>, if used */
486 char *set_range; /* range, if used. See README for detailed specification
488 long followlocation; /* as in HTTP Location: */
489 long maxredirs; /* maximum no. of http(s) redirects to follow */
490 char *set_referer; /* custom string */
491 bool free_referer; /* set TRUE if 'referer' points to a string we
493 char *useragent; /* User-Agent string */
494 char *postfields; /* if POST, set the fields' values here */
495 size_t postfieldsize; /* if POST, this might have a size to use instead of
496 strlen(), and then the data *may* be binary (contain
498 char *ftpport; /* port to send with the FTP PORT command */
499 char *device; /* network interface to use */
500 curl_write_callback fwrite; /* function that stores the output */
501 curl_write_callback fwrite_header; /* function that stores headers */
502 curl_read_callback fread; /* function that reads the input */
503 curl_progress_callback fprogress; /* function for progress information */
504 void *progress_client; /* pointer to pass to the progress callback */
505 curl_passwd_callback fpasswd; /* call for password */
506 void *passwd_client; /* pass to the passwd callback */
507 long timeout; /* in seconds, 0 means no timeout */
508 long connecttimeout; /* in seconds, 0 means no timeout */
509 long infilesize; /* size of file to upload, -1 means unknown */
510 long low_speed_limit; /* bytes/second */
511 long low_speed_time; /* number of seconds */
512 int set_resume_from; /* continue [ftp] transfer from here */
513 char *cookie; /* HTTP cookie string to send */
514 struct curl_slist *headers; /* linked list of extra headers */
515 struct HttpPost *httppost; /* linked list of POST data */
516 char *cert; /* PEM-formatted certificate */
517 char *cert_passwd; /* plain text certificate password */
518 char *cookiejar; /* dump all cookies to this file */
519 bool crlf; /* convert crlf on ftp upload(?) */
520 struct curl_slist *quote; /* before the transfer */
521 struct curl_slist *postquote; /* after the transfer */
522 struct curl_slist *telnet_options; /* linked list of telnet options */
523 TimeCond timecondition; /* kind of time/date comparison */
524 time_t timevalue; /* what time to compare with */
525 curl_closepolicy closepolicy; /* connection cache close concept */
526 Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */
527 char *customrequest; /* HTTP/FTP request to use */
528 char *auth_host; /* if set, this is the allocated string to the host name
529 * to which to send the authorization data to, and no other
530 * host (which location-following otherwise could lead to)
532 char *krb4_level; /* what security level */
533 struct ssl_config_data ssl; /* user defined SSL stuff */
535 /* Here follows boolean settings that define how to behave during
536 this session. They are STATIC, set by libcurl users or at least initially
537 and they don't change during operations. */
540 bool tunnel_thru_httpproxy;
546 bool http_fail_on_error;
547 bool http_follow_location;
548 bool http_include_header;
549 bool http_set_referer;
550 bool http_auto_referer; /* set "correct" referer when following location: */
556 bool krb4; /* kerberos4 connection requested */
557 bool reuse_forbid; /* forbidden to be reused, close after use */
558 bool reuse_fresh; /* do not re-use an existing connection */
559 bool expect100header; /* TRUE if we added Expect: 100-continue */
563 * In August 2001, this struct was redesigned and is since stricter than
564 * before. The 'connectdata' struct MUST have all the connection oriented
565 * stuff as we may now have several simultaneous connections and connection
568 * From now on, the 'SessionHandle' must only contain data that is set once to
569 * go for many (perhaps) independent connections. Values that are generated or
570 * calculated internally for the "session handle" must be defined within the
571 * 'struct urlstate' instead. */
573 struct SessionHandle {
574 struct UserDefined set; /* values set by the libcurl user */
575 struct DynamicStatic change; /* possibly modified userdefined data */
577 struct CookieInfo *cookies; /* the cookies, read from files and servers */
578 struct Progress progress; /* for all the progress meter data */
579 struct UrlState state; /* struct for fields used for state info and
580 other dynamic purposes */
581 struct PureInfo info; /* stats, reports and info data */
584 #define LIBCURL_NAME "libcurl"