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