curl.h

VC写的实现HTTP协议的完成程序

		/* If the download receives less than "low speed limit" bytes/second
		* during "low speed time" seconds, the operations is aborted.
		* You could i.e if you have a pretty high speed connection, abort if
		* it is less than 2000 bytes/sec during 20 seconds.   
		*/

		/* Set the "low speed limit" */
		CINIT(LOW_SPEED_LIMIT, LONG , 19),

		/* Set the "low speed time" */
		CINIT(LOW_SPEED_TIME, LONG, 20),

		/* Set the continuation offset */
		CINIT(RESUME_FROM, LONG, 21),

		/* Set cookie in request: */
		CINIT(COOKIE, OBJECTPOINT, 22),

		/* This points to a linked list of headers, struct curl_slist kind */
		CINIT(HTTPHEADER, OBJECTPOINT, 23),

		/* This points to a linked list of post entries, struct HttpPost */
		CINIT(HTTPPOST, OBJECTPOINT, 24),

		/* name of the file keeping your private SSL-certificate */
		CINIT(SSLCERT, OBJECTPOINT, 25),

		/* password for the SSL-private key, keep this for compatibility */
		CINIT(SSLCERTPASSWD, OBJECTPOINT, 26),
		/* password for the SSL private key */
		CINIT(SSLKEYPASSWD, OBJECTPOINT, 26),

		/* send TYPE parameter? */
		CINIT(CRLF, LONG, 27),

		/* send linked-list of QUOTE commands */
		CINIT(QUOTE, OBJECTPOINT, 28),

		/* send FILE * or void * to store headers to, if you use a callback it
		is simply passed to the callback unmodified */
		CINIT(WRITEHEADER, OBJECTPOINT, 29),

		/* point to a file to read the initial cookies from, also enables
		"cookie awareness" */
		CINIT(COOKIEFILE, OBJECTPOINT, 31),

		/* What version to specifly try to use.
		See CURL_SSLVERSION defines below. */
		CINIT(SSLVERSION, LONG, 32),

		/* What kind of HTTP time condition to use, see defines */
		CINIT(TIMECONDITION, LONG, 33),

		/* Time to use with the above condition. Specified in number of seconds
		since 1 Jan 1970 */
		CINIT(TIMEVALUE, LONG, 34),

		/* HTTP request, for odd commands like DELETE, TRACE and others */
		/* OBSOLETE DEFINE, left for tradition only */
		CINIT(HTTPREQUEST, OBJECTPOINT, 35),

		/* Custom request, for customizing the get command like
		HTTP: DELETE, TRACE and others
		FTP: to use a different list command
		*/
		CINIT(CUSTOMREQUEST, OBJECTPOINT, 36),

		/* HTTP request, for odd commands like DELETE, TRACE and others */
		CINIT(STDERR, OBJECTPOINT, 37),

		/* 38 is not used */

		/* send linked-list of post-transfer QUOTE commands */
		CINIT(POSTQUOTE, OBJECTPOINT, 39),

		/* Pass a pointer to string of the output using full variable-replacement
		as described elsewhere. */
		CINIT(WRITEINFO, OBJECTPOINT, 40),

		/* Previous FLAG bits */
		CINIT(VERBOSE, LONG, 41),      /* talk a lot */
		CINIT(HEADER, LONG, 42),       /* throw the header out too */
		CINIT(NOPROGRESS, LONG, 43),   /* shut off the progress meter */
		CINIT(NOBODY, LONG, 44),       /* use HEAD to get http document */
		CINIT(FAILONERROR, LONG, 45),  /* no output on http error codes >= 300 */
		CINIT(UPLOAD, LONG, 46),       /* this is an upload */
		CINIT(POST, LONG, 47),         /* HTTP POST method */
		CINIT(FTPLISTONLY, LONG, 48),  /* Use NLST when listing ftp dir */

		CINIT(FTPAPPEND, LONG, 50),    /* Append instead of overwrite on upload! */

		/* Specify whether to read the user+password from the .netrc or the URL.
		* This must be one of the CURL_NETRC_* enums below. */
		CINIT(NETRC, LONG, 51),

		CINIT(FOLLOWLOCATION, LONG, 52),  /* use Location: Luke! */

		/* This FTPASCII name is now obsolete, to be removed, use the TRANSFERTEXT
		instead. It goes for more protocols than just ftp... */
		CINIT(FTPASCII, LONG, 53),     /* use TYPE A for transfer */

		CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */
		CINIT(PUT, LONG, 54),          /* PUT the input file */

		CINIT(MUTE, LONG, 55),         /* OBSOLETE OPTION, removed in 7.8 */

		/* Function that will be called instead of the internal progress display
		* function. This function should be defined as the curl_progress_callback
		* prototype defines. */
		CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56),

		/* Data passed to the progress callback */
		CINIT(PROGRESSDATA, OBJECTPOINT, 57),

		/* We want the referer field set automatically when following locations */
		CINIT(AUTOREFERER, LONG, 58),

		/* Port of the proxy, can be set in the proxy string as well with:
		"[host]:[port]" */
		CINIT(PROXYPORT, LONG, 59),

		/* size of the POST input data, if strlen() is not good to use */
		CINIT(POSTFIELDSIZE, LONG, 60),

		/* tunnel non-http operations through a HTTP proxy */
		CINIT(HTTPPROXYTUNNEL, LONG, 61),

		/* Set the interface string to use as outgoing network interface */
		CINIT(INTERFACE, OBJECTPOINT, 62),

		/* Set the krb4 security level, this also enables krb4 awareness.  This is a
		* string, 'clear', 'safe', 'confidential' or 'private'.  If the string is
		* set but doesn't match one of these, 'private' will be used.  */
		CINIT(KRB4LEVEL, OBJECTPOINT, 63),

		/* Set if we should verify the peer in ssl handshake, set 1 to verify. */
		CINIT(SSL_VERIFYPEER, LONG, 64),

		/* The CApath or CAfile used to validate the peer certificate
		this option is used only if SSL_VERIFYPEER is true */
		CINIT(CAINFO, OBJECTPOINT, 65),

		/* Function pointer to replace the internal password prompt */
		CINIT(PASSWDFUNCTION, FUNCTIONPOINT, 66),

		/* Custom pointer that gets passed as first argument to the password
		function */
		CINIT(PASSWDDATA, OBJECTPOINT, 67),

		/* Maximum number of http redirects to follow */
		CINIT(MAXREDIRS, LONG, 68),

		/* Pass a pointer to a time_t to get a possible date of the requested
		document! Pass a NULL to shut it off. */
		CINIT(FILETIME, OBJECTPOINT, 69),

		/* This points to a linked list of telnet options */
		CINIT(TELNETOPTIONS, OBJECTPOINT, 70),

		/* Max amount of cached alive connections */
		CINIT(MAXCONNECTS, LONG, 71),

		/* What policy to use when closing connections when the cache is filled
		up */
		CINIT(CLOSEPOLICY, LONG, 72),

		/* Callback to use when CURLCLOSEPOLICY_CALLBACK is set */
		CINIT(CLOSEFUNCTION, FUNCTIONPOINT, 73),

		/* Set to explicitly use a new connection for the upcoming transfer.
		Do not use this unless you're absolutely sure of this, as it makes the
		operation slower and is less friendly for the network. */
		CINIT(FRESH_CONNECT, LONG, 74),

		/* Set to explicitly forbid the upcoming transfer's connection to be re-used
		when done. Do not use this unless you're absolutely sure of this, as it
		makes the operation slower and is less friendly for the network. */
		CINIT(FORBID_REUSE, LONG, 75),

		/* Set to a file name that contains random data for libcurl to use to
		seed the random engine when doing SSL connects. */
		CINIT(RANDOM_FILE, OBJECTPOINT, 76),

		/* Set to the Entropy Gathering Daemon socket pathname */
		CINIT(EGDSOCKET, OBJECTPOINT, 77),

		/* Time-out connect operations after this amount of seconds, if connects
		are OK within this time, then fine... This only aborts the connect
		phase. [Only works on unix-style/SIGALRM operating systems] */
		CINIT(CONNECTTIMEOUT, LONG, 78),

		/* Function that will be called to store headers (instead of fwrite). The
		* parameters will use fwrite() syntax, make sure to follow them. */
		CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),

		/* Set this to force the HTTP request to get back to GET. Only really usable
		if POST, PUT or a custom request have been used first.
		*/
		CINIT(HTTPGET, LONG, 80),

		/* Set if we should verify the Common name from the peer certificate in ssl
		* handshake, set 1 to check existence, 2 to ensure that it matches the
		* provided hostname. */
		CINIT(SSL_VERIFYHOST, LONG, 81),

		/* Specify which file name to write all known cookies in after completed
		operation. Set file name to "-" (dash) to make it go to stdout. */
		CINIT(COOKIEJAR, OBJECTPOINT, 82),

		/* Specify which SSL ciphers to use */
		CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83),

		/* Specify which HTTP version to use! This must be set to one of the
		CURL_HTTP_VERSION* enums set below. */
		CINIT(HTTP_VERSION, LONG, 84),

		/* Specificly switch on or off the FTP engine's use of the EPSV command. By
		default, that one will always be attempted before the more traditional
		PASV command. */     
		CINIT(FTP_USE_EPSV, LONG, 85),

		/* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */
		CINIT(SSLCERTTYPE, OBJECTPOINT, 86),

		/* name of the file keeping your private SSL-key */
		CINIT(SSLKEY, OBJECTPOINT, 87),

		/* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */
		CINIT(SSLKEYTYPE, OBJECTPOINT, 88),

		/* crypto engine for the SSL-sub system */
		CINIT(SSLENGINE, OBJECTPOINT, 89),

		/* set the crypto engine for the SSL-sub system as default
		the param has no meaning...
		*/
		CINIT(SSLENGINE_DEFAULT, LONG, 90),

		/* Non-zero value means to use the global dns cache */
		CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91),

		/* DNS cache timeout */
		CINIT(DNS_CACHE_TIMEOUT, LONG, 92),

		/* send linked-list of pre-transfer QUOTE commands (Wesley Laxton)*/
		CINIT(PREQUOTE, OBJECTPOINT, 93),

		/* set the debug function */
		CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),

		/* set the data for the debug function */
		CINIT(DEBUGDATA, OBJECTPOINT, 95),

		/* mark this as start of a cookie session */
		CINIT(COOKIESESSION, LONG, 96),

		/* The CApath directory used to validate the peer certificate
		this option is used only if SSL_VERIFYPEER is true */
		CINIT(CAPATH, OBJECTPOINT, 97),

		/* Instruct libcurl to use a smaller receive buffer */
		CINIT(BUFFERSIZE, LONG, 98),

		/* Instruct libcurl to not use any signal/alarm handlers, even when using
		timeouts. This option is useful for multi-threaded applications.
		See libcurl-the-guide for more background information. */
		CINIT(NOSIGNAL, LONG, 99),

		/* Provide a CURLShare for mutexing non-ts data */
		CINIT(SHARE, OBJECTPOINT, 100),

		/* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
		CURLPROXY_SOCKS4 and CURLPROXY_SOCKS5. */
		CINIT(PROXYTYPE, LONG, 101),

		/* Set the Accept-Encoding string. Use this to tell a server you would like
		the response to be compressed. */
		CINIT(ENCODING, OBJECTPOINT, 102),

		/* Set pointer to private data */
		CINIT(PRIVATE, OBJECTPOINT, 103),

		/* Set aliases for HTTP 200 in the HTTP Response header */
		CINIT(HTTP200ALIASES, OBJECTPOINT, 104),

		/* Continue to send authentication (user+password) when following locations,
		even when hostname changed. This can potentionally send off the name
		and password to whatever host the server decides. */
		CINIT(UNRESTRICTED_AUTH, LONG, 105),

		CURLOPT_LASTENTRY /* the last unused */
	} CURLoption;

	/* two convenient "aliases" that follow the name scheme better */
#define CURLOPT_WRITEDATA CURLOPT_FILE
#define CURLOPT_READDATA  CURLOPT_INFILE 
#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER


	/* These enums are for use with the CURLOPT_HTTP_VERSION option. */
	enum {
		CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
										like the library to choose the best possible
										for us! */
										CURL_HTTP_VERSION_1_0,  /* please use HTTP 1.0 in the request */
										CURL_HTTP_VERSION_1_1,  /* please use HTTP 1.1 in the request */

										CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */
	};

	/* These enums are for use with the CURLOPT_NETRC option. */
	enum CURL_NETRC_OPTION {
		CURL_NETRC_IGNORED,     /* The .netrc will never be read.
										* This is the default. */
										CURL_NETRC_OPTIONAL,    /* A user:password in the URL will be preferred
																		* to one in the .netrc. */
																		CURL_NETRC_REQUIRED,    /* A user:password in the URL will be ignored.
																										* Unless one is set programmatically, the .netrc
																										* will be queried. */
																										CURL_NETRC_LAST
	};

	enum {
		CURL_SSLVERSION_DEFAULT,
		CURL_SSLVERSION_TLSv1,
		CURL_SSLVERSION_SSLv2,
		CURL_SSLVERSION_SSLv3,

		CURL_SSLVERSION_LAST /* never use, keep last */
	};


	typedef enum {
		CURL_TIMECOND_NONE,

		CURL_TIMECOND_IFMODSINCE,