lib/urldata.h

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