lib/urldata.h

   1 #ifndef __URLDATA_H
   2 #define __URLDATA_H
   3 /*****************************************************************************
   4  *                                  _   _ ____  _
   5  *  Project                     ___| | | |  _ \| |
   6  *                             / __| | | | |_) | |
   7  *                            | (__| |_| |  _ <| |___
   8  *                             \___|\___/|_| \_\_____|
   9  *
  10  * Copyright (C) 2001, 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
  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 #else
  61 #include "rsa.h"
  62 #include "crypto.h"
  63 #include "x509.h"
  64 #include "pem.h"
  65 #include "ssl.h"
  66 #include "err.h"
  67 #endif
  68 #endif
  69
  70 #ifdef HAVE_NETINET_IN_H
  71 #include <netinet/in.h>
  72 #endif
  73
  74 #include "timeval.h"
  75
  76 #include <curl/curl.h>
  77
  78 #include "http_chunks.h" /* for the structs and enum stuff */
  79
  80 /* Download buffer size, keep it fairly big for speed reasons */
  81 #define BUFSIZE (1024*50)
  82
  83 /* Defaul upload buffer size, keep it smallish to get faster progress meter
  84    updates. This is just default, it is dynamic and adjusts to the upload
  85    speed. */
  86 #define UPLOAD_BUFSIZE (1024*2)
  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 /* struct for data related to SSL and SSL connections */
 114 struct ssl_connect_data {
 115   bool use;              /* use ssl encrypted communications TRUE/FALSE */
 116 #ifdef USE_SSLEAY
 117   /* these ones requires specific SSL-types */
 118   SSL_CTX* ctx;
 119   SSL*     handle;
 120   X509*    server_cert;
 121 #endif /* USE_SSLEAY */
 122 };
 123
 124 /* information about one single SSL session */
 125 struct curl_ssl_session {
 126   char *name;       /* host name for which this ID was used */
 127   void *sessionid;  /* as returned from the SSL layer */
 128   long age;         /* just a number, the higher the more recent */
 129   unsigned short remote_port; /* remote port to connect to */
 130 };
 131
 132 struct ssl_config_data {
 133   long version;          /* what version the client wants to use */
 134   long certverifyresult; /* result from the certificate verification */
 135   long verifypeer;       /* set TRUE if this is desired */
 136   long verifyhost;       /* 0: no verif, 1: check that CN exists, 2: CN must match hostname */
 137   char *CApath;          /* DOES NOT WORK ON WINDOWS */
 138   char *CAfile;          /* cerficate to verify peer against */
 139   char *random_file;     /* path to file containing "random" data */
 140   char *egdsocket;       /* path to file containing the EGD daemon socket */
 141
 142   long numsessions;                 /* SSL session id cache size */
 143 };
 144
 145 /****************************************************************************
 146  * HTTP unique setup
 147  ***************************************************************************/
 148 struct HTTP {
 149   struct FormData *sendit;
 150   int postsize;
 151   const char *p_pragma;      /* Pragma: string */
 152   const char *p_accept;      /* Accept: string */
 153   long readbytecount;
 154   long writebytecount;
 155
 156   /* For FORM posting */
 157   struct Form form;
 158   curl_read_callback storefread;
 159   FILE *in;
 160
 161   struct Curl_chunker chunk;
 162 };
 163
 164 /****************************************************************************
 165  * FTP unique setup
 166  ***************************************************************************/
 167 struct FTP {
 168   long *bytecountp;
 169   char *user;    /* user name string */
 170   char *passwd;  /* password string */
 171   char *urlpath; /* the originally given path part of the URL */
 172   char *dir;     /* decoded directory */
 173   char *file;    /* decoded file */
 174
 175   char *entrypath; /* the PWD reply when we logged on */
 176 };
 177
 178 /****************************************************************************
 179  * FILE unique setup
 180  ***************************************************************************/
 181 struct FILE {
 182   int fd; /* open file descriptor to read from! */
 183 };
 184
 185 /*
 186  * Boolean values that concerns this connection.
 187  */
 188 struct ConnectBits {
 189   bool close; /* if set, we close the connection after this request */
 190   bool reuse; /* if set, this is a re-used connection */
 191   bool chunk; /* if set, this is a chunked transfer-encoding */
 192   bool httpproxy;    /* if set, this transfer is done through a http proxy */
 193   bool user_passwd;    /* do we use user+password for this connection? */
 194   bool proxy_user_passwd; /* user+password for the proxy? */
 195
 196   bool use_range;
 197   bool rangestringalloc; /* the range string is malloc()'ed */
 198
 199   bool resume_done; /* nothing was transfered, resumed transfer already
 200                        complete */
 201 };
 202
 203 /*
 204  * The connectdata struct contains all fields and variables that should be
 205  * unique for an entire connection.
 206  */
 207 struct connectdata {
 208   /**** Fields set when inited and not modified again */
 209   struct SessionHandle *data; /* link to the root CURL struct */
 210   int connectindex; /* what index in the connects index this particular
 211                        struct has */
 212
 213   long protocol; /* PROT_* flags concerning the protocol set */
 214 #define PROT_MISSING (1<<0)
 215 #define PROT_GOPHER  (1<<1)
 216 #define PROT_HTTP    (1<<2)
 217 #define PROT_HTTPS   (1<<3)
 218 #define PROT_FTP     (1<<4)
 219 #define PROT_TELNET  (1<<5)
 220 #define PROT_DICT    (1<<6)
 221 #define PROT_LDAP    (1<<7)
 222 #define PROT_FILE    (1<<8)
 223 #define PROT_FTPS    (1<<9)
 224
 225 #ifdef ENABLE_IPV6
 226   struct addrinfo *hp; /* host info pointer list */
 227   struct addrinfo *ai; /* the particular host we use */
 228 #else
 229   char *hostent_buf; /* pointer to allocated memory for name info */
 230   struct hostent *hp;
 231   struct sockaddr_in serv_addr;
 232 #endif
 233   char protostr[64];  /* store the protocol string in this buffer */
 234   char gname[257]; /* store the hostname in this buffer */
 235   char *name;      /* host name pointer to fool around with */
 236   char *path;      /* allocated buffer to store the URL's path part in */
 237   char *hostname;  /* hostname to connect, as parsed from url */
 238   long port;       /* which port to use locally */
 239   unsigned short remote_port; /* what remote port to connect to,
 240                                  not the proxy port! */
 241   char *ppath;
 242   long bytecount;
 243
 244   char *range; /* range, if used. See README for detailed specification on
 245                   this syntax. */
 246   int resume_from; /* continue [ftp] transfer from here */
 247
 248   char *proxyhost; /* name of the http proxy host */
 249
 250   struct timeval now;     /* "current" time */
 251   struct timeval created; /* creation time */
 252   int firstsocket;     /* the main socket to use */
 253   int secondarysocket; /* for i.e ftp transfers */
 254
 255   long upload_bufsize; /* adjust as you see fit, never bigger than BUFSIZE
 256                           never smaller than UPLOAD_BUFSIZE */
 257
 258   long maxdownload; /* in bytes, the maximum amount of data to fetch, 0
 259                        means unlimited */
 260
 261   struct ssl_connect_data ssl; /* this is for ssl-stuff */
 262
 263   struct ConnectBits bits;    /* various state-flags for this connection */
 264
 265   /* These two functions MUST be set by the curl_connect() function to be
 266      be protocol dependent */
 267   CURLcode (*curl_do)(struct connectdata *connect);
 268   CURLcode (*curl_done)(struct connectdata *connect);
 269
 270   /* This function *MAY* be set to a protocol-dependent function that is run
 271    * after the connect() and everything is done, as a step in the connection.
 272    */
 273   CURLcode (*curl_connect)(struct connectdata *connect);
 274
 275   /* This function *MAY* be set to a protocol-dependent function that is run
 276    * by the curl_disconnect(), as a step in the disconnection.
 277    */
 278   CURLcode (*curl_disconnect)(struct connectdata *connect);
 279
 280   /* This function *MAY* be set to a protocol-dependent function that is run
 281    * in the curl_close() function if protocol-specific cleanups are required.
 282    */
 283   CURLcode (*curl_close)(struct connectdata *connect);
 284
 285   /**** curl_get() phase fields */
 286
 287   /* READ stuff */
 288   int sockfd;            /* socket to read from or -1 */
 289   int size;              /* -1 if unknown at this point */
 290   bool getheader;        /* TRUE if header parsing is wanted */
 291   long *bytecountp;      /* return number of bytes read or NULL */
 292
 293   /* WRITE stuff */
 294   int writesockfd;       /* socket to write to, it may very well be
 295                             the same we read from. -1 disables */
 296   long *writebytecountp; /* return number of bytes written or NULL */
 297
 298   /** Dynamicly allocated strings, may need to be freed before this **/
 299   /** struct is killed.                                             **/
 300   struct dynamically_allocated_data {
 301     char *proxyuserpwd; /* free later if not NULL! */
 302     char *uagent; /* free later if not NULL! */
 303     char *userpwd; /* free later if not NULL! */
 304     char *rangeline; /* free later if not NULL! */
 305     char *ref; /* free later if not NULL! */
 306     char *cookie; /* free later if not NULL! */
 307     char *host; /* free later if not NULL */
 308   } allocptr;
 309
 310   char *newurl; /* This can only be set if a Location: was in the
 311                    document headers */
 312
 313 #ifdef KRB4
 314   enum protection_level command_prot;
 315   enum protection_level data_prot;
 316   enum protection_level request_data_prot;
 317
 318   size_t buffer_size;
 319
 320   struct krb4buffer in_buffer, out_buffer;
 321   int sec_complete;
 322   void *app_data;
 323
 324   struct Curl_sec_client_mech *mech;
 325   struct sockaddr_in local_addr;
 326
 327 #endif
 328
 329   /*************** Request - specific items ************/
 330   /* previously this was in the urldata struct */
 331   union {
 332     struct HTTP *http;
 333     struct HTTP *gopher; /* alias, just for the sake of being more readable */
 334     struct HTTP *https;  /* alias, just for the sake of being more readable */
 335     struct FTP *ftp;
 336     struct FILE *file;
 337     void *telnet;        /* private for telnet.c-eyes only */
 338 #if 0 /* no need for special ones for these: */
 339     struct LDAP *ldap;
 340     struct DICT *dict;
 341 #endif
 342     void *generic;
 343   } proto;
 344
 345 };
 346
 347 /*
 348  * Struct to keep statistical and informational data.
 349  */
 350 struct PureInfo {
 351   int httpcode;
 352   int httpversion;
 353   time_t filetime; /* If requested, this is might get set. It may be 0 if
 354                       the time was unretrievable */
 355   long header_size;  /* size of read header(s) in bytes */
 356   long request_size; /* the amount of bytes sent in the request(s) */
 357 };
 358
 359
 360 struct Progress {
 361   long lastshow; /* time() of the last displayed progress meter or NULL to
 362                     force redraw at next call */
 363   double size_dl;
 364   double size_ul;
 365   double downloaded;
 366   double uploaded;
 367
 368   double current_speed; /* uses the currently fastest transfer */
 369
 370   bool callback;  /* set when progress callback is used */
 371   int width; /* screen width at download start */
 372   int flags; /* see progress.h */
 373   double timespent;
 374   double dlspeed;
 375   double ulspeed;
 376
 377   double t_nslookup;
 378   double t_connect;
 379   double t_pretransfer;
 380
 381   struct timeval start;
 382   struct timeval t_startsingle;
 383 #define CURR_TIME 5
 384
 385   double speeder[ CURR_TIME ];
 386   int speeder_c;
 387 };
 388
 389 typedef enum {
 390   HTTPREQ_NONE, /* first in list */
 391   HTTPREQ_GET,
 392   HTTPREQ_POST,
 393   HTTPREQ_POST_FORM, /* we make a difference internally */
 394   HTTPREQ_PUT,
 395   HTTPREQ_CUSTOM,
 396   HTTPREQ_LAST /* last in list */
 397 } Curl_HttpReq;
 398
 399 /*
 400  * Values that are generated, temporary or calculated internally for a
 401  * "session handle" must be defined within the 'struct urlstate'.  This struct
 402  * will be used within the SessionHandle struct. When the 'SessionHandle'
 403  * struct is cloned, this data MUST NOT be copied.
 404  *
 405  * Remember that any "state" information goes globally for the curl handle.
 406  * Session-data MUST be put in the connectdata struct and here.  */
 407 #define MAX_CURL_USER_LENGTH 256
 408 #define MAX_CURL_PASSWORD_LENGTH 256
 409
 410 struct UrlState {
 411   /* buffers to store authentication data in, as parsed from input options */
 412   char user[MAX_CURL_USER_LENGTH];
 413   char passwd[MAX_CURL_PASSWORD_LENGTH];
 414   char proxyuser[MAX_CURL_USER_LENGTH];
 415   char proxypasswd[MAX_CURL_PASSWORD_LENGTH];
 416
 417   struct timeval keeps_speed; /* for the progress meter really */
 418
 419   /* 'connects' will be an allocated array with pointers. If the pointer is
 420      set, it holds an allocated connection. */
 421   struct connectdata **connects;
 422   long numconnects; /* size of the 'connects' array */
 423
 424   char *headerbuff; /* allocated buffer to store headers in */
 425   int headersize;   /* size of the allocation */
 426
 427   char buffer[BUFSIZE+1]; /* buffer with size BUFSIZE */
 428
 429   double current_speed;  /* the ProgressShow() funcion sets this */
 430
 431   bool this_is_a_follow; /* this is a followed Location: request */
 432
 433   char *auth_host; /* if set, this should be the host name that we will
 434                       sent authorization to, no else. Used to make Location:
 435                       following not keep sending user+password... This is
 436                       strdup() data.
 437                     */
 438
 439   struct curl_ssl_session *session; /* array of 'numsessions' size */
 440   long sessionage;                  /* number of the most recent session */
 441 };
 442
 443
 444 /*
 445  * This 'DynamicStatic' struct defines dynamic states that actually change
 446  * values in the 'UserDefined' area, which MUST be taken into consideration
 447  * if the UserDefined struct is cloned or similar. You can probably just
 448  * copy these, but each one indicate a special action on other data.
 449  */
 450
 451 struct DynamicStatic {
 452   char *url;        /* work URL, copied from UserDefined */
 453   bool url_alloc;   /* URL string is malloc()'ed */
 454   char *proxy;      /* work proxy, copied from UserDefined */
 455   bool proxy_alloc; /* http proxy string is malloc()'ed */
 456   char *referer;    /* referer string */
 457   bool referer_alloc; /* referer sting is malloc()ed */
 458 };
 459
 460 /*
 461  * This 'UserDefined' struct must only contain data that is set once to go
 462  * for many (perhaps) independent connections. Values that are generated or
 463  * calculated internally for the "session handle" MUST be defined within the
 464  * 'struct urlstate' instead. The only exceptions MUST note the changes in
 465  * the 'DynamicStatic' struct.
 466  */
 467
 468 struct UserDefined {
 469   FILE *err;    /* the stderr writes goes here */
 470   char *errorbuffer; /* store failure messages in here */
 471   char *proxyuserpwd;  /* Proxy <user:password>, if used */
 472   long proxyport; /* If non-zero, use this port number by default. If the
 473                      proxy string features a ":[port]" that one will override
 474                      this. */
 475   void *out;         /* the fetched file goes here */
 476   void *in;          /* the uploaded file is read from here */
 477   void *writeheader; /* write the header to this is non-NULL */
 478   char *set_url;     /* what original URL to work on */
 479   char *set_proxy;   /* proxy to use */
 480   long use_port;     /* which port to use (when not using default) */
 481   char *userpwd;     /* <user:password>, if used */
 482   char *set_range;   /* range, if used. See README for detailed specification
 483                         on this syntax. */
 484   long followlocation; /* as in HTTP Location: */
 485   long maxredirs;    /* maximum no. of http(s) redirects to follow */
 486   char *set_referer; /* custom string */
 487   bool free_referer; /* set TRUE if 'referer' points to a string we
 488                         allocated */
 489   char *useragent;   /* User-Agent string */
 490   char *postfields;  /* if POST, set the fields' values here */
 491   size_t postfieldsize; /* if POST, this might have a size to use instead of
 492                            strlen(), and then the data *may* be binary (contain
 493                            zero bytes) */
 494   char *ftpport;     /* port to send with the FTP PORT command */
 495   char *device;      /* network interface to use */
 496   curl_write_callback fwrite;        /* function that stores the output */
 497   curl_write_callback fwrite_header; /* function that stores headers */
 498   curl_read_callback fread;          /* function that reads the input */
 499   curl_progress_callback fprogress;  /* function for progress information */
 500   void *progress_client; /* pointer to pass to the progress callback */
 501   curl_passwd_callback fpasswd;      /* call for password */
 502   void *passwd_client;               /* pass to the passwd callback */
 503   long timeout;         /* in seconds, 0 means no timeout */
 504   long connecttimeout;  /* in seconds, 0 means no timeout */
 505   long infilesize;      /* size of file to upload, -1 means unknown */
 506   long low_speed_limit; /* bytes/second */
 507   long low_speed_time;  /* number of seconds */
 508   int set_resume_from;  /* continue [ftp] transfer from here */
 509   char *cookie;         /* HTTP cookie string to send */
 510   struct curl_slist *headers; /* linked list of extra headers */
 511   struct HttpPost *httppost;  /* linked list of POST data */
 512   char *cert;           /* PEM-formatted certificate */
 513   char *cert_passwd;    /* plain text certificate password */
 514   char *cookiejar;      /* dump all cookies to this file */
 515   bool crlf;            /* convert crlf on ftp upload(?) */
 516   struct curl_slist *quote;     /* before the transfer */
 517   struct curl_slist *postquote; /* after the transfer */
 518   struct curl_slist *telnet_options; /* linked list of telnet options */
 519   TimeCond timecondition; /* kind of time/date comparison */
 520   time_t timevalue;       /* what time to compare with */
 521   curl_closepolicy closepolicy; /* connection cache close concept */
 522   Curl_HttpReq httpreq;   /* what kind of HTTP request (if any) is this */
 523   char *customrequest;    /* HTTP/FTP request to use */
 524   char *auth_host; /* if set, this is the allocated string to the host name
 525                     * to which to send the authorization data to, and no other
 526                     * host (which location-following otherwise could lead to)
 527                     */
 528   char *krb4_level; /* what security level */
 529   struct ssl_config_data ssl;  /* user defined SSL stuff */
 530
 531 /* Here follows boolean settings that define how to behave during
 532    this session. They are STATIC, set by libcurl users or at least initially
 533    and they don't change during operations. */
 534
 535   bool get_filetime;
 536   bool tunnel_thru_httpproxy;
 537   bool ftp_append;
 538   bool ftp_ascii;
 539   bool ftp_list_only;
 540   bool ftp_use_port;
 541   bool hide_progress;
 542   bool http_fail_on_error;
 543   bool http_follow_location;
 544   bool http_include_header;
 545   bool http_set_referer;
 546   bool http_auto_referer; /* set "correct" referer when following location: */
 547   bool no_body;
 548   bool set_port;
 549   bool upload;
 550   bool use_netrc;
 551   bool verbose;
 552   bool krb4;             /* kerberos4 connection requested */
 553   bool reuse_forbid;     /* forbidden to be reused, close after use */
 554   bool reuse_fresh;      /* do not re-use an existing connection  */
 555   bool expect100header;  /* TRUE if we added Expect: 100-continue */
 556 };
 557
 558 /*
 559  * In August 2001, this struct was redesigned and is since stricter than
 560  * before. The 'connectdata' struct MUST have all the connection oriented
 561  * stuff as we may now have several simultaneous connections and connection
 562  * structs in memory.
 563  *
 564  * From now on, the 'SessionHandle' must only contain data that is set once to
 565  * go for many (perhaps) independent connections. Values that are generated or
 566  * calculated internally for the "session handle" must be defined within the
 567  * 'struct urlstate' instead.  */
 568
 569 struct SessionHandle {
 570   struct UserDefined set;      /* values set by the libcurl user */
 571   struct DynamicStatic change; /* possibly modified userdefined data */
 572
 573   struct CookieInfo *cookies;  /* the cookies, read from files and servers */
 574   struct Progress progress;    /* for all the progress meter data */
 575   struct UrlState state;       /* struct for fields used for state info and
 576                                   other dynamic purposes */
 577   struct PureInfo info;        /* stats, reports and info data */
 578 };
 579
 580 #define LIBCURL_NAME "libcurl"
 581
 582 #endif