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