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