- find $HOME/cache -name '*.gcda' -o -name '*.gcno' -delete
env:
- - PHP=7.0 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=7.1 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=7.2 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=7.3 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=master enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=7.4 with_http_libicu_dir=no with_http_libidn_dir=no with_http_libidn2_dir=no with_http_libcurl_dir=no with_http_libevent_dir=no with_http_libbrotli_dir=no
- - PHP=7.4 PECLs=event enable_sockets=yes enable_debug=no enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=7.4 PECLs=event enable_sockets=yes enable_debug=yes enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=7.4 PECLs=event enable_sockets=yes enable_debug=no enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=7.4 PECLs=event enable_sockets=yes enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - CFLAGS='-O0 -g --coverage' CXXFLAGS='-O0 -g --coverage' PHP=7.4 PECLs=event enable_sockets=yes enable_json=yes enable_hash=yes enable_iconv=yes with_http_libicu_dir=yes with_http_libidn_dir=no with_http_libidn2_dir=no
- - CFLAGS='-O0 -g --coverage' CXXFLAGS='-O0 -g --coverage' PHP=7.4 PECLs=event enable_sockets=yes enable_json=yes enable_hash=yes enable_iconv=yes with_http_libidn_dir=yes with_http_libicu_dir=no with_http_libidn2_dir=no
- - CFLAGS='-O0 -g --coverage' CXXFLAGS='-O0 -g --coverage' PHP=7.4 PECLs=event enable_sockets=yes enable_json=yes enable_hash=yes enable_iconv=yes with_http_libidn2_dir=yes with_http_libicu_dir=no with_http_libidn_dir=no
+ - PHP=master enable_debug=yes enable_zts=yes enable_iconv=yes
+ - PHP=8.0 with_http_libicu_dir=no with_http_libidn_dir=no with_http_libidn2_dir=no with_http_libcurl_dir=no with_http_libevent_dir=no with_http_libbrotli_dir=no
+ - PHP=8.0 enable_debug=no enable_zts=no enable_iconv=yes
+ - PHP=8.0 enable_debug=yes enable_zts=no enable_iconv=yes
+ - PHP=8.0 enable_debug=no enable_zts=yes enable_iconv=yes
+ - PHP=8.0 enable_debug=yes enable_zts=yes enable_iconv=yes
+ - CFLAGS='-O0 -g --coverage' CXXFLAGS='-O0 -g --coverage' PHP=8.0 enable_iconv=yes with_http_libicu_dir=yes with_http_libidn_dir=no with_http_libidn2_dir=no
+ - CFLAGS='-O0 -g --coverage' CXXFLAGS='-O0 -g --coverage' PHP=8.0 enable_iconv=yes with_http_libidn_dir=yes with_http_libicu_dir=no with_http_libidn2_dir=no
+ - CFLAGS='-O0 -g --coverage' CXXFLAGS='-O0 -g --coverage' PHP=8.0 enable_iconv=yes with_http_libidn2_dir=yes with_http_libicu_dir=no with_http_libidn_dir=no
matrix:
fast_finish: true
allow_failures:
- - env: PHP=master enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
+ - env: PHP=master enable_debug=yes enable_zts=yes enable_iconv=yes
install:
- |
], [
AC_MSG_ERROR([please install and enable pecl/raphf])
])
- PECL_HAVE_PHP_EXT([hash])
PECL_HAVE_PHP_EXT([iconv])
dnl DONE
<?php
$gen = include "./travis/pecl/gen-matrix.php";
-$cur = "7.4";
+$cur = "8.0";
$env = $gen([
// most useful for all additional versions except current
- "PHP" => ["7.0", "7.1", "7.2", "7.3", "master"],
+ "PHP" => ["master"],
"enable_debug" => "yes",
- "enable_maintainer_zts" => "yes",
- "enable_json" => "yes",
- "enable_hash" => "yes",
+ "enable_zts" => "yes",
"enable_iconv" => "yes",
], [
// everything disabled for current
], [
// everything enabled for current, switching debug/zts
"PHP" => $cur,
- "PECLs" => "event", // for tests/client029.phpt
- "enable_sockets" => "yes", // needed by pecl/event
+// "PECLs" => "event", // for tests/client029.phpt
+// "enable_sockets" => "yes", // needed by pecl/event
"enable_debug",
- "enable_maintainer_zts",
- "enable_json" => "yes",
- "enable_hash" => "yes",
+ "enable_zts",
"enable_iconv" => "yes",
], [
// once everything enabled for current, with coverage
"CFLAGS" => "'-O0 -g --coverage'",
"CXXFLAGS" => "'-O0 -g --coverage'",
"PHP" => $cur,
- "PECLs" => "event", // for tests/client029.phpt
- "enable_sockets" => "yes", // needed by pecl/event
- "enable_json" => "yes",
- "enable_hash" => "yes",
+// "PECLs" => "event", // for tests/client029.phpt
+// "enable_sockets" => "yes", // needed by pecl/event
"enable_iconv" => "yes",
[
"with_http_libicu_dir",
zval old_opts_tmp, *old_opts, new_opts, *entry = NULL;
array_init(&new_opts);
- old_opts = zend_read_property(this_ce, instance, ZEND_STRL("options"), 0, &old_opts_tmp);
+ old_opts = zend_read_property(this_ce, Z_OBJ_P(instance), ZEND_STRL("options"), 0, &old_opts_tmp);
if (Z_TYPE_P(old_opts) == IS_ARRAY) {
array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL(new_opts));
}
}
- zend_update_property(this_ce, instance, ZEND_STRL("options"), &new_opts);
+ zend_update_property(this_ce, Z_OBJ_P(instance), ZEND_STRL("options"), &new_opts);
zval_ptr_dtor(&new_opts);
}
}
array_init(&new_opts);
if (!opts || !zend_hash_num_elements(Z_ARRVAL_P(opts))) {
- zend_update_property(this_ce, instance, ZEND_STRL("options"), &new_opts);
+ zend_update_property(this_ce, Z_OBJ_P(instance), ZEND_STRL("options"), &new_opts);
zval_ptr_dtor(&new_opts);
} else {
zval old_opts_tmp, *old_opts, add_opts, *opt;
if (Z_TYPE_P(opt) == IS_ARRAY && (zend_string_equals_literal(key.key, "ssl") || zend_string_equals_literal(key.key, "cookies"))) {
php_http_client_options_set_subr(instance, key.key->val, key.key->len, opt, 0);
} else if (is_client && (zend_string_equals_literal(key.key, "recordHistory") || zend_string_equals_literal(key.key, "responseMessageClass"))) {
- zend_update_property(this_ce, instance, key.key->val, key.key->len, opt);
+ zend_update_property(this_ce, Z_OBJ_P(instance), key.key->val, key.key->len, opt);
} else if (Z_TYPE_P(opt) == IS_NULL) {
- old_opts = zend_read_property(this_ce, instance, ZEND_STRL("options"), 0, &old_opts_tmp);
+ old_opts = zend_read_property(this_ce, Z_OBJ_P(instance), ZEND_STRL("options"), 0, &old_opts_tmp);
if (Z_TYPE_P(old_opts) == IS_ARRAY) {
zend_symtable_del(Z_ARRVAL_P(old_opts), key.key);
}
}
ZEND_HASH_FOREACH_END();
- old_opts = zend_read_property(this_ce, instance, ZEND_STRL("options"), 0, &old_opts_tmp);
+ old_opts = zend_read_property(this_ce, Z_OBJ_P(instance), ZEND_STRL("options"), 0, &old_opts_tmp);
if (Z_TYPE_P(old_opts) == IS_ARRAY) {
array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL(new_opts));
}
array_join(Z_ARRVAL(add_opts), Z_ARRVAL(new_opts), 0, 0);
- zend_update_property(this_ce, instance, ZEND_STRL("options"), &new_opts);
+ zend_update_property(this_ce, Z_OBJ_P(instance), ZEND_STRL("options"), &new_opts);
zval_ptr_dtor(&new_opts);
zval_ptr_dtor(&add_opts);
}
void php_http_client_options_get_subr(zval *instance, char *key, size_t len, zval *return_value)
{
zend_class_entry *this_ce = Z_OBJCE_P(instance);
- zval *options, opts_tmp, *opts = zend_read_property(this_ce, instance, ZEND_STRL("options"), 0, &opts_tmp);
+ zval *options, opts_tmp, *opts = zend_read_property(this_ce, Z_OBJ_P(instance), ZEND_STRL("options"), 0, &opts_tmp);
if ((Z_TYPE_P(opts) == IS_ARRAY) && (options = zend_symtable_str_find(Z_ARRVAL_P(opts), key, len))) {
RETVAL_ZVAL(options, 1, 0);
return &php_http_client_object_new_ex(ce, NULL)->zo;
}
-static HashTable *php_http_client_object_get_gc(zval *object, zval **table, int *n)
+static HashTable *php_http_client_object_get_gc(zend_object *object, zval **table, int *n)
{
- php_http_client_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+ php_http_client_object_t *obj = PHP_HTTP_OBJ(object, NULL);
zend_llist_element *el = NULL;
- HashTable *props = Z_OBJPROP_P(object);
+ HashTable *props = object->handlers->get_properties(object);
uint32_t count = zend_hash_num_elements(props) + zend_llist_count(&obj->client->responses) + zend_llist_count(&obj->client->requests) + 2;
zval *val;
static void handle_history(zval *zclient, php_http_message_t *request, php_http_message_t *response)
{
- zval new_hist, old_hist_tmp, *old_hist = zend_read_property(php_http_client_class_entry, zclient, ZEND_STRL("history"), 0, &old_hist_tmp);
+ zval new_hist, old_hist_tmp, *old_hist = zend_read_property(php_http_client_class_entry, Z_OBJ_P(zclient), ZEND_STRL("history"), 0, &old_hist_tmp);
php_http_message_t *req_copy = php_http_message_copy(request, NULL);
php_http_message_t *res_copy = php_http_message_copy(response, NULL);
php_http_message_t *zipped = php_http_message_zip(res_copy, req_copy);
php_http_message_object_prepend(&new_hist, old_hist, 1);
}
- zend_update_property(php_http_client_class_entry, zclient, ZEND_STRL("history"), &new_hist);
+ zend_update_property(php_http_client_class_entry, Z_OBJ_P(zclient), ZEND_STRL("history"), &new_hist);
zval_ptr_dtor(&new_hist);
}
/* ensure the message is of type response (could be uninitialized in case of early error, like DNS) */
php_http_message_set_type(msg, PHP_HTTP_RESPONSE);
- if (zend_is_true(zend_read_property(php_http_client_class_entry, &zclient, ZEND_STRL("recordHistory"), 0, &rec_hist_tmp))) {
+ if (zend_is_true(zend_read_property(php_http_client_class_entry, Z_OBJ(zclient), ZEND_STRL("recordHistory"), 0, &rec_hist_tmp))) {
handle_history(&zclient, e->request, *response);
}
object_init(&info);
info_ht = HASH_OF(&info);
php_http_client_getopt(client, PHP_HTTP_CLIENT_OPT_TRANSFER_INFO, e->request, &info_ht);
- zend_update_property(php_http_get_client_response_class_entry(), &zresponse, ZEND_STRL("transferInfo"), &info);
+ zend_update_property(php_http_get_client_response_class_entry(), Z_OBJ(zresponse), ZEND_STRL("transferInfo"), &info);
zval_ptr_dtor(&info);
zend_llist_add_element(&client->responses, &msg_obj);
ZVAL_STRINGL(&zdata, data, size);
zend_replace_error_handling(EH_NORMAL, NULL, &zeh);
- if (SUCCESS == zend_fcall_info_argn(&client_obj->debug.fci, 4, &zclient, &zreq, &ztype, &zdata)) {
- ++client->callback.depth;
- zend_fcall_info_call(&client_obj->debug.fci, &client_obj->debug.fcc, NULL, NULL);
- --client->callback.depth;
- zend_fcall_info_args_clear(&client_obj->debug.fci, 0);
- }
+ zend_fcall_info_argn(&client_obj->debug.fci, 4, &zclient, &zreq, &ztype, &zdata);
+ ++client->callback.depth;
+ zend_fcall_info_call(&client_obj->debug.fci, &client_obj->debug.fcc, NULL, NULL);
+ --client->callback.depth;
+ zend_fcall_info_args_clear(&client_obj->debug.fci, 0);
zend_restore_error_handling(&zeh);
zval_ptr_dtor(&zclient);
}
object_init_ex(&os, spl_ce_SplObjectStorage);
- zend_update_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), &os);
+ zend_update_property(php_http_client_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("observers"), &os);
zval_ptr_dtor(&os);
if (persistent_handle_name) {
{
HashTable *options;
unsigned num_options = 0;
- zval z_roptions, z_options_tmp, *z_coptions = zend_read_property(php_http_client_class_entry, client, ZEND_STRL("options"), 0, &z_options_tmp);
+ zval z_roptions, z_options_tmp, *z_coptions = zend_read_property(php_http_client_class_entry, Z_OBJ_P(client), ZEND_STRL("options"), 0, &z_options_tmp);
if (Z_TYPE_P(z_coptions) == IS_ARRAY) {
num_options = zend_hash_num_elements(Z_ARRVAL_P(z_coptions));
}
ZVAL_UNDEF(&z_roptions);
- zend_call_method_with_0_params(request, NULL, NULL, "getOptions", &z_roptions);
+ zend_call_method_with_0_params(Z_OBJ_P(request), NULL, NULL, "getOptions", &z_roptions);
if (Z_TYPE(z_roptions) == IS_ARRAY) {
unsigned num = zend_hash_num_elements(Z_ARRVAL(z_roptions));
if (num > num_options) {
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- zhistory = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("history"), 0, &zhistory_tmp);
+ zhistory = zend_read_property(php_http_client_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("history"), 0, &zhistory_tmp);
RETVAL_ZVAL(zhistory, 1, 0);
}
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|O!o!", &request, php_http_get_client_request_class_entry(), &zprogress), invalid_arg, return);
client_obj = PHP_HTTP_OBJ(NULL, getThis());
- observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0, &observers_tmp);
+ observers = zend_read_property(php_http_client_class_entry, &client_obj->zo, ZEND_STRL("observers"), 0, &observers_tmp);
if (Z_TYPE_P(observers) != IS_OBJECT) {
php_http_throw(unexpected_val, "Observer storage is corrupted");
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &observer, spl_ce_SplObserver), invalid_arg, return);
client_obj = PHP_HTTP_OBJ(NULL, getThis());
- observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0, &observers_tmp);
+ observers = zend_read_property(php_http_client_class_entry, &client_obj->zo, ZEND_STRL("observers"), 0, &observers_tmp);
if (Z_TYPE_P(observers) != IS_OBJECT) {
php_http_throw(unexpected_val, "Observer storage is corrupted");
}
ZVAL_UNDEF(&retval);
- zend_call_method_with_1_params(observers, NULL, NULL, "attach", &retval, observer);
+ zend_call_method_with_1_params(Z_OBJ_P(observers), NULL, NULL, "attach", &retval, observer);
zval_ptr_dtor(&retval);
RETVAL_ZVAL(getThis(), 1, 0);
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &observer, spl_ce_SplObserver), invalid_arg, return);
- observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0, &observers_tmp);
+ observers = zend_read_property(php_http_client_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("observers"), 0, &observers_tmp);
if (Z_TYPE_P(observers) != IS_OBJECT) {
php_http_throw(unexpected_val, "Observer storage is corrupted");
}
ZVAL_UNDEF(&retval);
- zend_call_method_with_1_params(observers, NULL, NULL, "detach", &retval, observer);
+ zend_call_method_with_1_params(Z_OBJ_P(observers), NULL, NULL, "detach", &retval, observer);
zval_ptr_dtor(&retval);
RETVAL_ZVAL(getThis(), 1, 0);
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0, &observers_tmp);
+ observers = zend_read_property(php_http_client_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("observers"), 0, &observers_tmp);
if (Z_TYPE_P(observers) != IS_OBJECT) {
php_http_throw(unexpected_val, "Observer storage is corrupted");
static PHP_METHOD(HttpClient, getOptions)
{
if (SUCCESS == zend_parse_parameters_none()) {
- zval options_tmp, *options = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("options"), 0, &options_tmp);
+ zval options_tmp, *options = zend_read_property(php_http_client_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("options"), 0, &options_tmp);
RETVAL_ZVAL(options, 1, 0);
}
}
long l = 0;
double d = 0;
struct curl_slist *s = NULL, *p = NULL;
- zval tmp = {{0}};
+ zval tmp;
+
+ ZVAL_NULL(&tmp);
/* BEGIN::CURLINFO */
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_EFFECTIVE_URL, &c)) {
static PHP_METHOD(HttpClientRequest, getOptions)
{
if (SUCCESS == zend_parse_parameters_none()) {
- zval tmp, *zoptions = zend_read_property(php_http_client_request_class_entry, getThis(), ZEND_STRL("options"), 0, &tmp);
+ zval tmp, *zoptions = zend_read_property(php_http_client_request_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("options"), 0, &tmp);
RETURN_ZVAL(zoptions, 1, 0);
}
}
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &info_name, &info_len), invalid_arg, return);
- info = zend_read_property(php_http_client_response_class_entry, getThis(), ZEND_STRL("transferInfo"), 0, &info_tmp);
+ info = zend_read_property(php_http_client_response_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("transferInfo"), 0, &info_tmp);
/* request completed? */
if (Z_TYPE_P(info) != IS_OBJECT) {
}
if (info_len && info_name) {
- info = zend_read_property(NULL, info, php_http_pretty_key(info_name, info_len, 0, 0), info_len, 0, &info_name_tmp);
+ info = zend_read_property(NULL, Z_OBJ_P(info), php_http_pretty_key(info_name, info_len, 0, 0), info_len, 0, &info_name_tmp);
if (!info) {
php_http_throw(unexpected_val, "Could not find transfer info with name '%s'", info_name);
} \
} while(0)
-zend_object *php_http_cookie_object_clone(zval *obj)
+zend_object *php_http_cookie_object_clone(zend_object *obj)
{
- php_http_cookie_object_t *new_obj, *old_obj = PHP_HTTP_OBJ(NULL, obj);
+ php_http_cookie_object_t *new_obj, *old_obj = PHP_HTTP_OBJ(obj, NULL);
PHP_HTTP_COOKIE_OBJECT_INIT(old_obj);
zend_object *php_http_cookie_object_new(zend_class_entry *ce);
php_http_cookie_object_t *php_http_cookie_object_new_ex(zend_class_entry *ce, php_http_cookie_list_t *list);
-zend_object *php_http_cookie_object_clone(zval *this_ptr);
+zend_object *php_http_cookie_object_clone(zend_object *this_ptr);
void php_http_cookie_object_free(zend_object *object);
PHP_MINIT_FUNCTION(http_cookie);
return o;
}
-zend_object *php_http_encoding_stream_object_clone(zval *object)
+zend_object *php_http_encoding_stream_object_clone(zend_object *object)
{
- php_http_encoding_stream_object_t *new_obj, *old_obj = PHP_HTTP_OBJ(NULL, object);
+ php_http_encoding_stream_object_t *new_obj, *old_obj = PHP_HTTP_OBJ(object, NULL);
php_http_encoding_stream_t *cpy = php_http_encoding_stream_copy(old_obj->stream, NULL);
if (!cpy) {
zend_object *php_http_encoding_stream_object_new(zend_class_entry *ce);
php_http_encoding_stream_object_t *php_http_encoding_stream_object_new_ex(zend_class_entry *ce, php_http_encoding_stream_t *s);
-zend_object *php_http_encoding_stream_object_clone(zval *object);
+zend_object *php_http_encoding_stream_object_clone(zend_object *object);
void php_http_encoding_stream_object_free(zend_object *object);
#endif
{
sapi_header_line h = {NULL, 0, 0};
ZEND_RESULT_CODE ret;
+ char *line;
- h.line_len = spprintf(&h.line, 0, "HTTP/%u.%u %ld %s", v->major, v->minor, code, php_http_env_get_response_status_for_code(code));
+ h.line_len = spprintf(&line, 0, "HTTP/%u.%u %ld %s", v->major, v->minor, code, php_http_env_get_response_status_for_code(code));
+ h.line = line;
ret = sapi_header_op(SAPI_HEADER_REPLACE, (void *) &h);
- efree(h.line);
+ efree(line);
return ret;
}
ZEND_RESULT_CODE php_http_env_set_response_header(long http_code, const char *header_str, size_t header_len, zend_bool replace)
{
- sapi_header_line h = {estrndup(header_str, header_len), header_len, http_code};
+ sapi_header_line h = {header_str, header_len, http_code};
ZEND_RESULT_CODE ret = sapi_header_op(replace ? SAPI_HEADER_REPLACE : SAPI_HEADER_ADD, (void *) &h);
- efree(h.line);
return ret;
}
{
ZEND_RESULT_CODE ret = FAILURE;
sapi_header_line h = {NULL, 0, http_code};
+ char *line;
- h.line_len = vspprintf(&h.line, 0, fmt, argv);
+ h.line_len = vspprintf(&line, 0, fmt, argv);
+ h.line = line;
if (h.line) {
if (h.line_len) {
ret = sapi_header_op(replace ? SAPI_HEADER_REPLACE : SAPI_HEADER_ADD, (void *) &h);
}
- efree(h.line);
+ efree(line);
}
return ret;
}
} else {
sapi_header_line h;
ZEND_RESULT_CODE ret;
+ char *line;
if (name_len > INT_MAX) {
return FAILURE;
}
h.response_code = http_code;
- h.line_len = spprintf(&h.line, 0, "%s: %s", name_str, data->val);
+ h.line_len = spprintf(&line, 0, "%s: %s", name_str, data->val);
+ h.line = line;
ret = sapi_header_op(replace ? SAPI_HEADER_REPLACE : SAPI_HEADER_ADD, (void *) &h);
zend_string_release(data);
- PTR_FREE(h.line);
+ PTR_FREE(line);
return ret;
}
zsg = php_http_env_get_superglobal(ZEND_STRL("_GET"));
object_init_ex(&zqs, php_http_querystring_get_class_entry());
php_http_expect(SUCCESS == php_http_querystring_ctor(&zqs, zsg), unexpected_val, return);
- zend_update_property(php_http_env_request_class_entry, getThis(), ZEND_STRL("query"), &zqs);
+ zend_update_property(php_http_env_request_class_entry, &obj->zo, ZEND_STRL("query"), &zqs);
zval_ptr_dtor(&zqs);
zsg = php_http_env_get_superglobal(ZEND_STRL("_POST"));
object_init_ex(&zqs, php_http_querystring_get_class_entry());
php_http_expect(SUCCESS == php_http_querystring_ctor(&zqs, zsg), unexpected_val, return);
- zend_update_property(php_http_env_request_class_entry, getThis(), ZEND_STRL("form"), &zqs);
+ zend_update_property(php_http_env_request_class_entry, &obj->zo, ZEND_STRL("form"), &zqs);
zval_ptr_dtor(&zqs);
zsg = php_http_env_get_superglobal(ZEND_STRL("_COOKIE"));
object_init_ex(&zqs, php_http_querystring_get_class_entry());
php_http_expect(SUCCESS == php_http_querystring_ctor(&zqs, zsg), unexpected_val, return);
- zend_update_property(php_http_env_request_class_entry, getThis(), ZEND_STRL("cookie"), &zqs);
+ zend_update_property(php_http_env_request_class_entry, &obj->zo, ZEND_STRL("cookie"), &zqs);
zval_ptr_dtor(&zqs);
array_init(&zqs);
if ((zsg = php_http_env_get_superglobal(ZEND_STRL("_FILES")))) {
zend_hash_apply_with_arguments(Z_ARRVAL_P(zsg), grab_files, 1, &zqs);
}
- zend_update_property(php_http_env_request_class_entry, getThis(), ZEND_STRL("files"), &zqs);
+ zend_update_property(php_http_env_request_class_entry, &obj->zo, ZEND_STRL("files"), &zqs);
zval_ptr_dtor(&zqs);
}
zend_fcall_info_cache fcc; \
zval rv, mn, *args = ecalloc(sizeof(zval), ZEND_NUM_ARGS()); \
zval *this_ptr = getThis(); \
- zval qs_tmp, *qs = zend_read_property(Z_OBJCE_P(this_ptr), this_ptr, ZEND_STRL(prop), 0, &qs_tmp); \
+ zval qs_tmp, *qs = zend_read_property(Z_OBJCE_P(this_ptr), Z_OBJ_P(this_ptr), ZEND_STRL(prop), 0, &qs_tmp); \
\
ZVAL_NULL(&rv); \
array_init(&mn); \
if (ZEND_NUM_ARGS()) {
call_querystring_get("form");
} else {
- zval zform_tmp, *zform = zend_read_property(php_http_env_request_class_entry, getThis(), ZEND_STRL("form"), 0, &zform_tmp);
+ zval zform_tmp, *zform = zend_read_property(php_http_env_request_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("form"), 0, &zform_tmp);
RETURN_ZVAL(zform, 1, 0);
}
}
if (ZEND_NUM_ARGS()) {
call_querystring_get("query");
} else {
- zval zquery_tmp, *zquery = zend_read_property(php_http_env_request_class_entry, getThis(), ZEND_STRL("query"), 0, &zquery_tmp);
+ zval zquery_tmp, *zquery = zend_read_property(php_http_env_request_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("query"), 0, &zquery_tmp);
RETURN_ZVAL(zquery, 1, 0);
}
}
if (ZEND_NUM_ARGS()) {
call_querystring_get("cookie");
} else {
- zval zcookie_tmp, *zcookie = zend_read_property(php_http_env_request_class_entry, getThis(), ZEND_STRL("cookie"), 0, &zcookie_tmp);
+ zval zcookie_tmp, *zcookie = zend_read_property(php_http_env_request_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("cookie"), 0, &zcookie_tmp);
RETURN_ZVAL(zcookie, 1, 0);
}
}
static PHP_METHOD(HttpEnvRequest, getFiles)
{
if (SUCCESS == zend_parse_parameters_none()) {
- zval zfiles_tmp, *zfiles = zend_read_property(php_http_env_request_class_entry, getThis(), ZEND_STRL("files"), 0, &zfiles_tmp);
+ zval zfiles_tmp, *zfiles = zend_read_property(php_http_env_request_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("files"), 0, &zfiles_tmp);
RETURN_ZVAL(zfiles, 1, 0);
}
}
if (EXPECTED(value_ptr)) {
switch (type) {
case IS_DOUBLE:
- zend_update_property_double(Z_OBJCE_P(options), options, name_str, name_len, *(double *)value_ptr);
+ zend_update_property_double(Z_OBJCE_P(options), Z_OBJ_P(options), name_str, name_len, *(double *)value_ptr);
break;
case IS_LONG:
- zend_update_property_long(Z_OBJCE_P(options), options, name_str, name_len, *(zend_long *)value_ptr);
+ zend_update_property_long(Z_OBJCE_P(options), Z_OBJ_P(options), name_str, name_len, *(zend_long *)value_ptr);
break;
case IS_STRING:
- zend_update_property_stringl(Z_OBJCE_P(options), options, name_str, name_len, value_ptr, value_len);
+ zend_update_property_stringl(Z_OBJCE_P(options), Z_OBJ_P(options), name_str, name_len, value_ptr, value_len);
break;
case IS_ARRAY:
case IS_OBJECT:
- zend_update_property(Z_OBJCE_P(options), options, name_str, name_len, value_ptr);
+ zend_update_property(Z_OBJCE_P(options), Z_OBJ_P(options), name_str, name_len, value_ptr);
break;
}
} else {
- zend_update_property_null(Z_OBJCE_P(options), options, name_str, name_len);
+ zend_update_property_null(Z_OBJCE_P(options), Z_OBJ_P(options), name_str, name_len);
}
} else {
convert_to_array(options);
zval *val = NULL;
if (EXPECTED(Z_TYPE_P(options) == IS_OBJECT)) {
- val = zend_read_property(Z_OBJCE_P(options), options, name_str, name_len, 0, tmp);
+ val = zend_read_property(Z_OBJCE_P(options), Z_OBJ_P(options), name_str, name_len, 0, tmp);
} else if (EXPECTED(Z_TYPE_P(options) == IS_ARRAY)) {
val = zend_symtable_str_find(Z_ARRVAL_P(options), name_str, name_len);
} else {
php_http_version_t v;
zend_string *zs = zval_get_string(zoption);
- zval_ptr_dtor(zoption);
if (EXPECTED(zs->len && php_http_version_parse(&v, zs->val))) {
ret = r->ops->set_protocol_version(r, &v);
php_http_version_dtor(&v);
}
zend_string_release(zs);
+ zval_ptr_dtor(zoption);
}
if (ret != SUCCESS) {
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "a", &zdisposition), invalid_arg, return);
- zend_update_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("contentDisposition"), zdisposition);
+ zend_update_property(Z_OBJCE_P(ZEND_THIS), Z_OBJ_P(ZEND_THIS), ZEND_STRL("contentDisposition"), zdisposition);
RETVAL_ZVAL(getThis(), 1, 0);
}
#include "php_http_api.h"
-#if PHP_HTTP_HAVE_HASH
-# include "ext/hash/php_hash.h"
-#endif
-
+#include "ext/hash/php_hash.h"
#include "ext/standard/crc32.h"
#include "ext/standard/sha1.h"
#include "ext/standard/md5.h"
php_http_etag_t *php_http_etag_init(const char *mode)
{
- void *ctx;
php_http_etag_t *e;
+ zend_string *mode_str = zend_string_init(mode, strlen(mode), 0);
+ const php_hash_ops *eho = php_hash_fetch_ops(mode_str);
- if (mode && (!strcasecmp(mode, "crc32b"))) {
- ctx = emalloc(sizeof(uint32_t));
- *((uint32_t *) ctx) = ~0;
- } else if (mode && !strcasecmp(mode, "sha1")) {
- PHP_SHA1Init(ctx = emalloc(sizeof(PHP_SHA1_CTX)));
- } else if (mode && !strcasecmp(mode, "md5")) {
- PHP_MD5Init(ctx = emalloc(sizeof(PHP_MD5_CTX)));
- } else {
-#if PHP_HTTP_HAVE_HASH
- const php_hash_ops *eho = NULL;
-
- if (mode && (eho = php_hash_fetch_ops(mode, strlen(mode)))) {
- ctx = emalloc(eho->context_size);
- eho->hash_init(ctx);
- } else
-#endif
+ if (!eho) {
+ zend_string_release(mode_str);
return NULL;
}
+ zend_string_release(mode_str);
- e = emalloc(sizeof(*e));
- e->ctx = ctx;
- e->mode = estrdup(mode);
+ e = emalloc(sizeof(*e) + eho->context_size - 1);
+ e->ops = eho;
+ eho->hash_init(e->ctx);
return e;
}
char *php_http_etag_finish(php_http_etag_t *e)
{
unsigned char digest[128] = {0};
- char *etag = NULL;
+ char *etag;
- if (!strcasecmp(e->mode, "crc32b")) {
- uint32_t e_ctx;
- memcpy(&e_ctx, e->ctx, 4);
- e_ctx = ntohl(~e_ctx);
- etag = php_http_etag_digest((unsigned char *) &e_ctx, 4);
- } else if ((!strcasecmp(e->mode, "sha1"))) {
- PHP_SHA1Final(digest, e->ctx);
- etag = php_http_etag_digest(digest, 20);
- } else if ((!strcasecmp(e->mode, "md5"))) {
- PHP_MD5Final(digest, e->ctx);
- etag = php_http_etag_digest(digest, 16);
- } else {
-#if PHP_HTTP_HAVE_HASH
- const php_hash_ops *eho = NULL;
-
- if ((eho = php_hash_fetch_ops(e->mode, strlen(e->mode)))) {
- eho->hash_final(digest, e->ctx);
- etag = php_http_etag_digest(digest, eho->digest_size);
- }
-#endif
- }
-
- efree(e->ctx);
- efree(e->mode);
+ e->ops->hash_final(digest, e->ctx);
+ etag = php_http_etag_digest(digest, e->ops->digest_size);
efree(e);
return etag;
size_t php_http_etag_update(php_http_etag_t *e, const char *data_ptr, size_t data_len)
{
- if (!strcasecmp(e->mode, "crc32b")) {
- uint32_t i, c = *((uint32_t *) e->ctx);
- for (i = 0; i < data_len; ++i) {
- CRC32(c, data_ptr[i]);
- }
- *((uint32_t *) e->ctx) = c;
- } else if ((!strcasecmp(e->mode, "sha1"))) {
- PHP_SHA1Update(e->ctx, (const unsigned char *) data_ptr, data_len);
- } else if ((!strcasecmp(e->mode, "md5"))) {
- PHP_MD5Update(e->ctx, (const unsigned char *) data_ptr, data_len);
- } else {
-#if PHP_HTTP_HAVE_HASH
- const php_hash_ops *eho = NULL;
-
- if ((eho = php_hash_fetch_ops(e->mode, strlen(e->mode)))) {
- eho->hash_update(e->ctx, (const unsigned char *) data_ptr, data_len);
- }
-#endif
- }
+ e->ops->hash_update(e->ctx, (const unsigned char *) data_ptr, data_len);
return data_len;
}
#ifndef PHP_HTTP_ETAG_H
#define PHP_HTTP_ETAG_H
+#include "ext/hash/php_hash.h"
+
typedef struct php_http_etag {
- void *ctx;
- char *mode;
+ const php_hash_ops *ops;
+ char ctx[1];
} php_http_etag_t;
PHP_HTTP_API php_http_etag_t *php_http_etag_init(const char *mode);
if (name_str && name_len) {
char *pretty_str = estrndup(name_str, name_len);
- zend_update_property_stringl(php_http_header_class_entry, getThis(), ZEND_STRL("name"), php_http_pretty_key(pretty_str, name_len, 1, 1), name_len);
+ zend_update_property_stringl(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("name"), php_http_pretty_key(pretty_str, name_len, 1, 1), name_len);
efree(pretty_str);
}
if (value_str && value_len) {
- zend_update_property_stringl(php_http_header_class_entry, getThis(), ZEND_STRL("value"), value_str, value_len);
+ zend_update_property_stringl(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), value_str, value_len);
}
}
zval name_tmp, value_tmp;
php_http_buffer_init(&buf);
- zs = zval_get_string(zend_read_property(php_http_header_class_entry, getThis(), ZEND_STRL("name"), 0, &name_tmp));
+ zs = zval_get_string(zend_read_property(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("name"), 0, &name_tmp));
php_http_buffer_appendz(&buf, zs);
zend_string_release(zs);
- zs = zval_get_string(zend_read_property(php_http_header_class_entry, getThis(), ZEND_STRL("value"), 0, &value_tmp));
+ zs = zval_get_string(zend_read_property(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), 0, &value_tmp));
if (zs->len) {
php_http_buffer_appends(&buf, ": ");
php_http_buffer_appendz(&buf, zs);
zend_hash_internal_pointer_reset(&ht);
switch (zend_hash_get_current_key(&ht, &key, &idx)) {
case HASH_KEY_IS_STRING:
- zend_update_property_str(php_http_header_class_entry, getThis(), ZEND_STRL("name"), key);
+ zend_update_property_str(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("name"), key);
break;
case HASH_KEY_IS_LONG:
- zend_update_property_long(php_http_header_class_entry, getThis(), ZEND_STRL("name"), idx);
+ zend_update_property_long(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("name"), idx);
break;
default:
break;
}
zs = zval_get_string(zend_hash_get_current_data(&ht));
- zend_update_property_str(php_http_header_class_entry, getThis(), ZEND_STRL("value"), zs);
+ zend_update_property_str(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), zs);
zend_string_release(zs);
}
}
return;
}
- zs = zval_get_string(zend_read_property(php_http_header_class_entry, getThis(), ZEND_STRL("value"), 0, &value_tmp));
+ zs = zval_get_string(zend_read_property(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), 0, &value_tmp));
RETVAL_BOOL(php_http_match(zs->val, val_str, flags));
zend_string_release(zs);
}
array_init(rs_array);
}
- zs = zval_get_string(zend_read_property(php_http_header_class_entry, getThis(), ZEND_STRL("name"), 0, &name_tmp));
+ zs = zval_get_string(zend_read_property(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("name"), 0, &name_tmp));
if (zend_string_equals_literal(zs, "Accept")) {
sep_str = "/";
sep_len = 1;
}
zend_string_release(zs);
- zs = zval_get_string(zend_read_property(php_http_header_class_entry, getThis(), ZEND_STRL("value"), 0, &value_tmp));
+ zs = zval_get_string(zend_read_property(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), 0, &value_tmp));
if ((rs = php_http_negotiate(zs->val, zs->len, supported, sep_str, sep_len))) {
PHP_HTTP_DO_NEGOTIATE_HANDLE_RESULT(rs, supported, rs_array);
} else {
object_init_ex(&zparams_obj, php_http_params_get_class_entry());
zargs = (zval *) ecalloc(ZEND_NUM_ARGS()+1, sizeof(zval));
- ZVAL_COPY_VALUE(&zargs[0], zend_read_property(php_http_header_class_entry, getThis(), ZEND_STRL("value"), 0, &value_tmp));
+ ZVAL_COPY_VALUE(&zargs[0], zend_read_property(php_http_header_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), 0, &value_tmp));
if (ZEND_NUM_ARGS()) {
zend_get_parameters_array(ZEND_NUM_ARGS(), ZEND_NUM_ARGS(), &zargs[1]);
}
object_init_ex(&zho, ce);
Z_TRY_ADDREF_P(val);
- zend_call_method_with_2_params(&zho, ce, NULL, "__construct", NULL, &zkey, val);
+ zend_call_method_with_2_params(Z_OBJ(zho), ce, NULL, "__construct", NULL, &zkey, val);
zval_ptr_dtor(val);
zval_ptr_dtor(&zkey);
return parser;
}
-#define php_http_header_parser_state_push(parser, state) zend_ptr_stack_push(&(parser)->stack, (void *) (state)), (state)
+static inline php_http_header_parser_state_t
+php_http_header_parser_state_push(php_http_header_parser_t *parser, php_http_header_parser_state_t state)
+{
+ zend_ptr_stack_push(&(parser)->stack, (void *) (state));
+ return state;
+}
+
#define php_http_header_parser_state_ex(parser) ((parser)->stack.top \
? (php_http_header_parser_state_t) (parser)->stack.elements[(parser)->stack.top - 1] \
: PHP_HTTP_HEADER_PARSER_STATE_START)
PHP_ME(HttpHeaderParser, getState, ai_HttpHeaderParser_getState, ZEND_ACC_PUBLIC)
PHP_ME(HttpHeaderParser, parse, ai_HttpHeaderParser_parse, ZEND_ACC_PUBLIC)
PHP_ME(HttpHeaderParser, stream, ai_HttpHeaderParser_stream, ZEND_ACC_PUBLIC)
- {NULL, NULL, NULL}
+ {0}
};
PHP_MINIT_FUNCTION(http_header_parser)
char *tmp = NULL;
size_t len = 0;
- php_http_info_to_string((php_http_info_t *) msg, &tmp, &len, PHP_HTTP_CRLF TSRMLS_CC);
+ php_http_info_to_string((php_http_info_t *) msg, &tmp, &len, PHP_HTTP_CRLF);
php_http_message_update_headers(msg);
php_http_buffer_append(str, tmp, len);
return php_http_message_class_entry;
}
-static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *rv);
-
-static PHP_WRITE_PROP_HANDLER_TYPE php_http_message_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot);
+static zval *php_http_message_object_read_prop(zend_object *object, zend_string *member, int type, void **cache_slot, zval *rv);
+static zval *php_http_message_object_write_prop(zend_object *object, zend_string *member, zval *value, void **cache_slot);
static zend_object_handlers php_http_message_object_handlers;
static HashTable php_http_message_object_prophandlers;
return o;
}
-zend_object *php_http_message_object_clone(zval *this_ptr)
+zend_object *php_http_message_object_clone(zend_object *this_ptr)
{
php_http_message_object_t *new_obj;
- php_http_message_object_t *old_obj = PHP_HTTP_OBJ(NULL, this_ptr);
+ php_http_message_object_t *old_obj = PHP_HTTP_OBJ(this_ptr, NULL);
new_obj = php_http_message_object_new_ex(old_obj->zo.ce, php_http_message_copy(old_obj->message, NULL));
zend_objects_clone_members(&new_obj->zo, &old_obj->zo);
zend_object_std_dtor(object);
}
-#if PHP_VERSION_ID >= 70400
-static zval *php_http_message_object_get_prop_ptr(zval *object, zval *member, int type, void **cache_slot)
+static zval *php_http_message_object_get_prop_ptr(zend_object *object, zend_string *member, int type, void **cache_slot)
{
return NULL;
}
-#endif
-static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *tmp)
+static zval *php_http_message_object_read_prop(zend_object *object, zend_string *member, int type, void **cache_slot, zval *tmp)
{
zval *return_value;
- zend_string *member_name = zval_get_string(member);
- php_http_message_object_prophandler_t *handler = php_http_message_object_get_prophandler(member_name);
+ php_http_message_object_prophandler_t *handler = php_http_message_object_get_prophandler(member);
return_value = zend_get_std_object_handlers()->read_property(object, member, type, cache_slot, tmp);
if (handler && handler->read) {
- php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(object, NULL);
handler->read(obj, return_value);
}
-
- zend_string_release(member_name);
return return_value;
}
-static PHP_WRITE_PROP_HANDLER_TYPE php_http_message_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot)
+static zval *php_http_message_object_write_prop(zend_object *object, zend_string *member, zval *value, void **cache_slot)
{
- php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(object, NULL);
php_http_message_object_prophandler_t *handler;
- zend_string *member_name = zval_get_string(member);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if ((handler = php_http_message_object_get_prophandler(member_name))) {
+ if ((handler = php_http_message_object_get_prophandler(member))) {
handler->write(obj, value);
} else {
zend_get_std_object_handlers()->write_property(object, member, value, cache_slot);
}
-
- zend_string_release(member_name);
- PHP_WRITE_PROP_HANDLER_RETURN(value);
+ return value;
}
-static HashTable *php_http_message_object_get_debug_info(zval *object, int *is_temp)
+static HashTable *php_http_message_object_get_debug_info(zend_object *object, int *is_temp)
{
zval tmp;
- php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(object, NULL);
HashTable *props = zend_get_std_object_handlers()->get_properties(object);
char *ver_str, *url_str = NULL;
size_t ver_len, url_len = 0;
return props;
}
-static HashTable *php_http_message_object_get_gc(zval *object, zval **table, int *n)
+static HashTable *php_http_message_object_get_gc(zend_object *object, zval **table, int *n)
{
- php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
- HashTable *props = Z_OBJPROP_P(object);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(object, NULL);
+ HashTable *props = object->handlers->get_properties(object);
uint32_t count = 2 + zend_hash_num_elements(props);
zval *val;
return NULL;
}
+static int php_http_message_object_cast(zend_object *object, zval *return_value, int type)
+{
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(object, NULL);
+ char *string;
+ size_t length;
+
+ switch (type) {
+ case IS_STRING:
+ PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
+ php_http_message_to_string(obj->message, &string, &length);
+ if (string) {
+ RETVAL_STR(php_http_cs2zs(string, length));
+ } else {
+ RETVAL_EMPTY_STRING();
+ }
+ return SUCCESS;
+ case _IS_BOOL:
+ RETVAL_TRUE;
+ return SUCCESS;
+ default:
+ return FAILURE;
+ }
+}
+
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage___construct, 0, 0, 0)
ZEND_ARG_INFO(0, message)
ZEND_ARG_INFO(0, greedy)
php_http_message_object_handlers.get_property_ptr_ptr = NULL;
#endif
php_http_message_object_handlers.get_gc = php_http_message_object_get_gc;
+ php_http_message_object_handlers.cast_object = php_http_message_object_cast;
zend_class_implements(php_http_message_class_entry, 3, spl_ce_Countable, zend_ce_serializable, zend_ce_iterator);
zend_object *php_http_message_object_new(zend_class_entry *ce);
php_http_message_object_t *php_http_message_object_new_ex(zend_class_entry *ce, php_http_message_t *msg);
-zend_object *php_http_message_object_clone(zval *object);
+zend_object *php_http_message_object_clone(zend_object *object);
void php_http_message_object_free(zend_object *object);
#endif
return FAILURE;
} else {
zend_string *znc = zval_get_string(zname), *ztc = zval_get_string(ztype);
- php_http_arrkey_t arrkey = {0, znc};
+ php_http_arrkey_t arrkey = {0, znc, 0, 0};
char *key = format_key(&arrkey, name);
ZEND_RESULT_CODE ret = php_http_message_body_add_form_file(body, key, ztc->val, zfc->val, stream);
return o;
}
-zend_object *php_http_message_body_object_clone(zval *object)
+zend_object *php_http_message_body_object_clone(zend_object *object)
{
php_http_message_body_object_t *new_obj;
- php_http_message_body_object_t *old_obj = PHP_HTTP_OBJ(NULL, object);
+ php_http_message_body_object_t *old_obj = PHP_HTTP_OBJ(object, NULL);
php_http_message_body_t *body = php_http_message_body_copy(old_obj->body, NULL);
new_obj = php_http_message_body_object_new_ex(old_obj->zo.ce, body);
return &new_obj->zo;
}
-static HashTable *php_http_message_body_object_get_gc(zval *object, zval **table, int *n)
+static HashTable *php_http_message_body_object_get_gc(zend_object *object, zval **table, int *n)
{
- php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, object);
- HashTable *props = Z_OBJPROP_P(object);
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(object, NULL);
+ HashTable *props = object->handlers->get_properties(object);
uint32_t count = zend_hash_num_elements(props);
obj->gc = erealloc(obj->gc, (1 + count) * sizeof(zval));
zend_object *php_http_message_body_object_new(zend_class_entry *ce);
php_http_message_body_object_t *php_http_message_body_object_new_ex(zend_class_entry *ce, php_http_message_body_t *body);
-zend_object *php_http_message_body_object_clone(zval *object);
+zend_object *php_http_message_body_object_clone(zend_object *object);
void php_http_message_body_object_free(zend_object *object);
#endif
return parser;
}
-#define php_http_message_parser_state_push(parser, state) zend_ptr_stack_push(&(parser)->stack, (void *) (state)), (state)
+static inline php_http_message_parser_state_t
+php_http_message_parser_state_push(php_http_message_parser_t *parser, php_http_message_parser_state_t state)
+{
+ zend_ptr_stack_push(&parser->stack, (void *) state);
+ return state;
+}
+
#define php_http_message_parser_state_pop(parser) ((parser)->stack.top \
? (php_http_message_parser_state_t) zend_ptr_stack_pop(&parser->stack) \
: PHP_HTTP_MESSAGE_PARSER_STATE_START)
PHP_ME(HttpMessageParser, getState, ai_HttpMessageParser_getState, ZEND_ACC_PUBLIC)
PHP_ME(HttpMessageParser, parse, ai_HttpMessageParser_parse, ZEND_ACC_PUBLIC)
PHP_ME(HttpMessageParser, stream, ai_HttpMessageParser_stream, ZEND_ACC_PUBLIC)
- {NULL, NULL, NULL}
+ {0}
};
PHP_MINIT_FUNCTION(http_message_parser)
zval zdata;
ZVAL_STRINGL(&zdata, str, len);
- if (SUCCESS == zend_fcall_info_argn(&fcd->fci, 2, &fcd->fcz, &zdata)) {
- zend_fcall_info_call(&fcd->fci, &fcd->fcc, NULL, NULL);
- zend_fcall_info_args_clear(&fcd->fci, 0);
- }
+ zend_fcall_info_argn(&fcd->fci, 2, &fcd->fcz, &zdata);
+ zend_fcall_info_call(&fcd->fci, &fcd->fcc, NULL, NULL);
+ zend_fcall_info_args_clear(&fcd->fci, 0);
zval_ptr_dtor(&zdata);
return len;
}
#if PHP_DEBUG
# undef HASH_OF
-# if PHP_VERSION_ID >= 70500
-# define HASH_OF(p) ((HashTable*)(Z_TYPE_P(p)==IS_ARRAY ? Z_ARRVAL_P(p) : ((Z_TYPE_P(p)==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties(Z_OBJ_P(p)) : NULL))))
-# else
-# define HASH_OF(p) ((HashTable*)(Z_TYPE_P(p)==IS_ARRAY ? Z_ARRVAL_P(p) : ((Z_TYPE_P(p)==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties((p)) : NULL))))
-# endif
+# define HASH_OF(p) ((HashTable*)(Z_TYPE_P(p)==IS_ARRAY ? Z_ARRVAL_P(p) : ((Z_TYPE_P(p)==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties(Z_OBJ_P(p)) : NULL))))
#endif
-#ifndef GC_SET_REFCOUNT
-# define GC_SET_REFCOUNT(gc, rc) GC_REFCOUNT(gc) = rc
-#endif
-#ifndef GC_ADDREF
-# define GC_ADDREF(gc) ++GC_REFCOUNT(gc)
-#endif
-#ifndef GC_DELREF
-# define GC_DELREF(gc) --GC_REFCOUNT(gc)
-#endif
-
-#ifdef ZEND_HASH_GET_APPLY_COUNT
-# define HT_IS_RECURSIVE(ht) (ZEND_HASH_GET_APPLY_COUNT(ht) > 0)
-#else
-# define HT_IS_RECURSIVE(ht) GC_IS_RECURSIVE(ht)
-#endif
-#ifdef ZEND_HASH_INC_APPLY_COUNT
-# define HT_PROTECT_RECURSION(ht) ZEND_HASH_INC_APPLY_COUNT(ht)
-#else
-# define HT_PROTECT_RECURSION(ht) GC_PROTECT_RECURSION(ht)
-#endif
-#ifdef ZEND_HASH_DEC_APPLY_COUNT
-# define HT_UNPROTECT_RECURSION(ht) ZEND_HASH_DEC_APPLY_COUNT(ht)
-#else
-# define HT_UNPROTECT_RECURSION(ht) GC_UNPROTECT_RECURSION(ht)
-#endif
-#if PHP_VERSION_ID >= 70400
-# define PHP_WRITE_PROP_HANDLER_TYPE zval *
-# define PHP_WRITE_PROP_HANDLER_RETURN(v) return v
-#else
-# define PHP_WRITE_PROP_HANDLER_TYPE void
-# define PHP_WRITE_PROP_HANDLER_RETURN(v)
-#endif
+#define HT_IS_RECURSIVE(ht) GC_IS_RECURSIVE(ht)
+#define HT_PROTECT_RECURSION(ht) GC_PROTECT_RECURSION(ht)
+#define HT_UNPROTECT_RECURSION(ht) GC_UNPROTECT_RECURSION(ht)
static inline void *PHP_HTTP_OBJ(zend_object *zo, zval *zv)
{
static inline zend_string *php_http_cs2zs(char *s, size_t l)
{
- zend_string *str = erealloc(s, sizeof(*str) + l);
-
- memmove(str->val, str, l);
- str->val[l] = 0;
- str->len = l;
- str->h = 0;
-
- GC_SET_REFCOUNT(str, 1);
- GC_TYPE_INFO(str) = IS_STRING;
-
+ zend_string *str = zend_string_init(s, l, 0);
+ efree(s);
return str;
}
return FAILURE;
}
-#define Z_ISUSER(zv) (Z_TYPE(zv) <= 10)
-#define Z_ISUSER_P(zvp) Z_ISUSER(*(zvp))
-
/* return object(values) */
#define ZVAL_OBJECT(z, o, addref) \
ZVAL_OBJ(z, o); \
# define PHP_HTTP_DEBUG_NEG 0
#endif
-static int php_http_negotiate_sort(const void *first, const void *second)
+static int php_http_negotiate_sort(Bucket *b1, Bucket *b2)
{
- Bucket *b1 = (Bucket *) first, *b2 = (Bucket *) second;
int result = numeric_compare_function(&b1->val, &b2->val);
return (result > 0 ? -1 : (result < 0 ? 1 : 0));
{
php_http_option_t *opt = Z_PTR_P(pData);
- zval_internal_dtor(&opt->defval);
+ zval_internal_ptr_dtor(&opt->defval);
zend_hash_destroy(&opt->suboptions.options);
zend_string_release(opt->name);
pefree(opt, opt->persistent);
def_param_sep_ptr,
def_arg_sep_ptr,
def_val_sep_ptr,
- {{0}},
+ {{0}, {0}, {0}},
PHP_HTTP_PARAMS_DEFAULT
};
HashTable *php_http_params_parse(HashTable *params, const php_http_params_opts_t *opts)
{
- php_http_params_state_t state = {{NULL,0}, {NULL,0}, {NULL,0}, {NULL,0}, {NULL,NULL,NULL}, 0, 0};
+ php_http_params_state_t state;
+ memset(&state, 0, sizeof(state));
state.input.str = opts->input.str;
state.input.len = opts->input.len;
{
switch (ZEND_NUM_ARGS()) {
case 5:
- zend_update_property_long(php_http_params_class_entry, getThis(), ZEND_STRL("flags"), flags);
+ zend_update_property_long(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("flags"), flags);
/* no break */
case 4:
- zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), val_sep);
+ zend_update_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("val_sep"), val_sep);
/* no break */
case 3:
- zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), arg_sep);
+ zend_update_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("arg_sep"), arg_sep);
/* no break */
case 2:
- zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), param_sep);
+ zend_update_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("param_sep"), param_sep);
/* no break */
}
case IS_OBJECT:
case IS_ARRAY:
convert_to_array(zparams);
- zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams);
+ zend_update_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), zparams);
break;
default:
zs = zval_get_string(zparams);
php_http_params_opts_t opts = {
{zs->val, zs->len},
- php_http_params_separator_init(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), 0, &tmp)),
- php_http_params_separator_init(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), 0, &tmp)),
- php_http_params_separator_init(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), 0, &tmp)),
- {{0}}, flags
+ php_http_params_separator_init(zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("param_sep"), 0, &tmp)),
+ php_http_params_separator_init(zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("arg_sep"), 0, &tmp)),
+ php_http_params_separator_init(zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("val_sep"), 0, &tmp)),
+ {{0}, {0}, {0}}, flags
};
array_init(&tmp);
php_http_params_parse(Z_ARRVAL(tmp), &opts);
- zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), &tmp);
+ zend_update_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), &tmp);
zval_ptr_dtor(&tmp);
php_http_params_separator_free(opts.param);
zval tmp;
array_init(&tmp);
- zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), &tmp);
+ zend_update_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), &tmp);
zval_ptr_dtor(&tmp);
}
}
if (SUCCESS != zend_parse_parameters_none()) {
return;
}
- zparams = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0, &zparams_tmp);
+ zparams = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), 0, &zparams_tmp);
RETURN_ZVAL(zparams, 1, 0);
}
long flags;
php_http_buffer_t buf;
- zparams = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0, &zparams_tmp);
+ zparams = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), 0, &zparams_tmp);
convert_to_array_ex(zparams);
- flags = zval_get_long(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("flags"), 0, &flags_tmp));
+ flags = zval_get_long(zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("flags"), 0, &flags_tmp));
- zpsep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), 0, &psep_tmp);
+ zpsep = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("param_sep"), 0, &psep_tmp);
if (Z_TYPE_P(zpsep) == IS_ARRAY && (tmp = zend_hash_get_current_data(Z_ARRVAL_P(zpsep)))) {
psep = zval_get_string(tmp);
} else {
psep = zval_get_string(zpsep);
}
- zasep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), 0, &asep_tmp);
+ zasep = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("arg_sep"), 0, &asep_tmp);
if (Z_TYPE_P(zasep) == IS_ARRAY && (tmp = zend_hash_get_current_data(Z_ARRVAL_P(zasep)))) {
asep = zval_get_string(tmp);
} else {
asep = zval_get_string(zasep);
}
- zvsep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), 0, &vsep_tmp);
+ zvsep = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("val_sep"), 0, &vsep_tmp);
if (Z_TYPE_P(zvsep) == IS_ARRAY && (tmp = zend_hash_get_current_data(Z_ARRVAL_P(zvsep)))) {
vsep = zval_get_string(tmp);
} else {
return;
}
- zparams = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0, &zparams_tmp);
+ zparams = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), 0, &zparams_tmp);
if (Z_TYPE_P(zparams) == IS_ARRAY && (zparam = zend_symtable_find(Z_ARRVAL_P(zparams), name))) {
RETVAL_BOOL(Z_TYPE_P(zparam) != IS_NULL);
return;
}
- zparams = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0, &zparams_tmp);
+ zparams = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), 0, &zparams_tmp);
if (Z_TYPE_P(zparams) == IS_ARRAY && (zparam = zend_symtable_find(Z_ARRVAL_P(zparams), name))) {
RETVAL_ZVAL(zparam, 1, 0);
return;
}
- zparams = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0, &zparams_tmp);
+ zparams = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), 0, &zparams_tmp);
if (Z_TYPE_P(zparams) == IS_ARRAY) {
zend_symtable_del(Z_ARRVAL_P(zparams), name);
return;
}
- zparams = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0, &zparams_tmp);
+ zparams = zend_read_property(php_http_params_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("params"), 0, &zparams_tmp);
convert_to_array(zparams);
if (name->len) {
array_init(&qa);
if (flags & QS_MERGE) {
- zval old_tmp, *old = zend_read_property(php_http_querystring_class_entry, instance, ZEND_STRL("queryArray"), 0, &old_tmp);
+ zval old_tmp, *old = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(instance), ZEND_STRL("queryArray"), 0, &old_tmp);
ZVAL_DEREF(old);
if (Z_TYPE_P(old) == IS_ARRAY) {
}
php_http_querystring_update(&qa, params, NULL);
- zend_update_property(php_http_querystring_class_entry, instance, ZEND_STRL("queryArray"), &qa);
+ zend_update_property(php_http_querystring_class_entry, Z_OBJ_P(instance), ZEND_STRL("queryArray"), &qa);
zval_ptr_dtor(&qa);
}
static inline void php_http_querystring_str(zval *instance, zval *return_value)
{
- zval qa_tmp, *qa = zend_read_property(php_http_querystring_class_entry, instance, ZEND_STRL("queryArray"), 0, &qa_tmp);
+ zval qa_tmp, *qa = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(instance), ZEND_STRL("queryArray"), 0, &qa_tmp);
ZVAL_DEREF(qa);
if (Z_TYPE_P(qa) == IS_ARRAY) {
static inline void php_http_querystring_get(zval *instance, int type, char *name, uint32_t name_len, zval *defval, zend_bool del, zval *return_value)
{
- zval *arrval, qarray_tmp, *qarray = zend_read_property(php_http_querystring_class_entry, instance, ZEND_STRL("queryArray"), 0, &qarray_tmp);
+ zval *arrval, qarray_tmp, *qarray = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(instance), ZEND_STRL("queryArray"), 0, &qarray_tmp);
ZVAL_DEREF(qarray);
if ((Z_TYPE_P(qarray) == IS_ARRAY) && (arrval = zend_symtable_str_find(Z_ARRVAL_P(qarray), name, name_len))) {
/* squeeze the hash out of the zval */
if (Z_TYPE_P(params) == IS_OBJECT && instanceof_function(Z_OBJCE_P(params), php_http_querystring_class_entry)) {
- zval qa_tmp, *qa = zend_read_property(php_http_querystring_class_entry, params, ZEND_STRL("queryArray"), 0, &qa_tmp);
+ zval qa_tmp, *qa = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(params), ZEND_STRL("queryArray"), 0, &qa_tmp);
ZVAL_DEREF(qa);
convert_to_array(qa);
if (Z_TYPE_P(instance) == IS_OBJECT) {
RETVAL_ZVAL(instance, 1, 0);
} else if ((_GET = php_http_env_get_superglobal(ZEND_STRL("_GET")))) {
- zval tmp, *qa;
+ zval *qa;
+ zend_string *qa_str = zend_string_init(ZEND_STRL("queryArray"), 0);
ZVAL_OBJ(return_value, php_http_querystring_object_new(php_http_querystring_class_entry));
-
- ZVAL_STRING(&tmp, "queryArray");
- qa = Z_OBJ_HT_P(return_value)->get_property_ptr_ptr(return_value, &tmp, BP_VAR_RW, NULL);
- zval_ptr_dtor(&tmp);
+ qa = Z_OBJ_HT_P(return_value)->get_property_ptr_ptr(Z_OBJ_P(return_value), qa_str, BP_VAR_RW, NULL);
+ zend_string_release(qa_str);
ZVAL_NEW_REF(_GET, _GET);
ZVAL_COPY(qa, _GET);
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0, &qa_tmp);
+ qa = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("queryArray"), 0, &qa_tmp);
object_init_ex(return_value, spl_ce_RecursiveArrayIterator);
- zend_call_method_with_1_params(return_value, spl_ce_RecursiveArrayIterator, NULL, "__construct", NULL, qa);
+ zend_call_method_with_1_params(Z_OBJ_P(return_value), spl_ce_RecursiveArrayIterator, NULL, "__construct", NULL, qa);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_toString, 0, 0, 0)
return;
}
- zqa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0, &zqa_tmp);
+ zqa = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("queryArray"), 0, &zqa_tmp);
RETURN_ZVAL(zqa, 1, 0);
}
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z", ¶ms), invalid_arg, return);
zend_replace_error_handling(EH_THROW, php_http_get_exception_bad_querystring_class_entry(), &zeh);
- ZVAL_OBJ(return_value, Z_OBJ_HT_P(instance)->clone_obj(instance));
+ ZVAL_OBJ(return_value, Z_OBJ_HT_P(instance)->clone_obj(Z_OBJ_P(instance)));
/* make sure we do not inherit the reference to _GET */
- SEPARATE_ZVAL(zend_read_property(Z_OBJCE_P(return_value), return_value, ZEND_STRL("queryArray"), 0, &qa_tmp));
+ SEPARATE_ZVAL(zend_read_property(Z_OBJCE_P(return_value), Z_OBJ_P(return_value), ZEND_STRL("queryArray"), 0, &qa_tmp));
php_http_querystring_set(return_value, params, QS_MERGE);
zend_restore_error_handling(&zeh);
}
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &ie, &ie_len, &oe, &oe_len), invalid_arg, return);
array_init(&na);
- qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0, &qa_tmp);
+ qa = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("queryArray"), 0, &qa_tmp);
ZVAL_DEREF(qa);
convert_to_array(qa);
return;
}
- qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0, &qa_tmp);
+ qa = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("queryArray"), 0, &qa_tmp);
ZVAL_DEREF(qa);
if (Z_TYPE_P(qa) == IS_ARRAY) {
return;
}
- qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0, &qa_tmp);
+ qa = zend_read_property(php_http_querystring_class_entry, Z_OBJ_P(ZEND_THIS), ZEND_STRL("queryArray"), 0, &qa_tmp);
ZVAL_DEREF(qa);
if (Z_TYPE_P(qa) == IS_ARRAY) {
if (!strct || Z_TYPE_P(strct) == IS_ARRAY) { \
zend_hash_str_update(ht, part, lenof(part), &tmp); \
} else { \
- zend_update_property(Z_OBJCE_P(strct), strct, part, lenof(part), &tmp); \
+ zend_update_property(Z_OBJCE_P(strct), Z_OBJ_P(strct), part, lenof(part), &tmp); \
zval_ptr_dtor(&tmp); \
}
# endif
efree(uhost_str);
- if (error > U_ZERO_ERROR) {
+ if (rc > U_ZERO_ERROR) {
goto error;
}
if ((old_purl = php_http_url_from_struct(HASH_OF(getThis())))) {
php_http_url_t *res_purl;
- ZVAL_OBJ(return_value, zend_objects_clone_obj(getThis()));
+ ZVAL_OBJ(return_value, zend_objects_clone_obj(Z_OBJ_P(getThis())));
res_purl = php_http_url_mod(old_purl, new_purl, flags);
php_http_url_to_struct(res_purl, return_value);
--TEST--
client deprecated methods
--SKIPIF--
-<?php
+<?php
include "skipif.inc";
skip_client_test();
?>
--FILE--
-<?php
+<?php
echo "Test\n";
--EXPECTF--
Test
-Deprecated: Function http\Client::enableEvents() is deprecated in %sclient024.php on line %d
+Deprecated: Method http\Client::enableEvents() is deprecated in %sclient024.php on line %d
-Deprecated: Function http\Client::enablePipelining() is deprecated in %sclient024.php on line %d
+Deprecated: Method http\Client::enablePipelining() is deprecated in %sclient024.php on line %d
===DONE===
--SKIPIF--
<?php
include "skipif.inc";
-php_version_compare(PHP_VERSION, "7.0.0-dev") or die("skip php<7");
+version_compare(PHP_VERSION, "7.0.0-dev") or die("skip php<7");
?>
--FILE--
<?php
URL barfs on punycode
--SKIPIF--
<?php
-include "./skipif.inc";
+include "skipif.inc";
?>
--FILE--
-<?php
+<?php
echo "Test\n";
echo new http\Url("http://www.xn--kln-sna.de"), "\n";
?>
+++ /dev/null
---TEST--
-message var_dump with inherited property with increased access level
---SKIPIF--
-<?php
-include "skipif.inc";
-?>
---FILE--
-<?php
-echo "Test\n";
-
-class c extends http\Message {
- public $headers;
-}
-
-$m = new c;
-$m->headers["foo"] = "bar";
-var_dump($m);
-
-?>
-DONE
---EXPECTF--
-Test
-object(c)#%d (9) {
- ["headers"]=>
- array(1) {
- ["foo"]=>
- string(3) "bar"
- }
- ["type":protected]=>
- int(0)
- ["body":protected]=>
- NULL
- ["requestMethod":protected]=>
- string(0) ""
- ["requestUrl":protected]=>
- string(0) ""
- ["responseStatus":protected]=>
- string(0) ""
- ["responseCode":protected]=>
- int(0)
- ["httpVersion":protected]=>
- string(3) "1.1"
- ["parentMessage":protected]=>
- NULL
-}
-DONE
Test
%a
HTTP Support => enabled
-Extension Version => 3.%s
+Extension Version => 4.%s
%a
Done
+++ /dev/null
---TEST--
-property proxy
---SKIPIF--
-<?php
-include "skipif.inc";
-?>
---FILE--
-<?php
-
-class m extends http\Message {
- function test1() {
- $this->headers["bykey"] = 1;
- var_dump($this->headers);
- }
- function test2() {
- $h = &$this->headers;
- $h["by1ref"] = 2;
- var_dump($this->headers);
- }
- function test3() {
- $x = &$this->headers["byXref"];
-
- $h = &$this->headers["by2ref"];
- $h = 1;
- var_dump($this->headers);
-
- $x = 2;
- var_dump($this->headers);
- }
- function test4() {
- $this->headers["bynext"][] = 1;
- $this->headers["bynext"][] = 2;
- $this->headers["bynext"][] = 3;
- var_dump($this->headers);
- }
-}
-
-$m=new m;
-$m->test1();
-$m->test2();
-$m->test3();
-$m->test4();
-echo $m,"\n";
-
-?>
-DONE
---EXPECTF--
-array(1) {
- ["bykey"]=>
- int(1)
-}
-array(2) {
- ["bykey"]=>
- int(1)
- ["by1ref"]=>
- int(2)
-}
-array(3) {
- ["bykey"]=>
- int(1)
- ["by1ref"]=>
- int(2)
- ["by2ref"]=>
- int(1)
-}
-array(4) {
- ["bykey"]=>
- int(1)
- ["by1ref"]=>
- int(2)
- ["by2ref"]=>
- int(1)
- ["byXref"]=>
- int(2)
-}
-array(5) {
- ["bykey"]=>
- int(1)
- ["by1ref"]=>
- int(2)
- ["by2ref"]=>
- int(1)
- ["byXref"]=>
- int(2)
- ["bynext"]=>
- array(3) {
- [0]=>
- int(1)
- [1]=>
- int(2)
- [2]=>
- int(3)
- }
-}
-bykey: 1
-by1ref: 2
-by2ref: 1
-byXref: 2
-bynext: 1
-bynext: 2
-bynext: 3
-
-DONE
-
+++ /dev/null
---TEST--
-query string
---SKIPIF--
-<?php
-include("skipif.inc");
-version_compare(PHP_VERSION, "7.2.0-dev", "<") or die("skip only for PHP < 7.2.0");
-?>
---GET--
-str=abc&num=-123&dec=123.123&bool=1&arr[]=1&arr[]=2&ma[l1][l2]=2&ma[l2][l3][l4]=3
---FILE--
-<?php
-echo "Test\n";
-
-printf("\nGlobal instance:\n");
-$q = http\QueryString::getGlobalInstance();
-printf("%s\n", $q);
-
-printf("\nStandard getters:\n");
-var_dump($q->getString("str"));
-var_dump($q->getInt("num"));
-var_dump($q->getFloat("dec"));
-var_dump($q->getInt("dec"));
-var_dump($q->getFloat("dec"));
-var_dump($q->getBool("bool"));
-var_dump($q->getInt("bool"));
-var_dump($q->getBool("num"));
-var_dump($q->getInt("num"));
-var_dump($q->getArray("arr"));
-var_dump($q->getArray("ma"));
-var_dump($q->getObject("arr"));
-var_dump($q->getObject("ma"));
-
-$s = $q->toString();
-
-printf("\nClone modifications do not alter global instance:\n");
-$q->mod(array("arr" => array(3 => 3)));
-printf("%s\n", $q);
-
-printf("\nClone modifications do not alter standard instance:\n");
-$q2 = new http\QueryString($s);
-$q3 = $q2->mod(array("arr" => array(3 => 3)));
-printf("%s\n%s\n", $q2, $q3);
-#var_dump($q2, $q3);
-
-printf("\nIterator:\n");
-$it = new RecursiveIteratorIterator($q2, RecursiveIteratorIterator::SELF_FIRST);
-foreach ($it as $k => $v) {
- $i = $it->getDepth()*8;
- @printf("%{$i}s: %s\n", $k, $v);
-}
-
-printf("\nReplace a multi dimensional key:\n");
-printf("%s\n", $q2->mod(array("ma" => null))->set(array("ma" => array("l1" => false))));
-
-printf("\nXlate:\n");
-$qu = new http\QueryString("ü=ö");
-printf("utf8: %s\n", $qu);
-printf("latin1: %s\n", method_exists($qu, "xlate") ? $qu->xlate("utf-8", "latin1") : "%FC=%F6");
-
-printf("\nOffsets:\n");
-var_dump($q2["ma"]);
-$q2["ma"] = array("bye");
-var_dump($q2["ma"]);
-var_dump(isset($q2["ma"]));
-unset($q2["ma"]);
-var_dump(isset($q2["ma"]));
-
-echo "Done\n";
-?>
---EXPECTF--
-Test
-
-Global instance:
-str=abc&num=-123&dec=123.123&bool=1&arr%5B0%5D=1&arr%5B1%5D=2&ma%5Bl1%5D%5Bl2%5D=2&ma%5Bl2%5D%5Bl3%5D%5Bl4%5D=3
-
-Standard getters:
-string(3) "abc"
-int(-123)
-float(123.123)
-int(123)
-float(123.123)
-bool(true)
-int(1)
-bool(true)
-int(-123)
-array(2) {
- [0]=>
- string(1) "1"
- [1]=>
- string(1) "2"
-}
-array(2) {
- ["l1"]=>
- array(1) {
- ["l2"]=>
- string(1) "2"
- }
- ["l2"]=>
- array(1) {
- ["l3"]=>
- array(1) {
- ["l4"]=>
- string(1) "3"
- }
- }
-}
-object(stdClass)#%d (2) {
- [0]=>
- string(1) "1"
- [1]=>
- string(1) "2"
-}
-object(stdClass)#%d (2) {
- ["l1"]=>
- array(1) {
- ["l2"]=>
- string(1) "2"
- }
- ["l2"]=>
- array(1) {
- ["l3"]=>
- array(1) {
- ["l4"]=>
- string(1) "3"
- }
- }
-}
-
-Clone modifications do not alter global instance:
-str=abc&num=-123&dec=123.123&bool=1&arr%5B0%5D=1&arr%5B1%5D=2&ma%5Bl1%5D%5Bl2%5D=2&ma%5Bl2%5D%5Bl3%5D%5Bl4%5D=3
-
-Clone modifications do not alter standard instance:
-str=abc&num=-123&dec=123.123&bool=1&arr%5B0%5D=1&arr%5B1%5D=2&ma%5Bl1%5D%5Bl2%5D=2&ma%5Bl2%5D%5Bl3%5D%5Bl4%5D=3
-str=abc&num=-123&dec=123.123&bool=1&arr%5B0%5D=1&arr%5B1%5D=2&arr%5B3%5D=3&ma%5Bl1%5D%5Bl2%5D=2&ma%5Bl2%5D%5Bl3%5D%5Bl4%5D=3
-
-Iterator:
-str: abc
-num: -123
-dec: 123.123
-bool: 1
-arr: Array
- 0: 1
- 1: 2
-ma: Array
- l1: Array
- l2: 2
- l2: Array
- l3: Array
- l4: 3
-
-Replace a multi dimensional key:
-str=abc&num=-123&dec=123.123&bool=1&arr%5B0%5D=1&arr%5B1%5D=2&ma%5Bl1%5D=
-
-Xlate:
-utf8: %C3%BC=%C3%B6
-latin1: %FC=%F6
-
-Offsets:
-array(2) {
- ["l1"]=>
- array(1) {
- ["l2"]=>
- string(1) "2"
- }
- ["l2"]=>
- array(1) {
- ["l3"]=>
- array(1) {
- ["l4"]=>
- string(1) "3"
- }
- }
-}
-array(1) {
- [0]=>
- string(3) "bye"
-}
-bool(true)
-bool(false)
-Done
<?php
_ext("http");
-function _ext($ext) {
+function _ext($ext) {
if (!extension_loaded($ext)) {
die("skip $ext extension needed\n");
}
}
function utf8locale() {
+ $locale = setlocale(LC_CTYPE, null);
+ if (stristr($locale, "utf") && substr($locale, -1) === "8") {
+ return true;
+ }
if (stristr(setlocale(LC_CTYPE, "C.UTF-8"), "utf")) {
return true;
}
}
function skip_curl_test($version) {
- if (!version_compare(http\Client\Curl\Versions\CURL, $version, "<=")) {
- die("need at least libcurl version $version\n");
+ if (!version_compare(http\Client\Curl\Versions\CURL, $version, ">=")) {
+ die("skip need at least libcurl version $version\n");
}
}
--FILE--
<?php
echo "Test\n";
-setlocale(LC_CTYPE, "C.UTF-8");
+include "skipif.inc";
+utf8locale();
$urls = array(
"s\xc3\xa7heme:",
--FILE--
<?php
echo "Test\n";
-setlocale(LC_CTYPE, "C.UTF-8");
+include "skipif.inc";
+utf8locale();
$urls = array(
"s\xc3\xa7heme:",
--FILE--
<?php
echo "Test\n";
-setlocale(LC_CTYPE, "C.UTF-8");
+include "skipif.inc";
+utf8locale();
$urls = array(
"http://mike:paßwort@𐌀𐌁𐌂.it/for/€/?by=¢#ø"
--FILE--
<?php
echo "Test\n";
-setlocale(LC_CTYPE, "C.UTF-8");
+include "skipif.inc";
+utf8locale();
$urls = array(
"http://mike:paßwort@𐌀𐌁𐌂.it/for/€/?by=¢#ø"
projects / m6w6 / ext-http / commitdiff
