diff options
Diffstat (limited to 'ext/curl/interface.c')
| -rw-r--r-- | ext/curl/interface.c | 1899 |
1 files changed, 1264 insertions, 635 deletions
diff --git a/ext/curl/interface.c b/ext/curl/interface.c index b03f346b59..14836cc5ab 100644 --- a/ext/curl/interface.c +++ b/ext/curl/interface.c @@ -90,6 +90,7 @@ int le_curl; int le_curl_multi_handle; +int le_curl_share_handle; #ifdef PHP_CURL_NEED_OPENSSL_TSL /* {{{ */ static MUTEX_T *php_curl_openssl_tsl = NULL; @@ -261,7 +262,6 @@ int _php_curl_verify_handlers(php_curl *ch, int reporterror TSRMLS_DC) /* {{{ */ ch->handlers->write->stream = NULL; ch->handlers->write->method = PHP_CURL_STDOUT; - ch->handlers->write->type = PHP_CURL_ASCII; curl_easy_setopt(ch->cp, CURLOPT_FILE, (void *) ch); } } @@ -314,6 +314,24 @@ ZEND_BEGIN_ARG_INFO(arginfo_curl_close, 0) ZEND_ARG_INFO(0, ch) ZEND_END_ARG_INFO() +#if LIBCURL_VERSION_NUM >= 0x070c01 /* 7.12.1 */ +ZEND_BEGIN_ARG_INFO(arginfo_curl_reset, 0) + ZEND_ARG_INFO(0, ch) +ZEND_END_ARG_INFO() +#endif + +#if LIBCURL_VERSION_NUM > 0x070f03 /* 7.15.4 */ +ZEND_BEGIN_ARG_INFO(arginfo_curl_escape, 0) + ZEND_ARG_INFO(0, ch) + ZEND_ARG_INFO(0, str) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_curl_unescape, 0) + ZEND_ARG_INFO(0, ch) + ZEND_ARG_INFO(0, str) +ZEND_END_ARG_INFO() +#endif + ZEND_BEGIN_ARG_INFO(arginfo_curl_multi_init, 0) ZEND_END_ARG_INFO() @@ -349,6 +367,19 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO(arginfo_curl_multi_close, 0) ZEND_ARG_INFO(0, mh) ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_curl_share_init, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_curl_share_close, 0) + ZEND_ARG_INFO(0, sh) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_curl_share_setopt, 0) + ZEND_ARG_INFO(0, sh) + ZEND_ARG_INFO(0, option) + ZEND_ARG_INFO(0, value) +ZEND_END_ARG_INFO() /* }}} */ /* {{{ curl_functions[] @@ -364,6 +395,13 @@ const zend_function_entry curl_functions[] = { PHP_FE(curl_error, arginfo_curl_error) PHP_FE(curl_errno, arginfo_curl_errno) PHP_FE(curl_close, arginfo_curl_close) +#if LIBCURL_VERSION_NUM >= 0x070c01 /* 7.12.1 */ + PHP_FE(curl_reset, arginfo_curl_reset) +#endif +#if LIBCURL_VERSION_NUM >= 0x070f04 /* 7.15.4 */ + PHP_FE(curl_escape, arginfo_curl_escape) + PHP_FE(curl_unescape, arginfo_curl_unescape) +#endif PHP_FE(curl_multi_init, arginfo_curl_multi_init) PHP_FE(curl_multi_add_handle, arginfo_curl_multi_add_handle) PHP_FE(curl_multi_remove_handle, arginfo_curl_multi_remove_handle) @@ -372,6 +410,9 @@ const zend_function_entry curl_functions[] = { PHP_FE(curl_multi_getcontent, arginfo_curl_multi_getcontent) PHP_FE(curl_multi_info_read, arginfo_curl_multi_info_read) PHP_FE(curl_multi_close, arginfo_curl_multi_close) + PHP_FE(curl_share_init, arginfo_curl_share_init) + PHP_FE(curl_share_close, arginfo_curl_share_close) + PHP_FE(curl_share_setopt, arginfo_curl_share_setopt) PHP_FE_END }; /* }}} */ @@ -428,42 +469,40 @@ PHP_MINFO_FUNCTION(curl) unsigned int i; static const struct feat feats[] = { -#if LIBCURL_VERSION_NUM > 0x070a06 /* 7.10.7 */ +#if LIBCURL_VERSION_NUM >= 0x070a07 /* 7.10.7 */ {"AsynchDNS", CURL_VERSION_ASYNCHDNS}, #endif -#if LIBCURL_VERSION_NUM > 0x070a05 /* 7.10.6 */ +#if LIBCURL_VERSION_NUM >= 0x070f04 /* 7.15.4 */ + {"CharConv", CURL_VERSION_CONV}, +#endif +#if LIBCURL_VERSION_NUM >= 0x070a06 /* 7.10.6 */ {"Debug", CURL_VERSION_DEBUG}, {"GSS-Negotiate", CURL_VERSION_GSSNEGOTIATE}, #endif -#if LIBCURL_VERSION_NUM > 0x070b02 /* 7.12.0 */ +#if LIBCURL_VERSION_NUM >= 0x070c00 /* 7.12.0 */ {"IDN", CURL_VERSION_IDN}, #endif -#ifdef CURL_VERSION_IPV6 {"IPv6", CURL_VERSION_IPV6}, -#endif -#if LIBCURL_VERSION_NUM > 0x070b00 /* 7.11.1 */ + {"krb4", CURL_VERSION_KERBEROS4}, +#if LIBCURL_VERSION_NUM >= 0x070b01 /* 7.11.1 */ {"Largefile", CURL_VERSION_LARGEFILE}, #endif -#if LIBCURL_VERSION_NUM > 0x070a05 /* 7.10.6 */ + {"libz", CURL_VERSION_LIBZ}, +#if LIBCURL_VERSION_NUM >= 0x070a06 /* 7.10.6 */ {"NTLM", CURL_VERSION_NTLM}, #endif -#if LIBCURL_VERSION_NUM > 0x070a07 /* 7.10.8 */ +#if LIBCURL_VERSION_NUM >= 0x071600 /* 7.22.0 */ + {"NTLMWB", CURL_VERSION_NTLM_WB}, +#endif +#if LIBCURL_VERSION_NUM >= 0x070a08 /* 7.10.8 */ {"SPNEGO", CURL_VERSION_SPNEGO}, #endif -#ifdef CURL_VERSION_SSL {"SSL", CURL_VERSION_SSL}, -#endif -#if LIBCURL_VERSION_NUM > 0x070d01 /* 7.13.2 */ +#if LIBCURL_VERSION_NUM >= 0x070d02 /* 7.13.2 */ {"SSPI", CURL_VERSION_SSPI}, #endif -#ifdef CURL_VERSION_KERBEROS4 - {"krb4", CURL_VERSION_KERBEROS4}, -#endif -#ifdef CURL_VERSION_LIBZ - {"libz", CURL_VERSION_LIBZ}, -#endif -#if LIBCURL_VERSION_NUM > 0x070f03 /* 7.15.4 */ - {"CharConv", CURL_VERSION_CONV}, +#if LIBCURL_VERSION_NUM >= 0x071504 /* 7.21.4 */ + {"TLS-SRP", CURL_VERSION_TLSAUTH_SRP}, #endif {NULL, 0} }; @@ -528,6 +567,7 @@ PHP_MINIT_FUNCTION(curl) { le_curl = zend_register_list_destructors_ex(_php_curl_close, NULL, "curl", module_number); le_curl_multi_handle = zend_register_list_destructors_ex(_php_curl_multi_close, NULL, "curl_multi", module_number); + le_curl_share_handle = zend_register_list_destructors_ex(_php_curl_share_close, NULL, "curl_share", module_number); REGISTER_INI_ENTRIES(); @@ -536,348 +576,547 @@ PHP_MINIT_FUNCTION(curl) of options and which version they were introduced */ /* Constants for curl_setopt() */ -#if LIBCURL_VERSION_NUM > 0x070a07 /* CURLOPT_IPRESOLVE is available since curl 7.10.8 */ - REGISTER_CURL_CONSTANT(CURLOPT_IPRESOLVE); - REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_WHATEVER); - REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_V4); - REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_V6); -#endif - REGISTER_CURL_CONSTANT(CURLOPT_DNS_USE_GLOBAL_CACHE); + 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_CLOSEPOLICY); + 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_PORT); + 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_READDATA); - REGISTER_CURL_CONSTANT(CURLOPT_INFILE); - REGISTER_CURL_CONSTANT(CURLOPT_INFILESIZE); - REGISTER_CURL_CONSTANT(CURLOPT_URL); - REGISTER_CURL_CONSTANT(CURLOPT_PROXY); - REGISTER_CURL_CONSTANT(CURLOPT_VERBOSE); + 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_NOPROGRESS); - REGISTER_CURL_CONSTANT(CURLOPT_PROGRESSFUNCTION); + 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_FAILONERROR); - REGISTER_CURL_CONSTANT(CURLOPT_UPLOAD); + REGISTER_CURL_CONSTANT(CURLOPT_NOPROGRESS); + REGISTER_CURL_CONSTANT(CURLOPT_NOSIGNAL); + REGISTER_CURL_CONSTANT(CURLOPT_PORT); REGISTER_CURL_CONSTANT(CURLOPT_POST); - REGISTER_CURL_CONSTANT(CURLOPT_FTPLISTONLY); - REGISTER_CURL_CONSTANT(CURLOPT_FTPAPPEND); - REGISTER_CURL_CONSTANT(CURLOPT_NETRC); - REGISTER_CURL_CONSTANT(CURLOPT_FOLLOWLOCATION); -#if CURLOPT_FTPASCII != 0 - REGISTER_CURL_CONSTANT(CURLOPT_FTPASCII); -#endif - REGISTER_CURL_CONSTANT(CURLOPT_PUT); -#if CURLOPT_MUTE != 0 - REGISTER_CURL_CONSTANT(CURLOPT_MUTE); -#endif - REGISTER_CURL_CONSTANT(CURLOPT_USERPWD); + 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_TIMEOUT); -#if LIBCURL_VERSION_NUM > 0x071002 - REGISTER_CURL_CONSTANT(CURLOPT_TIMEOUT_MS); -#endif - REGISTER_CURL_CONSTANT(CURLOPT_POSTFIELDS); + REGISTER_CURL_CONSTANT(CURLOPT_READDATA); + REGISTER_CURL_CONSTANT(CURLOPT_READFUNCTION); REGISTER_CURL_CONSTANT(CURLOPT_REFERER); - REGISTER_CURL_CONSTANT(CURLOPT_USERAGENT); - REGISTER_CURL_CONSTANT(CURLOPT_FTPPORT); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_USE_EPSV); - REGISTER_CURL_CONSTANT(CURLOPT_LOW_SPEED_LIMIT); - REGISTER_CURL_CONSTANT(CURLOPT_LOW_SPEED_TIME); REGISTER_CURL_CONSTANT(CURLOPT_RESUME_FROM); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIE); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIESESSION); - REGISTER_CURL_CONSTANT(CURLOPT_AUTOREFERER); + REGISTER_CURL_CONSTANT(CURLOPT_RETURNTRANSFER); + REGISTER_CURL_CONSTANT(CURLOPT_SHARE); REGISTER_CURL_CONSTANT(CURLOPT_SSLCERT); REGISTER_CURL_CONSTANT(CURLOPT_SSLCERTPASSWD); - REGISTER_CURL_CONSTANT(CURLOPT_WRITEHEADER); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_VERIFYHOST); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIEFILE); + 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_TIMECONDITION); + REGISTER_CURL_CONSTANT(CURLOPT_TIMEOUT); REGISTER_CURL_CONSTANT(CURLOPT_TIMEVALUE); - REGISTER_CURL_CONSTANT(CURLOPT_CUSTOMREQUEST); - REGISTER_CURL_CONSTANT(CURLOPT_STDERR); REGISTER_CURL_CONSTANT(CURLOPT_TRANSFERTEXT); - REGISTER_CURL_CONSTANT(CURLOPT_RETURNTRANSFER); - REGISTER_CURL_CONSTANT(CURLOPT_QUOTE); - REGISTER_CURL_CONSTANT(CURLOPT_POSTQUOTE); - REGISTER_CURL_CONSTANT(CURLOPT_INTERFACE); - REGISTER_CURL_CONSTANT(CURLOPT_KRB4LEVEL); - REGISTER_CURL_CONSTANT(CURLOPT_HTTPPROXYTUNNEL); - REGISTER_CURL_CONSTANT(CURLOPT_FILETIME); - REGISTER_CURL_CONSTANT(CURLOPT_WRITEFUNCTION); - REGISTER_CURL_CONSTANT(CURLOPT_READFUNCTION); -#if CURLOPT_PASSWDFUNCTION != 0 - REGISTER_CURL_CONSTANT(CURLOPT_PASSWDFUNCTION); -#endif - REGISTER_CURL_CONSTANT(CURLOPT_HEADERFUNCTION); - REGISTER_CURL_CONSTANT(CURLOPT_MAXREDIRS); - REGISTER_CURL_CONSTANT(CURLOPT_MAXCONNECTS); - REGISTER_CURL_CONSTANT(CURLOPT_CLOSEPOLICY); - REGISTER_CURL_CONSTANT(CURLOPT_FRESH_CONNECT); - REGISTER_CURL_CONSTANT(CURLOPT_FORBID_REUSE); - REGISTER_CURL_CONSTANT(CURLOPT_RANDOM_FILE); - REGISTER_CURL_CONSTANT(CURLOPT_EGDSOCKET); - REGISTER_CURL_CONSTANT(CURLOPT_CONNECTTIMEOUT); -#if LIBCURL_VERSION_NUM > 0x071002 - REGISTER_CURL_CONSTANT(CURLOPT_CONNECTTIMEOUT_MS); -#endif - REGISTER_CURL_CONSTANT(CURLOPT_SSL_VERIFYPEER); - REGISTER_CURL_CONSTANT(CURLOPT_CAINFO); - REGISTER_CURL_CONSTANT(CURLOPT_CAPATH); - REGISTER_CURL_CONSTANT(CURLOPT_COOKIEJAR); - REGISTER_CURL_CONSTANT(CURLOPT_SSL_CIPHER_LIST); - REGISTER_CURL_CONSTANT(CURLOPT_BINARYTRANSFER); - REGISTER_CURL_CONSTANT(CURLOPT_NOSIGNAL); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYTYPE); - REGISTER_CURL_CONSTANT(CURLOPT_BUFFERSIZE); - REGISTER_CURL_CONSTANT(CURLOPT_HTTPGET); - REGISTER_CURL_CONSTANT(CURLOPT_HTTP_VERSION); - REGISTER_CURL_CONSTANT(CURLOPT_SSLKEY); - REGISTER_CURL_CONSTANT(CURLOPT_SSLKEYTYPE); - REGISTER_CURL_CONSTANT(CURLOPT_SSLKEYPASSWD); - REGISTER_CURL_CONSTANT(CURLOPT_SSLENGINE); - REGISTER_CURL_CONSTANT(CURLOPT_SSLENGINE_DEFAULT); - REGISTER_CURL_CONSTANT(CURLOPT_SSLCERTTYPE); - REGISTER_CURL_CONSTANT(CURLOPT_CRLF); - REGISTER_CURL_CONSTANT(CURLOPT_ENCODING); - REGISTER_CURL_CONSTANT(CURLOPT_PROXYPORT); REGISTER_CURL_CONSTANT(CURLOPT_UNRESTRICTED_AUTH); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_USE_EPRT); -#if LIBCURL_VERSION_NUM > 0x070b01 /* CURLOPT_TCP_NODELAY is available since curl 7.11.2 */ - REGISTER_CURL_CONSTANT(CURLOPT_TCP_NODELAY); -#endif - REGISTER_CURL_CONSTANT(CURLOPT_HTTP200ALIASES); - REGISTER_CURL_CONSTANT(CURL_TIMECOND_IFMODSINCE); - REGISTER_CURL_CONSTANT(CURL_TIMECOND_IFUNMODSINCE); - REGISTER_CURL_CONSTANT(CURL_TIMECOND_LASTMOD); - -#if LIBCURL_VERSION_NUM > 0x070f04 /* CURLOPT_MAX_RECV_SPEED_LARGE & CURLOPT_MAX_SEND_SPEED_LARGE are available since curl 7.15.5 */ - REGISTER_CURL_CONSTANT(CURLOPT_MAX_RECV_SPEED_LARGE); - REGISTER_CURL_CONSTANT(CURLOPT_MAX_SEND_SPEED_LARGE); -#endif - -#if LIBCURL_VERSION_NUM > 0x070a05 /* CURLOPT_HTTPAUTH is available since curl 7.10.6 */ - REGISTER_CURL_CONSTANT(CURLOPT_HTTPAUTH); - /* http authentication options */ - REGISTER_CURL_CONSTANT(CURLAUTH_BASIC); - REGISTER_CURL_CONSTANT(CURLAUTH_DIGEST); - REGISTER_CURL_CONSTANT(CURLAUTH_GSSNEGOTIATE); - REGISTER_CURL_CONSTANT(CURLAUTH_NTLM); - REGISTER_CURL_CONSTANT(CURLAUTH_ANY); - REGISTER_CURL_CONSTANT(CURLAUTH_ANYSAFE); -#endif - -#if LIBCURL_VERSION_NUM > 0x070a06 /* CURLOPT_PROXYAUTH & CURLOPT_FTP_CREATE_MISSING_DIRS are available since curl 7.10.7 */ - REGISTER_CURL_CONSTANT(CURLOPT_PROXYAUTH); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_CREATE_MISSING_DIRS); -#endif - - REGISTER_CURL_CONSTANT(CURLOPT_PRIVATE); + 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); /* Constants effecting the way CURLOPT_CLOSEPOLICY works */ + REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_CALLBACK); REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_LEAST_RECENTLY_USED); REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_LEAST_TRAFFIC); - REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_SLOWEST); - REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_CALLBACK); REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_OLDEST); + REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_SLOWEST); - /* Info constants */ - REGISTER_CURL_CONSTANT(CURLINFO_EFFECTIVE_URL); - REGISTER_CURL_CONSTANT(CURLINFO_HTTP_CODE); - REGISTER_CURL_CONSTANT(CURLINFO_HEADER_SIZE); - REGISTER_CURL_CONSTANT(CURLINFO_REQUEST_SIZE); - REGISTER_CURL_CONSTANT(CURLINFO_TOTAL_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_NAMELOOKUP_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_CONNECT_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_PRETRANSFER_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_SIZE_UPLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_SIZE_DOWNLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_SPEED_DOWNLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_SPEED_UPLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_FILETIME); - REGISTER_CURL_CONSTANT(CURLINFO_SSL_VERIFYRESULT); - REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_LENGTH_DOWNLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_LENGTH_UPLOAD); - REGISTER_CURL_CONSTANT(CURLINFO_STARTTRANSFER_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_TYPE); - REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_TIME); - REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_COUNT); - REGISTER_CURL_CONSTANT(CURLINFO_HEADER_OUT); - REGISTER_CURL_CONSTANT(CURLINFO_PRIVATE); -#if LIBCURL_VERSION_NUM > 0x071301 - REGISTER_CURL_CONSTANT(CURLINFO_CERTINFO); -#endif -#if LIBCURL_VERSION_NUM >= 0x071202 - REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_URL); -#endif - - - /* cURL protocol constants (curl_version) */ - REGISTER_CURL_CONSTANT(CURL_VERSION_IPV6); - REGISTER_CURL_CONSTANT(CURL_VERSION_KERBEROS4); - REGISTER_CURL_CONSTANT(CURL_VERSION_SSL); - REGISTER_CURL_CONSTANT(CURL_VERSION_LIBZ); - - /* version constants */ - REGISTER_CURL_CONSTANT(CURLVERSION_NOW); - - /* Error Constants */ - REGISTER_CURL_CONSTANT(CURLE_OK); - REGISTER_CURL_CONSTANT(CURLE_UNSUPPORTED_PROTOCOL); - REGISTER_CURL_CONSTANT(CURLE_FAILED_INIT); - REGISTER_CURL_CONSTANT(CURLE_URL_MALFORMAT); - REGISTER_CURL_CONSTANT(CURLE_URL_MALFORMAT_USER); - REGISTER_CURL_CONSTANT(CURLE_COULDNT_RESOLVE_PROXY); - REGISTER_CURL_CONSTANT(CURLE_COULDNT_RESOLVE_HOST); + /* */ + 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_FUNCTION_ARGUMENT); + REGISTER_CURL_CONSTANT(CURLE_BAD_PASSWORD_ENTERED); REGISTER_CURL_CONSTANT(CURLE_COULDNT_CONNECT); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_SERVER_REPLY); + 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_USER_PASSWORD_INCORRECT); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_PASS_REPLY); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_USER_REPLY); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_PASV_REPLY); - REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_227_FORMAT); + 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_SET_BINARY); - REGISTER_CURL_CONSTANT(CURLE_PARTIAL_FILE); + REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_GET_SIZE); REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_RETR_FILE); - REGISTER_CURL_CONSTANT(CURLE_FTP_WRITE_ERROR); - REGISTER_CURL_CONSTANT(CURLE_FTP_QUOTE_ERROR); - REGISTER_CURL_CONSTANT(CURLE_HTTP_NOT_FOUND); - REGISTER_CURL_CONSTANT(CURLE_WRITE_ERROR); - REGISTER_CURL_CONSTANT(CURLE_MALFORMAT_USER); - REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_STOR_FILE); - REGISTER_CURL_CONSTANT(CURLE_READ_ERROR); - REGISTER_CURL_CONSTANT(CURLE_OUT_OF_MEMORY); - REGISTER_CURL_CONSTANT(CURLE_OPERATION_TIMEOUTED); REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_SET_ASCII); - REGISTER_CURL_CONSTANT(CURLE_FTP_PORT_FAILED); + 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_COULDNT_GET_SIZE); - REGISTER_CURL_CONSTANT(CURLE_HTTP_RANGE_ERROR); + 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_SSL_CONNECT_ERROR); - REGISTER_CURL_CONSTANT(CURLE_FTP_BAD_DOWNLOAD_RESUME); - REGISTER_CURL_CONSTANT(CURLE_FILE_COULDNT_READ_FILE); + REGISTER_CURL_CONSTANT(CURLE_HTTP_RANGE_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_FUNCTION_NOT_FOUND); - REGISTER_CURL_CONSTANT(CURLE_ABORTED_BY_CALLBACK); - REGISTER_CURL_CONSTANT(CURLE_BAD_FUNCTION_ARGUMENT); - REGISTER_CURL_CONSTANT(CURLE_BAD_CALLING_ORDER); - REGISTER_CURL_CONSTANT(CURLE_HTTP_PORT_FAILED); - REGISTER_CURL_CONSTANT(CURLE_BAD_PASSWORD_ENTERED); - REGISTER_CURL_CONSTANT(CURLE_TOO_MANY_REDIRECTS); - REGISTER_CURL_CONSTANT(CURLE_UNKNOWN_TELNET_OPTION); - REGISTER_CURL_CONSTANT(CURLE_TELNET_OPTION_SYNTAX); + REGISTER_CURL_CONSTANT(CURLE_MALFORMAT_USER); REGISTER_CURL_CONSTANT(CURLE_OBSOLETE); - REGISTER_CURL_CONSTANT(CURLE_SSL_PEER_CERTIFICATE); - REGISTER_CURL_CONSTANT(CURLE_GOT_NOTHING); - REGISTER_CURL_CONSTANT(CURLE_SSL_ENGINE_NOTFOUND); - REGISTER_CURL_CONSTANT(CURLE_SSL_ENGINE_SETFAILED); - REGISTER_CURL_CONSTANT(CURLE_SEND_ERROR); + REGISTER_CURL_CONSTANT(CURLE_OK); + 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_CACERT); - REGISTER_CURL_CONSTANT(CURLE_BAD_CONTENT_ENCODING); -#if LIBCURL_VERSION_NUM >= 0x070a08 - REGISTER_CURL_CONSTANT(CURLE_LDAP_INVALID_URL); - REGISTER_CURL_CONSTANT(CURLE_FILESIZE_EXCEEDED); -#endif -#if LIBCURL_VERSION_NUM >= 0x070b00 - REGISTER_CURL_CONSTANT(CURLE_FTP_SSL_FAILED); -#endif + 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); + 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_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); + + /* 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); + + /* Curl proxy constants */ REGISTER_CURL_CONSTANT(CURLPROXY_HTTP); REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4); REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5); - REGISTER_CURL_CONSTANT(CURL_NETRC_OPTIONAL); - REGISTER_CURL_CONSTANT(CURL_NETRC_IGNORED); - REGISTER_CURL_CONSTANT(CURL_NETRC_REQUIRED); + /* Curl Share constants */ + REGISTER_CURL_CONSTANT(CURLSHOPT_SHARE); + REGISTER_CURL_CONSTANT(CURLSHOPT_UNSHARE); - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_NONE); + /* 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); - REGISTER_CURL_CONSTANT(CURLM_CALL_MULTI_PERFORM); - REGISTER_CURL_CONSTANT(CURLM_OK); - REGISTER_CURL_CONSTANT(CURLM_BAD_HANDLE); - REGISTER_CURL_CONSTANT(CURLM_BAD_EASY_HANDLE); - REGISTER_CURL_CONSTANT(CURLM_OUT_OF_MEMORY); - REGISTER_CURL_CONSTANT(CURLM_INTERNAL_ERROR); + /* 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); - REGISTER_CURL_CONSTANT(CURLMSG_DONE); + /* Curl NETRC constants (CURLOPT_NETRC) */ + REGISTER_CURL_CONSTANT(CURL_NETRC_IGNORED); + REGISTER_CURL_CONSTANT(CURL_NETRC_OPTIONAL); + REGISTER_CURL_CONSTANT(CURL_NETRC_REQUIRED); -#if LIBCURL_VERSION_NUM >= 0x070c02 - REGISTER_CURL_CONSTANT(CURLOPT_FTPSSLAUTH); + /* 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); + + /* Curl version constants */ + REGISTER_CURL_CONSTANT(CURL_VERSION_IPV6); + REGISTER_CURL_CONSTANT(CURL_VERSION_KERBEROS4); + REGISTER_CURL_CONSTANT(CURL_VERSION_LIBZ); + REGISTER_CURL_CONSTANT(CURL_VERSION_SSL); + +#if LIBCURL_VERSION_NUM >= 0x070a06 /* 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070a07 /* Available since 7.10.7 */ + REGISTER_CURL_CONSTANT(CURLINFO_HTTP_CONNECTCODE); + REGISTER_CURL_CONSTANT(CURLOPT_FTP_CREATE_MISSING_DIRS); + REGISTER_CURL_CONSTANT(CURLOPT_PROXYAUTH); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070a08 /* 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070b00 /* 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070c02 /* 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); #endif -#if LIBCURL_VERSION_NUM > 0x070b00 - REGISTER_CURL_CONSTANT(CURLOPT_FTP_SSL); - REGISTER_CURL_CONSTANT(CURLFTPSSL_NONE); - REGISTER_CURL_CONSTANT(CURLFTPSSL_TRY); - REGISTER_CURL_CONSTANT(CURLFTPSSL_CONTROL); - REGISTER_CURL_CONSTANT(CURLFTPSSL_ALL); +#if LIBCURL_VERSION_NUM >= 0x070d00 /* Available since 7.13.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_FTP_ACCOUNT); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070b02 /* Available since 7.11.2 */ + REGISTER_CURL_CONSTANT(CURLOPT_TCP_NODELAY); #endif -#if LIBCURL_VERSION_NUM > 0x071301 - REGISTER_CURL_CONSTANT(CURLOPT_CERTINFO); - REGISTER_CURL_CONSTANT(CURLOPT_POSTREDIR); +#if LIBCURL_VERSION_NUM >= 0x070c02 /* Available since 7.12.2 */ + REGISTER_CURL_CONSTANT(CURLINFO_OS_ERRNO); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070c03 /* Available since 7.12.3 */ + REGISTER_CURL_CONSTANT(CURLINFO_NUM_CONNECTS); + REGISTER_CURL_CONSTANT(CURLINFO_SSL_ENGINES); #endif -/* SSH support works in 7.19.0+ using libssh2 */ -#if LIBCURL_VERSION_NUM >= 0x071300 - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_NONE); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_PUBLICKEY); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_PASSWORD); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_HOST); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_KEYBOARD); - REGISTER_CURL_CONSTANT(CURLSSH_AUTH_DEFAULT); - REGISTER_CURL_CONSTANT(CURLOPT_SSH_AUTH_TYPES); +#if LIBCURL_VERSION_NUM >= 0x070e01 /* Available since 7.14.1 */ + REGISTER_CURL_CONSTANT(CURLINFO_COOKIELIST); + REGISTER_CURL_CONSTANT(CURLOPT_COOKIELIST); + REGISTER_CURL_CONSTANT(CURLOPT_IGNORE_CONTENT_LENGTH); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070f00 /* Available since 7.15.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_FTP_SKIP_PASV_IP); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070f01 /* Available since 7.15.1 */ + REGISTER_CURL_CONSTANT(CURLOPT_FTP_FILEMETHOD); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070f02 /* Available since 7.15.2 */ + REGISTER_CURL_CONSTANT(CURLOPT_CONNECT_ONLY); + REGISTER_CURL_CONSTANT(CURLOPT_LOCALPORT); + REGISTER_CURL_CONSTANT(CURLOPT_LOCALPORTRANGE); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070f03 /* Available since 7.15.3 */ + REGISTER_CURL_CONSTANT(CURLFTPMETHOD_MULTICWD); + REGISTER_CURL_CONSTANT(CURLFTPMETHOD_NOCWD); + REGISTER_CURL_CONSTANT(CURLFTPMETHOD_SINGLECWD); +#endif + +#if LIBCURL_VERSION_NUM >- 0x070f04 /* Available since 7.15.4 */ + REGISTER_CURL_CONSTANT(CURLINFO_FTP_ENTRY_PATH); +#endif + +#if LIBCURL_VERSION_NUM >= 0x070f05 /* 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071000 /* Available since 7.16.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_SSL_SESSIONID_CACHE); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071001 /* Available since 7.16.1 */ + REGISTER_CURL_CONSTANT(CURLOPT_FTP_SSL_CCC); + REGISTER_CURL_CONSTANT(CURLFTPSSL_CCC_ACTIVE); + REGISTER_CURL_CONSTANT(CURLFTPSSL_CCC_NONE); + REGISTER_CURL_CONSTANT(CURLFTPSSL_CCC_PASSIVE); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071002 /* 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071004 /* Available since 7.16.4 */ + REGISTER_CURL_CONSTANT(CURLOPT_KRBLEVEL); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071100 /* Available since 7.17.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_APPEND); + REGISTER_CURL_CONSTANT(CURLOPT_DIRLISTONLY); + REGISTER_CURL_CONSTANT(CURLOPT_NEW_DIRECTORY_PERMS); + REGISTER_CURL_CONSTANT(CURLOPT_NEW_FILE_PERMS); + 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071200 /* Available since 7.18.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_PROXY_TRANSFER_MODE); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071202 /* Available since 7.18.2 */ + REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_URL); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071300 /* Available since 7.19.0 */ + REGISTER_CURL_CONSTANT(CURLE_SSH); + 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(CURLOPT_SSH_PUBLIC_KEYFILE); - REGISTER_CURL_CONSTANT(CURLOPT_SSH_PRIVATE_KEYFILE); + REGISTER_CURL_CONSTANT(CURLOPT_SSH_AUTH_TYPES); REGISTER_CURL_CONSTANT(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5); - REGISTER_CURL_CONSTANT(CURLE_SSH); + REGISTER_CURL_CONSTANT(CURLOPT_SSH_PRIVATE_KEYFILE); + REGISTER_CURL_CONSTANT(CURLOPT_SSH_PUBLIC_KEYFILE); + + 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); #endif -#if LIBCURL_VERSION_NUM >= 0x071304 - REGISTER_CURL_CONSTANT(CURLOPT_REDIR_PROTOCOLS); +#if LIBCURL_VERSION_NUM >= 0x071301 /* 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071303 /* Available since 7.19.3 */ + REGISTER_CURL_CONSTANT(CURLAUTH_DIGEST_IE); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071304 /* Available since 7.19.4 */ + REGISTER_CURL_CONSTANT(CURLINFO_CONDITION_UNMET); + + REGISTER_CURL_CONSTANT(CURLOPT_NOPROXY); REGISTER_CURL_CONSTANT(CURLOPT_PROTOCOLS); - REGISTER_CURL_CONSTANT(CURLPROTO_HTTP); - REGISTER_CURL_CONSTANT(CURLPROTO_HTTPS); + 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_LDAP); - REGISTER_CURL_CONSTANT(CURLPROTO_LDAPS); - REGISTER_CURL_CONSTANT(CURLPROTO_DICT); - REGISTER_CURL_CONSTANT(CURLPROTO_FILE); REGISTER_CURL_CONSTANT(CURLPROTO_TFTP); - REGISTER_CURL_CONSTANT(CURLPROTO_ALL); #endif -#if LIBCURL_VERSION_NUM >= 0x070f01 - REGISTER_CURL_CONSTANT(CURLOPT_FTP_FILEMETHOD); - REGISTER_CURL_CONSTANT(CURLOPT_FTP_SKIP_PASV_IP); +#if LIBCURL_VERSION_NUM >= 0x071306 /* Available since 7.19.6 */ + REGISTER_CURL_CONSTANT(CURLOPT_SSH_KNOWNHOSTS); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071400 /* 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_SETUP); + REGISTER_CURL_CONSTANT(CURL_RTSPREQ_SET_PARAMETER); + REGISTER_CURL_CONSTANT(CURL_RTSPREQ_TEARDOWN); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071500 /* 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071502 /* Available since 7.21.2 */ + REGISTER_CURL_CONSTANT(CURLPROTO_GOPHER); #endif -#if LIBCURL_VERSION_NUM >= 0x071001 - REGISTER_CURL_CONSTANT(CURLFTPMETHOD_MULTICWD); - REGISTER_CURL_CONSTANT(CURLFTPMETHOD_NOCWD); - REGISTER_CURL_CONSTANT(CURLFTPMETHOD_SINGLECWD); +#if LIBCURL_VERSION_NUM >= 0x071503 /* Available since 7.21.3 */ + REGISTER_CURL_CONSTANT(CURLAUTH_ONLY); + REGISTER_CURL_CONSTANT(CURLOPT_RESOLVE); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071504 /* 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); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071506 /* Available since 7.21.6 */ + REGISTER_CURL_CONSTANT(CURLOPT_ACCEPT_ENCODING); + REGISTER_CURL_CONSTANT(CURLOPT_TRANSFER_ENCODING); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071800 /* Available since 7.24.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_DNS_SERVERS); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071900 /* Available since 7.25.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_MAIL_AUTH); +#endif + +#if CURLOPT_FTPASCII != 0 + REGISTER_CURL_CONSTANT(CURLOPT_FTPASCII); +#endif +#if CURLOPT_MUTE != 0 + REGISTER_CURL_CONSTANT(CURLOPT_MUTE); +#endif +#if CURLOPT_PASSWDFUNCTION != 0 + REGISTER_CURL_CONSTANT(CURLOPT_PASSWDFUNCTION); #endif #ifdef PHP_CURL_NEED_OPENSSL_TSL @@ -906,7 +1145,6 @@ PHP_MINIT_FUNCTION(curl) } #ifdef PHP_CURL_URL_WRAPPERS -# if HAVE_CURL_VERSION_INFO { curl_version_info_data *info = curl_version_info(CURLVERSION_NOW); char **p = (char **)info->protocols; @@ -920,18 +1158,6 @@ PHP_MINIT_FUNCTION(curl) (void) *p++; } } -# else - php_unregister_url_stream_wrapper("http"); - php_register_url_stream_wrapper("http", &php_curl_wrapper TSRMLS_CC); - php_unregister_url_stream_wrapper("https"); - php_register_url_stream_wrapper("https", &php_curl_wrapper TSRMLS_CC); - php_unregister_url_stream_wrapper("ftp"); - php_register_url_stream_wrapper("ftp", &php_curl_wrapper TSRMLS_CC); - php_unregister_url_stream_wrapper("ftps"); - php_register_url_stream_wrapper("ftps", &php_curl_wrapper TSRMLS_CC); - php_unregister_url_stream_wrapper("ldap"); - php_register_url_stream_wrapper("ldap", &php_curl_wrapper TSRMLS_CC); -# endif #endif return SUCCESS; @@ -943,10 +1169,18 @@ PHP_MINIT_FUNCTION(curl) PHP_MSHUTDOWN_FUNCTION(curl) { #ifdef PHP_CURL_URL_WRAPPERS - php_unregister_url_stream_wrapper("http" TSRMLS_CC); - php_unregister_url_stream_wrapper("https" TSRMLS_CC); - php_unregister_url_stream_wrapper("ftp" TSRMLS_CC); - php_unregister_url_stream_wrapper("ldap" TSRMLS_CC); + { + curl_version_info_data *info = curl_version_info(CURLVERSION_NOW); + char **p = (char **)info->protocols; + + while (*p != NULL) { + /* Do not enable cURL "file" protocol and make sure cURL is always used when --with-curlwrappers is enabled */ + if (strncasecmp(*p, "file", sizeof("file")-1) != 0) { + php_unregister_url_stream_wrapper(*p TSRMLS_CC); + } + (void) *p++; + } + } #endif curl_global_cleanup(); #ifdef PHP_CURL_NEED_OPENSSL_TSL @@ -1045,13 +1279,77 @@ static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx) } /* }}} */ +#if LIBCURL_VERSION_NUM >= 0x071500 /* Available since 7.21.0 */ +/* {{{ curl_fnmatch + */ +static int curl_fnmatch(void *ctx, const char *pattern, const char *string) +{ + php_curl *ch = (php_curl *) ctx; + php_curl_fnmatch *t = ch->handlers->fnmatch; + int rval = CURL_FNMATCHFUNC_FAIL; + switch (t->method) { + case PHP_CURL_USER: { + zval **argv[3]; + zval *zhandle = NULL; + zval *zpattern = NULL; + zval *zstring = NULL; + zval *retval_ptr; + int error; + zend_fcall_info fci; + TSRMLS_FETCH_FROM_CTX(ch->thread_ctx); + + MAKE_STD_ZVAL(zhandle); + MAKE_STD_ZVAL(zpattern); + MAKE_STD_ZVAL(zstring); + + ZVAL_RESOURCE(zhandle, ch->id); + zend_list_addref(ch->id); + ZVAL_STRING(zpattern, pattern, 1); + ZVAL_STRING(zstring, string, 1); + + argv[0] = &zhandle; + argv[1] = &zpattern; + argv[2] = &zstring; + + fci.size = sizeof(fci); + fci.function_table = EG(function_table); + fci.function_name = t->func_name; + fci.object_ptr = NULL; + fci.retval_ptr_ptr = &retval_ptr; + fci.param_count = 3; + fci.params = argv; + fci.no_separation = 0; + fci.symbol_table = NULL; + + ch->in_callback = 1; + error = zend_call_function(&fci, &t->fci_cache TSRMLS_CC); + ch->in_callback = 0; + if (error == FAILURE) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot call the CURLOPT_FNMATCH_FUNCTION"); + } else if (retval_ptr) { + if (Z_TYPE_P(retval_ptr) != IS_LONG) { + convert_to_long_ex(&retval_ptr); + } + rval = Z_LVAL_P(retval_ptr); + zval_ptr_dtor(&retval_ptr); + } + zval_ptr_dtor(argv[0]); + zval_ptr_dtor(argv[1]); + zval_ptr_dtor(argv[2]); + break; + } + } + return rval; +} +/* }}} */ +#endif + /* {{{ curl_progress */ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow) { php_curl *ch = (php_curl *) clientp; php_curl_progress *t = ch->handlers->progress; - int length = -1; size_t rval = 0; #if PHP_CURL_DEBUG @@ -1061,7 +1359,8 @@ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double switch (t->method) { case PHP_CURL_USER: { - zval **argv[4]; + zval **argv[5]; + zval *handle = NULL; zval *zdltotal = NULL; zval *zdlnow = NULL; zval *zultotal = NULL; @@ -1071,27 +1370,31 @@ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double zend_fcall_info fci; TSRMLS_FETCH_FROM_CTX(ch->thread_ctx); + MAKE_STD_ZVAL(handle); MAKE_STD_ZVAL(zdltotal); MAKE_STD_ZVAL(zdlnow); MAKE_STD_ZVAL(zultotal); MAKE_STD_ZVAL(zulnow); + ZVAL_RESOURCE(handle, ch->id); + zend_list_addref(ch->id); ZVAL_LONG(zdltotal, (long) dltotal); ZVAL_LONG(zdlnow, (long) dlnow); ZVAL_LONG(zultotal, (long) ultotal); ZVAL_LONG(zulnow, (long) ulnow); - argv[0] = &zdltotal; - argv[1] = &zdlnow; - argv[2] = &zultotal; - argv[3] = &zulnow; + argv[0] = &handle; + argv[1] = &zdltotal; + argv[2] = &zdlnow; + argv[3] = &zultotal; + argv[4] = &zulnow; fci.size = sizeof(fci); fci.function_table = EG(function_table); fci.function_name = t->func_name; fci.object_ptr = NULL; fci.retval_ptr_ptr = &retval_ptr; - fci.param_count = 4; + fci.param_count = 5; fci.params = argv; fci.no_separation = 0; fci.symbol_table = NULL; @@ -1101,7 +1404,6 @@ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double ch->in_callback = 0; if (error == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot call the CURLOPT_PROGRESSFUNCTION"); - length = -1; } else if (retval_ptr) { if (Z_TYPE_P(retval_ptr) != IS_LONG) { convert_to_long_ex(&retval_ptr); @@ -1115,6 +1417,7 @@ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double zval_ptr_dtor(argv[1]); zval_ptr_dtor(argv[2]); zval_ptr_dtor(argv[3]); + zval_ptr_dtor(argv[4]); break; } } @@ -1415,7 +1718,10 @@ static void alloc_curl_handle(php_curl **ch) (*ch)->handlers->write = ecalloc(1, sizeof(php_curl_write)); (*ch)->handlers->write_header = ecalloc(1, sizeof(php_curl_write)); (*ch)->handlers->read = ecalloc(1, sizeof(php_curl_read)); - (*ch)->handlers->progress = ecalloc(1, sizeof(php_curl_progress)); + (*ch)->handlers->progress = NULL; +#if LIBCURL_VERSION_NUM >= 0x071500 /* Available since 7.21.0 */ + (*ch)->handlers->fnmatch = NULL; +#endif (*ch)->in_callback = 0; (*ch)->header.str_len = 0; @@ -1441,14 +1747,14 @@ static void split_certinfo(char *string, zval *hash) char *split; if(org) { - do { + do { char *key; char *val; char *tmp; - split = strstr(s, "; "); - if(split) - *split = '\0'; + split = strstr(s, "; "); + if(split) + *split = '\0'; key = s; tmp = memchr(key, '=', 64); @@ -1509,6 +1815,36 @@ static void create_certinfo(struct curl_certinfo *ci, zval *listcode TSRMLS_DC) /* }}} */ #endif +/* {{{ _php_curl_set_default_options() + Set default options for a handle */ +static void _php_curl_set_default_options(php_curl *ch) +{ + char *cainfo; + + curl_easy_setopt(ch->cp, CURLOPT_NOPROGRESS, 1); + curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 0); + curl_easy_setopt(ch->cp, CURLOPT_ERRORBUFFER, ch->err.str); + curl_easy_setopt(ch->cp, CURLOPT_WRITEFUNCTION, curl_write); + curl_easy_setopt(ch->cp, CURLOPT_FILE, (void *) ch); + curl_easy_setopt(ch->cp, CURLOPT_READFUNCTION, curl_read); + curl_easy_setopt(ch->cp, CURLOPT_INFILE, (void *) ch); + curl_easy_setopt(ch->cp, CURLOPT_HEADERFUNCTION, curl_write_header); + curl_easy_setopt(ch->cp, CURLOPT_WRITEHEADER, (void *) ch); + curl_easy_setopt(ch->cp, CURLOPT_DNS_USE_GLOBAL_CACHE, 1); + curl_easy_setopt(ch->cp, CURLOPT_DNS_CACHE_TIMEOUT, 120); + curl_easy_setopt(ch->cp, CURLOPT_MAXREDIRS, 20); /* prevent infinite redirects */ + + cainfo = INI_STR("curl.cainfo"); + if (cainfo && strlen(cainfo) > 0) { + curl_easy_setopt(ch->cp, CURLOPT_CAINFO, cainfo); + } + +#if defined(ZTS) + curl_easy_setopt(ch->cp, CURLOPT_NOSIGNAL, 1); +#endif +} +/* }}} */ + /* {{{ proto resource curl_init([string url]) Initialize a cURL session */ PHP_FUNCTION(curl_init) @@ -1518,7 +1854,6 @@ PHP_FUNCTION(curl_init) zval *clone; char *url = NULL; int url_len = 0; - char *cainfo; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &url, &url_len) == FAILURE) { return; @@ -1536,7 +1871,6 @@ PHP_FUNCTION(curl_init) ch->cp = cp; ch->handlers->write->method = PHP_CURL_STDOUT; - ch->handlers->write->type = PHP_CURL_ASCII; ch->handlers->read->method = PHP_CURL_DIRECT; ch->handlers->write_header->method = PHP_CURL_IGNORE; @@ -1545,27 +1879,7 @@ PHP_FUNCTION(curl_init) MAKE_STD_ZVAL(clone); ch->clone = clone; - curl_easy_setopt(ch->cp, CURLOPT_NOPROGRESS, 1); - curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 0); - curl_easy_setopt(ch->cp, CURLOPT_ERRORBUFFER, ch->err.str); - curl_easy_setopt(ch->cp, CURLOPT_WRITEFUNCTION, curl_write); - curl_easy_setopt(ch->cp, CURLOPT_FILE, (void *) ch); - curl_easy_setopt(ch->cp, CURLOPT_READFUNCTION, curl_read); - curl_easy_setopt(ch->cp, CURLOPT_INFILE, (void *) ch); - curl_easy_setopt(ch->cp, CURLOPT_HEADERFUNCTION, curl_write_header); - curl_easy_setopt(ch->cp, CURLOPT_WRITEHEADER, (void *) ch); - curl_easy_setopt(ch->cp, CURLOPT_DNS_USE_GLOBAL_CACHE, 1); - curl_easy_setopt(ch->cp, CURLOPT_DNS_CACHE_TIMEOUT, 120); - curl_easy_setopt(ch->cp, CURLOPT_MAXREDIRS, 20); /* prevent infinite redirects */ - - cainfo = INI_STR("curl.cainfo"); - if (cainfo && strlen(cainfo) > 0) { - curl_easy_setopt(ch->cp, CURLOPT_CAINFO, cainfo); - } - -#if defined(ZTS) - curl_easy_setopt(ch->cp, CURLOPT_NOSIGNAL, 1); -#endif + _php_curl_set_default_options(ch); if (url) { if (!php_curl_option_url(ch, url, url_len TSRMLS_CC)) { @@ -1610,7 +1924,6 @@ PHP_FUNCTION(curl_copy_handle) dupch->handlers->write->stream = ch->handlers->write->stream; } dupch->handlers->write->method = ch->handlers->write->method; - dupch->handlers->write->type = ch->handlers->write->type; if (ch->handlers->read->stream) { Z_ADDREF_P(ch->handlers->read->stream); } @@ -1645,18 +1958,34 @@ PHP_FUNCTION(curl_copy_handle) zval_add_ref(&ch->handlers->write_header->func_name); dupch->handlers->write_header->func_name = ch->handlers->write_header->func_name; } - - if (ch->handlers->progress->func_name) { - zval_add_ref(&ch->handlers->progress->func_name); - dupch->handlers->progress->func_name = ch->handlers->progress->func_name; - } - dupch->handlers->progress->method = ch->handlers->progress->method; curl_easy_setopt(dupch->cp, CURLOPT_ERRORBUFFER, dupch->err.str); curl_easy_setopt(dupch->cp, CURLOPT_FILE, (void *) dupch); curl_easy_setopt(dupch->cp, CURLOPT_INFILE, (void *) dupch); curl_easy_setopt(dupch->cp, CURLOPT_WRITEHEADER, (void *) dupch); - curl_easy_setopt(dupch->cp, CURLOPT_PROGRESSDATA, (void *) dupch); + + if (ch->handlers->progress) { + dupch->handlers->progress = ecalloc(1, sizeof(php_curl_progress)); + if (ch->handlers->progress->func_name) { + zval_add_ref(&ch->handlers->progress->func_name); + dupch->handlers->progress->func_name = ch->handlers->progress->func_name; + } + dupch->handlers->progress->method = ch->handlers->progress->method; + curl_easy_setopt(dupch->cp, CURLOPT_PROGRESSDATA, (void *) dupch); + } + +/* Available since 7.21.0 */ +#if LIBCURL_VERSION_NUM >= 0x071500 + if (ch->handlers->fnmatch) { + dupch->handlers->fnmatch = ecalloc(1, sizeof(php_curl_fnmatch)); + if (ch->handlers->fnmatch->func_name) { + zval_add_ref(&ch->handlers->fnmatch->func_name); + dupch->handlers->fnmatch->func_name = ch->handlers->fnmatch->func_name; + } + dupch->handlers->fnmatch->method = ch->handlers->fnmatch->method; + curl_easy_setopt(dupch->cp, CURLOPT_FNMATCH_DATA, (void *) dupch); + } +#endif efree(dupch->to_free); dupch->to_free = ch->to_free; @@ -1675,90 +2004,139 @@ static int _php_curl_setopt(php_curl *ch, long option, zval **zvalue, zval *retu CURLcode error=CURLE_OK; switch (option) { - case CURLOPT_INFILESIZE: - case CURLOPT_VERBOSE: - case CURLOPT_HEADER: - case CURLOPT_NOPROGRESS: - case CURLOPT_NOBODY: + /* Long options */ + case CURLOPT_AUTOREFERER: + case CURLOPT_BUFFERSIZE: + case CURLOPT_CLOSEPOLICY: + case CURLOPT_CONNECTTIMEOUT: + case CURLOPT_COOKIESESSION: + case CURLOPT_CRLF: + case CURLOPT_DNS_CACHE_TIMEOUT: + case CURLOPT_DNS_USE_GLOBAL_CACHE: case CURLOPT_FAILONERROR: - case CURLOPT_UPLOAD: - case CURLOPT_POST: - case CURLOPT_FTPLISTONLY: - case CURLOPT_FTPAPPEND: - case CURLOPT_NETRC: - case CURLOPT_PUT: -#if CURLOPT_MUTE != 0 - case CURLOPT_MUTE: -#endif - case CURLOPT_TIMEOUT: -#if LIBCURL_VERSION_NUM > 0x071002 - case CURLOPT_TIMEOUT_MS: -#endif + case CURLOPT_FILETIME: + case CURLOPT_FORBID_REUSE: + case CURLOPT_FRESH_CONNECT: + case CURLOPT_FTP_USE_EPRT: case CURLOPT_FTP_USE_EPSV: + case CURLOPT_HEADER: + case CURLOPT_HTTPGET: + case CURLOPT_HTTPPROXYTUNNEL: + case CURLOPT_HTTP_VERSION: + case CURLOPT_INFILESIZE: case CURLOPT_LOW_SPEED_LIMIT: - case CURLOPT_SSLVERSION: case CURLOPT_LOW_SPEED_TIME: - case CURLOPT_RESUME_FROM: - case CURLOPT_TIMEVALUE: - case CURLOPT_TIMECONDITION: - case CURLOPT_TRANSFERTEXT: - case CURLOPT_HTTPPROXYTUNNEL: - case CURLOPT_FILETIME: - case CURLOPT_MAXREDIRS: case CURLOPT_MAXCONNECTS: - case CURLOPT_CLOSEPOLICY: - case CURLOPT_FRESH_CONNECT: - case CURLOPT_FORBID_REUSE: - case CURLOPT_CONNECTTIMEOUT: -#if LIBCURL_VERSION_NUM > 0x071002 - case CURLOPT_CONNECTTIMEOUT_MS: -#endif - case CURLOPT_SSL_VERIFYHOST: - case CURLOPT_SSL_VERIFYPEER: - case CURLOPT_DNS_USE_GLOBAL_CACHE: + case CURLOPT_MAXREDIRS: + case CURLOPT_NETRC: + case CURLOPT_NOBODY: + case CURLOPT_NOPROGRESS: case CURLOPT_NOSIGNAL: - case CURLOPT_PROXYTYPE: - case CURLOPT_BUFFERSIZE: - case CURLOPT_HTTPGET: - case CURLOPT_HTTP_VERSION: - case CURLOPT_CRLF: - case CURLOPT_DNS_CACHE_TIMEOUT: + case CURLOPT_PORT: + case CURLOPT_POST: case CURLOPT_PROXYPORT: - case CURLOPT_FTP_USE_EPRT: -#if LIBCURL_VERSION_NUM > 0x070a05 /* CURLOPT_HTTPAUTH is available since curl 7.10.6 */ + case CURLOPT_PROXYTYPE: + case CURLOPT_PUT: + case CURLOPT_RESUME_FROM: + case CURLOPT_SSLVERSION: + case CURLOPT_SSL_VERIFYHOST: + case CURLOPT_SSL_VERIFYPEER: + case CURLOPT_TIMECONDITION: + case CURLOPT_TIMEOUT: + case CURLOPT_TIMEVALUE: + case CURLOPT_TRANSFERTEXT: + case CURLOPT_UNRESTRICTED_AUTH: + case CURLOPT_UPLOAD: + case CURLOPT_VERBOSE: +#if LIBCURL_VERSION_NUM >= 0x070a06 /* Available since 7.10.6 */ case CURLOPT_HTTPAUTH: #endif -#if LIBCURL_VERSION_NUM > 0x070a06 /* CURLOPT_PROXYAUTH & CURLOPT_FTP_CREATE_MISSING_DIRS are available since curl 7.10.7 */ - case CURLOPT_PROXYAUTH: +#if LIBCURL_VERSION_NUM >= 0x070a07 /* Available since 7.10.7 */ case CURLOPT_FTP_CREATE_MISSING_DIRS: + case CURLOPT_PROXYAUTH: #endif - -#if LIBCURL_VERSION_NUM >= 0x070c02 +#if LIBCURL_VERSION_NUM >= 0x070a08 /* Available since 7.10.8 */ + case CURLOPT_FTP_RESPONSE_TIMEOUT: + case CURLOPT_IPRESOLVE: + case CURLOPT_MAXFILESIZE: +#endif +#if LIBCURL_VERSION_NUM >= 0x070b02 /* Available since 7.11.2 */ + case CURLOPT_TCP_NODELAY: +#endif +#if LIBCURL_VERSION_NUM >= 0x070c02 /* Available since 7.12.2 */ case CURLOPT_FTPSSLAUTH: #endif -#if LIBCURL_VERSION_NUM > 0x070b00 +#if LIBCURL_VERSION_NUM >= 0x070e01 /* Available since 7.14.1 */ + case CURLOPT_IGNORE_CONTENT_LENGTH: +#endif +#if LIBCURL_VERSION_NUM >= 0x070f00 /* Available since 7.15.0 */ + case CURLOPT_FTP_SKIP_PASV_IP: +#endif +#if LIBCURL_VERSION_NUM >= 0x070f01 /* Available since 7.15.1 */ + case CURLOPT_FTP_FILEMETHOD: +#endif +#if LIBCURL_VERSION_NUM >= 0x070f02 /* Available since 7.15.2 */ + case CURLOPT_CONNECT_ONLY: + case CURLOPT_LOCALPORT: + case CURLOPT_LOCALPORTRANGE: +#endif +#if LIBCURL_VERSION_NUM >= 0x071000 /* Available since 7.16.0 */ + case CURLOPT_SSL_SESSIONID_CACHE: +#endif +#if LIBCURL_VERSION_NUM >= 0x071001 /* Available since 7.16.1 */ + case CURLOPT_FTP_SSL_CCC: +#endif +#if LIBCURL_VERSION_NUM >= 0x071002 /* Available since 7.16.2 */ + case CURLOPT_CONNECTTIMEOUT_MS: + case CURLOPT_HTTP_CONTENT_DECODING: + case CURLOPT_HTTP_TRANSFER_DECODING: + case CURLOPT_TIMEOUT_MS: +#endif +#if LIBCURL_VERSION_NUM >= 0x071100 /* Available since 7.17.0 */ + case CURLOPT_USE_SSL: +#elif LIBCURL_VERSION_NUM >= 0x070b00 /* Available since 7.11.0 */ case CURLOPT_FTP_SSL: +#endif +#if LIBCURL_VERSION_NUM >= 0x071100 /* Available since 7.17.0 */ + case CURLOPT_APPEND: + case CURLOPT_DIRLISTONLY: + case CURLOPT_NEW_DIRECTORY_PERMS: + case CURLOPT_NEW_FILE_PERMS: +#else + case CURLOPT_FTPAPPEND: + case CURLOPT_FTPLISTONLY: #endif - case CURLOPT_UNRESTRICTED_AUTH: - case CURLOPT_PORT: - case CURLOPT_AUTOREFERER: - case CURLOPT_COOKIESESSION: -#if LIBCURL_VERSION_NUM > 0x070b01 /* CURLOPT_TCP_NODELAY is available since curl 7.11.2 */ - case CURLOPT_TCP_NODELAY: +#if LIBCURL_VERSION_NUM >= 0x071200 /* Available since 7.18.0 */ + case CURLOPT_PROXY_TRANSFER_MODE: #endif -#if LIBCURL_VERSION_NUM >= 0x71304 - case CURLOPT_REDIR_PROTOCOLS: +#if LIBCURL_VERSION_NUM >= 0x071300 /* Available since 7.19.0 */ + case CURLOPT_ADDRESS_SCOPE: + case CURLOPT_SSH_AUTH_TYPES: +#endif +#if LIBCURL_VERSION_NUM > 0x071301 /* Available since 7.19.1 */ + case CURLOPT_CERTINFO: +#endif +#if LIBCURL_VERSION_NUM >= 0x071304 /* Available since 7.19.4 */ + case CURLOPT_NOPROXY: case CURLOPT_PROTOCOLS: + case CURLOPT_REDIR_PROTOCOLS: + case CURLOPT_SOCKS5_GSSAPI_NEC: + case CURLOPT_TFTP_BLKSIZE: #endif -#if LIBCURL_VERSION_NUM > 0x070a07 /* CURLOPT_IPRESOLVE is available since curl 7.10.8 */ - case CURLOPT_IPRESOLVE: +#if LIBCURL_VERSION_NUM >= 0x071400 /* Available since 7.20.0 */ + case CURLOPT_FTP_USE_PRET: + case CURLOPT_RTSP_CLIENT_CSEQ: + case CURLOPT_RTSP_REQUEST: + case CURLOPT_RTSP_SERVER_CSEQ: #endif -#if LIBCURL_VERSION_NUM >= 0x070f01 - case CURLOPT_FTP_FILEMETHOD: - case CURLOPT_FTP_SKIP_PASV_IP: +#if LIBCURL_VERSION_NUM >= 0x071500 /* Available since 7.21.0 */ + case CURLOPT_WILDCARDMATCH: #endif -#if LIBCURL_VERSION_NUM > 0x071301 - case CURLOPT_CERTINFO: +#if LIBCURL_VERSION_NUM >= 0x071504 /* Available since 7.21.4 */ + case CURLOPT_TLSAUTH_TYPE: +#endif +#if CURLOPT_MUTE != 0 + case CURLOPT_MUTE: #endif convert_to_long_ex(zvalue); #if LIBCURL_VERSION_NUM >= 0x71304 @@ -1771,57 +2149,77 @@ static int _php_curl_setopt(php_curl *ch, long option, zval **zvalue, zval *retu #endif error = curl_easy_setopt(ch->cp, option, Z_LVAL_PP(zvalue)); break; -#if LIBCURL_VERSION_NUM > 0x070f04 - case CURLOPT_MAX_RECV_SPEED_LARGE: - case CURLOPT_MAX_SEND_SPEED_LARGE: - convert_to_long_ex(zvalue); - error = curl_easy_setopt(ch->cp, option, (curl_off_t)Z_LVAL_PP(zvalue)); - break; -#endif - case CURLOPT_FOLLOWLOCATION: - convert_to_long_ex(zvalue); - if (PG(open_basedir) && *PG(open_basedir)) { - if (Z_LVAL_PP(zvalue) != 0) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLOPT_FOLLOWLOCATION cannot be activated when an open_basedir is set"); - RETVAL_FALSE; - return 1; - } - } - error = curl_easy_setopt(ch->cp, option, Z_LVAL_PP(zvalue)); - break; -#if LIBCURL_VERSION_NUM > 0x071301 - case CURLOPT_POSTREDIR: - convert_to_long_ex(zvalue); - error = curl_easy_setopt(ch->cp, CURLOPT_POSTREDIR, Z_LVAL_PP(zvalue) & CURL_REDIR_POST_ALL); - break; -#endif + + /* String options */ + case CURLOPT_CAINFO: + case CURLOPT_CAPATH: + case CURLOPT_COOKIE: + case CURLOPT_CUSTOMREQUEST: + case CURLOPT_EGDSOCKET: + case CURLOPT_FTPPORT: + case CURLOPT_INTERFACE: case CURLOPT_PRIVATE: - case CURLOPT_URL: case CURLOPT_PROXY: - case CURLOPT_USERPWD: case CURLOPT_PROXYUSERPWD: case CURLOPT_RANGE: - case CURLOPT_CUSTOMREQUEST: - case CURLOPT_USERAGENT: - case CURLOPT_FTPPORT: - case CURLOPT_COOKIE: case CURLOPT_REFERER: - case CURLOPT_INTERFACE: - case CURLOPT_KRB4LEVEL: - case CURLOPT_EGDSOCKET: - case CURLOPT_CAINFO: - case CURLOPT_CAPATH: - case CURLOPT_SSL_CIPHER_LIST: - case CURLOPT_SSLKEY: - case CURLOPT_SSLKEYTYPE: - case CURLOPT_SSLKEYPASSWD: + case CURLOPT_SSLCERTTYPE: case CURLOPT_SSLENGINE: case CURLOPT_SSLENGINE_DEFAULT: - case CURLOPT_SSLCERTTYPE: + case CURLOPT_SSLKEY: + case CURLOPT_SSLKEYPASSWD: + case CURLOPT_SSLKEYTYPE: + case CURLOPT_SSL_CIPHER_LIST: + case CURLOPT_URL: + case CURLOPT_USERAGENT: + case CURLOPT_USERPWD: +#if LIBCURL_VERSION_NUM >= 0x070d00 /* Available since 7.13.0 */ + case CURLOPT_FTP_ACCOUNT: +#endif +#if LIBCURL_VERSION_NUM >= 0x070e01 /* Available since 7.14.1 */ + case CURLOPT_COOKIELIST: +#endif +#if LIBCURL_VERSION_NUM >= 0x070f05 /* Available since 7.15.5 */ + case CURLOPT_FTP_ALTERNATIVE_TO_USER: +#endif +#if LIBCURL_VERSION_NUM >= 0x071004 /* Available since 7.16.4 */ + case CURLOPT_KRBLEVEL: +#else + case CURLOPT_KRB4LEVEL: +#endif +#if LIBCURL_VERSION_NUM >= 0x071300 /* Available since 7.19.0 */ + case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5: +#endif +#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */ + case CURLOPT_PASSWORD: + case CURLOPT_PROXYPASSWORD: + case CURLOPT_PROXYUSERNAME: + case CURLOPT_USERNAME: +#endif +#if LIBCURL_VERSION_NUM >= 0x071304 /* Available since 7.19.4 */ + case CURLOPT_SOCKS5_GSSAPI_SERVICE: +#endif +#if LIBCURL_VERSION_NUM >= 0x071400 /* Available since 7.20.0 */ + case CURLOPT_MAIL_FROM: + case CURLOPT_RTSP_SESSION_ID: + case CURLOPT_RTSP_STREAM_URI: + case CURLOPT_RTSP_TRANSPORT: +#endif +#if LIBCURL_VERSION_NUM >= 0x071504 /* Available since 7.21.4 */ + case CURLOPT_TLSAUTH_PASSWORD: + case CURLOPT_TLSAUTH_USERNAME: +#endif +#if LIBCURL_VERSION_NUM >= 0x071506 /* Available since 7.21.6 */ + case CURLOPT_ACCEPT_ENCODING: + case CURLOPT_TRANSFER_ENCODING: +#else case CURLOPT_ENCODING: -#if LIBCURL_VERSION_NUM >= 0x071300 - case CURLOPT_SSH_PUBLIC_KEYFILE: - case CURLOPT_SSH_PRIVATE_KEYFILE: +#endif +#if LIBCURL_VERSION_NUM >= 0x071800 /* Available since 7.24.0 */ + case CURLOPT_DNS_SERVERS: +#endif +#if LIBCURL_VERSION_NUM >= 0x071900 /* Available since 7.25.0 */ + case CURLOPT_MAIL_AUTH: #endif { #if LIBCURL_VERSION_NUM < 0x071100 @@ -1829,17 +2227,6 @@ static int _php_curl_setopt(php_curl *ch, long option, zval **zvalue, zval *retu #endif convert_to_string_ex(zvalue); -#if LIBCURL_VERSION_NUM >= 0x071300 - if ( - option == CURLOPT_SSH_PUBLIC_KEYFILE || option == CURLOPT_SSH_PRIVATE_KEYFILE - - ) { - if (php_check_open_basedir(Z_STRVAL_PP(zvalue) TSRMLS_CC)) { - RETVAL_FALSE; - return 1; - } - } -#endif if (option == CURLOPT_URL) { if (!php_curl_option_url(ch, Z_STRVAL_PP(zvalue), Z_STRLEN_PP(zvalue) TSRMLS_CC)) { RETVAL_FALSE; @@ -1865,10 +2252,12 @@ string_copy: } break; } + + /* Curl file handle options */ case CURLOPT_FILE: case CURLOPT_INFILE: - case CURLOPT_WRITEHEADER: - case CURLOPT_STDERR: { + case CURLOPT_STDERR: + case CURLOPT_WRITEHEADER: { FILE *fp = NULL; int type; void * what; @@ -1947,56 +2336,98 @@ string_copy: error = curl_easy_setopt(ch->cp, option, fp); break; } - break; } - case CURLOPT_RETURNTRANSFER: - convert_to_long_ex(zvalue); - if (Z_LVAL_PP(zvalue)) { - ch->handlers->write->method = PHP_CURL_RETURN; - } else { - ch->handlers->write->method = PHP_CURL_STDOUT; - } - break; - case CURLOPT_BINARYTRANSFER: - convert_to_long_ex(zvalue); + /* Curl linked list options */ + case CURLOPT_HTTP200ALIASES: + case CURLOPT_HTTPHEADER: + case CURLOPT_POSTQUOTE: + case CURLOPT_PREQUOTE: + case CURLOPT_QUOTE: +#if LIBCURL_VERSION_NUM >= 0x071400 /* Available since 7.20.0 */ + case CURLOPT_MAIL_RCPT: +#endif +#if LIBCURL_VERSION_NUM >= 0x071503 /* Available since 7.21.3 */ + case CURLOPT_RESOLVE: +#endif + { + zval **current; + HashTable *ph; + struct curl_slist *slist = NULL; - if (Z_LVAL_PP(zvalue)) { - ch->handlers->write->type = PHP_CURL_BINARY; - } else { - ch->handlers->write->type = PHP_CURL_ASCII; + ph = HASH_OF(*zvalue); + if (!ph) { + char *name; + switch (option) { + case CURLOPT_HTTPHEADER: + name = "CURLOPT_HTTPHEADER"; + break; + case CURLOPT_QUOTE: + name = "CURLOPT_QUOTE"; + break; + case CURLOPT_HTTP200ALIASES: + name = "CURLOPT_HTTP200ALIASES"; + break; + case CURLOPT_POSTQUOTE: + name = "CURLOPT_POSTQUOTE"; + break; + case CURLOPT_PREQUOTE: + name = "CURLOPT_PREQUOTE"; + break; +#if LIBCURL_VERSION_NUM >= 0x071400 /* Available since 7.20.0 */ + case CURLOPT_MAIL_RCPT: + name = "CURLOPT_MAIL_RCPT"; + break; +#endif +#if LIBCURL_VERSION_NUM >= 0x071503 /* Available since 7.21.3 */ + case CURLOPT_RESOLVE: + name = "CURLOPT_RESOLVE"; + break; +#endif + } + php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must pass either an object or an array with the %s argument", name); + RETVAL_FALSE; + return 1; } - break; - case CURLOPT_WRITEFUNCTION: - if (ch->handlers->write->func_name) { - zval_ptr_dtor(&ch->handlers->write->func_name); - ch->handlers->write->fci_cache = empty_fcall_info_cache; + + for (zend_hash_internal_pointer_reset(ph); + zend_hash_get_current_data(ph, (void **) ¤t) == SUCCESS; + zend_hash_move_forward(ph) + ) { + SEPARATE_ZVAL(current); + convert_to_string_ex(current); + + slist = curl_slist_append(slist, Z_STRVAL_PP(current)); + if (!slist) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not build curl_slist"); + RETVAL_FALSE; + return 1; + } } - zval_add_ref(zvalue); - ch->handlers->write->func_name = *zvalue; - ch->handlers->write->method = PHP_CURL_USER; + zend_llist_add_element(&ch->to_free->slist, &slist); + + error = curl_easy_setopt(ch->cp, option, slist); + break; - case CURLOPT_READFUNCTION: - if (ch->handlers->read->func_name) { - zval_ptr_dtor(&ch->handlers->read->func_name); - ch->handlers->read->fci_cache = empty_fcall_info_cache; - } - zval_add_ref(zvalue); - ch->handlers->read->func_name = *zvalue; - ch->handlers->read->method = PHP_CURL_USER; + } + + case CURLOPT_BINARYTRANSFER: + /* Do nothing, just backward compatibility */ break; - case CURLOPT_PROGRESSFUNCTION: - curl_easy_setopt(ch->cp, CURLOPT_PROGRESSFUNCTION, curl_progress); - curl_easy_setopt(ch->cp, CURLOPT_PROGRESSDATA, ch); - if (ch->handlers->progress->func_name) { - zval_ptr_dtor(&ch->handlers->progress->func_name); - ch->handlers->progress->fci_cache = empty_fcall_info_cache; + + case CURLOPT_FOLLOWLOCATION: + convert_to_long_ex(zvalue); + if (PG(open_basedir) && *PG(open_basedir)) { + if (Z_LVAL_PP(zvalue) != 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLOPT_FOLLOWLOCATION cannot be activated when an open_basedir is set"); + RETVAL_FALSE; + return 1; + } } - zval_add_ref(zvalue); - ch->handlers->progress->func_name = *zvalue; - ch->handlers->progress->method = PHP_CURL_USER; + error = curl_easy_setopt(ch->cp, option, Z_LVAL_PP(zvalue)); break; + case CURLOPT_HEADERFUNCTION: if (ch->handlers->write_header->func_name) { zval_ptr_dtor(&ch->handlers->write_header->func_name); @@ -2006,17 +2437,7 @@ string_copy: ch->handlers->write_header->func_name = *zvalue; ch->handlers->write_header->method = PHP_CURL_USER; break; -#if CURLOPT_PASSWDFUNCTION != 0 - case CURLOPT_PASSWDFUNCTION: - if (ch->handlers->passwd) { - zval_ptr_dtor(&ch->handlers->passwd); - } - zval_add_ref(zvalue); - ch->handlers->passwd = *zvalue; - error = curl_easy_setopt(ch->cp, CURLOPT_PASSWDFUNCTION, curl_passwd); - error = curl_easy_setopt(ch->cp, CURLOPT_PASSWDDATA, (void *) ch); - break; -#endif + case CURLOPT_POSTFIELDS: if (Z_TYPE_PP(zvalue) == IS_ARRAY || Z_TYPE_PP(zvalue) == IS_OBJECT) { zval **current; @@ -2035,11 +2456,11 @@ string_copy: zend_hash_get_current_data(postfields, (void **) ¤t) == SUCCESS; zend_hash_move_forward(postfields) ) { - char *postval; - char *string_key = NULL; - uint string_key_len; - ulong num_key; - int numeric_key; + char *postval; + char *string_key = NULL; + uint string_key_len; + ulong num_key; + int numeric_key; SEPARATE_ZVAL(current); convert_to_string_ex(current); @@ -2129,48 +2550,97 @@ string_copy: #endif } break; - case CURLOPT_HTTPHEADER: - case CURLOPT_QUOTE: - case CURLOPT_HTTP200ALIASES: - case CURLOPT_POSTQUOTE: { - zval **current; - HashTable *ph; - struct curl_slist *slist = NULL; - ph = HASH_OF(*zvalue); - if (!ph) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must pass either an object or an array with the CURLOPT_HTTPHEADER, CURLOPT_QUOTE, CURLOPT_HTTP200ALIASES and CURLOPT_POSTQUOTE arguments"); - RETVAL_FALSE; - return 1; + case CURLOPT_PROGRESSFUNCTION: + curl_easy_setopt(ch->cp, CURLOPT_PROGRESSFUNCTION, curl_progress); + curl_easy_setopt(ch->cp, CURLOPT_PROGRESSDATA, ch); + if (ch->handlers->progress == NULL) { + ch->handlers->progress = ecalloc(1, sizeof(php_curl_progress)); + } else if (ch->handlers->progress->func_name) { + zval_ptr_dtor(&ch->handlers->progress->func_name); + ch->handlers->progress->fci_cache = empty_fcall_info_cache; } + zval_add_ref(zvalue); + ch->handlers->progress->func_name = *zvalue; + ch->handlers->progress->method = PHP_CURL_USER; + break; - for (zend_hash_internal_pointer_reset(ph); - zend_hash_get_current_data(ph, (void **) ¤t) == SUCCESS; - zend_hash_move_forward(ph) - ) { - SEPARATE_ZVAL(current); - convert_to_string_ex(current); + case CURLOPT_READFUNCTION: + if (ch->handlers->read->func_name) { + zval_ptr_dtor(&ch->handlers->read->func_name); + ch->handlers->read->fci_cache = empty_fcall_info_cache; + } + zval_add_ref(zvalue); + ch->handlers->read->func_name = *zvalue; + ch->handlers->read->method = PHP_CURL_USER; + break; - slist = curl_slist_append(slist, Z_STRVAL_PP(current)); - if (!slist) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not build curl_slist"); - RETVAL_FALSE; - return 1; - } + case CURLOPT_RETURNTRANSFER: + convert_to_long_ex(zvalue); + if (Z_LVAL_PP(zvalue)) { + ch->handlers->write->method = PHP_CURL_RETURN; + } else { + ch->handlers->write->method = PHP_CURL_STDOUT; } - zend_llist_add_element(&ch->to_free->slist, &slist); + break; - error = curl_easy_setopt(ch->cp, option, slist); + case CURLOPT_WRITEFUNCTION: + if (ch->handlers->write->func_name) { + zval_ptr_dtor(&ch->handlers->write->func_name); + ch->handlers->write->fci_cache = empty_fcall_info_cache; + } + zval_add_ref(zvalue); + ch->handlers->write->func_name = *zvalue; + ch->handlers->write->method = PHP_CURL_USER; + break; +#if LIBCURL_VERSION_NUM >= 0x070f05 /* Available since 7.15.5 */ + case CURLOPT_MAX_RECV_SPEED_LARGE: + case CURLOPT_MAX_SEND_SPEED_LARGE: + convert_to_long_ex(zvalue); + error = curl_easy_setopt(ch->cp, option, (curl_off_t)Z_LVAL_PP(zvalue)); break; - } +#endif + +#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */ + case CURLOPT_POSTREDIR: + convert_to_long_ex(zvalue); + error = curl_easy_setopt(ch->cp, CURLOPT_POSTREDIR, Z_LVAL_PP(zvalue) & CURL_REDIR_POST_ALL); + break; +#endif + +#if CURLOPT_PASSWDFUNCTION != 0 + case CURLOPT_PASSWDFUNCTION: + if (ch->handlers->passwd) { + zval_ptr_dtor(&ch->handlers->passwd); + } + zval_add_ref(zvalue); + ch->handlers->passwd = *zvalue; + error = curl_easy_setopt(ch->cp, CURLOPT_PASSWDFUNCTION, curl_passwd); + error = curl_easy_setopt(ch->cp, CURLOPT_PASSWDDATA, (void *) ch); + break; +#endif + /* the following options deal with files, therefore the open_basedir check * is required. */ + case CURLOPT_COOKIEFILE: case CURLOPT_COOKIEJAR: - case CURLOPT_SSLCERT: case CURLOPT_RANDOM_FILE: - case CURLOPT_COOKIEFILE: { + case CURLOPT_SSLCERT: +#if LIBCURL_VERSION_NUM >= 0x070b00 /* Available since 7.11.0 */ + case CURLOPT_NETRC_FILE: +#endif +#if LIBCURL_VERSION_NUM >= 0x071300 /* Available since 7.19.0 */ + case CURLOPT_CRLFILE: + case CURLOPT_ISSUERCERT: + case CURLOPT_SSH_PRIVATE_KEYFILE: + case CURLOPT_SSH_PUBLIC_KEYFILE: +#endif +#if LIBCURL_VERSION_NUM >= 0x071306 /* Available since 7.19.6 */ + case CURLOPT_SSH_KNOWNHOSTS: +#endif + { #if LIBCURL_VERSION_NUM < 0x071100 char *copystr = NULL; #endif @@ -2192,6 +2662,7 @@ string_copy: #endif break; } + case CURLINFO_HEADER_OUT: convert_to_long_ex(zvalue); if (Z_LVAL_PP(zvalue) == 1) { @@ -2204,6 +2675,32 @@ string_copy: curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 0); } break; + + case CURLOPT_SHARE: + { + php_curlsh *sh = NULL; + ZEND_FETCH_RESOURCE(sh, php_curlsh *, zvalue, -1, le_curl_share_handle_name, le_curl_share_handle); + if (sh) { + curl_easy_setopt(ch->cp, CURLOPT_SHARE, sh->share); + } + } + +#if LIBCURL_VERSION_NUM >= 0x071500 /* Available since 7.21.0 */ + case CURLOPT_FNMATCH_FUNCTION: + curl_easy_setopt(ch->cp, CURLOPT_FNMATCH_FUNCTION, curl_fnmatch); + curl_easy_setopt(ch->cp, CURLOPT_FNMATCH_DATA, ch); + if (ch->handlers->fnmatch == NULL) { + ch->handlers->fnmatch = ecalloc(1, sizeof(php_curl_fnmatch)); + } else if (ch->handlers->fnmatch->func_name) { + zval_ptr_dtor(&ch->handlers->fnmatch->func_name); + ch->handlers->fnmatch->fci_cache = empty_fcall_info_cache; + } + zval_add_ref(zvalue); + ch->handlers->fnmatch->func_name = *zvalue; + ch->handlers->fnmatch->method = PHP_CURL_USER; + break; +#endif + } SAVE_CURL_ERROR(ch, error); @@ -2440,18 +2937,25 @@ PHP_FUNCTION(curl_getinfo) if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_TIME, &d_code) == CURLE_OK) { CAAD("redirect_time", d_code); } -#if LIBCURL_VERSION_NUM > 0x071301 +#if LIBCURL_VERSION_NUM >= 0x071202 /* Available since 7.18.2 */ + if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_URL, &s_code) == CURLE_OK) { + CAAS("redirect_url", s_code); + } +#endif +#if LIBCURL_VERSION_NUM >= 0x071300 /* Available since 7.19.0 */ + if (curl_easy_getinfo(ch->cp, CURLINFO_PRIMARY_IP, &s_code) == CURLE_OK) { + CAAS("primary_ip", s_code); + } +#endif +#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */ if (curl_easy_getinfo(ch->cp, CURLINFO_CERTINFO, &ci) == CURLE_OK) { MAKE_STD_ZVAL(listcode); array_init(listcode); create_certinfo(ci, listcode TSRMLS_CC); CAAZ("certinfo", listcode); } - if (curl_easy_getinfo(ch->cp, CURLINFO_PRIMARY_IP, &s_code) == CURLE_OK) { - CAAS("primary_ip", s_code); - } #endif -#if LIBCURL_VERSION_NUM > 0x071500 +#if LIBCURL_VERSION_NUM >= 0x071500 /* Available since 7.21.0 */ if (curl_easy_getinfo(ch->cp, CURLINFO_PRIMARY_PORT, &l_code) == CURLE_OK) { CAAL("primary_port", l_code); } @@ -2462,88 +2966,18 @@ PHP_FUNCTION(curl_getinfo) CAAL("local_port", l_code); } #endif -#if LIBCURL_VERSION_NUM >= 0x071202 - if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_URL, &s_code) == CURLE_OK) { - CAAS("redirect_url", s_code); - } -#endif if (ch->header.str_len > 0) { CAAS("request_header", ch->header.str); } } else { switch (option) { - /* string variable types */ -#if LIBCURL_VERSION_NUM >= 0x071500 - case CURLINFO_PRIMARY_IP: -#endif -#if LIBCURL_VERSION_NUM >= 0x071500 - case CURLINFO_LOCAL_IP: -#endif - case CURLINFO_PRIVATE: - case CURLINFO_EFFECTIVE_URL: - case CURLINFO_CONTENT_TYPE: -#if LIBCURL_VERSION_NUM >= 0x071202 - case CURLINFO_REDIRECT_URL: -#endif - { - char *s_code = NULL; - - if (curl_easy_getinfo(ch->cp, option, &s_code) == CURLE_OK && s_code) { - RETURN_STRING(s_code, 1); - } else { - RETURN_FALSE; - } - break; - } - /* Long variable types */ -#if LIBCURL_VERSION_NUM >= 0x071500 - case CURLINFO_PRIMARY_PORT: - case CURLINFO_LOCAL_PORT: -#endif - case CURLINFO_HTTP_CODE: - case CURLINFO_HEADER_SIZE: - case CURLINFO_REQUEST_SIZE: - case CURLINFO_FILETIME: - case CURLINFO_SSL_VERIFYRESULT: - case CURLINFO_REDIRECT_COUNT: { - long code = 0; - - if (curl_easy_getinfo(ch->cp, option, &code) == CURLE_OK) { - RETURN_LONG(code); - } else { - RETURN_FALSE; - } - break; - } - /* Double variable types */ - case CURLINFO_TOTAL_TIME: - case CURLINFO_NAMELOOKUP_TIME: - case CURLINFO_CONNECT_TIME: - case CURLINFO_PRETRANSFER_TIME: - case CURLINFO_SIZE_UPLOAD: - case CURLINFO_SIZE_DOWNLOAD: - case CURLINFO_SPEED_DOWNLOAD: - case CURLINFO_SPEED_UPLOAD: - case CURLINFO_CONTENT_LENGTH_DOWNLOAD: - case CURLINFO_CONTENT_LENGTH_UPLOAD: - case CURLINFO_STARTTRANSFER_TIME: - case CURLINFO_REDIRECT_TIME: { - double code = 0.0; - - if (curl_easy_getinfo(ch->cp, option, &code) == CURLE_OK) { - RETURN_DOUBLE(code); - } else { - RETURN_FALSE; - } - break; - } case CURLINFO_HEADER_OUT: if (ch->header.str_len > 0) { RETURN_STRINGL(ch->header.str, ch->header.str_len, 1); } else { RETURN_FALSE; } -#if LIBCURL_VERSION_NUM > 0x071301 +#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */ case CURLINFO_CERTINFO: { struct curl_certinfo *ci = NULL; @@ -2557,6 +2991,61 @@ PHP_FUNCTION(curl_getinfo) break; } #endif + default: { + int type = CURLINFO_TYPEMASK & option; + switch (type) { + case CURLINFO_STRING: + { + char *s_code = NULL; + + if (curl_easy_getinfo(ch->cp, option, &s_code) == CURLE_OK && s_code) { + RETURN_STRING(s_code, 1); + } else { + RETURN_FALSE; + } + break; + } + case CURLINFO_LONG: + { + long code = 0; + + if (curl_easy_getinfo(ch->cp, option, &code) == CURLE_OK) { + RETURN_LONG(code); + } else { + RETURN_FALSE; + } + break; + } + case CURLINFO_DOUBLE: + { + double code = 0.0; + + if (curl_easy_getinfo(ch->cp, option, &code) == CURLE_OK) { + RETURN_DOUBLE(code); + } else { + RETURN_FALSE; + } + break; + } + case CURLINFO_SLIST: + { + struct curl_slist *slist; + array_init(return_value); + if (curl_easy_getinfo(ch->cp, option, &slist) == CURLE_OK) { + while (slist) { + add_next_index_string(return_value, slist->data, 1); + slist = slist->next; + } + curl_slist_free_all(slist); + } else { + RETURN_FALSE; + } + break; + } + default: + RETURN_FALSE; + } + } } } } @@ -2657,9 +3146,6 @@ static void _php_curl_close_ex(php_curl *ch TSRMLS_DC) if (ch->handlers->write_header->func_name) { zval_ptr_dtor(&ch->handlers->write_header->func_name); } - if (ch->handlers->progress->func_name) { - zval_ptr_dtor(&ch->handlers->progress->func_name); - } if (ch->handlers->passwd) { zval_ptr_dtor(&ch->handlers->passwd); } @@ -2683,7 +3169,23 @@ static void _php_curl_close_ex(php_curl *ch TSRMLS_DC) efree(ch->handlers->write); efree(ch->handlers->write_header); efree(ch->handlers->read); - efree(ch->handlers->progress); + + if (ch->handlers->progress) { + if (ch->handlers->progress->func_name) { + zval_ptr_dtor(&ch->handlers->progress->func_name); + } + efree(ch->handlers->progress); + } + +#if LIBCURL_VERSION_NUM >= 0x071500 /* Available since 7.21.0 */ + if (ch->handlers->fnmatch) { + if (ch->handlers->fnmatch->func_name) { + zval_ptr_dtor(&ch->handlers->fnmatch->func_name); + } + efree(ch->handlers->fnmatch); + } +#endif + efree(ch->handlers); efree(ch); } @@ -2698,6 +3200,133 @@ static void _php_curl_close(zend_rsrc_list_entry *rsrc TSRMLS_DC) } /* }}} */ +#if LIBCURL_VERSION_NUM >= 0x070c01 /* 7.12.1 */ +/* {{{ _php_curl_reset_handlers() + Reset all handlers of a given php_curl */ +static _php_curl_reset_handlers(php_curl *ch) +{ + if (ch->handlers->write->stream) { + Z_DELREF_P(ch->handlers->write->stream); + ch->handlers->write->stream = NULL; + } + ch->handlers->write->fp = NULL; + ch->handlers->write->method = PHP_CURL_STDOUT; + + if (ch->handlers->write_header->stream) { + Z_DELREF_P(ch->handlers->write_header->stream); + ch->handlers->write_header->stream = NULL; + } + ch->handlers->write_header->fp = NULL; + ch->handlers->write_header->method = PHP_CURL_IGNORE; + + if (ch->handlers->read->stream) { + Z_DELREF_P(ch->handlers->read->stream); + ch->handlers->read->stream = NULL; + } + ch->handlers->read->fp = NULL; + ch->handlers->read->fd = NULL; + ch->handlers->read->method = PHP_CURL_DIRECT; + + if (ch->handlers->std_err) { + zval_ptr_dtor(&ch->handlers->std_err); + ch->handlers->std_err = NULL; + } + + if (ch->handlers->progress) { + if (ch->handlers->progress->func_name) { + zval_ptr_dtor(&ch->handlers->progress->func_name); + } + efree(ch->handlers->progress); + ch->handlers->progress = NULL; + } + +#if LIBCURL_VERSION_NUM >= 0x071500 /* Available since 7.21.0 */ + if (ch->handlers->fnmatch) { + if (ch->handlers->fnmatch->func_name) { + zval_ptr_dtor(&ch->handlers->fnmatch->func_name); + } + efree(ch->handlers->fnmatch); + ch->handlers->fnmatch = NULL; + } +#endif + +} +/* }}} */ + +/* {{{ proto void curl_reset(resource ch) + Reset all options of a libcurl session handle */ +PHP_FUNCTION(curl_reset) +{ + zval *zid; + php_curl *ch; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zid) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl); + + if (ch->in_callback) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attempt to reset cURL handle from a callback"); + return; + } + + curl_easy_reset(ch->cp); + _php_curl_reset_handlers(ch); + _php_curl_set_default_options(ch); +} +/* }}} */ +#endif + +#if LIBCURL_VERSION_NUM > 0x070f03 /* 7.15.4 */ +/* {{{ proto void curl_escape(resource ch, string str) + URL encodes the given string */ +PHP_FUNCTION(curl_escape) +{ + char *str = NULL, *res = NULL; + int str_len = 0; + zval *zid; + php_curl *ch; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &zid, &str, &str_len) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl); + + if (res = curl_easy_escape(ch->cp, str, str_len)) { + RETVAL_STRING(res, 1); + free(res); + } else { + RETURN_FALSE; + } +} +/* }}} */ + +/* {{{ proto void curl_unescape(resource ch, string str) + URL decodes the given string */ +PHP_FUNCTION(curl_unescape) +{ + char *str = NULL, *out = NULL; + int str_len = 0, out_len; + zval *zid; + php_curl *ch; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &zid, &str, &str_len) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl); + + if (out = curl_easy_unescape(ch->cp, str, str_len, &out_len)) { + RETVAL_STRINGL(out, out_len, 1); + free(out); + } else { + RETURN_FALSE; + } +} +#endif +/* }}} */ #endif /* HAVE_CURL */ /* |