1999-12-29 09:20:26 -05:00
|
|
|
#ifndef __URLDATA_H
|
|
|
|
#define __URLDATA_H
|
2002-09-03 07:52:59 -04:00
|
|
|
/***************************************************************************
|
2004-05-17 02:50:32 -04:00
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
1999-12-29 09:20:26 -05:00
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2006-01-19 18:52:03 -05:00
|
|
|
* Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2002-09-03 07:52:59 -04: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-05-17 02:50:32 -04:00
|
|
|
*
|
2001-01-03 04:29:33 -05: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
|
2002-09-03 07:52:59 -04:00
|
|
|
* furnished to do so, under the terms of the COPYING file.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* $Id$
|
2002-09-03 07:52:59 -04:00
|
|
|
***************************************************************************/
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* This file is for lib internal stuff */
|
|
|
|
|
|
|
|
#include "setup.h"
|
|
|
|
|
|
|
|
#define PORT_FTP 21
|
2004-01-11 17:56:36 -05:00
|
|
|
#define PORT_FTPS 990
|
1999-12-29 09:20:26 -05:00
|
|
|
#define PORT_TELNET 23
|
|
|
|
#define PORT_HTTP 80
|
|
|
|
#define PORT_HTTPS 443
|
|
|
|
#define PORT_DICT 2628
|
|
|
|
#define PORT_LDAP 389
|
2005-09-02 11:11:08 -04:00
|
|
|
#define PORT_TFTP 69
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
#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"
|
2000-06-20 11:31:26 -04:00
|
|
|
#define CURL_DEFAULT_PASSWORD "curl_by_daniel@haxx.se"
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
#include "cookie.h"
|
2000-05-22 10:12:12 -04:00
|
|
|
#include "formdata.h"
|
2004-05-17 02:50:32 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#ifdef USE_SSLEAY
|
|
|
|
#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"
|
2001-12-17 18:01:39 -05:00
|
|
|
#ifdef HAVE_OPENSSL_ENGINE_H
|
|
|
|
#include <openssl/engine.h>
|
|
|
|
#endif
|
2004-12-19 04:37:32 -05:00
|
|
|
#ifdef HAVE_OPENSSL_PKCS12_H
|
|
|
|
#include <openssl/pkcs12.h>
|
|
|
|
#endif
|
2005-04-07 11:27:13 -04:00
|
|
|
#else /* SSLeay-style includes */
|
1999-12-29 09:20:26 -05:00
|
|
|
#include "rsa.h"
|
|
|
|
#include "crypto.h"
|
|
|
|
#include "x509.h"
|
|
|
|
#include "pem.h"
|
|
|
|
#include "ssl.h"
|
|
|
|
#include "err.h"
|
2005-04-07 11:27:13 -04:00
|
|
|
#endif /* USE_OPENSSL */
|
|
|
|
#endif /* USE_SSLEAY */
|
|
|
|
|
|
|
|
#ifdef USE_GNUTLS
|
|
|
|
#include <gnutls/gnutls.h>
|
1999-12-29 09:20:26 -05:00
|
|
|
#endif
|
|
|
|
|
2000-06-13 19:04:44 -04:00
|
|
|
#ifdef HAVE_NETINET_IN_H
|
2000-05-22 10:12:12 -04:00
|
|
|
#include <netinet/in.h>
|
2000-06-13 19:04:44 -04:00
|
|
|
#endif
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2000-02-15 19:02:40 -05:00
|
|
|
#include "timeval.h"
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2004-01-22 07:45:50 -05:00
|
|
|
#ifdef HAVE_ZLIB_H
|
2004-10-06 03:50:18 -04:00
|
|
|
#include <zlib.h> /* for content-encoding */
|
2004-01-22 07:45:50 -05:00
|
|
|
#endif
|
|
|
|
|
2004-04-26 03:20:11 -04:00
|
|
|
#ifdef USE_ARES
|
|
|
|
#include <ares.h>
|
|
|
|
#endif
|
|
|
|
|
2000-06-08 11:11:39 -04:00
|
|
|
#include <curl/curl.h>
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-03-07 18:51:41 -05:00
|
|
|
#include "http_chunks.h" /* for the structs and enum stuff */
|
2002-11-05 05:51:41 -05:00
|
|
|
#include "hostip.h"
|
|
|
|
#include "hash.h"
|
2006-04-10 11:00:53 -04:00
|
|
|
#include "splay.h"
|
2001-03-07 18:51:41 -05:00
|
|
|
|
2003-09-19 08:56:22 -04:00
|
|
|
#ifdef HAVE_GSSAPI
|
2005-08-29 04:42:45 -04:00
|
|
|
# ifdef HAVE_GSSGNU
|
|
|
|
# include <gss.h>
|
|
|
|
# elif defined HAVE_GSSMIT
|
|
|
|
# include <gssapi/gssapi.h>
|
|
|
|
# include <gssapi/gssapi_generic.h>
|
|
|
|
# else
|
|
|
|
# include <gssapi.h>
|
|
|
|
# endif
|
2003-09-19 08:56:22 -04:00
|
|
|
#endif
|
2003-06-10 08:22:19 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Download buffer size, keep it fairly big for speed reasons */
|
2002-05-03 10:50:29 -04:00
|
|
|
#define BUFSIZE CURL_MAX_WRITE_SIZE
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* Initial size of the buffer to store headers in, it'll be enlarged in case
|
|
|
|
of need. */
|
|
|
|
#define HEADERSIZE 256
|
|
|
|
|
2004-02-20 03:47:23 -05: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))
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2003-12-02 08:27:29 -05:00
|
|
|
#ifdef HAVE_KRB4
|
2001-01-24 07:10:10 -05:00
|
|
|
/* Types needed for krb4-ftp connections */
|
2000-09-21 04:50:48 -04:00
|
|
|
struct krb4buffer {
|
|
|
|
void *data;
|
|
|
|
size_t size;
|
|
|
|
size_t index;
|
|
|
|
int eof_flag;
|
|
|
|
};
|
2004-05-17 02:50:32 -04:00
|
|
|
enum protection_level {
|
2006-03-21 16:54:44 -05:00
|
|
|
prot_clear,
|
|
|
|
prot_safe,
|
|
|
|
prot_confidential,
|
|
|
|
prot_private
|
2000-09-21 04:50:48 -04:00
|
|
|
};
|
|
|
|
#endif
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2006-03-21 16:54:44 -05:00
|
|
|
/* enum for the nonblocking SSL connection state machine */
|
|
|
|
typedef enum {
|
|
|
|
ssl_connect_1,
|
|
|
|
ssl_connect_2,
|
|
|
|
ssl_connect_2_reading,
|
|
|
|
ssl_connect_2_writing,
|
|
|
|
ssl_connect_3,
|
|
|
|
ssl_connect_done
|
|
|
|
} ssl_connect_state;
|
|
|
|
|
2003-11-24 02:15:37 -05:00
|
|
|
/* struct for data related to each SSL connection */
|
2001-02-20 12:35:51 -05:00
|
|
|
struct ssl_connect_data {
|
2003-11-24 02:15:37 -05:00
|
|
|
bool use; /* use ssl encrypted communications TRUE/FALSE */
|
2001-02-20 12:35:51 -05:00
|
|
|
#ifdef USE_SSLEAY
|
|
|
|
/* these ones requires specific SSL-types */
|
|
|
|
SSL_CTX* ctx;
|
|
|
|
SSL* handle;
|
|
|
|
X509* server_cert;
|
2006-03-21 16:54:44 -05:00
|
|
|
ssl_connect_state connecting_state;
|
2001-02-20 12:35:51 -05:00
|
|
|
#endif /* USE_SSLEAY */
|
2005-04-07 11:27:13 -04:00
|
|
|
#ifdef USE_GNUTLS
|
|
|
|
gnutls_session session;
|
2006-05-07 14:27:36 -04:00
|
|
|
gnutls_certificate_credentials cred;
|
2005-04-07 11:27:13 -04:00
|
|
|
#endif /* USE_GNUTLS */
|
2001-02-20 12:35:51 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
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 */
|
2002-08-26 19:13:25 -04:00
|
|
|
long verifyhost; /* 0: no verify
|
|
|
|
1: check that CN exists
|
|
|
|
2: CN must match hostname */
|
2001-02-20 12:35:51 -05:00
|
|
|
char *CApath; /* DOES NOT WORK ON WINDOWS */
|
|
|
|
char *CAfile; /* cerficate to verify peer against */
|
2001-03-12 10:47:41 -05:00
|
|
|
char *random_file; /* path to file containing "random" data */
|
|
|
|
char *egdsocket; /* path to file containing the EGD daemon socket */
|
2001-09-11 18:21:26 -04:00
|
|
|
char *cipher_list; /* list of ciphers to use */
|
2002-08-26 19:13:25 -04:00
|
|
|
long numsessions; /* SSL session id cache size */
|
2004-10-06 03:50:18 -04:00
|
|
|
curl_ssl_ctx_callback fsslctx; /* function to initialize ssl ctx */
|
|
|
|
void *fsslctxp; /*parameter for call back */
|
2001-02-20 12:35:51 -05:00
|
|
|
};
|
|
|
|
|
2003-03-31 00:13:26 -05: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 */
|
2005-04-07 11:27:13 -04:00
|
|
|
size_t idsize; /* if known, otherwise 0 */
|
2003-03-31 00:13:26 -05:00
|
|
|
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 */
|
|
|
|
};
|
|
|
|
|
2003-05-22 12:09:54 -04:00
|
|
|
/* Struct used for Digest challenge-response authentication */
|
|
|
|
struct digestdata {
|
|
|
|
char *nonce;
|
|
|
|
char *cnonce;
|
|
|
|
char *realm;
|
|
|
|
int algo;
|
2004-03-30 08:00:53 -05:00
|
|
|
bool stale; /* set true for re-negotiation */
|
2004-04-29 04:18:32 -04:00
|
|
|
char *opaque;
|
|
|
|
char *qop;
|
|
|
|
char *algorithm;
|
|
|
|
int nc; /* nounce count */
|
2003-05-22 12:09:54 -04:00
|
|
|
};
|
2003-03-31 00:13:26 -05:00
|
|
|
|
2003-06-11 09:38:55 -04:00
|
|
|
typedef enum {
|
|
|
|
NTLMSTATE_NONE,
|
|
|
|
NTLMSTATE_TYPE1,
|
|
|
|
NTLMSTATE_TYPE2,
|
|
|
|
NTLMSTATE_TYPE3,
|
|
|
|
NTLMSTATE_LAST
|
|
|
|
} curlntlm;
|
|
|
|
|
2005-03-10 18:15:29 -05:00
|
|
|
#ifdef USE_WINDOWS_SSPI
|
|
|
|
/* When including these headers, you must define either SECURITY_WIN32
|
|
|
|
* or SECURITY_KERNEL, indicating who is compiling the code.
|
|
|
|
*/
|
|
|
|
#define SECURITY_WIN32 1
|
2005-03-13 19:01:30 -05:00
|
|
|
#include <security.h>
|
2005-03-12 12:31:15 -05:00
|
|
|
#include <sspi.h>
|
2005-03-10 18:15:29 -05:00
|
|
|
#include <rpc.h>
|
|
|
|
#endif
|
|
|
|
|
2006-04-07 17:50:47 -04:00
|
|
|
#if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV)
|
|
|
|
#include <iconv.h>
|
|
|
|
#endif
|
|
|
|
|
2003-11-24 02:08:07 -05:00
|
|
|
/* Struct used for NTLM challenge-response authentication */
|
2003-06-11 09:38:55 -04:00
|
|
|
struct ntlmdata {
|
|
|
|
curlntlm state;
|
2005-03-10 18:15:29 -05:00
|
|
|
#ifdef USE_WINDOWS_SSPI
|
|
|
|
CredHandle handle;
|
|
|
|
CtxtHandle c_handle;
|
|
|
|
SEC_WINNT_AUTH_IDENTITY identity;
|
|
|
|
SEC_WINNT_AUTH_IDENTITY *p_identity;
|
|
|
|
int has_handles;
|
|
|
|
void *type_2;
|
|
|
|
int n_type_2;
|
|
|
|
#else
|
2006-04-05 08:35:48 -04:00
|
|
|
unsigned int flags;
|
2003-06-11 09:38:55 -04:00
|
|
|
unsigned char nonce[8];
|
2005-03-10 18:15:29 -05:00
|
|
|
#endif
|
2003-06-11 09:38:55 -04:00
|
|
|
};
|
|
|
|
|
2003-09-19 08:56:22 -04:00
|
|
|
#ifdef HAVE_GSSAPI
|
2003-06-10 08:22:19 -04:00
|
|
|
struct negotiatedata {
|
2003-09-11 18:21:11 -04:00
|
|
|
bool gss; /* Whether we're processing GSS-Negotiate or Negotiate */
|
|
|
|
const char* protocol; /* "GSS-Negotiate" or "Negotiate" */
|
2003-06-10 08:22:19 -04:00
|
|
|
OM_uint32 status;
|
|
|
|
gss_ctx_id_t context;
|
|
|
|
gss_name_t server_name;
|
|
|
|
gss_buffer_desc output_token;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
/****************************************************************************
|
|
|
|
* HTTP unique setup
|
|
|
|
***************************************************************************/
|
|
|
|
struct HTTP {
|
|
|
|
struct FormData *sendit;
|
2004-03-12 08:06:01 -05:00
|
|
|
curl_off_t postsize; /* off_t to handle large file sizes */
|
2002-12-10 08:10:00 -05:00
|
|
|
char *postdata;
|
|
|
|
|
2001-08-14 04:40:39 -04:00
|
|
|
const char *p_pragma; /* Pragma: string */
|
|
|
|
const char *p_accept; /* Accept: string */
|
2004-05-17 02:50:32 -04:00
|
|
|
curl_off_t readbytecount;
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t writebytecount;
|
2001-02-20 12:35:51 -05:00
|
|
|
|
|
|
|
/* For FORM posting */
|
|
|
|
struct Form form;
|
2001-03-07 18:51:41 -05:00
|
|
|
struct Curl_chunker chunk;
|
2002-12-09 11:05:57 -05:00
|
|
|
|
2002-12-10 08:10:00 -05:00
|
|
|
struct back {
|
|
|
|
curl_read_callback fread; /* backup storage for fread pointer */
|
|
|
|
void *fread_in; /* backup storage for fread_in pointer */
|
|
|
|
char *postdata;
|
2004-03-12 08:06:01 -05:00
|
|
|
curl_off_t postsize;
|
2002-12-10 08:10:00 -05: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 */
|
2001-02-20 12:35:51 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* FTP unique setup
|
|
|
|
***************************************************************************/
|
2005-02-09 08:06:40 -05:00
|
|
|
typedef enum {
|
|
|
|
FTP_STOP, /* do nothing state, stops the state machine */
|
|
|
|
FTP_WAIT220, /* waiting for the inintial 220 response immediately after
|
|
|
|
a connect */
|
|
|
|
FTP_AUTH,
|
|
|
|
FTP_USER,
|
|
|
|
FTP_PASS,
|
|
|
|
FTP_ACCT,
|
|
|
|
FTP_PBSZ,
|
|
|
|
FTP_PROT,
|
|
|
|
FTP_PWD,
|
|
|
|
FTP_QUOTE, /* waiting for a response to a command sent in a quote list */
|
|
|
|
FTP_RETR_PREQUOTE,
|
|
|
|
FTP_STOR_PREQUOTE,
|
|
|
|
FTP_POSTQUOTE,
|
|
|
|
FTP_CWD, /* change dir */
|
|
|
|
FTP_MKD, /* if the dir didn't exist */
|
|
|
|
FTP_MDTM, /* to figure out the datestamp */
|
|
|
|
FTP_TYPE, /* to set type when doing a head-like request */
|
|
|
|
FTP_LIST_TYPE, /* set type when about to do a dir list */
|
|
|
|
FTP_RETR_TYPE, /* set type when about to RETR a file */
|
|
|
|
FTP_STOR_TYPE, /* set type when about to STOR a file */
|
|
|
|
FTP_SIZE, /* get the remote file's size for head-like request */
|
|
|
|
FTP_RETR_SIZE, /* get the remote file's size for RETR */
|
|
|
|
FTP_STOR_SIZE, /* get the size for (resumed) STOR */
|
|
|
|
FTP_REST, /* when used to check if the server supports it in head-like */
|
|
|
|
FTP_RETR_REST, /* when asking for "resume" in for RETR */
|
|
|
|
FTP_PORT, /* generic state for PORT, LPRT and EPRT, check count1 */
|
|
|
|
FTP_PASV, /* generic state for PASV and EPSV, check count1 */
|
|
|
|
FTP_LIST, /* generic state for LIST, NLST or a custom list command */
|
|
|
|
FTP_RETR,
|
|
|
|
FTP_STOR, /* generic state for STOR and APPE */
|
|
|
|
FTP_QUIT,
|
|
|
|
FTP_LAST /* never used */
|
|
|
|
} ftpstate;
|
|
|
|
|
2005-11-28 18:06:00 -05:00
|
|
|
typedef enum {
|
|
|
|
FTPFILE_MULTICWD = 1, /* as defined by RFC1738 */
|
|
|
|
FTPFILE_NOCWD = 2, /* use SIZE / RETR / STOR on the full path */
|
|
|
|
FTPFILE_SINGLECWD = 3 /* make one CWD, then SIZE / RETR / STOR on the file */
|
|
|
|
} curl_ftpfile;
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
struct FTP {
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t *bytecountp;
|
2001-02-20 12:35:51 -05:00
|
|
|
char *user; /* user name string */
|
|
|
|
char *passwd; /* password string */
|
|
|
|
char *urlpath; /* the originally given path part of the URL */
|
2004-04-15 03:52:39 -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 */
|
2001-02-20 12:35:51 -05:00
|
|
|
char *file; /* decoded file */
|
2001-03-02 02:42:35 -05:00
|
|
|
|
|
|
|
char *entrypath; /* the PWD reply when we logged on */
|
2001-12-03 08:48:59 -05:00
|
|
|
|
|
|
|
char *cache; /* data cache between getresponse()-calls */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t cache_size; /* size of cache in bytes */
|
2002-06-14 02:57:00 -04: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) */
|
2002-12-03 05:25:31 -05: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-11-25 17:21:49 -05: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() */
|
|
|
|
bool cwddone; /* if it has been determined that the proper CWD combo
|
|
|
|
already has been done */
|
2006-01-10 18:03:22 -05:00
|
|
|
bool cwdfail; /* set TRUE if a CWD command fails, as then we must prevent
|
|
|
|
caching the current directory */
|
2004-11-25 17:21:49 -05:00
|
|
|
char *prevpath; /* conn->path from the previous transfer */
|
2005-03-29 06:35:25 -05:00
|
|
|
|
2005-02-09 08:06:40 -05:00
|
|
|
size_t nread_resp; /* number of bytes currently read of a server response */
|
2005-03-29 06:35:25 -05:00
|
|
|
char *linestart_resp; /* line start pointer for the FTP server response
|
|
|
|
reader function */
|
|
|
|
|
2005-02-09 08:06:40 -05:00
|
|
|
int count1; /* general purpose counter for the state machine */
|
|
|
|
int count2; /* general purpose counter for the state machine */
|
|
|
|
int count3; /* general purpose counter for the state machine */
|
|
|
|
char *sendthis; /* allocated pointer to a buffer that is to be sent to the
|
|
|
|
ftp server */
|
|
|
|
size_t sendleft; /* number of bytes left to send from the sendthis buffer */
|
|
|
|
size_t sendsize; /* total size of the sendthis buffer */
|
|
|
|
struct timeval response; /* set to Curl_tvnow() when a command has been sent
|
|
|
|
off, used to time-out response reading */
|
|
|
|
ftpstate state; /* always use ftp.c:state() to change state! */
|
|
|
|
curl_off_t downloadsize;
|
2001-02-20 12:35:51 -05:00
|
|
|
};
|
|
|
|
|
2001-03-05 08:39:01 -05:00
|
|
|
/****************************************************************************
|
|
|
|
* FILE unique setup
|
|
|
|
***************************************************************************/
|
2004-03-03 04:25:59 -05:00
|
|
|
struct FILEPROTO {
|
2004-05-25 17:47:29 -04:00
|
|
|
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! */
|
2001-03-05 08:39:01 -05:00
|
|
|
};
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
/*
|
|
|
|
* Boolean values that concerns this connection.
|
|
|
|
*/
|
|
|
|
struct ConnectBits {
|
|
|
|
bool close; /* if set, we close the connection after this request */
|
2001-03-02 02:42:35 -05:00
|
|
|
bool reuse; /* if set, this is a re-used connection */
|
2001-03-07 12:12:12 -05:00
|
|
|
bool chunk; /* if set, this is a chunked transfer-encoding */
|
2001-08-30 18:48:34 -04:00
|
|
|
bool httpproxy; /* if set, this transfer is done through a http proxy */
|
|
|
|
bool user_passwd; /* do we use user+password for this connection? */
|
2001-03-14 09:11:11 -05:00
|
|
|
bool proxy_user_passwd; /* user+password for the proxy? */
|
2005-01-29 08:07:16 -05:00
|
|
|
bool ipv6_ip; /* we communicate with a remote site specified with pure IPv6
|
2002-09-11 06:32:37 -04:00
|
|
|
IP address */
|
2005-01-29 08:07:16 -05:00
|
|
|
bool ipv6; /* we communicate with a site using an IPv6 address */
|
2001-04-18 03:25:11 -04:00
|
|
|
bool use_range;
|
|
|
|
bool rangestringalloc; /* the range string is malloc()'ed */
|
2002-11-11 18:03:03 -05: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 */
|
2002-12-10 08:10:00 -05:00
|
|
|
bool getheader; /* TRUE if header parsing is wanted */
|
2002-11-11 18:03:03 -05:00
|
|
|
|
2002-12-10 08:10:00 -05:00
|
|
|
bool forbidchunk; /* used only to explicitly forbid chunk-upload for
|
|
|
|
specific upload buffers. See readmoredata() in
|
|
|
|
http.c for details. */
|
2005-02-09 08:06:40 -05:00
|
|
|
|
|
|
|
bool tcpconnect; /* the TCP layer (or simimlar) is connected, this is set
|
|
|
|
the first time on the first connect function call */
|
|
|
|
bool protoconnstart;/* the protocol layer has STARTED its operation after
|
|
|
|
the TCP layer connect */
|
|
|
|
|
2004-02-02 09:49:54 -05:00
|
|
|
bool retry; /* this connection is about to get closed and then
|
|
|
|
re-attempted at another connection. */
|
2004-04-06 11:14:10 -04:00
|
|
|
bool no_body; /* CURLOPT_NO_BODY (or similar) was set */
|
2004-05-26 04:54:36 -04:00
|
|
|
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 */
|
2004-11-24 11:11:35 -05:00
|
|
|
bool authneg; /* TRUE when the auth phase has started, which means
|
|
|
|
that we are creating a request with an auth header,
|
|
|
|
but it is not the final request in the auth
|
|
|
|
negotiation. */
|
|
|
|
bool rewindaftersend;/* TRUE when the sending couldn't be stopped even
|
|
|
|
though it will be discarded. When the whole send
|
|
|
|
operation is done, we must call the data rewind
|
|
|
|
callback. */
|
2004-11-25 17:21:49 -05:00
|
|
|
bool ftp_use_epsv; /* As set with CURLOPT_FTP_USE_EPSV, but if we find out
|
|
|
|
EPSV doesn't work we disable it for the forthcoming
|
|
|
|
requests */
|
|
|
|
|
|
|
|
bool ftp_use_eprt; /* As set with CURLOPT_FTP_USE_EPRT, but if we find out
|
|
|
|
EPRT doesn't work we disable it for the forthcoming
|
|
|
|
requests */
|
2005-04-25 17:39:48 -04:00
|
|
|
bool netrc; /* name+password provided by netrc */
|
2005-11-28 18:06:00 -05:00
|
|
|
|
2005-07-12 14:15:34 -04:00
|
|
|
bool trailerHdrPresent; /* Set when Trailer: header found in HTTP response.
|
2005-11-28 18:06:00 -05:00
|
|
|
Required to determine whether to look for trailers
|
|
|
|
in case of Transfer-Encoding: chunking */
|
2006-03-07 18:11:41 -05:00
|
|
|
bool done; /* set to FALSE when Curl_do() is called and set to TRUE
|
|
|
|
when Curl_done() is called, to prevent Curl_done() to
|
|
|
|
get invoked twice when the multi interface is
|
|
|
|
used. */
|
2001-02-20 12:35:51 -05:00
|
|
|
};
|
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
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 */
|
|
|
|
};
|
|
|
|
|
2002-01-03 10:01:22 -05: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-06-16 05:28:47 -04:00
|
|
|
curl_off_t bytecount; /* total number of bytes read */
|
|
|
|
curl_off_t writebytecount; /* number of bytes written */
|
2002-01-03 10:01:22 -05:00
|
|
|
struct timeval start; /* transfer started at this time */
|
|
|
|
struct timeval now; /* current time */
|
2004-10-06 03:50:18 -04:00
|
|
|
bool header; /* incoming data has HTTP header */
|
2002-10-23 09:48:37 -04:00
|
|
|
enum {
|
2004-06-16 05:28:47 -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 */
|
2004-10-06 03:50:18 -04:00
|
|
|
} badheader; /* the header was deemed bad and will be
|
2002-09-13 08:40:36 -04:00
|
|
|
written as body */
|
2004-10-06 03:50:18 -04:00
|
|
|
int headerline; /* counts header lines to better track the
|
2002-01-03 10:01:22 -05:00
|
|
|
first one */
|
2004-10-06 03:50:18 -04:00
|
|
|
char *hbufp; /* points at *end* of header line */
|
2004-05-12 04:00:21 -04:00
|
|
|
size_t hbuflen;
|
2004-10-06 03:50:18 -04: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 */
|
|
|
|
curl_off_t offset; /* possible resume offset read from the
|
2002-01-03 10:01:22 -05:00
|
|
|
Content-Range: header */
|
2004-10-06 03:50:18 -04:00
|
|
|
int httpcode; /* error code from the 'HTTP/1.? XXX' line */
|
|
|
|
int httpversion; /* the HTTP version*10 */
|
2003-02-24 11:53:53 -05: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 */
|
2004-10-06 03:50:18 -04:00
|
|
|
int content_encoding; /* What content encoding. sec 3.5, RFC2616. */
|
2002-09-02 18:31:18 -04:00
|
|
|
|
2004-10-06 03:50:18 -04:00
|
|
|
#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 */
|
2002-09-02 18:31:18 -04:00
|
|
|
|
|
|
|
#ifdef HAVE_LIBZ
|
2004-10-06 03:50:18 -04:00
|
|
|
bool zlib_init; /* True if zlib already initialized;
|
|
|
|
undefined if Content-Encoding header. */
|
|
|
|
z_stream z; /* State structure for zlib. */
|
2002-09-02 18:31:18 -04:00
|
|
|
#endif
|
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
time_t timeofdoc;
|
|
|
|
long bodywrites;
|
|
|
|
|
|
|
|
char *buf;
|
2002-01-16 09:53:19 -05:00
|
|
|
char *uploadbuf;
|
2004-03-09 17:52:50 -05:00
|
|
|
curl_socket_t maxfd;
|
2002-01-03 10:01:22 -05:00
|
|
|
|
|
|
|
int keepon;
|
|
|
|
|
2002-11-11 03:40:37 -05:00
|
|
|
bool upload_done; /* set to TRUE when doing chunked transfer-encoding upload
|
|
|
|
and we're uploading the last chunk */
|
2003-06-11 11:31:40 -04:00
|
|
|
|
2003-06-12 19:03:08 -04:00
|
|
|
bool ignorebody; /* we read a response-body but we ignore it! */
|
2005-04-08 12:59:13 -04:00
|
|
|
bool ignorecl; /* This HTTP response has no body so we ignore the Content-
|
|
|
|
Length: header */
|
2002-01-03 10:01:22 -05:00
|
|
|
};
|
|
|
|
|
2004-04-26 03:20:11 -04:00
|
|
|
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
|
|
|
|
defined(USE_THREADING_GETADDRINFO)
|
2003-08-05 10:40:59 -04:00
|
|
|
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 */
|
2004-02-22 17:31:24 -05:00
|
|
|
void *os_specific; /* 'struct thread_data' for Windows */
|
2003-08-05 10:40:59 -04:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2003-11-24 02:15:37 -05:00
|
|
|
#define FIRSTSOCKET 0
|
|
|
|
#define SECONDARYSOCKET 1
|
|
|
|
|
2006-04-07 07:47:21 -04:00
|
|
|
/* These function pointer types are here only to allow easier typecasting
|
|
|
|
within the source when we need to cast between data pointers (such as NULL)
|
|
|
|
and function pointers. */
|
|
|
|
typedef CURLcode (*Curl_do_more_func)(struct connectdata *);
|
|
|
|
typedef CURLcode (*Curl_done_func)(struct connectdata *, CURLcode);
|
|
|
|
|
2000-05-22 10:12:12 -04: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 */
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data; /* link to the root CURL struct */
|
2004-07-04 17:36:14 -04:00
|
|
|
long connectindex; /* what index in the connects index this particular
|
2001-02-20 12:35:51 -05:00
|
|
|
struct has */
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
long protocol; /* PROT_* flags concerning the protocol set */
|
|
|
|
#define PROT_MISSING (1<<0)
|
|
|
|
#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)
|
2005-09-02 11:11:08 -04:00
|
|
|
#define PROT_TFTP (1<<11)
|
2001-03-29 03:16:55 -05:00
|
|
|
#define PROT_FTPS (1<<9)
|
2001-12-02 09:16:34 -05:00
|
|
|
#define PROT_SSL (1<<10) /* protocol requires SSL */
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2005-01-28 17:14:48 -05:00
|
|
|
/* 'dns_entry' is the particular host we use. This points to an entry in the
|
|
|
|
DNS cache and it will not get pruned while locked. It gets unlocked in
|
|
|
|
Curl_done() */
|
2004-06-24 03:43:48 -04:00
|
|
|
struct Curl_dns_entry *dns_entry;
|
2005-01-28 17:14:48 -05:00
|
|
|
|
|
|
|
/* 'ip_addr' is the particular IP we connected to. It points to a struct
|
|
|
|
within the DNS cache, so this pointer is only valid as long as the DNS
|
|
|
|
cache entry remains locked. It gets unlocked in Curl_done() */
|
|
|
|
Curl_addrinfo *ip_addr;
|
|
|
|
|
|
|
|
/* 'ip_addr_str' is the ip_addr data as a human readable malloc()ed string.
|
|
|
|
It remains available as long as the connection does, which is longer than
|
2005-01-29 08:07:16 -05:00
|
|
|
the ip_addr itself. Set with Curl_store_ip_addr() when ip_addr has been
|
|
|
|
set. */
|
2005-01-28 17:14:48 -05:00
|
|
|
char *ip_addr_str;
|
2002-11-05 05:51:41 -05:00
|
|
|
|
2004-05-07 14:46:28 -04:00
|
|
|
char protostr[16]; /* store the protocol string in this buffer */
|
2005-09-16 17:30:08 -04:00
|
|
|
int socktype; /* SOCK_STREAM or SOCK_DGRAM */
|
2004-04-27 09:56:23 -04:00
|
|
|
|
|
|
|
struct hostname host;
|
|
|
|
struct hostname proxy;
|
|
|
|
|
2004-04-20 03:53:24 -04:00
|
|
|
char *pathbuffer;/* allocated buffer to store the URL's path part in */
|
|
|
|
char *path; /* path to use, points to somewhere within the pathbuffer
|
|
|
|
area */
|
2001-02-20 12:35:51 -05:00
|
|
|
long port; /* which port to use locally */
|
|
|
|
unsigned short remote_port; /* what remote port to connect to,
|
|
|
|
not the proxy port! */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t bytecount;
|
2001-10-19 07:58:32 -04:00
|
|
|
long headerbytecount; /* only count received headers */
|
2004-04-07 10:27:54 -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 */
|
2001-03-09 10:19:42 -05:00
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
char *range; /* range, if used. See README for detailed specification on
|
|
|
|
this syntax. */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t resume_from; /* continue [ftp] transfer from here */
|
2001-04-18 03:25:11 -04:00
|
|
|
|
2003-07-19 19:55:15 -04:00
|
|
|
char *user; /* user name string, allocated */
|
|
|
|
char *passwd; /* password string, allocated */
|
|
|
|
|
2003-07-21 09:16:30 -04:00
|
|
|
char *proxyuser; /* proxy user name string, allocated */
|
|
|
|
char *proxypasswd; /* proxy password string, allocated */
|
2004-05-17 02:50:32 -04:00
|
|
|
|
2001-03-13 02:53:59 -05:00
|
|
|
struct timeval now; /* "current" time */
|
|
|
|
struct timeval created; /* creation time */
|
2004-03-09 17:52:50 -05:00
|
|
|
curl_socket_t sock[2]; /* two sockets, the second is used for the data
|
|
|
|
transfer when doing FTP */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t maxdownload; /* in bytes, the maximum amount of data to fetch, 0
|
2004-03-09 17:52:50 -05:00
|
|
|
means unlimited */
|
2004-05-17 02:50:32 -04:00
|
|
|
|
2003-11-24 02:15:37 -05:00
|
|
|
struct ssl_connect_data ssl[2]; /* this is for ssl-stuff */
|
2003-03-24 18:10:38 -05:00
|
|
|
struct ssl_config_data ssl_config;
|
2001-02-20 12:35:51 -05:00
|
|
|
|
|
|
|
struct ConnectBits bits; /* various state-flags for this connection */
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
/* These two functions MUST be set by the curl_connect() function to be
|
|
|
|
be protocol dependent */
|
2005-02-09 08:06:40 -05:00
|
|
|
CURLcode (*curl_do)(struct connectdata *, bool *done);
|
2006-04-07 07:47:21 -04:00
|
|
|
Curl_done_func curl_done;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2002-08-12 05:43:20 -04: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.
|
|
|
|
*/
|
2006-04-07 07:47:21 -04:00
|
|
|
Curl_do_more_func curl_do_more;
|
2002-08-12 05:43:20 -04:00
|
|
|
|
2000-05-22 10:12:12 -04: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.
|
2005-02-09 08:06:40 -05:00
|
|
|
* The 'done' pointer points to a bool that should be set to TRUE if the
|
|
|
|
* function completes before return. If it doesn't complete, the caller
|
|
|
|
* should call the curl_connecting() function until it is.
|
2004-05-17 02:50:32 -04:00
|
|
|
*/
|
2005-02-09 08:06:40 -05:00
|
|
|
CURLcode (*curl_connect)(struct connectdata *, bool *done);
|
|
|
|
|
|
|
|
/* See above. Currently only used for FTP. */
|
|
|
|
CURLcode (*curl_connecting)(struct connectdata *, bool *done);
|
|
|
|
CURLcode (*curl_doing)(struct connectdata *, bool *done);
|
|
|
|
|
|
|
|
/* Called from the multi interface during the PROTOCONNECT phase, and it
|
|
|
|
should then return a proper fd set */
|
2006-04-10 11:00:53 -04:00
|
|
|
int (*curl_proto_getsock)(struct connectdata *conn,
|
|
|
|
curl_socket_t *socks,
|
|
|
|
int numsocks);
|
2005-02-09 08:06:40 -05:00
|
|
|
|
|
|
|
/* Called from the multi interface during the DOING phase, and it should
|
|
|
|
then return a proper fd set */
|
2006-04-10 11:00:53 -04:00
|
|
|
int (*curl_doing_getsock)(struct connectdata *conn,
|
|
|
|
curl_socket_t *socks,
|
|
|
|
int numsocks);
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-03-02 02:42:35 -05: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-05-17 02:50:32 -04:00
|
|
|
*/
|
2003-10-18 16:14:33 -04:00
|
|
|
CURLcode (*curl_disconnect)(struct connectdata *);
|
2001-03-02 02:42:35 -05:00
|
|
|
|
2000-07-25 17:14:12 -04: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-05-17 02:50:32 -04:00
|
|
|
*/
|
2003-10-18 16:14:33 -04:00
|
|
|
CURLcode (*curl_close)(struct connectdata *);
|
2000-07-25 17:14:12 -04:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
/**** curl_get() phase fields */
|
|
|
|
|
|
|
|
/* READ stuff */
|
2004-10-06 03:50:18 -04:00
|
|
|
curl_socket_t sockfd; /* socket to read from or CURL_SOCKET_BAD */
|
|
|
|
curl_off_t size; /* -1 if unknown at this point */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t *bytecountp; /* return number of bytes read or NULL */
|
2004-05-17 02:50:32 -04:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
/* WRITE stuff */
|
2004-03-09 17:52:50 -05:00
|
|
|
curl_socket_t writesockfd; /* socket to write to, it may very
|
|
|
|
well be the same we read from.
|
|
|
|
CURL_SOCKET_BAD disables */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t *writebytecountp; /* return number of bytes written or NULL */
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-02-22 18:32:02 -05: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! */
|
2003-06-26 07:31:50 -04:00
|
|
|
char *accept_encoding; /* free later if not NULL! */
|
2001-02-22 18:32:02 -05: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 */
|
2003-04-30 13:01:00 -04:00
|
|
|
char *cookiehost; /* free later if not NULL */
|
2001-02-22 18:32:02 -05:00
|
|
|
} allocptr;
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2001-03-09 10:19:42 -05:00
|
|
|
char *newurl; /* This can only be set if a Location: was in the
|
2004-10-06 03:50:18 -04:00
|
|
|
document headers */
|
2001-03-09 10:19:42 -05:00
|
|
|
|
2005-04-07 11:27:13 -04:00
|
|
|
int sec_complete; /* if krb4 is enabled for this connection */
|
2003-12-02 08:27:29 -05:00
|
|
|
#ifdef HAVE_KRB4
|
2000-09-21 04:50:48 -04: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;
|
|
|
|
void *app_data;
|
2004-12-14 20:38:25 -05:00
|
|
|
const struct Curl_sec_client_mech *mech;
|
2001-08-17 06:13:32 -04:00
|
|
|
struct sockaddr_in local_addr;
|
2000-09-21 04:50:48 -04:00
|
|
|
#endif
|
2001-02-20 12:35:51 -05:00
|
|
|
|
|
|
|
/*************** Request - specific items ************/
|
|
|
|
/* previously this was in the urldata struct */
|
|
|
|
union {
|
|
|
|
struct HTTP *http;
|
|
|
|
struct HTTP *https; /* alias, just for the sake of being more readable */
|
|
|
|
struct FTP *ftp;
|
2005-09-02 11:11:08 -04:00
|
|
|
void *tftp; /* private for tftp.c-eyes only */
|
2004-03-03 04:25:59 -05:00
|
|
|
struct FILEPROTO *file;
|
2001-03-05 08:59:43 -05:00
|
|
|
void *telnet; /* private for telnet.c-eyes only */
|
2001-02-20 12:35:51 -05:00
|
|
|
void *generic;
|
|
|
|
} proto;
|
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
/* This struct is inited when needed */
|
|
|
|
struct Curl_transfer_keeper keep;
|
2002-01-16 09:53:19 -05:00
|
|
|
|
|
|
|
/* 'upload_present' is used to keep a byte counter of how much data there is
|
|
|
|
still left in the buffer, aimed for upload. */
|
2004-07-01 04:10:21 -04:00
|
|
|
ssize_t upload_present;
|
2002-01-16 09:53:19 -05: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 */
|
2002-08-12 05:43:20 -04:00
|
|
|
char *upload_fromhere;
|
2002-12-09 10:37:54 -05:00
|
|
|
|
|
|
|
curl_read_callback fread; /* function that reads the input */
|
|
|
|
void *fread_in; /* pointer to pass to the fread() above */
|
2003-06-26 07:31:50 -04:00
|
|
|
|
2003-07-15 19:36:50 -04:00
|
|
|
struct ntlmdata ntlm; /* NTLM differs from other authentication schemes
|
|
|
|
because it authenticates connections, not
|
|
|
|
single requests! */
|
2003-07-22 05:58:18 -04:00
|
|
|
struct ntlmdata proxyntlm; /* NTLM data for proxy */
|
2003-08-05 10:40:59 -04:00
|
|
|
|
2004-03-24 17:45:37 -05:00
|
|
|
char syserr_buf [256]; /* buffer for Curl_strerror() */
|
|
|
|
|
2004-04-26 03:20:11 -04:00
|
|
|
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
|
|
|
|
defined(USE_THREADING_GETADDRINFO)
|
2003-08-05 10:40:59 -04:00
|
|
|
/* data used for the asynch name resolve callback */
|
|
|
|
struct Curl_async async;
|
|
|
|
#endif
|
2004-06-03 07:41:05 -04:00
|
|
|
struct connectdata *sec_conn; /* secondary connection for 3rd party
|
|
|
|
transfer */
|
2005-01-21 04:32:32 -05:00
|
|
|
|
|
|
|
enum { NORMAL, SOURCE3RD, TARGET3RD } xfertype;
|
2005-07-12 14:15:34 -04:00
|
|
|
|
|
|
|
/* These three are used for chunked-encoding trailer support */
|
|
|
|
char *trailer; /* allocated buffer to store trailer in */
|
|
|
|
int trlMax; /* allocated buffer size */
|
|
|
|
int trlPos; /* index of where to store data */
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
};
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2003-06-26 07:31:50 -04:00
|
|
|
/* The end of connectdata. */
|
2002-09-02 18:31:18 -04:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
/*
|
|
|
|
* Struct to keep statistical and informational data.
|
|
|
|
*/
|
|
|
|
struct PureInfo {
|
2003-08-20 11:41:45 -04:00
|
|
|
int httpcode; /* Recent HTTP or FTP response code */
|
2003-08-11 19:15:41 -04:00
|
|
|
int httpproxycode;
|
2001-08-30 18:48:34 -04:00
|
|
|
int httpversion;
|
2003-07-30 03:22:28 -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. */
|
2001-08-30 18:48:34 -04:00
|
|
|
long header_size; /* size of read header(s) in bytes */
|
|
|
|
long request_size; /* the amount of bytes sent in the request(s) */
|
2002-01-29 05:49:32 -05:00
|
|
|
|
2003-09-04 06:55:20 -04:00
|
|
|
long proxyauthavail;
|
|
|
|
long httpauthavail;
|
|
|
|
|
2004-10-19 11:30:08 -04:00
|
|
|
long numconnects; /* how many new connection did libcurl created */
|
|
|
|
|
2002-01-29 05:49:32 -05:00
|
|
|
char *contenttype; /* the content type of the object */
|
2000-05-22 10:12:12 -04:00
|
|
|
};
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
|
2000-02-14 18:13:15 -05:00
|
|
|
struct Progress {
|
2000-02-15 19:02:40 -05:00
|
|
|
long lastshow; /* time() of the last displayed progress meter or NULL to
|
|
|
|
force redraw at next call */
|
2004-03-10 11:20:33 -05: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 */
|
2000-02-14 18:13:15 -05:00
|
|
|
|
2004-03-11 16:48:15 -05:00
|
|
|
curl_off_t current_speed; /* uses the currently fastest transfer */
|
2000-02-14 18:13:15 -05:00
|
|
|
|
2000-06-16 09:17:44 -04:00
|
|
|
bool callback; /* set when progress callback is used */
|
2000-02-14 18:13:15 -05:00
|
|
|
int width; /* screen width at download start */
|
|
|
|
int flags; /* see progress.h */
|
2001-10-12 08:31:43 -04:00
|
|
|
|
2001-11-20 10:00:50 -05:00
|
|
|
double timespent;
|
2001-10-12 08:31:43 -04:00
|
|
|
|
2004-03-11 16:48:15 -05:00
|
|
|
curl_off_t dlspeed;
|
|
|
|
curl_off_t ulspeed;
|
2000-03-01 17:06:57 -05:00
|
|
|
|
2000-11-06 10:31:10 -05:00
|
|
|
double t_nslookup;
|
|
|
|
double t_connect;
|
|
|
|
double t_pretransfer;
|
2001-11-20 10:00:50 -05:00
|
|
|
double t_starttransfer;
|
2002-04-16 03:59:20 -04:00
|
|
|
double t_redirect;
|
2000-09-25 17:49:37 -04:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
struct timeval start;
|
|
|
|
struct timeval t_startsingle;
|
2001-10-12 08:31:43 -04:00
|
|
|
#define CURR_TIME (5+1) /* 6 entries for 5 seconds */
|
2000-09-25 17:49:37 -04:00
|
|
|
|
2004-03-10 11:20:33 -05:00
|
|
|
curl_off_t speeder[ CURR_TIME ];
|
2001-10-12 08:31:43 -04:00
|
|
|
struct timeval speeder_time[ CURR_TIME ];
|
2000-09-25 17:49:37 -04:00
|
|
|
int speeder_c;
|
2000-02-14 18:13:15 -05:00
|
|
|
};
|
|
|
|
|
2001-01-26 10:52:01 -05:00
|
|
|
typedef enum {
|
|
|
|
HTTPREQ_NONE, /* first in list */
|
|
|
|
HTTPREQ_GET,
|
|
|
|
HTTPREQ_POST,
|
|
|
|
HTTPREQ_POST_FORM, /* we make a difference internally */
|
|
|
|
HTTPREQ_PUT,
|
2004-04-06 11:14:10 -04:00
|
|
|
HTTPREQ_HEAD,
|
2001-01-26 10:52:01 -05:00
|
|
|
HTTPREQ_CUSTOM,
|
|
|
|
HTTPREQ_LAST /* last in list */
|
|
|
|
} Curl_HttpReq;
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
/*
|
|
|
|
* Values that are generated, temporary or calculated internally for a
|
2006-03-21 17:30:03 -05:00
|
|
|
* "session handle" must be defined within the 'struct UrlState'. This struct
|
2001-08-30 18:48:34 -04:00
|
|
|
* 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
|
2003-05-21 04:08:48 -04:00
|
|
|
#define MAX_CURL_USER_LENGTH_TXT "255"
|
|
|
|
#define MAX_CURL_PASSWORD_LENGTH_TXT "255"
|
2001-08-30 18:48:34 -04:00
|
|
|
|
2004-05-04 03:52:53 -04:00
|
|
|
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 */
|
2004-11-24 11:11:35 -05:00
|
|
|
bool multi; /* TRUE if this is not yet authenticated but within the auth
|
|
|
|
multipass negotiation */
|
|
|
|
|
2004-05-04 03:52:53 -04:00
|
|
|
};
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
struct UrlState {
|
2002-08-05 13:04:39 -04:00
|
|
|
enum {
|
|
|
|
Curl_if_none,
|
|
|
|
Curl_if_easy,
|
|
|
|
Curl_if_multi
|
|
|
|
} used_interface;
|
|
|
|
|
2001-08-30 18:48:34 -04: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 */
|
2006-05-26 07:26:42 -04:00
|
|
|
long lastconnect; /* index of most recent connect or -1 if undefined */
|
2001-08-30 18:48:34 -04:00
|
|
|
|
|
|
|
char *headerbuff; /* allocated buffer to store headers in */
|
2004-05-12 04:00:21 -04:00
|
|
|
size_t headersize; /* size of the allocation */
|
2001-08-30 18:48:34 -04:00
|
|
|
|
2002-01-16 09:53:19 -05:00
|
|
|
char buffer[BUFSIZE+1]; /* download buffer */
|
|
|
|
char uploadbuffer[BUFSIZE+1]; /* upload buffer */
|
2004-03-23 11:01:31 -05:00
|
|
|
curl_off_t current_speed; /* the ProgressShow() funcion sets this,
|
|
|
|
bytes / second */
|
2000-07-25 17:14:12 -04:00
|
|
|
bool this_is_a_follow; /* this is a followed Location: request */
|
2001-08-30 18:48:34 -04:00
|
|
|
|
2004-09-10 16:58:51 -04:00
|
|
|
char *first_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.
|
2001-08-30 18:48:34 -04:00
|
|
|
*/
|
2001-09-06 04:32:01 -04:00
|
|
|
|
|
|
|
struct curl_ssl_session *session; /* array of 'numsessions' size */
|
|
|
|
long sessionage; /* number of the most recent session */
|
2001-09-12 08:02:12 -04:00
|
|
|
|
2003-01-20 07:52:34 -05:00
|
|
|
char *scratch; /* huge buffer[BUFSIZE*2] when doing upload CRLF replacing */
|
2001-11-02 17:30:34 -05: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. */
|
2004-09-30 17:01:23 -04:00
|
|
|
int os_errno; /* filled in with errno whenever an error occurs */
|
2002-01-03 10:01:22 -05:00
|
|
|
#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. */
|
2003-05-22 12:09:54 -04:00
|
|
|
|
|
|
|
struct digestdata digest;
|
2004-05-04 03:52:53 -04:00
|
|
|
struct digestdata proxydigest;
|
2003-06-10 08:22:19 -04:00
|
|
|
|
2003-09-19 08:56:22 -04:00
|
|
|
#ifdef HAVE_GSSAPI
|
2003-06-10 08:22:19 -04:00
|
|
|
struct negotiatedata negotiate;
|
|
|
|
#endif
|
2003-06-26 07:31:50 -04:00
|
|
|
|
2004-05-04 03:52:53 -04:00
|
|
|
struct auth authhost;
|
|
|
|
struct auth authproxy;
|
2003-08-05 10:40:59 -04:00
|
|
|
|
2004-04-22 16:07:41 -04:00
|
|
|
bool authproblem; /* TRUE if there's some problem authenticating */
|
2003-08-05 10:40:59 -04:00
|
|
|
#ifdef USE_ARES
|
|
|
|
ares_channel areschannel; /* for name resolves */
|
|
|
|
#endif
|
2004-12-14 04:36:22 -05:00
|
|
|
|
|
|
|
#if defined(USE_SSLEAY) && defined(HAVE_OPENSSL_ENGINE_H)
|
|
|
|
ENGINE *engine;
|
|
|
|
#endif /* USE_SSLEAY */
|
2006-04-10 11:00:53 -04:00
|
|
|
struct timeval expiretime; /* set this with Curl_expire() only */
|
|
|
|
struct Curl_tree timenode; /* for the splay stuff */
|
2006-03-21 17:30:03 -05:00
|
|
|
|
|
|
|
/* a place to store the most recenlty set FTP entrypath */
|
|
|
|
char *most_recent_ftp_entrypath;
|
2006-04-26 03:40:37 -04:00
|
|
|
|
|
|
|
#ifndef WIN32
|
|
|
|
/* do FTP line-end conversions on most platforms */
|
|
|
|
#define CURL_DO_LINEEND_CONV
|
|
|
|
/* for FTP downloads: track CRLF sequences that span blocks */
|
|
|
|
bool prev_block_had_trailing_cr;
|
|
|
|
/* for FTP downloads: how many CRLFs did we converted to LFs? */
|
2006-04-26 09:08:12 -04:00
|
|
|
curl_off_t crlf_conversions;
|
2006-04-26 03:40:37 -04:00
|
|
|
#endif
|
2000-05-22 10:12:12 -04:00
|
|
|
};
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
/*
|
2001-08-30 18:48:34 -04: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 */
|
2003-07-04 12:29:23 -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
|
2004-05-17 02:50:32 -04:00
|
|
|
to change it and if so, we reconnect to use the new
|
2003-07-04 12:29:23 -04:00
|
|
|
URL instead */
|
2001-08-30 18:48:34 -04: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 */
|
2002-10-17 03:10:39 -04:00
|
|
|
struct curl_slist *cookielist; /* list of cookie files set by
|
|
|
|
curl_easy_setopt(COOKIEFILE) calls */
|
2001-08-30 18:48:34 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This 'UserDefined' struct must only contain data that is set once to go
|
2001-02-22 18:32:02 -05:00
|
|
|
* for many (perhaps) independent connections. Values that are generated or
|
2001-08-30 18:48:34 -04:00
|
|
|
* calculated internally for the "session handle" MUST be defined within the
|
2006-03-21 17:30:03 -05:00
|
|
|
* 'struct UrlState' instead. The only exceptions MUST note the changes in
|
2001-08-30 18:48:34 -04:00
|
|
|
* the 'DynamicStatic' struct.
|
2000-05-22 10:12:12 -04:00
|
|
|
*/
|
2006-04-10 11:00:53 -04:00
|
|
|
struct Curl_one_easy; /* declared and used only in multi.c */
|
|
|
|
struct Curl_multi; /* declared and used only in multi.c */
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
struct UserDefined {
|
2002-04-12 03:21:11 -04:00
|
|
|
FILE *err; /* the stderr user data goes here */
|
|
|
|
void *debugdata; /* the data that will be passed to fdebug */
|
2000-05-22 10:12:12 -04:00
|
|
|
char *errorbuffer; /* store failure messages in here */
|
|
|
|
char *proxyuserpwd; /* Proxy <user:password>, if used */
|
2000-07-25 03:32:22 -04:00
|
|
|
long proxyport; /* If non-zero, use this port number by default. If the
|
|
|
|
proxy string features a ":[port]" that one will override
|
2004-05-17 02:50:32 -04:00
|
|
|
this. */
|
2001-05-04 03:47:11 -04:00
|
|
|
void *out; /* the fetched file goes here */
|
|
|
|
void *in; /* the uploaded file is read from here */
|
2006-03-21 17:30:03 -05:00
|
|
|
void *writeheader; /* write the header to this if non-NULL */
|
2001-08-30 18:48:34 -04:00
|
|
|
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 */
|
2003-06-26 07:31:50 -04:00
|
|
|
long httpauth; /* what kind of HTTP authentication to use (bitmask) */
|
2003-08-11 07:47:45 -04:00
|
|
|
long proxyauth; /* what kind of proxy authentication to use (bitmask) */
|
2001-08-30 18:48:34 -04:00
|
|
|
char *set_range; /* range, if used. See README for detailed specification
|
|
|
|
on this syntax. */
|
|
|
|
long followlocation; /* as in HTTP Location: */
|
2005-10-27 18:05:38 -04:00
|
|
|
long maxredirs; /* maximum no. of http(s) redirects to follow, set to -1
|
|
|
|
for infinity */
|
2001-08-30 18:48:34 -04:00
|
|
|
char *set_referer; /* custom string */
|
2000-06-20 07:23:31 -04:00
|
|
|
bool free_referer; /* set TRUE if 'referer' points to a string we
|
|
|
|
allocated */
|
1999-12-29 09:20:26 -05:00
|
|
|
char *useragent; /* User-Agent string */
|
2002-12-09 10:37:54 -05:00
|
|
|
char *encoding; /* Accept-Encoding string */
|
2001-08-30 18:48:34 -04:00
|
|
|
char *postfields; /* if POST, set the fields' values here */
|
2004-03-12 03:55:47 -05: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) */
|
2001-08-30 18:48:34 -04:00
|
|
|
char *ftpport; /* port to send with the FTP PORT command */
|
2006-01-30 03:24:07 -05:00
|
|
|
char *device; /* local network interface/address to use */
|
|
|
|
unsigned short localport; /* local port number to bind to */
|
|
|
|
int localportrange; /* number of additional port numbers to test in case the
|
|
|
|
'localport' one can't be bind()ed */
|
2001-08-30 18:48:34 -04:00
|
|
|
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 */
|
2002-04-12 03:21:11 -04:00
|
|
|
curl_debug_callback fdebug; /* function that write informational data */
|
2004-11-26 11:08:15 -05:00
|
|
|
curl_ioctl_callback ioctl; /* function for I/O control */
|
2006-04-07 17:50:47 -04:00
|
|
|
|
|
|
|
/* the 3 curl_conv_callback functions below are used on non-ASCII hosts */
|
|
|
|
/* function to convert from the network encoding: */
|
|
|
|
curl_conv_callback convfromnetwork;
|
|
|
|
/* function to convert to the network encoding: */
|
|
|
|
curl_conv_callback convtonetwork;
|
|
|
|
/* function to convert from UTF-8 encoding: */
|
|
|
|
curl_conv_callback convfromutf8;
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
void *progress_client; /* pointer to pass to the progress callback */
|
2004-11-26 11:08:15 -05:00
|
|
|
void *ioctl_client; /* pointer to pass to the ioctl callback */
|
2001-08-30 18:48:34 -04:00
|
|
|
long timeout; /* in seconds, 0 means no timeout */
|
|
|
|
long connecttimeout; /* in seconds, 0 means no timeout */
|
2003-09-03 18:02:40 -04:00
|
|
|
long ftp_response_timeout; /* in seconds, 0 means no timeout */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t infilesize; /* size of file to upload, -1 means unknown */
|
1999-12-29 09:20:26 -05:00
|
|
|
long low_speed_limit; /* bytes/second */
|
|
|
|
long low_speed_time; /* number of seconds */
|
2006-06-22 17:36:53 -04:00
|
|
|
curl_off_t max_send_speed; /* high speed limit in bytes/second for upload */
|
|
|
|
curl_off_t max_recv_speed; /* high speed limit in bytes/second for download */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t set_resume_from; /* continue [ftp] transfer from here */
|
2001-08-30 18:48:34 -04:00
|
|
|
char *cookie; /* HTTP cookie string to send */
|
2000-06-05 04:23:50 -04:00
|
|
|
struct curl_slist *headers; /* linked list of extra headers */
|
2004-01-22 06:54:00 -05:00
|
|
|
struct curl_httppost *httppost; /* linked list of POST data */
|
2001-12-17 18:01:39 -05: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 */
|
2001-08-30 18:48:34 -04:00
|
|
|
char *cookiejar; /* dump all cookies to this file */
|
2002-05-07 05:58:13 -04:00
|
|
|
bool cookiesession; /* new cookie session? */
|
2001-08-30 18:48:34 -04:00
|
|
|
bool crlf; /* convert crlf on ftp upload(?) */
|
2005-01-25 17:13:12 -05:00
|
|
|
char *ftp_account; /* ftp account data */
|
2002-02-28 18:31:23 -05:00
|
|
|
struct curl_slist *quote; /* after connection is established */
|
2000-01-10 18:36:14 -05:00
|
|
|
struct curl_slist *postquote; /* after the transfer */
|
2004-06-03 07:41:05 -04:00
|
|
|
struct curl_slist *prequote; /* before the transfer, after type */
|
2005-01-21 04:32:32 -05:00
|
|
|
struct curl_slist *source_quote; /* 3rd party quote */
|
2004-06-03 07:41:05 -04:00
|
|
|
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 */
|
2001-02-20 12:35:51 -05:00
|
|
|
struct curl_slist *telnet_options; /* linked list of telnet options */
|
2001-10-09 02:52:37 -04:00
|
|
|
curl_TimeCond timecondition; /* kind of time/date comparison */
|
2001-01-24 07:10:10 -05:00
|
|
|
time_t timevalue; /* what time to compare with */
|
2001-08-30 18:48:34 -04:00
|
|
|
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 */
|
2001-10-09 02:52:37 -04:00
|
|
|
long httpversion; /* when non-zero, a specific HTTP version requested to
|
|
|
|
be used in the library's request(s) */
|
2000-07-25 17:14:12 -04:00
|
|
|
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)
|
|
|
|
*/
|
2001-01-24 07:10:10 -05:00
|
|
|
char *krb4_level; /* what security level */
|
2001-08-30 18:48:34 -04:00
|
|
|
struct ssl_config_data ssl; /* user defined SSL stuff */
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2002-08-30 05:20:11 -04:00
|
|
|
curl_proxytype proxytype; /* what kind of proxy that is in use */
|
|
|
|
|
2002-01-07 23:30:59 -05:00
|
|
|
int dns_cache_timeout; /* DNS cache timeout */
|
2002-06-15 17:00:54 -04:00
|
|
|
long buffer_size; /* size of receive buffer to use */
|
2002-11-20 14:11:22 -05:00
|
|
|
|
2004-12-16 16:27:23 -05:00
|
|
|
char *private_data; /* Private data */
|
2003-01-07 11:15:53 -05:00
|
|
|
|
2006-04-10 11:00:53 -04:00
|
|
|
struct Curl_one_easy *one_easy; /* When adding an easy handle to a multi
|
|
|
|
handle, an internal 'Curl_one_easy'
|
|
|
|
struct is created and this is a pointer
|
|
|
|
to the particular struct associated with
|
|
|
|
this SessionHandle */
|
|
|
|
|
2003-01-07 11:15:53 -05:00
|
|
|
struct curl_slist *http200aliases; /* linked list of aliases for http200 */
|
2003-09-19 11:16:47 -04:00
|
|
|
|
2004-07-01 03:43:20 -04:00
|
|
|
long ip_version;
|
2003-10-17 09:11:00 -04:00
|
|
|
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t max_filesize; /* Maximum file size to download */
|
2004-05-17 02:50:32 -04:00
|
|
|
|
2005-01-21 04:32:32 -05:00
|
|
|
char *source_url; /* for 3rd party transfer */
|
2004-06-03 07:41:05 -04:00
|
|
|
char *source_userpwd; /* for 3rd party transfer */
|
|
|
|
|
2005-11-28 18:06:00 -05:00
|
|
|
curl_ftpfile ftp_filemethod; /* how to get to a file when FTP is used */
|
|
|
|
|
2001-08-30 18:48:34 -04: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-06-03 07:41:05 -04:00
|
|
|
bool printhost; /* printing host name in debug info */
|
2001-08-30 18:48:34 -04:00
|
|
|
bool get_filetime;
|
|
|
|
bool tunnel_thru_httpproxy;
|
|
|
|
bool ftp_append;
|
|
|
|
bool ftp_ascii;
|
|
|
|
bool ftp_list_only;
|
2003-08-08 05:13:19 -04:00
|
|
|
bool ftp_create_missing_dirs;
|
2001-08-30 18:48:34 -04:00
|
|
|
bool ftp_use_port;
|
|
|
|
bool hide_progress;
|
|
|
|
bool http_fail_on_error;
|
|
|
|
bool http_follow_location;
|
2003-03-30 23:41:05 -05:00
|
|
|
bool http_disable_hostname_check_before_authentication;
|
2004-04-13 03:37:28 -04:00
|
|
|
bool include_header; /* include received protocol headers in data output */
|
2001-08-30 18:48:34 -04:00
|
|
|
bool http_set_referer;
|
|
|
|
bool http_auto_referer; /* set "correct" referer when following location: */
|
2004-04-06 11:14:10 -04:00
|
|
|
bool opt_no_body; /* as set with CURLOPT_NO_BODY */
|
2001-08-30 18:48:34 -04:00
|
|
|
bool set_port;
|
|
|
|
bool upload;
|
2002-05-21 18:17:19 -04:00
|
|
|
enum CURL_NETRC_OPTION
|
|
|
|
use_netrc; /* defined in include/curl.h */
|
2003-11-11 09:30:43 -05:00
|
|
|
char *netrc_file; /* if not NULL, use this instead of trying to find
|
|
|
|
$HOME/.netrc */
|
2001-08-30 18:48:34 -04: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 */
|
2001-11-28 18:20:14 -05:00
|
|
|
bool ftp_use_epsv; /* if EPSV is to be attempted or not */
|
2003-05-09 03:39:29 -04:00
|
|
|
bool ftp_use_eprt; /* if EPRT is to be attempted or not */
|
2003-11-24 02:15:37 -05:00
|
|
|
curl_ftpssl ftp_ssl; /* if AUTH TLS is to be attempted etc */
|
2004-09-16 17:45:16 -04:00
|
|
|
curl_ftpauth ftpsslauth; /* what AUTH XXX to be attempted */
|
2002-08-22 15:38:50 -04:00
|
|
|
bool no_signal; /* do not use any signal/alarm handler */
|
2004-04-13 03:16:26 -04:00
|
|
|
bool global_dns_cache; /* subject for future removal */
|
|
|
|
bool tcp_nodelay; /* whether to enable TCP_NODELAY or not */
|
2005-08-24 06:57:28 -04:00
|
|
|
bool ignorecl; /* ignore content length */
|
2005-09-04 01:16:06 -04:00
|
|
|
bool ftp_skip_ip; /* skip the IP address the FTP server passes on to
|
|
|
|
us */
|
2006-02-11 17:35:16 -05:00
|
|
|
bool connect_only; /* make connection, let application use the socket */
|
2001-08-30 18:48:34 -04:00
|
|
|
};
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2006-07-07 18:58:06 -04:00
|
|
|
struct Names {
|
|
|
|
struct curl_hash *hostcache;
|
|
|
|
enum {
|
|
|
|
HCACHE_NONE, /* not pointing to anything */
|
|
|
|
HCACHE_PRIVATE, /* points to our own */
|
|
|
|
HCACHE_GLOBAL, /* points to the (shrug) global one */
|
|
|
|
HCACHE_MULTI, /* points to a shared one in the multi handle */
|
|
|
|
HCACHE_SHARED /* points to a shared one in a shared object */
|
|
|
|
} hostcachetype;
|
|
|
|
};
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
/*
|
2006-07-07 18:58:06 -04:00
|
|
|
* The 'connectdata' struct MUST have all the connection oriented stuff as we
|
|
|
|
* may have several simultaneous connections and connection structs in memory.
|
2001-08-30 18:48:34 -04:00
|
|
|
*
|
2006-07-07 18:58:06 -04:00
|
|
|
* The 'struct UserDefined' must only contain data that is set once to go for
|
|
|
|
* many (perhaps) independent connections. Values that are generated or
|
2001-08-30 18:48:34 -04:00
|
|
|
* calculated internally for the "session handle" must be defined within the
|
2006-07-07 18:58:06 -04:00
|
|
|
* 'struct UrlState' instead.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
|
|
|
|
struct SessionHandle {
|
2006-07-07 18:58:06 -04:00
|
|
|
struct Names dns;
|
2006-04-10 11:00:53 -04:00
|
|
|
struct Curl_multi *multi; /* if non-NULL, points to the multi handle
|
2005-01-10 05:07:07 -05:00
|
|
|
struct of which this "belongs" */
|
2003-01-08 10:50:52 -05:00
|
|
|
struct Curl_share *share; /* Share, handles global variable mutexing */
|
2001-08-30 18:48:34 -04: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 */
|
2006-04-07 17:50:47 -04:00
|
|
|
/* set by ftp_transfertype for use by Curl_client_write and others */
|
|
|
|
bool ftp_in_ascii_mode;
|
|
|
|
#if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV)
|
|
|
|
iconv_t outbound_cd; /* for translating to the network encoding */
|
|
|
|
iconv_t inbound_cd; /* for translating from the network encoding */
|
|
|
|
iconv_t utf8_cd; /* for translating to UTF8 */
|
|
|
|
#endif /* CURL_DOES_CONVERSIONS && HAVE_ICONV */
|
1999-12-29 09:20:26 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
#define LIBCURL_NAME "libcurl"
|
|
|
|
|
|
|
|
#endif
|