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*20)
  87
  88 /* Initial size of the buffer to store headers in, it'll be enlarged in case
  89    of need. */
  90 #define HEADERSIZE 256
  91
  92 /* Just a convenience macro to get the larger value out of two given */
  93 #ifndef MAX
  94 #define MAX(x,y) ((x)>(y)?(x):(y))
  95 #endif
  96
  97 #ifdef KRB4
  98 /* Types needed for krb4-ftp connections */
  99 struct krb4buffer {
 100   void *data;
 101   size_t size;
 102   size_t index;
 103   int eof_flag;
 104 };
 105 enum protection_level {
 106     prot_clear,
 107     prot_safe,
 108     prot_confidential,
 109     prot_private
 110 };
 111 #endif
 112
 113 #ifndef HAVE_OPENSSL_ENGINE_H
 114 typedef void ENGINE;
 115 #endif
 116 /* struct for data related to SSL and SSL connections */
 117 struct ssl_connect_data {
 118   bool use;              /* use ssl encrypted communications TRUE/FALSE */
 119 #ifdef USE_SSLEAY
 120   /* these ones requires specific SSL-types */
 121   SSL_CTX* ctx;
 122   SSL*     handle;
 123   X509*    server_cert;
 124 #endif /* USE_SSLEAY */
 125 };
 126
 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 */
 133 };
 134
 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 */
 145
 146   long numsessions;                 /* SSL session id cache size */
 147 };
 148
 149 /****************************************************************************
 150  * HTTP unique setup
 151  ***************************************************************************/
 152 struct HTTP {
 153   struct FormData *sendit;
 154   int postsize;
 155   const char *p_pragma;      /* Pragma: string */
 156   const char *p_accept;      /* Accept: string */
 157   long readbytecount;
 158   long writebytecount;
 159
 160   /* For FORM posting */
 161   struct Form form;
 162   curl_read_callback storefread;
 163   FILE *in;
 164
 165   struct Curl_chunker chunk;
 166 };
 167
 168 /****************************************************************************
 169  * FTP unique setup
 170  ***************************************************************************/
 171 struct FTP {
 172   long *bytecountp;
 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 */
 178
 179   char *entrypath; /* the PWD reply when we logged on */
 180
 181   char *cache;       /* data cache between getresponse()-calls */
 182   size_t cache_size; /* size of cache in bytes */
 183 };
 184
 185 /****************************************************************************
 186  * FILE unique setup
 187  ***************************************************************************/
 188 struct FILE {
 189   int fd; /* open file descriptor to read from! */
 190 };
 191
 192 /*
 193  * Boolean values that concerns this connection.
 194  */
 195 struct ConnectBits {
 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? */
 202
 203   bool use_range;
 204   bool rangestringalloc; /* the range string is malloc()'ed */
 205
 206   bool resume_done; /* nothing was transfered, resumed transfer already
 207                        complete */
 208 };
 209
 210 /*
 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
 213  * losing state.
 214  */
 215
 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
 224                                    first one */
 225   char *hbufp;                  /* points at *end* of header line */
 226   int hbuflen;
 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
 238                                    or directly */
 239
 240   /* for the low speed checks: */
 241   time_t timeofdoc;
 242   long bodywrites;
 243   int writetype;
 244
 245   /* the highest fd we use + 1 */
 246   struct SessionHandle *data;
 247   struct connectdata *conn;
 248   char *buf;
 249   char *uploadbuf;
 250   int maxfd;
 251
 252   /* the file descriptors to play with */
 253   fd_set readfd;
 254   fd_set writefd;
 255   fd_set rkeepfd;
 256   fd_set wkeepfd;
 257   int keepon;
 258
 259 };
 260
 261
 262 /*
 263  * The connectdata struct contains all fields and variables that should be
 264  * unique for an entire connection.
 265  */
 266 struct connectdata {
 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
 270                        struct has */
 271
 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 */
 284
 285   Curl_addrinfo *hostaddr; /* IP-protocol independent host info pointer list */
 286   char *hostent_buf; /* pointer to allocated memory for name info */
 287
 288 #ifdef ENABLE_IPV6
 289   struct addrinfo *serv_addr;   /* the particular host we use */
 290 #else
 291   struct sockaddr_in serv_addr;
 292 #endif
 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! */
 301   char *ppath;
 302   long bytecount;
 303   long headerbytecount;  /* only count received headers */
 304
 305   char *range; /* range, if used. See README for detailed specification on
 306                   this syntax. */
 307   ssize_t resume_from; /* continue [ftp] transfer from here */
 308
 309   char *proxyhost; /* name of the http proxy host */
 310
 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
 316                        means unlimited */
 317
 318   struct ssl_connect_data ssl; /* this is for ssl-stuff */
 319
 320   struct ConnectBits bits;    /* various state-flags for this connection */
 321
 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);
 326
 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.
 329    */
 330   CURLcode (*curl_connect)(struct connectdata *connect);
 331
 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.
 334    */
 335   CURLcode (*curl_disconnect)(struct connectdata *connect);
 336
 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.
 339    */
 340   CURLcode (*curl_close)(struct connectdata *connect);
 341
 342   /**** curl_get() phase fields */
 343
 344   /* READ stuff */
 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 */
 349
 350   /* WRITE stuff */
 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 */
 354
 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 */
 365   } allocptr;
 366
 367   char *newurl; /* This can only be set if a Location: was in the
 368                    document headers */
 369
 370 #ifdef KRB4
 371   enum protection_level command_prot;
 372   enum protection_level data_prot;
 373   enum protection_level request_data_prot;
 374
 375   size_t buffer_size;
 376
 377   struct krb4buffer in_buffer, out_buffer;
 378   int sec_complete;
 379   void *app_data;
 380
 381   struct Curl_sec_client_mech *mech;
 382   struct sockaddr_in local_addr;
 383
 384 #endif
 385
 386   /*************** Request - specific items ************/
 387   /* previously this was in the urldata struct */
 388   union {
 389     struct HTTP *http;
 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 */
 392     struct FTP *ftp;
 393     struct FILE *file;
 394     void *telnet;        /* private for telnet.c-eyes only */
 395 #if 0 /* no need for special ones for these: */
 396     struct LDAP *ldap;
 397     struct DICT *dict;
 398 #endif
 399     void *generic;
 400   } proto;
 401
 402   /* This struct is inited when needed */
 403   struct Curl_transfer_keeper keep;
 404
 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. */
 407   int upload_present;
 408
 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
 412       position */
 413   char *upload_fromhere;
 414 };
 415
 416 /*
 417  * Struct to keep statistical and informational data.
 418  */
 419 struct PureInfo {
 420   int httpcode;
 421   int httpversion;
 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) */
 426
 427   char *contenttype; /* the content type of the object */
 428 };
 429
 430
 431 struct Progress {
 432   long lastshow; /* time() of the last displayed progress meter or NULL to
 433                     force redraw at next call */
 434   double size_dl;
 435   double size_ul;
 436   double downloaded;
 437   double uploaded;
 438
 439   double current_speed; /* uses the currently fastest transfer */
 440
 441   bool callback;  /* set when progress callback is used */
 442   int width; /* screen width at download start */
 443   int flags; /* see progress.h */
 444
 445   double timespent;
 446
 447   double dlspeed;
 448   double ulspeed;
 449
 450   double t_nslookup;
 451   double t_connect;
 452   double t_pretransfer;
 453   double t_starttransfer;
 454
 455   struct timeval start;
 456   struct timeval t_startsingle;
 457 #define CURR_TIME (5+1) /* 6 entries for 5 seconds */
 458
 459   double speeder[ CURR_TIME ];
 460   struct timeval speeder_time[ CURR_TIME ];
 461   int speeder_c;
 462 };
 463
 464 typedef enum {
 465   HTTPREQ_NONE, /* first in list */
 466   HTTPREQ_GET,
 467   HTTPREQ_POST,
 468   HTTPREQ_POST_FORM, /* we make a difference internally */
 469   HTTPREQ_PUT,
 470   HTTPREQ_CUSTOM,
 471   HTTPREQ_LAST /* last in list */
 472 } Curl_HttpReq;
 473
 474 /*
 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.
 479  *
 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
 484
 485 struct UrlState {
 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];
 491
 492   struct timeval keeps_speed; /* for the progress meter really */
 493
 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 */
 498
 499   char *headerbuff; /* allocated buffer to store headers in */
 500   int headersize;   /* size of the allocation */
 501
 502   char buffer[BUFSIZE+1]; /* download buffer */
 503   char uploadbuffer[BUFSIZE+1]; /* upload buffer */
 504   double current_speed;  /* the ProgressShow() funcion sets this */
 505
 506   bool this_is_a_follow; /* this is a followed Location: request */
 507
 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
 511                       strdup() data.
 512                     */
 513
 514   struct curl_ssl_session *session; /* array of 'numsessions' size */
 515   long sessionage;                  /* number of the most recent session */
 516
 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
 520                     called. */
 521
 522 #ifdef HAVE_SIGNAL
 523   /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */
 524   void (*prev_signal)(int sig);
 525 #endif
 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. */
 528 };
 529
 530
 531 /*
 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.
 536  */
 537
 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 */
 545 };
 546
 547 /*
 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.
 553  */
 554
 555 struct UserDefined {
 556   FILE *err;    /* the stderr writes goes here */
 557   char *errorbuffer; /* store failure messages in here */
 558   char *proxyuserpwd;  /* Proxy <user:password>, if used */
 559   long proxyport; /* If non-zero, use this port number by default. If the
 560                      proxy string features a ":[port]" that one will override
 561                      this. */
 562   void *out;         /* the fetched file goes here */
 563   void *in;          /* the uploaded file is read from here */
 564   void *writeheader; /* write the header to this is non-NULL */
 565   char *set_url;     /* what original URL to work on */
 566   char *set_proxy;   /* proxy to use */
 567   long use_port;     /* which port to use (when not using default) */
 568   char *userpwd;     /* <user:password>, if used */
 569   char *set_range;   /* range, if used. See README for detailed specification
 570                         on this syntax. */
 571   long followlocation; /* as in HTTP Location: */
 572   long maxredirs;    /* maximum no. of http(s) redirects to follow */
 573   char *set_referer; /* custom string */
 574   bool free_referer; /* set TRUE if 'referer' points to a string we
 575                         allocated */
 576   char *useragent;   /* User-Agent string */
 577   char *postfields;  /* if POST, set the fields' values here */
 578   size_t postfieldsize; /* if POST, this might have a size to use instead of
 579                            strlen(), and then the data *may* be binary (contain
 580                            zero bytes) */
 581   char *ftpport;     /* port to send with the FTP PORT command */
 582   char *device;      /* network interface to use */
 583   curl_write_callback fwrite;        /* function that stores the output */
 584   curl_write_callback fwrite_header; /* function that stores headers */
 585   curl_read_callback fread;          /* function that reads the input */
 586   curl_progress_callback fprogress;  /* function for progress information */
 587   void *progress_client; /* pointer to pass to the progress callback */
 588   curl_passwd_callback fpasswd;      /* call for password */
 589   void *passwd_client;               /* pass to the passwd callback */
 590   long timeout;         /* in seconds, 0 means no timeout */
 591   long connecttimeout;  /* in seconds, 0 means no timeout */
 592   long infilesize;      /* size of file to upload, -1 means unknown */
 593   long low_speed_limit; /* bytes/second */
 594   long low_speed_time;  /* number of seconds */
 595   int set_resume_from;  /* continue [ftp] transfer from here */
 596   char *cookie;         /* HTTP cookie string to send */
 597   struct curl_slist *headers; /* linked list of extra headers */
 598   struct HttpPost *httppost;  /* linked list of POST data */
 599   char *cert;           /* certificate */
 600   char *cert_type;      /* format for certificate (default: PEM) */
 601   char *key;            /* private key */
 602   char *key_type;       /* format for private key (default: PEM) */
 603   char *key_passwd;     /* plain text private key password */
 604   char *crypto_engine;  /* name of the crypto engine to use */
 605   char *cookiejar;      /* dump all cookies to this file */
 606   bool crlf;            /* convert crlf on ftp upload(?) */
 607   struct curl_slist *quote;     /* before the transfer */
 608   struct curl_slist *postquote; /* after the transfer */
 609   struct curl_slist *telnet_options; /* linked list of telnet options */
 610   curl_TimeCond timecondition; /* kind of time/date comparison */
 611   time_t timevalue;       /* what time to compare with */
 612   curl_closepolicy closepolicy; /* connection cache close concept */
 613   Curl_HttpReq httpreq;   /* what kind of HTTP request (if any) is this */
 614   char *customrequest;    /* HTTP/FTP request to use */
 615   long httpversion; /* when non-zero, a specific HTTP version requested to
 616                        be used in the library's request(s) */
 617   char *auth_host; /* if set, this is the allocated string to the host name
 618                     * to which to send the authorization data to, and no other
 619                     * host (which location-following otherwise could lead to)
 620                     */
 621   char *krb4_level; /* what security level */
 622   struct ssl_config_data ssl;  /* user defined SSL stuff */
 623
 624   int dns_cache_timeout; /* DNS cache timeout */
 625
 626 /* Here follows boolean settings that define how to behave during
 627    this session. They are STATIC, set by libcurl users or at least initially
 628    and they don't change during operations. */
 629
 630   bool get_filetime;
 631   bool tunnel_thru_httpproxy;
 632   bool ftp_append;
 633   bool ftp_ascii;
 634   bool ftp_list_only;
 635   bool ftp_use_port;
 636   bool hide_progress;
 637   bool http_fail_on_error;
 638   bool http_follow_location;
 639   bool include_header;
 640 #define http_include_header include_header /* former name */
 641
 642   bool http_set_referer;
 643   bool http_auto_referer; /* set "correct" referer when following location: */
 644   bool no_body;
 645   bool set_port;
 646   bool upload;
 647   bool use_netrc;
 648   bool verbose;
 649   bool krb4;             /* kerberos4 connection requested */
 650   bool reuse_forbid;     /* forbidden to be reused, close after use */
 651   bool reuse_fresh;      /* do not re-use an existing connection  */
 652   bool expect100header;  /* TRUE if we added Expect: 100-continue */
 653   bool ftp_use_epsv;     /* if EPSV is to be attempted or not */
 654
 655   bool global_dns_cache;
 656 };
 657
 658 /*
 659  * In August 2001, this struct was redesigned and is since stricter than
 660  * before. The 'connectdata' struct MUST have all the connection oriented
 661  * stuff as we may now have several simultaneous connections and connection
 662  * structs in memory.
 663  *
 664  * From now on, the 'SessionHandle' must only contain data that is set once to
 665  * go for many (perhaps) independent connections. Values that are generated or
 666  * calculated internally for the "session handle" must be defined within the
 667  * 'struct urlstate' instead.  */
 668
 669 struct SessionHandle {
 670   curl_hash          *hostcache;
 671   struct UserDefined set;      /* values set by the libcurl user */
 672   struct DynamicStatic change; /* possibly modified userdefined data */
 673
 674   struct CookieInfo *cookies;  /* the cookies, read from files and servers */
 675   struct Progress progress;    /* for all the progress meter data */
 676   struct UrlState state;       /* struct for fields used for state info and
 677                                   other dynamic purposes */
 678   struct PureInfo info;        /* stats, reports and info data */
 679 #ifdef USE_SSLEAY
 680   ENGINE*  engine;
 681 #endif /* USE_SSLEAY */
 682 };
 683
 684 #define LIBCURL_NAME "libcurl"
 685
 686 #endif