Added two fields in the connectdata struct for kerberos fiddles
[platform/upstream/curl.git] / 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   long verifyhost;       /* 0: no verif, 1: check that CN exists, 2: CN must match hostname */
133   char *CApath;          /* DOES NOT WORK ON WINDOWS */
134   char *CAfile;          /* cerficate to verify peer against */
135   char *random_file;     /* path to file containing "random" data */
136   char *egdsocket;       /* path to file containing the EGD daemon socket */
137 };
138
139 /****************************************************************************
140  * HTTP unique setup
141  ***************************************************************************/
142 struct HTTP {
143   struct FormData *sendit;
144   int postsize;
145   const char *p_pragma;      /* Pragma: string */
146   const char *p_accept;      /* Accept: string */
147   long readbytecount; 
148   long writebytecount;
149
150   /* For FORM posting */
151   struct Form form;
152   curl_read_callback storefread;
153   FILE *in;
154
155   struct Curl_chunker chunk;
156 };
157
158 /****************************************************************************
159  * FTP unique setup
160  ***************************************************************************/
161 struct FTP {
162   long *bytecountp;
163   char *user;    /* user name string */
164   char *passwd;  /* password string */
165   char *urlpath; /* the originally given path part of the URL */
166   char *dir;     /* decoded directory */
167   char *file;    /* decoded file */
168
169   char *entrypath; /* the PWD reply when we logged on */
170 };
171
172 /****************************************************************************
173  * FILE unique setup
174  ***************************************************************************/
175 struct FILE {
176   int fd; /* open file descriptor to read from! */
177 };
178
179 /*
180  * Boolean values that concerns this connection.
181  */
182 struct ConnectBits {
183   bool close; /* if set, we close the connection after this request */
184   bool reuse; /* if set, this is a re-used connection */
185   bool chunk; /* if set, this is a chunked transfer-encoding */
186   bool httpproxy; /* if set, this transfer is done through a http proxy */
187   bool user_passwd;       /* do we use user+password for this connection? */
188   bool proxy_user_passwd; /* user+password for the proxy? */
189
190   bool use_range;
191   bool rangestringalloc; /* the range string is malloc()'ed */
192
193   bool resume_done; /* nothing was transfered, resumed transfer already
194                        complete */
195 };
196
197 /*
198  * The connectdata struct contains all fields and variables that should be
199  * unique for an entire connection.
200  */
201 struct connectdata {
202   /**** Fields set when inited and not modified again */
203   struct UrlData *data; /* link to the root CURL struct */
204   int connectindex; /* what index in the connects index this particular
205                        struct has */
206
207   long protocol; /* PROT_* flags concerning the protocol set */
208 #define PROT_MISSING (1<<0)
209 #define PROT_GOPHER  (1<<1)
210 #define PROT_HTTP    (1<<2)
211 #define PROT_HTTPS   (1<<3)
212 #define PROT_FTP     (1<<4)
213 #define PROT_TELNET  (1<<5)
214 #define PROT_DICT    (1<<6)
215 #define PROT_LDAP    (1<<7)
216 #define PROT_FILE    (1<<8)
217 #define PROT_FTPS    (1<<9)
218
219 #ifdef ENABLE_IPV6
220   struct addrinfo *hp; /* host info pointer list */
221   struct addrinfo *ai; /* the particular host we use */
222 #else
223   char *hostent_buf; /* pointer to allocated memory for name info */
224   struct hostent *hp;
225   struct sockaddr_in serv_addr;
226 #endif
227   char protostr[64];  /* store the protocol string in this buffer */
228   char gname[257]; /* store the hostname in this buffer */
229   char *name;      /* host name pointer to fool around with */
230   char *path;      /* allocated buffer to store the URL's path part in */
231   char *hostname;  /* hostname to connect, as parsed from url */
232   long port;       /* which port to use locally */
233   unsigned short remote_port; /* what remote port to connect to,
234                                  not the proxy port! */
235   char *ppath;
236   long bytecount;
237
238   char *range; /* range, if used. See README for detailed specification on
239                   this syntax. */
240   int resume_from; /* continue [ftp] transfer from here */
241
242   char *proxyhost; /* name of the http proxy host */
243
244   struct timeval now;     /* "current" time */
245   struct timeval created; /* creation time */
246   int firstsocket;     /* the main socket to use */
247   int secondarysocket; /* for i.e ftp transfers */
248
249   long upload_bufsize; /* adjust as you see fit, never bigger than BUFSIZE
250                           never smaller than UPLOAD_BUFSIZE */
251
252   long maxdownload; /* in bytes, the maximum amount of data to fetch, 0
253                        means unlimited */
254   
255   struct ssl_connect_data ssl; /* this is for ssl-stuff */
256
257   struct ConnectBits bits;    /* various state-flags for this connection */
258
259   /* These two functions MUST be set by the curl_connect() function to be
260      be protocol dependent */
261   CURLcode (*curl_do)(struct connectdata *connect);
262   CURLcode (*curl_done)(struct connectdata *connect);
263
264   /* This function *MAY* be set to a protocol-dependent function that is run
265    * after the connect() and everything is done, as a step in the connection.
266    */ 
267   CURLcode (*curl_connect)(struct connectdata *connect);
268
269   /* This function *MAY* be set to a protocol-dependent function that is run
270    * by the curl_disconnect(), as a step in the disconnection.
271    */ 
272   CURLcode (*curl_disconnect)(struct connectdata *connect);
273
274   /* This function *MAY* be set to a protocol-dependent function that is run
275    * in the curl_close() function if protocol-specific cleanups are required.
276    */ 
277   CURLcode (*curl_close)(struct connectdata *connect);
278
279   /**** curl_get() phase fields */
280
281   /* READ stuff */
282   int sockfd;            /* socket to read from or -1 */
283   int size;              /* -1 if unknown at this point */
284   bool getheader;        /* TRUE if header parsing is wanted */
285   long *bytecountp;      /* return number of bytes read or NULL */
286           
287   /* WRITE stuff */
288   int writesockfd;       /* socket to write to, it may very well be
289                             the same we read from. -1 disables */
290   long *writebytecountp; /* return number of bytes written or NULL */
291
292   /** Dynamicly allocated strings, may need to be freed before this **/
293   /** struct is killed.                                             **/
294   struct dynamically_allocated_data {
295     char *proxyuserpwd; /* free later if not NULL! */
296     char *uagent; /* free later if not NULL! */
297     char *userpwd; /* free later if not NULL! */
298     char *rangeline; /* free later if not NULL! */
299     char *ref; /* free later if not NULL! */
300     char *cookie; /* free later if not NULL! */
301     char *host; /* free later if not NULL */
302   } allocptr;
303
304   char *newurl; /* This can only be set if a Location: was in the
305                    document headers */
306
307 #ifdef KRB4
308   enum protection_level command_prot;
309   enum protection_level data_prot;
310   enum protection_level request_data_prot;
311
312   size_t buffer_size;
313
314   struct krb4buffer in_buffer, out_buffer;
315   int sec_complete;
316   void *app_data;
317
318   struct Curl_sec_client_mech *mech;
319   struct sockaddr_in local_addr;
320
321 #endif
322
323   /*************** Request - specific items ************/
324   /* previously this was in the urldata struct */
325   union {
326     struct HTTP *http;
327     struct HTTP *gopher; /* alias, just for the sake of being more readable */
328     struct HTTP *https;  /* alias, just for the sake of being more readable */
329     struct FTP *ftp;
330     struct FILE *file;
331     void *telnet;        /* private for telnet.c-eyes only */
332 #if 0 /* no need for special ones for these: */
333     struct LDAP *ldap;
334     struct DICT *dict;
335 #endif
336     void *generic;
337   } proto;
338
339
340 };
341
342 struct Progress {
343   long lastshow; /* time() of the last displayed progress meter or NULL to
344                     force redraw at next call */
345   double size_dl;
346   double size_ul;
347   double downloaded;
348   double uploaded;
349
350   double current_speed; /* uses the currently fastest transfer */
351
352   bool callback;  /* set when progress callback is used */
353   int width; /* screen width at download start */
354   int flags; /* see progress.h */
355   double timespent;
356   double dlspeed;
357   double ulspeed;
358
359   struct timeval start;
360   struct timeval t_startsingle;
361   /* various data stored for possible later report */
362   double t_nslookup;
363   double t_connect;
364   double t_pretransfer;
365   int httpcode;
366   int httpversion;
367   time_t filetime; /* If requested, this is might get set. It may be 0 if
368                       the time was unretrievable */
369
370 #define CURR_TIME 5
371
372   double speeder[ CURR_TIME ];
373   int speeder_c;
374 };
375
376 typedef enum {
377   HTTPREQ_NONE, /* first in list */
378   HTTPREQ_GET,
379   HTTPREQ_POST,
380   HTTPREQ_POST_FORM, /* we make a difference internally */
381   HTTPREQ_PUT,
382   HTTPREQ_CUSTOM,
383   HTTPREQ_LAST /* last in list */
384 } Curl_HttpReq;
385
386 /* This struct is for boolean settings that define how to behave during
387    this session. */
388 struct Configbits {
389   bool get_filetime;
390   bool tunnel_thru_httpproxy;
391   bool ftp_append;
392   bool ftp_ascii;
393   bool ftp_list_only;
394   bool ftp_use_port;
395   bool hide_progress;
396   bool http_fail_on_error;
397   bool http_follow_location;
398   bool http_include_header;
399   bool http_set_referer;
400   bool http_auto_referer; /* set "correct" referer when following location: */
401   bool httpproxy;
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   size_t 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   long 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
580 #endif