/* +----------------------------------------------------------------------+ | Copyright (c) The PHP Group | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | | available through the world-wide-web at the following url: | | https://www.php.net/license/3_01.txt | | If you did not receive a copy of the PHP license and are unable to | | obtain it through the world-wide-web, please send a note to | | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Author: Sterling Hughes | +----------------------------------------------------------------------+ */ #define ZEND_INCLUDE_FULL_WINDOWS_HEADERS #ifdef HAVE_CONFIG_H #include #endif #include "php.h" #include "Zend/zend_exceptions.h" #include #include #ifdef PHP_WIN32 #include #include #endif #include #include /* As of curl 7.11.1 this is no longer defined inside curl.h */ #ifndef HttpPost #define HttpPost curl_httppost #endif #include "zend_smart_str.h" #include "ext/standard/info.h" #include "ext/standard/file.h" #include "ext/standard/url.h" #include "curl_private.h" #ifdef __GNUC__ /* don't complain about deprecated CURLOPT_* we're exposing to PHP; we need to keep using those to avoid breaking PHP API compatibility */ # pragma GCC diagnostic ignored "-Wdeprecated-declarations" #endif #include "zend_attributes.h" #include "curl_arginfo.h" ZEND_DECLARE_MODULE_GLOBALS(curl) #define CAAL(s, v) add_assoc_long_ex(return_value, s, sizeof(s) - 1, (zend_long) v); #define CAAD(s, v) add_assoc_double_ex(return_value, s, sizeof(s) - 1, (double) v); #define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s) - 1, (char *) (v ? v : "")); #define CAASTR(s, v) add_assoc_str_ex(return_value, s, sizeof(s) - 1, \ v ? zend_string_copy(v) : ZSTR_EMPTY_ALLOC()); #define CAAZ(s, v) add_assoc_zval_ex(return_value, s, sizeof(s) -1 , (zval *) v); #if defined(PHP_WIN32) || defined(__GNUC__) # define php_curl_ret(__ret) RETVAL_FALSE; return __ret; #else # define php_curl_ret(__ret) RETVAL_FALSE; return; #endif static zend_result php_curl_option_str(php_curl *ch, zend_long option, const char *str, const size_t len) { if (zend_char_has_nul_byte(str, len)) { zend_value_error("%s(): cURL option must not contain any null bytes", get_active_function_name()); return FAILURE; } CURLcode error = curl_easy_setopt(ch->cp, option, str); SAVE_CURL_ERROR(ch, error); return error == CURLE_OK ? SUCCESS : FAILURE; } static zend_result php_curl_option_url(php_curl *ch, const zend_string *url) /* {{{ */ { /* Disable file:// if open_basedir are used */ if (PG(open_basedir) && *PG(open_basedir)) { curl_easy_setopt(ch->cp, CURLOPT_PROTOCOLS, CURLPROTO_ALL & ~CURLPROTO_FILE); } #ifdef PHP_WIN32 if ( zend_string_starts_with_literal_ci(url, "file://") && '/' != ZSTR_VAL(url)[sizeof("file://") - 1] && ZSTR_LEN(url) < MAXPATHLEN - 2 ) { char _tmp[MAXPATHLEN] = {0}; memmove(_tmp, "file:///", sizeof("file:///") - 1); memmove(_tmp + sizeof("file:///") - 1, ZSTR_VAL(url) + sizeof("file://") - 1, ZSTR_LEN(url) - sizeof("file://") + 1); return php_curl_option_str(ch, CURLOPT_URL, _tmp, ZSTR_LEN(url) + 1); } #endif return php_curl_option_str(ch, CURLOPT_URL, ZSTR_VAL(url), ZSTR_LEN(url)); } /* }}} */ void _php_curl_verify_handlers(php_curl *ch, bool reporterror) /* {{{ */ { php_stream *stream; ZEND_ASSERT(ch); if (!Z_ISUNDEF(ch->handlers.std_err)) { stream = (php_stream *)zend_fetch_resource2_ex(&ch->handlers.std_err, NULL, php_file_le_stream(), php_file_le_pstream()); if (stream == NULL) { if (reporterror) { php_error_docref(NULL, E_WARNING, "CURLOPT_STDERR resource has gone away, resetting to stderr"); } zval_ptr_dtor(&ch->handlers.std_err); ZVAL_UNDEF(&ch->handlers.std_err); curl_easy_setopt(ch->cp, CURLOPT_STDERR, stderr); } } if (ch->handlers.read && !Z_ISUNDEF(ch->handlers.read->stream)) { stream = (php_stream *)zend_fetch_resource2_ex(&ch->handlers.read->stream, NULL, php_file_le_stream(), php_file_le_pstream()); if (stream == NULL) { if (reporterror) { php_error_docref(NULL, E_WARNING, "CURLOPT_INFILE resource has gone away, resetting to default"); } zval_ptr_dtor(&ch->handlers.read->stream); ZVAL_UNDEF(&ch->handlers.read->stream); ch->handlers.read->res = NULL; ch->handlers.read->fp = 0; curl_easy_setopt(ch->cp, CURLOPT_INFILE, (void *) ch); } } if (ch->handlers.write_header && !Z_ISUNDEF(ch->handlers.write_header->stream)) { stream = (php_stream *)zend_fetch_resource2_ex(&ch->handlers.write_header->stream, NULL, php_file_le_stream(), php_file_le_pstream()); if (stream == NULL) { if (reporterror) { php_error_docref(NULL, E_WARNING, "CURLOPT_WRITEHEADER resource has gone away, resetting to default"); } zval_ptr_dtor(&ch->handlers.write_header->stream); ZVAL_UNDEF(&ch->handlers.write_header->stream); ch->handlers.write_header->fp = 0; ch->handlers.write_header->method = PHP_CURL_IGNORE; curl_easy_setopt(ch->cp, CURLOPT_WRITEHEADER, (void *) ch); } } if (ch->handlers.write && !Z_ISUNDEF(ch->handlers.write->stream)) { stream = (php_stream *)zend_fetch_resource2_ex(&ch->handlers.write->stream, NULL, php_file_le_stream(), php_file_le_pstream()); if (stream == NULL) { if (reporterror) { php_error_docref(NULL, E_WARNING, "CURLOPT_FILE resource has gone away, resetting to default"); } zval_ptr_dtor(&ch->handlers.write->stream); ZVAL_UNDEF(&ch->handlers.write->stream); ch->handlers.write->fp = 0; ch->handlers.write->method = PHP_CURL_STDOUT; curl_easy_setopt(ch->cp, CURLOPT_FILE, (void *) ch); } } return; } /* }}} */ /* {{{ curl_module_entry */ zend_module_entry curl_module_entry = { STANDARD_MODULE_HEADER, "curl", ext_functions, PHP_MINIT(curl), PHP_MSHUTDOWN(curl), NULL, NULL, PHP_MINFO(curl), PHP_CURL_VERSION, PHP_MODULE_GLOBALS(curl), PHP_GINIT(curl), PHP_GSHUTDOWN(curl), NULL, STANDARD_MODULE_PROPERTIES_EX }; /* }}} */ #ifdef COMPILE_DL_CURL ZEND_GET_MODULE (curl) #endif PHP_GINIT_FUNCTION(curl) { zend_hash_init(&curl_globals->persistent_curlsh, 0, NULL, curl_share_free_persistent_curlsh, true); GC_MAKE_PERSISTENT_LOCAL(&curl_globals->persistent_curlsh); } PHP_GSHUTDOWN_FUNCTION(curl) { zend_hash_destroy(&curl_globals->persistent_curlsh); } /* CurlHandle class */ zend_class_entry *curl_ce; zend_class_entry *curl_share_ce; zend_class_entry *curl_share_persistent_ce; static zend_object_handlers curl_object_handlers; static zend_object *curl_create_object(zend_class_entry *class_type); static void curl_free_obj(zend_object *object); static HashTable *curl_get_gc(zend_object *object, zval **table, int *n); static zend_function *curl_get_constructor(zend_object *object); static zend_object *curl_clone_obj(zend_object *object); php_curl *init_curl_handle_into_zval(zval *curl); static inline zend_result build_mime_structure_from_hash(php_curl *ch, zval *zpostfields); /* {{{ PHP_INI_BEGIN */ PHP_INI_BEGIN() PHP_INI_ENTRY("curl.cainfo", "", PHP_INI_SYSTEM, NULL) PHP_INI_END() /* }}} */ /* {{{ PHP_MINFO_FUNCTION */ PHP_MINFO_FUNCTION(curl) { curl_version_info_data *d; char **p; char str[1024]; size_t n = 0; d = curl_version_info(CURLVERSION_NOW); php_info_print_table_start(); php_info_print_table_row(2, "cURL support", "enabled"); php_info_print_table_row(2, "cURL Information", d->version); snprintf(str, sizeof(str), "%d", d->age); php_info_print_table_row(2, "Age", str); /* To update on each new cURL release using src/main.c in cURL sources */ /* make sure to sync this list with curl_version as well */ if (d->features) { struct feat { const char *name; int bitmask; }; unsigned int i; static const struct feat feats[] = { {"AsynchDNS", CURL_VERSION_ASYNCHDNS}, {"CharConv", CURL_VERSION_CONV}, {"Debug", CURL_VERSION_DEBUG}, {"GSS-Negotiate", CURL_VERSION_GSSNEGOTIATE}, {"IDN", CURL_VERSION_IDN}, {"IPv6", CURL_VERSION_IPV6}, {"krb4", CURL_VERSION_KERBEROS4}, {"Largefile", CURL_VERSION_LARGEFILE}, {"libz", CURL_VERSION_LIBZ}, {"NTLM", CURL_VERSION_NTLM}, {"NTLMWB", CURL_VERSION_NTLM_WB}, {"SPNEGO", CURL_VERSION_SPNEGO}, {"SSL", CURL_VERSION_SSL}, {"SSPI", CURL_VERSION_SSPI}, {"TLS-SRP", CURL_VERSION_TLSAUTH_SRP}, {"HTTP2", CURL_VERSION_HTTP2}, {"GSSAPI", CURL_VERSION_GSSAPI}, {"KERBEROS5", CURL_VERSION_KERBEROS5}, {"UNIX_SOCKETS", CURL_VERSION_UNIX_SOCKETS}, {"PSL", CURL_VERSION_PSL}, {"HTTPS_PROXY", CURL_VERSION_HTTPS_PROXY}, {"MULTI_SSL", CURL_VERSION_MULTI_SSL}, {"BROTLI", CURL_VERSION_BROTLI}, #if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ {"ALTSVC", CURL_VERSION_ALTSVC}, #endif #if LIBCURL_VERSION_NUM >= 0x074200 /* Available since 7.66.0 */ {"HTTP3", CURL_VERSION_HTTP3}, #endif #if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ {"UNICODE", CURL_VERSION_UNICODE}, {"ZSTD", CURL_VERSION_ZSTD}, #endif #if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ {"HSTS", CURL_VERSION_HSTS}, #endif #if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ {"GSASL", CURL_VERSION_GSASL}, #endif {NULL, 0} }; php_info_print_table_row(1, "Features"); for(i=0; ifeatures & feats[i].bitmask ? "Yes" : "No"); } } } n = 0; p = (char **) d->protocols; while (*p != NULL) { n += snprintf(str + n, sizeof(str) - n, "%s%s", *p, *(p + 1) != NULL ? ", " : ""); p++; } php_info_print_table_row(2, "Protocols", str); php_info_print_table_row(2, "Host", d->host); if (d->ssl_version) { php_info_print_table_row(2, "SSL Version", d->ssl_version); } if (d->libz_version) { php_info_print_table_row(2, "ZLib Version", d->libz_version); } #if defined(CURLVERSION_SECOND) && CURLVERSION_NOW >= CURLVERSION_SECOND if (d->ares) { php_info_print_table_row(2, "ZLib Version", d->ares); } #endif #if defined(CURLVERSION_THIRD) && CURLVERSION_NOW >= CURLVERSION_THIRD if (d->libidn) { php_info_print_table_row(2, "libIDN Version", d->libidn); } #endif if (d->iconv_ver_num) { php_info_print_table_row(2, "IconV Version", d->iconv_ver_num); } if (d->libssh_version) { php_info_print_table_row(2, "libSSH Version", d->libssh_version); } php_info_print_table_end(); DISPLAY_INI_ENTRIES(); } /* }}} */ /* {{{ PHP_MINIT_FUNCTION */ PHP_MINIT_FUNCTION(curl) { REGISTER_INI_ENTRIES(); register_curl_symbols(module_number); if (curl_global_init(CURL_GLOBAL_DEFAULT) != CURLE_OK) { return FAILURE; } curl_ce = register_class_CurlHandle(); curl_ce->create_object = curl_create_object; curl_ce->default_object_handlers = &curl_object_handlers; memcpy(&curl_object_handlers, &std_object_handlers, sizeof(zend_object_handlers)); curl_object_handlers.offset = XtOffsetOf(php_curl, std); curl_object_handlers.free_obj = curl_free_obj; curl_object_handlers.get_gc = curl_get_gc; curl_object_handlers.get_constructor = curl_get_constructor; curl_object_handlers.clone_obj = curl_clone_obj; curl_object_handlers.cast_object = curl_cast_object; curl_object_handlers.compare = zend_objects_not_comparable; curl_multi_ce = register_class_CurlMultiHandle(); curl_multi_register_handlers(); curl_share_ce = register_class_CurlShareHandle(); curl_share_register_handlers(); curl_share_persistent_ce = register_class_CurlSharePersistentHandle(); curl_share_persistent_register_handlers(); curlfile_register_class(); return SUCCESS; } /* }}} */ /* CurlHandle class */ static zend_object *curl_create_object(zend_class_entry *class_type) { php_curl *intern = zend_object_alloc(sizeof(php_curl), class_type); zend_object_std_init(&intern->std, class_type); object_properties_init(&intern->std, class_type); return &intern->std; } static zend_function *curl_get_constructor(zend_object *object) { zend_throw_error(NULL, "Cannot directly construct CurlHandle, use curl_init() instead"); return NULL; } static zend_object *curl_clone_obj(zend_object *object) { php_curl *ch; CURL *cp; zval *postfields; zend_object *clone_object; php_curl *clone_ch; clone_object = curl_create_object(curl_ce); clone_ch = curl_from_obj(clone_object); init_curl_handle(clone_ch); ch = curl_from_obj(object); cp = curl_easy_duphandle(ch->cp); if (!cp) { zend_throw_exception(NULL, "Failed to clone CurlHandle", 0); return &clone_ch->std; } clone_ch->cp = cp; _php_setup_easy_copy_handlers(clone_ch, ch); postfields = &ch->postfields; if (Z_TYPE_P(postfields) != IS_UNDEF) { if (build_mime_structure_from_hash(clone_ch, postfields) == FAILURE) { zend_throw_exception(NULL, "Failed to clone CurlHandle", 0); return &clone_ch->std; } } return &clone_ch->std; } static HashTable *curl_get_gc(zend_object *object, zval **table, int *n) { php_curl *curl = curl_from_obj(object); zend_get_gc_buffer *gc_buffer = zend_get_gc_buffer_create(); zend_get_gc_buffer_add_zval(gc_buffer, &curl->postfields); if (curl->handlers.read) { if (ZEND_FCC_INITIALIZED(curl->handlers.read->fcc)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.read->fcc); } zend_get_gc_buffer_add_zval(gc_buffer, &curl->handlers.read->stream); } if (curl->handlers.write) { if (ZEND_FCC_INITIALIZED(curl->handlers.write->fcc)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.write->fcc); } zend_get_gc_buffer_add_zval(gc_buffer, &curl->handlers.write->stream); } if (curl->handlers.write_header) { if (ZEND_FCC_INITIALIZED(curl->handlers.write_header->fcc)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.write_header->fcc); } zend_get_gc_buffer_add_zval(gc_buffer, &curl->handlers.write_header->stream); } if (ZEND_FCC_INITIALIZED(curl->handlers.progress)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.progress); } if (ZEND_FCC_INITIALIZED(curl->handlers.xferinfo)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.xferinfo); } if (ZEND_FCC_INITIALIZED(curl->handlers.fnmatch)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.fnmatch); } if (ZEND_FCC_INITIALIZED(curl->handlers.debug)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.debug); } #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ if (ZEND_FCC_INITIALIZED(curl->handlers.prereq)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.prereq); } #endif #if LIBCURL_VERSION_NUM >= 0x075400 /* Available since 7.84.0 */ if (ZEND_FCC_INITIALIZED(curl->handlers.sshhostkey)) { zend_get_gc_buffer_add_fcc(gc_buffer, &curl->handlers.sshhostkey); } #endif zend_get_gc_buffer_add_zval(gc_buffer, &curl->handlers.std_err); zend_get_gc_buffer_add_zval(gc_buffer, &curl->private_data); zend_get_gc_buffer_use(gc_buffer, table, n); /* CurlHandle can never have properties as it's final and has strict-properties on. * Avoid building a hash table. */ return NULL; } zend_result curl_cast_object(zend_object *obj, zval *result, int type) { if (type == IS_LONG) { /* For better backward compatibility, make (int) $curl_handle return the object ID, * similar to how it previously returned the resource ID. */ ZVAL_LONG(result, obj->handle); return SUCCESS; } return zend_std_cast_object_tostring(obj, result, type); } /* {{{ PHP_MSHUTDOWN_FUNCTION */ PHP_MSHUTDOWN_FUNCTION(curl) { curl_global_cleanup(); UNREGISTER_INI_ENTRIES(); return SUCCESS; } /* }}} */ /* {{{ curl_write */ static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx) { php_curl *ch = (php_curl *) ctx; php_curl_write *write_handler = ch->handlers.write; size_t length = size * nmemb; #if PHP_CURL_DEBUG fprintf(stderr, "curl_write() called\n"); fprintf(stderr, "data = %s, size = %d, nmemb = %d, ctx = %x\n", data, size, nmemb, ctx); #endif switch (write_handler->method) { case PHP_CURL_STDOUT: PHPWRITE(data, length); break; case PHP_CURL_FILE: return fwrite(data, size, nmemb, write_handler->fp); case PHP_CURL_RETURN: if (length > 0) { smart_str_appendl(&write_handler->buf, data, (int) length); } break; case PHP_CURL_USER: { zval argv[2]; zval retval; GC_ADDREF(&ch->std); ZVAL_OBJ(&argv[0], &ch->std); ZVAL_STRINGL(&argv[1], data, length); ch->in_callback = true; zend_call_known_fcc(&write_handler->fcc, &retval, /* param_count */ 2, argv, /* named_params */ NULL); ch->in_callback = false; if (!Z_ISUNDEF(retval)) { _php_curl_verify_handlers(ch, /* reporterror */ true); /* TODO Check callback returns an int or something castable to int */ length = php_curl_get_long(&retval); } zval_ptr_dtor(&argv[0]); zval_ptr_dtor(&argv[1]); break; } } return length; } /* }}} */ /* {{{ curl_fnmatch */ static int curl_fnmatch(void *ctx, const char *pattern, const char *string) { php_curl *ch = (php_curl *) ctx; int rval = CURL_FNMATCHFUNC_FAIL; zval argv[3]; zval retval; GC_ADDREF(&ch->std); ZVAL_OBJ(&argv[0], &ch->std); ZVAL_STRING(&argv[1], pattern); ZVAL_STRING(&argv[2], string); ch->in_callback = true; zend_call_known_fcc(&ch->handlers.fnmatch, &retval, /* param_count */ 3, argv, /* named_params */ NULL); ch->in_callback = false; if (!Z_ISUNDEF(retval)) { _php_curl_verify_handlers(ch, /* reporterror */ true); /* TODO Check callback returns an int or something castable to int */ rval = php_curl_get_long(&retval); } zval_ptr_dtor(&argv[0]); zval_ptr_dtor(&argv[1]); zval_ptr_dtor(&argv[2]); return rval; } /* }}} */ /* {{{ curl_progress */ static int curl_progress(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow) { php_curl *ch = (php_curl *)clientp; int rval = 0; #if PHP_CURL_DEBUG fprintf(stderr, "curl_progress() called\n"); fprintf(stderr, "clientp = %x, dltotal = %f, dlnow = %f, ultotal = %f, ulnow = %f\n", clientp, dltotal, dlnow, ultotal, ulnow); #endif zval args[5]; zval retval; GC_ADDREF(&ch->std); ZVAL_OBJ(&args[0], &ch->std); ZVAL_LONG(&args[1], (zend_long)dltotal); ZVAL_LONG(&args[2], (zend_long)dlnow); ZVAL_LONG(&args[3], (zend_long)ultotal); ZVAL_LONG(&args[4], (zend_long)ulnow); ch->in_callback = true; zend_call_known_fcc(&ch->handlers.progress, &retval, /* param_count */ 5, args, /* named_params */ NULL); ch->in_callback = false; if (!Z_ISUNDEF(retval)) { _php_curl_verify_handlers(ch, /* reporterror */ true); /* TODO Check callback returns an int or something castable to int */ if (0 != php_curl_get_long(&retval)) { rval = 1; } } zval_ptr_dtor(&args[0]); return rval; } /* }}} */ /* {{{ curl_xferinfo */ static int curl_xferinfo(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow) { php_curl *ch = (php_curl *)clientp; int rval = 0; #if PHP_CURL_DEBUG fprintf(stderr, "curl_xferinfo() called\n"); fprintf(stderr, "clientp = %x, dltotal = %ld, dlnow = %ld, ultotal = %ld, ulnow = %ld\n", clientp, dltotal, dlnow, ultotal, ulnow); #endif zval argv[5]; zval retval; GC_ADDREF(&ch->std); ZVAL_OBJ(&argv[0], &ch->std); ZVAL_LONG(&argv[1], dltotal); ZVAL_LONG(&argv[2], dlnow); ZVAL_LONG(&argv[3], ultotal); ZVAL_LONG(&argv[4], ulnow); ch->in_callback = true; zend_call_known_fcc(&ch->handlers.xferinfo, &retval, /* param_count */ 5, argv, /* named_params */ NULL); ch->in_callback = false; if (!Z_ISUNDEF(retval)) { _php_curl_verify_handlers(ch, /* reporterror */ true); /* TODO Check callback returns an int or something castable to int */ if (0 != php_curl_get_long(&retval)) { rval = 1; } } zval_ptr_dtor(&argv[0]); return rval; } /* }}} */ #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ static int curl_prereqfunction(void *clientp, char *conn_primary_ip, char *conn_local_ip, int conn_primary_port, int conn_local_port) { php_curl *ch = (php_curl *)clientp; int rval = CURL_PREREQFUNC_OK; // when CURLOPT_PREREQFUNCTION is set to null, curl_prereqfunction still // gets called. Return CURL_PREREQFUNC_OK immediately in this case to avoid // zend_call_known_fcc() with an uninitialized FCC. if (!ZEND_FCC_INITIALIZED(ch->handlers.prereq)) { return rval; } #if PHP_CURL_DEBUG fprintf(stderr, "curl_prereqfunction() called\n"); fprintf(stderr, "conn_primary_ip = %s, conn_local_ip = %s, conn_primary_port = %d, conn_local_port = %d\n", conn_primary_ip, conn_local_ip, conn_primary_port, conn_local_port); #endif zval args[5]; zval retval; GC_ADDREF(&ch->std); ZVAL_OBJ(&args[0], &ch->std); ZVAL_STRING(&args[1], conn_primary_ip); ZVAL_STRING(&args[2], conn_local_ip); ZVAL_LONG(&args[3], conn_primary_port); ZVAL_LONG(&args[4], conn_local_port); ch->in_callback = true; zend_call_known_fcc(&ch->handlers.prereq, &retval, /* param_count */ 5, args, /* named_params */ NULL); ch->in_callback = false; if (!Z_ISUNDEF(retval)) { _php_curl_verify_handlers(ch, /* reporterror */ true); if (Z_TYPE(retval) == IS_LONG) { zend_long retval_long = Z_LVAL(retval); if (retval_long == CURL_PREREQFUNC_OK || retval_long == CURL_PREREQFUNC_ABORT) { rval = retval_long; } else { zend_value_error("The CURLOPT_PREREQFUNCTION callback must return either CURL_PREREQFUNC_OK or CURL_PREREQFUNC_ABORT"); } } else { zend_type_error("The CURLOPT_PREREQFUNCTION callback must return either CURL_PREREQFUNC_OK or CURL_PREREQFUNC_ABORT"); } } zval_ptr_dtor(&args[0]); zval_ptr_dtor(&args[1]); zval_ptr_dtor(&args[2]); return rval; } #endif #if LIBCURL_VERSION_NUM >= 0x075400 /* Available since 7.84.0 */ static int curl_ssh_hostkeyfunction(void *clientp, int keytype, const char *key, size_t keylen) { php_curl *ch = (php_curl *)clientp; int rval = CURLKHMATCH_MISMATCH; /* cancel connection in case of an exception */ #if PHP_CURL_DEBUG fprintf(stderr, "curl_ssh_hostkeyfunction() called\n"); fprintf(stderr, "clientp = %x, keytype = %d, key = %s, keylen = %zu\n", clientp, keytype, key, keylen); #endif zval args[4]; zval retval; GC_ADDREF(&ch->std); ZVAL_OBJ(&args[0], &ch->std); ZVAL_LONG(&args[1], keytype); ZVAL_STRINGL(&args[2], key, keylen); ZVAL_LONG(&args[3], keylen); ch->in_callback = true; zend_call_known_fcc(&ch->handlers.sshhostkey, &retval, /* param_count */ 4, args, /* named_params */ NULL); ch->in_callback = false; if (!Z_ISUNDEF(retval)) { _php_curl_verify_handlers(ch, /* reporterror */ true); if (Z_TYPE(retval) == IS_LONG) { zend_long retval_long = Z_LVAL(retval); if (retval_long == CURLKHMATCH_OK || retval_long == CURLKHMATCH_MISMATCH) { rval = retval_long; } else { zend_throw_error(NULL, "The CURLOPT_SSH_HOSTKEYFUNCTION callback must return either CURLKHMATCH_OK or CURLKHMATCH_MISMATCH"); } } else { zend_throw_error(NULL, "The CURLOPT_SSH_HOSTKEYFUNCTION callback must return either CURLKHMATCH_OK or CURLKHMATCH_MISMATCH"); zval_ptr_dtor(&retval); } } zval_ptr_dtor(&args[0]); zval_ptr_dtor(&args[2]); return rval; } #endif /* {{{ curl_read */ static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx) { php_curl *ch = (php_curl *)ctx; php_curl_read *read_handler = ch->handlers.read; size_t length = 0; switch (read_handler->method) { case PHP_CURL_DIRECT: if (read_handler->fp) { length = fread(data, size, nmemb, read_handler->fp); } break; case PHP_CURL_USER: { zval argv[3]; zval retval; GC_ADDREF(&ch->std); ZVAL_OBJ(&argv[0], &ch->std); if (read_handler->res) { GC_ADDREF(read_handler->res); ZVAL_RES(&argv[1], read_handler->res); } else { ZVAL_NULL(&argv[1]); } ZVAL_LONG(&argv[2], (int)size * nmemb); ch->in_callback = true; zend_call_known_fcc(&read_handler->fcc, &retval, /* param_count */ 3, argv, /* named_params */ NULL); ch->in_callback = false; if (!Z_ISUNDEF(retval)) { _php_curl_verify_handlers(ch, /* reporterror */ true); if (Z_TYPE(retval) == IS_STRING) { length = MIN((size * nmemb), Z_STRLEN(retval)); memcpy(data, Z_STRVAL(retval), length); } else if (Z_TYPE(retval) == IS_LONG) { length = Z_LVAL_P(&retval); } // TODO Do type error if invalid type? zval_ptr_dtor(&retval); } zval_ptr_dtor(&argv[0]); zval_ptr_dtor(&argv[1]); break; } } return length; } /* }}} */ /* {{{ curl_write_header */ static size_t curl_write_header(char *data, size_t size, size_t nmemb, void *ctx) { php_curl *ch = (php_curl *) ctx; php_curl_write *write_handler = ch->handlers.write_header; size_t length = size * nmemb; switch (write_handler->method) { case PHP_CURL_STDOUT: /* Handle special case write when we're returning the entire transfer */ if (ch->handlers.write->method == PHP_CURL_RETURN && length > 0) { smart_str_appendl(&ch->handlers.write->buf, data, (int) length); } else { PHPWRITE(data, length); } break; case PHP_CURL_FILE: return fwrite(data, size, nmemb, write_handler->fp); case PHP_CURL_USER: { zval argv[2]; zval retval; GC_ADDREF(&ch->std); ZVAL_OBJ(&argv[0], &ch->std); ZVAL_STRINGL(&argv[1], data, length); ch->in_callback = true; zend_call_known_fcc(&write_handler->fcc, &retval, /* param_count */ 2, argv, /* named_params */ NULL); ch->in_callback = false; if (!Z_ISUNDEF(retval)) { // TODO: Check for valid int type for return value _php_curl_verify_handlers(ch, /* reporterror */ true); length = php_curl_get_long(&retval); } zval_ptr_dtor(&argv[0]); zval_ptr_dtor(&argv[1]); break; } case PHP_CURL_IGNORE: return length; default: return -1; } return length; } /* }}} */ static int curl_debug(CURL *handle, curl_infotype type, char *data, size_t size, void *clientp) /* {{{ */ { php_curl *ch = (php_curl *)clientp; #if PHP_CURL_DEBUG fprintf(stderr, "curl_debug() called\n"); fprintf(stderr, "type = %d, data = %s\n", type, data); #endif // Implicitly store the headers for compatibility with CURLINFO_HEADER_OUT // used as a Curl option. Previously, setting CURLINFO_HEADER_OUT set curl_debug // as the CURLOPT_DEBUGFUNCTION and stored the debug data when type is set to // CURLINFO_HEADER_OUT. For backward compatibility, we now store the headers // but also call the user-callback function if available. if (type == CURLINFO_HEADER_OUT) { if (ch->header.str) { zend_string_release_ex(ch->header.str, 0); } ch->header.str = zend_string_init(data, size, 0); } if (!ZEND_FCC_INITIALIZED(ch->handlers.debug)) { return 0; } zval args[3]; GC_ADDREF(&ch->std); ZVAL_OBJ(&args[0], &ch->std); ZVAL_LONG(&args[1], type); ZVAL_STRINGL(&args[2], data, size); ch->in_callback = true; zend_call_known_fcc(&ch->handlers.debug, NULL, /* param_count */ 3, args, /* named_params */ NULL); ch->in_callback = false; zval_ptr_dtor(&args[0]); zval_ptr_dtor(&args[2]); return 0; } /* }}} */ /* {{{ curl_free_post */ static void curl_free_post(void **post) { curl_mime_free((curl_mime *)*post); } /* }}} */ struct mime_data_cb_arg { zend_string *filename; php_stream *stream; }; /* {{{ curl_free_cb_arg */ static void curl_free_cb_arg(void **cb_arg_p) { struct mime_data_cb_arg *cb_arg = (struct mime_data_cb_arg *) *cb_arg_p; ZEND_ASSERT(cb_arg->stream == NULL); zend_string_release(cb_arg->filename); efree(cb_arg); } /* }}} */ /* {{{ curl_free_slist */ static void curl_free_slist(zval *el) { curl_slist_free_all(((struct curl_slist *)Z_PTR_P(el))); } /* }}} */ /* {{{ Return cURL version information. */ PHP_FUNCTION(curl_version) { curl_version_info_data *d; ZEND_PARSE_PARAMETERS_NONE(); d = curl_version_info(CURLVERSION_NOW); if (d == NULL) { RETURN_FALSE; } array_init(return_value); CAAL("version_number", d->version_num); CAAL("age", d->age); CAAL("features", d->features); /* Add an array of features */ { struct feat { const char *name; int bitmask; }; unsigned int i; zval feature_list; array_init(&feature_list); /* Sync this list with PHP_MINFO_FUNCTION(curl) as well */ static const struct feat feats[] = { {"AsynchDNS", CURL_VERSION_ASYNCHDNS}, {"CharConv", CURL_VERSION_CONV}, {"Debug", CURL_VERSION_DEBUG}, {"GSS-Negotiate", CURL_VERSION_GSSNEGOTIATE}, {"IDN", CURL_VERSION_IDN}, {"IPv6", CURL_VERSION_IPV6}, {"krb4", CURL_VERSION_KERBEROS4}, {"Largefile", CURL_VERSION_LARGEFILE}, {"libz", CURL_VERSION_LIBZ}, {"NTLM", CURL_VERSION_NTLM}, {"NTLMWB", CURL_VERSION_NTLM_WB}, {"SPNEGO", CURL_VERSION_SPNEGO}, {"SSL", CURL_VERSION_SSL}, {"SSPI", CURL_VERSION_SSPI}, {"TLS-SRP", CURL_VERSION_TLSAUTH_SRP}, {"HTTP2", CURL_VERSION_HTTP2}, {"GSSAPI", CURL_VERSION_GSSAPI}, {"KERBEROS5", CURL_VERSION_KERBEROS5}, {"UNIX_SOCKETS", CURL_VERSION_UNIX_SOCKETS}, {"PSL", CURL_VERSION_PSL}, {"HTTPS_PROXY", CURL_VERSION_HTTPS_PROXY}, {"MULTI_SSL", CURL_VERSION_MULTI_SSL}, {"BROTLI", CURL_VERSION_BROTLI}, #if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ {"ALTSVC", CURL_VERSION_ALTSVC}, #endif #if LIBCURL_VERSION_NUM >= 0x074200 /* Available since 7.66.0 */ {"HTTP3", CURL_VERSION_HTTP3}, #endif #if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ {"UNICODE", CURL_VERSION_UNICODE}, {"ZSTD", CURL_VERSION_ZSTD}, #endif #if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ {"HSTS", CURL_VERSION_HSTS}, #endif #if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ {"GSASL", CURL_VERSION_GSASL}, #endif }; for(i = 0; i < sizeof(feats) / sizeof(feats[0]); i++) { if (feats[i].name) { add_assoc_bool(&feature_list, feats[i].name, d->features & feats[i].bitmask ? true : false); } } CAAZ("feature_list", &feature_list); } CAAL("ssl_version_number", d->ssl_version_num); CAAS("version", d->version); CAAS("host", d->host); CAAS("ssl_version", d->ssl_version); CAAS("libz_version", d->libz_version); /* Add an array of protocols */ { char **p = (char **) d->protocols; zval protocol_list; array_init(&protocol_list); while (*p != NULL) { add_next_index_string(&protocol_list, *p); p++; } CAAZ("protocols", &protocol_list); } if (d->age >= 1) { CAAS("ares", d->ares); CAAL("ares_num", d->ares_num); } if (d->age >= 2) { CAAS("libidn", d->libidn); } if (d->age >= 3) { CAAL("iconv_ver_num", d->iconv_ver_num); CAAS("libssh_version", d->libssh_version); } if (d->age >= 4) { CAAL("brotli_ver_num", d->brotli_ver_num); CAAS("brotli_version", d->brotli_version); } } /* }}} */ php_curl *init_curl_handle_into_zval(zval *curl) { php_curl *ch; object_init_ex(curl, curl_ce); ch = Z_CURL_P(curl); init_curl_handle(ch); return ch; } void init_curl_handle(php_curl *ch) { ch->to_free = ecalloc(1, sizeof(struct _php_curl_free)); 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 = empty_fcall_info_cache; ch->handlers.xferinfo = empty_fcall_info_cache; ch->handlers.fnmatch = empty_fcall_info_cache; ch->handlers.debug = empty_fcall_info_cache; #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ ch->handlers.prereq = empty_fcall_info_cache; #endif #if LIBCURL_VERSION_NUM >= 0x075400 /* Available since 7.84.0 */ ch->handlers.sshhostkey = empty_fcall_info_cache; #endif ch->clone = emalloc(sizeof(uint32_t)); *ch->clone = 1; memset(&ch->err, 0, sizeof(struct _php_curl_error)); zend_llist_init(&ch->to_free->post, sizeof(struct HttpPost *), (llist_dtor_func_t)curl_free_post, 0); zend_llist_init(&ch->to_free->stream, sizeof(struct mime_data_cb_arg *), (llist_dtor_func_t)curl_free_cb_arg, 0); zend_hash_init(&ch->to_free->slist, 4, NULL, curl_free_slist, 0); ZVAL_UNDEF(&ch->postfields); } /* }}} */ /* {{{ create_certinfo */ static void create_certinfo(struct curl_certinfo *ci, zval *listcode) { int i; if (ci) { zval certhash; for (i=0; inum_of_certs; i++) { struct curl_slist *slist; array_init(&certhash); for (slist = ci->certinfo[i]; slist; slist = slist->next) { char s[64]; char *tmp; strncpy(s, slist->data, sizeof(s)); s[sizeof(s)-1] = '\0'; tmp = memchr(s, ':', sizeof(s)); if(tmp) { *tmp = '\0'; size_t len = strlen(s); add_assoc_string(&certhash, s, &slist->data[len+1]); } else { php_error_docref(NULL, E_WARNING, "Could not extract hash key from certificate info"); } } add_next_index_zval(listcode, &certhash); } } } /* }}} */ /* {{{ _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, 1L); curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 0L); 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_CACHE_TIMEOUT, 120L); curl_easy_setopt(ch->cp, CURLOPT_MAXREDIRS, 20L); /* prevent infinite redirects */ cainfo = INI_STR("openssl.cafile"); if (!(cainfo && cainfo[0] != '\0')) { cainfo = INI_STR("curl.cainfo"); } if (cainfo && cainfo[0] != '\0') { curl_easy_setopt(ch->cp, CURLOPT_CAINFO, cainfo); } #ifdef ZTS curl_easy_setopt(ch->cp, CURLOPT_NOSIGNAL, 1L); #endif } /* }}} */ /* {{{ Initialize a cURL session */ PHP_FUNCTION(curl_init) { php_curl *ch; CURL *cp; zend_string *url = NULL; ZEND_PARSE_PARAMETERS_START(0,1) Z_PARAM_OPTIONAL Z_PARAM_STR_OR_NULL(url) ZEND_PARSE_PARAMETERS_END(); cp = curl_easy_init(); if (!cp) { php_error_docref(NULL, E_WARNING, "Could not initialize a new cURL handle"); RETURN_FALSE; } ch = init_curl_handle_into_zval(return_value); ch->cp = cp; ch->handlers.write->method = PHP_CURL_STDOUT; ch->handlers.read->method = PHP_CURL_DIRECT; ch->handlers.write_header->method = PHP_CURL_IGNORE; _php_curl_set_default_options(ch); if (url) { if (php_curl_option_url(ch, url) == FAILURE) { zval_ptr_dtor(return_value); RETURN_FALSE; } } } /* }}} */ static void php_curl_copy_fcc_with_option(php_curl *ch, CURLoption option, zend_fcall_info_cache *target_fcc, zend_fcall_info_cache *source_fcc) { if (ZEND_FCC_INITIALIZED(*source_fcc)) { zend_fcc_dup(target_fcc, source_fcc); curl_easy_setopt(ch->cp, option, (void *) ch); } } void _php_setup_easy_copy_handlers(php_curl *ch, php_curl *source) { if (!Z_ISUNDEF(source->handlers.write->stream)) { Z_ADDREF(source->handlers.write->stream); } ch->handlers.write->stream = source->handlers.write->stream; ch->handlers.write->method = source->handlers.write->method; if (!Z_ISUNDEF(source->handlers.read->stream)) { Z_ADDREF(source->handlers.read->stream); } ch->handlers.read->stream = source->handlers.read->stream; ch->handlers.read->method = source->handlers.read->method; ch->handlers.write_header->method = source->handlers.write_header->method; if (!Z_ISUNDEF(source->handlers.write_header->stream)) { Z_ADDREF(source->handlers.write_header->stream); } ch->handlers.write_header->stream = source->handlers.write_header->stream; ch->handlers.write->fp = source->handlers.write->fp; ch->handlers.write_header->fp = source->handlers.write_header->fp; ch->handlers.read->fp = source->handlers.read->fp; ch->handlers.read->res = source->handlers.read->res; if (ZEND_FCC_INITIALIZED(source->handlers.read->fcc)) { zend_fcc_dup(&ch->handlers.read->fcc, &source->handlers.read->fcc); } if (ZEND_FCC_INITIALIZED(source->handlers.write->fcc)) { zend_fcc_dup(&ch->handlers.write->fcc, &source->handlers.write->fcc); } if (ZEND_FCC_INITIALIZED(source->handlers.write_header->fcc)) { zend_fcc_dup(&ch->handlers.write_header->fcc, &source->handlers.write_header->fcc); } curl_easy_setopt(ch->cp, CURLOPT_ERRORBUFFER, ch->err.str); curl_easy_setopt(ch->cp, CURLOPT_FILE, (void *) ch); curl_easy_setopt(ch->cp, CURLOPT_INFILE, (void *) ch); curl_easy_setopt(ch->cp, CURLOPT_WRITEHEADER, (void *) ch); curl_easy_setopt(ch->cp, CURLOPT_DEBUGDATA, (void *) ch); php_curl_copy_fcc_with_option(ch, CURLOPT_PROGRESSDATA, &ch->handlers.progress, &source->handlers.progress); php_curl_copy_fcc_with_option(ch, CURLOPT_XFERINFODATA, &ch->handlers.xferinfo, &source->handlers.xferinfo); php_curl_copy_fcc_with_option(ch, CURLOPT_FNMATCH_DATA, &ch->handlers.fnmatch, &source->handlers.fnmatch); php_curl_copy_fcc_with_option(ch, CURLOPT_DEBUGDATA, &ch->handlers.debug, &source->handlers.debug); #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ php_curl_copy_fcc_with_option(ch, CURLOPT_PREREQDATA, &ch->handlers.prereq, &source->handlers.prereq); #endif #if LIBCURL_VERSION_NUM >= 0x075400 /* Available since 7.84.0 */ php_curl_copy_fcc_with_option(ch, CURLOPT_SSH_HOSTKEYDATA, &ch->handlers.sshhostkey, &source->handlers.sshhostkey); #endif ZVAL_COPY(&ch->private_data, &source->private_data); efree(ch->to_free); ch->to_free = source->to_free; efree(ch->clone); ch->clone = source->clone; /* Keep track of cloned copies to avoid invoking curl destructors for every clone */ (*source->clone)++; } zend_long php_curl_get_long(zval *zv) { if (EXPECTED(Z_TYPE_P(zv) == IS_LONG)) { return Z_LVAL_P(zv); } else { zend_long ret = zval_get_long(zv); zval_ptr_dtor(zv); return ret; } } static size_t read_cb(char *buffer, size_t size, size_t nitems, void *arg) /* {{{ */ { struct mime_data_cb_arg *cb_arg = (struct mime_data_cb_arg *) arg; ssize_t numread; if (cb_arg->stream == NULL) { if (!(cb_arg->stream = php_stream_open_wrapper(ZSTR_VAL(cb_arg->filename), "rb", IGNORE_PATH, NULL))) { return CURL_READFUNC_ABORT; } } numread = php_stream_read(cb_arg->stream, buffer, nitems * size); if (numread < 0) { php_stream_close(cb_arg->stream); cb_arg->stream = NULL; return CURL_READFUNC_ABORT; } return numread; } /* }}} */ static int seek_cb(void *arg, curl_off_t offset, int origin) /* {{{ */ { struct mime_data_cb_arg *cb_arg = (struct mime_data_cb_arg *) arg; int res; if (cb_arg->stream == NULL) { return CURL_SEEKFUNC_CANTSEEK; } res = php_stream_seek(cb_arg->stream, offset, origin); return res == SUCCESS ? CURL_SEEKFUNC_OK : CURL_SEEKFUNC_CANTSEEK; } /* }}} */ static void free_cb(void *arg) /* {{{ */ { struct mime_data_cb_arg *cb_arg = (struct mime_data_cb_arg *) arg; if (cb_arg->stream != NULL) { php_stream_close(cb_arg->stream); cb_arg->stream = NULL; } } /* }}} */ static inline CURLcode add_simple_field(curl_mime *mime, zend_string *string_key, zval *current) { CURLcode error = CURLE_OK; curl_mimepart *part; CURLcode form_error; zend_string *postval, *tmp_postval; postval = zval_get_tmp_string(current, &tmp_postval); part = curl_mime_addpart(mime); if (part == NULL) { zend_tmp_string_release(tmp_postval); return CURLE_OUT_OF_MEMORY; } if ((form_error = curl_mime_name(part, ZSTR_VAL(string_key))) != CURLE_OK || (form_error = curl_mime_data(part, ZSTR_VAL(postval), ZSTR_LEN(postval))) != CURLE_OK) { error = form_error; } zend_tmp_string_release(tmp_postval); return error; } static inline zend_result build_mime_structure_from_hash(php_curl *ch, zval *zpostfields) /* {{{ */ { HashTable *postfields = Z_ARRVAL_P(zpostfields); CURLcode error = CURLE_OK; zval *current; zend_string *string_key; zend_ulong num_key; curl_mime *mime = NULL; curl_mimepart *part; CURLcode form_error; if (zend_hash_num_elements(postfields) > 0) { mime = curl_mime_init(ch->cp); if (mime == NULL) { return FAILURE; } } ZEND_HASH_FOREACH_KEY_VAL(postfields, num_key, string_key, current) { zend_string *postval; /* Pretend we have a string_key here */ if (!string_key) { string_key = zend_long_to_str(num_key); } else { zend_string_addref(string_key); } ZVAL_DEREF(current); if (Z_TYPE_P(current) == IS_OBJECT && instanceof_function(Z_OBJCE_P(current), curl_CURLFile_class)) { /* new-style file upload */ zval *prop, rv; char *type = NULL, *filename = NULL; struct mime_data_cb_arg *cb_arg; php_stream_statbuf ssb; size_t filesize = -1; curl_seek_callback seekfunc = seek_cb; prop = zend_read_property_ex(curl_CURLFile_class, Z_OBJ_P(current), ZSTR_KNOWN(ZEND_STR_NAME), /* silent */ false, &rv); ZVAL_DEREF(prop); if (Z_TYPE_P(prop) != IS_STRING) { php_error_docref(NULL, E_WARNING, "Invalid filename for key %s", ZSTR_VAL(string_key)); } else { postval = Z_STR_P(prop); if (php_check_open_basedir(ZSTR_VAL(postval))) { goto out_string; } prop = zend_read_property(curl_CURLFile_class, Z_OBJ_P(current), "mime", sizeof("mime")-1, 0, &rv); ZVAL_DEREF(prop); if (Z_TYPE_P(prop) == IS_STRING && Z_STRLEN_P(prop) > 0) { type = Z_STRVAL_P(prop); } prop = zend_read_property(curl_CURLFile_class, Z_OBJ_P(current), "postname", sizeof("postname")-1, 0, &rv); ZVAL_DEREF(prop); if (Z_TYPE_P(prop) == IS_STRING && Z_STRLEN_P(prop) > 0) { filename = Z_STRVAL_P(prop); } zval_ptr_dtor(&ch->postfields); ZVAL_COPY(&ch->postfields, zpostfields); php_stream *stream; if ((stream = php_stream_open_wrapper(ZSTR_VAL(postval), "rb", STREAM_MUST_SEEK, NULL))) { if (!stream->readfilters.head && !php_stream_stat(stream, &ssb)) { filesize = ssb.sb.st_size; } } else { seekfunc = NULL; } part = curl_mime_addpart(mime); if (part == NULL) { if (stream) { php_stream_close(stream); } goto out_string; } cb_arg = emalloc(sizeof *cb_arg); cb_arg->filename = zend_string_copy(postval); cb_arg->stream = stream; if ((form_error = curl_mime_name(part, ZSTR_VAL(string_key))) != CURLE_OK || (form_error = curl_mime_data_cb(part, filesize, read_cb, seekfunc, free_cb, cb_arg)) != CURLE_OK || (form_error = curl_mime_filename(part, filename ? filename : ZSTR_VAL(postval))) != CURLE_OK || (form_error = curl_mime_type(part, type ? type : "application/octet-stream")) != CURLE_OK) { error = form_error; } zend_llist_add_element(&ch->to_free->stream, &cb_arg); } zend_string_release_ex(string_key, 0); continue; } if (Z_TYPE_P(current) == IS_OBJECT && instanceof_function(Z_OBJCE_P(current), curl_CURLStringFile_class)) { /* new-style file upload from string */ zval *prop, rv; char *type = NULL, *filename = NULL; prop = zend_read_property(curl_CURLStringFile_class, Z_OBJ_P(current), "postname", sizeof("postname")-1, 0, &rv); if (EG(exception)) { goto out_string; } ZVAL_DEREF(prop); ZEND_ASSERT(Z_TYPE_P(prop) == IS_STRING); filename = Z_STRVAL_P(prop); prop = zend_read_property(curl_CURLStringFile_class, Z_OBJ_P(current), "mime", sizeof("mime")-1, 0, &rv); if (EG(exception)) { goto out_string; } ZVAL_DEREF(prop); ZEND_ASSERT(Z_TYPE_P(prop) == IS_STRING); type = Z_STRVAL_P(prop); prop = zend_read_property(curl_CURLStringFile_class, Z_OBJ_P(current), "data", sizeof("data")-1, 0, &rv); if (EG(exception)) { goto out_string; } ZVAL_DEREF(prop); ZEND_ASSERT(Z_TYPE_P(prop) == IS_STRING); postval = Z_STR_P(prop); zval_ptr_dtor(&ch->postfields); ZVAL_COPY(&ch->postfields, zpostfields); part = curl_mime_addpart(mime); if (part == NULL) { goto out_string; } if ((form_error = curl_mime_name(part, ZSTR_VAL(string_key))) != CURLE_OK || (form_error = curl_mime_data(part, ZSTR_VAL(postval), ZSTR_LEN(postval))) != CURLE_OK || (form_error = curl_mime_filename(part, filename)) != CURLE_OK || (form_error = curl_mime_type(part, type)) != CURLE_OK) { error = form_error; } zend_string_release_ex(string_key, 0); continue; } if (Z_TYPE_P(current) == IS_ARRAY) { zval *current_element; ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(current), current_element) { add_simple_field(mime, string_key, current_element); } ZEND_HASH_FOREACH_END(); zend_string_release_ex(string_key, 0); continue; } add_simple_field(mime, string_key, current); zend_string_release_ex(string_key, 0); } ZEND_HASH_FOREACH_END(); SAVE_CURL_ERROR(ch, error); if (error != CURLE_OK) { goto out_mime; } if ((*ch->clone) == 1) { zend_llist_clean(&ch->to_free->post); } zend_llist_add_element(&ch->to_free->post, &mime); error = curl_easy_setopt(ch->cp, CURLOPT_MIMEPOST, mime); SAVE_CURL_ERROR(ch, error); return error == CURLE_OK ? SUCCESS : FAILURE; out_string: zend_string_release_ex(string_key, false); out_mime: curl_mime_free(mime); return FAILURE; } /* }}} */ /* {{{ Copy a cURL handle along with all of it's preferences */ PHP_FUNCTION(curl_copy_handle) { zval *zid; ZEND_PARSE_PARAMETERS_START(1,1) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) ZEND_PARSE_PARAMETERS_END(); zend_object *new_object = Z_OBJ_P(zid)->handlers->clone_obj(Z_OBJ_P(zid)); if (EG(exception)) { if (new_object != NULL) { OBJ_RELEASE(new_object); } zend_clear_exception(); php_error_docref(NULL, E_WARNING, "Cannot duplicate cURL handle"); RETURN_FALSE; } RETURN_OBJ(new_object); } /* }}} */ static bool php_curl_set_callable_handler(zend_fcall_info_cache *const handler_fcc, zval *callable, bool is_array_config, const char *option_name) { if (ZEND_FCC_INITIALIZED(*handler_fcc)) { zend_fcc_dtor(handler_fcc); } if (Z_TYPE_P(callable) == IS_NULL) { return true; } char *error = NULL; if (UNEXPECTED(!zend_is_callable_ex(callable, /* object */ NULL, /* check_flags */ 0, /* callable_name */ NULL, handler_fcc, /* error */ &error))) { if (!EG(exception)) { zend_argument_type_error(2 + !is_array_config, "must be a valid callback for option %s, %s", option_name, error); } efree(error); return false; } zend_fcc_addref(handler_fcc); return true; } #define HANDLE_CURL_OPTION_CALLABLE_PHP_CURL_USER(curl_ptr, constant_no_function, handler_type, default_method) \ case constant_no_function##FUNCTION: { \ bool result = php_curl_set_callable_handler(&curl_ptr->handlers.handler_type->fcc, zvalue, is_array_config, #constant_no_function "FUNCTION"); \ if (!result) { \ curl_ptr->handlers.handler_type->method = default_method; \ return FAILURE; \ } \ if (!ZEND_FCC_INITIALIZED(curl_ptr->handlers.handler_type->fcc)) { \ curl_ptr->handlers.handler_type->method = default_method; \ return SUCCESS; \ } \ curl_ptr->handlers.handler_type->method = PHP_CURL_USER; \ break; \ } #define HANDLE_CURL_OPTION_CALLABLE(curl_ptr, constant_no_function, handler_fcc, c_callback) \ case constant_no_function##FUNCTION: { \ bool result = php_curl_set_callable_handler(&curl_ptr->handler_fcc, zvalue, is_array_config, #constant_no_function "FUNCTION"); \ if (!result) { \ return FAILURE; \ } \ curl_easy_setopt(curl_ptr->cp, constant_no_function##FUNCTION, (c_callback)); \ curl_easy_setopt(curl_ptr->cp, constant_no_function##DATA, curl_ptr); \ break; \ } static zend_result _php_curl_setopt(php_curl *ch, zend_long option, zval *zvalue, bool is_array_config) /* {{{ */ { CURLcode error = CURLE_OK; zend_long lval; switch (option) { /* Callable options */ HANDLE_CURL_OPTION_CALLABLE_PHP_CURL_USER(ch, CURLOPT_WRITE, write, PHP_CURL_STDOUT); HANDLE_CURL_OPTION_CALLABLE_PHP_CURL_USER(ch, CURLOPT_HEADER, write_header, PHP_CURL_IGNORE); HANDLE_CURL_OPTION_CALLABLE_PHP_CURL_USER(ch, CURLOPT_READ, read, PHP_CURL_DIRECT); HANDLE_CURL_OPTION_CALLABLE(ch, CURLOPT_PROGRESS, handlers.progress, curl_progress); HANDLE_CURL_OPTION_CALLABLE(ch, CURLOPT_XFERINFO, handlers.xferinfo, curl_xferinfo); HANDLE_CURL_OPTION_CALLABLE(ch, CURLOPT_FNMATCH_, handlers.fnmatch, curl_fnmatch); HANDLE_CURL_OPTION_CALLABLE(ch, CURLOPT_DEBUG, handlers.debug, curl_debug); #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ HANDLE_CURL_OPTION_CALLABLE(ch, CURLOPT_PREREQ, handlers.prereq, curl_prereqfunction); #endif #if LIBCURL_VERSION_NUM >= 0x075400 /* Available since 7.84.0 */ HANDLE_CURL_OPTION_CALLABLE(ch, CURLOPT_SSH_HOSTKEY, handlers.sshhostkey, curl_ssh_hostkeyfunction); #endif /* Long options */ case CURLOPT_SSL_VERIFYHOST: lval = zval_get_long(zvalue); if (lval == 1) { php_error_docref(NULL, E_NOTICE, "CURLOPT_SSL_VERIFYHOST no longer accepts the value 1, value 2 will be used instead"); error = curl_easy_setopt(ch->cp, option, 2L); break; } ZEND_FALLTHROUGH; case CURLOPT_AUTOREFERER: case CURLOPT_BUFFERSIZE: case CURLOPT_CONNECTTIMEOUT: case CURLOPT_COOKIESESSION: case CURLOPT_CRLF: case CURLOPT_DNS_CACHE_TIMEOUT: case CURLOPT_FAILONERROR: 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_LOW_SPEED_TIME: case CURLOPT_MAXCONNECTS: case CURLOPT_MAXREDIRS: case CURLOPT_NETRC: case CURLOPT_NOBODY: case CURLOPT_NOPROGRESS: case CURLOPT_NOSIGNAL: case CURLOPT_PORT: case CURLOPT_POST: case CURLOPT_PROXYPORT: case CURLOPT_PROXYTYPE: case CURLOPT_PUT: case CURLOPT_RESUME_FROM: case CURLOPT_SSLVERSION: 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: case CURLOPT_HTTPAUTH: case CURLOPT_FTP_CREATE_MISSING_DIRS: case CURLOPT_PROXYAUTH: case CURLOPT_SERVER_RESPONSE_TIMEOUT: case CURLOPT_IPRESOLVE: case CURLOPT_MAXFILESIZE: case CURLOPT_TCP_NODELAY: case CURLOPT_FTPSSLAUTH: case CURLOPT_IGNORE_CONTENT_LENGTH: case CURLOPT_FTP_SKIP_PASV_IP: case CURLOPT_FTP_FILEMETHOD: case CURLOPT_CONNECT_ONLY: case CURLOPT_LOCALPORT: case CURLOPT_LOCALPORTRANGE: case CURLOPT_SSL_SESSIONID_CACHE: case CURLOPT_FTP_SSL_CCC: case CURLOPT_SSH_AUTH_TYPES: case CURLOPT_CONNECTTIMEOUT_MS: case CURLOPT_HTTP_CONTENT_DECODING: case CURLOPT_HTTP_TRANSFER_DECODING: case CURLOPT_TIMEOUT_MS: case CURLOPT_NEW_DIRECTORY_PERMS: case CURLOPT_NEW_FILE_PERMS: case CURLOPT_USE_SSL: case CURLOPT_APPEND: case CURLOPT_DIRLISTONLY: case CURLOPT_PROXY_TRANSFER_MODE: case CURLOPT_ADDRESS_SCOPE: case CURLOPT_CERTINFO: case CURLOPT_PROTOCOLS: case CURLOPT_REDIR_PROTOCOLS: case CURLOPT_SOCKS5_GSSAPI_NEC: case CURLOPT_TFTP_BLKSIZE: case CURLOPT_FTP_USE_PRET: case CURLOPT_RTSP_CLIENT_CSEQ: case CURLOPT_RTSP_REQUEST: case CURLOPT_RTSP_SERVER_CSEQ: case CURLOPT_WILDCARDMATCH: case CURLOPT_GSSAPI_DELEGATION: case CURLOPT_ACCEPTTIMEOUT_MS: case CURLOPT_SSL_OPTIONS: case CURLOPT_TCP_KEEPALIVE: case CURLOPT_TCP_KEEPIDLE: case CURLOPT_TCP_KEEPINTVL: case CURLOPT_SASL_IR: case CURLOPT_EXPECT_100_TIMEOUT_MS: case CURLOPT_SSL_ENABLE_ALPN: case CURLOPT_SSL_ENABLE_NPN: case CURLOPT_HEADEROPT: case CURLOPT_SSL_VERIFYSTATUS: case CURLOPT_PATH_AS_IS: case CURLOPT_SSL_FALSESTART: case CURLOPT_PIPEWAIT: case CURLOPT_STREAM_WEIGHT: case CURLOPT_TFTP_NO_OPTIONS: case CURLOPT_TCP_FASTOPEN: case CURLOPT_KEEP_SENDING_ON_ERROR: case CURLOPT_PROXY_SSL_OPTIONS: case CURLOPT_PROXY_SSL_VERIFYHOST: case CURLOPT_PROXY_SSL_VERIFYPEER: case CURLOPT_PROXY_SSLVERSION: case CURLOPT_SUPPRESS_CONNECT_HEADERS: case CURLOPT_SOCKS5_AUTH: case CURLOPT_SSH_COMPRESSION: case CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS: case CURLOPT_DNS_SHUFFLE_ADDRESSES: case CURLOPT_HAPROXYPROTOCOL: case CURLOPT_DISALLOW_USERNAME_IN_URL: #if LIBCURL_VERSION_NUM >= 0x073E00 /* Available since 7.62.0 */ case CURLOPT_UPKEEP_INTERVAL_MS: case CURLOPT_UPLOAD_BUFFERSIZE: #endif #if LIBCURL_VERSION_NUM >= 0x074000 /* Available since 7.64.0 */ case CURLOPT_HTTP09_ALLOWED: #endif #if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ case CURLOPT_ALTSVC_CTRL: #endif #if LIBCURL_VERSION_NUM >= 0x074100 /* Available since 7.65.0 */ case CURLOPT_MAXAGE_CONN: #endif #if LIBCURL_VERSION_NUM >= 0x074500 /* Available since 7.69.0 */ case CURLOPT_MAIL_RCPT_ALLLOWFAILS: #endif #if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ case CURLOPT_HSTS_CTRL: #endif #if LIBCURL_VERSION_NUM >= 0x074c00 /* Available since 7.76.0 */ case CURLOPT_DOH_SSL_VERIFYHOST: case CURLOPT_DOH_SSL_VERIFYPEER: case CURLOPT_DOH_SSL_VERIFYSTATUS: #endif #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ case CURLOPT_MAXLIFETIME_CONN: #endif #if LIBCURL_VERSION_NUM >= 0x075100 /* Available since 7.81.0 */ case CURLOPT_MIME_OPTIONS: #endif #if LIBCURL_VERSION_NUM >= 0x075600 /* Available since 7.86.0 */ case CURLOPT_WS_OPTIONS: #endif #if LIBCURL_VERSION_NUM >= 0x075700 /* Available since 7.87.0 */ case CURLOPT_CA_CACHE_TIMEOUT: case CURLOPT_QUICK_EXIT: #endif #if LIBCURL_VERSION_NUM >= 0x080900 /* Available since 8.9.0 */ case CURLOPT_TCP_KEEPCNT: #endif case CURLOPT_FOLLOWLOCATION: lval = zval_get_long(zvalue); if ((option == CURLOPT_PROTOCOLS || option == CURLOPT_REDIR_PROTOCOLS) && (PG(open_basedir) && *PG(open_basedir)) && (lval & CURLPROTO_FILE)) { php_error_docref(NULL, E_WARNING, "CURLPROTO_FILE cannot be activated when an open_basedir is set"); return FAILURE; } error = curl_easy_setopt(ch->cp, option, lval); break; case CURLOPT_SAFE_UPLOAD: if (!zend_is_true(zvalue)) { zend_value_error("%s(): Disabling safe uploads is no longer supported", get_active_function_name()); return FAILURE; } break; /* String options */ case CURLOPT_CAINFO: case CURLOPT_CAPATH: case CURLOPT_COOKIE: case CURLOPT_EGDSOCKET: case CURLOPT_INTERFACE: case CURLOPT_PROXY: case CURLOPT_PROXYUSERPWD: case CURLOPT_REFERER: case CURLOPT_SSLCERTTYPE: case CURLOPT_SSLENGINE: case CURLOPT_SSLENGINE_DEFAULT: case CURLOPT_SSLKEY: case CURLOPT_SSLKEYPASSWD: case CURLOPT_SSLKEYTYPE: case CURLOPT_SSL_CIPHER_LIST: case CURLOPT_USERAGENT: case CURLOPT_COOKIELIST: case CURLOPT_FTP_ALTERNATIVE_TO_USER: case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5: case CURLOPT_PROXYPASSWORD: case CURLOPT_PROXYUSERNAME: case CURLOPT_NOPROXY: case CURLOPT_SOCKS5_GSSAPI_SERVICE: case CURLOPT_MAIL_FROM: case CURLOPT_RTSP_STREAM_URI: case CURLOPT_RTSP_TRANSPORT: case CURLOPT_TLSAUTH_TYPE: case CURLOPT_TLSAUTH_PASSWORD: case CURLOPT_TLSAUTH_USERNAME: case CURLOPT_TRANSFER_ENCODING: case CURLOPT_DNS_SERVERS: case CURLOPT_MAIL_AUTH: case CURLOPT_LOGIN_OPTIONS: case CURLOPT_PINNEDPUBLICKEY: case CURLOPT_PROXY_SERVICE_NAME: case CURLOPT_SERVICE_NAME: case CURLOPT_DEFAULT_PROTOCOL: case CURLOPT_PRE_PROXY: case CURLOPT_PROXY_CAINFO: case CURLOPT_PROXY_CAPATH: case CURLOPT_PROXY_CRLFILE: case CURLOPT_PROXY_KEYPASSWD: case CURLOPT_PROXY_PINNEDPUBLICKEY: case CURLOPT_PROXY_SSL_CIPHER_LIST: case CURLOPT_PROXY_SSLCERT: case CURLOPT_PROXY_SSLCERTTYPE: case CURLOPT_PROXY_SSLKEY: case CURLOPT_PROXY_SSLKEYTYPE: case CURLOPT_PROXY_TLSAUTH_PASSWORD: case CURLOPT_PROXY_TLSAUTH_TYPE: case CURLOPT_PROXY_TLSAUTH_USERNAME: case CURLOPT_ABSTRACT_UNIX_SOCKET: case CURLOPT_REQUEST_TARGET: case CURLOPT_PROXY_TLS13_CIPHERS: case CURLOPT_TLS13_CIPHERS: #if LIBCURL_VERSION_NUM >= 0x074001 /* Available since 7.64.1 */ case CURLOPT_ALTSVC: #endif #if LIBCURL_VERSION_NUM >= 0x074200 /* Available since 7.66.0 */ case CURLOPT_SASL_AUTHZID: #endif #if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ case CURLOPT_PROXY_ISSUERCERT: #endif #if LIBCURL_VERSION_NUM >= 0x074900 /* Available since 7.73.0 */ case CURLOPT_SSL_EC_CURVES: #endif #if LIBCURL_VERSION_NUM >= 0x074b00 /* Available since 7.75.0 */ case CURLOPT_AWS_SIGV4: #endif #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ case CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256: #endif #if LIBCURL_VERSION_NUM >= 0x075500 /* Available since 7.85.0 */ case CURLOPT_PROTOCOLS_STR: case CURLOPT_REDIR_PROTOCOLS_STR: #endif { zend_string *tmp_str; zend_string *str = zval_get_tmp_string(zvalue, &tmp_str); #if LIBCURL_VERSION_NUM >= 0x075500 /* Available since 7.85.0 */ if ((option == CURLOPT_PROTOCOLS_STR || option == CURLOPT_REDIR_PROTOCOLS_STR) && (PG(open_basedir) && *PG(open_basedir)) && (php_memnistr(ZSTR_VAL(str), "file", sizeof("file") - 1, ZSTR_VAL(str) + ZSTR_LEN(str)) != NULL || php_memnistr(ZSTR_VAL(str), "all", sizeof("all") - 1, ZSTR_VAL(str) + ZSTR_LEN(str)) != NULL)) { zend_tmp_string_release(tmp_str); php_error_docref(NULL, E_WARNING, "The FILE protocol cannot be activated when an open_basedir is set"); return FAILURE; } #endif zend_result ret = php_curl_option_str(ch, option, ZSTR_VAL(str), ZSTR_LEN(str)); zend_tmp_string_release(tmp_str); return ret; } /* Curl nullable string options */ case CURLOPT_CUSTOMREQUEST: case CURLOPT_FTPPORT: case CURLOPT_RANGE: case CURLOPT_FTP_ACCOUNT: case CURLOPT_RTSP_SESSION_ID: case CURLOPT_ACCEPT_ENCODING: case CURLOPT_DNS_INTERFACE: case CURLOPT_DNS_LOCAL_IP4: case CURLOPT_DNS_LOCAL_IP6: case CURLOPT_XOAUTH2_BEARER: case CURLOPT_UNIX_SOCKET_PATH: #if LIBCURL_VERSION_NUM >= 0x073E00 /* Available since 7.62.0 */ case CURLOPT_DOH_URL: #endif #if LIBCURL_VERSION_NUM >= 0x074a00 /* Available since 7.74.0 */ case CURLOPT_HSTS: #endif case CURLOPT_KRBLEVEL: // Authorization header would be implictly set // with an empty string thus we explictly set the option // to null to avoid this unwarranted side effect case CURLOPT_USERPWD: case CURLOPT_USERNAME: case CURLOPT_PASSWORD: #if LIBCURL_VERSION_NUM >= 0x080e00 /* Available since 8.14.0 */ case CURLOPT_SSL_SIGNATURE_ALGORITHMS: #endif { if (Z_ISNULL_P(zvalue)) { error = curl_easy_setopt(ch->cp, option, NULL); } else { zend_string *tmp_str; zend_string *str = zval_get_tmp_string(zvalue, &tmp_str); zend_result ret = php_curl_option_str(ch, option, ZSTR_VAL(str), ZSTR_LEN(str)); zend_tmp_string_release(tmp_str); return ret; } break; } /* Curl private option */ case CURLOPT_PRIVATE: { zval_ptr_dtor(&ch->private_data); ZVAL_COPY(&ch->private_data, zvalue); return SUCCESS; } /* Curl url option */ case CURLOPT_URL: { zend_string *tmp_str; zend_string *str = zval_get_tmp_string(zvalue, &tmp_str); zend_result ret = php_curl_option_url(ch, str); zend_tmp_string_release(tmp_str); return ret; } /* Curl file handle options */ case CURLOPT_FILE: case CURLOPT_INFILE: case CURLOPT_STDERR: case CURLOPT_WRITEHEADER: { FILE *fp = NULL; php_stream *what = NULL; if (Z_TYPE_P(zvalue) != IS_NULL) { what = (php_stream *)zend_fetch_resource2_ex(zvalue, "File-Handle", php_file_le_stream(), php_file_le_pstream()); if (!what) { return FAILURE; } if (FAILURE == php_stream_cast(what, PHP_STREAM_AS_STDIO, (void *) &fp, REPORT_ERRORS)) { return FAILURE; } if (!fp) { return FAILURE; } } error = CURLE_OK; switch (option) { case CURLOPT_FILE: if (!what) { if (!Z_ISUNDEF(ch->handlers.write->stream)) { zval_ptr_dtor(&ch->handlers.write->stream); ZVAL_UNDEF(&ch->handlers.write->stream); } ch->handlers.write->fp = NULL; ch->handlers.write->method = PHP_CURL_STDOUT; } else if (what->mode[0] != 'r' || what->mode[1] == '+') { zval_ptr_dtor(&ch->handlers.write->stream); ch->handlers.write->fp = fp; ch->handlers.write->method = PHP_CURL_FILE; ZVAL_COPY(&ch->handlers.write->stream, zvalue); } else { zend_value_error("%s(): The provided file handle must be writable", get_active_function_name()); return FAILURE; } break; case CURLOPT_WRITEHEADER: if (!what) { if (!Z_ISUNDEF(ch->handlers.write_header->stream)) { zval_ptr_dtor(&ch->handlers.write_header->stream); ZVAL_UNDEF(&ch->handlers.write_header->stream); } ch->handlers.write_header->fp = NULL; ch->handlers.write_header->method = PHP_CURL_IGNORE; } else if (what->mode[0] != 'r' || what->mode[1] == '+') { zval_ptr_dtor(&ch->handlers.write_header->stream); ch->handlers.write_header->fp = fp; ch->handlers.write_header->method = PHP_CURL_FILE; ZVAL_COPY(&ch->handlers.write_header->stream, zvalue); } else { zend_value_error("%s(): The provided file handle must be writable", get_active_function_name()); return FAILURE; } break; case CURLOPT_INFILE: if (!what) { if (!Z_ISUNDEF(ch->handlers.read->stream)) { zval_ptr_dtor(&ch->handlers.read->stream); ZVAL_UNDEF(&ch->handlers.read->stream); } ch->handlers.read->fp = NULL; ch->handlers.read->res = NULL; } else { zval_ptr_dtor(&ch->handlers.read->stream); ch->handlers.read->fp = fp; ch->handlers.read->res = Z_RES_P(zvalue); ZVAL_COPY(&ch->handlers.read->stream, zvalue); } break; case CURLOPT_STDERR: if (!what) { if (!Z_ISUNDEF(ch->handlers.std_err)) { zval_ptr_dtor(&ch->handlers.std_err); ZVAL_UNDEF(&ch->handlers.std_err); } } else if (what->mode[0] != 'r' || what->mode[1] == '+') { zval_ptr_dtor(&ch->handlers.std_err); ZVAL_COPY(&ch->handlers.std_err, zvalue); } else { zend_value_error("%s(): The provided file handle must be writable", get_active_function_name()); return FAILURE; } ZEND_FALLTHROUGH; default: error = curl_easy_setopt(ch->cp, option, fp); break; } break; } /* Curl linked list options */ case CURLOPT_HTTP200ALIASES: case CURLOPT_HTTPHEADER: case CURLOPT_POSTQUOTE: case CURLOPT_PREQUOTE: case CURLOPT_QUOTE: case CURLOPT_TELNETOPTIONS: case CURLOPT_MAIL_RCPT: case CURLOPT_RESOLVE: case CURLOPT_PROXYHEADER: case CURLOPT_CONNECT_TO: { zval *current; HashTable *ph; zend_string *val, *tmp_val; struct curl_slist *slist = NULL; if (Z_TYPE_P(zvalue) != IS_ARRAY) { const char *name = NULL; 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; case CURLOPT_TELNETOPTIONS: name = "CURLOPT_TELNETOPTIONS"; break; case CURLOPT_MAIL_RCPT: name = "CURLOPT_MAIL_RCPT"; break; case CURLOPT_RESOLVE: name = "CURLOPT_RESOLVE"; break; case CURLOPT_PROXYHEADER: name = "CURLOPT_PROXYHEADER"; break; case CURLOPT_CONNECT_TO: name = "CURLOPT_CONNECT_TO"; break; } zend_type_error("%s(): The %s option must have an array value", get_active_function_name(), name); return FAILURE; } ph = Z_ARRVAL_P(zvalue); ZEND_HASH_FOREACH_VAL(ph, current) { ZVAL_DEREF(current); val = zval_get_tmp_string(current, &tmp_val); struct curl_slist *new_slist = curl_slist_append(slist, ZSTR_VAL(val)); zend_tmp_string_release(tmp_val); if (!new_slist) { curl_slist_free_all(slist); php_error_docref(NULL, E_WARNING, "Could not build curl_slist"); return FAILURE; } slist = new_slist; } ZEND_HASH_FOREACH_END(); if (slist) { if ((*ch->clone) == 1) { zend_hash_index_update_ptr(&ch->to_free->slist, option, slist); } else { zend_hash_next_index_insert_ptr(&ch->to_free->slist, slist); } } error = curl_easy_setopt(ch->cp, option, slist); break; } case CURLOPT_BINARYTRANSFER: case CURLOPT_DNS_USE_GLOBAL_CACHE: /* Do nothing, just backward compatibility */ break; case CURLOPT_POSTFIELDS: if (Z_TYPE_P(zvalue) == IS_ARRAY) { if (zend_hash_num_elements(Z_ARRVAL_P(zvalue)) == 0) { /* no need to build the mime structure for empty hashtables; also works around https://github.com/curl/curl/issues/6455 */ curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDS, ""); error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, 0L); } else { return build_mime_structure_from_hash(ch, zvalue); } } else { zend_string *tmp_str; zend_string *str = zval_get_tmp_string(zvalue, &tmp_str); /* with curl 7.17.0 and later, we can use COPYPOSTFIELDS, but we have to provide size before */ error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, ZSTR_LEN(str)); error = curl_easy_setopt(ch->cp, CURLOPT_COPYPOSTFIELDS, ZSTR_VAL(str)); zend_tmp_string_release(tmp_str); } break; case CURLOPT_RETURNTRANSFER: if (zend_is_true(zvalue)) { ch->handlers.write->method = PHP_CURL_RETURN; } else { ch->handlers.write->method = PHP_CURL_STDOUT; } break; /* Curl off_t options */ case CURLOPT_INFILESIZE_LARGE: case CURLOPT_MAX_RECV_SPEED_LARGE: case CURLOPT_MAX_SEND_SPEED_LARGE: case CURLOPT_MAXFILESIZE_LARGE: case CURLOPT_TIMEVALUE_LARGE: lval = zval_get_long(zvalue); error = curl_easy_setopt(ch->cp, option, (curl_off_t)lval); break; case CURLOPT_POSTREDIR: lval = zval_get_long(zvalue); error = curl_easy_setopt(ch->cp, CURLOPT_POSTREDIR, (long) (lval & CURL_REDIR_POST_ALL)); break; /* the following options deal with files, therefore the open_basedir check * is required. */ case CURLOPT_COOKIEFILE: case CURLOPT_COOKIEJAR: case CURLOPT_RANDOM_FILE: case CURLOPT_SSLCERT: case CURLOPT_NETRC_FILE: case CURLOPT_SSH_PRIVATE_KEYFILE: case CURLOPT_SSH_PUBLIC_KEYFILE: case CURLOPT_CRLFILE: case CURLOPT_ISSUERCERT: case CURLOPT_SSH_KNOWNHOSTS: { zend_string *tmp_str; zend_string *str = zval_get_tmp_string(zvalue, &tmp_str); zend_result ret; if (ZSTR_LEN(str) && php_check_open_basedir(ZSTR_VAL(str))) { zend_tmp_string_release(tmp_str); return FAILURE; } ret = php_curl_option_str(ch, option, ZSTR_VAL(str), ZSTR_LEN(str)); zend_tmp_string_release(tmp_str); return ret; } case CURLINFO_HEADER_OUT: if (ZEND_FCC_INITIALIZED(ch->handlers.debug)) { zend_value_error("CURLINFO_HEADER_OUT option must not be set when the CURLOPT_DEBUGFUNCTION option is set"); return FAILURE; } if (zend_is_true(zvalue)) { curl_easy_setopt(ch->cp, CURLOPT_DEBUGFUNCTION, curl_debug); curl_easy_setopt(ch->cp, CURLOPT_DEBUGDATA, (void *)ch); curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 1L); } else { curl_easy_setopt(ch->cp, CURLOPT_DEBUGFUNCTION, NULL); curl_easy_setopt(ch->cp, CURLOPT_DEBUGDATA, NULL); curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 0L); } break; case CURLOPT_SHARE: { if (Z_TYPE_P(zvalue) != IS_OBJECT) { break; } if (Z_OBJCE_P(zvalue) != curl_share_ce && Z_OBJCE_P(zvalue) != curl_share_persistent_ce) { break; } php_curlsh *sh = Z_CURL_SHARE_P(zvalue); curl_easy_setopt(ch->cp, CURLOPT_SHARE, sh->share); if (ch->share) { OBJ_RELEASE(&ch->share->std); } GC_ADDREF(&sh->std); ch->share = sh; } break; /* Curl blob options */ #if LIBCURL_VERSION_NUM >= 0x074700 /* Available since 7.71.0 */ case CURLOPT_ISSUERCERT_BLOB: case CURLOPT_PROXY_ISSUERCERT_BLOB: case CURLOPT_PROXY_SSLCERT_BLOB: case CURLOPT_PROXY_SSLKEY_BLOB: case CURLOPT_SSLCERT_BLOB: case CURLOPT_SSLKEY_BLOB: #if LIBCURL_VERSION_NUM >= 0x074d00 /* Available since 7.77.0 */ case CURLOPT_CAINFO_BLOB: case CURLOPT_PROXY_CAINFO_BLOB: #endif { zend_string *tmp_str; zend_string *str = zval_get_tmp_string(zvalue, &tmp_str); struct curl_blob stblob; stblob.data = ZSTR_VAL(str); stblob.len = ZSTR_LEN(str); stblob.flags = CURL_BLOB_COPY; error = curl_easy_setopt(ch->cp, option, &stblob); zend_tmp_string_release(tmp_str); } break; #endif default: if (is_array_config) { zend_argument_value_error(2, "must contain only valid cURL options"); } else { zend_argument_value_error(2, "is not a valid cURL option"); } error = CURLE_UNKNOWN_OPTION; break; } SAVE_CURL_ERROR(ch, error); if (error != CURLE_OK) { return FAILURE; } else { return SUCCESS; } } /* }}} */ /* {{{ Set an option for a cURL transfer */ PHP_FUNCTION(curl_setopt) { zval *zid, *zvalue; zend_long options; php_curl *ch; ZEND_PARSE_PARAMETERS_START(3, 3) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) Z_PARAM_LONG(options) Z_PARAM_ZVAL(zvalue) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); if (_php_curl_setopt(ch, options, zvalue, 0) == SUCCESS) { RETURN_TRUE; } else { RETURN_FALSE; } } /* }}} */ /* {{{ Set an array of option for a cURL transfer */ PHP_FUNCTION(curl_setopt_array) { zval *zid, *arr, *entry; php_curl *ch; zend_ulong option; zend_string *string_key; ZEND_PARSE_PARAMETERS_START(2, 2) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) Z_PARAM_ARRAY(arr) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(arr), option, string_key, entry) { if (UNEXPECTED(string_key)) { zend_argument_value_error(2, "contains an invalid cURL option"); RETURN_THROWS(); } ZVAL_DEREF(entry); if (_php_curl_setopt(ch, (zend_long) option, entry, 1) == FAILURE) { RETURN_FALSE; } } ZEND_HASH_FOREACH_END(); RETURN_TRUE; } /* }}} */ /* {{{ _php_curl_cleanup_handle(ch) Cleanup an execution phase */ void _php_curl_cleanup_handle(php_curl *ch) { smart_str_free(&ch->handlers.write->buf); if (ch->header.str) { zend_string_release_ex(ch->header.str, 0); ch->header.str = NULL; } memset(ch->err.str, 0, CURL_ERROR_SIZE + 1); ch->err.no = 0; } /* }}} */ /* {{{ Perform a cURL session */ PHP_FUNCTION(curl_exec) { CURLcode error; zval *zid; php_curl *ch; ZEND_PARSE_PARAMETERS_START(1, 1) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); _php_curl_verify_handlers(ch, /* reporterror */ true); _php_curl_cleanup_handle(ch); error = curl_easy_perform(ch->cp); SAVE_CURL_ERROR(ch, error); if (error != CURLE_OK) { smart_str_free(&ch->handlers.write->buf); RETURN_FALSE; } if (!Z_ISUNDEF(ch->handlers.std_err)) { php_stream *stream; stream = (php_stream*)zend_fetch_resource2_ex(&ch->handlers.std_err, NULL, php_file_le_stream(), php_file_le_pstream()); if (stream) { php_stream_flush(stream); } } if (ch->handlers.write->method == PHP_CURL_RETURN && ch->handlers.write->buf.s) { smart_str_0(&ch->handlers.write->buf); RETURN_STR_COPY(ch->handlers.write->buf.s); } /* flush the file handle, so any remaining data is synched to disk */ if (ch->handlers.write->method == PHP_CURL_FILE && ch->handlers.write->fp) { fflush(ch->handlers.write->fp); } if (ch->handlers.write_header->method == PHP_CURL_FILE && ch->handlers.write_header->fp) { fflush(ch->handlers.write_header->fp); } if (ch->handlers.write->method == PHP_CURL_RETURN) { RETURN_EMPTY_STRING(); } else { RETURN_TRUE; } } /* }}} */ /* {{{ Get information regarding a specific transfer */ PHP_FUNCTION(curl_getinfo) { zval *zid; php_curl *ch; zend_long option; bool option_is_null = 1; ZEND_PARSE_PARAMETERS_START(1, 2) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) Z_PARAM_OPTIONAL Z_PARAM_LONG_OR_NULL(option, option_is_null) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); if (option_is_null) { char *s_code; /* libcurl expects long datatype. So far no cases are known where it would be an issue. Using zend_long would truncate a 64-bit var on Win64, so the exact long datatype fits everywhere, as long as there's no 32-bit int overflow. */ long l_code; double d_code; struct curl_certinfo *ci = NULL; zval listcode; curl_off_t co; array_init(return_value); if (curl_easy_getinfo(ch->cp, CURLINFO_EFFECTIVE_URL, &s_code) == CURLE_OK) { CAAS("url", s_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_CONTENT_TYPE, &s_code) == CURLE_OK) { if (s_code != NULL) { CAAS("content_type", s_code); } else { zval retnull; ZVAL_NULL(&retnull); CAAZ("content_type", &retnull); } } if (curl_easy_getinfo(ch->cp, CURLINFO_HTTP_CODE, &l_code) == CURLE_OK) { CAAL("http_code", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_HEADER_SIZE, &l_code) == CURLE_OK) { CAAL("header_size", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_REQUEST_SIZE, &l_code) == CURLE_OK) { CAAL("request_size", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_FILETIME, &l_code) == CURLE_OK) { CAAL("filetime", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_SSL_VERIFYRESULT, &l_code) == CURLE_OK) { CAAL("ssl_verify_result", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_COUNT, &l_code) == CURLE_OK) { CAAL("redirect_count", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_TOTAL_TIME, &d_code) == CURLE_OK) { CAAD("total_time", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_NAMELOOKUP_TIME, &d_code) == CURLE_OK) { CAAD("namelookup_time", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_CONNECT_TIME, &d_code) == CURLE_OK) { CAAD("connect_time", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_PRETRANSFER_TIME, &d_code) == CURLE_OK) { CAAD("pretransfer_time", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_SIZE_UPLOAD, &d_code) == CURLE_OK) { CAAD("size_upload", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_SIZE_DOWNLOAD, &d_code) == CURLE_OK) { CAAD("size_download", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_SPEED_DOWNLOAD, &d_code) == CURLE_OK) { CAAD("speed_download", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_SPEED_UPLOAD, &d_code) == CURLE_OK) { CAAD("speed_upload", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d_code) == CURLE_OK) { CAAD("download_content_length", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_CONTENT_LENGTH_UPLOAD, &d_code) == CURLE_OK) { CAAD("upload_content_length", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_STARTTRANSFER_TIME, &d_code) == CURLE_OK) { CAAD("starttransfer_time", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_TIME, &d_code) == CURLE_OK) { CAAD("redirect_time", d_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_URL, &s_code) == CURLE_OK) { CAAS("redirect_url", s_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_PRIMARY_IP, &s_code) == CURLE_OK) { CAAS("primary_ip", s_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_CERTINFO, &ci) == CURLE_OK) { array_init(&listcode); create_certinfo(ci, &listcode); CAAZ("certinfo", &listcode); } if (curl_easy_getinfo(ch->cp, CURLINFO_PRIMARY_PORT, &l_code) == CURLE_OK) { CAAL("primary_port", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_LOCAL_IP, &s_code) == CURLE_OK) { CAAS("local_ip", s_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_LOCAL_PORT, &l_code) == CURLE_OK) { CAAL("local_port", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_HTTP_VERSION, &l_code) == CURLE_OK) { CAAL("http_version", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_PROTOCOL, &l_code) == CURLE_OK) { CAAL("protocol", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_PROXY_SSL_VERIFYRESULT, &l_code) == CURLE_OK) { CAAL("ssl_verifyresult", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_SCHEME, &s_code) == CURLE_OK) { CAAS("scheme", s_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_APPCONNECT_TIME_T, &co) == CURLE_OK) { CAAL("appconnect_time_us", co); } #if LIBCURL_VERSION_NUM >= 0x080600 /* Available since 8.6.0 */ if (curl_easy_getinfo(ch->cp, CURLINFO_QUEUE_TIME_T , &co) == CURLE_OK) { CAAL("queue_time_us", co); } #endif if (curl_easy_getinfo(ch->cp, CURLINFO_CONNECT_TIME_T, &co) == CURLE_OK) { CAAL("connect_time_us", co); } if (curl_easy_getinfo(ch->cp, CURLINFO_NAMELOOKUP_TIME_T, &co) == CURLE_OK) { CAAL("namelookup_time_us", co); } if (curl_easy_getinfo(ch->cp, CURLINFO_PRETRANSFER_TIME_T, &co) == CURLE_OK) { CAAL("pretransfer_time_us", co); } if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_TIME_T, &co) == CURLE_OK) { CAAL("redirect_time_us", co); } if (curl_easy_getinfo(ch->cp, CURLINFO_STARTTRANSFER_TIME_T, &co) == CURLE_OK) { CAAL("starttransfer_time_us", co); } #if LIBCURL_VERSION_NUM >= 0x080a00 /* Available since 8.10.0 */ if (curl_easy_getinfo(ch->cp, CURLINFO_POSTTRANSFER_TIME_T, &co) == CURLE_OK) { CAAL("posttransfer_time_us", co); } #endif if (curl_easy_getinfo(ch->cp, CURLINFO_TOTAL_TIME_T, &co) == CURLE_OK) { CAAL("total_time_us", co); } if (ch->header.str) { CAASTR("request_header", ch->header.str); } #if LIBCURL_VERSION_NUM >= 0x074800 /* Available since 7.72.0 */ if (curl_easy_getinfo(ch->cp, CURLINFO_EFFECTIVE_METHOD, &s_code) == CURLE_OK) { CAAS("effective_method", s_code); } #endif #if LIBCURL_VERSION_NUM >= 0x075400 /* Available since 7.84.0 */ if (curl_easy_getinfo(ch->cp, CURLINFO_CAPATH, &s_code) == CURLE_OK) { CAAS("capath", s_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_CAINFO, &s_code) == CURLE_OK) { CAAS("cainfo", s_code); } #endif #if LIBCURL_VERSION_NUM >= 0x080700 /* Available since 8.7.0 */ if (curl_easy_getinfo(ch->cp, CURLINFO_USED_PROXY, &l_code) == CURLE_OK) { CAAL("used_proxy", l_code); } #endif #if LIBCURL_VERSION_NUM >= 0x080c00 /* Available since 8.12.0 */ if (curl_easy_getinfo(ch->cp, CURLINFO_HTTPAUTH_USED, &l_code) == CURLE_OK) { CAAL("httpauth_used", l_code); } if (curl_easy_getinfo(ch->cp, CURLINFO_PROXYAUTH_USED, &l_code) == CURLE_OK) { CAAL("proxyauth_used", l_code); } #endif #if LIBCURL_VERSION_NUM >= 0x080200 /* Available since 8.2.0 */ if (curl_easy_getinfo(ch->cp, CURLINFO_CONN_ID , &co) == CURLE_OK) { CAAL("conn_id", co); } #endif } else { switch (option) { case CURLINFO_HEADER_OUT: if (ch->header.str) { RETURN_STR_COPY(ch->header.str); } else { RETURN_FALSE; } case CURLINFO_CERTINFO: { struct curl_certinfo *ci = NULL; array_init(return_value); if (curl_easy_getinfo(ch->cp, CURLINFO_CERTINFO, &ci) == CURLE_OK) { create_certinfo(ci, return_value); } else { RETURN_FALSE; } break; } case CURLINFO_PRIVATE: if (!Z_ISUNDEF(ch->private_data)) { RETURN_COPY(&ch->private_data); } else { RETURN_FALSE; } break; 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); } else { RETURN_FALSE; } break; } case CURLINFO_LONG: { zend_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; if (curl_easy_getinfo(ch->cp, option, &slist) == CURLE_OK) { struct curl_slist *current = slist; array_init(return_value); zend_hash_real_init_packed(Z_ARRVAL_P(return_value)); while (current) { add_next_index_string(return_value, current->data); current = current->next; } curl_slist_free_all(slist); } else { RETURN_FALSE; } break; } case CURLINFO_OFF_T: { curl_off_t c_off; if (curl_easy_getinfo(ch->cp, option, &c_off) == CURLE_OK) { RETURN_LONG((long) c_off); } else { RETURN_FALSE; } break; } default: RETURN_FALSE; } } } } } /* }}} */ /* {{{ Return a string contain the last error for the current session */ PHP_FUNCTION(curl_error) { zval *zid; php_curl *ch; ZEND_PARSE_PARAMETERS_START(1, 1) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); if (ch->err.no) { ch->err.str[CURL_ERROR_SIZE] = 0; if (strlen(ch->err.str) > 0) { RETURN_STRING(ch->err.str); } else { RETURN_STRING(curl_easy_strerror(ch->err.no)); } } else { RETURN_EMPTY_STRING(); } } /* }}} */ /* {{{ Return an integer containing the last error number */ PHP_FUNCTION(curl_errno) { zval *zid; php_curl *ch; ZEND_PARSE_PARAMETERS_START(1,1) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); RETURN_LONG(ch->err.no); } /* }}} */ /* {{{ Close a cURL session */ PHP_FUNCTION(curl_close) { zval *zid; php_curl *ch; ZEND_PARSE_PARAMETERS_START(1, 1) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); if (ch->in_callback) { zend_throw_error(NULL, "%s(): Attempt to close cURL handle from a callback", get_active_function_name()); RETURN_THROWS(); } } /* }}} */ static void curl_free_obj(zend_object *object) { php_curl *ch = curl_from_obj(object); #if PHP_CURL_DEBUG fprintf(stderr, "DTOR CALLED, ch = %x\n", ch); #endif if (!ch->cp) { /* Can happen if constructor throws. */ zend_object_std_dtor(&ch->std); return; } _php_curl_verify_handlers(ch, /* reporterror */ false); curl_easy_cleanup(ch->cp); /* cURL destructors should be invoked only by last curl handle */ if (--(*ch->clone) == 0) { zend_llist_clean(&ch->to_free->post); zend_llist_clean(&ch->to_free->stream); zend_hash_destroy(&ch->to_free->slist); efree(ch->to_free); efree(ch->clone); } smart_str_free(&ch->handlers.write->buf); if (ZEND_FCC_INITIALIZED(ch->handlers.write->fcc)) { zend_fcc_dtor(&ch->handlers.write->fcc); } if (ZEND_FCC_INITIALIZED(ch->handlers.write_header->fcc)) { zend_fcc_dtor(&ch->handlers.write_header->fcc); } if (ZEND_FCC_INITIALIZED(ch->handlers.read->fcc)) { zend_fcc_dtor(&ch->handlers.read->fcc); } zval_ptr_dtor(&ch->handlers.std_err); if (ch->header.str) { zend_string_release_ex(ch->header.str, 0); } zval_ptr_dtor(&ch->handlers.write_header->stream); zval_ptr_dtor(&ch->handlers.write->stream); zval_ptr_dtor(&ch->handlers.read->stream); efree(ch->handlers.write); efree(ch->handlers.write_header); efree(ch->handlers.read); if (ZEND_FCC_INITIALIZED(ch->handlers.progress)) { zend_fcc_dtor(&ch->handlers.progress); } if (ZEND_FCC_INITIALIZED(ch->handlers.xferinfo)) { zend_fcc_dtor(&ch->handlers.xferinfo); } if (ZEND_FCC_INITIALIZED(ch->handlers.fnmatch)) { zend_fcc_dtor(&ch->handlers.fnmatch); } if (ZEND_FCC_INITIALIZED(ch->handlers.debug)) { zend_fcc_dtor(&ch->handlers.debug); } #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ if (ZEND_FCC_INITIALIZED(ch->handlers.prereq)) { zend_fcc_dtor(&ch->handlers.prereq); } #endif #if LIBCURL_VERSION_NUM >= 0x075400 /* Available since 7.84.0 */ if (ZEND_FCC_INITIALIZED(ch->handlers.sshhostkey)) { zend_fcc_dtor(&ch->handlers.sshhostkey); } #endif zval_ptr_dtor(&ch->postfields); zval_ptr_dtor(&ch->private_data); if (ch->share) { OBJ_RELEASE(&ch->share->std); } zend_object_std_dtor(&ch->std); } /* }}} */ /* {{{ return string describing error code */ PHP_FUNCTION(curl_strerror) { zend_long code; const char *str; ZEND_PARSE_PARAMETERS_START(1, 1) Z_PARAM_LONG(code) ZEND_PARSE_PARAMETERS_END(); str = curl_easy_strerror(code); if (str) { RETURN_STRING(str); } else { RETURN_NULL(); } } /* }}} */ /* {{{ _php_curl_reset_handlers() Reset all handlers of a given php_curl */ static void _php_curl_reset_handlers(php_curl *ch) { if (!Z_ISUNDEF(ch->handlers.write->stream)) { zval_ptr_dtor(&ch->handlers.write->stream); ZVAL_UNDEF(&ch->handlers.write->stream); } ch->handlers.write->fp = NULL; ch->handlers.write->method = PHP_CURL_STDOUT; if (!Z_ISUNDEF(ch->handlers.write_header->stream)) { zval_ptr_dtor(&ch->handlers.write_header->stream); ZVAL_UNDEF(&ch->handlers.write_header->stream); } ch->handlers.write_header->fp = NULL; ch->handlers.write_header->method = PHP_CURL_IGNORE; if (!Z_ISUNDEF(ch->handlers.read->stream)) { zval_ptr_dtor(&ch->handlers.read->stream); ZVAL_UNDEF(&ch->handlers.read->stream); } ch->handlers.read->fp = NULL; ch->handlers.read->res = NULL; ch->handlers.read->method = PHP_CURL_DIRECT; if (!Z_ISUNDEF(ch->handlers.std_err)) { zval_ptr_dtor(&ch->handlers.std_err); ZVAL_UNDEF(&ch->handlers.std_err); } if (ZEND_FCC_INITIALIZED(ch->handlers.progress)) { zend_fcc_dtor(&ch->handlers.progress); } if (ZEND_FCC_INITIALIZED(ch->handlers.xferinfo)) { zend_fcc_dtor(&ch->handlers.xferinfo); } if (ZEND_FCC_INITIALIZED(ch->handlers.fnmatch)) { zend_fcc_dtor(&ch->handlers.fnmatch); } if (ZEND_FCC_INITIALIZED(ch->handlers.debug)) { zend_fcc_dtor(&ch->handlers.debug); } #if LIBCURL_VERSION_NUM >= 0x075000 /* Available since 7.80.0 */ if (ZEND_FCC_INITIALIZED(ch->handlers.prereq)) { zend_fcc_dtor(&ch->handlers.prereq); } #endif #if LIBCURL_VERSION_NUM >= 0x075400 /* Available since 7.84.0 */ if (ZEND_FCC_INITIALIZED(ch->handlers.sshhostkey)) { zend_fcc_dtor(&ch->handlers.sshhostkey); } #endif } /* }}} */ /* {{{ Reset all options of a libcurl session handle */ PHP_FUNCTION(curl_reset) { zval *zid; php_curl *ch; ZEND_PARSE_PARAMETERS_START(1, 1) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); if (ch->in_callback) { zend_throw_error(NULL, "%s(): Attempt to reset cURL handle from a callback", get_active_function_name()); RETURN_THROWS(); } curl_easy_reset(ch->cp); _php_curl_reset_handlers(ch); _php_curl_set_default_options(ch); } /* }}} */ /* {{{ URL encodes the given string */ PHP_FUNCTION(curl_escape) { zend_string *str; char *res; zval *zid; php_curl *ch; ZEND_PARSE_PARAMETERS_START(2,2) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) Z_PARAM_STR(str) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); if (ZEND_SIZE_T_INT_OVFL(ZSTR_LEN(str))) { RETURN_FALSE; } if ((res = curl_easy_escape(ch->cp, ZSTR_VAL(str), ZSTR_LEN(str)))) { RETVAL_STRING(res); curl_free(res); } else { RETURN_FALSE; } } /* }}} */ /* {{{ URL decodes the given string */ PHP_FUNCTION(curl_unescape) { char *out = NULL; int out_len; zval *zid; zend_string *str; php_curl *ch; ZEND_PARSE_PARAMETERS_START(2,2) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) Z_PARAM_STR(str) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); if (ZEND_SIZE_T_INT_OVFL(ZSTR_LEN(str))) { RETURN_FALSE; } if ((out = curl_easy_unescape(ch->cp, ZSTR_VAL(str), ZSTR_LEN(str), &out_len))) { RETVAL_STRINGL(out, out_len); curl_free(out); } else { RETURN_FALSE; } } /* }}} */ /* {{{ pause and unpause a connection */ PHP_FUNCTION(curl_pause) { zend_long bitmask; zval *zid; php_curl *ch; ZEND_PARSE_PARAMETERS_START(2,2) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) Z_PARAM_LONG(bitmask) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); RETURN_LONG(curl_easy_pause(ch->cp, bitmask)); } /* }}} */ #if LIBCURL_VERSION_NUM >= 0x073E00 /* Available since 7.62.0 */ /* {{{ perform connection upkeep checks */ PHP_FUNCTION(curl_upkeep) { CURLcode error; zval *zid; php_curl *ch; ZEND_PARSE_PARAMETERS_START(1, 1) Z_PARAM_OBJECT_OF_CLASS(zid, curl_ce) ZEND_PARSE_PARAMETERS_END(); ch = Z_CURL_P(zid); error = curl_easy_upkeep(ch->cp); SAVE_CURL_ERROR(ch, error); RETURN_BOOL(error == CURLE_OK); } /*}}} */ #endif