CMake/Source/CTest/Curl/urldata.h

959 lines
36 KiB
C
Raw Normal View History

2003-01-07 05:13:39 +03:00
#ifndef __URLDATA_H
#define __URLDATA_H
2003-01-10 07:26:37 +03:00
/***************************************************************************
2004-10-05 17:34:20 +04:00
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
2003-01-07 05:13:39 +03:00
* \___|\___/|_| \_\_____|
*
2004-10-05 17:34:20 +04:00
* Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
2003-01-07 05:13:39 +03:00
*
2003-01-10 07:26:37 +03:00
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at http://curl.haxx.se/docs/copyright.html.
2004-10-05 17:34:20 +04:00
*
2003-01-07 05:13:39 +03:00
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
* copies of the Software, and permit persons to whom the Software is
2003-01-10 07:26:37 +03:00
* furnished to do so, under the terms of the COPYING file.
2003-01-07 05:13:39 +03:00
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
* $Id$
2003-01-10 07:26:37 +03:00
***************************************************************************/
2003-01-07 05:13:39 +03:00
/* This file is for lib internal stuff */
#include "setup.h"
#define PORT_FTP 21
2004-10-05 17:34:20 +04:00
#define PORT_FTPS 990
2003-01-07 05:13:39 +03:00
#define PORT_TELNET 23
#define PORT_GOPHER 70
#define PORT_HTTP 80
#define PORT_HTTPS 443
#define PORT_DICT 2628
#define PORT_LDAP 389
#define DICT_MATCH "/MATCH:"
#define DICT_MATCH2 "/M:"
#define DICT_MATCH3 "/FIND:"
#define DICT_DEFINE "/DEFINE:"
#define DICT_DEFINE2 "/D:"
#define DICT_DEFINE3 "/LOOKUP:"
#define CURL_DEFAULT_USER "anonymous"
#define CURL_DEFAULT_PASSWORD "curl_by_daniel@haxx.se"
#include "cookie.h"
#include "formdata.h"
2004-10-05 17:34:20 +04:00
2003-01-07 05:13:39 +03:00
#ifdef USE_SSLEAY
/* SSLeay stuff usually in /usr/local/ssl/include */
#ifdef USE_OPENSSL
#include "openssl/rsa.h"
#include "openssl/crypto.h"
#include "openssl/x509.h"
#include "openssl/pem.h"
#include "openssl/ssl.h"
#include "openssl/err.h"
#ifdef HAVE_OPENSSL_ENGINE_H
#include <openssl/engine.h>
#endif
#else
#include "rsa.h"
#include "crypto.h"
#include "x509.h"
#include "pem.h"
#include "ssl.h"
#include "err.h"
#endif
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#include "timeval.h"
2004-10-05 17:34:20 +04:00
#ifdef HAVE_ZLIB_H
#include <zlib.h> /* for content-encoding */
#endif
#ifdef USE_ARES
#include <ares.h>
#endif
2003-01-07 05:13:39 +03:00
#include <curl/curl.h>
#include "http_chunks.h" /* for the structs and enum stuff */
2003-01-10 07:26:37 +03:00
#include "hostip.h"
#include "hash.h"
2004-10-05 17:34:20 +04:00
#ifdef HAVE_GSSAPI
#ifdef HAVE_GSSMIT
#include <gssapi/gssapi.h>
#include <gssapi/gssapi_generic.h>
#else
#include <gssapi.h>
#endif
2003-01-10 07:26:37 +03:00
#endif
2003-01-07 05:13:39 +03:00
/* Download buffer size, keep it fairly big for speed reasons */
2003-01-10 07:26:37 +03:00
#define BUFSIZE CURL_MAX_WRITE_SIZE
2003-01-07 05:13:39 +03:00
/* Initial size of the buffer to store headers in, it'll be enlarged in case
of need. */
#define HEADERSIZE 256
2004-10-05 17:34:20 +04:00
/* Just a convenience macro to get the larger value out of two given.
We prefix with CURL to prevent name collisions. */
#define CURLMAX(x,y) ((x)>(y)?(x):(y))
2003-01-07 05:13:39 +03:00
2004-10-05 17:34:20 +04:00
#ifdef HAVE_KRB4
2003-01-07 05:13:39 +03:00
/* Types needed for krb4-ftp connections */
struct krb4buffer {
void *data;
size_t size;
size_t index;
int eof_flag;
};
2004-10-05 17:34:20 +04:00
enum protection_level {
prot_clear,
prot_safe,
prot_confidential,
prot_private
2003-01-07 05:13:39 +03:00
};
#endif
2004-10-05 17:34:20 +04:00
/* struct for data related to each SSL connection */
2003-01-07 05:13:39 +03:00
struct ssl_connect_data {
2004-10-05 17:34:20 +04:00
bool use; /* use ssl encrypted communications TRUE/FALSE */
2003-01-07 05:13:39 +03:00
#ifdef USE_SSLEAY
/* these ones requires specific SSL-types */
SSL_CTX* ctx;
SSL* handle;
X509* server_cert;
#endif /* USE_SSLEAY */
};
struct ssl_config_data {
long version; /* what version the client wants to use */
long certverifyresult; /* result from the certificate verification */
long verifypeer; /* set TRUE if this is desired */
2003-01-10 07:26:37 +03:00
long verifyhost; /* 0: no verify
1: check that CN exists
2: CN must match hostname */
2003-01-07 05:13:39 +03:00
char *CApath; /* DOES NOT WORK ON WINDOWS */
char *CAfile; /* cerficate to verify peer against */
char *random_file; /* path to file containing "random" data */
char *egdsocket; /* path to file containing the EGD daemon socket */
char *cipher_list; /* list of ciphers to use */
2003-01-10 07:26:37 +03:00
long numsessions; /* SSL session id cache size */
2004-10-05 17:34:20 +04:00
curl_ssl_ctx_callback fsslctx; /* function to initialize ssl ctx */
void *fsslctxp; /*parameter for call back */
2003-01-07 05:13:39 +03:00
};
2004-10-05 17:34:20 +04:00
/* information stored about one single SSL session */
struct curl_ssl_session {
char *name; /* host name for which this ID was used */
void *sessionid; /* as returned from the SSL layer */
long age; /* just a number, the higher the more recent */
unsigned short remote_port; /* remote port to connect to */
struct ssl_config_data ssl_config; /* setup for this session */
};
/* Struct used for Digest challenge-response authentication */
struct digestdata {
char *nonce;
char *cnonce;
char *realm;
int algo;
bool stale; /* set true for re-negotiation */
char *opaque;
char *qop;
char *algorithm;
int nc; /* nounce count */
};
typedef enum {
NTLMSTATE_NONE,
NTLMSTATE_TYPE1,
NTLMSTATE_TYPE2,
NTLMSTATE_TYPE3,
NTLMSTATE_LAST
} curlntlm;
/* for 3rd party transfers to decide which side that issues PASV */
typedef enum {
CURL_TARGET_PASV,
CURL_SOURCE_PASV
} curl_pasv_side;
/* Struct used for NTLM challenge-response authentication */
struct ntlmdata {
curlntlm state;
unsigned char nonce[8];
};
#ifdef HAVE_GSSAPI
struct negotiatedata {
bool gss; /* Whether we're processing GSS-Negotiate or Negotiate */
const char* protocol; /* "GSS-Negotiate" or "Negotiate" */
OM_uint32 status;
gss_ctx_id_t context;
gss_name_t server_name;
gss_buffer_desc output_token;
};
#endif
2003-01-07 05:13:39 +03:00
/****************************************************************************
* HTTP unique setup
***************************************************************************/
struct HTTP {
struct FormData *sendit;
2004-10-05 17:34:20 +04:00
curl_off_t postsize; /* off_t to handle large file sizes */
2003-01-14 17:12:37 +03:00
char *postdata;
2003-01-07 05:13:39 +03:00
const char *p_pragma; /* Pragma: string */
const char *p_accept; /* Accept: string */
2004-10-05 17:34:20 +04:00
curl_off_t readbytecount;
curl_off_t writebytecount;
2003-01-07 05:13:39 +03:00
/* For FORM posting */
struct Form form;
struct Curl_chunker chunk;
2003-01-14 17:12:37 +03:00
struct back {
curl_read_callback fread; /* backup storage for fread pointer */
void *fread_in; /* backup storage for fread_in pointer */
char *postdata;
2004-10-05 17:34:20 +04:00
curl_off_t postsize;
2003-01-14 17:12:37 +03:00
} backup;
enum {
HTTPSEND_NADA, /* init */
HTTPSEND_REQUEST, /* sending a request */
HTTPSEND_BODY, /* sending body */
HTTPSEND_LAST /* never use this */
} sending;
void *send_buffer; /* used if the request couldn't be sent in one chunk,
points to an allocated send_buffer struct */
2003-01-07 05:13:39 +03:00
};
/****************************************************************************
* FTP unique setup
***************************************************************************/
struct FTP {
2004-10-05 17:34:20 +04:00
curl_off_t *bytecountp;
2003-01-07 05:13:39 +03:00
char *user; /* user name string */
char *passwd; /* password string */
char *urlpath; /* the originally given path part of the URL */
2004-10-05 17:34:20 +04:00
char **dirs; /* realloc()ed array for path components */
int dirdepth; /* number of entries used in the 'dirs' array */
int diralloc; /* number of entries allocated for the 'dirs' array */
2003-01-07 05:13:39 +03:00
char *file; /* decoded file */
char *entrypath; /* the PWD reply when we logged on */
char *cache; /* data cache between getresponse()-calls */
2004-10-05 17:34:20 +04:00
curl_off_t cache_size; /* size of cache in bytes */
2003-01-10 07:26:37 +03:00
bool dont_check; /* Set to TRUE to prevent the final (post-transfer)
file size and 226/250 status check. It should still
read the line, just ignore the result. */
bool no_transfer; /* nothing was transfered, (possibly because a resumed
transfer already was complete) */
2003-01-14 17:12:37 +03:00
long response_time; /* When no timeout is given, this is the amount of
seconds we await for an FTP response. Initialized
in Curl_ftp_connect() */
2004-10-05 17:34:20 +04:00
bool ctl_valid; /* Tells Curl_ftp_quit() whether or not to do
anything. If the connection has timed out or
been closed, this should be FALSE when it gets
to Curl_ftp_quit() */
2003-01-07 05:13:39 +03:00
};
/****************************************************************************
* FILE unique setup
***************************************************************************/
2004-10-05 17:34:20 +04:00
struct FILEPROTO {
char *path; /* the path we operate on */
char *freepath; /* pointer to the allocated block we must free, this might
differ from the 'path' pointer */
int fd; /* open file descriptor to read from! */
2003-01-07 05:13:39 +03:00
};
/*
* Boolean values that concerns this connection.
*/
struct ConnectBits {
bool close; /* if set, we close the connection after this request */
bool reuse; /* if set, this is a re-used connection */
bool chunk; /* if set, this is a chunked transfer-encoding */
bool httpproxy; /* if set, this transfer is done through a http proxy */
bool user_passwd; /* do we use user+password for this connection? */
bool proxy_user_passwd; /* user+password for the proxy? */
2003-01-10 07:26:37 +03:00
bool ipv6_ip; /* we communicate with a remove site specified with pure IPv6
IP address */
2003-01-07 05:13:39 +03:00
bool use_range;
bool rangestringalloc; /* the range string is malloc()'ed */
2003-01-10 07:26:37 +03:00
bool do_more; /* this is set TRUE if the ->curl_do_more() function is
supposed to be called, after ->curl_do() */
bool upload_chunky; /* set TRUE if we are doing chunked transfer-encoding
on upload */
2003-01-14 17:12:37 +03:00
bool getheader; /* TRUE if header parsing is wanted */
bool forbidchunk; /* used only to explicitly forbid chunk-upload for
specific upload buffers. See readmoredata() in
http.c for details. */
bool tcpconnect; /* the tcp stream (or simimlar) is connected, this
is set the first time on the first connect function
call */
2004-10-05 17:34:20 +04:00
bool retry; /* this connection is about to get closed and then
re-attempted at another connection. */
bool no_body; /* CURLOPT_NO_BODY (or similar) was set */
bool tunnel_proxy; /* if CONNECT is used to "tunnel" through the proxy.
This is implicit when SSL-protocols are used through
proxies, but can also be enabled explicitly by
apps */
bool authprobe; /* set TRUE when this transfer is done to probe for auth
types, as when asking for "any" type when speaking
HTTP */
};
struct hostname {
char *rawalloc; /* allocated "raw" version of the name */
char *encalloc; /* allocated IDN-encoded version of the name */
char *name; /* name to use internally, might be encoded, might be raw */
char *dispname; /* name to display, as 'name' might be encoded */
2003-01-07 05:13:39 +03:00
};
/*
* This struct is all the previously local variables from Curl_perform() moved
* to struct to allow the function to return and get re-invoked better without
* losing state.
*/
struct Curl_transfer_keeper {
2004-10-05 17:34:20 +04:00
curl_off_t bytecount; /* total number of bytes read */
curl_off_t writebytecount; /* number of bytes written */
2003-01-07 05:13:39 +03:00
struct timeval start; /* transfer started at this time */
struct timeval now; /* current time */
bool header; /* incoming data has HTTP header */
2003-01-10 07:26:37 +03:00
enum {
2004-10-05 17:34:20 +04:00
HEADER_NORMAL, /* no bad header at all */
HEADER_PARTHEADER, /* part of the chunk is a bad header, the rest
is normal data */
HEADER_ALLBAD /* all was believed to be header */
2003-01-10 07:26:37 +03:00
} badheader; /* the header was deemed bad and will be
written as body */
2003-01-07 05:13:39 +03:00
int headerline; /* counts header lines to better track the
first one */
char *hbufp; /* points at *end* of header line */
2004-10-05 17:34:20 +04:00
size_t hbuflen;
2003-01-07 05:13:39 +03:00
char *str; /* within buf */
char *str_start; /* within buf */
char *end_ptr; /* within buf */
char *p; /* within headerbuff */
bool content_range; /* set TRUE if Content-Range: was found */
2004-10-05 17:34:20 +04:00
curl_off_t offset; /* possible resume offset read from the
2003-01-07 05:13:39 +03:00
Content-Range: header */
int httpcode; /* error code from the 'HTTP/1.? XXX' line */
int httpversion; /* the HTTP version*10 */
2004-10-05 17:34:20 +04:00
struct timeval start100; /* time stamp to wait for the 100 code from */
bool write_after_100_header; /* TRUE = we enable the write after we
received a 100-continue/timeout or
FALSE = directly */
bool wait100_after_headers; /* TRUE = after the request-headers have been
sent off properly, we go into the wait100
state, FALSE = don't */
2003-01-10 07:26:37 +03:00
int content_encoding; /* What content encoding. sec 3.5, RFC2616. */
#define IDENTITY 0 /* No encoding */
#define DEFLATE 1 /* zlib delfate [RFC 1950 & 1951] */
#define GZIP 2 /* gzip algorithm [RFC 1952] */
#define COMPRESS 3 /* Not handled, added for completeness */
#ifdef HAVE_LIBZ
bool zlib_init; /* True if zlib already initialized;
2004-10-05 17:34:20 +04:00
undefined if Content-Encoding header. */
2003-01-10 07:26:37 +03:00
z_stream z; /* State structure for zlib. */
#endif
2003-01-07 05:13:39 +03:00
time_t timeofdoc;
long bodywrites;
char *buf;
char *uploadbuf;
2004-10-05 17:34:20 +04:00
curl_socket_t maxfd;
2003-01-07 05:13:39 +03:00
2003-01-10 07:26:37 +03:00
/* pointers to the actual descriptors we check */
fd_set *readfdp;
fd_set *writefdp;
2003-01-07 05:13:39 +03:00
/* the file descriptors to play with */
fd_set readfd;
fd_set writefd;
fd_set rkeepfd;
fd_set wkeepfd;
int keepon;
2003-01-10 07:26:37 +03:00
bool upload_done; /* set to TRUE when doing chunked transfer-encoding upload
and we're uploading the last chunk */
2004-10-05 17:34:20 +04:00
bool ignorebody; /* we read a response-body but we ignore it! */
2003-01-07 05:13:39 +03:00
};
2004-10-05 17:34:20 +04:00
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
defined(USE_THREADING_GETADDRINFO)
struct Curl_async {
char *hostname;
int port;
struct Curl_dns_entry *dns;
bool done; /* set TRUE when the lookup is complete */
int status; /* if done is TRUE, this is the status from the callback */
void *os_specific; /* 'struct thread_data' for Windows */
};
#endif
#define FIRSTSOCKET 0
#define SECONDARYSOCKET 1
2003-01-07 05:13:39 +03:00
/*
* The connectdata struct contains all fields and variables that should be
* unique for an entire connection.
*/
struct connectdata {
/**** Fields set when inited and not modified again */
struct SessionHandle *data; /* link to the root CURL struct */
2004-10-05 17:34:20 +04:00
long connectindex; /* what index in the connects index this particular
2003-01-07 05:13:39 +03:00
struct has */
long protocol; /* PROT_* flags concerning the protocol set */
#define PROT_MISSING (1<<0)
#define PROT_GOPHER (1<<1)
#define PROT_HTTP (1<<2)
#define PROT_HTTPS (1<<3)
#define PROT_FTP (1<<4)
#define PROT_TELNET (1<<5)
#define PROT_DICT (1<<6)
#define PROT_LDAP (1<<7)
#define PROT_FILE (1<<8)
#define PROT_FTPS (1<<9)
#define PROT_SSL (1<<10) /* protocol requires SSL */
2003-01-10 07:26:37 +03:00
/* the particular host we use, in two different ways */
2004-10-05 17:34:20 +04:00
struct Curl_dns_entry *dns_entry;
Curl_addrinfo *ip_addr; /* the particular IP we connected to */
2003-01-07 05:13:39 +03:00
2004-10-05 17:34:20 +04:00
char protostr[16]; /* store the protocol string in this buffer */
struct hostname host;
struct hostname proxy;
char *pathbuffer;/* allocated buffer to store the URL's path part in */
char *path; /* path to use, points to somewhere within the pathbuffer
area */
2003-01-07 05:13:39 +03:00
long port; /* which port to use locally */
unsigned short remote_port; /* what remote port to connect to,
not the proxy port! */
2004-10-05 17:34:20 +04:00
curl_off_t bytecount;
2003-01-07 05:13:39 +03:00
long headerbytecount; /* only count received headers */
2004-10-05 17:34:20 +04:00
long deductheadercount; /* this amount of bytes doesn't count when we check
if anything has been transfered at the end of
a connection. We use this counter to make only
a 100 reply (without a following second response
code) result in a CURLE_GOT_NOTHING error code */
2003-01-07 05:13:39 +03:00
char *range; /* range, if used. See README for detailed specification on
this syntax. */
2004-10-05 17:34:20 +04:00
curl_off_t resume_from; /* continue [ftp] transfer from here */
char *user; /* user name string, allocated */
char *passwd; /* password string, allocated */
2003-01-07 05:13:39 +03:00
2004-10-05 17:34:20 +04:00
char *proxyuser; /* proxy user name string, allocated */
char *proxypasswd; /* proxy password string, allocated */
2003-01-07 05:13:39 +03:00
struct timeval now; /* "current" time */
struct timeval created; /* creation time */
2004-10-05 17:34:20 +04:00
curl_socket_t sock[2]; /* two sockets, the second is used for the data
transfer when doing FTP */
curl_off_t maxdownload; /* in bytes, the maximum amount of data to fetch, 0
means unlimited */
struct ssl_connect_data ssl[2]; /* this is for ssl-stuff */
struct ssl_config_data ssl_config;
2003-01-07 05:13:39 +03:00
struct ConnectBits bits; /* various state-flags for this connection */
/* These two functions MUST be set by the curl_connect() function to be
be protocol dependent */
2004-10-05 17:34:20 +04:00
CURLcode (*curl_do)(struct connectdata *);
CURLcode (*curl_done)(struct connectdata *, CURLcode);
2003-01-07 05:13:39 +03:00
2003-01-10 07:26:37 +03:00
/* If the curl_do() function is better made in two halves, this
* curl_do_more() function will be called afterwards, if set. For example
* for doing the FTP stuff after the PASV/PORT command.
*/
2004-10-05 17:34:20 +04:00
CURLcode (*curl_do_more)(struct connectdata *);
2003-01-10 07:26:37 +03:00
2003-01-07 05:13:39 +03:00
/* This function *MAY* be set to a protocol-dependent function that is run
* after the connect() and everything is done, as a step in the connection.
2004-10-05 17:34:20 +04:00
*/
CURLcode (*curl_connect)(struct connectdata *);
2003-01-07 05:13:39 +03:00
/* This function *MAY* be set to a protocol-dependent function that is run
* by the curl_disconnect(), as a step in the disconnection.
2004-10-05 17:34:20 +04:00
*/
CURLcode (*curl_disconnect)(struct connectdata *);
2003-01-07 05:13:39 +03:00
/* This function *MAY* be set to a protocol-dependent function that is run
* in the curl_close() function if protocol-specific cleanups are required.
2004-10-05 17:34:20 +04:00
*/
CURLcode (*curl_close)(struct connectdata *);
2003-01-07 05:13:39 +03:00
/**** curl_get() phase fields */
/* READ stuff */
2004-10-05 17:34:20 +04:00
curl_socket_t sockfd; /* socket to read from or CURL_SOCKET_BAD */
curl_off_t size; /* -1 if unknown at this point */
curl_off_t *bytecountp; /* return number of bytes read or NULL */
2003-01-07 05:13:39 +03:00
/* WRITE stuff */
2004-10-05 17:34:20 +04:00
curl_socket_t writesockfd; /* socket to write to, it may very
well be the same we read from.
CURL_SOCKET_BAD disables */
curl_off_t *writebytecountp; /* return number of bytes written or NULL */
2003-01-07 05:13:39 +03:00
/** Dynamicly allocated strings, may need to be freed before this **/
/** struct is killed. **/
struct dynamically_allocated_data {
char *proxyuserpwd; /* free later if not NULL! */
char *uagent; /* free later if not NULL! */
2004-10-05 17:34:20 +04:00
char *accept_encoding; /* free later if not NULL! */
2003-01-07 05:13:39 +03:00
char *userpwd; /* free later if not NULL! */
char *rangeline; /* free later if not NULL! */
char *ref; /* free later if not NULL! */
char *host; /* free later if not NULL */
2004-10-05 17:34:20 +04:00
char *cookiehost; /* free later if not NULL */
2003-01-07 05:13:39 +03:00
} allocptr;
char *newurl; /* This can only be set if a Location: was in the
document headers */
2004-10-05 17:34:20 +04:00
#ifdef HAVE_KRB4
2003-01-07 05:13:39 +03:00
enum protection_level command_prot;
enum protection_level data_prot;
enum protection_level request_data_prot;
size_t buffer_size;
struct krb4buffer in_buffer, out_buffer;
int sec_complete;
void *app_data;
struct Curl_sec_client_mech *mech;
struct sockaddr_in local_addr;
#endif
/*************** Request - specific items ************/
/* previously this was in the urldata struct */
union {
struct HTTP *http;
struct HTTP *gopher; /* alias, just for the sake of being more readable */
struct HTTP *https; /* alias, just for the sake of being more readable */
struct FTP *ftp;
2004-10-05 17:34:20 +04:00
struct FILEPROTO *file;
2003-01-07 05:13:39 +03:00
void *telnet; /* private for telnet.c-eyes only */
void *generic;
} proto;
/* This struct is inited when needed */
struct Curl_transfer_keeper keep;
/* 'upload_present' is used to keep a byte counter of how much data there is
still left in the buffer, aimed for upload. */
2004-10-05 17:34:20 +04:00
ssize_t upload_present;
2003-01-07 05:13:39 +03:00
/* 'upload_fromhere' is used as a read-pointer when we uploaded parts of a
buffer, so the next read should read from where this pointer points to,
and the 'upload_present' contains the number of bytes available at this
position */
2003-01-10 07:26:37 +03:00
char *upload_fromhere;
2003-01-14 17:12:37 +03:00
curl_read_callback fread; /* function that reads the input */
void *fread_in; /* pointer to pass to the fread() above */
2004-10-05 17:34:20 +04:00
struct ntlmdata ntlm; /* NTLM differs from other authentication schemes
because it authenticates connections, not
single requests! */
struct ntlmdata proxyntlm; /* NTLM data for proxy */
char syserr_buf [256]; /* buffer for Curl_strerror() */
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
defined(USE_THREADING_GETADDRINFO)
/* data used for the asynch name resolve callback */
struct Curl_async async;
#endif
struct connectdata *sec_conn; /* secondary connection for 3rd party
transfer */
2003-01-07 05:13:39 +03:00
};
2004-10-05 17:34:20 +04:00
/* The end of connectdata. */
2003-01-10 07:26:37 +03:00
2003-01-07 05:13:39 +03:00
/*
* Struct to keep statistical and informational data.
*/
struct PureInfo {
2004-10-05 17:34:20 +04:00
int httpcode; /* Recent HTTP or FTP response code */
int httpproxycode;
2003-01-07 05:13:39 +03:00
int httpversion;
2004-10-05 17:34:20 +04:00
long filetime; /* If requested, this is might get set. Set to -1 if the time
was unretrievable. We cannot have this of type time_t,
since time_t is unsigned on several platforms such as
OpenVMS. */
2003-01-07 05:13:39 +03:00
long header_size; /* size of read header(s) in bytes */
long request_size; /* the amount of bytes sent in the request(s) */
2004-10-05 17:34:20 +04:00
long proxyauthavail;
long httpauthavail;
2003-01-07 05:13:39 +03:00
char *contenttype; /* the content type of the object */
};
struct Progress {
long lastshow; /* time() of the last displayed progress meter or NULL to
force redraw at next call */
2004-10-05 17:34:20 +04:00
curl_off_t size_dl; /* total expected size */
curl_off_t size_ul; /* total expected size */
curl_off_t downloaded; /* transfered so far */
curl_off_t uploaded; /* transfered so far */
2003-01-07 05:13:39 +03:00
2004-10-05 17:34:20 +04:00
curl_off_t current_speed; /* uses the currently fastest transfer */
2003-01-07 05:13:39 +03:00
bool callback; /* set when progress callback is used */
int width; /* screen width at download start */
int flags; /* see progress.h */
double timespent;
2004-10-05 17:34:20 +04:00
curl_off_t dlspeed;
curl_off_t ulspeed;
2003-01-07 05:13:39 +03:00
double t_nslookup;
double t_connect;
double t_pretransfer;
double t_starttransfer;
2003-01-10 07:26:37 +03:00
double t_redirect;
2003-01-07 05:13:39 +03:00
struct timeval start;
struct timeval t_startsingle;
#define CURR_TIME (5+1) /* 6 entries for 5 seconds */
2004-10-05 17:34:20 +04:00
curl_off_t speeder[ CURR_TIME ];
2003-01-07 05:13:39 +03:00
struct timeval speeder_time[ CURR_TIME ];
int speeder_c;
};
typedef enum {
HTTPREQ_NONE, /* first in list */
HTTPREQ_GET,
HTTPREQ_POST,
HTTPREQ_POST_FORM, /* we make a difference internally */
HTTPREQ_PUT,
2004-10-05 17:34:20 +04:00
HTTPREQ_HEAD,
2003-01-07 05:13:39 +03:00
HTTPREQ_CUSTOM,
HTTPREQ_LAST /* last in list */
} Curl_HttpReq;
/*
* Values that are generated, temporary or calculated internally for a
* "session handle" must be defined within the 'struct urlstate'. This struct
* will be used within the SessionHandle struct. When the 'SessionHandle'
* struct is cloned, this data MUST NOT be copied.
*
* Remember that any "state" information goes globally for the curl handle.
* Session-data MUST be put in the connectdata struct and here. */
#define MAX_CURL_USER_LENGTH 256
#define MAX_CURL_PASSWORD_LENGTH 256
2004-10-05 17:34:20 +04:00
#define MAX_CURL_USER_LENGTH_TXT "255"
#define MAX_CURL_PASSWORD_LENGTH_TXT "255"
struct auth {
long want; /* Bitmask set to the authentication methods wanted by the app
(with CURLOPT_HTTPAUTH or CURLOPT_PROXYAUTH). */
long picked;
long avail; /* bitmask for what the server reports to support for this
resource */
bool done; /* TRUE when the auth phase is done and ready to do the *actual*
request */
};
2003-01-07 05:13:39 +03:00
struct UrlState {
2003-01-10 07:26:37 +03:00
enum {
Curl_if_none,
Curl_if_easy,
Curl_if_multi
} used_interface;
2003-01-07 05:13:39 +03:00
/* buffers to store authentication data in, as parsed from input options */
struct timeval keeps_speed; /* for the progress meter really */
/* 'connects' will be an allocated array with pointers. If the pointer is
set, it holds an allocated connection. */
struct connectdata **connects;
long numconnects; /* size of the 'connects' array */
char *headerbuff; /* allocated buffer to store headers in */
2004-10-05 17:34:20 +04:00
size_t headersize; /* size of the allocation */
2003-01-07 05:13:39 +03:00
char buffer[BUFSIZE+1]; /* download buffer */
char uploadbuffer[BUFSIZE+1]; /* upload buffer */
2004-10-05 17:34:20 +04:00
curl_off_t current_speed; /* the ProgressShow() funcion sets this,
bytes / second */
2003-01-07 05:13:39 +03:00
bool this_is_a_follow; /* this is a followed Location: request */
char *auth_host; /* if set, this should be the host name that we will
sent authorization to, no else. Used to make Location:
following not keep sending user+password... This is
strdup() data.
*/
struct curl_ssl_session *session; /* array of 'numsessions' size */
long sessionage; /* number of the most recent session */
2004-10-05 17:34:20 +04:00
char *scratch; /* huge buffer[BUFSIZE*2] when doing upload CRLF replacing */
2003-01-07 05:13:39 +03:00
bool errorbuf; /* Set to TRUE if the error buffer is already filled in.
This must be set to FALSE every time _easy_perform() is
called. */
#ifdef HAVE_SIGNAL
/* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */
void (*prev_signal)(int sig);
#endif
bool allow_port; /* Is set.use_port allowed to take effect or not. This
is always set TRUE when curl_easy_perform() is called. */
2004-10-05 17:34:20 +04:00
struct digestdata digest;
struct digestdata proxydigest;
#ifdef HAVE_GSSAPI
struct negotiatedata negotiate;
#endif
struct auth authhost;
struct auth authproxy;
bool authproblem; /* TRUE if there's some problem authenticating */
#ifdef USE_ARES
ares_channel areschannel; /* for name resolves */
#endif
2003-01-07 05:13:39 +03:00
};
/*
* This 'DynamicStatic' struct defines dynamic states that actually change
* values in the 'UserDefined' area, which MUST be taken into consideration
* if the UserDefined struct is cloned or similar. You can probably just
* copy these, but each one indicate a special action on other data.
*/
struct DynamicStatic {
char *url; /* work URL, copied from UserDefined */
bool url_alloc; /* URL string is malloc()'ed */
2004-10-05 17:34:20 +04:00
bool url_changed; /* set on CURL_OPT_URL, used to detect if the URL was
changed after the connect phase, as we allow callback
to change it and if so, we reconnect to use the new
URL instead */
2003-01-07 05:13:39 +03:00
char *proxy; /* work proxy, copied from UserDefined */
bool proxy_alloc; /* http proxy string is malloc()'ed */
char *referer; /* referer string */
bool referer_alloc; /* referer sting is malloc()ed */
2003-01-10 07:26:37 +03:00
struct curl_slist *cookielist; /* list of cookie files set by
curl_easy_setopt(COOKIEFILE) calls */
2003-01-07 05:13:39 +03:00
};
/*
* This 'UserDefined' struct must only contain data that is set once to go
* for many (perhaps) independent connections. Values that are generated or
* calculated internally for the "session handle" MUST be defined within the
* 'struct urlstate' instead. The only exceptions MUST note the changes in
* the 'DynamicStatic' struct.
*/
struct UserDefined {
2003-01-10 07:26:37 +03:00
FILE *err; /* the stderr user data goes here */
void *debugdata; /* the data that will be passed to fdebug */
2003-01-07 05:13:39 +03:00
char *errorbuffer; /* store failure messages in here */
char *proxyuserpwd; /* Proxy <user:password>, if used */
long proxyport; /* If non-zero, use this port number by default. If the
proxy string features a ":[port]" that one will override
2004-10-05 17:34:20 +04:00
this. */
2003-01-07 05:13:39 +03:00
void *out; /* the fetched file goes here */
void *in; /* the uploaded file is read from here */
void *writeheader; /* write the header to this is non-NULL */
char *set_url; /* what original URL to work on */
char *set_proxy; /* proxy to use */
long use_port; /* which port to use (when not using default) */
char *userpwd; /* <user:password>, if used */
2004-10-05 17:34:20 +04:00
long httpauth; /* what kind of HTTP authentication to use (bitmask) */
long proxyauth; /* what kind of proxy authentication to use (bitmask) */
2003-01-07 05:13:39 +03:00
char *set_range; /* range, if used. See README for detailed specification
on this syntax. */
long followlocation; /* as in HTTP Location: */
long maxredirs; /* maximum no. of http(s) redirects to follow */
char *set_referer; /* custom string */
bool free_referer; /* set TRUE if 'referer' points to a string we
allocated */
char *useragent; /* User-Agent string */
2003-01-14 17:12:37 +03:00
char *encoding; /* Accept-Encoding string */
2003-01-07 05:13:39 +03:00
char *postfields; /* if POST, set the fields' values here */
2004-10-05 17:34:20 +04:00
curl_off_t postfieldsize; /* if POST, this might have a size to use instead
of strlen(), and then the data *may* be binary
(contain zero bytes) */
2003-01-07 05:13:39 +03:00
char *ftpport; /* port to send with the FTP PORT command */
char *device; /* network interface to use */
curl_write_callback fwrite; /* function that stores the output */
curl_write_callback fwrite_header; /* function that stores headers */
curl_read_callback fread; /* function that reads the input */
curl_progress_callback fprogress; /* function for progress information */
2003-01-10 07:26:37 +03:00
curl_debug_callback fdebug; /* function that write informational data */
2003-01-07 05:13:39 +03:00
void *progress_client; /* pointer to pass to the progress callback */
long timeout; /* in seconds, 0 means no timeout */
long connecttimeout; /* in seconds, 0 means no timeout */
2004-10-05 17:34:20 +04:00
long ftp_response_timeout; /* in seconds, 0 means no timeout */
curl_off_t infilesize; /* size of file to upload, -1 means unknown */
2003-01-07 05:13:39 +03:00
long low_speed_limit; /* bytes/second */
long low_speed_time; /* number of seconds */
2004-10-05 17:34:20 +04:00
curl_off_t set_resume_from; /* continue [ftp] transfer from here */
2003-01-07 05:13:39 +03:00
char *cookie; /* HTTP cookie string to send */
struct curl_slist *headers; /* linked list of extra headers */
2004-10-05 17:34:20 +04:00
struct curl_httppost *httppost; /* linked list of POST data */
2003-01-07 05:13:39 +03:00
char *cert; /* certificate */
char *cert_type; /* format for certificate (default: PEM) */
char *key; /* private key */
char *key_type; /* format for private key (default: PEM) */
char *key_passwd; /* plain text private key password */
char *crypto_engine; /* name of the crypto engine to use */
char *cookiejar; /* dump all cookies to this file */
2003-01-10 07:26:37 +03:00
bool cookiesession; /* new cookie session? */
2003-01-07 05:13:39 +03:00
bool crlf; /* convert crlf on ftp upload(?) */
struct curl_slist *quote; /* after connection is established */
struct curl_slist *postquote; /* after the transfer */
2004-10-05 17:34:20 +04:00
struct curl_slist *prequote; /* before the transfer, after type */
struct curl_slist *source_prequote; /* in 3rd party transfer mode - before
the transfer on source host */
struct curl_slist *source_postquote; /* in 3rd party transfer mode - after
the transfer on source host */
2003-01-07 05:13:39 +03:00
struct curl_slist *telnet_options; /* linked list of telnet options */
curl_TimeCond timecondition; /* kind of time/date comparison */
time_t timevalue; /* what time to compare with */
curl_closepolicy closepolicy; /* connection cache close concept */
Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */
char *customrequest; /* HTTP/FTP request to use */
long httpversion; /* when non-zero, a specific HTTP version requested to
be used in the library's request(s) */
char *auth_host; /* if set, this is the allocated string to the host name
* to which to send the authorization data to, and no other
* host (which location-following otherwise could lead to)
*/
char *krb4_level; /* what security level */
struct ssl_config_data ssl; /* user defined SSL stuff */
2003-01-10 07:26:37 +03:00
curl_proxytype proxytype; /* what kind of proxy that is in use */
2003-01-07 05:13:39 +03:00
int dns_cache_timeout; /* DNS cache timeout */
2003-01-10 07:26:37 +03:00
long buffer_size; /* size of receive buffer to use */
2003-01-14 17:12:37 +03:00
char *private; /* Private data */
struct curl_slist *http200aliases; /* linked list of aliases for http200 */
2004-10-05 17:34:20 +04:00
long ip_version;
curl_off_t max_filesize; /* Maximum file size to download */
char *source_host; /* for 3rd party transfer */
char *source_port; /* for 3rd party transfer */
char *source_userpwd; /* for 3rd party transfer */
char *source_path; /* for 3rd party transfer */
curl_pasv_side pasvHost; /* for 3rd party transfer indicates passive host */
2003-01-07 05:13:39 +03:00
/* Here follows boolean settings that define how to behave during
this session. They are STATIC, set by libcurl users or at least initially
and they don't change during operations. */
2004-10-05 17:34:20 +04:00
bool printhost; /* printing host name in debug info */
2003-01-07 05:13:39 +03:00
bool get_filetime;
bool tunnel_thru_httpproxy;
bool ftp_append;
bool ftp_ascii;
bool ftp_list_only;
2004-10-05 17:34:20 +04:00
bool ftp_create_missing_dirs;
2003-01-07 05:13:39 +03:00
bool ftp_use_port;
bool hide_progress;
bool http_fail_on_error;
bool http_follow_location;
2004-10-05 17:34:20 +04:00
bool http_disable_hostname_check_before_authentication;
bool include_header; /* include received protocol headers in data output */
2003-01-07 05:13:39 +03:00
bool http_set_referer;
bool http_auto_referer; /* set "correct" referer when following location: */
2004-10-05 17:34:20 +04:00
bool opt_no_body; /* as set with CURLOPT_NO_BODY */
2003-01-07 05:13:39 +03:00
bool set_port;
bool upload;
2003-01-10 07:26:37 +03:00
enum CURL_NETRC_OPTION
use_netrc; /* defined in include/curl.h */
2004-10-05 17:34:20 +04:00
char *netrc_file; /* if not NULL, use this instead of trying to find
$HOME/.netrc */
2003-01-07 05:13:39 +03:00
bool verbose;
bool krb4; /* kerberos4 connection requested */
bool reuse_forbid; /* forbidden to be reused, close after use */
bool reuse_fresh; /* do not re-use an existing connection */
bool expect100header; /* TRUE if we added Expect: 100-continue */
bool ftp_use_epsv; /* if EPSV is to be attempted or not */
2004-10-05 17:34:20 +04:00
bool ftp_use_eprt; /* if EPRT is to be attempted or not */
curl_ftpssl ftp_ssl; /* if AUTH TLS is to be attempted etc */
2003-01-10 07:26:37 +03:00
bool no_signal; /* do not use any signal/alarm handler */
2004-10-05 17:34:20 +04:00
bool global_dns_cache; /* subject for future removal */
bool tcp_nodelay; /* whether to enable TCP_NODELAY or not */
2003-01-07 05:13:39 +03:00
};
/*
* In August 2001, this struct was redesigned and is since stricter than
* before. The 'connectdata' struct MUST have all the connection oriented
* stuff as we may now have several simultaneous connections and connection
* structs in memory.
*
* From now on, the 'SessionHandle' must only contain data that is set once to
* go for many (perhaps) independent connections. Values that are generated or
* calculated internally for the "session handle" must be defined within the
* 'struct urlstate' instead. */
struct SessionHandle {
2003-01-10 07:26:37 +03:00
curl_hash *hostcache;
2003-01-14 17:12:37 +03:00
struct Curl_share *share; /* Share, handles global variable mutexing */
2003-01-07 05:13:39 +03:00
struct UserDefined set; /* values set by the libcurl user */
struct DynamicStatic change; /* possibly modified userdefined data */
struct CookieInfo *cookies; /* the cookies, read from files and servers */
struct Progress progress; /* for all the progress meter data */
struct UrlState state; /* struct for fields used for state info and
other dynamic purposes */
struct PureInfo info; /* stats, reports and info data */
2004-10-05 17:34:20 +04:00
#if defined(USE_SSLEAY) && defined(HAVE_OPENSSL_ENGINE_H)
2003-01-07 05:13:39 +03:00
ENGINE* engine;
#endif /* USE_SSLEAY */
};
#define LIBCURL_NAME "libcurl"
#endif