From 040b7aee4740286ad7a76172cbcf845bdd530174 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1t=C3=A9=20Kocsis?= Date: Fri, 19 Aug 2022 19:04:26 +0200 Subject: [PATCH] Declare ext/curl constants in stubs --- ext/curl/curl.stub.php | 3526 +++++++++++++++++++++++++++++++++++++++ ext/curl/curl_arginfo.h | 1071 +++++++++++- ext/curl/interface.c | 931 +---------- 3 files changed, 4597 insertions(+), 931 deletions(-) diff --git a/ext/curl/curl.stub.php b/ext/curl/curl.stub.php index 58c5a959b25f6..282fc1eaaa126 100644 --- a/ext/curl/curl.stub.php +++ b/ext/curl/curl.stub.php @@ -2,6 +2,3532 @@ /** @generate-class-entries */ +/* See http://curl.haxx.se/lxr/source/docs/libcurl/symbols-in-versions + or curl src/docs/libcurl/symbols-in-versions for a (almost) complete list + of options and which version they were introduced */ + +/** + * @var int + * @cvalue CURLOPT_AUTOREFERER + */ +const CURLOPT_AUTOREFERER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_BINARYTRANSFER + */ +const CURLOPT_BINARYTRANSFER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_BUFFERSIZE + */ +const CURLOPT_BUFFERSIZE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_CAINFO + */ +const CURLOPT_CAINFO = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_CAPATH + */ +const CURLOPT_CAPATH = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_CONNECTTIMEOUT + */ +const CURLOPT_CONNECTTIMEOUT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_COOKIE + */ +const CURLOPT_COOKIE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_COOKIEFILE + */ +const CURLOPT_COOKIEFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_COOKIEJAR + */ +const CURLOPT_COOKIEJAR = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_COOKIESESSION + */ +const CURLOPT_COOKIESESSION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_CRLF + */ +const CURLOPT_CRLF = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_CUSTOMREQUEST + */ +const CURLOPT_CUSTOMREQUEST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DNS_CACHE_TIMEOUT + */ +const CURLOPT_DNS_CACHE_TIMEOUT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DNS_USE_GLOBAL_CACHE + */ +const CURLOPT_DNS_USE_GLOBAL_CACHE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_EGDSOCKET + */ +const CURLOPT_EGDSOCKET = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_ENCODING + */ +const CURLOPT_ENCODING = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FAILONERROR + */ +const CURLOPT_FAILONERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FILE + */ +const CURLOPT_FILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FILETIME + */ +const CURLOPT_FILETIME = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FOLLOWLOCATION + */ +const CURLOPT_FOLLOWLOCATION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FORBID_REUSE + */ +const CURLOPT_FORBID_REUSE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FRESH_CONNECT + */ +const CURLOPT_FRESH_CONNECT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTPAPPEND + */ +const CURLOPT_FTPAPPEND = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTPLISTONLY + */ +const CURLOPT_FTPLISTONLY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTPPORT + */ +const CURLOPT_FTPPORT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTP_USE_EPRT + */ +const CURLOPT_FTP_USE_EPRT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTP_USE_EPSV + */ +const CURLOPT_FTP_USE_EPSV = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HEADER + */ +const CURLOPT_HEADER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HEADERFUNCTION + */ +const CURLOPT_HEADERFUNCTION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HTTP200ALIASES + */ +const CURLOPT_HTTP200ALIASES = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HTTPGET + */ +const CURLOPT_HTTPGET = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HTTPHEADER + */ +const CURLOPT_HTTPHEADER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HTTPPROXYTUNNEL + */ +const CURLOPT_HTTPPROXYTUNNEL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HTTP_VERSION + */ +const CURLOPT_HTTP_VERSION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_INFILE + */ +const CURLOPT_INFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_INFILESIZE + */ +const CURLOPT_INFILESIZE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_INTERFACE + */ +const CURLOPT_INTERFACE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_KRB4LEVEL + */ +const CURLOPT_KRB4LEVEL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_LOW_SPEED_LIMIT + */ +const CURLOPT_LOW_SPEED_LIMIT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_LOW_SPEED_TIME + */ +const CURLOPT_LOW_SPEED_TIME = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_MAXCONNECTS + */ +const CURLOPT_MAXCONNECTS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_MAXREDIRS + */ +const CURLOPT_MAXREDIRS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_NETRC + */ +const CURLOPT_NETRC = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_NOBODY + */ +const CURLOPT_NOBODY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_NOPROGRESS + */ +const CURLOPT_NOPROGRESS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_NOSIGNAL + */ +const CURLOPT_NOSIGNAL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PORT + */ +const CURLOPT_PORT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_POST + */ +const CURLOPT_POST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_POSTFIELDS + */ +const CURLOPT_POSTFIELDS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_POSTQUOTE + */ +const CURLOPT_POSTQUOTE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PREQUOTE + */ +const CURLOPT_PREQUOTE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PRIVATE + */ +const CURLOPT_PRIVATE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROGRESSFUNCTION + */ +const CURLOPT_PROGRESSFUNCTION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY + */ +const CURLOPT_PROXY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXYPORT + */ +const CURLOPT_PROXYPORT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXYTYPE + */ +const CURLOPT_PROXYTYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXYUSERPWD + */ +const CURLOPT_PROXYUSERPWD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PUT + */ +const CURLOPT_PUT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_QUOTE + */ +const CURLOPT_QUOTE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RANDOM_FILE + */ +const CURLOPT_RANDOM_FILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RANGE + */ +const CURLOPT_RANGE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_READDATA + */ +const CURLOPT_READDATA = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_READFUNCTION + */ +const CURLOPT_READFUNCTION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_REFERER + */ +const CURLOPT_REFERER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RESUME_FROM + */ +const CURLOPT_RESUME_FROM = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RETURNTRANSFER + */ +const CURLOPT_RETURNTRANSFER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SHARE + */ +const CURLOPT_SHARE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLCERT + */ +const CURLOPT_SSLCERT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLCERTPASSWD + */ +const CURLOPT_SSLCERTPASSWD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLCERTTYPE + */ +const CURLOPT_SSLCERTTYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLENGINE + */ +const CURLOPT_SSLENGINE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLENGINE_DEFAULT + */ +const CURLOPT_SSLENGINE_DEFAULT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLKEY + */ +const CURLOPT_SSLKEY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLKEYPASSWD + */ +const CURLOPT_SSLKEYPASSWD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLKEYTYPE + */ +const CURLOPT_SSLKEYTYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLVERSION + */ +const CURLOPT_SSLVERSION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_CIPHER_LIST + */ +const CURLOPT_SSL_CIPHER_LIST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_VERIFYHOST + */ +const CURLOPT_SSL_VERIFYHOST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_VERIFYPEER + */ +const CURLOPT_SSL_VERIFYPEER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_STDERR + */ +const CURLOPT_STDERR = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TELNETOPTIONS + */ +const CURLOPT_TELNETOPTIONS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TIMECONDITION + */ +const CURLOPT_TIMECONDITION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TIMEOUT + */ +const CURLOPT_TIMEOUT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TIMEVALUE + */ +const CURLOPT_TIMEVALUE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TRANSFERTEXT + */ +const CURLOPT_TRANSFERTEXT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_UNRESTRICTED_AUTH + */ +const CURLOPT_UNRESTRICTED_AUTH = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_UPLOAD + */ +const CURLOPT_UPLOAD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_URL + */ +const CURLOPT_URL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_USERAGENT + */ +const CURLOPT_USERAGENT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_USERPWD + */ +const CURLOPT_USERPWD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_VERBOSE + */ +const CURLOPT_VERBOSE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_WRITEFUNCTION + */ +const CURLOPT_WRITEFUNCTION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_WRITEHEADER + */ +const CURLOPT_WRITEHEADER = UNKNOWN; +#if LIBCURL_VERSION_NUM >= 0x072000 +/** + * @var int + * @cvalue CURLOPT_XFERINFOFUNCTION + */ +const CURLOPT_XFERINFOFUNCTION = UNKNOWN; +#endif + +/* */ +/** + * @var int + * @cvalue CURLE_ABORTED_BY_CALLBACK + */ +const CURLE_ABORTED_BY_CALLBACK = UNKNOWN; +/** + * @var int + * @cvalue CURLE_BAD_CALLING_ORDER + */ +const CURLE_BAD_CALLING_ORDER = UNKNOWN; +/** + * @var int + * @cvalue CURLE_BAD_CONTENT_ENCODING + */ +const CURLE_BAD_CONTENT_ENCODING = UNKNOWN; +/** + * @var int + * @cvalue CURLE_BAD_DOWNLOAD_RESUME + */ +const CURLE_BAD_DOWNLOAD_RESUME = UNKNOWN; +/** + * @var int + * @cvalue CURLE_BAD_FUNCTION_ARGUMENT + */ +const CURLE_BAD_FUNCTION_ARGUMENT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_BAD_PASSWORD_ENTERED + */ +const CURLE_BAD_PASSWORD_ENTERED = UNKNOWN; +/** + * @var int + * @cvalue CURLE_COULDNT_CONNECT + */ +const CURLE_COULDNT_CONNECT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_COULDNT_RESOLVE_HOST + */ +const CURLE_COULDNT_RESOLVE_HOST = UNKNOWN; +/** + * @var int + * @cvalue CURLE_COULDNT_RESOLVE_PROXY + */ +const CURLE_COULDNT_RESOLVE_PROXY = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FAILED_INIT + */ +const CURLE_FAILED_INIT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FILE_COULDNT_READ_FILE + */ +const CURLE_FILE_COULDNT_READ_FILE = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_ACCESS_DENIED + */ +const CURLE_FTP_ACCESS_DENIED = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_BAD_DOWNLOAD_RESUME + */ +const CURLE_FTP_BAD_DOWNLOAD_RESUME = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_CANT_GET_HOST + */ +const CURLE_FTP_CANT_GET_HOST = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_CANT_RECONNECT + */ +const CURLE_FTP_CANT_RECONNECT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_COULDNT_GET_SIZE + */ +const CURLE_FTP_COULDNT_GET_SIZE = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_COULDNT_RETR_FILE + */ +const CURLE_FTP_COULDNT_RETR_FILE = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_COULDNT_SET_ASCII + */ +const CURLE_FTP_COULDNT_SET_ASCII = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_COULDNT_SET_BINARY + */ +const CURLE_FTP_COULDNT_SET_BINARY = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_COULDNT_STOR_FILE + */ +const CURLE_FTP_COULDNT_STOR_FILE = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_COULDNT_USE_REST + */ +const CURLE_FTP_COULDNT_USE_REST = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_PARTIAL_FILE + */ +const CURLE_FTP_PARTIAL_FILE = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_PORT_FAILED + */ +const CURLE_FTP_PORT_FAILED = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_QUOTE_ERROR + */ +const CURLE_FTP_QUOTE_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_USER_PASSWORD_INCORRECT + */ +const CURLE_FTP_USER_PASSWORD_INCORRECT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_WEIRD_227_FORMAT + */ +const CURLE_FTP_WEIRD_227_FORMAT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_WEIRD_PASS_REPLY + */ +const CURLE_FTP_WEIRD_PASS_REPLY = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_WEIRD_PASV_REPLY + */ +const CURLE_FTP_WEIRD_PASV_REPLY = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_WEIRD_SERVER_REPLY + */ +const CURLE_FTP_WEIRD_SERVER_REPLY = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_WEIRD_USER_REPLY + */ +const CURLE_FTP_WEIRD_USER_REPLY = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FTP_WRITE_ERROR + */ +const CURLE_FTP_WRITE_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_FUNCTION_NOT_FOUND + */ +const CURLE_FUNCTION_NOT_FOUND = UNKNOWN; +/** + * @var int + * @cvalue CURLE_GOT_NOTHING + */ +const CURLE_GOT_NOTHING = UNKNOWN; +/** + * @var int + * @cvalue CURLE_HTTP_NOT_FOUND + */ +const CURLE_HTTP_NOT_FOUND = UNKNOWN; +/** + * @var int + * @cvalue CURLE_HTTP_PORT_FAILED + */ +const CURLE_HTTP_PORT_FAILED = UNKNOWN; +/** + * @var int + * @cvalue CURLE_HTTP_POST_ERROR + */ +const CURLE_HTTP_POST_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_HTTP_RANGE_ERROR + */ +const CURLE_HTTP_RANGE_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_HTTP_RETURNED_ERROR + */ +const CURLE_HTTP_RETURNED_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_LDAP_CANNOT_BIND + */ +const CURLE_LDAP_CANNOT_BIND = UNKNOWN; +/** + * @var int + * @cvalue CURLE_LDAP_SEARCH_FAILED + */ +const CURLE_LDAP_SEARCH_FAILED = UNKNOWN; +/** + * @var int + * @cvalue CURLE_LIBRARY_NOT_FOUND + */ +const CURLE_LIBRARY_NOT_FOUND = UNKNOWN; +/** + * @var int + * @cvalue CURLE_MALFORMAT_USER + */ +const CURLE_MALFORMAT_USER = UNKNOWN; +/** + * @var int + * @cvalue CURLE_OBSOLETE + */ +const CURLE_OBSOLETE = UNKNOWN; +/** + * @var int + * @cvalue CURLE_OK + */ +const CURLE_OK = UNKNOWN; +/** + * @var int + * @cvalue CURLE_OPERATION_TIMEDOUT + */ +const CURLE_OPERATION_TIMEDOUT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_OPERATION_TIMEOUTED + */ +const CURLE_OPERATION_TIMEOUTED = UNKNOWN; +/** + * @var int + * @cvalue CURLE_OUT_OF_MEMORY + */ +const CURLE_OUT_OF_MEMORY = UNKNOWN; +/** + * @var int + * @cvalue CURLE_PARTIAL_FILE + */ +const CURLE_PARTIAL_FILE = UNKNOWN; +/** + * @var int + * @cvalue CURLE_READ_ERROR + */ +const CURLE_READ_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_RECV_ERROR + */ +const CURLE_RECV_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SEND_ERROR + */ +const CURLE_SEND_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SHARE_IN_USE + */ +const CURLE_SHARE_IN_USE = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SSL_CACERT + */ +const CURLE_SSL_CACERT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SSL_CERTPROBLEM + */ +const CURLE_SSL_CERTPROBLEM = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SSL_CIPHER + */ +const CURLE_SSL_CIPHER = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SSL_CONNECT_ERROR + */ +const CURLE_SSL_CONNECT_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SSL_ENGINE_NOTFOUND + */ +const CURLE_SSL_ENGINE_NOTFOUND = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SSL_ENGINE_SETFAILED + */ +const CURLE_SSL_ENGINE_SETFAILED = UNKNOWN; +/** + * @var int + * @cvalue CURLE_SSL_PEER_CERTIFICATE + */ +const CURLE_SSL_PEER_CERTIFICATE = UNKNOWN; +#if LIBCURL_VERSION_NUM >= 0x072700 /* Available since 7.39.0 */ +/** + * @var int + * @cvalue CURLE_SSL_PINNEDPUBKEYNOTMATCH + */ +const CURLE_SSL_PINNEDPUBKEYNOTMATCH = UNKNOWN; +#endif +/** + * @var int + * @cvalue CURLE_TELNET_OPTION_SYNTAX + */ +const CURLE_TELNET_OPTION_SYNTAX = UNKNOWN; +/** + * @var int + * @cvalue CURLE_TOO_MANY_REDIRECTS + */ +const CURLE_TOO_MANY_REDIRECTS = UNKNOWN; +/** + * @var int + * @cvalue CURLE_UNKNOWN_TELNET_OPTION + */ +const CURLE_UNKNOWN_TELNET_OPTION = UNKNOWN; +/** + * @var int + * @cvalue CURLE_UNSUPPORTED_PROTOCOL + */ +const CURLE_UNSUPPORTED_PROTOCOL = UNKNOWN; +/** + * @var int + * @cvalue CURLE_URL_MALFORMAT + */ +const CURLE_URL_MALFORMAT = UNKNOWN; +/** + * @var int + * @cvalue CURLE_URL_MALFORMAT_USER + */ +const CURLE_URL_MALFORMAT_USER = UNKNOWN; +/** + * @var int + * @cvalue CURLE_WRITE_ERROR + */ +const CURLE_WRITE_ERROR = UNKNOWN; + +/* cURL info constants */ +/** + * @var int + * @cvalue CURLINFO_CONNECT_TIME + */ +const CURLINFO_CONNECT_TIME = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_CONTENT_LENGTH_DOWNLOAD + */ +const CURLINFO_CONTENT_LENGTH_DOWNLOAD = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_CONTENT_LENGTH_UPLOAD + */ +const CURLINFO_CONTENT_LENGTH_UPLOAD = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_CONTENT_TYPE + */ +const CURLINFO_CONTENT_TYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_EFFECTIVE_URL + */ +const CURLINFO_EFFECTIVE_URL = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_FILETIME + */ +const CURLINFO_FILETIME = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_HEADER_OUT + */ +const CURLINFO_HEADER_OUT = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_HEADER_SIZE + */ +const CURLINFO_HEADER_SIZE = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_HTTP_CODE + */ +const CURLINFO_HTTP_CODE = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_LASTONE + */ +const CURLINFO_LASTONE = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_NAMELOOKUP_TIME + */ +const CURLINFO_NAMELOOKUP_TIME = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PRETRANSFER_TIME + */ +const CURLINFO_PRETRANSFER_TIME = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PRIVATE + */ +const CURLINFO_PRIVATE = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_REDIRECT_COUNT + */ +const CURLINFO_REDIRECT_COUNT = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_REDIRECT_TIME + */ +const CURLINFO_REDIRECT_TIME = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_REQUEST_SIZE + */ +const CURLINFO_REQUEST_SIZE = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SIZE_DOWNLOAD + */ +const CURLINFO_SIZE_DOWNLOAD = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SIZE_UPLOAD + */ +const CURLINFO_SIZE_UPLOAD = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SPEED_DOWNLOAD + */ +const CURLINFO_SPEED_DOWNLOAD = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SPEED_UPLOAD + */ +const CURLINFO_SPEED_UPLOAD = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SSL_VERIFYRESULT + */ +const CURLINFO_SSL_VERIFYRESULT = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_STARTTRANSFER_TIME + */ +const CURLINFO_STARTTRANSFER_TIME = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_TOTAL_TIME + */ +const CURLINFO_TOTAL_TIME = UNKNOWN; +#if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ +/** + * @var int + * @cvalue CURLINFO_EFFECTIVE_METHOD + */ +const CURLINFO_EFFECTIVE_METHOD = UNKNOWN; +#endif + +/* Other */ +/** + * @var int + * @cvalue CURLMSG_DONE + */ +const CURLMSG_DONE = UNKNOWN; +/** + * @var int + * @cvalue CURLVERSION_NOW + */ +const CURLVERSION_NOW = UNKNOWN; + +/* Curl Multi Constants */ +/** + * @var int + * @cvalue CURLM_BAD_EASY_HANDLE + */ +const CURLM_BAD_EASY_HANDLE = UNKNOWN; +/** + * @var int + * @cvalue CURLM_BAD_HANDLE + */ +const CURLM_BAD_HANDLE = UNKNOWN; +/** + * @var int + * @cvalue CURLM_CALL_MULTI_PERFORM + */ +const CURLM_CALL_MULTI_PERFORM = UNKNOWN; +/** + * @var int + * @cvalue CURLM_INTERNAL_ERROR + */ +const CURLM_INTERNAL_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLM_OK + */ +const CURLM_OK = UNKNOWN; +/** + * @var int + * @cvalue CURLM_OUT_OF_MEMORY + */ +const CURLM_OUT_OF_MEMORY = UNKNOWN; +#if LIBCURL_VERSION_NUM >= 0x072001 /* Available since 7.32.1 */ +/** + * @var int + * @cvalue CURLM_ADDED_ALREADY + */ +const CURLM_ADDED_ALREADY = UNKNOWN; +#endif + +/* Curl proxy constants */ +/** + * @var int + * @cvalue CURLPROXY_HTTP + */ +const CURLPROXY_HTTP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROXY_SOCKS4 + */ +const CURLPROXY_SOCKS4 = UNKNOWN; +/** + * @var int + * @cvalue CURLPROXY_SOCKS5 + */ +const CURLPROXY_SOCKS5 = UNKNOWN; + +/* Curl Share constants */ +/** + * @var int + * @cvalue CURLSHOPT_NONE + */ +const CURLSHOPT_NONE = UNKNOWN; +/** + * @var int + * @cvalue CURLSHOPT_SHARE + */ +const CURLSHOPT_SHARE = UNKNOWN; +/** + * @var int + * @cvalue CURLSHOPT_UNSHARE + */ +const CURLSHOPT_UNSHARE = UNKNOWN; + +/* Curl Http Version constants (CURLOPT_HTTP_VERSION) */ +/** + * @var int + * @cvalue CURL_HTTP_VERSION_1_0 + */ +const CURL_HTTP_VERSION_1_0 = UNKNOWN; +/** + * @var int + * @cvalue CURL_HTTP_VERSION_1_1 + */ +const CURL_HTTP_VERSION_1_1 = UNKNOWN; +/** + * @var int + * @cvalue CURL_HTTP_VERSION_NONE + */ +const CURL_HTTP_VERSION_NONE = UNKNOWN; + +/* Curl Lock constants */ +/** + * @var int + * @cvalue CURL_LOCK_DATA_COOKIE + */ +const CURL_LOCK_DATA_COOKIE = UNKNOWN; +/** + * @var int + * @cvalue CURL_LOCK_DATA_DNS + */ +const CURL_LOCK_DATA_DNS = UNKNOWN; +/** + * @var int + * @cvalue CURL_LOCK_DATA_SSL_SESSION + */ +const CURL_LOCK_DATA_SSL_SESSION = UNKNOWN; + +/* Curl NETRC constants (CURLOPT_NETRC) */ +/** + * @var int + * @cvalue CURL_NETRC_IGNORED + */ +const CURL_NETRC_IGNORED = UNKNOWN; +/** + * @var int + * @cvalue CURL_NETRC_OPTIONAL + */ +const CURL_NETRC_OPTIONAL = UNKNOWN; +/** + * @var int + * @cvalue CURL_NETRC_REQUIRED + */ +const CURL_NETRC_REQUIRED = UNKNOWN; + +/* Curl SSL Version constants (CURLOPT_SSLVERSION) */ +/** + * @var int + * @cvalue CURL_SSLVERSION_DEFAULT + */ +const CURL_SSLVERSION_DEFAULT = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_SSLv2 + */ +const CURL_SSLVERSION_SSLv2 = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_SSLv3 + */ +const CURL_SSLVERSION_SSLv3 = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_TLSv1 + */ +const CURL_SSLVERSION_TLSv1 = UNKNOWN; + +/* Curl TIMECOND constants (CURLOPT_TIMECONDITION) */ +/** + * @var int + * @cvalue CURL_TIMECOND_IFMODSINCE + */ +const CURL_TIMECOND_IFMODSINCE = UNKNOWN; +/** + * @var int + * @cvalue CURL_TIMECOND_IFUNMODSINCE + */ +const CURL_TIMECOND_IFUNMODSINCE = UNKNOWN; +/** + * @var int + * @cvalue CURL_TIMECOND_LASTMOD + */ +const CURL_TIMECOND_LASTMOD = UNKNOWN; +/** + * @var int + * @cvalue CURL_TIMECOND_NONE + */ +const CURL_TIMECOND_NONE = UNKNOWN; + +/* Curl version constants */ +/** + * @var int + * @cvalue CURL_VERSION_ASYNCHDNS + */ +const CURL_VERSION_ASYNCHDNS = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_CONV + */ +const CURL_VERSION_CONV = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_DEBUG + */ +const CURL_VERSION_DEBUG = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_GSSNEGOTIATE + */ +const CURL_VERSION_GSSNEGOTIATE = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_IDN + */ +const CURL_VERSION_IDN = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_IPV6 + */ +const CURL_VERSION_IPV6 = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_KERBEROS4 + */ +const CURL_VERSION_KERBEROS4 = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_LARGEFILE + */ +const CURL_VERSION_LARGEFILE = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_LIBZ + */ +const CURL_VERSION_LIBZ = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_NTLM + */ +const CURL_VERSION_NTLM = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_SPNEGO + */ +const CURL_VERSION_SPNEGO = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_SSL + */ +const CURL_VERSION_SSL = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_SSPI + */ +const CURL_VERSION_SSPI = UNKNOWN; + +/* Available since 7.10.6 */ +/** + * @var int + * @cvalue CURLOPT_HTTPAUTH + */ +const CURLOPT_HTTPAUTH = UNKNOWN; +/* http authentication options */ +/** + * @var int + * @cvalue CURLAUTH_ANY + */ +const CURLAUTH_ANY = UNKNOWN; +/** + * @var int + * @cvalue CURLAUTH_ANYSAFE + */ +const CURLAUTH_ANYSAFE = UNKNOWN; +/** + * @var int + * @cvalue CURLAUTH_BASIC + */ +const CURLAUTH_BASIC = UNKNOWN; +/** + * @var int + * @cvalue CURLAUTH_DIGEST + */ +const CURLAUTH_DIGEST = UNKNOWN; +/** + * @var int + * @cvalue CURLAUTH_GSSNEGOTIATE + */ +const CURLAUTH_GSSNEGOTIATE = UNKNOWN; +/** + * @var int + * @cvalue CURLAUTH_NONE + */ +const CURLAUTH_NONE = UNKNOWN; +/** + * @var int + * @cvalue CURLAUTH_NTLM + */ +const CURLAUTH_NTLM = UNKNOWN; + +/* Available since 7.10.7 */ +/** + * @var int + * @cvalue CURLINFO_HTTP_CONNECTCODE + */ +const CURLINFO_HTTP_CONNECTCODE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTP_CREATE_MISSING_DIRS + */ +const CURLOPT_FTP_CREATE_MISSING_DIRS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXYAUTH + */ +const CURLOPT_PROXYAUTH = UNKNOWN; + +/* Available since 7.10.8 */ +/** + * @var int + * @cvalue CURLE_FILESIZE_EXCEEDED + */ +const CURLE_FILESIZE_EXCEEDED = UNKNOWN; +/** + * @var int + * @cvalue CURLE_LDAP_INVALID_URL + */ +const CURLE_LDAP_INVALID_URL = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_HTTPAUTH_AVAIL + */ +const CURLINFO_HTTPAUTH_AVAIL = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_RESPONSE_CODE + */ +const CURLINFO_RESPONSE_CODE = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PROXYAUTH_AVAIL + */ +const CURLINFO_PROXYAUTH_AVAIL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTP_RESPONSE_TIMEOUT + */ +const CURLOPT_FTP_RESPONSE_TIMEOUT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_IPRESOLVE + */ +const CURLOPT_IPRESOLVE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_MAXFILESIZE + */ +const CURLOPT_MAXFILESIZE = UNKNOWN; +/** + * @var int + * @cvalue CURL_IPRESOLVE_V4 + */ +const CURL_IPRESOLVE_V4 = UNKNOWN; +/** + * @var int + * @cvalue CURL_IPRESOLVE_V6 + */ +const CURL_IPRESOLVE_V6 = UNKNOWN; +/** + * @var int + * @cvalue CURL_IPRESOLVE_WHATEVER + */ +const CURL_IPRESOLVE_WHATEVER = UNKNOWN; + +/* Available since 7.11.0 */ +/** + * @var int + * @cvalue CURLE_FTP_SSL_FAILED + */ +const CURLE_FTP_SSL_FAILED = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPSSL_ALL + */ +const CURLFTPSSL_ALL = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPSSL_CONTROL + */ +const CURLFTPSSL_CONTROL = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPSSL_NONE + */ +const CURLFTPSSL_NONE = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPSSL_TRY + */ +const CURLFTPSSL_TRY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTP_SSL + */ +const CURLOPT_FTP_SSL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_NETRC_FILE + */ +const CURLOPT_NETRC_FILE = UNKNOWN; + +/* Available since 7.11.1 */ +/** + * @var int + * @cvalue CURLOPT_MAXFILESIZE_LARGE + */ +const CURLOPT_MAXFILESIZE_LARGE = UNKNOWN; + +/* Available since 7.11.2 */ +/** + * @var int + * @cvalue CURLOPT_TCP_NODELAY + */ +const CURLOPT_TCP_NODELAY = UNKNOWN; + +/* Available since 7.12.2 */ +/** + * @var int + * @cvalue CURLFTPAUTH_DEFAULT + */ +const CURLFTPAUTH_DEFAULT = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPAUTH_SSL + */ +const CURLFTPAUTH_SSL = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPAUTH_TLS + */ +const CURLFTPAUTH_TLS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTPSSLAUTH + */ +const CURLOPT_FTPSSLAUTH = UNKNOWN; + +/* Available since 7.13.0 */ +/** + * @var int + * @cvalue CURLOPT_FTP_ACCOUNT + */ +const CURLOPT_FTP_ACCOUNT = UNKNOWN; + +/* Available since 7.12.2 */ +/** + * @var int + * @cvalue CURLINFO_OS_ERRNO + */ +const CURLINFO_OS_ERRNO = UNKNOWN; + +/* Available since 7.12.3 */ +/** + * @var int + * @cvalue CURLINFO_NUM_CONNECTS + */ +const CURLINFO_NUM_CONNECTS = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SSL_ENGINES + */ +const CURLINFO_SSL_ENGINES = UNKNOWN; + +/* Available since 7.14.1 */ +/** + * @var int + * @cvalue CURLINFO_COOKIELIST + */ +const CURLINFO_COOKIELIST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_COOKIELIST + */ +const CURLOPT_COOKIELIST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_IGNORE_CONTENT_LENGTH + */ +const CURLOPT_IGNORE_CONTENT_LENGTH = UNKNOWN; + +/* Available since 7.15.0 */ +/** + * @var int + * @cvalue CURLOPT_FTP_SKIP_PASV_IP + */ +const CURLOPT_FTP_SKIP_PASV_IP = UNKNOWN; + +/* Available since 7.15.1 */ +/** + * @var int + * @cvalue CURLOPT_FTP_FILEMETHOD + */ +const CURLOPT_FTP_FILEMETHOD = UNKNOWN; + +/* Available since 7.15.2 */ +/** + * @var int + * @cvalue CURLOPT_CONNECT_ONLY + */ +const CURLOPT_CONNECT_ONLY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_LOCALPORT + */ +const CURLOPT_LOCALPORT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_LOCALPORTRANGE + */ +const CURLOPT_LOCALPORTRANGE = UNKNOWN; + +/* Available since 7.15.3 */ +/** + * @var int + * @cvalue CURLFTPMETHOD_DEFAULT + */ +const CURLFTPMETHOD_DEFAULT = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPMETHOD_MULTICWD + */ +const CURLFTPMETHOD_MULTICWD = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPMETHOD_NOCWD + */ +const CURLFTPMETHOD_NOCWD = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPMETHOD_SINGLECWD + */ +const CURLFTPMETHOD_SINGLECWD = UNKNOWN; + +/* Available since 7.15.4 */ +/** + * @var int + * @cvalue CURLINFO_FTP_ENTRY_PATH + */ +const CURLINFO_FTP_ENTRY_PATH = UNKNOWN; + +/* Available since 7.15.5 */ +/** + * @var int + * @cvalue CURLOPT_FTP_ALTERNATIVE_TO_USER + */ +const CURLOPT_FTP_ALTERNATIVE_TO_USER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_MAX_RECV_SPEED_LARGE + */ +const CURLOPT_MAX_RECV_SPEED_LARGE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_MAX_SEND_SPEED_LARGE + */ +const CURLOPT_MAX_SEND_SPEED_LARGE = UNKNOWN; + +/* Available since 7.16.0 */ +/** + * @var int + * @cvalue CURLE_SSL_CACERT_BADFILE + */ +const CURLE_SSL_CACERT_BADFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_SESSIONID_CACHE + */ +const CURLOPT_SSL_SESSIONID_CACHE = UNKNOWN; +/** + * @var int + * @cvalue CURLMOPT_PIPELINING + */ +const CURLMOPT_PIPELINING = UNKNOWN; + +/* Available since 7.16.1 */ +/** + * @var int + * @cvalue CURLE_SSH + */ +const CURLE_SSH = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTP_SSL_CCC + */ +const CURLOPT_FTP_SSL_CCC = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSH_AUTH_TYPES + */ +const CURLOPT_SSH_AUTH_TYPES = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSH_PRIVATE_KEYFILE + */ +const CURLOPT_SSH_PRIVATE_KEYFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSH_PUBLIC_KEYFILE + */ +const CURLOPT_SSH_PUBLIC_KEYFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPSSL_CCC_ACTIVE + */ +const CURLFTPSSL_CCC_ACTIVE = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPSSL_CCC_NONE + */ +const CURLFTPSSL_CCC_NONE = UNKNOWN; +/** + * @var int + * @cvalue CURLFTPSSL_CCC_PASSIVE + */ +const CURLFTPSSL_CCC_PASSIVE = UNKNOWN; + +/* Available since 7.16.2 */ +/** + * @var int + * @cvalue CURLOPT_CONNECTTIMEOUT_MS + */ +const CURLOPT_CONNECTTIMEOUT_MS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HTTP_CONTENT_DECODING + */ +const CURLOPT_HTTP_CONTENT_DECODING = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HTTP_TRANSFER_DECODING + */ +const CURLOPT_HTTP_TRANSFER_DECODING = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TIMEOUT_MS + */ +const CURLOPT_TIMEOUT_MS = UNKNOWN; + +/* Available since 7.16.3 */ +/** + * @var int + * @cvalue CURLMOPT_MAXCONNECTS + */ +const CURLMOPT_MAXCONNECTS = UNKNOWN; + +/* Available since 7.16.4 */ +/** + * @var int + * @cvalue CURLOPT_KRBLEVEL + */ +const CURLOPT_KRBLEVEL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_NEW_DIRECTORY_PERMS + */ +const CURLOPT_NEW_DIRECTORY_PERMS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_NEW_FILE_PERMS + */ +const CURLOPT_NEW_FILE_PERMS = UNKNOWN; + +/* Available since 7.17.0 */ +/** + * @var int + * @cvalue CURLOPT_APPEND + */ +const CURLOPT_APPEND = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DIRLISTONLY + */ +const CURLOPT_DIRLISTONLY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_USE_SSL + */ +const CURLOPT_USE_SSL = UNKNOWN; +/* Curl SSL Constants */ +/** + * @var int + * @cvalue CURLUSESSL_ALL + */ +const CURLUSESSL_ALL = UNKNOWN; +/** + * @var int + * @cvalue CURLUSESSL_CONTROL + */ +const CURLUSESSL_CONTROL = UNKNOWN; +/** + * @var int + * @cvalue CURLUSESSL_NONE + */ +const CURLUSESSL_NONE = UNKNOWN; +/** + * @var int + * @cvalue CURLUSESSL_TRY + */ +const CURLUSESSL_TRY = UNKNOWN; + +/* Available since 7.17.1 */ +/** + * @var int + * @cvalue CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 + */ +const CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 = UNKNOWN; + +/* Available since 7.18.0 */ +/** + * @var int + * @cvalue CURLOPT_PROXY_TRANSFER_MODE + */ +const CURLOPT_PROXY_TRANSFER_MODE = UNKNOWN; +/** + * @var int + * @cvalue CURLPAUSE_ALL + */ +const CURLPAUSE_ALL = UNKNOWN; +/** + * @var int + * @cvalue CURLPAUSE_CONT + */ +const CURLPAUSE_CONT = UNKNOWN; +/** + * @var int + * @cvalue CURLPAUSE_RECV + */ +const CURLPAUSE_RECV = UNKNOWN; +/** + * @var int + * @cvalue CURLPAUSE_RECV_CONT + */ +const CURLPAUSE_RECV_CONT = UNKNOWN; +/** + * @var int + * @cvalue CURLPAUSE_SEND + */ +const CURLPAUSE_SEND = UNKNOWN; +/** + * @var int + * @cvalue CURLPAUSE_SEND_CONT + */ +const CURLPAUSE_SEND_CONT = UNKNOWN; +/** + * @var int + * @cvalue CURL_READFUNC_PAUSE + */ +const CURL_READFUNC_PAUSE = UNKNOWN; +/** + * @var int + * @cvalue CURL_WRITEFUNC_PAUSE + */ +const CURL_WRITEFUNC_PAUSE = UNKNOWN; + +/** + * @var int + * @cvalue CURLPROXY_SOCKS4A + */ +const CURLPROXY_SOCKS4A = UNKNOWN; +/** + * @var int + * @cvalue CURLPROXY_SOCKS5_HOSTNAME + */ +const CURLPROXY_SOCKS5_HOSTNAME = UNKNOWN; + +/* Available since 7.18.2 */ +/** + * @var int + * @cvalue CURLINFO_REDIRECT_URL + */ +const CURLINFO_REDIRECT_URL = UNKNOWN; + +/* Available since 7.19.0 */ +/** + * @var int + * @cvalue CURLINFO_APPCONNECT_TIME + */ +const CURLINFO_APPCONNECT_TIME = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PRIMARY_IP + */ +const CURLINFO_PRIMARY_IP = UNKNOWN; + +/** + * @var int + * @cvalue CURLOPT_ADDRESS_SCOPE + */ +const CURLOPT_ADDRESS_SCOPE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_CRLFILE + */ +const CURLOPT_CRLFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_ISSUERCERT + */ +const CURLOPT_ISSUERCERT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_KEYPASSWD + */ +const CURLOPT_KEYPASSWD = UNKNOWN; + +/** + * @var int + * @cvalue CURLSSH_AUTH_ANY + */ +const CURLSSH_AUTH_ANY = UNKNOWN; +/** + * @var int + * @cvalue CURLSSH_AUTH_DEFAULT + */ +const CURLSSH_AUTH_DEFAULT = UNKNOWN; +/** + * @var int + * @cvalue CURLSSH_AUTH_HOST + */ +const CURLSSH_AUTH_HOST = UNKNOWN; +/** + * @var int + * @cvalue CURLSSH_AUTH_KEYBOARD + */ +const CURLSSH_AUTH_KEYBOARD = UNKNOWN; +/** + * @var int + * @cvalue CURLSSH_AUTH_NONE + */ +const CURLSSH_AUTH_NONE = UNKNOWN; +/** + * @var int + * @cvalue CURLSSH_AUTH_PASSWORD + */ +const CURLSSH_AUTH_PASSWORD = UNKNOWN; +/** + * @var int + * @cvalue CURLSSH_AUTH_PUBLICKEY + */ +const CURLSSH_AUTH_PUBLICKEY = UNKNOWN; + +/* Available since 7.19.1 */ +/** + * @var int + * @cvalue CURLINFO_CERTINFO + */ +const CURLINFO_CERTINFO = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_CERTINFO + */ +const CURLOPT_CERTINFO = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PASSWORD + */ +const CURLOPT_PASSWORD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_POSTREDIR + */ +const CURLOPT_POSTREDIR = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXYPASSWORD + */ +const CURLOPT_PROXYPASSWORD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXYUSERNAME + */ +const CURLOPT_PROXYUSERNAME = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_USERNAME + */ +const CURLOPT_USERNAME = UNKNOWN; +/** + * @var int + * @cvalue CURL_REDIR_POST_301 + */ +const CURL_REDIR_POST_301 = UNKNOWN; +/** + * @var int + * @cvalue CURL_REDIR_POST_302 + */ +const CURL_REDIR_POST_302 = UNKNOWN; +/** + * @var int + * @cvalue CURL_REDIR_POST_ALL + */ +const CURL_REDIR_POST_ALL = UNKNOWN; + +/* Available since 7.19.3 */ +/** + * @var int + * @cvalue CURLAUTH_DIGEST_IE + */ +const CURLAUTH_DIGEST_IE = UNKNOWN; + +/* Available since 7.19.4 */ +/** + * @var int + * @cvalue CURLINFO_CONDITION_UNMET + */ +const CURLINFO_CONDITION_UNMET = UNKNOWN; + +/** + * @var int + * @cvalue CURLOPT_NOPROXY + */ +const CURLOPT_NOPROXY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROTOCOLS + */ +const CURLOPT_PROTOCOLS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_REDIR_PROTOCOLS + */ +const CURLOPT_REDIR_PROTOCOLS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SOCKS5_GSSAPI_NEC + */ +const CURLOPT_SOCKS5_GSSAPI_NEC = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SOCKS5_GSSAPI_SERVICE + */ +const CURLOPT_SOCKS5_GSSAPI_SERVICE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TFTP_BLKSIZE + */ +const CURLOPT_TFTP_BLKSIZE = UNKNOWN; + +/** + * @var int + * @cvalue CURLPROTO_ALL + */ +const CURLPROTO_ALL = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_DICT + */ +const CURLPROTO_DICT = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_FILE + */ +const CURLPROTO_FILE = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_FTP + */ +const CURLPROTO_FTP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_FTPS + */ +const CURLPROTO_FTPS = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_HTTP + */ +const CURLPROTO_HTTP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_HTTPS + */ +const CURLPROTO_HTTPS = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_LDAP + */ +const CURLPROTO_LDAP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_LDAPS + */ +const CURLPROTO_LDAPS = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_SCP + */ +const CURLPROTO_SCP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_SFTP + */ +const CURLPROTO_SFTP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_TELNET + */ +const CURLPROTO_TELNET = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_TFTP + */ +const CURLPROTO_TFTP = UNKNOWN; + +/** + * @var int + * @cvalue CURLPROXY_HTTP_1_0 + */ +const CURLPROXY_HTTP_1_0 = UNKNOWN; + +/** + * @var int + * @cvalue CURLFTP_CREATE_DIR + */ +const CURLFTP_CREATE_DIR = UNKNOWN; +/** + * @var int + * @cvalue CURLFTP_CREATE_DIR_NONE + */ +const CURLFTP_CREATE_DIR_NONE = UNKNOWN; +/** + * @var int + * @cvalue CURLFTP_CREATE_DIR_RETRY + */ +const CURLFTP_CREATE_DIR_RETRY = UNKNOWN; + +/* Available since 7.19.6 */ +/** + * @var int + * @cvalue CURL_VERSION_CURLDEBUG + */ +const CURL_VERSION_CURLDEBUG = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSH_KNOWNHOSTS + */ +const CURLOPT_SSH_KNOWNHOSTS = UNKNOWN; + +/* Available since 7.20.0 */ +/** + * @var int + * @cvalue CURLINFO_RTSP_CLIENT_CSEQ + */ +const CURLINFO_RTSP_CLIENT_CSEQ = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_RTSP_CSEQ_RECV + */ +const CURLINFO_RTSP_CSEQ_RECV = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_RTSP_SERVER_CSEQ + */ +const CURLINFO_RTSP_SERVER_CSEQ = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_RTSP_SESSION_ID + */ +const CURLINFO_RTSP_SESSION_ID = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FTP_USE_PRET + */ +const CURLOPT_FTP_USE_PRET = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_MAIL_FROM + */ +const CURLOPT_MAIL_FROM = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_MAIL_RCPT + */ +const CURLOPT_MAIL_RCPT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RTSP_CLIENT_CSEQ + */ +const CURLOPT_RTSP_CLIENT_CSEQ = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RTSP_REQUEST + */ +const CURLOPT_RTSP_REQUEST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RTSP_SERVER_CSEQ + */ +const CURLOPT_RTSP_SERVER_CSEQ = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RTSP_SESSION_ID + */ +const CURLOPT_RTSP_SESSION_ID = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RTSP_STREAM_URI + */ +const CURLOPT_RTSP_STREAM_URI = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RTSP_TRANSPORT + */ +const CURLOPT_RTSP_TRANSPORT = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_IMAP + */ +const CURLPROTO_IMAP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_IMAPS + */ +const CURLPROTO_IMAPS = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_POP3 + */ +const CURLPROTO_POP3 = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_POP3S + */ +const CURLPROTO_POP3S = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_RTSP + */ +const CURLPROTO_RTSP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_SMTP + */ +const CURLPROTO_SMTP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_SMTPS + */ +const CURLPROTO_SMTPS = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_ANNOUNCE + */ +const CURL_RTSPREQ_ANNOUNCE = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_DESCRIBE + */ +const CURL_RTSPREQ_DESCRIBE = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_GET_PARAMETER + */ +const CURL_RTSPREQ_GET_PARAMETER = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_OPTIONS + */ +const CURL_RTSPREQ_OPTIONS = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_PAUSE + */ +const CURL_RTSPREQ_PAUSE = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_PLAY + */ +const CURL_RTSPREQ_PLAY = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_RECEIVE + */ +const CURL_RTSPREQ_RECEIVE = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_RECORD + */ +const CURL_RTSPREQ_RECORD = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_SET_PARAMETER + */ +const CURL_RTSPREQ_SET_PARAMETER = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_SETUP + */ +const CURL_RTSPREQ_SETUP = UNKNOWN; +/** + * @var int + * @cvalue CURL_RTSPREQ_TEARDOWN + */ +const CURL_RTSPREQ_TEARDOWN = UNKNOWN; + +/* Available since 7.21.0 */ +/** + * @var int + * @cvalue CURLINFO_LOCAL_IP + */ +const CURLINFO_LOCAL_IP = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_LOCAL_PORT + */ +const CURLINFO_LOCAL_PORT = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PRIMARY_PORT + */ +const CURLINFO_PRIMARY_PORT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_FNMATCH_FUNCTION + */ +const CURLOPT_FNMATCH_FUNCTION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_WILDCARDMATCH + */ +const CURLOPT_WILDCARDMATCH = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_RTMP + */ +const CURLPROTO_RTMP = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_RTMPE + */ +const CURLPROTO_RTMPE = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_RTMPS + */ +const CURLPROTO_RTMPS = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_RTMPT + */ +const CURLPROTO_RTMPT = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_RTMPTE + */ +const CURLPROTO_RTMPTE = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_RTMPTS + */ +const CURLPROTO_RTMPTS = UNKNOWN; +/** + * @var int + * @cvalue CURL_FNMATCHFUNC_FAIL + */ +const CURL_FNMATCHFUNC_FAIL = UNKNOWN; +/** + * @var int + * @cvalue CURL_FNMATCHFUNC_MATCH + */ +const CURL_FNMATCHFUNC_MATCH = UNKNOWN; +/** + * @var int + * @cvalue CURL_FNMATCHFUNC_NOMATCH + */ +const CURL_FNMATCHFUNC_NOMATCH = UNKNOWN; + +/* Available since 7.21.2 */ +/** + * @var int + * @cvalue CURLPROTO_GOPHER + */ +const CURLPROTO_GOPHER = UNKNOWN; + +/* Available since 7.21.3 */ +/** + * @var int + * @cvalue CURLAUTH_ONLY + */ +const CURLAUTH_ONLY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_RESOLVE + */ +const CURLOPT_RESOLVE = UNKNOWN; + +/* Available since 7.21.4 */ +/** + * @var int + * @cvalue CURLOPT_TLSAUTH_PASSWORD + */ +const CURLOPT_TLSAUTH_PASSWORD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TLSAUTH_TYPE + */ +const CURLOPT_TLSAUTH_TYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TLSAUTH_USERNAME + */ +const CURLOPT_TLSAUTH_USERNAME = UNKNOWN; +/** + * @var int + * @cvalue CURL_TLSAUTH_SRP + */ +const CURL_TLSAUTH_SRP = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_TLSAUTH_SRP + */ +const CURL_VERSION_TLSAUTH_SRP = UNKNOWN; + +/* Available since 7.21.6 */ +/** + * @var int + * @cvalue CURLOPT_ACCEPT_ENCODING + */ +const CURLOPT_ACCEPT_ENCODING = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TRANSFER_ENCODING + */ +const CURLOPT_TRANSFER_ENCODING = UNKNOWN; + +/* Available since 7.22.0 */ +/** + * @var int + * @cvalue CURLAUTH_NTLM_WB + */ +const CURLAUTH_NTLM_WB = UNKNOWN; +/** + * @var int + * @cvalue CURLGSSAPI_DELEGATION_FLAG + */ +const CURLGSSAPI_DELEGATION_FLAG = UNKNOWN; +/** + * @var int + * @cvalue CURLGSSAPI_DELEGATION_POLICY_FLAG + */ +const CURLGSSAPI_DELEGATION_POLICY_FLAG = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_GSSAPI_DELEGATION + */ +const CURLOPT_GSSAPI_DELEGATION = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_NTLM_WB + */ +const CURL_VERSION_NTLM_WB = UNKNOWN; + +/* Available since 7.24.0 */ +/** + * @var int + * @cvalue CURLOPT_ACCEPTTIMEOUT_MS + */ +const CURLOPT_ACCEPTTIMEOUT_MS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DNS_SERVERS + */ +const CURLOPT_DNS_SERVERS = UNKNOWN; + +/* Available since 7.25.0 */ +/** + * @var int + * @cvalue CURLOPT_MAIL_AUTH + */ +const CURLOPT_MAIL_AUTH = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_OPTIONS + */ +const CURLOPT_SSL_OPTIONS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TCP_KEEPALIVE + */ +const CURLOPT_TCP_KEEPALIVE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TCP_KEEPIDLE + */ +const CURLOPT_TCP_KEEPIDLE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TCP_KEEPINTVL + */ +const CURLOPT_TCP_KEEPINTVL = UNKNOWN; +/** + * @var int + * @cvalue CURLSSLOPT_ALLOW_BEAST + */ +const CURLSSLOPT_ALLOW_BEAST = UNKNOWN; + +/* Available since 7.25.1 */ +/** + * @var int + * @cvalue CURL_REDIR_POST_303 + */ +const CURL_REDIR_POST_303 = UNKNOWN; + +/* Available since 7.28.0 */ +/** + * @var int + * @cvalue CURLSSH_AUTH_AGENT + */ +const CURLSSH_AUTH_AGENT = UNKNOWN; + +#if LIBCURL_VERSION_NUM >= 0x071e00 /* Available since 7.30.0 */ +/** + * @var int + * @cvalue CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE + */ +const CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE = UNKNOWN; +/** + * @var int + * @cvalue CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE + */ +const CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE = UNKNOWN; +/** + * @var int + * @cvalue CURLMOPT_MAX_HOST_CONNECTIONS + */ +const CURLMOPT_MAX_HOST_CONNECTIONS = UNKNOWN; +/** + * @var int + * @cvalue CURLMOPT_MAX_PIPELINE_LENGTH + */ +const CURLMOPT_MAX_PIPELINE_LENGTH = UNKNOWN; +/** + * @var int + * @cvalue CURLMOPT_MAX_TOTAL_CONNECTIONS + */ +const CURLMOPT_MAX_TOTAL_CONNECTIONS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x071f00 /* Available since 7.31.0 */ +/** + * @var int + * @cvalue CURLOPT_SASL_IR + */ +const CURLOPT_SASL_IR = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ +/** + * @var int + * @cvalue CURLOPT_DNS_INTERFACE + */ +const CURLOPT_DNS_INTERFACE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DNS_LOCAL_IP4 + */ +const CURLOPT_DNS_LOCAL_IP4 = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DNS_LOCAL_IP6 + */ +const CURLOPT_DNS_LOCAL_IP6 = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_XOAUTH2_BEARER + */ +const CURLOPT_XOAUTH2_BEARER = UNKNOWN; + +/** + * @var int + * @cvalue CURL_HTTP_VERSION_2_0 + */ +const CURL_HTTP_VERSION_2_0 = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_HTTP2 + */ +const CURL_VERSION_HTTP2 = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */ +/** + * @var int + * @cvalue CURLOPT_LOGIN_OPTIONS + */ +const CURLOPT_LOGIN_OPTIONS = UNKNOWN; + +/** + * @var int + * @cvalue CURL_SSLVERSION_TLSv1_0 + */ +const CURL_SSLVERSION_TLSv1_0 = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_TLSv1_1 + */ +const CURL_SSLVERSION_TLSv1_1 = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_TLSv1_2 + */ +const CURL_SSLVERSION_TLSv1_2 = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072400 /* Available since 7.36.0 */ +/** + * @var int + * @cvalue CURLOPT_EXPECT_100_TIMEOUT_MS + */ +const CURLOPT_EXPECT_100_TIMEOUT_MS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_ENABLE_ALPN + */ +const CURLOPT_SSL_ENABLE_ALPN = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_ENABLE_NPN + */ +const CURLOPT_SSL_ENABLE_NPN = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ +/** + * @var int + * @cvalue CURLHEADER_SEPARATE + */ +const CURLHEADER_SEPARATE = UNKNOWN; +/** + * @var int + * @cvalue CURLHEADER_UNIFIED + */ +const CURLHEADER_UNIFIED = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HEADEROPT + */ +const CURLOPT_HEADEROPT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXYHEADER + */ +const CURLOPT_PROXYHEADER = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072600 /* Available since 7.38.0 */ +/** + * @var int + * @cvalue CURLAUTH_NEGOTIATE + */ +const CURLAUTH_NEGOTIATE = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_GSSAPI + */ +const CURL_VERSION_GSSAPI = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072700 /* Available since 7.39.0 */ +/** + * @var int + * @cvalue CURLOPT_PINNEDPUBLICKEY + */ +const CURLOPT_PINNEDPUBLICKEY = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ +/** + * @var int + * @cvalue CURLOPT_UNIX_SOCKET_PATH + */ +const CURLOPT_UNIX_SOCKET_PATH = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_SMB + */ +const CURLPROTO_SMB = UNKNOWN; +/** + * @var int + * @cvalue CURLPROTO_SMBS + */ +const CURLPROTO_SMBS = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_KERBEROS5 + */ +const CURL_VERSION_KERBEROS5 = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_UNIX_SOCKETS + */ +const CURL_VERSION_UNIX_SOCKETS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072900 /* Available since 7.41.0 */ +/** + * @var int + * @cvalue CURLOPT_SSL_VERIFYSTATUS + */ +const CURLOPT_SSL_VERIFYSTATUS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072a00 /* Available since 7.42.0 */ +/** + * @var int + * @cvalue CURLOPT_PATH_AS_IS + */ +const CURLOPT_PATH_AS_IS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_FALSESTART + */ +const CURLOPT_SSL_FALSESTART = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ +/** + * @var int + * @cvalue CURL_HTTP_VERSION_2 + */ +const CURL_HTTP_VERSION_2 = UNKNOWN; + +/** + * @var int + * @cvalue CURLOPT_PIPEWAIT + */ +const CURLOPT_PIPEWAIT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SERVICE_NAME + */ +const CURLOPT_PROXY_SERVICE_NAME = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SERVICE_NAME + */ +const CURLOPT_SERVICE_NAME = UNKNOWN; + +/** + * @var int + * @cvalue CURLPIPE_NOTHING + */ +const CURLPIPE_NOTHING = UNKNOWN; +/** + * @var int + * @cvalue CURLPIPE_HTTP1 + */ +const CURLPIPE_HTTP1 = UNKNOWN; +/** + * @var int + * @cvalue CURLPIPE_MULTIPLEX + */ +const CURLPIPE_MULTIPLEX = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072c00 /* Available since 7.44.0 */ +/** + * @var int + * @cvalue CURLSSLOPT_NO_REVOKE + */ +const CURLSSLOPT_NO_REVOKE = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072d00 /* Available since 7.45.0 */ +/** + * @var int + * @cvalue CURLOPT_DEFAULT_PROTOCOL + */ +const CURLOPT_DEFAULT_PROTOCOL = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072e00 /* Available since 7.46.0 */ +/** + * @var int + * @cvalue CURLOPT_STREAM_WEIGHT + */ +const CURLOPT_STREAM_WEIGHT = UNKNOWN; +/** + * @var int + * @cvalue CURLMOPT_PUSHFUNCTION + */ +const CURLMOPT_PUSHFUNCTION = UNKNOWN; +/** + * @var int + * @cvalue CURL_PUSH_OK + */ +const CURL_PUSH_OK = UNKNOWN; +/** + * @var int + * @cvalue CURL_PUSH_DENY + */ +const CURL_PUSH_DENY = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x072f00 /* Available since 7.47.0 */ +/** + * @var int + * @cvalue CURL_HTTP_VERSION_2TLS + */ +const CURL_HTTP_VERSION_2TLS = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_PSL + */ +const CURL_VERSION_PSL = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073000 /* Available since 7.48.0 */ +/** + * @var int + * @cvalue CURLOPT_TFTP_NO_OPTIONS + */ +const CURLOPT_TFTP_NO_OPTIONS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ +/** + * @var int + * @cvalue CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE + */ +const CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_CONNECT_TO + */ +const CURLOPT_CONNECT_TO = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TCP_FASTOPEN + */ +const CURLOPT_TCP_FASTOPEN = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073200 /* Available since 7.50.0 */ +/** + * @var int + * @cvalue CURLINFO_HTTP_VERSION + */ +const CURLINFO_HTTP_VERSION = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073300 /* Available since 7.51.0 */ +/** + * @var int + * @cvalue CURLE_WEIRD_SERVER_REPLY + */ +const CURLE_WEIRD_SERVER_REPLY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_KEEP_SENDING_ON_ERROR + */ +const CURLOPT_KEEP_SENDING_ON_ERROR = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ +/** + * @var int + * @cvalue CURL_SSLVERSION_TLSv1_3 + */ +const CURL_SSLVERSION_TLSv1_3 = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_HTTPS_PROXY + */ +const CURL_VERSION_HTTPS_PROXY = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PROTOCOL + */ +const CURLINFO_PROTOCOL = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PROXY_SSL_VERIFYRESULT + */ +const CURLINFO_PROXY_SSL_VERIFYRESULT = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SCHEME + */ +const CURLINFO_SCHEME = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PRE_PROXY + */ +const CURLOPT_PRE_PROXY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_CAINFO + */ +const CURLOPT_PROXY_CAINFO = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_CAPATH + */ +const CURLOPT_PROXY_CAPATH = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_CRLFILE + */ +const CURLOPT_PROXY_CRLFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_KEYPASSWD + */ +const CURLOPT_PROXY_KEYPASSWD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_PINNEDPUBLICKEY + */ +const CURLOPT_PROXY_PINNEDPUBLICKEY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSL_CIPHER_LIST + */ +const CURLOPT_PROXY_SSL_CIPHER_LIST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSL_OPTIONS + */ +const CURLOPT_PROXY_SSL_OPTIONS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSL_VERIFYHOST + */ +const CURLOPT_PROXY_SSL_VERIFYHOST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSL_VERIFYPEER + */ +const CURLOPT_PROXY_SSL_VERIFYPEER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSLCERT + */ +const CURLOPT_PROXY_SSLCERT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSLCERTTYPE + */ +const CURLOPT_PROXY_SSLCERTTYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSLKEY + */ +const CURLOPT_PROXY_SSLKEY = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSLKEYTYPE + */ +const CURLOPT_PROXY_SSLKEYTYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSLVERSION + */ +const CURLOPT_PROXY_SSLVERSION = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_TLSAUTH_PASSWORD + */ +const CURLOPT_PROXY_TLSAUTH_PASSWORD = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_TLSAUTH_TYPE + */ +const CURLOPT_PROXY_TLSAUTH_TYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_TLSAUTH_USERNAME + */ +const CURLOPT_PROXY_TLSAUTH_USERNAME = UNKNOWN; +/** + * @var int + * @cvalue CURLPROXY_HTTPS + */ +const CURLPROXY_HTTPS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073500 /* Available since 7.53.0 */ +/** + * @var int + * @cvalue CURL_MAX_READ_SIZE + */ +const CURL_MAX_READ_SIZE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_ABSTRACT_UNIX_SOCKET + */ +const CURLOPT_ABSTRACT_UNIX_SOCKET = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ +/** + * @var int + * @cvalue CURL_SSLVERSION_MAX_DEFAULT + */ +const CURL_SSLVERSION_MAX_DEFAULT = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_MAX_NONE + */ +const CURL_SSLVERSION_MAX_NONE = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_MAX_TLSv1_0 + */ +const CURL_SSLVERSION_MAX_TLSv1_0 = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_MAX_TLSv1_1 + */ +const CURL_SSLVERSION_MAX_TLSv1_1 = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_MAX_TLSv1_2 + */ +const CURL_SSLVERSION_MAX_TLSv1_2 = UNKNOWN; +/** + * @var int + * @cvalue CURL_SSLVERSION_MAX_TLSv1_3 + */ +const CURL_SSLVERSION_MAX_TLSv1_3 = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SUPPRESS_CONNECT_HEADERS + */ +const CURLOPT_SUPPRESS_CONNECT_HEADERS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073601 /* Available since 7.54.1 */ +/** + * @var int + * @cvalue CURLAUTH_GSSAPI + */ +const CURLAUTH_GSSAPI = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ +/** + * @var int + * @cvalue CURLINFO_CONTENT_LENGTH_DOWNLOAD_T + */ +const CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_CONTENT_LENGTH_UPLOAD_T + */ +const CURLINFO_CONTENT_LENGTH_UPLOAD_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SIZE_DOWNLOAD_T + */ +const CURLINFO_SIZE_DOWNLOAD_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SIZE_UPLOAD_T + */ +const CURLINFO_SIZE_UPLOAD_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SPEED_DOWNLOAD_T + */ +const CURLINFO_SPEED_DOWNLOAD_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_SPEED_UPLOAD_T + */ +const CURLINFO_SPEED_UPLOAD_T = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_REQUEST_TARGET + */ +const CURLOPT_REQUEST_TARGET = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SOCKS5_AUTH + */ +const CURLOPT_SOCKS5_AUTH = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073800 /* Available since 7.56.0 */ +/** + * @var int + * @cvalue CURLOPT_SSH_COMPRESSION + */ +const CURLOPT_SSH_COMPRESSION = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_MULTI_SSL + */ +const CURL_VERSION_MULTI_SSL = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073900 /* Available since 7.57.0 */ +/** + * @var int + * @cvalue CURL_VERSION_BROTLI + */ +const CURL_VERSION_BROTLI = UNKNOWN; +/** + * @var int + * @cvalue CURL_LOCK_DATA_CONNECT + */ +const CURL_LOCK_DATA_CONNECT = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073a00 /* Available since 7.58.0 */ +/** + * @var int + * @cvalue CURLSSH_AUTH_GSSAPI + */ +const CURLSSH_AUTH_GSSAPI = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073b00 /* Available since 7.59.0 */ +/** + * @var int + * @cvalue CURLINFO_FILETIME_T + */ +const CURLINFO_FILETIME_T = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS + */ +const CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TIMEVALUE_LARGE + */ +const CURLOPT_TIMEVALUE_LARGE = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073c00 /* Available since 7.60.0 */ +/** + * @var int + * @cvalue CURLOPT_DNS_SHUFFLE_ADDRESSES + */ +const CURLOPT_DNS_SHUFFLE_ADDRESSES = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HAPROXYPROTOCOL + */ +const CURLOPT_HAPROXYPROTOCOL = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ +/** + * @var int + * @cvalue CURL_LOCK_DATA_PSL + */ +const CURL_LOCK_DATA_PSL = UNKNOWN; +/** + * @var int + * @cvalue CURLAUTH_BEARER + */ +const CURLAUTH_BEARER = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_APPCONNECT_TIME_T + */ +const CURLINFO_APPCONNECT_TIME_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_CONNECT_TIME_T + */ +const CURLINFO_CONNECT_TIME_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_NAMELOOKUP_TIME_T + */ +const CURLINFO_NAMELOOKUP_TIME_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PRETRANSFER_TIME_T + */ +const CURLINFO_PRETRANSFER_TIME_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_REDIRECT_TIME_T + */ +const CURLINFO_REDIRECT_TIME_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_STARTTRANSFER_TIME_T + */ +const CURLINFO_STARTTRANSFER_TIME_T = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_TOTAL_TIME_T + */ +const CURLINFO_TOTAL_TIME_T = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DISALLOW_USERNAME_IN_URL + */ +const CURLOPT_DISALLOW_USERNAME_IN_URL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_TLS13_CIPHERS + */ +const CURLOPT_PROXY_TLS13_CIPHERS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_TLS13_CIPHERS + */ +const CURLOPT_TLS13_CIPHERS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x073E00 /* Available since 7.62.0 */ +/** + * @var int + * @cvalue CURLOPT_DOH_URL + */ +const CURLOPT_DOH_URL = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_UPKEEP_INTERVAL_MS + */ +const CURLOPT_UPKEEP_INTERVAL_MS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_UPLOAD_BUFFERSIZE + */ +const CURLOPT_UPLOAD_BUFFERSIZE = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074000 /* Available since 7.64.0 */ +/** + * @var int + * @cvalue CURLOPT_HTTP09_ALLOWED + */ +const CURLOPT_HTTP09_ALLOWED = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ +/** + * @var int + * @cvalue CURLALTSVC_H1 + */ +const CURLALTSVC_H1 = UNKNOWN; +/** + * @var int + * @cvalue CURLALTSVC_H2 + */ +const CURLALTSVC_H2 = UNKNOWN; +/** + * @var int + * @cvalue CURLALTSVC_H3 + */ +const CURLALTSVC_H3 = UNKNOWN; +/** + * @var int + * @cvalue CURLALTSVC_READONLYFILE + */ +const CURLALTSVC_READONLYFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_ALTSVC + */ +const CURLOPT_ALTSVC = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_ALTSVC_CTRL + */ +const CURLOPT_ALTSVC_CTRL = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_ALTSVC + */ +const CURL_VERSION_ALTSVC = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074100 /* Available since 7.65.0 */ +/** + * @var int + * @cvalue CURLOPT_MAXAGE_CONN + */ +const CURLOPT_MAXAGE_CONN = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074200 /* Available since 7.66.0 */ +/** + * @var int + * @cvalue CURLOPT_SASL_AUTHZID + */ +const CURLOPT_SASL_AUTHZID = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_HTTP3 + */ +const CURL_VERSION_HTTP3 = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_RETRY_AFTER + */ +const CURLINFO_RETRY_AFTER = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074300 /* Available since 7.67.0 */ +/** + * @var int + * @cvalue CURLMOPT_MAX_CONCURRENT_STREAMS + */ +const CURLMOPT_MAX_CONCURRENT_STREAMS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074400 /* Available since 7.68.0 */ +/** + * @var int + * @cvalue CURLSSLOPT_NO_PARTIALCHAIN + */ +const CURLSSLOPT_NO_PARTIALCHAIN = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074500 /* Available since 7.69.0 */ +/** + * @var int + * @cvalue CURLOPT_MAIL_RCPT_ALLLOWFAILS + */ +const CURLOPT_MAIL_RCPT_ALLLOWFAILS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074600 /* Available since 7.70.0 */ +/** + * @var int + * @cvalue CURLSSLOPT_REVOKE_BEST_EFFORT + */ +const CURLSSLOPT_REVOKE_BEST_EFFORT = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ +/** + * @var int + * @cvalue CURLOPT_ISSUERCERT_BLOB + */ +const CURLOPT_ISSUERCERT_BLOB = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_ISSUERCERT + */ +const CURLOPT_PROXY_ISSUERCERT = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_ISSUERCERT_BLOB + */ +const CURLOPT_PROXY_ISSUERCERT_BLOB = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSLCERT_BLOB + */ +const CURLOPT_PROXY_SSLCERT_BLOB = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_SSLKEY_BLOB + */ +const CURLOPT_PROXY_SSLKEY_BLOB = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLCERT_BLOB + */ +const CURLOPT_SSLCERT_BLOB = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSLKEY_BLOB + */ +const CURLOPT_SSLKEY_BLOB = UNKNOWN; + +/** + * @var int + * @cvalue CURLPROTO_MQTT + */ +const CURLPROTO_MQTT = UNKNOWN; + +/** + * @var int + * @cvalue CURLSSLOPT_NATIVE_CA + */ +const CURLSSLOPT_NATIVE_CA = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ +/** + * @var int + * @cvalue CURL_VERSION_UNICODE + */ +const CURL_VERSION_UNICODE = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_ZSTD + */ +const CURL_VERSION_ZSTD = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ +/** + * @var int + * @cvalue CURLE_PROXY + */ +const CURLE_PROXY = UNKNOWN; +/** + * @var int + * @cvalue CURLINFO_PROXY_ERROR + */ +const CURLINFO_PROXY_ERROR = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSL_EC_CURVES + */ +const CURLOPT_SSL_EC_CURVES = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_BAD_ADDRESS_TYPE + */ +const CURLPX_BAD_ADDRESS_TYPE = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_BAD_VERSION + */ +const CURLPX_BAD_VERSION = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_CLOSED + */ +const CURLPX_CLOSED = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_GSSAPI + */ +const CURLPX_GSSAPI = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_GSSAPI_PERMSG + */ +const CURLPX_GSSAPI_PERMSG = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_GSSAPI_PROTECTION + */ +const CURLPX_GSSAPI_PROTECTION = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_IDENTD + */ +const CURLPX_IDENTD = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_IDENTD_DIFFER + */ +const CURLPX_IDENTD_DIFFER = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_LONG_HOSTNAME + */ +const CURLPX_LONG_HOSTNAME = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_LONG_PASSWD + */ +const CURLPX_LONG_PASSWD = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_LONG_USER + */ +const CURLPX_LONG_USER = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_NO_AUTH + */ +const CURLPX_NO_AUTH = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_OK + */ +const CURLPX_OK = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_RECV_ADDRESS + */ +const CURLPX_RECV_ADDRESS = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_RECV_AUTH + */ +const CURLPX_RECV_AUTH = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_RECV_CONNECT + */ +const CURLPX_RECV_CONNECT = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_RECV_REQACK + */ +const CURLPX_RECV_REQACK = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED + */ +const CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_COMMAND_NOT_SUPPORTED + */ +const CURLPX_REPLY_COMMAND_NOT_SUPPORTED = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_CONNECTION_REFUSED + */ +const CURLPX_REPLY_CONNECTION_REFUSED = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_GENERAL_SERVER_FAILURE + */ +const CURLPX_REPLY_GENERAL_SERVER_FAILURE = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_HOST_UNREACHABLE + */ +const CURLPX_REPLY_HOST_UNREACHABLE = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_NETWORK_UNREACHABLE + */ +const CURLPX_REPLY_NETWORK_UNREACHABLE = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_NOT_ALLOWED + */ +const CURLPX_REPLY_NOT_ALLOWED = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_TTL_EXPIRED + */ +const CURLPX_REPLY_TTL_EXPIRED = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REPLY_UNASSIGNED + */ +const CURLPX_REPLY_UNASSIGNED = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_REQUEST_FAILED + */ +const CURLPX_REQUEST_FAILED = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_RESOLVE_HOST + */ +const CURLPX_RESOLVE_HOST = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_SEND_AUTH + */ +const CURLPX_SEND_AUTH = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_SEND_CONNECT + */ +const CURLPX_SEND_CONNECT = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_SEND_REQUEST + */ +const CURLPX_SEND_REQUEST = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_UNKNOWN_FAIL + */ +const CURLPX_UNKNOWN_FAIL = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_UNKNOWN_MODE + */ +const CURLPX_UNKNOWN_MODE = UNKNOWN; +/** + * @var int + * @cvalue CURLPX_USER_REJECTED + */ +const CURLPX_USER_REJECTED = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ +/** + * @var int + * @cvalue CURLHSTS_ENABLE + */ +const CURLHSTS_ENABLE = UNKNOWN; +/** + * @var int + * @cvalue CURLHSTS_READONLYFILE + */ +const CURLHSTS_READONLYFILE = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HSTS + */ +const CURLOPT_HSTS = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_HSTS_CTRL + */ +const CURLOPT_HSTS_CTRL = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_HSTS + */ +const CURL_VERSION_HSTS = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074b00 /* Available since 7.75.0 */ +/** + * @var int + * @cvalue CURLAUTH_AWS_SIGV4 + */ +const CURLAUTH_AWS_SIGV4 = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_AWS_SIGV4 + */ +const CURLOPT_AWS_SIGV4 = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ +/** + * @var int + * @cvalue CURLINFO_REFERER + */ +const CURLINFO_REFERER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DOH_SSL_VERIFYHOST + */ +const CURLOPT_DOH_SSL_VERIFYHOST = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DOH_SSL_VERIFYPEER + */ +const CURLOPT_DOH_SSL_VERIFYPEER = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_DOH_SSL_VERIFYSTATUS + */ +const CURLOPT_DOH_SSL_VERIFYSTATUS = UNKNOWN; +/** + * @var int + * @cvalue CURL_VERSION_GSASL + */ +const CURL_VERSION_GSASL = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x074d00 /* Available since 7.77.0 */ +/** + * @var int + * @cvalue CURLOPT_CAINFO_BLOB + */ +const CURLOPT_CAINFO_BLOB = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_PROXY_CAINFO_BLOB + */ +const CURLOPT_PROXY_CAINFO_BLOB = UNKNOWN; +/** + * @var int + * @cvalue CURLSSLOPT_AUTO_CLIENT_CERT + */ +const CURLSSLOPT_AUTO_CLIENT_CERT = UNKNOWN; +#endif + +#if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ +/** + * @var int + * @cvalue CURLOPT_MAXLIFETIME_CONN + */ +const CURLOPT_MAXLIFETIME_CONN = UNKNOWN; +/** + * @var int + * @cvalue CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 + */ +const CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 = UNKNOWN; +#endif + +/** + * @var int + * @cvalue CURLOPT_SAFE_UPLOAD + */ +const CURLOPT_SAFE_UPLOAD = UNKNOWN; + /** * @strict-properties * @not-serializable diff --git a/ext/curl/curl_arginfo.h b/ext/curl/curl_arginfo.h index b8b0b4013ef95..1f05be710a19a 100644 --- a/ext/curl/curl_arginfo.h +++ b/ext/curl/curl_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 1bd8a84a4aa80912463ea76d08f64d3c2cf4c0db */ + * Stub hash: 778f1aa4a9333ef419c89276911333bc8a04a065 */ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_curl_close, 0, 1, IS_VOID, 0) ZEND_ARG_OBJ_INFO(0, handle, CurlHandle, 0) @@ -230,6 +230,1075 @@ static const zend_function_entry class_CurlShareHandle_methods[] = { ZEND_FE_END }; +static void register_curl_symbols(int module_number) +{ + REGISTER_LONG_CONSTANT("CURLOPT_AUTOREFERER", CURLOPT_AUTOREFERER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_BINARYTRANSFER", CURLOPT_BINARYTRANSFER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_BUFFERSIZE", CURLOPT_BUFFERSIZE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CAINFO", CURLOPT_CAINFO, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CAPATH", CURLOPT_CAPATH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CONNECTTIMEOUT", CURLOPT_CONNECTTIMEOUT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_COOKIE", CURLOPT_COOKIE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_COOKIEFILE", CURLOPT_COOKIEFILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_COOKIEJAR", CURLOPT_COOKIEJAR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_COOKIESESSION", CURLOPT_COOKIESESSION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CRLF", CURLOPT_CRLF, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CUSTOMREQUEST", CURLOPT_CUSTOMREQUEST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_DNS_CACHE_TIMEOUT", CURLOPT_DNS_CACHE_TIMEOUT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_DNS_USE_GLOBAL_CACHE", CURLOPT_DNS_USE_GLOBAL_CACHE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_EGDSOCKET", CURLOPT_EGDSOCKET, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_ENCODING", CURLOPT_ENCODING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FAILONERROR", CURLOPT_FAILONERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FILE", CURLOPT_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FILETIME", CURLOPT_FILETIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FOLLOWLOCATION", CURLOPT_FOLLOWLOCATION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FORBID_REUSE", CURLOPT_FORBID_REUSE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FRESH_CONNECT", CURLOPT_FRESH_CONNECT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTPAPPEND", CURLOPT_FTPAPPEND, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTPLISTONLY", CURLOPT_FTPLISTONLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTPPORT", CURLOPT_FTPPORT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_USE_EPRT", CURLOPT_FTP_USE_EPRT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_USE_EPSV", CURLOPT_FTP_USE_EPSV, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HEADER", CURLOPT_HEADER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HEADERFUNCTION", CURLOPT_HEADERFUNCTION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HTTP200ALIASES", CURLOPT_HTTP200ALIASES, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HTTPGET", CURLOPT_HTTPGET, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HTTPHEADER", CURLOPT_HTTPHEADER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HTTPPROXYTUNNEL", CURLOPT_HTTPPROXYTUNNEL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HTTP_VERSION", CURLOPT_HTTP_VERSION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_INFILE", CURLOPT_INFILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_INFILESIZE", CURLOPT_INFILESIZE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_INTERFACE", CURLOPT_INTERFACE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_KRB4LEVEL", CURLOPT_KRB4LEVEL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_LOW_SPEED_LIMIT", CURLOPT_LOW_SPEED_LIMIT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_LOW_SPEED_TIME", CURLOPT_LOW_SPEED_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAXCONNECTS", CURLOPT_MAXCONNECTS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAXREDIRS", CURLOPT_MAXREDIRS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_NETRC", CURLOPT_NETRC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_NOBODY", CURLOPT_NOBODY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_NOPROGRESS", CURLOPT_NOPROGRESS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_NOSIGNAL", CURLOPT_NOSIGNAL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PORT", CURLOPT_PORT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_POST", CURLOPT_POST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_POSTFIELDS", CURLOPT_POSTFIELDS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_POSTQUOTE", CURLOPT_POSTQUOTE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PREQUOTE", CURLOPT_PREQUOTE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PRIVATE", CURLOPT_PRIVATE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROGRESSFUNCTION", CURLOPT_PROGRESSFUNCTION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROXY", CURLOPT_PROXY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROXYPORT", CURLOPT_PROXYPORT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROXYTYPE", CURLOPT_PROXYTYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROXYUSERPWD", CURLOPT_PROXYUSERPWD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PUT", CURLOPT_PUT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_QUOTE", CURLOPT_QUOTE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RANDOM_FILE", CURLOPT_RANDOM_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RANGE", CURLOPT_RANGE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_READDATA", CURLOPT_READDATA, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_READFUNCTION", CURLOPT_READFUNCTION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_REFERER", CURLOPT_REFERER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RESUME_FROM", CURLOPT_RESUME_FROM, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RETURNTRANSFER", CURLOPT_RETURNTRANSFER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SHARE", CURLOPT_SHARE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLCERT", CURLOPT_SSLCERT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLCERTPASSWD", CURLOPT_SSLCERTPASSWD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLCERTTYPE", CURLOPT_SSLCERTTYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLENGINE", CURLOPT_SSLENGINE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLENGINE_DEFAULT", CURLOPT_SSLENGINE_DEFAULT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLKEY", CURLOPT_SSLKEY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLKEYPASSWD", CURLOPT_SSLKEYPASSWD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLKEYTYPE", CURLOPT_SSLKEYTYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSLVERSION", CURLOPT_SSLVERSION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSL_CIPHER_LIST", CURLOPT_SSL_CIPHER_LIST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSL_VERIFYHOST", CURLOPT_SSL_VERIFYHOST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSL_VERIFYPEER", CURLOPT_SSL_VERIFYPEER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_STDERR", CURLOPT_STDERR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TELNETOPTIONS", CURLOPT_TELNETOPTIONS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TIMECONDITION", CURLOPT_TIMECONDITION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TIMEOUT", CURLOPT_TIMEOUT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TIMEVALUE", CURLOPT_TIMEVALUE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TRANSFERTEXT", CURLOPT_TRANSFERTEXT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_UNRESTRICTED_AUTH", CURLOPT_UNRESTRICTED_AUTH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_UPLOAD", CURLOPT_UPLOAD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_URL", CURLOPT_URL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_USERAGENT", CURLOPT_USERAGENT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_USERPWD", CURLOPT_USERPWD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_VERBOSE", CURLOPT_VERBOSE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_WRITEFUNCTION", CURLOPT_WRITEFUNCTION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_WRITEHEADER", CURLOPT_WRITEHEADER, CONST_CS | CONST_PERSISTENT); +#if LIBCURL_VERSION_NUM >= 0x072000 + REGISTER_LONG_CONSTANT("CURLOPT_XFERINFOFUNCTION", CURLOPT_XFERINFOFUNCTION, CONST_CS | CONST_PERSISTENT); +#endif + REGISTER_LONG_CONSTANT("CURLE_ABORTED_BY_CALLBACK", CURLE_ABORTED_BY_CALLBACK, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_BAD_CALLING_ORDER", CURLE_BAD_CALLING_ORDER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_BAD_CONTENT_ENCODING", CURLE_BAD_CONTENT_ENCODING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_BAD_DOWNLOAD_RESUME", CURLE_BAD_DOWNLOAD_RESUME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_BAD_FUNCTION_ARGUMENT", CURLE_BAD_FUNCTION_ARGUMENT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_BAD_PASSWORD_ENTERED", CURLE_BAD_PASSWORD_ENTERED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_COULDNT_CONNECT", CURLE_COULDNT_CONNECT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_COULDNT_RESOLVE_HOST", CURLE_COULDNT_RESOLVE_HOST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_COULDNT_RESOLVE_PROXY", CURLE_COULDNT_RESOLVE_PROXY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FAILED_INIT", CURLE_FAILED_INIT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FILE_COULDNT_READ_FILE", CURLE_FILE_COULDNT_READ_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_ACCESS_DENIED", CURLE_FTP_ACCESS_DENIED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_BAD_DOWNLOAD_RESUME", CURLE_FTP_BAD_DOWNLOAD_RESUME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_CANT_GET_HOST", CURLE_FTP_CANT_GET_HOST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_CANT_RECONNECT", CURLE_FTP_CANT_RECONNECT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_COULDNT_GET_SIZE", CURLE_FTP_COULDNT_GET_SIZE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_COULDNT_RETR_FILE", CURLE_FTP_COULDNT_RETR_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_COULDNT_SET_ASCII", CURLE_FTP_COULDNT_SET_ASCII, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_COULDNT_SET_BINARY", CURLE_FTP_COULDNT_SET_BINARY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_COULDNT_STOR_FILE", CURLE_FTP_COULDNT_STOR_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_COULDNT_USE_REST", CURLE_FTP_COULDNT_USE_REST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_PARTIAL_FILE", CURLE_FTP_PARTIAL_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_PORT_FAILED", CURLE_FTP_PORT_FAILED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_QUOTE_ERROR", CURLE_FTP_QUOTE_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_USER_PASSWORD_INCORRECT", CURLE_FTP_USER_PASSWORD_INCORRECT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_WEIRD_227_FORMAT", CURLE_FTP_WEIRD_227_FORMAT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_WEIRD_PASS_REPLY", CURLE_FTP_WEIRD_PASS_REPLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_WEIRD_PASV_REPLY", CURLE_FTP_WEIRD_PASV_REPLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_WEIRD_SERVER_REPLY", CURLE_FTP_WEIRD_SERVER_REPLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_WEIRD_USER_REPLY", CURLE_FTP_WEIRD_USER_REPLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_WRITE_ERROR", CURLE_FTP_WRITE_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FUNCTION_NOT_FOUND", CURLE_FUNCTION_NOT_FOUND, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_GOT_NOTHING", CURLE_GOT_NOTHING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_HTTP_NOT_FOUND", CURLE_HTTP_NOT_FOUND, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_HTTP_PORT_FAILED", CURLE_HTTP_PORT_FAILED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_HTTP_POST_ERROR", CURLE_HTTP_POST_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_HTTP_RANGE_ERROR", CURLE_HTTP_RANGE_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_HTTP_RETURNED_ERROR", CURLE_HTTP_RETURNED_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_LDAP_CANNOT_BIND", CURLE_LDAP_CANNOT_BIND, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_LDAP_SEARCH_FAILED", CURLE_LDAP_SEARCH_FAILED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_LIBRARY_NOT_FOUND", CURLE_LIBRARY_NOT_FOUND, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_MALFORMAT_USER", CURLE_MALFORMAT_USER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_OBSOLETE", CURLE_OBSOLETE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_OK", CURLE_OK, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_OPERATION_TIMEDOUT", CURLE_OPERATION_TIMEDOUT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_OPERATION_TIMEOUTED", CURLE_OPERATION_TIMEOUTED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_OUT_OF_MEMORY", CURLE_OUT_OF_MEMORY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_PARTIAL_FILE", CURLE_PARTIAL_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_READ_ERROR", CURLE_READ_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_RECV_ERROR", CURLE_RECV_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SEND_ERROR", CURLE_SEND_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SHARE_IN_USE", CURLE_SHARE_IN_USE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSL_CACERT", CURLE_SSL_CACERT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSL_CERTPROBLEM", CURLE_SSL_CERTPROBLEM, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSL_CIPHER", CURLE_SSL_CIPHER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSL_CONNECT_ERROR", CURLE_SSL_CONNECT_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSL_ENGINE_NOTFOUND", CURLE_SSL_ENGINE_NOTFOUND, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSL_ENGINE_SETFAILED", CURLE_SSL_ENGINE_SETFAILED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSL_PEER_CERTIFICATE", CURLE_SSL_PEER_CERTIFICATE, CONST_CS | CONST_PERSISTENT); +#if LIBCURL_VERSION_NUM >= 0x072700 /* Available since 7.39.0 */ + REGISTER_LONG_CONSTANT("CURLE_SSL_PINNEDPUBKEYNOTMATCH", CURLE_SSL_PINNEDPUBKEYNOTMATCH, CONST_CS | CONST_PERSISTENT); +#endif + REGISTER_LONG_CONSTANT("CURLE_TELNET_OPTION_SYNTAX", CURLE_TELNET_OPTION_SYNTAX, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_TOO_MANY_REDIRECTS", CURLE_TOO_MANY_REDIRECTS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_UNKNOWN_TELNET_OPTION", CURLE_UNKNOWN_TELNET_OPTION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_UNSUPPORTED_PROTOCOL", CURLE_UNSUPPORTED_PROTOCOL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_URL_MALFORMAT", CURLE_URL_MALFORMAT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_URL_MALFORMAT_USER", CURLE_URL_MALFORMAT_USER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_WRITE_ERROR", CURLE_WRITE_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_CONNECT_TIME", CURLINFO_CONNECT_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_CONTENT_LENGTH_DOWNLOAD", CURLINFO_CONTENT_LENGTH_DOWNLOAD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_CONTENT_LENGTH_UPLOAD", CURLINFO_CONTENT_LENGTH_UPLOAD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_CONTENT_TYPE", CURLINFO_CONTENT_TYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_EFFECTIVE_URL", CURLINFO_EFFECTIVE_URL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_FILETIME", CURLINFO_FILETIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_HEADER_OUT", CURLINFO_HEADER_OUT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_HEADER_SIZE", CURLINFO_HEADER_SIZE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_HTTP_CODE", CURLINFO_HTTP_CODE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_LASTONE", CURLINFO_LASTONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_NAMELOOKUP_TIME", CURLINFO_NAMELOOKUP_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_PRETRANSFER_TIME", CURLINFO_PRETRANSFER_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_PRIVATE", CURLINFO_PRIVATE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_REDIRECT_COUNT", CURLINFO_REDIRECT_COUNT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_REDIRECT_TIME", CURLINFO_REDIRECT_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_REQUEST_SIZE", CURLINFO_REQUEST_SIZE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_SIZE_DOWNLOAD", CURLINFO_SIZE_DOWNLOAD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_SIZE_UPLOAD", CURLINFO_SIZE_UPLOAD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_SPEED_DOWNLOAD", CURLINFO_SPEED_DOWNLOAD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_SPEED_UPLOAD", CURLINFO_SPEED_UPLOAD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_SSL_VERIFYRESULT", CURLINFO_SSL_VERIFYRESULT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_STARTTRANSFER_TIME", CURLINFO_STARTTRANSFER_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_TOTAL_TIME", CURLINFO_TOTAL_TIME, CONST_CS | CONST_PERSISTENT); +#if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_EFFECTIVE_METHOD", CURLINFO_EFFECTIVE_METHOD, CONST_CS | CONST_PERSISTENT); +#endif + REGISTER_LONG_CONSTANT("CURLMSG_DONE", CURLMSG_DONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLVERSION_NOW", CURLVERSION_NOW, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLM_BAD_EASY_HANDLE", CURLM_BAD_EASY_HANDLE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLM_BAD_HANDLE", CURLM_BAD_HANDLE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLM_CALL_MULTI_PERFORM", CURLM_CALL_MULTI_PERFORM, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLM_INTERNAL_ERROR", CURLM_INTERNAL_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLM_OK", CURLM_OK, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLM_OUT_OF_MEMORY", CURLM_OUT_OF_MEMORY, CONST_CS | CONST_PERSISTENT); +#if LIBCURL_VERSION_NUM >= 0x072001 /* Available since 7.32.1 */ + REGISTER_LONG_CONSTANT("CURLM_ADDED_ALREADY", CURLM_ADDED_ALREADY, CONST_CS | CONST_PERSISTENT); +#endif + REGISTER_LONG_CONSTANT("CURLPROXY_HTTP", CURLPROXY_HTTP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROXY_SOCKS4", CURLPROXY_SOCKS4, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROXY_SOCKS5", CURLPROXY_SOCKS5, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSHOPT_NONE", CURLSHOPT_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSHOPT_SHARE", CURLSHOPT_SHARE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSHOPT_UNSHARE", CURLSHOPT_UNSHARE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_HTTP_VERSION_1_0", CURL_HTTP_VERSION_1_0, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_HTTP_VERSION_1_1", CURL_HTTP_VERSION_1_1, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_HTTP_VERSION_NONE", CURL_HTTP_VERSION_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_LOCK_DATA_COOKIE", CURL_LOCK_DATA_COOKIE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_LOCK_DATA_DNS", CURL_LOCK_DATA_DNS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_LOCK_DATA_SSL_SESSION", CURL_LOCK_DATA_SSL_SESSION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_NETRC_IGNORED", CURL_NETRC_IGNORED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_NETRC_OPTIONAL", CURL_NETRC_OPTIONAL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_NETRC_REQUIRED", CURL_NETRC_REQUIRED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_DEFAULT", CURL_SSLVERSION_DEFAULT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_SSLv2", CURL_SSLVERSION_SSLv2, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_SSLv3", CURL_SSLVERSION_SSLv3, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_TLSv1", CURL_SSLVERSION_TLSv1, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_TIMECOND_IFMODSINCE", CURL_TIMECOND_IFMODSINCE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_TIMECOND_IFUNMODSINCE", CURL_TIMECOND_IFUNMODSINCE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_TIMECOND_LASTMOD", CURL_TIMECOND_LASTMOD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_TIMECOND_NONE", CURL_TIMECOND_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_ASYNCHDNS", CURL_VERSION_ASYNCHDNS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_CONV", CURL_VERSION_CONV, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_DEBUG", CURL_VERSION_DEBUG, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_GSSNEGOTIATE", CURL_VERSION_GSSNEGOTIATE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_IDN", CURL_VERSION_IDN, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_IPV6", CURL_VERSION_IPV6, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_KERBEROS4", CURL_VERSION_KERBEROS4, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_LARGEFILE", CURL_VERSION_LARGEFILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_LIBZ", CURL_VERSION_LIBZ, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_NTLM", CURL_VERSION_NTLM, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_SPNEGO", CURL_VERSION_SPNEGO, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_SSL", CURL_VERSION_SSL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_SSPI", CURL_VERSION_SSPI, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HTTPAUTH", CURLOPT_HTTPAUTH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_ANY", CURLAUTH_ANY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_ANYSAFE", CURLAUTH_ANYSAFE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_BASIC", CURLAUTH_BASIC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_DIGEST", CURLAUTH_DIGEST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_GSSNEGOTIATE", CURLAUTH_GSSNEGOTIATE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_NONE", CURLAUTH_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_NTLM", CURLAUTH_NTLM, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_HTTP_CONNECTCODE", CURLINFO_HTTP_CONNECTCODE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_CREATE_MISSING_DIRS", CURLOPT_FTP_CREATE_MISSING_DIRS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROXYAUTH", CURLOPT_PROXYAUTH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FILESIZE_EXCEEDED", CURLE_FILESIZE_EXCEEDED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_LDAP_INVALID_URL", CURLE_LDAP_INVALID_URL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_HTTPAUTH_AVAIL", CURLINFO_HTTPAUTH_AVAIL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_RESPONSE_CODE", CURLINFO_RESPONSE_CODE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_PROXYAUTH_AVAIL", CURLINFO_PROXYAUTH_AVAIL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_RESPONSE_TIMEOUT", CURLOPT_FTP_RESPONSE_TIMEOUT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_IPRESOLVE", CURLOPT_IPRESOLVE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAXFILESIZE", CURLOPT_MAXFILESIZE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_IPRESOLVE_V4", CURL_IPRESOLVE_V4, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_IPRESOLVE_V6", CURL_IPRESOLVE_V6, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_IPRESOLVE_WHATEVER", CURL_IPRESOLVE_WHATEVER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_FTP_SSL_FAILED", CURLE_FTP_SSL_FAILED, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPSSL_ALL", CURLFTPSSL_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPSSL_CONTROL", CURLFTPSSL_CONTROL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPSSL_NONE", CURLFTPSSL_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPSSL_TRY", CURLFTPSSL_TRY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_SSL", CURLOPT_FTP_SSL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_NETRC_FILE", CURLOPT_NETRC_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAXFILESIZE_LARGE", CURLOPT_MAXFILESIZE_LARGE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TCP_NODELAY", CURLOPT_TCP_NODELAY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPAUTH_DEFAULT", CURLFTPAUTH_DEFAULT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPAUTH_SSL", CURLFTPAUTH_SSL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPAUTH_TLS", CURLFTPAUTH_TLS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTPSSLAUTH", CURLOPT_FTPSSLAUTH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_ACCOUNT", CURLOPT_FTP_ACCOUNT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_OS_ERRNO", CURLINFO_OS_ERRNO, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_NUM_CONNECTS", CURLINFO_NUM_CONNECTS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_SSL_ENGINES", CURLINFO_SSL_ENGINES, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_COOKIELIST", CURLINFO_COOKIELIST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_COOKIELIST", CURLOPT_COOKIELIST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_IGNORE_CONTENT_LENGTH", CURLOPT_IGNORE_CONTENT_LENGTH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_SKIP_PASV_IP", CURLOPT_FTP_SKIP_PASV_IP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_FILEMETHOD", CURLOPT_FTP_FILEMETHOD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CONNECT_ONLY", CURLOPT_CONNECT_ONLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_LOCALPORT", CURLOPT_LOCALPORT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_LOCALPORTRANGE", CURLOPT_LOCALPORTRANGE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPMETHOD_DEFAULT", CURLFTPMETHOD_DEFAULT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPMETHOD_MULTICWD", CURLFTPMETHOD_MULTICWD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPMETHOD_NOCWD", CURLFTPMETHOD_NOCWD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPMETHOD_SINGLECWD", CURLFTPMETHOD_SINGLECWD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_FTP_ENTRY_PATH", CURLINFO_FTP_ENTRY_PATH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_ALTERNATIVE_TO_USER", CURLOPT_FTP_ALTERNATIVE_TO_USER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAX_RECV_SPEED_LARGE", CURLOPT_MAX_RECV_SPEED_LARGE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAX_SEND_SPEED_LARGE", CURLOPT_MAX_SEND_SPEED_LARGE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSL_CACERT_BADFILE", CURLE_SSL_CACERT_BADFILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSL_SESSIONID_CACHE", CURLOPT_SSL_SESSIONID_CACHE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLMOPT_PIPELINING", CURLMOPT_PIPELINING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLE_SSH", CURLE_SSH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_SSL_CCC", CURLOPT_FTP_SSL_CCC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSH_AUTH_TYPES", CURLOPT_SSH_AUTH_TYPES, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSH_PRIVATE_KEYFILE", CURLOPT_SSH_PRIVATE_KEYFILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSH_PUBLIC_KEYFILE", CURLOPT_SSH_PUBLIC_KEYFILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPSSL_CCC_ACTIVE", CURLFTPSSL_CCC_ACTIVE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPSSL_CCC_NONE", CURLFTPSSL_CCC_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTPSSL_CCC_PASSIVE", CURLFTPSSL_CCC_PASSIVE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CONNECTTIMEOUT_MS", CURLOPT_CONNECTTIMEOUT_MS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HTTP_CONTENT_DECODING", CURLOPT_HTTP_CONTENT_DECODING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_HTTP_TRANSFER_DECODING", CURLOPT_HTTP_TRANSFER_DECODING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TIMEOUT_MS", CURLOPT_TIMEOUT_MS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLMOPT_MAXCONNECTS", CURLMOPT_MAXCONNECTS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_KRBLEVEL", CURLOPT_KRBLEVEL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_NEW_DIRECTORY_PERMS", CURLOPT_NEW_DIRECTORY_PERMS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_NEW_FILE_PERMS", CURLOPT_NEW_FILE_PERMS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_APPEND", CURLOPT_APPEND, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_DIRLISTONLY", CURLOPT_DIRLISTONLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_USE_SSL", CURLOPT_USE_SSL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLUSESSL_ALL", CURLUSESSL_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLUSESSL_CONTROL", CURLUSESSL_CONTROL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLUSESSL_NONE", CURLUSESSL_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLUSESSL_TRY", CURLUSESSL_TRY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSH_HOST_PUBLIC_KEY_MD5", CURLOPT_SSH_HOST_PUBLIC_KEY_MD5, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_TRANSFER_MODE", CURLOPT_PROXY_TRANSFER_MODE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPAUSE_ALL", CURLPAUSE_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPAUSE_CONT", CURLPAUSE_CONT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPAUSE_RECV", CURLPAUSE_RECV, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPAUSE_RECV_CONT", CURLPAUSE_RECV_CONT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPAUSE_SEND", CURLPAUSE_SEND, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPAUSE_SEND_CONT", CURLPAUSE_SEND_CONT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_READFUNC_PAUSE", CURL_READFUNC_PAUSE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_WRITEFUNC_PAUSE", CURL_WRITEFUNC_PAUSE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROXY_SOCKS4A", CURLPROXY_SOCKS4A, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROXY_SOCKS5_HOSTNAME", CURLPROXY_SOCKS5_HOSTNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_REDIRECT_URL", CURLINFO_REDIRECT_URL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_APPCONNECT_TIME", CURLINFO_APPCONNECT_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_PRIMARY_IP", CURLINFO_PRIMARY_IP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_ADDRESS_SCOPE", CURLOPT_ADDRESS_SCOPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CRLFILE", CURLOPT_CRLFILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_ISSUERCERT", CURLOPT_ISSUERCERT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_KEYPASSWD", CURLOPT_KEYPASSWD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_ANY", CURLSSH_AUTH_ANY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_DEFAULT", CURLSSH_AUTH_DEFAULT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_HOST", CURLSSH_AUTH_HOST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_KEYBOARD", CURLSSH_AUTH_KEYBOARD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_NONE", CURLSSH_AUTH_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_PASSWORD", CURLSSH_AUTH_PASSWORD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_PUBLICKEY", CURLSSH_AUTH_PUBLICKEY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_CERTINFO", CURLINFO_CERTINFO, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_CERTINFO", CURLOPT_CERTINFO, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PASSWORD", CURLOPT_PASSWORD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_POSTREDIR", CURLOPT_POSTREDIR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROXYPASSWORD", CURLOPT_PROXYPASSWORD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROXYUSERNAME", CURLOPT_PROXYUSERNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_USERNAME", CURLOPT_USERNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_REDIR_POST_301", CURL_REDIR_POST_301, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_REDIR_POST_302", CURL_REDIR_POST_302, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_REDIR_POST_ALL", CURL_REDIR_POST_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_DIGEST_IE", CURLAUTH_DIGEST_IE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_CONDITION_UNMET", CURLINFO_CONDITION_UNMET, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_NOPROXY", CURLOPT_NOPROXY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_PROTOCOLS", CURLOPT_PROTOCOLS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_REDIR_PROTOCOLS", CURLOPT_REDIR_PROTOCOLS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SOCKS5_GSSAPI_NEC", CURLOPT_SOCKS5_GSSAPI_NEC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SOCKS5_GSSAPI_SERVICE", CURLOPT_SOCKS5_GSSAPI_SERVICE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TFTP_BLKSIZE", CURLOPT_TFTP_BLKSIZE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_ALL", CURLPROTO_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_DICT", CURLPROTO_DICT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_FILE", CURLPROTO_FILE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_FTP", CURLPROTO_FTP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_FTPS", CURLPROTO_FTPS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_HTTP", CURLPROTO_HTTP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_HTTPS", CURLPROTO_HTTPS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_LDAP", CURLPROTO_LDAP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_LDAPS", CURLPROTO_LDAPS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_SCP", CURLPROTO_SCP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_SFTP", CURLPROTO_SFTP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_TELNET", CURLPROTO_TELNET, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_TFTP", CURLPROTO_TFTP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROXY_HTTP_1_0", CURLPROXY_HTTP_1_0, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTP_CREATE_DIR", CURLFTP_CREATE_DIR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTP_CREATE_DIR_NONE", CURLFTP_CREATE_DIR_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLFTP_CREATE_DIR_RETRY", CURLFTP_CREATE_DIR_RETRY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_CURLDEBUG", CURL_VERSION_CURLDEBUG, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSH_KNOWNHOSTS", CURLOPT_SSH_KNOWNHOSTS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_RTSP_CLIENT_CSEQ", CURLINFO_RTSP_CLIENT_CSEQ, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_RTSP_CSEQ_RECV", CURLINFO_RTSP_CSEQ_RECV, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_RTSP_SERVER_CSEQ", CURLINFO_RTSP_SERVER_CSEQ, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_RTSP_SESSION_ID", CURLINFO_RTSP_SESSION_ID, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FTP_USE_PRET", CURLOPT_FTP_USE_PRET, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAIL_FROM", CURLOPT_MAIL_FROM, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAIL_RCPT", CURLOPT_MAIL_RCPT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RTSP_CLIENT_CSEQ", CURLOPT_RTSP_CLIENT_CSEQ, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RTSP_REQUEST", CURLOPT_RTSP_REQUEST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RTSP_SERVER_CSEQ", CURLOPT_RTSP_SERVER_CSEQ, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RTSP_SESSION_ID", CURLOPT_RTSP_SESSION_ID, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RTSP_STREAM_URI", CURLOPT_RTSP_STREAM_URI, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RTSP_TRANSPORT", CURLOPT_RTSP_TRANSPORT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_IMAP", CURLPROTO_IMAP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_IMAPS", CURLPROTO_IMAPS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_POP3", CURLPROTO_POP3, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_POP3S", CURLPROTO_POP3S, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_RTSP", CURLPROTO_RTSP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_SMTP", CURLPROTO_SMTP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_SMTPS", CURLPROTO_SMTPS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_ANNOUNCE", CURL_RTSPREQ_ANNOUNCE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_DESCRIBE", CURL_RTSPREQ_DESCRIBE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_GET_PARAMETER", CURL_RTSPREQ_GET_PARAMETER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_OPTIONS", CURL_RTSPREQ_OPTIONS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_PAUSE", CURL_RTSPREQ_PAUSE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_PLAY", CURL_RTSPREQ_PLAY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_RECEIVE", CURL_RTSPREQ_RECEIVE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_RECORD", CURL_RTSPREQ_RECORD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_SET_PARAMETER", CURL_RTSPREQ_SET_PARAMETER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_SETUP", CURL_RTSPREQ_SETUP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_RTSPREQ_TEARDOWN", CURL_RTSPREQ_TEARDOWN, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_LOCAL_IP", CURLINFO_LOCAL_IP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_LOCAL_PORT", CURLINFO_LOCAL_PORT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLINFO_PRIMARY_PORT", CURLINFO_PRIMARY_PORT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_FNMATCH_FUNCTION", CURLOPT_FNMATCH_FUNCTION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_WILDCARDMATCH", CURLOPT_WILDCARDMATCH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_RTMP", CURLPROTO_RTMP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_RTMPE", CURLPROTO_RTMPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_RTMPS", CURLPROTO_RTMPS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_RTMPT", CURLPROTO_RTMPT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_RTMPTE", CURLPROTO_RTMPTE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_RTMPTS", CURLPROTO_RTMPTS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_FNMATCHFUNC_FAIL", CURL_FNMATCHFUNC_FAIL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_FNMATCHFUNC_MATCH", CURL_FNMATCHFUNC_MATCH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_FNMATCHFUNC_NOMATCH", CURL_FNMATCHFUNC_NOMATCH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLPROTO_GOPHER", CURLPROTO_GOPHER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_ONLY", CURLAUTH_ONLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_RESOLVE", CURLOPT_RESOLVE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TLSAUTH_PASSWORD", CURLOPT_TLSAUTH_PASSWORD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TLSAUTH_TYPE", CURLOPT_TLSAUTH_TYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TLSAUTH_USERNAME", CURLOPT_TLSAUTH_USERNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_TLSAUTH_SRP", CURL_TLSAUTH_SRP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_TLSAUTH_SRP", CURL_VERSION_TLSAUTH_SRP, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_ACCEPT_ENCODING", CURLOPT_ACCEPT_ENCODING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TRANSFER_ENCODING", CURLOPT_TRANSFER_ENCODING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLAUTH_NTLM_WB", CURLAUTH_NTLM_WB, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLGSSAPI_DELEGATION_FLAG", CURLGSSAPI_DELEGATION_FLAG, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLGSSAPI_DELEGATION_POLICY_FLAG", CURLGSSAPI_DELEGATION_POLICY_FLAG, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_GSSAPI_DELEGATION", CURLOPT_GSSAPI_DELEGATION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_VERSION_NTLM_WB", CURL_VERSION_NTLM_WB, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_ACCEPTTIMEOUT_MS", CURLOPT_ACCEPTTIMEOUT_MS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_DNS_SERVERS", CURLOPT_DNS_SERVERS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_MAIL_AUTH", CURLOPT_MAIL_AUTH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_SSL_OPTIONS", CURLOPT_SSL_OPTIONS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TCP_KEEPALIVE", CURLOPT_TCP_KEEPALIVE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TCP_KEEPIDLE", CURLOPT_TCP_KEEPIDLE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLOPT_TCP_KEEPINTVL", CURLOPT_TCP_KEEPINTVL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSLOPT_ALLOW_BEAST", CURLSSLOPT_ALLOW_BEAST, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURL_REDIR_POST_303", CURL_REDIR_POST_303, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_AGENT", CURLSSH_AUTH_AGENT, CONST_CS | CONST_PERSISTENT); +#if LIBCURL_VERSION_NUM >= 0x071e00 /* Available since 7.30.0 */ + REGISTER_LONG_CONSTANT("CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE", CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x071e00 /* Available since 7.30.0 */ + REGISTER_LONG_CONSTANT("CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE", CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x071e00 /* Available since 7.30.0 */ + REGISTER_LONG_CONSTANT("CURLMOPT_MAX_HOST_CONNECTIONS", CURLMOPT_MAX_HOST_CONNECTIONS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x071e00 /* Available since 7.30.0 */ + REGISTER_LONG_CONSTANT("CURLMOPT_MAX_PIPELINE_LENGTH", CURLMOPT_MAX_PIPELINE_LENGTH, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x071e00 /* Available since 7.30.0 */ + REGISTER_LONG_CONSTANT("CURLMOPT_MAX_TOTAL_CONNECTIONS", CURLMOPT_MAX_TOTAL_CONNECTIONS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x071f00 /* Available since 7.31.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SASL_IR", CURLOPT_SASL_IR, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DNS_INTERFACE", CURLOPT_DNS_INTERFACE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DNS_LOCAL_IP4", CURLOPT_DNS_LOCAL_IP4, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DNS_LOCAL_IP6", CURLOPT_DNS_LOCAL_IP6, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_XOAUTH2_BEARER", CURLOPT_XOAUTH2_BEARER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ + REGISTER_LONG_CONSTANT("CURL_HTTP_VERSION_2_0", CURL_HTTP_VERSION_2_0, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_HTTP2", CURL_VERSION_HTTP2, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_LOGIN_OPTIONS", CURLOPT_LOGIN_OPTIONS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_TLSv1_0", CURL_SSLVERSION_TLSv1_0, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_TLSv1_1", CURL_SSLVERSION_TLSv1_1, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_TLSv1_2", CURL_SSLVERSION_TLSv1_2, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072400 /* Available since 7.36.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_EXPECT_100_TIMEOUT_MS", CURLOPT_EXPECT_100_TIMEOUT_MS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072400 /* Available since 7.36.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSL_ENABLE_ALPN", CURLOPT_SSL_ENABLE_ALPN, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072400 /* Available since 7.36.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSL_ENABLE_NPN", CURLOPT_SSL_ENABLE_NPN, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ + REGISTER_LONG_CONSTANT("CURLHEADER_SEPARATE", CURLHEADER_SEPARATE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ + REGISTER_LONG_CONSTANT("CURLHEADER_UNIFIED", CURLHEADER_UNIFIED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_HEADEROPT", CURLOPT_HEADEROPT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXYHEADER", CURLOPT_PROXYHEADER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072600 /* Available since 7.38.0 */ + REGISTER_LONG_CONSTANT("CURLAUTH_NEGOTIATE", CURLAUTH_NEGOTIATE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072600 /* Available since 7.38.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_GSSAPI", CURL_VERSION_GSSAPI, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072700 /* Available since 7.39.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PINNEDPUBLICKEY", CURLOPT_PINNEDPUBLICKEY, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_UNIX_SOCKET_PATH", CURLOPT_UNIX_SOCKET_PATH, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ + REGISTER_LONG_CONSTANT("CURLPROTO_SMB", CURLPROTO_SMB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ + REGISTER_LONG_CONSTANT("CURLPROTO_SMBS", CURLPROTO_SMBS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_KERBEROS5", CURL_VERSION_KERBEROS5, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_UNIX_SOCKETS", CURL_VERSION_UNIX_SOCKETS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072900 /* Available since 7.41.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSL_VERIFYSTATUS", CURLOPT_SSL_VERIFYSTATUS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072a00 /* Available since 7.42.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PATH_AS_IS", CURLOPT_PATH_AS_IS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072a00 /* Available since 7.42.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSL_FALSESTART", CURLOPT_SSL_FALSESTART, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + REGISTER_LONG_CONSTANT("CURL_HTTP_VERSION_2", CURL_HTTP_VERSION_2, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PIPEWAIT", CURLOPT_PIPEWAIT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SERVICE_NAME", CURLOPT_PROXY_SERVICE_NAME, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SERVICE_NAME", CURLOPT_SERVICE_NAME, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + REGISTER_LONG_CONSTANT("CURLPIPE_NOTHING", CURLPIPE_NOTHING, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + REGISTER_LONG_CONSTANT("CURLPIPE_HTTP1", CURLPIPE_HTTP1, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + REGISTER_LONG_CONSTANT("CURLPIPE_MULTIPLEX", CURLPIPE_MULTIPLEX, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072c00 /* Available since 7.44.0 */ + REGISTER_LONG_CONSTANT("CURLSSLOPT_NO_REVOKE", CURLSSLOPT_NO_REVOKE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072d00 /* Available since 7.45.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DEFAULT_PROTOCOL", CURLOPT_DEFAULT_PROTOCOL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072e00 /* Available since 7.46.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_STREAM_WEIGHT", CURLOPT_STREAM_WEIGHT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072e00 /* Available since 7.46.0 */ + REGISTER_LONG_CONSTANT("CURLMOPT_PUSHFUNCTION", CURLMOPT_PUSHFUNCTION, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072e00 /* Available since 7.46.0 */ + REGISTER_LONG_CONSTANT("CURL_PUSH_OK", CURL_PUSH_OK, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072e00 /* Available since 7.46.0 */ + REGISTER_LONG_CONSTANT("CURL_PUSH_DENY", CURL_PUSH_DENY, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072f00 /* Available since 7.47.0 */ + REGISTER_LONG_CONSTANT("CURL_HTTP_VERSION_2TLS", CURL_HTTP_VERSION_2TLS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x072f00 /* Available since 7.47.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_PSL", CURL_VERSION_PSL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073000 /* Available since 7.48.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_TFTP_NO_OPTIONS", CURLOPT_TFTP_NO_OPTIONS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ + REGISTER_LONG_CONSTANT("CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE", CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_CONNECT_TO", CURLOPT_CONNECT_TO, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_TCP_FASTOPEN", CURLOPT_TCP_FASTOPEN, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073200 /* Available since 7.50.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_HTTP_VERSION", CURLINFO_HTTP_VERSION, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073300 /* Available since 7.51.0 */ + REGISTER_LONG_CONSTANT("CURLE_WEIRD_SERVER_REPLY", CURLE_WEIRD_SERVER_REPLY, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073300 /* Available since 7.51.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_KEEP_SENDING_ON_ERROR", CURLOPT_KEEP_SENDING_ON_ERROR, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_TLSv1_3", CURL_SSLVERSION_TLSv1_3, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_HTTPS_PROXY", CURL_VERSION_HTTPS_PROXY, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_PROTOCOL", CURLINFO_PROTOCOL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_PROXY_SSL_VERIFYRESULT", CURLINFO_PROXY_SSL_VERIFYRESULT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_SCHEME", CURLINFO_SCHEME, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PRE_PROXY", CURLOPT_PRE_PROXY, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_CAINFO", CURLOPT_PROXY_CAINFO, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_CAPATH", CURLOPT_PROXY_CAPATH, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_CRLFILE", CURLOPT_PROXY_CRLFILE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_KEYPASSWD", CURLOPT_PROXY_KEYPASSWD, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_PINNEDPUBLICKEY", CURLOPT_PROXY_PINNEDPUBLICKEY, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSL_CIPHER_LIST", CURLOPT_PROXY_SSL_CIPHER_LIST, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSL_OPTIONS", CURLOPT_PROXY_SSL_OPTIONS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSL_VERIFYHOST", CURLOPT_PROXY_SSL_VERIFYHOST, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSL_VERIFYPEER", CURLOPT_PROXY_SSL_VERIFYPEER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSLCERT", CURLOPT_PROXY_SSLCERT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSLCERTTYPE", CURLOPT_PROXY_SSLCERTTYPE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSLKEY", CURLOPT_PROXY_SSLKEY, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSLKEYTYPE", CURLOPT_PROXY_SSLKEYTYPE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSLVERSION", CURLOPT_PROXY_SSLVERSION, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_TLSAUTH_PASSWORD", CURLOPT_PROXY_TLSAUTH_PASSWORD, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_TLSAUTH_TYPE", CURLOPT_PROXY_TLSAUTH_TYPE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_TLSAUTH_USERNAME", CURLOPT_PROXY_TLSAUTH_USERNAME, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ + REGISTER_LONG_CONSTANT("CURLPROXY_HTTPS", CURLPROXY_HTTPS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073500 /* Available since 7.53.0 */ + REGISTER_LONG_CONSTANT("CURL_MAX_READ_SIZE", CURL_MAX_READ_SIZE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073500 /* Available since 7.53.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_ABSTRACT_UNIX_SOCKET", CURLOPT_ABSTRACT_UNIX_SOCKET, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_MAX_DEFAULT", CURL_SSLVERSION_MAX_DEFAULT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_MAX_NONE", CURL_SSLVERSION_MAX_NONE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_MAX_TLSv1_0", CURL_SSLVERSION_MAX_TLSv1_0, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_MAX_TLSv1_1", CURL_SSLVERSION_MAX_TLSv1_1, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_MAX_TLSv1_2", CURL_SSLVERSION_MAX_TLSv1_2, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ + REGISTER_LONG_CONSTANT("CURL_SSLVERSION_MAX_TLSv1_3", CURL_SSLVERSION_MAX_TLSv1_3, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SUPPRESS_CONNECT_HEADERS", CURLOPT_SUPPRESS_CONNECT_HEADERS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073601 /* Available since 7.54.1 */ + REGISTER_LONG_CONSTANT("CURLAUTH_GSSAPI", CURLAUTH_GSSAPI, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_CONTENT_LENGTH_DOWNLOAD_T", CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_CONTENT_LENGTH_UPLOAD_T", CURLINFO_CONTENT_LENGTH_UPLOAD_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_SIZE_DOWNLOAD_T", CURLINFO_SIZE_DOWNLOAD_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_SIZE_UPLOAD_T", CURLINFO_SIZE_UPLOAD_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_SPEED_DOWNLOAD_T", CURLINFO_SPEED_DOWNLOAD_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_SPEED_UPLOAD_T", CURLINFO_SPEED_UPLOAD_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_REQUEST_TARGET", CURLOPT_REQUEST_TARGET, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SOCKS5_AUTH", CURLOPT_SOCKS5_AUTH, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073800 /* Available since 7.56.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSH_COMPRESSION", CURLOPT_SSH_COMPRESSION, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073800 /* Available since 7.56.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_MULTI_SSL", CURL_VERSION_MULTI_SSL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073900 /* Available since 7.57.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_BROTLI", CURL_VERSION_BROTLI, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073900 /* Available since 7.57.0 */ + REGISTER_LONG_CONSTANT("CURL_LOCK_DATA_CONNECT", CURL_LOCK_DATA_CONNECT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073a00 /* Available since 7.58.0 */ + REGISTER_LONG_CONSTANT("CURLSSH_AUTH_GSSAPI", CURLSSH_AUTH_GSSAPI, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073b00 /* Available since 7.59.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_FILETIME_T", CURLINFO_FILETIME_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073b00 /* Available since 7.59.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS", CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073b00 /* Available since 7.59.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_TIMEVALUE_LARGE", CURLOPT_TIMEVALUE_LARGE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073c00 /* Available since 7.60.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DNS_SHUFFLE_ADDRESSES", CURLOPT_DNS_SHUFFLE_ADDRESSES, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073c00 /* Available since 7.60.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_HAPROXYPROTOCOL", CURLOPT_HAPROXYPROTOCOL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURL_LOCK_DATA_PSL", CURL_LOCK_DATA_PSL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLAUTH_BEARER", CURLAUTH_BEARER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_APPCONNECT_TIME_T", CURLINFO_APPCONNECT_TIME_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_CONNECT_TIME_T", CURLINFO_CONNECT_TIME_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_NAMELOOKUP_TIME_T", CURLINFO_NAMELOOKUP_TIME_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_PRETRANSFER_TIME_T", CURLINFO_PRETRANSFER_TIME_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_REDIRECT_TIME_T", CURLINFO_REDIRECT_TIME_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_STARTTRANSFER_TIME_T", CURLINFO_STARTTRANSFER_TIME_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_TOTAL_TIME_T", CURLINFO_TOTAL_TIME_T, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DISALLOW_USERNAME_IN_URL", CURLOPT_DISALLOW_USERNAME_IN_URL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_TLS13_CIPHERS", CURLOPT_PROXY_TLS13_CIPHERS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_TLS13_CIPHERS", CURLOPT_TLS13_CIPHERS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073E00 /* Available since 7.62.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DOH_URL", CURLOPT_DOH_URL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073E00 /* Available since 7.62.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_UPKEEP_INTERVAL_MS", CURLOPT_UPKEEP_INTERVAL_MS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x073E00 /* Available since 7.62.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_UPLOAD_BUFFERSIZE", CURLOPT_UPLOAD_BUFFERSIZE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074000 /* Available since 7.64.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_HTTP09_ALLOWED", CURLOPT_HTTP09_ALLOWED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ + REGISTER_LONG_CONSTANT("CURLALTSVC_H1", CURLALTSVC_H1, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ + REGISTER_LONG_CONSTANT("CURLALTSVC_H2", CURLALTSVC_H2, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ + REGISTER_LONG_CONSTANT("CURLALTSVC_H3", CURLALTSVC_H3, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ + REGISTER_LONG_CONSTANT("CURLALTSVC_READONLYFILE", CURLALTSVC_READONLYFILE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ + REGISTER_LONG_CONSTANT("CURLOPT_ALTSVC", CURLOPT_ALTSVC, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ + REGISTER_LONG_CONSTANT("CURLOPT_ALTSVC_CTRL", CURLOPT_ALTSVC_CTRL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_ALTSVC", CURL_VERSION_ALTSVC, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074100 /* Available since 7.65.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_MAXAGE_CONN", CURLOPT_MAXAGE_CONN, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074200 /* Available since 7.66.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SASL_AUTHZID", CURLOPT_SASL_AUTHZID, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074200 /* Available since 7.66.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_HTTP3", CURL_VERSION_HTTP3, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074200 /* Available since 7.66.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_RETRY_AFTER", CURLINFO_RETRY_AFTER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074300 /* Available since 7.67.0 */ + REGISTER_LONG_CONSTANT("CURLMOPT_MAX_CONCURRENT_STREAMS", CURLMOPT_MAX_CONCURRENT_STREAMS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074400 /* Available since 7.68.0 */ + REGISTER_LONG_CONSTANT("CURLSSLOPT_NO_PARTIALCHAIN", CURLSSLOPT_NO_PARTIALCHAIN, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074500 /* Available since 7.69.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_MAIL_RCPT_ALLLOWFAILS", CURLOPT_MAIL_RCPT_ALLLOWFAILS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074600 /* Available since 7.70.0 */ + REGISTER_LONG_CONSTANT("CURLSSLOPT_REVOKE_BEST_EFFORT", CURLSSLOPT_REVOKE_BEST_EFFORT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_ISSUERCERT_BLOB", CURLOPT_ISSUERCERT_BLOB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_ISSUERCERT", CURLOPT_PROXY_ISSUERCERT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_ISSUERCERT_BLOB", CURLOPT_PROXY_ISSUERCERT_BLOB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSLCERT_BLOB", CURLOPT_PROXY_SSLCERT_BLOB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_SSLKEY_BLOB", CURLOPT_PROXY_SSLKEY_BLOB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSLCERT_BLOB", CURLOPT_SSLCERT_BLOB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSLKEY_BLOB", CURLOPT_SSLKEY_BLOB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLPROTO_MQTT", CURLPROTO_MQTT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ + REGISTER_LONG_CONSTANT("CURLSSLOPT_NATIVE_CA", CURLSSLOPT_NATIVE_CA, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_UNICODE", CURL_VERSION_UNICODE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_ZSTD", CURL_VERSION_ZSTD, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLE_PROXY", CURLE_PROXY, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_PROXY_ERROR", CURLINFO_PROXY_ERROR, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSL_EC_CURVES", CURLOPT_SSL_EC_CURVES, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_BAD_ADDRESS_TYPE", CURLPX_BAD_ADDRESS_TYPE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_BAD_VERSION", CURLPX_BAD_VERSION, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_CLOSED", CURLPX_CLOSED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_GSSAPI", CURLPX_GSSAPI, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_GSSAPI_PERMSG", CURLPX_GSSAPI_PERMSG, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_GSSAPI_PROTECTION", CURLPX_GSSAPI_PROTECTION, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_IDENTD", CURLPX_IDENTD, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_IDENTD_DIFFER", CURLPX_IDENTD_DIFFER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_LONG_HOSTNAME", CURLPX_LONG_HOSTNAME, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_LONG_PASSWD", CURLPX_LONG_PASSWD, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_LONG_USER", CURLPX_LONG_USER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_NO_AUTH", CURLPX_NO_AUTH, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_OK", CURLPX_OK, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_RECV_ADDRESS", CURLPX_RECV_ADDRESS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_RECV_AUTH", CURLPX_RECV_AUTH, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_RECV_CONNECT", CURLPX_RECV_CONNECT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_RECV_REQACK", CURLPX_RECV_REQACK, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED", CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_COMMAND_NOT_SUPPORTED", CURLPX_REPLY_COMMAND_NOT_SUPPORTED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_CONNECTION_REFUSED", CURLPX_REPLY_CONNECTION_REFUSED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_GENERAL_SERVER_FAILURE", CURLPX_REPLY_GENERAL_SERVER_FAILURE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_HOST_UNREACHABLE", CURLPX_REPLY_HOST_UNREACHABLE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_NETWORK_UNREACHABLE", CURLPX_REPLY_NETWORK_UNREACHABLE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_NOT_ALLOWED", CURLPX_REPLY_NOT_ALLOWED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_TTL_EXPIRED", CURLPX_REPLY_TTL_EXPIRED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REPLY_UNASSIGNED", CURLPX_REPLY_UNASSIGNED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_REQUEST_FAILED", CURLPX_REQUEST_FAILED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_RESOLVE_HOST", CURLPX_RESOLVE_HOST, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_SEND_AUTH", CURLPX_SEND_AUTH, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_SEND_CONNECT", CURLPX_SEND_CONNECT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_SEND_REQUEST", CURLPX_SEND_REQUEST, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_UNKNOWN_FAIL", CURLPX_UNKNOWN_FAIL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_UNKNOWN_MODE", CURLPX_UNKNOWN_MODE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ + REGISTER_LONG_CONSTANT("CURLPX_USER_REJECTED", CURLPX_USER_REJECTED, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ + REGISTER_LONG_CONSTANT("CURLHSTS_ENABLE", CURLHSTS_ENABLE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ + REGISTER_LONG_CONSTANT("CURLHSTS_READONLYFILE", CURLHSTS_READONLYFILE, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_HSTS", CURLOPT_HSTS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_HSTS_CTRL", CURLOPT_HSTS_CTRL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_HSTS", CURL_VERSION_HSTS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074b00 /* Available since 7.75.0 */ + REGISTER_LONG_CONSTANT("CURLAUTH_AWS_SIGV4", CURLAUTH_AWS_SIGV4, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074b00 /* Available since 7.75.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_AWS_SIGV4", CURLOPT_AWS_SIGV4, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ + REGISTER_LONG_CONSTANT("CURLINFO_REFERER", CURLINFO_REFERER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DOH_SSL_VERIFYHOST", CURLOPT_DOH_SSL_VERIFYHOST, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DOH_SSL_VERIFYPEER", CURLOPT_DOH_SSL_VERIFYPEER, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_DOH_SSL_VERIFYSTATUS", CURLOPT_DOH_SSL_VERIFYSTATUS, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ + REGISTER_LONG_CONSTANT("CURL_VERSION_GSASL", CURL_VERSION_GSASL, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074d00 /* Available since 7.77.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_CAINFO_BLOB", CURLOPT_CAINFO_BLOB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074d00 /* Available since 7.77.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_PROXY_CAINFO_BLOB", CURLOPT_PROXY_CAINFO_BLOB, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x074d00 /* Available since 7.77.0 */ + REGISTER_LONG_CONSTANT("CURLSSLOPT_AUTO_CLIENT_CERT", CURLSSLOPT_AUTO_CLIENT_CERT, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_MAXLIFETIME_CONN", CURLOPT_MAXLIFETIME_CONN, CONST_CS | CONST_PERSISTENT); +#endif +#if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ + REGISTER_LONG_CONSTANT("CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256", CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256, CONST_CS | CONST_PERSISTENT); +#endif + REGISTER_LONG_CONSTANT("CURLOPT_SAFE_UPLOAD", CURLOPT_SAFE_UPLOAD, CONST_CS | CONST_PERSISTENT); +} + static zend_class_entry *register_class_CurlHandle(void) { zend_class_entry ce, *class_entry; diff --git a/ext/curl/interface.c b/ext/curl/interface.c index 0e9aae4b76458..e698c7be2cd97 100644 --- a/ext/curl/interface.c +++ b/ext/curl/interface.c @@ -374,936 +374,7 @@ PHP_MINIT_FUNCTION(curl) { REGISTER_INI_ENTRIES(); - /* See http://curl.haxx.se/lxr/source/docs/libcurl/symbols-in-versions - or curl src/docs/libcurl/symbols-in-versions for a (almost) complete list - of options and which version they were introduced */ - - /* Constants for curl_setopt() */ - REGISTER_CURL_CONSTANT(CURLOPT_AUTOREFERER); - REGISTER_CURL_CONSTANT(CURLOPT_BINARYTRANSFER); - REGISTER_CURL_CONSTANT(CURLOPT_BUFFERSIZE); - REGISTER_CURL_CONSTANT(CURLOPT_CAINFO); - REGISTER_CURL_CONSTANT(CURLOPT_CAPATH); - REGISTER_CURL_CONSTANT(CURLOPT_CONNECTTIMEOUT); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIE); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIEFILE); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIEJAR); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIESESSION); - REGISTER_CURL_CONSTANT(CURLOPT_CRLF); - REGISTER_CURL_CONSTANT(CURLOPT_CUSTOMREQUEST); - REGISTER_CURL_CONSTANT(CURLOPT_DNS_CACHE_TIMEOUT); - REGISTER_CURL_CONSTANT(CURLOPT_DNS_USE_GLOBAL_CACHE); - REGISTER_CURL_CONSTANT(CURLOPT_EGDSOCKET); - REGISTER_CURL_CONSTANT(CURLOPT_ENCODING); - REGISTER_CURL_CONSTANT(CURLOPT_FAILONERROR); - REGISTER_CURL_CONSTANT(CURLOPT_FILE); - REGISTER_CURL_CONSTANT(CURLOPT_FILETIME); - REGISTER_CURL_CONSTANT(CURLOPT_FOLLOWLOCATION); - REGISTER_CURL_CONSTANT(CURLOPT_FORBID_REUSE); - REGISTER_CURL_CONSTANT(CURLOPT_FRESH_CONNECT); - REGISTER_CURL_CONSTANT(CURLOPT_FTPAPPEND); - REGISTER_CURL_CONSTANT(CURLOPT_FTPLISTONLY); - REGISTER_CURL_CONSTANT(CURLOPT_FTPPORT); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_USE_EPRT); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_USE_EPSV); - REGISTER_CURL_CONSTANT(CURLOPT_HEADER); - REGISTER_CURL_CONSTANT(CURLOPT_HEADERFUNCTION); - REGISTER_CURL_CONSTANT(CURLOPT_HTTP200ALIASES); - REGISTER_CURL_CONSTANT(CURLOPT_HTTPGET); - REGISTER_CURL_CONSTANT(CURLOPT_HTTPHEADER); - REGISTER_CURL_CONSTANT(CURLOPT_HTTPPROXYTUNNEL); - REGISTER_CURL_CONSTANT(CURLOPT_HTTP_VERSION); - REGISTER_CURL_CONSTANT(CURLOPT_INFILE); - REGISTER_CURL_CONSTANT(CURLOPT_INFILESIZE); - REGISTER_CURL_CONSTANT(CURLOPT_INTERFACE); - REGISTER_CURL_CONSTANT(CURLOPT_KRB4LEVEL); - REGISTER_CURL_CONSTANT(CURLOPT_LOW_SPEED_LIMIT); - REGISTER_CURL_CONSTANT(CURLOPT_LOW_SPEED_TIME); - REGISTER_CURL_CONSTANT(CURLOPT_MAXCONNECTS); - REGISTER_CURL_CONSTANT(CURLOPT_MAXREDIRS); - REGISTER_CURL_CONSTANT(CURLOPT_NETRC); - REGISTER_CURL_CONSTANT(CURLOPT_NOBODY); - REGISTER_CURL_CONSTANT(CURLOPT_NOPROGRESS); - REGISTER_CURL_CONSTANT(CURLOPT_NOSIGNAL); - REGISTER_CURL_CONSTANT(CURLOPT_PORT); - REGISTER_CURL_CONSTANT(CURLOPT_POST); - REGISTER_CURL_CONSTANT(CURLOPT_POSTFIELDS); - REGISTER_CURL_CONSTANT(CURLOPT_POSTQUOTE); - REGISTER_CURL_CONSTANT(CURLOPT_PREQUOTE); - REGISTER_CURL_CONSTANT(CURLOPT_PRIVATE); - REGISTER_CURL_CONSTANT(CURLOPT_PROGRESSFUNCTION); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYPORT); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYTYPE); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYUSERPWD); - REGISTER_CURL_CONSTANT(CURLOPT_PUT); - REGISTER_CURL_CONSTANT(CURLOPT_QUOTE); - REGISTER_CURL_CONSTANT(CURLOPT_RANDOM_FILE); - REGISTER_CURL_CONSTANT(CURLOPT_RANGE); - REGISTER_CURL_CONSTANT(CURLOPT_READDATA); - REGISTER_CURL_CONSTANT(CURLOPT_READFUNCTION); - REGISTER_CURL_CONSTANT(CURLOPT_REFERER); - REGISTER_CURL_CONSTANT(CURLOPT_RESUME_FROM); - REGISTER_CURL_CONSTANT(CURLOPT_RETURNTRANSFER); - REGISTER_CURL_CONSTANT(CURLOPT_SHARE); - REGISTER_CURL_CONSTANT(CURLOPT_SSLCERT); - REGISTER_CURL_CONSTANT(CURLOPT_SSLCERTPASSWD); - REGISTER_CURL_CONSTANT(CURLOPT_SSLCERTTYPE); - REGISTER_CURL_CONSTANT(CURLOPT_SSLENGINE); - REGISTER_CURL_CONSTANT(CURLOPT_SSLENGINE_DEFAULT); - REGISTER_CURL_CONSTANT(CURLOPT_SSLKEY); - REGISTER_CURL_CONSTANT(CURLOPT_SSLKEYPASSWD); - REGISTER_CURL_CONSTANT(CURLOPT_SSLKEYTYPE); - REGISTER_CURL_CONSTANT(CURLOPT_SSLVERSION); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_CIPHER_LIST); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_VERIFYHOST); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_VERIFYPEER); - REGISTER_CURL_CONSTANT(CURLOPT_STDERR); - REGISTER_CURL_CONSTANT(CURLOPT_TELNETOPTIONS); - REGISTER_CURL_CONSTANT(CURLOPT_TIMECONDITION); - REGISTER_CURL_CONSTANT(CURLOPT_TIMEOUT); - REGISTER_CURL_CONSTANT(CURLOPT_TIMEVALUE); - REGISTER_CURL_CONSTANT(CURLOPT_TRANSFERTEXT); - REGISTER_CURL_CONSTANT(CURLOPT_UNRESTRICTED_AUTH); - REGISTER_CURL_CONSTANT(CURLOPT_UPLOAD); - REGISTER_CURL_CONSTANT(CURLOPT_URL); - REGISTER_CURL_CONSTANT(CURLOPT_USERAGENT); - REGISTER_CURL_CONSTANT(CURLOPT_USERPWD); - REGISTER_CURL_CONSTANT(CURLOPT_VERBOSE); - REGISTER_CURL_CONSTANT(CURLOPT_WRITEFUNCTION); - REGISTER_CURL_CONSTANT(CURLOPT_WRITEHEADER); -#if LIBCURL_VERSION_NUM >= 0x072000 - REGISTER_CURL_CONSTANT(CURLOPT_XFERINFOFUNCTION); -#endif - - /* */ - REGISTER_CURL_CONSTANT(CURLE_ABORTED_BY_CALLBACK); - REGISTER_CURL_CONSTANT(CURLE_BAD_CALLING_ORDER); - REGISTER_CURL_CONSTANT(CURLE_BAD_CONTENT_ENCODING); - REGISTER_CURL_CONSTANT(CURLE_BAD_DOWNLOAD_RESUME); - REGISTER_CURL_CONSTANT(CURLE_BAD_FUNCTION_ARGUMENT); - REGISTER_CURL_CONSTANT(CURLE_BAD_PASSWORD_ENTERED); - REGISTER_CURL_CONSTANT(CURLE_COULDNT_CONNECT); - REGISTER_CURL_CONSTANT(CURLE_COULDNT_RESOLVE_HOST); - REGISTER_CURL_CONSTANT(CURLE_COULDNT_RESOLVE_PROXY); - REGISTER_CURL_CONSTANT(CURLE_FAILED_INIT); - REGISTER_CURL_CONSTANT(CURLE_FILE_COULDNT_READ_FILE); - REGISTER_CURL_CONSTANT(CURLE_FTP_ACCESS_DENIED); - REGISTER_CURL_CONSTANT(CURLE_FTP_BAD_DOWNLOAD_RESUME); - REGISTER_CURL_CONSTANT(CURLE_FTP_CANT_GET_HOST); - REGISTER_CURL_CONSTANT(CURLE_FTP_CANT_RECONNECT); - REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_GET_SIZE); - REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_RETR_FILE); - REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_SET_ASCII); - REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_SET_BINARY); - REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_STOR_FILE); - REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_USE_REST); - REGISTER_CURL_CONSTANT(CURLE_FTP_PARTIAL_FILE); - REGISTER_CURL_CONSTANT(CURLE_FTP_PORT_FAILED); - REGISTER_CURL_CONSTANT(CURLE_FTP_QUOTE_ERROR); - REGISTER_CURL_CONSTANT(CURLE_FTP_USER_PASSWORD_INCORRECT); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_227_FORMAT); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_PASS_REPLY); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_PASV_REPLY); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_SERVER_REPLY); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_USER_REPLY); - REGISTER_CURL_CONSTANT(CURLE_FTP_WRITE_ERROR); - REGISTER_CURL_CONSTANT(CURLE_FUNCTION_NOT_FOUND); - REGISTER_CURL_CONSTANT(CURLE_GOT_NOTHING); - REGISTER_CURL_CONSTANT(CURLE_HTTP_NOT_FOUND); - REGISTER_CURL_CONSTANT(CURLE_HTTP_PORT_FAILED); - REGISTER_CURL_CONSTANT(CURLE_HTTP_POST_ERROR); - REGISTER_CURL_CONSTANT(CURLE_HTTP_RANGE_ERROR); - REGISTER_CURL_CONSTANT(CURLE_HTTP_RETURNED_ERROR); - REGISTER_CURL_CONSTANT(CURLE_LDAP_CANNOT_BIND); - REGISTER_CURL_CONSTANT(CURLE_LDAP_SEARCH_FAILED); - REGISTER_CURL_CONSTANT(CURLE_LIBRARY_NOT_FOUND); - REGISTER_CURL_CONSTANT(CURLE_MALFORMAT_USER); - REGISTER_CURL_CONSTANT(CURLE_OBSOLETE); - REGISTER_CURL_CONSTANT(CURLE_OK); - REGISTER_CURL_CONSTANT(CURLE_OPERATION_TIMEDOUT); - REGISTER_CURL_CONSTANT(CURLE_OPERATION_TIMEOUTED); - REGISTER_CURL_CONSTANT(CURLE_OUT_OF_MEMORY); - REGISTER_CURL_CONSTANT(CURLE_PARTIAL_FILE); - REGISTER_CURL_CONSTANT(CURLE_READ_ERROR); - REGISTER_CURL_CONSTANT(CURLE_RECV_ERROR); - REGISTER_CURL_CONSTANT(CURLE_SEND_ERROR); - REGISTER_CURL_CONSTANT(CURLE_SHARE_IN_USE); - REGISTER_CURL_CONSTANT(CURLE_SSL_CACERT); - REGISTER_CURL_CONSTANT(CURLE_SSL_CERTPROBLEM); - REGISTER_CURL_CONSTANT(CURLE_SSL_CIPHER); - REGISTER_CURL_CONSTANT(CURLE_SSL_CONNECT_ERROR); - REGISTER_CURL_CONSTANT(CURLE_SSL_ENGINE_NOTFOUND); - REGISTER_CURL_CONSTANT(CURLE_SSL_ENGINE_SETFAILED); - REGISTER_CURL_CONSTANT(CURLE_SSL_PEER_CERTIFICATE); -#if LIBCURL_VERSION_NUM >= 0x072700 /* Available since 7.39.0 */ - REGISTER_CURL_CONSTANT(CURLE_SSL_PINNEDPUBKEYNOTMATCH); -#endif - REGISTER_CURL_CONSTANT(CURLE_TELNET_OPTION_SYNTAX); - REGISTER_CURL_CONSTANT(CURLE_TOO_MANY_REDIRECTS); - REGISTER_CURL_CONSTANT(CURLE_UNKNOWN_TELNET_OPTION); - REGISTER_CURL_CONSTANT(CURLE_UNSUPPORTED_PROTOCOL); - REGISTER_CURL_CONSTANT(CURLE_URL_MALFORMAT); - REGISTER_CURL_CONSTANT(CURLE_URL_MALFORMAT_USER); - REGISTER_CURL_CONSTANT(CURLE_WRITE_ERROR); - - /* cURL info constants */ - REGISTER_CURL_CONSTANT(CURLINFO_CONNECT_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_LENGTH_DOWNLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_LENGTH_UPLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_TYPE); - REGISTER_CURL_CONSTANT(CURLINFO_EFFECTIVE_URL); - REGISTER_CURL_CONSTANT(CURLINFO_FILETIME); - REGISTER_CURL_CONSTANT(CURLINFO_HEADER_OUT); - REGISTER_CURL_CONSTANT(CURLINFO_HEADER_SIZE); - REGISTER_CURL_CONSTANT(CURLINFO_HTTP_CODE); - REGISTER_CURL_CONSTANT(CURLINFO_LASTONE); - REGISTER_CURL_CONSTANT(CURLINFO_NAMELOOKUP_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_PRETRANSFER_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_PRIVATE); - REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_COUNT); - REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_REQUEST_SIZE); - REGISTER_CURL_CONSTANT(CURLINFO_SIZE_DOWNLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_SIZE_UPLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_SPEED_DOWNLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_SPEED_UPLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_SSL_VERIFYRESULT); - REGISTER_CURL_CONSTANT(CURLINFO_STARTTRANSFER_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_TOTAL_TIME); -#if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ - REGISTER_CURL_CONSTANT(CURLINFO_EFFECTIVE_METHOD); -#endif - - /* Other */ - REGISTER_CURL_CONSTANT(CURLMSG_DONE); - REGISTER_CURL_CONSTANT(CURLVERSION_NOW); - - /* Curl Multi Constants */ - REGISTER_CURL_CONSTANT(CURLM_BAD_EASY_HANDLE); - REGISTER_CURL_CONSTANT(CURLM_BAD_HANDLE); - REGISTER_CURL_CONSTANT(CURLM_CALL_MULTI_PERFORM); - REGISTER_CURL_CONSTANT(CURLM_INTERNAL_ERROR); - REGISTER_CURL_CONSTANT(CURLM_OK); - REGISTER_CURL_CONSTANT(CURLM_OUT_OF_MEMORY); -#if LIBCURL_VERSION_NUM >= 0x072001 /* Available since 7.32.1 */ - REGISTER_CURL_CONSTANT(CURLM_ADDED_ALREADY); -#endif - - /* Curl proxy constants */ - REGISTER_CURL_CONSTANT(CURLPROXY_HTTP); - REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4); - REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5); - - /* Curl Share constants */ - REGISTER_CURL_CONSTANT(CURLSHOPT_NONE); - REGISTER_CURL_CONSTANT(CURLSHOPT_SHARE); - REGISTER_CURL_CONSTANT(CURLSHOPT_UNSHARE); - - /* Curl Http Version constants (CURLOPT_HTTP_VERSION) */ - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_1_0); - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_1_1); - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_NONE); - - /* Curl Lock constants */ - REGISTER_CURL_CONSTANT(CURL_LOCK_DATA_COOKIE); - REGISTER_CURL_CONSTANT(CURL_LOCK_DATA_DNS); - REGISTER_CURL_CONSTANT(CURL_LOCK_DATA_SSL_SESSION); - - /* Curl NETRC constants (CURLOPT_NETRC) */ - REGISTER_CURL_CONSTANT(CURL_NETRC_IGNORED); - REGISTER_CURL_CONSTANT(CURL_NETRC_OPTIONAL); - REGISTER_CURL_CONSTANT(CURL_NETRC_REQUIRED); - - /* Curl SSL Version constants (CURLOPT_SSLVERSION) */ - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_DEFAULT); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_SSLv2); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_SSLv3); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_TLSv1); - - /* Curl TIMECOND constants (CURLOPT_TIMECONDITION) */ - REGISTER_CURL_CONSTANT(CURL_TIMECOND_IFMODSINCE); - REGISTER_CURL_CONSTANT(CURL_TIMECOND_IFUNMODSINCE); - REGISTER_CURL_CONSTANT(CURL_TIMECOND_LASTMOD); - REGISTER_CURL_CONSTANT(CURL_TIMECOND_NONE); - - /* Curl version constants */ - REGISTER_CURL_CONSTANT(CURL_VERSION_ASYNCHDNS); - REGISTER_CURL_CONSTANT(CURL_VERSION_CONV); - REGISTER_CURL_CONSTANT(CURL_VERSION_DEBUG); - REGISTER_CURL_CONSTANT(CURL_VERSION_GSSNEGOTIATE); - REGISTER_CURL_CONSTANT(CURL_VERSION_IDN); - REGISTER_CURL_CONSTANT(CURL_VERSION_IPV6); - REGISTER_CURL_CONSTANT(CURL_VERSION_KERBEROS4); - REGISTER_CURL_CONSTANT(CURL_VERSION_LARGEFILE); - REGISTER_CURL_CONSTANT(CURL_VERSION_LIBZ); - REGISTER_CURL_CONSTANT(CURL_VERSION_NTLM); - REGISTER_CURL_CONSTANT(CURL_VERSION_SPNEGO); - REGISTER_CURL_CONSTANT(CURL_VERSION_SSL); - REGISTER_CURL_CONSTANT(CURL_VERSION_SSPI); - - /* Available since 7.10.6 */ - REGISTER_CURL_CONSTANT(CURLOPT_HTTPAUTH); - /* http authentication options */ - REGISTER_CURL_CONSTANT(CURLAUTH_ANY); - REGISTER_CURL_CONSTANT(CURLAUTH_ANYSAFE); - REGISTER_CURL_CONSTANT(CURLAUTH_BASIC); - REGISTER_CURL_CONSTANT(CURLAUTH_DIGEST); - REGISTER_CURL_CONSTANT(CURLAUTH_GSSNEGOTIATE); - REGISTER_CURL_CONSTANT(CURLAUTH_NONE); - REGISTER_CURL_CONSTANT(CURLAUTH_NTLM); - - /* Available since 7.10.7 */ - REGISTER_CURL_CONSTANT(CURLINFO_HTTP_CONNECTCODE); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_CREATE_MISSING_DIRS); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYAUTH); - - /* Available since 7.10.8 */ - REGISTER_CURL_CONSTANT(CURLE_FILESIZE_EXCEEDED); - REGISTER_CURL_CONSTANT(CURLE_LDAP_INVALID_URL); - REGISTER_CURL_CONSTANT(CURLINFO_HTTPAUTH_AVAIL); - REGISTER_CURL_CONSTANT(CURLINFO_RESPONSE_CODE); - REGISTER_CURL_CONSTANT(CURLINFO_PROXYAUTH_AVAIL); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_RESPONSE_TIMEOUT); - REGISTER_CURL_CONSTANT(CURLOPT_IPRESOLVE); - REGISTER_CURL_CONSTANT(CURLOPT_MAXFILESIZE); - REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_V4); - REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_V6); - REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_WHATEVER); - - /* Available since 7.11.0 */ - REGISTER_CURL_CONSTANT(CURLE_FTP_SSL_FAILED); - REGISTER_CURL_CONSTANT(CURLFTPSSL_ALL); - REGISTER_CURL_CONSTANT(CURLFTPSSL_CONTROL); - REGISTER_CURL_CONSTANT(CURLFTPSSL_NONE); - REGISTER_CURL_CONSTANT(CURLFTPSSL_TRY); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_SSL); - REGISTER_CURL_CONSTANT(CURLOPT_NETRC_FILE); - - /* Available since 7.11.1 */ - REGISTER_CURL_CONSTANT(CURLOPT_MAXFILESIZE_LARGE); - - /* Available since 7.11.2 */ - REGISTER_CURL_CONSTANT(CURLOPT_TCP_NODELAY); - - /* Available since 7.12.2 */ - REGISTER_CURL_CONSTANT(CURLFTPAUTH_DEFAULT); - REGISTER_CURL_CONSTANT(CURLFTPAUTH_SSL); - REGISTER_CURL_CONSTANT(CURLFTPAUTH_TLS); - REGISTER_CURL_CONSTANT(CURLOPT_FTPSSLAUTH); - - /* Available since 7.13.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_FTP_ACCOUNT); - - /* Available since 7.12.2 */ - REGISTER_CURL_CONSTANT(CURLINFO_OS_ERRNO); - - /* Available since 7.12.3 */ - REGISTER_CURL_CONSTANT(CURLINFO_NUM_CONNECTS); - REGISTER_CURL_CONSTANT(CURLINFO_SSL_ENGINES); - - /* Available since 7.14.1 */ - REGISTER_CURL_CONSTANT(CURLINFO_COOKIELIST); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIELIST); - REGISTER_CURL_CONSTANT(CURLOPT_IGNORE_CONTENT_LENGTH); - - /* Available since 7.15.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_FTP_SKIP_PASV_IP); - - /* Available since 7.15.1 */ - REGISTER_CURL_CONSTANT(CURLOPT_FTP_FILEMETHOD); - - /* Available since 7.15.2 */ - REGISTER_CURL_CONSTANT(CURLOPT_CONNECT_ONLY); - REGISTER_CURL_CONSTANT(CURLOPT_LOCALPORT); - REGISTER_CURL_CONSTANT(CURLOPT_LOCALPORTRANGE); - - /* Available since 7.15.3 */ - REGISTER_CURL_CONSTANT(CURLFTPMETHOD_DEFAULT); - REGISTER_CURL_CONSTANT(CURLFTPMETHOD_MULTICWD); - REGISTER_CURL_CONSTANT(CURLFTPMETHOD_NOCWD); - REGISTER_CURL_CONSTANT(CURLFTPMETHOD_SINGLECWD); - - /* Available since 7.15.4 */ - REGISTER_CURL_CONSTANT(CURLINFO_FTP_ENTRY_PATH); - - /* Available since 7.15.5 */ - REGISTER_CURL_CONSTANT(CURLOPT_FTP_ALTERNATIVE_TO_USER); - REGISTER_CURL_CONSTANT(CURLOPT_MAX_RECV_SPEED_LARGE); - REGISTER_CURL_CONSTANT(CURLOPT_MAX_SEND_SPEED_LARGE); - - /* Available since 7.16.0 */ - REGISTER_CURL_CONSTANT(CURLE_SSL_CACERT_BADFILE); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_SESSIONID_CACHE); - REGISTER_CURL_CONSTANT(CURLMOPT_PIPELINING); - - /* Available since 7.16.1 */ - REGISTER_CURL_CONSTANT(CURLE_SSH); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_SSL_CCC); - REGISTER_CURL_CONSTANT(CURLOPT_SSH_AUTH_TYPES); - REGISTER_CURL_CONSTANT(CURLOPT_SSH_PRIVATE_KEYFILE); - REGISTER_CURL_CONSTANT(CURLOPT_SSH_PUBLIC_KEYFILE); - REGISTER_CURL_CONSTANT(CURLFTPSSL_CCC_ACTIVE); - REGISTER_CURL_CONSTANT(CURLFTPSSL_CCC_NONE); - REGISTER_CURL_CONSTANT(CURLFTPSSL_CCC_PASSIVE); - - /* Available since 7.16.2 */ - REGISTER_CURL_CONSTANT(CURLOPT_CONNECTTIMEOUT_MS); - REGISTER_CURL_CONSTANT(CURLOPT_HTTP_CONTENT_DECODING); - REGISTER_CURL_CONSTANT(CURLOPT_HTTP_TRANSFER_DECODING); - REGISTER_CURL_CONSTANT(CURLOPT_TIMEOUT_MS); - - /* Available since 7.16.3 */ - REGISTER_CURL_CONSTANT(CURLMOPT_MAXCONNECTS); - - /* Available since 7.16.4 */ - REGISTER_CURL_CONSTANT(CURLOPT_KRBLEVEL); - REGISTER_CURL_CONSTANT(CURLOPT_NEW_DIRECTORY_PERMS); - REGISTER_CURL_CONSTANT(CURLOPT_NEW_FILE_PERMS); - - /* Available since 7.17.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_APPEND); - REGISTER_CURL_CONSTANT(CURLOPT_DIRLISTONLY); - REGISTER_CURL_CONSTANT(CURLOPT_USE_SSL); - /* Curl SSL Constants */ - REGISTER_CURL_CONSTANT(CURLUSESSL_ALL); - REGISTER_CURL_CONSTANT(CURLUSESSL_CONTROL); - REGISTER_CURL_CONSTANT(CURLUSESSL_NONE); - REGISTER_CURL_CONSTANT(CURLUSESSL_TRY); - - /* Available since 7.17.1 */ - REGISTER_CURL_CONSTANT(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5); - - /* Available since 7.18.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_TRANSFER_MODE); - REGISTER_CURL_CONSTANT(CURLPAUSE_ALL); - REGISTER_CURL_CONSTANT(CURLPAUSE_CONT); - REGISTER_CURL_CONSTANT(CURLPAUSE_RECV); - REGISTER_CURL_CONSTANT(CURLPAUSE_RECV_CONT); - REGISTER_CURL_CONSTANT(CURLPAUSE_SEND); - REGISTER_CURL_CONSTANT(CURLPAUSE_SEND_CONT); - REGISTER_CURL_CONSTANT(CURL_READFUNC_PAUSE); - REGISTER_CURL_CONSTANT(CURL_WRITEFUNC_PAUSE); - - REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4A); - REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5_HOSTNAME); - - /* Available since 7.18.2 */ - REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_URL); - - /* Available since 7.19.0 */ - REGISTER_CURL_CONSTANT(CURLINFO_APPCONNECT_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_PRIMARY_IP); - - REGISTER_CURL_CONSTANT(CURLOPT_ADDRESS_SCOPE); - REGISTER_CURL_CONSTANT(CURLOPT_CRLFILE); - REGISTER_CURL_CONSTANT(CURLOPT_ISSUERCERT); - REGISTER_CURL_CONSTANT(CURLOPT_KEYPASSWD); - - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_ANY); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_DEFAULT); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_HOST); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_KEYBOARD); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_NONE); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_PASSWORD); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_PUBLICKEY); - - /* Available since 7.19.1 */ - REGISTER_CURL_CONSTANT(CURLINFO_CERTINFO); - REGISTER_CURL_CONSTANT(CURLOPT_CERTINFO); - REGISTER_CURL_CONSTANT(CURLOPT_PASSWORD); - REGISTER_CURL_CONSTANT(CURLOPT_POSTREDIR); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYPASSWORD); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYUSERNAME); - REGISTER_CURL_CONSTANT(CURLOPT_USERNAME); - REGISTER_CURL_CONSTANT(CURL_REDIR_POST_301); - REGISTER_CURL_CONSTANT(CURL_REDIR_POST_302); - REGISTER_CURL_CONSTANT(CURL_REDIR_POST_ALL); - - /* Available since 7.19.3 */ - REGISTER_CURL_CONSTANT(CURLAUTH_DIGEST_IE); - - /* Available since 7.19.4 */ - REGISTER_CURL_CONSTANT(CURLINFO_CONDITION_UNMET); - - REGISTER_CURL_CONSTANT(CURLOPT_NOPROXY); - REGISTER_CURL_CONSTANT(CURLOPT_PROTOCOLS); - REGISTER_CURL_CONSTANT(CURLOPT_REDIR_PROTOCOLS); - REGISTER_CURL_CONSTANT(CURLOPT_SOCKS5_GSSAPI_NEC); - REGISTER_CURL_CONSTANT(CURLOPT_SOCKS5_GSSAPI_SERVICE); - REGISTER_CURL_CONSTANT(CURLOPT_TFTP_BLKSIZE); - - REGISTER_CURL_CONSTANT(CURLPROTO_ALL); - REGISTER_CURL_CONSTANT(CURLPROTO_DICT); - REGISTER_CURL_CONSTANT(CURLPROTO_FILE); - REGISTER_CURL_CONSTANT(CURLPROTO_FTP); - REGISTER_CURL_CONSTANT(CURLPROTO_FTPS); - REGISTER_CURL_CONSTANT(CURLPROTO_HTTP); - REGISTER_CURL_CONSTANT(CURLPROTO_HTTPS); - REGISTER_CURL_CONSTANT(CURLPROTO_LDAP); - REGISTER_CURL_CONSTANT(CURLPROTO_LDAPS); - REGISTER_CURL_CONSTANT(CURLPROTO_SCP); - REGISTER_CURL_CONSTANT(CURLPROTO_SFTP); - REGISTER_CURL_CONSTANT(CURLPROTO_TELNET); - REGISTER_CURL_CONSTANT(CURLPROTO_TFTP); - - REGISTER_CURL_CONSTANT(CURLPROXY_HTTP_1_0); - - REGISTER_CURL_CONSTANT(CURLFTP_CREATE_DIR); - REGISTER_CURL_CONSTANT(CURLFTP_CREATE_DIR_NONE); - REGISTER_CURL_CONSTANT(CURLFTP_CREATE_DIR_RETRY); - - /* Available since 7.19.6 */ - REGISTER_CURL_CONSTANT(CURL_VERSION_CURLDEBUG); - REGISTER_CURL_CONSTANT(CURLOPT_SSH_KNOWNHOSTS); - - /* Available since 7.20.0 */ - REGISTER_CURL_CONSTANT(CURLINFO_RTSP_CLIENT_CSEQ); - REGISTER_CURL_CONSTANT(CURLINFO_RTSP_CSEQ_RECV); - REGISTER_CURL_CONSTANT(CURLINFO_RTSP_SERVER_CSEQ); - REGISTER_CURL_CONSTANT(CURLINFO_RTSP_SESSION_ID); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_USE_PRET); - REGISTER_CURL_CONSTANT(CURLOPT_MAIL_FROM); - REGISTER_CURL_CONSTANT(CURLOPT_MAIL_RCPT); - REGISTER_CURL_CONSTANT(CURLOPT_RTSP_CLIENT_CSEQ); - REGISTER_CURL_CONSTANT(CURLOPT_RTSP_REQUEST); - REGISTER_CURL_CONSTANT(CURLOPT_RTSP_SERVER_CSEQ); - REGISTER_CURL_CONSTANT(CURLOPT_RTSP_SESSION_ID); - REGISTER_CURL_CONSTANT(CURLOPT_RTSP_STREAM_URI); - REGISTER_CURL_CONSTANT(CURLOPT_RTSP_TRANSPORT); - REGISTER_CURL_CONSTANT(CURLPROTO_IMAP); - REGISTER_CURL_CONSTANT(CURLPROTO_IMAPS); - REGISTER_CURL_CONSTANT(CURLPROTO_POP3); - REGISTER_CURL_CONSTANT(CURLPROTO_POP3S); - REGISTER_CURL_CONSTANT(CURLPROTO_RTSP); - REGISTER_CURL_CONSTANT(CURLPROTO_SMTP); - REGISTER_CURL_CONSTANT(CURLPROTO_SMTPS); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_ANNOUNCE); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_DESCRIBE); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_GET_PARAMETER); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_OPTIONS); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_PAUSE); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_PLAY); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_RECEIVE); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_RECORD); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_SET_PARAMETER); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_SETUP); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_TEARDOWN); - - /* Available since 7.21.0 */ - REGISTER_CURL_CONSTANT(CURLINFO_LOCAL_IP); - REGISTER_CURL_CONSTANT(CURLINFO_LOCAL_PORT); - REGISTER_CURL_CONSTANT(CURLINFO_PRIMARY_PORT); - REGISTER_CURL_CONSTANT(CURLOPT_FNMATCH_FUNCTION); - REGISTER_CURL_CONSTANT(CURLOPT_WILDCARDMATCH); - REGISTER_CURL_CONSTANT(CURLPROTO_RTMP); - REGISTER_CURL_CONSTANT(CURLPROTO_RTMPE); - REGISTER_CURL_CONSTANT(CURLPROTO_RTMPS); - REGISTER_CURL_CONSTANT(CURLPROTO_RTMPT); - REGISTER_CURL_CONSTANT(CURLPROTO_RTMPTE); - REGISTER_CURL_CONSTANT(CURLPROTO_RTMPTS); - REGISTER_CURL_CONSTANT(CURL_FNMATCHFUNC_FAIL); - REGISTER_CURL_CONSTANT(CURL_FNMATCHFUNC_MATCH); - REGISTER_CURL_CONSTANT(CURL_FNMATCHFUNC_NOMATCH); - - /* Available since 7.21.2 */ - REGISTER_CURL_CONSTANT(CURLPROTO_GOPHER); - - /* Available since 7.21.3 */ - REGISTER_CURL_CONSTANT(CURLAUTH_ONLY); - REGISTER_CURL_CONSTANT(CURLOPT_RESOLVE); - - /* Available since 7.21.4 */ - REGISTER_CURL_CONSTANT(CURLOPT_TLSAUTH_PASSWORD); - REGISTER_CURL_CONSTANT(CURLOPT_TLSAUTH_TYPE); - REGISTER_CURL_CONSTANT(CURLOPT_TLSAUTH_USERNAME); - REGISTER_CURL_CONSTANT(CURL_TLSAUTH_SRP); - REGISTER_CURL_CONSTANT(CURL_VERSION_TLSAUTH_SRP); - - /* Available since 7.21.6 */ - REGISTER_CURL_CONSTANT(CURLOPT_ACCEPT_ENCODING); - REGISTER_CURL_CONSTANT(CURLOPT_TRANSFER_ENCODING); - - /* Available since 7.22.0 */ - REGISTER_CURL_CONSTANT(CURLAUTH_NTLM_WB); - REGISTER_CURL_CONSTANT(CURLGSSAPI_DELEGATION_FLAG); - REGISTER_CURL_CONSTANT(CURLGSSAPI_DELEGATION_POLICY_FLAG); - REGISTER_CURL_CONSTANT(CURLOPT_GSSAPI_DELEGATION); - REGISTER_CURL_CONSTANT(CURL_VERSION_NTLM_WB); - - /* Available since 7.24.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_ACCEPTTIMEOUT_MS); - REGISTER_CURL_CONSTANT(CURLOPT_DNS_SERVERS); - - /* Available since 7.25.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_MAIL_AUTH); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_OPTIONS); - REGISTER_CURL_CONSTANT(CURLOPT_TCP_KEEPALIVE); - REGISTER_CURL_CONSTANT(CURLOPT_TCP_KEEPIDLE); - REGISTER_CURL_CONSTANT(CURLOPT_TCP_KEEPINTVL); - REGISTER_CURL_CONSTANT(CURLSSLOPT_ALLOW_BEAST); - - /* Available since 7.25.1 */ - REGISTER_CURL_CONSTANT(CURL_REDIR_POST_303); - - /* Available since 7.28.0 */ - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_AGENT); - -#if LIBCURL_VERSION_NUM >= 0x071e00 /* Available since 7.30.0 */ - REGISTER_CURL_CONSTANT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE); - REGISTER_CURL_CONSTANT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE); - REGISTER_CURL_CONSTANT(CURLMOPT_MAX_HOST_CONNECTIONS); - REGISTER_CURL_CONSTANT(CURLMOPT_MAX_PIPELINE_LENGTH); - REGISTER_CURL_CONSTANT(CURLMOPT_MAX_TOTAL_CONNECTIONS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x071f00 /* Available since 7.31.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_SASL_IR); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_DNS_INTERFACE); - REGISTER_CURL_CONSTANT(CURLOPT_DNS_LOCAL_IP4); - REGISTER_CURL_CONSTANT(CURLOPT_DNS_LOCAL_IP6); - REGISTER_CURL_CONSTANT(CURLOPT_XOAUTH2_BEARER); - - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2_0); - REGISTER_CURL_CONSTANT(CURL_VERSION_HTTP2); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_LOGIN_OPTIONS); - - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_TLSv1_0); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_TLSv1_1); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_TLSv1_2); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072400 /* Available since 7.36.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_EXPECT_100_TIMEOUT_MS); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_ENABLE_ALPN); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_ENABLE_NPN); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ - REGISTER_CURL_CONSTANT(CURLHEADER_SEPARATE); - REGISTER_CURL_CONSTANT(CURLHEADER_UNIFIED); - REGISTER_CURL_CONSTANT(CURLOPT_HEADEROPT); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYHEADER); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072600 /* Available since 7.38.0 */ - REGISTER_CURL_CONSTANT(CURLAUTH_NEGOTIATE); - REGISTER_CURL_CONSTANT(CURL_VERSION_GSSAPI); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072700 /* Available since 7.39.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_PINNEDPUBLICKEY); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_UNIX_SOCKET_PATH); - REGISTER_CURL_CONSTANT(CURLPROTO_SMB); - REGISTER_CURL_CONSTANT(CURLPROTO_SMBS); - REGISTER_CURL_CONSTANT(CURL_VERSION_KERBEROS5); - REGISTER_CURL_CONSTANT(CURL_VERSION_UNIX_SOCKETS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072900 /* Available since 7.41.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_SSL_VERIFYSTATUS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072a00 /* Available since 7.42.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_PATH_AS_IS); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_FALSESTART); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2); - - REGISTER_CURL_CONSTANT(CURLOPT_PIPEWAIT); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SERVICE_NAME); - REGISTER_CURL_CONSTANT(CURLOPT_SERVICE_NAME); - - REGISTER_CURL_CONSTANT(CURLPIPE_NOTHING); - REGISTER_CURL_CONSTANT(CURLPIPE_HTTP1); - REGISTER_CURL_CONSTANT(CURLPIPE_MULTIPLEX); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072c00 /* Available since 7.44.0 */ - REGISTER_CURL_CONSTANT(CURLSSLOPT_NO_REVOKE); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072d00 /* Available since 7.45.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_DEFAULT_PROTOCOL); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072e00 /* Available since 7.46.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_STREAM_WEIGHT); - REGISTER_CURL_CONSTANT(CURLMOPT_PUSHFUNCTION); - REGISTER_CURL_CONSTANT(CURL_PUSH_OK); - REGISTER_CURL_CONSTANT(CURL_PUSH_DENY); -#endif - -#if LIBCURL_VERSION_NUM >= 0x072f00 /* Available since 7.47.0 */ - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2TLS); - REGISTER_CURL_CONSTANT(CURL_VERSION_PSL); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073000 /* Available since 7.48.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_TFTP_NO_OPTIONS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE); - REGISTER_CURL_CONSTANT(CURLOPT_CONNECT_TO); - REGISTER_CURL_CONSTANT(CURLOPT_TCP_FASTOPEN); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073200 /* Available since 7.50.0 */ - REGISTER_CURL_CONSTANT(CURLINFO_HTTP_VERSION); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073300 /* Available since 7.51.0 */ - REGISTER_CURL_CONSTANT(CURLE_WEIRD_SERVER_REPLY); - REGISTER_CURL_CONSTANT(CURLOPT_KEEP_SENDING_ON_ERROR); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073400 /* Available since 7.52.0 */ - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_TLSv1_3); - REGISTER_CURL_CONSTANT(CURL_VERSION_HTTPS_PROXY); - REGISTER_CURL_CONSTANT(CURLINFO_PROTOCOL); - REGISTER_CURL_CONSTANT(CURLINFO_PROXY_SSL_VERIFYRESULT); - REGISTER_CURL_CONSTANT(CURLINFO_SCHEME); - REGISTER_CURL_CONSTANT(CURLOPT_PRE_PROXY); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_CAINFO); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_CAPATH); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_CRLFILE); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_KEYPASSWD); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_PINNEDPUBLICKEY); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSL_CIPHER_LIST); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSL_OPTIONS); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSL_VERIFYHOST); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSL_VERIFYPEER); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSLCERT); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSLCERTTYPE); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSLKEY); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSLKEYTYPE); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSLVERSION); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_TLSAUTH_PASSWORD); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_TLSAUTH_TYPE); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_TLSAUTH_USERNAME); - REGISTER_CURL_CONSTANT(CURLPROXY_HTTPS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073500 /* Available since 7.53.0 */ - REGISTER_CURL_CONSTANT(CURL_MAX_READ_SIZE); - REGISTER_CURL_CONSTANT(CURLOPT_ABSTRACT_UNIX_SOCKET); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073600 /* Available since 7.54.0 */ - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_MAX_DEFAULT); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_MAX_NONE); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_MAX_TLSv1_0); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_MAX_TLSv1_1); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_MAX_TLSv1_2); - REGISTER_CURL_CONSTANT(CURL_SSLVERSION_MAX_TLSv1_3); - REGISTER_CURL_CONSTANT(CURLOPT_SUPPRESS_CONNECT_HEADERS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073601 /* Available since 7.54.1 */ - REGISTER_CURL_CONSTANT(CURLAUTH_GSSAPI); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073700 /* Available since 7.55.0 */ - REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_LENGTH_DOWNLOAD_T); - REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_LENGTH_UPLOAD_T); - REGISTER_CURL_CONSTANT(CURLINFO_SIZE_DOWNLOAD_T); - REGISTER_CURL_CONSTANT(CURLINFO_SIZE_UPLOAD_T); - REGISTER_CURL_CONSTANT(CURLINFO_SPEED_DOWNLOAD_T); - REGISTER_CURL_CONSTANT(CURLINFO_SPEED_UPLOAD_T); - REGISTER_CURL_CONSTANT(CURLOPT_REQUEST_TARGET); - REGISTER_CURL_CONSTANT(CURLOPT_SOCKS5_AUTH); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073800 /* Available since 7.56.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_SSH_COMPRESSION); - REGISTER_CURL_CONSTANT(CURL_VERSION_MULTI_SSL); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073900 /* Available since 7.57.0 */ - REGISTER_CURL_CONSTANT(CURL_VERSION_BROTLI); - REGISTER_CURL_CONSTANT(CURL_LOCK_DATA_CONNECT); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073a00 /* Available since 7.58.0 */ - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_GSSAPI); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073b00 /* Available since 7.59.0 */ - REGISTER_CURL_CONSTANT(CURLINFO_FILETIME_T); - REGISTER_CURL_CONSTANT(CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS); - REGISTER_CURL_CONSTANT(CURLOPT_TIMEVALUE_LARGE); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073c00 /* Available since 7.60.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_DNS_SHUFFLE_ADDRESSES); - REGISTER_CURL_CONSTANT(CURLOPT_HAPROXYPROTOCOL); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */ - REGISTER_CURL_CONSTANT(CURL_LOCK_DATA_PSL); - REGISTER_CURL_CONSTANT(CURLAUTH_BEARER); - REGISTER_CURL_CONSTANT(CURLINFO_APPCONNECT_TIME_T); - REGISTER_CURL_CONSTANT(CURLINFO_CONNECT_TIME_T); - REGISTER_CURL_CONSTANT(CURLINFO_NAMELOOKUP_TIME_T); - REGISTER_CURL_CONSTANT(CURLINFO_PRETRANSFER_TIME_T); - REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_TIME_T); - REGISTER_CURL_CONSTANT(CURLINFO_STARTTRANSFER_TIME_T); - REGISTER_CURL_CONSTANT(CURLINFO_TOTAL_TIME_T); - REGISTER_CURL_CONSTANT(CURLOPT_DISALLOW_USERNAME_IN_URL); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_TLS13_CIPHERS); - REGISTER_CURL_CONSTANT(CURLOPT_TLS13_CIPHERS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x073E00 /* Available since 7.62.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_DOH_URL); - REGISTER_CURL_CONSTANT(CURLOPT_UPKEEP_INTERVAL_MS); - REGISTER_CURL_CONSTANT(CURLOPT_UPLOAD_BUFFERSIZE); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074000 /* Available since 7.64.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_HTTP09_ALLOWED); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ - REGISTER_CURL_CONSTANT(CURLALTSVC_H1); - REGISTER_CURL_CONSTANT(CURLALTSVC_H2); - REGISTER_CURL_CONSTANT(CURLALTSVC_H3); - REGISTER_CURL_CONSTANT(CURLALTSVC_READONLYFILE); - REGISTER_CURL_CONSTANT(CURLOPT_ALTSVC); - REGISTER_CURL_CONSTANT(CURLOPT_ALTSVC_CTRL); - REGISTER_CURL_CONSTANT(CURL_VERSION_ALTSVC); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074100 /* Available since 7.65.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_MAXAGE_CONN); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074200 /* Available since 7.66.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_SASL_AUTHZID); - REGISTER_CURL_CONSTANT(CURL_VERSION_HTTP3); - REGISTER_CURL_CONSTANT(CURLINFO_RETRY_AFTER); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074300 /* Available since 7.67.0 */ - REGISTER_CURL_CONSTANT(CURLMOPT_MAX_CONCURRENT_STREAMS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074400 /* Available since 7.68.0 */ - REGISTER_CURL_CONSTANT(CURLSSLOPT_NO_PARTIALCHAIN); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074500 /* Available since 7.69.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_MAIL_RCPT_ALLLOWFAILS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074600 /* Available since 7.70.0 */ - REGISTER_CURL_CONSTANT(CURLSSLOPT_REVOKE_BEST_EFFORT); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_ISSUERCERT_BLOB); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_ISSUERCERT); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_ISSUERCERT_BLOB); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSLCERT_BLOB); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SSLKEY_BLOB); - REGISTER_CURL_CONSTANT(CURLOPT_SSLCERT_BLOB); - REGISTER_CURL_CONSTANT(CURLOPT_SSLKEY_BLOB); - - REGISTER_CURL_CONSTANT(CURLPROTO_MQTT); - - REGISTER_CURL_CONSTANT(CURLSSLOPT_NATIVE_CA); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ - REGISTER_CURL_CONSTANT(CURL_VERSION_UNICODE); - REGISTER_CURL_CONSTANT(CURL_VERSION_ZSTD); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ - REGISTER_CURL_CONSTANT(CURLE_PROXY); - REGISTER_CURL_CONSTANT(CURLINFO_PROXY_ERROR); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_EC_CURVES); - REGISTER_CURL_CONSTANT(CURLPX_BAD_ADDRESS_TYPE); - REGISTER_CURL_CONSTANT(CURLPX_BAD_VERSION); - REGISTER_CURL_CONSTANT(CURLPX_CLOSED); - REGISTER_CURL_CONSTANT(CURLPX_GSSAPI); - REGISTER_CURL_CONSTANT(CURLPX_GSSAPI_PERMSG); - REGISTER_CURL_CONSTANT(CURLPX_GSSAPI_PROTECTION); - REGISTER_CURL_CONSTANT(CURLPX_IDENTD); - REGISTER_CURL_CONSTANT(CURLPX_IDENTD_DIFFER); - REGISTER_CURL_CONSTANT(CURLPX_LONG_HOSTNAME); - REGISTER_CURL_CONSTANT(CURLPX_LONG_PASSWD); - REGISTER_CURL_CONSTANT(CURLPX_LONG_USER); - REGISTER_CURL_CONSTANT(CURLPX_NO_AUTH); - REGISTER_CURL_CONSTANT(CURLPX_OK); - REGISTER_CURL_CONSTANT(CURLPX_RECV_ADDRESS); - REGISTER_CURL_CONSTANT(CURLPX_RECV_AUTH); - REGISTER_CURL_CONSTANT(CURLPX_RECV_CONNECT); - REGISTER_CURL_CONSTANT(CURLPX_RECV_REQACK); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_COMMAND_NOT_SUPPORTED); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_CONNECTION_REFUSED); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_GENERAL_SERVER_FAILURE); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_HOST_UNREACHABLE); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_NETWORK_UNREACHABLE); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_NOT_ALLOWED); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_TTL_EXPIRED); - REGISTER_CURL_CONSTANT(CURLPX_REPLY_UNASSIGNED); - REGISTER_CURL_CONSTANT(CURLPX_REQUEST_FAILED); - REGISTER_CURL_CONSTANT(CURLPX_RESOLVE_HOST); - REGISTER_CURL_CONSTANT(CURLPX_SEND_AUTH); - REGISTER_CURL_CONSTANT(CURLPX_SEND_CONNECT); - REGISTER_CURL_CONSTANT(CURLPX_SEND_REQUEST); - REGISTER_CURL_CONSTANT(CURLPX_UNKNOWN_FAIL); - REGISTER_CURL_CONSTANT(CURLPX_UNKNOWN_MODE); - REGISTER_CURL_CONSTANT(CURLPX_USER_REJECTED); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ - REGISTER_CURL_CONSTANT(CURLHSTS_ENABLE); - REGISTER_CURL_CONSTANT(CURLHSTS_READONLYFILE); - REGISTER_CURL_CONSTANT(CURLOPT_HSTS); - REGISTER_CURL_CONSTANT(CURLOPT_HSTS_CTRL); - REGISTER_CURL_CONSTANT(CURL_VERSION_HSTS); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074b00 /* Available since 7.75.0 */ - REGISTER_CURL_CONSTANT(CURLAUTH_AWS_SIGV4); - REGISTER_CURL_CONSTANT(CURLOPT_AWS_SIGV4); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ - REGISTER_CURL_CONSTANT(CURLINFO_REFERER); - REGISTER_CURL_CONSTANT(CURLOPT_DOH_SSL_VERIFYHOST); - REGISTER_CURL_CONSTANT(CURLOPT_DOH_SSL_VERIFYPEER); - REGISTER_CURL_CONSTANT(CURLOPT_DOH_SSL_VERIFYSTATUS); - REGISTER_CURL_CONSTANT(CURL_VERSION_GSASL); -#endif - -#if LIBCURL_VERSION_NUM >= 0x074d00 /* Available since 7.77.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_CAINFO_BLOB); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY_CAINFO_BLOB); - REGISTER_CURL_CONSTANT(CURLSSLOPT_AUTO_CLIENT_CERT); -#endif - -#if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ - REGISTER_CURL_CONSTANT(CURLOPT_MAXLIFETIME_CONN); - REGISTER_CURL_CONSTANT(CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256); -#endif - - REGISTER_CURL_CONSTANT(CURLOPT_SAFE_UPLOAD); + register_curl_symbols(module_number); #ifdef PHP_CURL_NEED_OPENSSL_TSL if (!CRYPTO_get_id_callback()) {