Add support for DNS cache timeouts via the CURLOPT_DNS_CACHE_TIMEOUT option.
[platform/upstream/curl.git] / lib / urldata.h
1 #ifndef __URLDATA_H
2 #define __URLDATA_H
3 /*****************************************************************************
4  *                                  _   _ ____  _     
5  *  Project                     ___| | | |  _ \| |    
6  *                             / __| | | | |_) | |    
7  *                            | (__| |_| |  _ <| |___ 
8  *                             \___|\___/|_| \_\_____|
9  *
10  * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
11  *
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.
14  *
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.
19  *
20  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21  * KIND, either express or implied.
22  *
23  * $Id$
24  *****************************************************************************/
25
26 /* This file is for lib internal stuff */
27
28 #include "setup.h"
29 #include "hostip.h"
30 #include "hash.h"
31
32 #define PORT_FTP 21
33 #define PORT_TELNET 23
34 #define PORT_GOPHER 70
35 #define PORT_HTTP 80
36 #define PORT_HTTPS 443
37 #define PORT_DICT 2628
38 #define PORT_LDAP 389
39
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:"
46
47 #define CURL_DEFAULT_USER "anonymous"
48 #define CURL_DEFAULT_PASSWORD "curl_by_daniel@haxx.se"
49
50 #include "cookie.h"
51 #include "formdata.h"
52     
53 #ifdef USE_SSLEAY
54 /* SSLeay stuff usually in /usr/local/ssl/include */
55 #ifdef USE_OPENSSL
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>
64 #endif
65 #else
66 #include "rsa.h"
67 #include "crypto.h"
68 #include "x509.h"
69 #include "pem.h"
70 #include "ssl.h"
71 #include "err.h"
72 #endif
73 #endif
74
75 #ifdef HAVE_NETINET_IN_H
76 #include <netinet/in.h>
77 #endif
78
79 #include "timeval.h"
80
81 #include <curl/curl.h>
82
83 #include "http_chunks.h" /* for the structs and enum stuff */
84
85 /* Download buffer size, keep it fairly big for speed reasons */
86 #define BUFSIZE (1024*50)
87
88 /* Defaul upload buffer size, keep it smallish to get faster progress meter
89    updates. This is just default, it is dynamic and adjusts to the upload
90    speed. */
91 #define UPLOAD_BUFSIZE (1024*2)
92
93 /* Initial size of the buffer to store headers in, it'll be enlarged in case
94    of need. */
95 #define HEADERSIZE 256
96
97 /* Just a convenience macro to get the larger value out of two given */
98 #ifndef MAX
99 #define MAX(x,y) ((x)>(y)?(x):(y))
100 #endif
101
102 #ifdef KRB4
103 /* Types needed for krb4-ftp connections */
104 struct krb4buffer {
105   void *data;
106   size_t size;
107   size_t index;
108   int eof_flag;
109 };
110 enum protection_level { 
111     prot_clear, 
112     prot_safe, 
113     prot_confidential, 
114     prot_private 
115 };
116 #endif
117
118 #ifndef HAVE_OPENSSL_ENGINE_H
119 typedef void ENGINE;
120 #endif
121 /* struct for data related to SSL and SSL connections */
122 struct ssl_connect_data {
123   bool use;              /* use ssl encrypted communications TRUE/FALSE */
124 #ifdef USE_SSLEAY
125   /* these ones requires specific SSL-types */
126   SSL_CTX* ctx;
127   SSL*     handle;
128   X509*    server_cert;
129 #endif /* USE_SSLEAY */
130 };
131
132 /* information about one single SSL session */
133 struct curl_ssl_session {
134   char *name;       /* host name for which this ID was used */
135   void *sessionid;  /* as returned from the SSL layer */
136   long age;         /* just a number, the higher the more recent */
137   unsigned short remote_port; /* remote port to connect to */
138 };
139
140 struct ssl_config_data {
141   long version;          /* what version the client wants to use */
142   long certverifyresult; /* result from the certificate verification */
143   long verifypeer;       /* set TRUE if this is desired */
144   long verifyhost;       /* 0: no verif, 1: check that CN exists, 2: CN must match hostname */
145   char *CApath;          /* DOES NOT WORK ON WINDOWS */
146   char *CAfile;          /* cerficate to verify peer against */
147   char *random_file;     /* path to file containing "random" data */
148   char *egdsocket;       /* path to file containing the EGD daemon socket */
149   char *cipher_list;     /* list of ciphers to use */
150
151   long numsessions;                 /* SSL session id cache size */
152 };
153
154 /****************************************************************************
155  * HTTP unique setup
156  ***************************************************************************/
157 struct HTTP {
158   struct FormData *sendit;
159   int postsize;
160   const char *p_pragma;      /* Pragma: string */
161   const char *p_accept;      /* Accept: string */
162   long readbytecount; 
163   long writebytecount;
164
165   /* For FORM posting */
166   struct Form form;
167   curl_read_callback storefread;
168   FILE *in;
169
170   struct Curl_chunker chunk;
171 };
172
173 /****************************************************************************
174  * FTP unique setup
175  ***************************************************************************/
176 struct FTP {
177   long *bytecountp;
178   char *user;    /* user name string */
179   char *passwd;  /* password string */
180   char *urlpath; /* the originally given path part of the URL */
181   char *dir;     /* decoded directory */
182   char *file;    /* decoded file */
183
184   char *entrypath; /* the PWD reply when we logged on */
185
186   char *cache;       /* data cache between getresponse()-calls */
187   size_t cache_size; /* size of cache in bytes */                    
188 };
189
190 /****************************************************************************
191  * FILE unique setup
192  ***************************************************************************/
193 struct FILE {
194   int fd; /* open file descriptor to read from! */
195 };
196
197 /*
198  * Boolean values that concerns this connection.
199  */
200 struct ConnectBits {
201   bool close; /* if set, we close the connection after this request */
202   bool reuse; /* if set, this is a re-used connection */
203   bool chunk; /* if set, this is a chunked transfer-encoding */
204   bool httpproxy;    /* if set, this transfer is done through a http proxy */
205   bool user_passwd;    /* do we use user+password for this connection? */
206   bool proxy_user_passwd; /* user+password for the proxy? */
207
208   bool use_range;
209   bool rangestringalloc; /* the range string is malloc()'ed */
210
211   bool resume_done; /* nothing was transfered, resumed transfer already
212                        complete */
213 };
214
215 /*
216  * This struct is all the previously local variables from Curl_perform() moved
217  * to struct to allow the function to return and get re-invoked better without
218  * losing state.
219  */
220
221 struct Curl_transfer_keeper {
222   int bytecount;                /* total number of bytes read */
223   int writebytecount;           /* number of bytes written */
224   long contentlength;           /* size of incoming data */
225   struct timeval start;         /* transfer started at this time */
226   struct timeval now;           /* current time */
227   bool header;                  /* incoming data has HTTP header */
228   int headerline;               /* counts header lines to better track the
229                                    first one */
230   char *hbufp;                  /* points at *end* of header line */
231   int hbuflen;
232   char *str;                    /* within buf */
233   char *str_start;              /* within buf */
234   char *end_ptr;                /* within buf */
235   char *p;                      /* within headerbuff */
236   bool content_range;           /* set TRUE if Content-Range: was found */
237   int offset;                   /* possible resume offset read from the
238                                    Content-Range: header */
239   int httpcode;                 /* error code from the 'HTTP/1.? XXX' line */
240   int httpversion;              /* the HTTP version*10 */
241   bool write_after_100_header;  /* should we enable the write after
242                                    we received a 100-continue/timeout
243                                    or directly */
244
245   /* for the low speed checks: */
246   time_t timeofdoc;
247   long bodywrites;
248   int writetype;
249
250   /* the highest fd we use + 1 */
251   struct SessionHandle *data;
252   struct connectdata *conn;
253   char *buf;
254   int maxfd;
255
256   /* the file descriptors to play with */
257   fd_set readfd;
258   fd_set writefd;
259   fd_set rkeepfd;
260   fd_set wkeepfd;
261   int keepon;
262
263 };
264
265
266 /*
267  * The connectdata struct contains all fields and variables that should be
268  * unique for an entire connection.
269  */
270 struct connectdata {
271   /**** Fields set when inited and not modified again */
272   struct SessionHandle *data; /* link to the root CURL struct */
273   int connectindex; /* what index in the connects index this particular
274                        struct has */
275
276   long protocol; /* PROT_* flags concerning the protocol set */
277 #define PROT_MISSING (1<<0)
278 #define PROT_GOPHER  (1<<1)
279 #define PROT_HTTP    (1<<2)
280 #define PROT_HTTPS   (1<<3)
281 #define PROT_FTP     (1<<4)
282 #define PROT_TELNET  (1<<5)
283 #define PROT_DICT    (1<<6)
284 #define PROT_LDAP    (1<<7)
285 #define PROT_FILE    (1<<8)
286 #define PROT_FTPS    (1<<9)
287 #define PROT_SSL     (1<<10) /* protocol requires SSL */
288
289   Curl_addrinfo *hostaddr; /* IP-protocol independent host info pointer list */
290   char *hostent_buf; /* pointer to allocated memory for name info */
291
292 #ifdef ENABLE_IPV6
293   struct addrinfo *serv_addr;   /* the particular host we use */
294 #else
295   struct sockaddr_in serv_addr;
296 #endif
297   char protostr[64];  /* store the protocol string in this buffer */
298   char gname[513]; /* store the hostname in this buffer */
299   char *name;      /* host name pointer to fool around with */
300   char *path;      /* allocated buffer to store the URL's path part in */
301   char *hostname;  /* hostname to connect, as parsed from url */
302   long port;       /* which port to use locally */
303   unsigned short remote_port; /* what remote port to connect to,
304                                  not the proxy port! */
305   char *ppath;
306   long bytecount;
307   long headerbytecount;  /* only count received headers */
308
309   char *range; /* range, if used. See README for detailed specification on
310                   this syntax. */
311   ssize_t resume_from; /* continue [ftp] transfer from here */
312
313   char *proxyhost; /* name of the http proxy host */
314
315   struct timeval now;     /* "current" time */
316   struct timeval created; /* creation time */
317   int firstsocket;     /* the main socket to use */
318   int secondarysocket; /* for i.e ftp transfers */
319
320   long upload_bufsize; /* adjust as you see fit, never bigger than BUFSIZE
321                           never smaller than UPLOAD_BUFSIZE */
322
323   long maxdownload; /* in bytes, the maximum amount of data to fetch, 0
324                        means unlimited */
325   
326   struct ssl_connect_data ssl; /* this is for ssl-stuff */
327
328   struct ConnectBits bits;    /* various state-flags for this connection */
329
330   /* These two functions MUST be set by the curl_connect() function to be
331      be protocol dependent */
332   CURLcode (*curl_do)(struct connectdata *connect);
333   CURLcode (*curl_done)(struct connectdata *connect);
334
335   /* This function *MAY* be set to a protocol-dependent function that is run
336    * after the connect() and everything is done, as a step in the connection.
337    */ 
338   CURLcode (*curl_connect)(struct connectdata *connect);
339
340   /* This function *MAY* be set to a protocol-dependent function that is run
341    * by the curl_disconnect(), as a step in the disconnection.
342    */ 
343   CURLcode (*curl_disconnect)(struct connectdata *connect);
344
345   /* This function *MAY* be set to a protocol-dependent function that is run
346    * in the curl_close() function if protocol-specific cleanups are required.
347    */ 
348   CURLcode (*curl_close)(struct connectdata *connect);
349
350   /**** curl_get() phase fields */
351
352   /* READ stuff */
353   int sockfd;            /* socket to read from or -1 */
354   int size;              /* -1 if unknown at this point */
355   bool getheader;        /* TRUE if header parsing is wanted */
356   long *bytecountp;      /* return number of bytes read or NULL */
357           
358   /* WRITE stuff */
359   int writesockfd;       /* socket to write to, it may very well be
360                             the same we read from. -1 disables */
361   long *writebytecountp; /* return number of bytes written or NULL */
362
363   /** Dynamicly allocated strings, may need to be freed before this **/
364   /** struct is killed.                                             **/
365   struct dynamically_allocated_data {
366     char *proxyuserpwd; /* free later if not NULL! */
367     char *uagent; /* free later if not NULL! */
368     char *userpwd; /* free later if not NULL! */
369     char *rangeline; /* free later if not NULL! */
370     char *ref; /* free later if not NULL! */
371     char *cookie; /* free later if not NULL! */
372     char *host; /* free later if not NULL */
373   } allocptr;
374
375   char *newurl; /* This can only be set if a Location: was in the
376                    document headers */
377
378 #ifdef KRB4
379   enum protection_level command_prot;
380   enum protection_level data_prot;
381   enum protection_level request_data_prot;
382
383   size_t buffer_size;
384
385   struct krb4buffer in_buffer, out_buffer;
386   int sec_complete;
387   void *app_data;
388
389   struct Curl_sec_client_mech *mech;
390   struct sockaddr_in local_addr;
391
392 #endif
393
394   /*************** Request - specific items ************/
395   /* previously this was in the urldata struct */
396   union {
397     struct HTTP *http;
398     struct HTTP *gopher; /* alias, just for the sake of being more readable */
399     struct HTTP *https;  /* alias, just for the sake of being more readable */
400     struct FTP *ftp;
401     struct FILE *file;
402     void *telnet;        /* private for telnet.c-eyes only */
403 #if 0 /* no need for special ones for these: */
404     struct LDAP *ldap;
405     struct DICT *dict;
406 #endif
407     void *generic;
408   } proto;
409
410   /* This struct is inited when needed */
411   struct Curl_transfer_keeper keep;
412 };
413
414 /*
415  * Struct to keep statistical and informational data.
416  */
417 struct PureInfo {
418   int httpcode;
419   int httpversion;
420   long filetime; /* If requested, this is might get set. Set to -1 if
421                     the time was unretrievable */
422   long header_size;  /* size of read header(s) in bytes */
423   long request_size; /* the amount of bytes sent in the request(s) */
424 };
425
426
427 struct Progress {
428   long lastshow; /* time() of the last displayed progress meter or NULL to
429                     force redraw at next call */
430   double size_dl;
431   double size_ul;
432   double downloaded;
433   double uploaded;
434
435   double current_speed; /* uses the currently fastest transfer */
436
437   bool callback;  /* set when progress callback is used */
438   int width; /* screen width at download start */
439   int flags; /* see progress.h */
440
441   double timespent;
442
443   double dlspeed;
444   double ulspeed;
445
446   double t_nslookup;
447   double t_connect;
448   double t_pretransfer;
449   double t_starttransfer;
450
451   struct timeval start;
452   struct timeval t_startsingle;
453 #define CURR_TIME (5+1) /* 6 entries for 5 seconds */
454
455   double speeder[ CURR_TIME ];
456   struct timeval speeder_time[ CURR_TIME ];
457   int speeder_c;
458 };
459
460 typedef enum {
461   HTTPREQ_NONE, /* first in list */
462   HTTPREQ_GET,
463   HTTPREQ_POST,
464   HTTPREQ_POST_FORM, /* we make a difference internally */
465   HTTPREQ_PUT,
466   HTTPREQ_CUSTOM,
467   HTTPREQ_LAST /* last in list */
468 } Curl_HttpReq;
469
470 /*
471  * Values that are generated, temporary or calculated internally for a
472  * "session handle" must be defined within the 'struct urlstate'.  This struct
473  * will be used within the SessionHandle struct. When the 'SessionHandle'
474  * struct is cloned, this data MUST NOT be copied.
475  *
476  * Remember that any "state" information goes globally for the curl handle.
477  * Session-data MUST be put in the connectdata struct and here.  */
478 #define MAX_CURL_USER_LENGTH 256
479 #define MAX_CURL_PASSWORD_LENGTH 256
480
481 struct UrlState {
482   /* buffers to store authentication data in, as parsed from input options */
483   char user[MAX_CURL_USER_LENGTH];
484   char passwd[MAX_CURL_PASSWORD_LENGTH];
485   char proxyuser[MAX_CURL_USER_LENGTH];
486   char proxypasswd[MAX_CURL_PASSWORD_LENGTH];
487
488   struct timeval keeps_speed; /* for the progress meter really */
489
490   /* 'connects' will be an allocated array with pointers. If the pointer is
491      set, it holds an allocated connection. */
492   struct connectdata **connects;
493   long numconnects; /* size of the 'connects' array */
494
495   char *headerbuff; /* allocated buffer to store headers in */
496   int headersize;   /* size of the allocation */
497
498   char buffer[BUFSIZE+1]; /* buffer with size BUFSIZE */
499
500   double current_speed;  /* the ProgressShow() funcion sets this */
501
502   bool this_is_a_follow; /* this is a followed Location: request */
503
504   char *auth_host; /* if set, this should be the host name that we will
505                       sent authorization to, no else. Used to make Location:
506                       following not keep sending user+password... This is
507                       strdup() data.
508                     */
509
510   struct curl_ssl_session *session; /* array of 'numsessions' size */
511   long sessionage;                  /* number of the most recent session */
512
513   char scratch[BUFSIZE*2]; /* huge buffer when doing upload CRLF replacing */
514   bool errorbuf; /* Set to TRUE if the error buffer is already filled in.
515                     This must be set to FALSE every time _easy_perform() is
516                     called. */
517
518 #ifdef HAVE_SIGNAL
519   /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */
520   void (*prev_signal)(int sig);
521 #endif
522   bool allow_port; /* Is set.use_port allowed to take effect or not. This
523                       is always set TRUE when curl_easy_perform() is called. */
524 };
525
526
527 /*
528  * This 'DynamicStatic' struct defines dynamic states that actually change
529  * values in the 'UserDefined' area, which MUST be taken into consideration
530  * if the UserDefined struct is cloned or similar. You can probably just
531  * copy these, but each one indicate a special action on other data.
532  */
533
534 struct DynamicStatic {
535   char *url;        /* work URL, copied from UserDefined */
536   bool url_alloc;   /* URL string is malloc()'ed */
537   char *proxy;      /* work proxy, copied from UserDefined */
538   bool proxy_alloc; /* http proxy string is malloc()'ed */
539   char *referer;    /* referer string */
540   bool referer_alloc; /* referer sting is malloc()ed */
541 };
542
543 /*
544  * This 'UserDefined' struct must only contain data that is set once to go
545  * for many (perhaps) independent connections. Values that are generated or
546  * calculated internally for the "session handle" MUST be defined within the
547  * 'struct urlstate' instead. The only exceptions MUST note the changes in
548  * the 'DynamicStatic' struct.
549  */
550
551 struct UserDefined {
552   FILE *err;    /* the stderr writes goes here */
553   char *errorbuffer; /* store failure messages in here */
554   char *proxyuserpwd;  /* Proxy <user:password>, if used */
555   long proxyport; /* If non-zero, use this port number by default. If the
556                      proxy string features a ":[port]" that one will override
557                      this. */  
558   void *out;         /* the fetched file goes here */
559   void *in;          /* the uploaded file is read from here */
560   void *writeheader; /* write the header to this is non-NULL */
561   char *set_url;     /* what original URL to work on */
562   char *set_proxy;   /* proxy to use */
563   long use_port;     /* which port to use (when not using default) */
564   char *userpwd;     /* <user:password>, if used */
565   char *set_range;   /* range, if used. See README for detailed specification
566                         on this syntax. */
567   long followlocation; /* as in HTTP Location: */
568   long maxredirs;    /* maximum no. of http(s) redirects to follow */
569   char *set_referer; /* custom string */
570   bool free_referer; /* set TRUE if 'referer' points to a string we
571                         allocated */
572   char *useragent;   /* User-Agent string */
573   char *postfields;  /* if POST, set the fields' values here */
574   size_t postfieldsize; /* if POST, this might have a size to use instead of
575                            strlen(), and then the data *may* be binary (contain
576                            zero bytes) */
577   char *ftpport;     /* port to send with the FTP PORT command */
578   char *device;      /* network interface to use */
579   curl_write_callback fwrite;        /* function that stores the output */
580   curl_write_callback fwrite_header; /* function that stores headers */
581   curl_read_callback fread;          /* function that reads the input */
582   curl_progress_callback fprogress;  /* function for progress information */
583   void *progress_client; /* pointer to pass to the progress callback */
584   curl_passwd_callback fpasswd;      /* call for password */
585   void *passwd_client;               /* pass to the passwd callback */
586   long timeout;         /* in seconds, 0 means no timeout */
587   long connecttimeout;  /* in seconds, 0 means no timeout */
588   long infilesize;      /* size of file to upload, -1 means unknown */
589   long low_speed_limit; /* bytes/second */
590   long low_speed_time;  /* number of seconds */
591   int set_resume_from;  /* continue [ftp] transfer from here */
592   char *cookie;         /* HTTP cookie string to send */
593   struct curl_slist *headers; /* linked list of extra headers */
594   struct HttpPost *httppost;  /* linked list of POST data */
595   char *cert;           /* certificate */
596   char *cert_type;      /* format for certificate (default: PEM) */
597   char *key;            /* private key */
598   char *key_type;       /* format for private key (default: PEM) */
599   char *key_passwd;     /* plain text private key password */
600   char *crypto_engine;  /* name of the crypto engine to use */
601   char *cookiejar;      /* dump all cookies to this file */
602   bool crlf;            /* convert crlf on ftp upload(?) */
603   struct curl_slist *quote;     /* before the transfer */
604   struct curl_slist *postquote; /* after the transfer */
605   struct curl_slist *telnet_options; /* linked list of telnet options */
606   curl_TimeCond timecondition; /* kind of time/date comparison */
607   time_t timevalue;       /* what time to compare with */
608   curl_closepolicy closepolicy; /* connection cache close concept */
609   Curl_HttpReq httpreq;   /* what kind of HTTP request (if any) is this */
610   char *customrequest;    /* HTTP/FTP request to use */
611   long httpversion; /* when non-zero, a specific HTTP version requested to
612                        be used in the library's request(s) */
613   char *auth_host; /* if set, this is the allocated string to the host name
614                     * to which to send the authorization data to, and no other
615                     * host (which location-following otherwise could lead to)
616                     */
617   char *krb4_level; /* what security level */
618   struct ssl_config_data ssl;  /* user defined SSL stuff */
619
620 /* Here follows boolean settings that define how to behave during
621    this session. They are STATIC, set by libcurl users or at least initially
622    and they don't change during operations. */
623
624   bool get_filetime;
625   bool tunnel_thru_httpproxy;
626   bool ftp_append;
627   bool ftp_ascii;
628   bool ftp_list_only;
629   bool ftp_use_port;
630   bool hide_progress;
631   bool http_fail_on_error;
632   bool http_follow_location;
633   bool include_header;
634 #define http_include_header include_header /* former name */
635
636   bool http_set_referer;
637   bool http_auto_referer; /* set "correct" referer when following location: */
638   bool no_body;
639   bool set_port;
640   bool upload;
641   bool use_netrc;
642   bool verbose;
643   bool krb4;             /* kerberos4 connection requested */
644   bool reuse_forbid;     /* forbidden to be reused, close after use */
645   bool reuse_fresh;      /* do not re-use an existing connection  */
646   bool expect100header;  /* TRUE if we added Expect: 100-continue */
647   bool ftp_use_epsv;     /* if EPSV is to be attempted or not */
648
649   bool global_dns_cache;
650   bool dns_cache_timeout;
651 };
652
653 /*
654  * In August 2001, this struct was redesigned and is since stricter than
655  * before. The 'connectdata' struct MUST have all the connection oriented
656  * stuff as we may now have several simultaneous connections and connection
657  * structs in memory.
658  *
659  * From now on, the 'SessionHandle' must only contain data that is set once to
660  * go for many (perhaps) independent connections. Values that are generated or
661  * calculated internally for the "session handle" must be defined within the
662  * 'struct urlstate' instead.  */
663
664 struct SessionHandle {
665   curl_hash          *hostcache;
666   struct UserDefined set;      /* values set by the libcurl user */
667   struct DynamicStatic change; /* possibly modified userdefined data */
668
669   struct CookieInfo *cookies;  /* the cookies, read from files and servers */
670   struct Progress progress;    /* for all the progress meter data */
671   struct UrlState state;       /* struct for fields used for state info and
672                                   other dynamic purposes */
673   struct PureInfo info;        /* stats, reports and info data */
674 #ifdef USE_SSLEAY
675   ENGINE*  engine;
676 #endif /* USE_SSLEAY */
677 };
678
679 #define LIBCURL_NAME "libcurl"
680
681 #endif