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