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