lib/urldata.h

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