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