lib/urldata.h

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