--curl.h from libcurl 7.46.0
local ffi = require'ffi'
if ffi.abi'win' then
if ffi.abi'64bit' then
ffi.cdef'typedef uint64_t UINT_PTR;'
else
ffi.cdef'typedef uint32_t UINT_PTR;'
end
ffi.cdef[[
typedef UINT_PTR SOCKET;
typedef SOCKET curl_socket_t;
]]
else
ffi.cdef'typedef int curl_socket_t;'
end
ffi.cdef[[
// curl.h --------------------------------------------------------------------
typedef struct CURL CURL;
typedef void curl_fd_set;
typedef long long curl_off_t;
typedef long time_t;
typedef enum {
CURLOPT_WRITEDATA = 10000 + 1,
CURLOPT_URL = 10000 + 2,
CURLOPT_PORT = 0 + 3,
CURLOPT_PROXY = 10000 + 4,
CURLOPT_USERPWD = 10000 + 5,
CURLOPT_PROXYUSERPWD = 10000 + 6,
CURLOPT_RANGE = 10000 + 7,
CURLOPT_READDATA = 10000 + 9,
CURLOPT_ERRORBUFFER = 10000 + 10,
CURLOPT_WRITEFUNCTION = 20000 + 11,
CURLOPT_READFUNCTION = 20000 + 12,
CURLOPT_TIMEOUT = 0 + 13,
// CURLOPT_INFILESIZE = 0 + 14,
CURLOPT_POSTFIELDS = 10000 + 15,
CURLOPT_REFERER = 10000 + 16,
CURLOPT_FTPPORT = 10000 + 17,
CURLOPT_USERAGENT = 10000 + 18,
CURLOPT_LOW_SPEED_LIMIT = 0 + 19,
CURLOPT_LOW_SPEED_TIME = 0 + 20,
// CURLOPT_RESUME_FROM = 0 + 21,
CURLOPT_COOKIE = 10000 + 22,
CURLOPT_HTTPHEADER = 10000 + 23,
CURLOPT_HTTPPOST = 10000 + 24,
CURLOPT_SSLCERT = 10000 + 25,
CURLOPT_KEYPASSWD = 10000 + 26,
CURLOPT_CRLF = 0 + 27,
CURLOPT_QUOTE = 10000 + 28,
CURLOPT_HEADERDATA = 10000 + 29,
CURLOPT_COOKIEFILE = 10000 + 31,
CURLOPT_SSLVERSION = 0 + 32,
CURLOPT_TIMECONDITION = 0 + 33,
CURLOPT_TIMEVALUE = 0 + 34,
CURLOPT_CUSTOMREQUEST = 10000 + 36,
CURLOPT_STDERR = 10000 + 37,
CURLOPT_POSTQUOTE = 10000 + 39,
CURLOPT_OBSOLETE40 = 10000 + 40,
CURLOPT_VERBOSE = 0 + 41,
CURLOPT_HEADER = 0 + 42,
CURLOPT_NOPROGRESS = 0 + 43,
CURLOPT_NOBODY = 0 + 44,
CURLOPT_FAILONERROR = 0 + 45,
CURLOPT_UPLOAD = 0 + 46,
CURLOPT_POST = 0 + 47,
CURLOPT_DIRLISTONLY = 0 + 48,
CURLOPT_APPEND = 0 + 50,
CURLOPT_NETRC = 0 + 51,
CURLOPT_FOLLOWLOCATION = 0 + 52,
CURLOPT_TRANSFERTEXT = 0 + 53,
CURLOPT_PUT = 0 + 54,
CURLOPT_PROGRESSFUNCTION = 20000 + 56,
CURLOPT_PROGRESSDATA = 10000 + 57,
CURLOPT_XFERINFODATA = CURLOPT_PROGRESSDATA,
CURLOPT_AUTOREFERER = 0 + 58,
CURLOPT_PROXYPORT = 0 + 59,
// CURLOPT_POSTFIELDSIZE = 0 + 60,
CURLOPT_HTTPPROXYTUNNEL = 0 + 61,
CURLOPT_INTERFACE = 10000 + 62,
CURLOPT_KRBLEVEL = 10000 + 63,
CURLOPT_SSL_VERIFYPEER = 0 + 64,
CURLOPT_CAINFO = 10000 + 65,
CURLOPT_MAXREDIRS = 0 + 68,
CURLOPT_FILETIME = 0 + 69,
CURLOPT_TELNETOPTIONS = 10000 + 70,
CURLOPT_MAXCONNECTS = 0 + 71,
CURLOPT_OBSOLETE72 = 0 + 72,
CURLOPT_FRESH_CONNECT = 0 + 74,
CURLOPT_FORBID_REUSE = 0 + 75,
CURLOPT_RANDOM_FILE = 10000 + 76,
CURLOPT_EGDSOCKET = 10000 + 77,
CURLOPT_CONNECTTIMEOUT = 0 + 78,
CURLOPT_HEADERFUNCTION = 20000 + 79,
CURLOPT_HTTPGET = 0 + 80,
CURLOPT_SSL_VERIFYHOST = 0 + 81,
CURLOPT_COOKIEJAR = 10000 + 82,
CURLOPT_SSL_CIPHER_LIST = 10000 + 83,
CURLOPT_HTTP_VERSION = 0 + 84,
CURLOPT_FTP_USE_EPSV = 0 + 85,
CURLOPT_SSLCERTTYPE = 10000 + 86,
CURLOPT_SSLKEY = 10000 + 87,
CURLOPT_SSLKEYTYPE = 10000 + 88,
CURLOPT_SSLENGINE = 10000 + 89,
CURLOPT_SSLENGINE_DEFAULT = 0 + 90,
CURLOPT_DNS_USE_GLOBAL_CACHE = 0 + 91,
CURLOPT_DNS_CACHE_TIMEOUT = 0 + 92,
CURLOPT_PREQUOTE = 10000 + 93,
CURLOPT_DEBUGFUNCTION = 20000 + 94,
CURLOPT_DEBUGDATA = 10000 + 95,
CURLOPT_COOKIESESSION = 0 + 96,
CURLOPT_CAPATH = 10000 + 97,
CURLOPT_BUFFERSIZE = 0 + 98,
CURLOPT_NOSIGNAL = 0 + 99,
CURLOPT_SHARE = 10000 + 100,
CURLOPT_PROXYTYPE = 0 + 101,
CURLOPT_ACCEPT_ENCODING = 10000 + 102,
CURLOPT_PRIVATE = 10000 + 103,
CURLOPT_HTTP200ALIASES = 10000 + 104,
CURLOPT_UNRESTRICTED_AUTH = 0 + 105,
CURLOPT_FTP_USE_EPRT = 0 + 106,
CURLOPT_HTTPAUTH = 0 + 107,
CURLOPT_SSL_CTX_FUNCTION = 20000 + 108,
CURLOPT_SSL_CTX_DATA = 10000 + 109,
CURLOPT_FTP_CREATE_MISSING_DIRS = 0 + 110,
CURLOPT_PROXYAUTH = 0 + 111,
CURLOPT_FTP_RESPONSE_TIMEOUT = 0 + 112,
CURLOPT_SERVER_RESPONSE_TIMEOUT = CURLOPT_FTP_RESPONSE_TIMEOUT,
CURLOPT_IPRESOLVE = 0 + 113,
// CURLOPT_MAXFILESIZE = 0 + 114,
CURLOPT_INFILESIZE = 30000 + 115, // was *_LARGE
CURLOPT_RESUME_FROM = 30000 + 116, // was *_LARGE
CURLOPT_MAXFILESIZE = 30000 + 117, // was *_LARGE
CURLOPT_NETRC_FILE = 10000 + 118,
CURLOPT_USE_SSL = 0 + 119,
CURLOPT_POSTFIELDSIZE = 30000 + 120, // was *_LARGE
CURLOPT_TCP_NODELAY = 0 + 121,
CURLOPT_FTPSSLAUTH = 0 + 129,
CURLOPT_IOCTLFUNCTION = 20000 + 130,
CURLOPT_IOCTLDATA = 10000 + 131,
CURLOPT_FTP_ACCOUNT = 10000 + 134,
CURLOPT_COOKIELIST = 10000 + 135,
CURLOPT_IGNORE_CONTENT_LENGTH = 0 + 136,
CURLOPT_FTP_SKIP_PASV_IP = 0 + 137,
CURLOPT_FTP_FILEMETHOD = 0 + 138,
CURLOPT_LOCALPORT = 0 + 139,
CURLOPT_LOCALPORTRANGE = 0 + 140,
CURLOPT_CONNECT_ONLY = 0 + 141,
CURLOPT_CONV_FROM_NETWORK_FUNCTION = 20000 + 142,
CURLOPT_CONV_TO_NETWORK_FUNCTION = 20000 + 143,
CURLOPT_CONV_FROM_UTF8_FUNCTION = 20000 + 144,
CURLOPT_MAX_SEND_SPEED = 30000 + 145, // was *_LARGE
CURLOPT_MAX_RECV_SPEED = 30000 + 146, // was *_LARGE
CURLOPT_FTP_ALTERNATIVE_TO_USER = 10000 + 147,
CURLOPT_SOCKOPTFUNCTION = 20000 + 148,
CURLOPT_SOCKOPTDATA = 10000 + 149,
CURLOPT_SSL_SESSIONID_CACHE = 0 + 150,
CURLOPT_SSH_AUTH_TYPES = 0 + 151,
CURLOPT_SSH_PUBLIC_KEYFILE = 10000 + 152,
CURLOPT_SSH_PRIVATE_KEYFILE = 10000 + 153,
CURLOPT_FTP_SSL_CCC = 0 + 154,
CURLOPT_TIMEOUT_MS = 0 + 155,
CURLOPT_CONNECTTIMEOUT_MS = 0 + 156,
CURLOPT_HTTP_TRANSFER_DECODING = 0 + 157,
CURLOPT_HTTP_CONTENT_DECODING = 0 + 158,
CURLOPT_NEW_FILE_PERMS = 0 + 159,
CURLOPT_NEW_DIRECTORY_PERMS = 0 + 160,
CURLOPT_POSTREDIR = 0 + 161,
CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 = 10000 + 162,
CURLOPT_OPENSOCKETFUNCTION = 20000 + 163,
CURLOPT_OPENSOCKETDATA = 10000 + 164,
CURLOPT_COPYPOSTFIELDS = 10000 + 165,
CURLOPT_PROXY_TRANSFER_MODE = 0 + 166,
CURLOPT_SEEKFUNCTION = 20000 + 167,
CURLOPT_SEEKDATA = 10000 + 168,
CURLOPT_CRLFILE = 10000 + 169,
CURLOPT_ISSUERCERT = 10000 + 170,
CURLOPT_ADDRESS_SCOPE = 0 + 171,
CURLOPT_CERTINFO = 0 + 172,
CURLOPT_USERNAME = 10000 + 173,
CURLOPT_PASSWORD = 10000 + 174,
CURLOPT_PROXYUSERNAME = 10000 + 175,
CURLOPT_PROXYPASSWORD = 10000 + 176,
CURLOPT_NOPROXY = 10000 + 177,
CURLOPT_TFTP_BLKSIZE = 0 + 178,
CURLOPT_SOCKS5_GSSAPI_SERVICE = 10000 + 179,
CURLOPT_SOCKS5_GSSAPI_NEC = 0 + 180,
CURLOPT_PROTOCOLS = 0 + 181,
CURLOPT_REDIR_PROTOCOLS = 0 + 182,
CURLOPT_SSH_KNOWNHOSTS = 10000 + 183,
CURLOPT_SSH_KEYFUNCTION = 20000 + 184,
CURLOPT_SSH_KEYDATA = 10000 + 185,
CURLOPT_MAIL_FROM = 10000 + 186,
CURLOPT_MAIL_RCPT = 10000 + 187,
CURLOPT_FTP_USE_PRET = 0 + 188,
CURLOPT_RTSP_REQUEST = 0 + 189,
CURLOPT_RTSP_SESSION_ID = 10000 + 190,
CURLOPT_RTSP_STREAM_URI = 10000 + 191,
CURLOPT_RTSP_TRANSPORT = 10000 + 192,
CURLOPT_RTSP_CLIENT_CSEQ = 0 + 193,
CURLOPT_RTSP_SERVER_CSEQ = 0 + 194,
CURLOPT_INTERLEAVEDATA = 10000 + 195,
CURLOPT_INTERLEAVEFUNCTION = 20000 + 196,
CURLOPT_WILDCARDMATCH = 0 + 197,
CURLOPT_CHUNK_BGN_FUNCTION = 20000 + 198,
CURLOPT_CHUNK_END_FUNCTION = 20000 + 199,
CURLOPT_FNMATCH_FUNCTION = 20000 + 200,
CURLOPT_CHUNK_DATA = 10000 + 201,
CURLOPT_FNMATCH_DATA = 10000 + 202,
CURLOPT_RESOLVE = 10000 + 203,
CURLOPT_TLSAUTH_USERNAME = 10000 + 204,
CURLOPT_TLSAUTH_PASSWORD = 10000 + 205,
CURLOPT_TLSAUTH_TYPE = 10000 + 206,
CURLOPT_TRANSFER_ENCODING = 0 + 207,
CURLOPT_CLOSESOCKETFUNCTION = 20000 + 208,
CURLOPT_CLOSESOCKETDATA = 10000 + 209,
CURLOPT_GSSAPI_DELEGATION = 0 + 210,
CURLOPT_DNS_SERVERS = 10000 + 211,
CURLOPT_ACCEPTTIMEOUT_MS = 0 + 212,
CURLOPT_TCP_KEEPALIVE = 0 + 213,
CURLOPT_TCP_KEEPIDLE = 0 + 214,
CURLOPT_TCP_KEEPINTVL = 0 + 215,
CURLOPT_SSL_OPTIONS = 0 + 216,
CURLOPT_MAIL_AUTH = 10000 + 217,
CURLOPT_SASL_IR = 0 + 218,
CURLOPT_XFERINFOFUNCTION = 20000 + 219,
CURLOPT_XOAUTH2_BEARER = 10000 + 220,
CURLOPT_DNS_INTERFACE = 10000 + 221,
CURLOPT_DNS_LOCAL_IP4 = 10000 + 222,
CURLOPT_DNS_LOCAL_IP6 = 10000 + 223,
CURLOPT_LOGIN_OPTIONS = 10000 + 224,
CURLOPT_SSL_ENABLE_NPN = 0 + 225,
CURLOPT_SSL_ENABLE_ALPN = 0 + 226,
CURLOPT_EXPECT_100_TIMEOUT_MS = 0 + 227,
CURLOPT_PROXYHEADER = 10000 + 228,
CURLOPT_HEADEROPT = 0 + 229,
CURLOPT_PINNEDPUBLICKEY = 10000 + 230,
CURLOPT_UNIX_SOCKET_PATH = 10000 + 231,
CURLOPT_SSL_VERIFYSTATUS = 0 + 232,
CURLOPT_SSL_FALSESTART = 0 + 233,
CURLOPT_PATH_AS_IS = 0 + 234,
CURLOPT_PROXY_SERVICE_NAME = 10000 + 235,
CURLOPT_SERVICE_NAME = 10000 + 236,
CURLOPT_PIPEWAIT = 0 + 237,
CURLOPT_DEFAULT_PROTOCOL = 10000 + 238,
CURLOPT_LASTENTRY
} CURLoption;
enum {
CURLOPT_POST301 = CURLOPT_POSTREDIR,
CURLOPT_SSLKEYPASSWD = CURLOPT_KEYPASSWD,
CURLOPT_FTPAPPEND = CURLOPT_APPEND,
CURLOPT_FTPLISTONLY = CURLOPT_DIRLISTONLY,
CURLOPT_FTP_SSL = CURLOPT_USE_SSL,
CURLOPT_SSLCERTPASSWD = CURLOPT_KEYPASSWD,
CURLOPT_KRB4LEVEL = CURLOPT_KRBLEVEL,
CURL_IPRESOLVE_WHATEVER = 0,
CURL_IPRESOLVE_V4 = 1,
CURL_IPRESOLVE_V6 = 2,
CURLOPT_RTSPHEADER = CURLOPT_HTTPHEADER,
};
enum {
CURL_HTTPPOST_FILENAME = (1<<0),
CURL_HTTPPOST_READFILE = (1<<1),
CURL_HTTPPOST_PTRNAME = (1<<2),
CURL_HTTPPOST_PTRCONTENTS = (1<<3),
CURL_HTTPPOST_BUFFER = (1<<4),
CURL_HTTPPOST_PTRBUFFER = (1<<5),
CURL_HTTPPOST_CALLBACK = (1<<6),
CURL_HTTPPOST_LARGE = (1<<7),
};
struct curl_httppost {
struct curl_httppost *next;
char *name;
long namelength;
char *contents;
long contentslength;
char *buffer;
long bufferlength;
char *contenttype;
struct curl_slist* contentheader;
struct curl_httppost *more;
long flags;
char *showfilename;
void *userp;
curl_off_t contentlen;
};
typedef int (*curl_progress_callback)(void *clientp,
double dltotal,
double dlnow,
double ultotal,
double ulnow);
typedef int (*curl_xferinfo_callback)(void *clientp,
curl_off_t dltotal,
curl_off_t dlnow,
curl_off_t ultotal,
curl_off_t ulnow);
enum {
CURL_MAX_WRITE_SIZE = 16384,
CURL_MAX_HTTP_HEADER = (100*1024),
CURL_WRITEFUNC_PAUSE = 0x10000001,
};
typedef size_t (*curl_write_callback)(char *buffer,
size_t size,
size_t nitems,
void *outstream);
typedef enum {
CURLFILETYPE_FILE = 0,
CURLFILETYPE_DIRECTORY,
CURLFILETYPE_SYMLINK,
CURLFILETYPE_DEVICE_BLOCK,
CURLFILETYPE_DEVICE_CHAR,
CURLFILETYPE_NAMEDPIPE,
CURLFILETYPE_SOCKET,
CURLFILETYPE_DOOR,
CURLFILETYPE_UNKNOWN
} curlfiletype;
enum {
CURLFINFOFLAG_KNOWN_FILENAME = (1<<0),
CURLFINFOFLAG_KNOWN_FILETYPE = (1<<1),
CURLFINFOFLAG_KNOWN_TIME = (1<<2),
CURLFINFOFLAG_KNOWN_PERM = (1<<3),
CURLFINFOFLAG_KNOWN_UID = (1<<4),
CURLFINFOFLAG_KNOWN_GID = (1<<5),
CURLFINFOFLAG_KNOWN_SIZE = (1<<6),
CURLFINFOFLAG_KNOWN_HLINKCOUNT = (1<<7),
};
struct curl_fileinfo {
char *filename;
curlfiletype filetype;
time_t time;
unsigned int perm;
int uid;
int gid;
curl_off_t size;
long int hardlinks;
struct {
char *time;
char *perm;
char *user;
char *group;
char *target;
} strings;
unsigned int flags;
char * b_data;
size_t b_size;
size_t b_used;
};
enum {
CURL_CHUNK_BGN_FUNC_OK = 0,
CURL_CHUNK_BGN_FUNC_FAIL = 1,
CURL_CHUNK_BGN_FUNC_SKIP = 2,
};
typedef long (*curl_chunk_bgn_callback)(const void *transfer_info,
void *ptr,
int remains);
enum {
CURL_CHUNK_END_FUNC_OK = 0,
CURL_CHUNK_END_FUNC_FAIL = 1,
};
typedef long (*curl_chunk_end_callback)(void *ptr);
enum {
CURL_FNMATCHFUNC_MATCH = 0,
CURL_FNMATCHFUNC_NOMATCH = 1,
CURL_FNMATCHFUNC_FAIL = 2,
};
typedef int (*curl_fnmatch_callback)(void *ptr,
const char *pattern,
const char *string);
enum {
CURL_SEEKFUNC_OK = 0,
CURL_SEEKFUNC_FAIL = 1,
CURL_SEEKFUNC_CANTSEEK = 2,
};
typedef int (*curl_seek_callback)(void *instream,
curl_off_t offset,
int origin);
enum {
CURL_READFUNC_ABORT = 0x10000000,
CURL_READFUNC_PAUSE = 0x10000001,
};
typedef size_t (*curl_read_callback)(char *buffer,
size_t size,
size_t nitems,
void *instream);
typedef enum {
CURLSOCKTYPE_IPCXN,
CURLSOCKTYPE_ACCEPT,
CURLSOCKTYPE_LAST
} curlsocktype;
enum {
CURL_SOCKOPT_OK = 0,
CURL_SOCKOPT_ERROR = 1,
CURL_SOCKOPT_ALREADY_CONNECTED = 2,
};
typedef int (*curl_sockopt_callback)(void *clientp,
curl_socket_t curlfd,
curlsocktype purpose);
struct curl_sockaddr {
int family;
int socktype;
int protocol;
unsigned int addrlen;
};
typedef curl_socket_t
(*curl_opensocket_callback)(void *clientp,
curlsocktype purpose,
struct curl_sockaddr *address);
typedef int
(*curl_closesocket_callback)(void *clientp, curl_socket_t item);
typedef enum {
CURLIOE_OK,
CURLIOE_UNKNOWNCMD,
CURLIOE_FAILRESTART,
CURLIOE_LAST
} curlioerr;
typedef enum {
CURLIOCMD_NOP,
CURLIOCMD_RESTARTREAD,
CURLIOCMD_LAST
} curliocmd;
typedef curlioerr (*curl_ioctl_callback)(CURL *handle,
int cmd,
void *clientp);
typedef void *(*curl_malloc_callback)(size_t size);
typedef void (*curl_free_callback)(void *ptr);
typedef void *(*curl_realloc_callback)(void *ptr, size_t size);
typedef char *(*curl_strdup_callback)(const char *str);
typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size);
typedef enum {
CURLINFO_TEXT = 0,
CURLINFO_HEADER_IN,
CURLINFO_HEADER_OUT,
CURLINFO_DATA_IN,
CURLINFO_DATA_OUT,
CURLINFO_SSL_DATA_IN,
CURLINFO_SSL_DATA_OUT,
CURLINFO_END
} curl_infotype;
typedef int (*curl_debug_callback)
(CURL *handle,
curl_infotype type,
char *data,
size_t size,
void *userptr);
typedef enum {
CURLE_OK = 0,
CURLE_UNSUPPORTED_PROTOCOL,
CURLE_FAILED_INIT,
CURLE_URL_MALFORMAT,
CURLE_NOT_BUILT_IN,
CURLE_COULDNT_RESOLVE_PROXY,
CURLE_COULDNT_RESOLVE_HOST,
CURLE_COULDNT_CONNECT,
CURLE_FTP_WEIRD_SERVER_REPLY,
CURLE_REMOTE_ACCESS_DENIED,
CURLE_FTP_ACCEPT_FAILED,
CURLE_FTP_WEIRD_PASS_REPLY,
CURLE_FTP_ACCEPT_TIMEOUT,
CURLE_FTP_WEIRD_PASV_REPLY,
CURLE_FTP_WEIRD_227_FORMAT,
CURLE_FTP_CANT_GET_HOST,
CURLE_HTTP2,
CURLE_FTP_COULDNT_SET_TYPE,
CURLE_PARTIAL_FILE,
CURLE_FTP_COULDNT_RETR_FILE,
CURLE_OBSOLETE20,
CURLE_QUOTE_ERROR,
CURLE_HTTP_RETURNED_ERROR,
CURLE_WRITE_ERROR,
CURLE_OBSOLETE24,
CURLE_UPLOAD_FAILED,
CURLE_READ_ERROR,
CURLE_OUT_OF_MEMORY,
CURLE_OPERATION_TIMEDOUT,
CURLE_OBSOLETE29,
CURLE_FTP_PORT_FAILED,
CURLE_FTP_COULDNT_USE_REST,
CURLE_OBSOLETE32,
CURLE_RANGE_ERROR,
CURLE_HTTP_POST_ERROR,
CURLE_SSL_CONNECT_ERROR,
CURLE_BAD_DOWNLOAD_RESUME,
CURLE_FILE_COULDNT_READ_FILE,
CURLE_LDAP_CANNOT_BIND,
CURLE_LDAP_SEARCH_FAILED,
CURLE_OBSOLETE40,
CURLE_FUNCTION_NOT_FOUND,
CURLE_ABORTED_BY_CALLBACK,
CURLE_BAD_FUNCTION_ARGUMENT,
CURLE_OBSOLETE44,
CURLE_INTERFACE_FAILED,
CURLE_OBSOLETE46,
CURLE_TOO_MANY_REDIRECTS ,
CURLE_UNKNOWN_OPTION,
CURLE_TELNET_OPTION_SYNTAX ,
CURLE_OBSOLETE50,
CURLE_PEER_FAILED_VERIFICATION,
CURLE_GOT_NOTHING,
CURLE_SSL_ENGINE_NOTFOUND,
CURLE_SSL_ENGINE_SETFAILED,
CURLE_SEND_ERROR,
CURLE_RECV_ERROR,
CURLE_OBSOLETE57,
CURLE_SSL_CERTPROBLEM,
CURLE_SSL_CIPHER,
CURLE_SSL_CACERT,
CURLE_BAD_CONTENT_ENCODING,
CURLE_LDAP_INVALID_URL,
CURLE_FILESIZE_EXCEEDED,
CURLE_USE_SSL_FAILED,
CURLE_SEND_FAIL_REWIND,
CURLE_SSL_ENGINE_INITFAILED,
CURLE_LOGIN_DENIED,
CURLE_TFTP_NOTFOUND,
CURLE_TFTP_PERM,
CURLE_REMOTE_DISK_FULL,
CURLE_TFTP_ILLEGAL,
CURLE_TFTP_UNKNOWNID,
CURLE_REMOTE_FILE_EXISTS,
CURLE_TFTP_NOSUCHUSER,
CURLE_CONV_FAILED,
CURLE_CONV_REQD,
CURLE_SSL_CACERT_BADFILE,
CURLE_REMOTE_FILE_NOT_FOUND,
CURLE_SSH,
CURLE_SSL_SHUTDOWN_FAILED,
CURLE_AGAIN,
CURLE_SSL_CRL_BADFILE,
CURLE_SSL_ISSUER_ERROR,
CURLE_FTP_PRET_FAILED,
CURLE_RTSP_CSEQ_ERROR,
CURLE_RTSP_SESSION_ERROR,
CURLE_FTP_BAD_FILE_LIST,
CURLE_CHUNK_FAILED,
CURLE_NO_CONNECTION_AVAILABLE,
CURLE_SSL_PINNEDPUBKEYNOTMATCH,
CURLE_SSL_INVALIDCERTSTATUS,
CURL_LAST
} CURLcode;
enum {
CURLE_OBSOLETE16 = CURLE_HTTP2,
CURLE_OBSOLETE10 = CURLE_FTP_ACCEPT_FAILED,
CURLE_OBSOLETE12 = CURLE_FTP_ACCEPT_TIMEOUT,
CURLOPT_ENCODING = CURLOPT_ACCEPT_ENCODING,
CURLE_UNKNOWN_TELNET_OPTION = CURLE_UNKNOWN_OPTION,
CURLE_SSL_PEER_CERTIFICATE = CURLE_PEER_FAILED_VERIFICATION,
CURLE_OBSOLETE = CURLE_OBSOLETE50,
CURLE_BAD_PASSWORD_ENTERED = CURLE_OBSOLETE46,
CURLE_BAD_CALLING_ORDER = CURLE_OBSOLETE44,
CURLE_FTP_USER_PASSWORD_INCORRECT = CURLE_OBSOLETE10,
CURLE_FTP_CANT_RECONNECT = CURLE_OBSOLETE16,
CURLE_FTP_COULDNT_GET_SIZE = CURLE_OBSOLETE32,
CURLE_FTP_COULDNT_SET_ASCII = CURLE_OBSOLETE29,
CURLE_FTP_WEIRD_USER_REPLY = CURLE_OBSOLETE12,
CURLE_FTP_WRITE_ERROR = CURLE_OBSOLETE20,
CURLE_LIBRARY_NOT_FOUND = CURLE_OBSOLETE40,
CURLE_MALFORMAT_USER = CURLE_OBSOLETE24,
CURLE_SHARE_IN_USE = CURLE_OBSOLETE57,
CURLE_URL_MALFORMAT_USER = CURLE_NOT_BUILT_IN,
CURLE_FTP_ACCESS_DENIED = CURLE_REMOTE_ACCESS_DENIED,
CURLE_FTP_COULDNT_SET_BINARY = CURLE_FTP_COULDNT_SET_TYPE,
CURLE_FTP_QUOTE_ERROR = CURLE_QUOTE_ERROR,
CURLE_TFTP_DISKFULL = CURLE_REMOTE_DISK_FULL,
CURLE_TFTP_EXISTS = CURLE_REMOTE_FILE_EXISTS,
CURLE_HTTP_RANGE_ERROR = CURLE_RANGE_ERROR,
CURLE_FTP_SSL_FAILED = CURLE_USE_SSL_FAILED,
CURLE_OPERATION_TIMEOUTED = CURLE_OPERATION_TIMEDOUT,
CURLE_HTTP_NOT_FOUND = CURLE_HTTP_RETURNED_ERROR,
CURLE_HTTP_PORT_FAILED = CURLE_INTERFACE_FAILED,
CURLE_FTP_COULDNT_STOR_FILE = CURLE_UPLOAD_FAILED,
CURLE_FTP_PARTIAL_FILE = CURLE_PARTIAL_FILE,
CURLE_FTP_BAD_DOWNLOAD_RESUME = CURLE_BAD_DOWNLOAD_RESUME,
CURLE_ALREADY_COMPLETE = 99999,
CURLOPT_FILE = CURLOPT_WRITEDATA,
CURLOPT_INFILE = CURLOPT_READDATA,
CURLOPT_WRITEHEADER = CURLOPT_HEADERDATA,
CURLOPT_WRITEINFO = CURLOPT_OBSOLETE40,
CURLOPT_CLOSEPOLICY = CURLOPT_OBSOLETE72,
};
typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length);
typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl,
void *ssl_ctx,
void *userptr);
typedef enum {
CURLPROXY_HTTP = 0,
CURLPROXY_HTTP_1_0 = 1,
CURLPROXY_SOCKS4 = 4,
CURLPROXY_SOCKS5 = 5,
CURLPROXY_SOCKS4A = 6,
CURLPROXY_SOCKS5_HOSTNAME = 7
} curl_proxytype;
enum {
CURLAUTH_NONE = ((unsigned long)0),
CURLAUTH_BASIC = (((unsigned long)1)<<0),
CURLAUTH_DIGEST = (((unsigned long)1)<<1),
CURLAUTH_NEGOTIATE = (((unsigned long)1)<<2),
CURLAUTH_GSSNEGOTIATE = CURLAUTH_NEGOTIATE,
CURLAUTH_NTLM = (((unsigned long)1)<<3),
CURLAUTH_DIGEST_IE = (((unsigned long)1)<<4),
CURLAUTH_NTLM_WB = (((unsigned long)1)<<5),
CURLAUTH_ONLY = (((unsigned long)1)<<31),
CURLAUTH_ANY = (~CURLAUTH_DIGEST_IE),
CURLAUTH_ANYSAFE = (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)),
};
enum {
CURLSSH_AUTH_ANY = ~0,
CURLSSH_AUTH_NONE = 0,
CURLSSH_AUTH_PUBLICKEY = (1<<0),
CURLSSH_AUTH_PASSWORD = (1<<1),
CURLSSH_AUTH_HOST = (1<<2),
CURLSSH_AUTH_KEYBOARD = (1<<3),
CURLSSH_AUTH_AGENT = (1<<4),
CURLSSH_AUTH_DEFAULT = CURLSSH_AUTH_ANY,
};
enum {
CURLGSSAPI_DELEGATION_NONE = 0,
CURLGSSAPI_DELEGATION_POLICY_FLAG = (1<<0),
CURLGSSAPI_DELEGATION_FLAG = (1<<1),
CURL_ERROR_SIZE = 256,
};
enum curl_khtype {
CURLKHTYPE_UNKNOWN,
CURLKHTYPE_RSA1,
CURLKHTYPE_RSA,
CURLKHTYPE_DSS
};
struct curl_khkey {
const char *key;
size_t len;
enum curl_khtype keytype;
};
enum curl_khstat {
CURLKHSTAT_FINE_ADD_TO_FILE,
CURLKHSTAT_FINE,
CURLKHSTAT_REJECT,
CURLKHSTAT_DEFER,
CURLKHSTAT_LAST
};
enum curl_khmatch {
CURLKHMATCH_OK,
CURLKHMATCH_MISMATCH,
CURLKHMATCH_MISSING,
CURLKHMATCH_LAST
};
typedef int
(*curl_sshkeycallback) (CURL *easy,
const struct curl_khkey *knownkey,
const struct curl_khkey *foundkey,
enum curl_khmatch,
void *clientp);
typedef enum {
CURLUSESSL_NONE,
CURLUSESSL_TRY,
CURLUSESSL_CONTROL,
CURLUSESSL_ALL,
CURLUSESSL_LAST
} curl_usessl;
enum {
CURLSSLOPT_ALLOW_BEAST = (1<<0),
CURLSSLOPT_NO_REVOKE = (1<<1),
CURLFTPSSL_NONE = CURLUSESSL_NONE,
CURLFTPSSL_TRY = CURLUSESSL_TRY,
CURLFTPSSL_CONTROL = CURLUSESSL_CONTROL,
CURLFTPSSL_ALL = CURLUSESSL_ALL,
CURLFTPSSL_LAST = CURLUSESSL_LAST,
};
typedef enum {
CURLFTPSSL_CCC_NONE,
CURLFTPSSL_CCC_PASSIVE,
CURLFTPSSL_CCC_ACTIVE,
CURLFTPSSL_CCC_LAST
} curl_ftpccc;
typedef enum {
CURLFTPAUTH_DEFAULT,
CURLFTPAUTH_SSL,
CURLFTPAUTH_TLS,
CURLFTPAUTH_LAST
} curl_ftpauth;
typedef enum {
CURLFTP_CREATE_DIR_NONE,
CURLFTP_CREATE_DIR,
CURLFTP_CREATE_DIR_RETRY,
CURLFTP_CREATE_DIR_LAST
} curl_ftpcreatedir;
typedef enum {
CURLFTPMETHOD_DEFAULT,
CURLFTPMETHOD_MULTICWD,
CURLFTPMETHOD_NOCWD,
CURLFTPMETHOD_SINGLECWD,
CURLFTPMETHOD_LAST
} curl_ftpmethod;
enum {
CURLHEADER_UNIFIED = 0,
CURLHEADER_SEPARATE = (1<<0),
};
enum {
CURLPROTO_HTTP = (1<<0),
CURLPROTO_HTTPS = (1<<1),
CURLPROTO_FTP = (1<<2),
CURLPROTO_FTPS = (1<<3),
CURLPROTO_SCP = (1<<4),
CURLPROTO_SFTP = (1<<5),
CURLPROTO_TELNET = (1<<6),
CURLPROTO_LDAP = (1<<7),
CURLPROTO_LDAPS = (1<<8),
CURLPROTO_DICT = (1<<9),
CURLPROTO_FILE = (1<<10),
CURLPROTO_TFTP = (1<<11),
CURLPROTO_IMAP = (1<<12),
CURLPROTO_IMAPS = (1<<13),
CURLPROTO_POP3 = (1<<14),
CURLPROTO_POP3S = (1<<15),
CURLPROTO_SMTP = (1<<16),
CURLPROTO_SMTPS = (1<<17),
CURLPROTO_RTSP = (1<<18),
CURLPROTO_RTMP = (1<<19),
CURLPROTO_RTMPT = (1<<20),
CURLPROTO_RTMPE = (1<<21),
CURLPROTO_RTMPTE = (1<<22),
CURLPROTO_RTMPS = (1<<23),
CURLPROTO_RTMPTS = (1<<24),
CURLPROTO_GOPHER = (1<<25),
CURLPROTO_SMB = (1<<26),
CURLPROTO_SMBS = (1<<27),
CURLPROTO_ALL = (~0),
CURLOPTTYPE_LONG = 0,
CURLOPTTYPE_OBJECTPOINT = 10000,
CURLOPTTYPE_STRINGPOINT = 10000,
CURLOPTTYPE_FUNCTIONPOINT = 20000,
CURLOPTTYPE_OFF_T = 30000,
};
enum {
CURL_HTTP_VERSION_NONE,
CURL_HTTP_VERSION_1_0,
CURL_HTTP_VERSION_1_1,
CURL_HTTP_VERSION_2_0,
CURL_HTTP_VERSION_LAST
};
enum {
CURL_RTSPREQ_NONE,
CURL_RTSPREQ_OPTIONS,
CURL_RTSPREQ_DESCRIBE,
CURL_RTSPREQ_ANNOUNCE,
CURL_RTSPREQ_SETUP,
CURL_RTSPREQ_PLAY,
CURL_RTSPREQ_PAUSE,
CURL_RTSPREQ_TEARDOWN,
CURL_RTSPREQ_GET_PARAMETER,
CURL_RTSPREQ_SET_PARAMETER,
CURL_RTSPREQ_RECORD,
CURL_RTSPREQ_RECEIVE,
CURL_RTSPREQ_LAST
};
enum CURL_NETRC_OPTION {
CURL_NETRC_IGNORED,
CURL_NETRC_OPTIONAL,
CURL_NETRC_REQUIRED,
CURL_NETRC_LAST
};
enum {
CURL_SSLVERSION_DEFAULT,
CURL_SSLVERSION_TLSv1,
CURL_SSLVERSION_SSLv2,
CURL_SSLVERSION_SSLv3,
CURL_SSLVERSION_TLSv1_0,
CURL_SSLVERSION_TLSv1_1,
CURL_SSLVERSION_TLSv1_2,
CURL_SSLVERSION_LAST
};
enum CURL_TLSAUTH {
CURL_TLSAUTH_NONE,
CURL_TLSAUTH_SRP,
CURL_TLSAUTH_LAST
};
enum {
CURL_REDIR_GET_ALL = 0,
CURL_REDIR_POST_301 = 1,
CURL_REDIR_POST_302 = 2,
CURL_REDIR_POST_303 = 4,
CURL_REDIR_POST_ALL = (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303),
};
typedef enum {
CURL_TIMECOND_NONE,
CURL_TIMECOND_IFMODSINCE,
CURL_TIMECOND_IFUNMODSINCE,
CURL_TIMECOND_LASTMOD,
CURL_TIMECOND_LAST
} curl_TimeCond;
int (curl_strequal)(const char *s1, const char *s2);
int (curl_strnequal)(const char *s1, const char *s2, size_t n);
typedef enum {
CURLFORM_NOTHING,
CURLFORM_COPYNAME,
CURLFORM_PTRNAME,
CURLFORM_NAMELENGTH,
CURLFORM_COPYCONTENTS,
CURLFORM_PTRCONTENTS,
CURLFORM_CONTENTSLENGTH,
CURLFORM_FILECONTENT,
CURLFORM_ARRAY,
CURLFORM_OBSOLETE,
CURLFORM_FILE,
CURLFORM_BUFFER,
CURLFORM_BUFFERPTR,
CURLFORM_BUFFERLENGTH,
CURLFORM_CONTENTTYPE,
CURLFORM_CONTENTHEADER,
CURLFORM_FILENAME,
CURLFORM_END,
CURLFORM_OBSOLETE2,
CURLFORM_STREAM,
CURLFORM_CONTENTLEN,
CURLFORM_LASTENTRY
} CURLformoption;
struct curl_forms {
CURLformoption option;
const char *value;
};
typedef enum {
CURL_FORMADD_OK,
CURL_FORMADD_MEMORY,
CURL_FORMADD_OPTION_TWICE,
CURL_FORMADD_NULL,
CURL_FORMADD_UNKNOWN_OPTION,
CURL_FORMADD_INCOMPLETE,
CURL_FORMADD_ILLEGAL_ARRAY,
CURL_FORMADD_DISABLED,
CURL_FORMADD_LAST
} CURLFORMcode;
CURLFORMcode curl_formadd(struct curl_httppost **httppost, struct curl_httppost **last_post, ...);
typedef size_t (*curl_formget_callback)(void *arg, const char *buf, size_t len);
int curl_formget(struct curl_httppost *form, void *arg, curl_formget_callback append);
void curl_formfree(struct curl_httppost *form);
char *curl_version(void);
char *curl_easy_escape(CURL *handle, const char *string, int length);
char *curl_escape(const char *string, int length);
char *curl_easy_unescape(CURL *handle, const char *string, int length, int *outlength);
char *curl_unescape(const char *string, int length);
void curl_free(void *p);
CURLcode curl_global_init(long flags);
CURLcode curl_global_init_mem(long flags,
curl_malloc_callback m,
curl_free_callback f,
curl_realloc_callback r,
curl_strdup_callback s,
curl_calloc_callback c);
void curl_global_cleanup(void);
struct curl_slist {
char *data;
struct curl_slist *next;
};
struct curl_slist *curl_slist_append(struct curl_slist *, const char *);
void curl_slist_free_all(struct curl_slist *);
time_t curl_getdate(const char *p, const time_t *unused);
struct curl_certinfo {
int num_of_certs;
struct curl_slist **certinfo;
};
typedef enum {
CURLSSLBACKEND_NONE = 0,
CURLSSLBACKEND_OPENSSL = 1,
CURLSSLBACKEND_GNUTLS = 2,
CURLSSLBACKEND_NSS = 3,
CURLSSLBACKEND_OBSOLETE4 = 4,
CURLSSLBACKEND_GSKIT = 5,
CURLSSLBACKEND_POLARSSL = 6,
CURLSSLBACKEND_CYASSL = 7,
CURLSSLBACKEND_SCHANNEL = 8,
CURLSSLBACKEND_DARWINSSL = 9,
CURLSSLBACKEND_AXTLS = 10,
CURLSSLBACKEND_MBEDTLS = 11
} curl_sslbackend;
struct curl_tlssessioninfo {
curl_sslbackend backend;
void *internals;
};
enum {
CURLINFO_STRING = 0x100000,
CURLINFO_LONG = 0x200000,
CURLINFO_DOUBLE = 0x300000,
CURLINFO_SLIST = 0x400000,
CURLINFO_SOCKET = 0x500000,
CURLINFO_MASK = 0x0fffff,
CURLINFO_TYPEMASK = 0xf00000,
};
typedef enum {
CURLINFO_NONE,
CURLINFO_EFFECTIVE_URL = 0x100000 + 1,
CURLINFO_RESPONSE_CODE = 0x200000 + 2,
CURLINFO_TOTAL_TIME = 0x300000 + 3,
CURLINFO_NAMELOOKUP_TIME = 0x300000 + 4,
CURLINFO_CONNECT_TIME = 0x300000 + 5,
CURLINFO_PRETRANSFER_TIME = 0x300000 + 6,
CURLINFO_SIZE_UPLOAD = 0x300000 + 7,
CURLINFO_SIZE_DOWNLOAD = 0x300000 + 8,
CURLINFO_SPEED_DOWNLOAD = 0x300000 + 9,
CURLINFO_SPEED_UPLOAD = 0x300000 + 10,
CURLINFO_HEADER_SIZE = 0x200000 + 11,
CURLINFO_REQUEST_SIZE = 0x200000 + 12,
CURLINFO_SSL_VERIFYRESULT = 0x200000 + 13,
CURLINFO_FILETIME = 0x200000 + 14,
CURLINFO_CONTENT_LENGTH_DOWNLOAD = 0x300000 + 15,
CURLINFO_CONTENT_LENGTH_UPLOAD = 0x300000 + 16,
CURLINFO_STARTTRANSFER_TIME = 0x300000 + 17,
CURLINFO_CONTENT_TYPE = 0x100000 + 18,
CURLINFO_REDIRECT_TIME = 0x300000 + 19,
CURLINFO_REDIRECT_COUNT = 0x200000 + 20,
CURLINFO_PRIVATE = 0x100000 + 21,
CURLINFO_HTTP_CONNECTCODE = 0x200000 + 22,
CURLINFO_HTTPAUTH_AVAIL = 0x200000 + 23,
CURLINFO_PROXYAUTH_AVAIL = 0x200000 + 24,
CURLINFO_OS_ERRNO = 0x200000 + 25,
CURLINFO_NUM_CONNECTS = 0x200000 + 26,
CURLINFO_SSL_ENGINES = 0x400000 + 27,
CURLINFO_COOKIELIST = 0x400000 + 28,
CURLINFO_LASTSOCKET = 0x200000 + 29,
CURLINFO_FTP_ENTRY_PATH = 0x100000 + 30,
CURLINFO_REDIRECT_URL = 0x100000 + 31,
CURLINFO_PRIMARY_IP = 0x100000 + 32,
CURLINFO_APPCONNECT_TIME = 0x300000 + 33,
CURLINFO_CERTINFO = 0x400000 + 34,
CURLINFO_CONDITION_UNMET = 0x200000 + 35,
CURLINFO_RTSP_SESSION_ID = 0x100000 + 36,
CURLINFO_RTSP_CLIENT_CSEQ = 0x200000 + 37,
CURLINFO_RTSP_SERVER_CSEQ = 0x200000 + 38,
CURLINFO_RTSP_CSEQ_RECV = 0x200000 + 39,
CURLINFO_PRIMARY_PORT = 0x200000 + 40,
CURLINFO_LOCAL_IP = 0x100000 + 41,
CURLINFO_LOCAL_PORT = 0x200000 + 42,
CURLINFO_TLS_SESSION = 0x400000 + 43,
CURLINFO_ACTIVESOCKET = 0x500000 + 44,
CURLINFO_LASTONE = 44
} CURLINFO;
enum {
CURLINFO_HTTP_CODE = CURLINFO_RESPONSE_CODE,
};
typedef enum {
CURLCLOSEPOLICY_NONE,
CURLCLOSEPOLICY_OLDEST,
CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
CURLCLOSEPOLICY_LEAST_TRAFFIC,
CURLCLOSEPOLICY_SLOWEST,
CURLCLOSEPOLICY_CALLBACK,
CURLCLOSEPOLICY_LAST
} curl_closepolicy;
enum {
CURL_GLOBAL_SSL = (1<<0),
CURL_GLOBAL_WIN32 = (1<<1),
CURL_GLOBAL_ALL = (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32),
CURL_GLOBAL_NOTHING = 0,
CURL_GLOBAL_DEFAULT = CURL_GLOBAL_ALL,
CURL_GLOBAL_ACK_EINTR = (1<<2),
};
typedef enum {
CURL_LOCK_DATA_NONE = 0,
CURL_LOCK_DATA_SHARE,
CURL_LOCK_DATA_COOKIE,
CURL_LOCK_DATA_DNS,
CURL_LOCK_DATA_SSL_SESSION,
CURL_LOCK_DATA_CONNECT,
CURL_LOCK_DATA_LAST
} curl_lock_data;
typedef enum {
CURL_LOCK_ACCESS_NONE = 0,
CURL_LOCK_ACCESS_SHARED = 1,
CURL_LOCK_ACCESS_SINGLE = 2,
CURL_LOCK_ACCESS_LAST
} curl_lock_access;
typedef void (*curl_lock_function)(CURL *handle,
curl_lock_data data,
curl_lock_access locktype,
void *userptr);
typedef void (*curl_unlock_function)(CURL *handle,
curl_lock_data data,
void *userptr);
typedef struct CURLSH CURLSH;
typedef enum {
CURLSHE_OK,
CURLSHE_BAD_OPTION,
CURLSHE_IN_USE,
CURLSHE_INVALID,
CURLSHE_NOMEM,
CURLSHE_NOT_BUILT_IN,
CURLSHE_LAST
} CURLSHcode;
typedef enum {
CURLSHOPT_NONE,
CURLSHOPT_SHARE,
CURLSHOPT_UNSHARE,
CURLSHOPT_LOCKFUNC,
CURLSHOPT_UNLOCKFUNC,
CURLSHOPT_USERDATA,
CURLSHOPT_LAST
} CURLSHoption;
CURLSH *curl_share_init(void);
CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);
CURLSHcode curl_share_cleanup(CURLSH *);
typedef enum {
CURLVERSION_FIRST,
CURLVERSION_SECOND,
CURLVERSION_THIRD,
CURLVERSION_FOURTH,
CURLVERSION_LAST
} CURLversion;
enum {
CURLVERSION_NOW = CURLVERSION_FOURTH,
};
typedef struct {
CURLversion age;
const char *version;
unsigned int version_num;
const char *host;
int features;
const char *ssl_version;
long ssl_version_num;
const char *libz_version;
const char * const *protocols;
const char *ares;
int ares_num;
const char *libidn;
int iconv_ver_num;
const char *libssh_version;
} curl_version_info_data;
enum {
CURL_VERSION_IPV6 = (1<<0),
CURL_VERSION_KERBEROS4 = (1<<1),
CURL_VERSION_SSL = (1<<2),
CURL_VERSION_LIBZ = (1<<3),
CURL_VERSION_NTLM = (1<<4),
CURL_VERSION_GSSNEGOTIATE = (1<<5),
CURL_VERSION_DEBUG = (1<<6),
CURL_VERSION_ASYNCHDNS = (1<<7),
CURL_VERSION_SPNEGO = (1<<8),
CURL_VERSION_LARGEFILE = (1<<9),
CURL_VERSION_IDN = (1<<10),
CURL_VERSION_SSPI = (1<<11),
CURL_VERSION_CONV = (1<<12),
CURL_VERSION_CURLDEBUG = (1<<13),
CURL_VERSION_TLSAUTH_SRP = (1<<14),
CURL_VERSION_NTLM_WB = (1<<15),
CURL_VERSION_HTTP2 = (1<<16),
CURL_VERSION_GSSAPI = (1<<17),
CURL_VERSION_KERBEROS5 = (1<<18),
CURL_VERSION_UNIX_SOCKETS = (1<<19),
};
curl_version_info_data *curl_version_info(CURLversion);
// easy.h --------------------------------------------------------------------
const char *curl_easy_strerror(CURLcode);
const char *curl_share_strerror(CURLSHcode);
CURLcode curl_easy_pause(CURL *handle, int bitmask);
enum {
CURLPAUSE_RECV = (1<<0),
CURLPAUSE_RECV_CONT = (0),
CURLPAUSE_SEND = (1<<2),
CURLPAUSE_SEND_CONT = (0),
CURLPAUSE_ALL = (CURLPAUSE_RECV|CURLPAUSE_SEND),
CURLPAUSE_CONT = (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT),
};
CURL *curl_easy_init(void);
CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
CURLcode curl_easy_perform(CURL *curl);
void curl_easy_cleanup(CURL *curl);
CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
CURL* curl_easy_duphandle(CURL *curl);
void curl_easy_reset(CURL *curl);
CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
size_t *n);
CURLcode curl_easy_send(CURL *curl, const void *buffer,
size_t buflen, size_t *n);
// multi.h -------------------------------------------------------------------
typedef struct CURLM CURLM;
typedef enum {
CURLM_CALL_MULTI_PERFORM = -1,
CURLM_OK,
CURLM_BAD_HANDLE,
CURLM_BAD_EASY_HANDLE,
CURLM_OUT_OF_MEMORY,
CURLM_INTERNAL_ERROR,
CURLM_BAD_SOCKET,
CURLM_UNKNOWN_OPTION,
CURLM_ADDED_ALREADY,
CURLM_LAST
} CURLMcode;
enum {
CURLM_CALL_MULTI_SOCKET = CURLM_CALL_MULTI_PERFORM,
CURLPIPE_NOTHING = 0,
CURLPIPE_HTTP1 = 1,
CURLPIPE_MULTIPLEX = 2,
};
typedef enum {
CURLMSG_NONE,
CURLMSG_DONE,
CURLMSG_LAST
} CURLMSG;
struct CURLMsg {
CURLMSG msg;
CURL *easy_handle;
union {
void *whatever;
CURLcode result;
} data;
};
typedef struct CURLMsg CURLMsg;
enum {
CURL_WAIT_POLLIN = 0x0001,
CURL_WAIT_POLLPRI = 0x0002,
CURL_WAIT_POLLOUT = 0x0004,
};
struct curl_waitfd {
curl_socket_t fd;
short events;
short revents;
};
CURLM *curl_multi_init(void);
CURLMcode curl_multi_add_handle(CURLM *multi_handle, CURL *curl_handle);
CURLMcode curl_multi_remove_handle(CURLM *multi_handle, CURL *curl_handle);
CURLMcode curl_multi_fdset(CURLM *multi_handle,
curl_fd_set *read_fd_set,
curl_fd_set *write_fd_set,
curl_fd_set *exc_fd_set,
int *max_fd);
CURLMcode curl_multi_wait(CURLM *multi_handle,
struct curl_waitfd extra_fds[],
unsigned int extra_nfds,
int timeout_ms,
int *ret);
CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles);
CURLMcode curl_multi_cleanup(CURLM *multi_handle);
CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue);
const char *curl_multi_strerror(CURLMcode);
enum {
CURL_POLL_NONE = 0,
CURL_POLL_IN = 1,
CURL_POLL_OUT = 2,
CURL_POLL_INOUT = 3,
CURL_POLL_REMOVE = 4,
CURL_CSELECT_IN = 0x01,
CURL_CSELECT_OUT = 0x02,
CURL_CSELECT_ERR = 0x04,
};
typedef int (*curl_socket_callback)(CURL *easy, curl_socket_t s, int what, void *userp, void *socketp);
typedef int (*curl_multi_timer_callback)(CURLM *multi, long timeout_ms, void *userp);
CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s, int *running_handles);
CURLMcode curl_multi_socket_action(CURLM *multi_handle, curl_socket_t s, int ev_bitmask, int *running_handles);
CURLMcode curl_multi_socket_all(CURLM *multi_handle, int *running_handles);
CURLMcode curl_multi_timeout(CURLM *multi_handle, long *milliseconds);
typedef enum {
CURLMOPT_SOCKETFUNCTION = 20000 + 1,
CURLMOPT_SOCKETDATA = 10000 + 2,
CURLMOPT_PIPELINING = 0 + 3,
CURLMOPT_TIMERFUNCTION = 20000 + 4,
CURLMOPT_TIMERDATA = 10000 + 5,
CURLMOPT_MAXCONNECTS = 0 + 6,
CURLMOPT_MAX_HOST_CONNECTIONS = 0 + 7,
CURLMOPT_MAX_PIPELINE_LENGTH = 0 + 8,
CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE = 30000 + 9,
CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE = 30000 + 10,
CURLMOPT_PIPELINING_SITE_BL = 10000 + 11,
CURLMOPT_PIPELINING_SERVER_BL = 10000 + 12,
CURLMOPT_MAX_TOTAL_CONNECTIONS = 0 + 13,
CURLMOPT_PUSHFUNCTION = 20000 + 14,
CURLMOPT_PUSHDATA = 10000 + 15,
CURLMOPT_LASTENTRY
} CURLMoption;
CURLMcode curl_multi_setopt(CURLM *multi_handle, CURLMoption option, ...);
CURLMcode curl_multi_assign(CURLM *multi_handle, curl_socket_t sockfd, void *sockp);
enum {
CURL_PUSH_OK = 0,
CURL_PUSH_DENY = 1,
};
struct curl_pushheaders;
char *curl_pushheader_bynum(struct curl_pushheaders *h, size_t num);
char *curl_pushheader_byname(struct curl_pushheaders *h, const char *name);
typedef int (*curl_push_callback)(CURL *parent,
CURL *easy,
size_t num_headers,
struct curl_pushheaders *headers,
void *userp);
]]
扫一扫
9904
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
