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