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