if test `echo $CURL_VERSION | $SED -e 's/[[^0-9]]/ /g' | $AWK '{print $1*10000 + $2*100 + $3}'` -lt 71802; then
AC_MSG_ERROR([libcurl version greater or equal to 7.18.2 required])
fi
+
+ AC_MSG_CHECKING([for HTTP2 support in libcurl])
+ if $CURL_CONFIG --features | $EGREP -q HTTP2; then
+ AC_MSG_RESULT([yes])
+ AC_DEFINE([PHP_HTTP_HAVE_HTTP2], [1], [ ])
+ else
+ AC_MSG_RESULT([no])
+ fi
dnl
dnl compile tests
save_INCLUDES="$INCLUDES"
INCLUDES=
save_LIBS="$LIBS"
- LIBS=
+ LIBS=-lcurl
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS `$CURL_CONFIG --cflags`"
save_LDFLAGS="$LDFLAGS"
- LDFLAGS="$LDFLAGS `$CURL_CONFIG --libs` $ld_runpath_switch$CURL_DIR/$PHP_LIBDIR"
+ LDFLAGS="$ld_runpath_switch$CURL_DIR/$PHP_LIBDIR"
AC_MSG_CHECKING([for SSL support in libcurl])
CURL_SSL=`$CURL_CONFIG --feature | $EGREP SSL`
], [
AC_MSG_RESULT([no])
])
+
+ AC_MSG_CHECKING([whether CURLOPT_TLSAUTH_TYPE expects CURL_TLSAUTH_SRP or literal "SRP"])
+ AC_TRY_RUN([
+ #include <curl/curl.h>
+ int main(int argc, char *argv[]) {
+ CURL *ch = curl_easy_init();
+ return curl_easy_setopt(ch, CURLOPT_TLSAUTH_TYPE, CURL_TLSAUTH_SRP);
+ }
+ ], [
+ AC_MSG_RESULT([CURL_TLSAUTH_SRP])
+ AC_DEFINE([PHP_HTTP_CURL_TLSAUTH_SRP], [CURL_TLSAUTH_SRP], [ ])
+ AC_DEFINE([PHP_HTTP_CURL_TLSAUTH_DEF], [CURL_TLSAUTH_NONE], [ ])
+ ], [
+ AC_TRY_RUN([
+ #include <curl/curl.h>
+ int main(int argc, char *argv[]) {
+ CURL *ch = curl_easy_init();
+ return curl_easy_setopt(ch, CURLOPT_TLSAUTH_TYPE, "SRP");
+ }
+ ], [
+ AC_MSG_RESULT(["SRP"])
+ AC_DEFINE([PHP_HTTP_CURL_TLSAUTH_SRP], ["SRP"], [ ])
+ AC_DEFINE([PHP_HTTP_CURL_TLSAUTH_DEF], [""], [ ])
+ ], [
+ AC_MSG_RESULT([neither])
+ ], [
+ AC_MSG_RESULT([neither])
+ ])
+ ], [
+ AC_MSG_RESULT([neither])
+ ])
INCLUDES="$save_INCLUDES"
LIBS="$save_LIBS"
PHP_INSTALL_HEADERS(ext/http, $PHP_HTTP_HEADERS)
AC_DEFINE([HAVE_HTTP], [1], [Have extended HTTP support])
+ if $HTTP_HAVE_A_REQUEST_LIB; then
+ AC_DEFINE([PHP_HTTP_HAVE_CLIENT], [1], [Have HTTP client support])
+ fi
fi
#!/usr/bin/env php
<?php
-// $Id: gen_curlinfo.php 323304 2012-02-17 21:13:24Z mike $
error_reporting(0);
);
$exclude = array(
'PRIVATE', 'LASTSOCKET', 'FTP_ENTRY_PATH', 'CERTINFO', 'TLS_SESSION',
- 'RTSP_SESSION_ID', 'RTSP_CLIENT_CSEQ', 'RTSP_SERVER_CSEQ', 'RTSP_CSEQ_RECV'
+ 'RTSP_SESSION_ID', 'RTSP_CLIENT_CSEQ', 'RTSP_SERVER_CSEQ', 'RTSP_CSEQ_RECV',
+ 'COOKIELIST'
);
$translate = array(
$templates = array(
'STRING' =>
' if (CURLE_OK == curl_easy_getinfo(ch, %s, &c)) {
- add_assoc_string_ex(&array, "%s", sizeof("%2$s"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "%s", lenof("%2$s"), &tmp);
}
',
'DOUBLE' =>
' if (CURLE_OK == curl_easy_getinfo(ch, %s, &d)) {
- add_assoc_double_ex(&array, "%s", sizeof("%2$s"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "%s", lenof("%2$s"), &tmp);
}
',
'LONG' =>
' if (CURLE_OK == curl_easy_getinfo(ch, %s, &l)) {
- add_assoc_long_ex(&array, "%s", sizeof("%2$s"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "%s", lenof("%2$s"), &tmp);
}
',
'SLIST' =>
' if (CURLE_OK == curl_easy_getinfo(ch, %s, &s)) {
- MAKE_STD_ZVAL(subarray);
- array_init(subarray);
+ array_init(&tmp);
for (p = s; p; p = p->next) {
if (p->data) {
- add_next_index_string(subarray, p->data, 1);
+ add_next_index_string(&tmp, p->data);
}
}
- add_assoc_zval_ex(&array, "%s", sizeof("%2$s"), subarray);
+ zend_hash_str_update(info, "%s", lenof("%2$s"), &tmp);
curl_slist_free_all(s);
}
',
#include <php.h>
#include "php_http_buffer.h"
-PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_init_ex(php_http_buffer_t *buf, size_t chunk_size, int flags)
+PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_init_ex(
+ php_http_buffer_t *buf, size_t chunk_size, unsigned flags)
{
if (!buf) {
buf = pemalloc(sizeof(*buf), flags & PHP_HTTP_BUFFER_INIT_PERSISTENT);
if (buf) {
buf->size = (chunk_size) ? chunk_size : PHP_HTTP_BUFFER_DEFAULT_SIZE;
buf->pmem = (flags & PHP_HTTP_BUFFER_INIT_PERSISTENT) ? 1 : 0;
- buf->data = (flags & PHP_HTTP_BUFFER_INIT_PREALLOC) ? pemalloc(buf->size, buf->pmem) : NULL;
+ buf->data = (flags & PHP_HTTP_BUFFER_INIT_PREALLOC) ?
+ pemalloc(buf->size, buf->pmem) : NULL;
buf->free = (flags & PHP_HTTP_BUFFER_INIT_PREALLOC) ? buf->size : 0;
buf->used = 0;
}
return buf;
}
-PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_from_string_ex(php_http_buffer_t *buf, const char *string, size_t length)
+PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_from_string_ex(
+ php_http_buffer_t *buf, const char *str, size_t len)
{
if ((buf = php_http_buffer_init(buf))) {
- if (PHP_HTTP_BUFFER_NOMEM == php_http_buffer_append(buf, string, length)) {
+ if (PHP_HTTP_BUFFER_NOMEM == php_http_buffer_append(buf, str, len)) {
pefree(buf, buf->pmem);
buf = NULL;
}
return buf;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_resize_ex(php_http_buffer_t *buf, size_t len, size_t override_size, int allow_error)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_resize_ex(
+ php_http_buffer_t *buf, size_t len, size_t override_size,
+ zend_bool allow_error)
{
char *ptr = NULL;
#if 0
- fprintf(stderr, "RESIZE: len=%lu, size=%lu, used=%lu, free=%lu\n", len, buf->size, buf->used, buf->free);
+ fprintf(stderr, "RESIZE: len=%lu, size=%lu, used=%lu, free=%lu, total=%lu\n", len, buf->size, buf->used, buf->free, buf->free+buf->used);
#endif
if (buf->free < len) {
size_t size = override_size ? override_size : buf->size;
}
if (allow_error) {
- ptr = perealloc_recoverable(buf->data, buf->used + buf->free + size, buf->pmem);
+ ptr = perealloc_recoverable(buf->data,
+ buf->used + buf->free + size, buf->pmem);
} else {
ptr = perealloc(buf->data, buf->used + buf->free + size, buf->pmem);
}
return 0;
}
-PHP_HTTP_BUFFER_API char *php_http_buffer_account(php_http_buffer_t *buf, size_t to_account)
+PHP_HTTP_BUFFER_API char *php_http_buffer_account(
+ php_http_buffer_t *buf, size_t to_account)
{
- /* it's probably already too late but check anyway */
- if (to_account > buf->free) {
- return NULL;
- }
+ assert(to_account <= buf->free);
buf->free -= to_account;
buf->used += to_account;
return buf->used;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_append(php_http_buffer_t *buf, const char *append, size_t append_len)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_append(php_http_buffer_t *buf,
+ const char *append, size_t append_len)
{
- if (buf->free < append_len && PHP_HTTP_BUFFER_NOMEM == php_http_buffer_resize(buf, append_len)) {
+ if ( buf->free < append_len &&
+ PHP_HTTP_BUFFER_NOMEM == php_http_buffer_resize(buf, append_len)
+ ) {
return PHP_HTTP_BUFFER_NOMEM;
}
memcpy(buf->data + buf->used, append, append_len);
return append_len;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_appendf(php_http_buffer_t *buf, const char *format, ...)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_appendf(php_http_buffer_t *buf,
+ const char *format, ...)
{
va_list argv;
char *append;
return append_len;
}
-PHP_HTTP_BUFFER_API char *php_http_buffer_data(const php_http_buffer_t *buf, char **into, size_t *len)
+PHP_HTTP_BUFFER_API char *php_http_buffer_data(const php_http_buffer_t *buf,
+ char **into, size_t *len)
{
char *copy = ecalloc(1, buf->used + 1);
memcpy(copy, buf->data, buf->used);
return copy;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_cut(php_http_buffer_t *buf, size_t offset, size_t length)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_cut(php_http_buffer_t *buf,
+ size_t offset, size_t length)
{
if (offset > buf->used) {
return 0;
if (offset + length > buf->used) {
length = buf->used - offset;
}
- memmove(buf->data + offset, buf->data + offset + length, buf->used - length - offset);
+ memmove(buf->data + offset, buf->data + offset + length,
+ buf->used - length - offset);
buf->used -= length;
buf->free += length;
return length;
}
-PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_fix(php_http_buffer_t *buf)
+PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_fix(
+ php_http_buffer_t *buf)
{
- if (buf->free < 1 && PHP_HTTP_BUFFER_NOMEM == php_http_buffer_resize_ex(buf, 1, 1, 0)) {
+ if ( buf->free < 1 &&
+ PHP_HTTP_BUFFER_NOMEM == php_http_buffer_resize_ex(buf, 1, 1, 0)
+ ) {
return NULL;
}
buf->data[buf->used] = '\0';
}
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_chunk_buffer(php_http_buffer_t **s, const char *data, size_t data_len, char **chunk, size_t chunk_size)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_chunk_buffer(php_http_buffer_t **s,
+ const char *data, size_t data_len, char **chunk, size_t chunk_size)
{
php_http_buffer_t *storage;
*chunk = NULL;
if (!*s) {
- *s = php_http_buffer_init_ex(NULL, chunk_size << 1, chunk_size ? PHP_HTTP_BUFFER_INIT_PREALLOC : 0);
+ *s = php_http_buffer_init_ex(NULL, chunk_size << 1,
+ chunk_size ? PHP_HTTP_BUFFER_INIT_PREALLOC : 0);
}
storage = *s;
return 0;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_chunked_output(php_http_buffer_t **s, const char *data, size_t data_len, size_t chunk_len, php_http_buffer_pass_func_t passout, void *opaque TSRMLS_DC)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_chunked_output(php_http_buffer_t **s,
+ const char *data, size_t data_len, size_t chunk_len,
+ php_http_buffer_pass_func_t passout, void *opaque)
{
char *chunk = NULL;
size_t passed = 0, got = 0;
while ((got = php_http_buffer_chunk_buffer(s, data, data_len, &chunk, chunk_len))) {
- if (PHP_HTTP_BUFFER_PASS0 == passout(opaque, chunk, got TSRMLS_CC)) {
+ if (PHP_HTTP_BUFFER_PASS0 == passout(opaque, chunk, got)) {
PTR_SET(chunk, NULL);
return PHP_HTTP_BUFFER_PASS0;
}
return passed;
}
-PHP_HTTP_BUFFER_API ssize_t php_http_buffer_passthru(php_http_buffer_t **s, size_t chunk_size, php_http_buffer_pass_func_t passin, void *passin_arg, php_http_buffer_pass_func_t passon, void *passon_arg TSRMLS_DC)
+PHP_HTTP_BUFFER_API ssize_t php_http_buffer_passthru(php_http_buffer_t **s, size_t chunk_size,
+ php_http_buffer_pass_func_t passin, void *passin_arg,
+ php_http_buffer_pass_func_t passon, void *passon_arg)
{
- size_t passed_on = 0, passed_in = php_http_buffer_chunked_input(s, chunk_size, passin, passin_arg TSRMLS_CC);
+ size_t passed_on = 0, passed_in;
+
+ passed_in = php_http_buffer_chunked_input(s, chunk_size, passin, passin_arg);
if (passed_in == PHP_HTTP_BUFFER_PASS0) {
return passed_in;
}
if (passed_in || (*s)->used) {
- passed_on = passon(passon_arg, (*s)->data, (*s)->used TSRMLS_CC);
+ passed_on = passon(passon_arg, (*s)->data, (*s)->used);
if (passed_on == PHP_HTTP_BUFFER_PASS0) {
return passed_on;
return passed_on - passed_in;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_chunked_input(php_http_buffer_t **s, size_t chunk_size, php_http_buffer_pass_func_t passin, void *opaque TSRMLS_DC)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_chunked_input(php_http_buffer_t **s,
+ size_t chunk_size, php_http_buffer_pass_func_t passin, void *opaque)
{
php_http_buffer_t *str;
size_t passed;
if (!*s) {
- *s = php_http_buffer_init_ex(NULL, chunk_size, chunk_size ? PHP_HTTP_BUFFER_INIT_PREALLOC : 0);
+ *s = php_http_buffer_init_ex(NULL, chunk_size,
+ chunk_size ? PHP_HTTP_BUFFER_INIT_PREALLOC : 0);
}
str = *s;
php_http_buffer_resize(str, chunk_size);
- passed = passin(opaque, str->data + str->used, chunk_size TSRMLS_CC);
+ passed = passin(opaque, str->data + str->used, chunk_size);
if (passed != PHP_HTTP_BUFFER_PASS0) {
str->used += passed;
#ifdef PHP_HTTP_BUFFER_EXTENDED
-PHP_HTTP_BUFFER_API int php_http_buffer_cmp(php_http_buffer_t *left, php_http_buffer_t *right)
+PHP_HTTP_BUFFER_API int php_http_buffer_cmp(php_http_buffer_t *left,
+ php_http_buffer_t *right)
{
if (left->used > right->used) {
return -1;
}
}
-PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_copy(const php_http_buffer_t *from, php_http_buffer_t *to)
+PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_copy(
+ const php_http_buffer_t *from, php_http_buffer_t *to)
{
int free_to = !to;
return to;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_insert(php_http_buffer_t *buf, const char *insert, size_t insert_len, size_t offset)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_insert(php_http_buffer_t *buf,
+ const char *insert, size_t insert_len, size_t offset)
{
if (PHP_HTTP_BUFFER_NOMEM == php_http_buffer_resize(buf, insert_len)) {
return PHP_HTTP_BUFFER_NOMEM;
return insert_len;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_insertf(php_http_buffer_t *buf, size_t offset, const char *format, ...)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_insertf(php_http_buffer_t *buf,
+ size_t offset, const char *format, ...)
{
va_list argv;
char *insert;
return insert_len;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_prepend(php_http_buffer_t *buf, const char *prepend, size_t prepend_len)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_prepend(php_http_buffer_t *buf,
+ const char *prepend, size_t prepend_len)
{
if (PHP_HTTP_BUFFER_NOMEM == php_http_buffer_resize(buf, prepend_len)) {
return PHP_HTTP_BUFFER_NOMEM;
return prepend_len;
}
-PHP_HTTP_BUFFER_API size_t php_http_buffer_prependf(php_http_buffer_t *buf, const char *format, ...)
+PHP_HTTP_BUFFER_API size_t php_http_buffer_prependf(php_http_buffer_t *buf,
+ const char *format, ...)
{
va_list argv;
char *prepend;
return prepend_len;
}
-PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_sub(const php_http_buffer_t *buf, size_t offset, size_t length)
+PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_sub(
+ const php_http_buffer_t *buf, size_t offset, size_t length)
{
if (offset >= buf->used) {
return NULL;
} else {
- size_t need = 1 + ((length + offset) > buf->used ? (buf->used - offset) : (length - offset));
- php_http_buffer_t *sub = php_http_buffer_init_ex(NULL, need, PHP_HTTP_BUFFER_INIT_PREALLOC | (buf->pmem ? PHP_HTTP_BUFFER_INIT_PERSISTENT:0));
+ php_http_buffer_t *sub;
+ size_t need = 1 + ((length + offset) > buf->used ?
+ (buf->used - offset) : (length - offset));
+ unsigned flags = buf->pmem ? PHP_HTTP_BUFFER_INIT_PERSISTENT : 0;
+
+ sub = php_http_buffer_init_ex(NULL, need,
+ PHP_HTTP_BUFFER_INIT_PREALLOC | flags);
+
if (sub) {
if (PHP_HTTP_BUFFER_NOMEM == php_http_buffer_append(sub, buf->data + offset, need)) {
php_http_buffer_free(&sub);
}
}
-PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_right(const php_http_buffer_t *buf, size_t length)
+PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_right(
+ const php_http_buffer_t *buf, size_t length)
{
if (length < buf->used) {
return php_http_buffer_sub(buf, buf->used - length, length);
}
-PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_merge_va(php_http_buffer_t *buf, unsigned argc, va_list argv)
+PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_merge_va(
+ php_http_buffer_t *buf, unsigned argc, va_list argv)
{
unsigned i = 0;
buf = php_http_buffer_init(buf);
return buf;
}
-PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_merge_ex(php_http_buffer_t *buf, unsigned argc, ...)
+PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_merge_ex(
+ php_http_buffer_t *buf, unsigned argc, ...)
{
va_list argv;
php_http_buffer_t *ret;
*/
static HashTable php_http_client_drivers;
-STATUS php_http_client_driver_add(php_http_client_driver_t *driver)
+static void php_http_client_driver_hash_dtor(zval *pData)
{
- return zend_hash_add(&php_http_client_drivers, driver->name_str, driver->name_len + 1, (void *) driver, sizeof(php_http_client_driver_t), NULL);
+ pefree(Z_PTR_P(pData), 1);
}
-STATUS php_http_client_driver_get(const char *name_str, size_t name_len, php_http_client_driver_t *driver)
+ZEND_RESULT_CODE php_http_client_driver_add(php_http_client_driver_t *driver)
{
+ return zend_hash_add_mem(&php_http_client_drivers, driver->driver_name, (void *) driver, sizeof(php_http_client_driver_t))
+ ? SUCCESS : FAILURE;
+}
+
+php_http_client_driver_t *php_http_client_driver_get(zend_string *name)
+{
+ zval *ztmp;
php_http_client_driver_t *tmp;
- if ((name_str && SUCCESS == zend_hash_find(&php_http_client_drivers, name_str, name_len + 1, (void *) &tmp))
- || (SUCCESS == zend_hash_get_current_data(&php_http_client_drivers, (void *) &tmp))) {
- *driver = *tmp;
- return SUCCESS;
+ if (name && (tmp = zend_hash_find_ptr(&php_http_client_drivers, name))) {
+ return tmp;
}
- return FAILURE;
+ if ((ztmp = zend_hash_get_current_data(&php_http_client_drivers))) {
+ return Z_PTR_P(ztmp);
+ }
+ return NULL;
}
-static int apply_driver_list(void *p, void *arg TSRMLS_DC)
+static int apply_driver_list(zval *p, void *arg)
{
- php_http_client_driver_t *d = p;
- zval *zname;
+ php_http_client_driver_t *d = Z_PTR_P(p);
+ zval zname;
- MAKE_STD_ZVAL(zname);
- ZVAL_STRINGL(zname, d->name_str, d->name_len, 1);
+ ZVAL_STR(&zname, d->driver_name);
- zend_hash_next_index_insert(arg, &zname, sizeof(zval *), NULL);
+ zend_hash_next_index_insert(arg, &zname);
return ZEND_HASH_APPLY_KEEP;
}
-void php_http_client_driver_list(HashTable *ht TSRMLS_DC)
+void php_http_client_driver_list(HashTable *ht)
{
- zend_hash_apply_with_argument(&php_http_client_drivers, apply_driver_list, ht TSRMLS_CC);
+ zend_hash_apply_with_argument(&php_http_client_drivers, apply_driver_list, ht);
}
-void php_http_client_options_set_subr(zval *this_ptr, char *key, size_t len, zval *opts, int overwrite TSRMLS_DC)
+void php_http_client_options_set_subr(zval *instance, char *key, size_t len, zval *opts, int overwrite)
{
if (overwrite || (opts && zend_hash_num_elements(Z_ARRVAL_P(opts)))) {
- zend_class_entry *this_ce = Z_OBJCE_P(getThis());
- zval *old_opts, *new_opts, **entry = NULL;
+ zend_class_entry *this_ce = Z_OBJCE_P(instance);
+ zval old_opts_tmp, *old_opts, new_opts, *entry = NULL;
- MAKE_STD_ZVAL(new_opts);
- array_init(new_opts);
- old_opts = zend_read_property(this_ce, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
+ array_init(&new_opts);
+ old_opts = zend_read_property(this_ce, 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_P(new_opts));
+ array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL(new_opts));
}
if (overwrite) {
if (opts && zend_hash_num_elements(Z_ARRVAL_P(opts))) {
Z_ADDREF_P(opts);
- zend_symtable_update(Z_ARRVAL_P(new_opts), key, len, (void *) &opts, sizeof(zval *), NULL);
+ zend_symtable_str_update(Z_ARRVAL(new_opts), key, len, opts);
} else {
- zend_symtable_del(Z_ARRVAL_P(new_opts), key, len);
+ zend_symtable_str_del(Z_ARRVAL(new_opts), key, len);
}
} else if (opts && zend_hash_num_elements(Z_ARRVAL_P(opts))) {
- if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(new_opts), key, len, (void *) &entry)) {
- array_join(Z_ARRVAL_P(opts), Z_ARRVAL_PP(entry), 0, 0);
+ if ((entry = zend_symtable_str_find(Z_ARRVAL(new_opts), key, len))) {
+ array_join(Z_ARRVAL_P(opts), Z_ARRVAL_P(entry), 0, 0);
} else {
Z_ADDREF_P(opts);
- zend_symtable_update(Z_ARRVAL_P(new_opts), key, len, (void *) &opts, sizeof(zval *), NULL);
+ zend_symtable_str_update(Z_ARRVAL(new_opts), key, len, opts);
}
}
- zend_update_property(this_ce, getThis(), ZEND_STRL("options"), new_opts TSRMLS_CC);
+ zend_update_property(this_ce, instance, ZEND_STRL("options"), &new_opts);
zval_ptr_dtor(&new_opts);
}
}
-void php_http_client_options_set(zval *this_ptr, zval *opts TSRMLS_DC)
+void php_http_client_options_set(zval *instance, zval *opts)
{
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
- HashPosition pos;
- zval *new_opts;
- zend_class_entry *this_ce = Z_OBJCE_P(getThis());
- zend_bool is_client = instanceof_function(this_ce, php_http_client_class_entry TSRMLS_CC);
+ php_http_arrkey_t key;
+ zval new_opts;
+ zend_class_entry *this_ce = Z_OBJCE_P(instance);
+ zend_bool is_client = instanceof_function(this_ce, php_http_client_class_entry);
- MAKE_STD_ZVAL(new_opts);
- array_init(new_opts);
+ array_init(&new_opts);
if (!opts || !zend_hash_num_elements(Z_ARRVAL_P(opts))) {
- zend_update_property(this_ce, getThis(), ZEND_STRL("options"), new_opts TSRMLS_CC);
+ zend_update_property(this_ce, instance, ZEND_STRL("options"), &new_opts);
zval_ptr_dtor(&new_opts);
} else {
- zval *old_opts, *add_opts, **opt;
+ zval old_opts_tmp, *old_opts, add_opts, *opt;
- MAKE_STD_ZVAL(add_opts);
- array_init(add_opts);
+ array_init(&add_opts);
/* some options need extra attention -- thus cannot use array_merge() directly */
- FOREACH_KEYVAL(pos, opts, key, opt) {
- if (key.type == HASH_KEY_IS_STRING) {
-#define KEYMATCH(k, s) ((sizeof(s)==k.len) && !strcasecmp(k.str, s))
- if (Z_TYPE_PP(opt) == IS_ARRAY && (KEYMATCH(key, "ssl") || KEYMATCH(key, "cookies"))) {
- php_http_client_options_set_subr(getThis(), key.str, key.len, *opt, 0 TSRMLS_CC);
- } else if (is_client && (KEYMATCH(key, "recordHistory") || KEYMATCH(key, "responseMessageClass"))) {
- zend_update_property(this_ce, getThis(), key.str, key.len-1, *opt TSRMLS_CC);
- } else if (Z_TYPE_PP(opt) == IS_NULL) {
- old_opts = zend_read_property(this_ce, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
+ ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(opts), key.h, key.key, opt)
+ {
+ if (key.key) {
+ 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);
+ } else if (Z_TYPE_P(opt) == IS_NULL) {
+ old_opts = zend_read_property(this_ce, 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.str, key.len);
+ zend_symtable_del(Z_ARRVAL_P(old_opts), key.key);
}
} else {
- Z_ADDREF_P(*opt);
- add_assoc_zval_ex(add_opts, key.str, key.len, *opt);
+ Z_TRY_ADDREF_P(opt);
+ add_assoc_zval_ex(&add_opts, key.key->val, key.key->len, opt);
}
}
}
+ ZEND_HASH_FOREACH_END();
- old_opts = zend_read_property(this_ce, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
+ old_opts = zend_read_property(this_ce, 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_P(new_opts));
+ array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL(new_opts));
}
- array_join(Z_ARRVAL_P(add_opts), Z_ARRVAL_P(new_opts), 0, 0);
- zend_update_property(this_ce, getThis(), ZEND_STRL("options"), new_opts TSRMLS_CC);
+ array_join(Z_ARRVAL(add_opts), Z_ARRVAL(new_opts), 0, 0);
+ zend_update_property(this_ce, instance, ZEND_STRL("options"), &new_opts);
zval_ptr_dtor(&new_opts);
zval_ptr_dtor(&add_opts);
}
}
-void php_http_client_options_get_subr(zval *this_ptr, char *key, size_t len, zval *return_value TSRMLS_DC)
+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(getThis());
- zval **options, *opts = zend_read_property(this_ce, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
+ 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);
- if ((Z_TYPE_P(opts) == IS_ARRAY) && (SUCCESS == zend_symtable_find(Z_ARRVAL_P(opts), key, len, (void *) &options))) {
- RETVAL_ZVAL(*options, 1, 0);
+ if ((Z_TYPE_P(opts) == IS_ARRAY) && (options = zend_symtable_str_find(Z_ARRVAL_P(opts), key, len))) {
+ RETVAL_ZVAL_FAST(options);
}
}
}
}
-php_http_client_t *php_http_client_init(php_http_client_t *h, php_http_client_ops_t *ops, php_resource_factory_t *rf, void *init_arg TSRMLS_DC)
+php_http_client_t *php_http_client_init(php_http_client_t *h, php_http_client_ops_t *ops, php_resource_factory_t *rf, void *init_arg)
{
php_http_client_t *free_h = NULL;
}
zend_llist_init(&h->requests, sizeof(php_http_client_enqueue_t), queue_dtor, 0);
zend_llist_init(&h->responses, sizeof(void *), NULL, 0);
- TSRMLS_SET_CTX(h->ts);
if (h->ops->init) {
if (!(h = h->ops->init(h, init_arg))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not initialize client");
- if (free_h) {
- efree(free_h);
- }
+ php_error_docref(NULL, E_WARNING, "Could not initialize client");
+ PTR_FREE(free_h);
}
}
}
}
-STATUS php_http_client_enqueue(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
+ZEND_RESULT_CODE php_http_client_enqueue(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
{
- TSRMLS_FETCH_FROM_CTX(h->ts);
-
if (h->ops->enqueue) {
if (php_http_client_enqueued(h, enqueue->request, NULL)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to enqueue request; request already in queue");
+ php_error_docref(NULL, E_WARNING, "Failed to enqueue request; request already in queue");
return FAILURE;
}
return h->ops->enqueue(h, enqueue);
return FAILURE;
}
-STATUS php_http_client_dequeue(php_http_client_t *h, php_http_message_t *request)
+ZEND_RESULT_CODE php_http_client_dequeue(php_http_client_t *h, php_http_message_t *request)
{
- TSRMLS_FETCH_FROM_CTX(h->ts);
-
if (h->ops->dequeue) {
php_http_client_enqueue_t *enqueue = php_http_client_enqueued(h, request, NULL);
if (!enqueue) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to dequeue request; request not in queue");
+ php_error_docref(NULL, E_WARNING, "Failed to dequeue request; request not in queue");
return FAILURE;
}
return h->ops->dequeue(h, enqueue);
return el ? (php_http_client_enqueue_t *) el->data : NULL;
}
-STATUS php_http_client_wait(php_http_client_t *h, struct timeval *custom_timeout)
+ZEND_RESULT_CODE php_http_client_wait(php_http_client_t *h, struct timeval *custom_timeout)
{
if (h->ops->wait) {
return h->ops->wait(h, custom_timeout);
return FAILURE;
}
-STATUS php_http_client_exec(php_http_client_t *h)
+ZEND_RESULT_CODE php_http_client_exec(php_http_client_t *h)
{
if (h->ops->exec) {
return h->ops->exec(h);
zend_llist_clean(&h->responses);
}
-STATUS php_http_client_setopt(php_http_client_t *h, php_http_client_setopt_opt_t opt, void *arg)
+ZEND_RESULT_CODE php_http_client_setopt(php_http_client_t *h, php_http_client_setopt_opt_t opt, void *arg)
{
if (h->ops->setopt) {
return h->ops->setopt(h, opt, arg);
return FAILURE;
}
-STATUS php_http_client_getopt(php_http_client_t *h, php_http_client_getopt_opt_t opt, void *arg, void *res_ptr)
+ZEND_RESULT_CODE php_http_client_getopt(php_http_client_t *h, php_http_client_getopt_opt_t opt, void *arg, void *res_ptr)
{
if (h->ops->getopt) {
return h->ops->getopt(h, opt, arg, res_ptr);
zend_class_entry *php_http_client_class_entry;
static zend_object_handlers php_http_client_object_handlers;
-void php_http_client_object_free(void *object TSRMLS_DC)
+void php_http_client_object_free(zend_object *object)
{
- php_http_client_object_t *o = (php_http_client_object_t *) object;
+ php_http_client_object_t *o = PHP_HTTP_OBJ(object, NULL);
php_http_client_free(&o->client);
- zend_object_std_dtor((zend_object *) o TSRMLS_CC);
- efree(o);
+ php_http_object_method_dtor(&o->notify);
+ php_http_object_method_free(&o->update);
+ zend_object_std_dtor(object);
}
-zend_object_value php_http_client_object_new_ex(zend_class_entry *ce, php_http_client_t *client, php_http_client_object_t **ptr TSRMLS_DC)
+php_http_client_object_t *php_http_client_object_new_ex(zend_class_entry *ce, php_http_client_t *client)
{
php_http_client_object_t *o;
- o = ecalloc(1, sizeof(php_http_client_object_t) + (ce->default_properties_count - 1) * sizeof(zval));
- o = ecalloc(1, sizeof(php_http_client_object_t));
- zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
- object_properties_init((zend_object *) o, ce);
++ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+ zend_object_std_init(&o->zo, ce);
+ object_properties_init(&o->zo, ce);
o->client = client;
- if (ptr) {
- *ptr = o;
- }
-
- o->zv.handle = zend_objects_store_put(o, NULL, php_http_client_object_free, NULL TSRMLS_CC);
- o->zv.handlers = &php_http_client_object_handlers;
+ o->zo.handlers = &php_http_client_object_handlers;
- return o->zv;
+ return o;
}
-zend_object_value php_http_client_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *php_http_client_object_new(zend_class_entry *ce)
{
- return php_http_client_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+ return &php_http_client_object_new_ex(ce, NULL)->zo;
}
-static void handle_history(zval *zclient, php_http_message_t *request, php_http_message_t *response TSRMLS_DC)
+static void handle_history(zval *zclient, php_http_message_t *request, php_http_message_t *response)
{
- zval *new_hist, *old_hist = zend_read_property(php_http_client_class_entry, zclient, ZEND_STRL("history"), 0 TSRMLS_CC);
- php_http_message_t *zipped = php_http_message_zip(response, request);
- zend_object_value ov = php_http_message_object_new_ex(php_http_message_class_entry, zipped, NULL TSRMLS_CC);
+ zval new_hist, old_hist_tmp, *old_hist = zend_read_property(php_http_client_class_entry, 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_t *obj = php_http_message_object_new_ex(php_http_message_class_entry, zipped);
- MAKE_STD_ZVAL(new_hist);
- ZVAL_OBJVAL(new_hist, ov, 0);
+ ZVAL_OBJ(&new_hist, &obj->zo);
if (Z_TYPE_P(old_hist) == IS_OBJECT) {
- php_http_message_object_prepend(new_hist, old_hist, 1 TSRMLS_CC);
+ php_http_message_object_prepend(&new_hist, old_hist, 1);
}
- zend_update_property(php_http_client_class_entry, zclient, ZEND_STRL("history"), new_hist TSRMLS_CC);
+ zend_update_property(php_http_client_class_entry, zclient, ZEND_STRL("history"), &new_hist);
zval_ptr_dtor(&new_hist);
}
- static ZEND_RESULT_CODE handle_response(void *arg, php_http_client_t *client, php_http_client_enqueue_t *e, php_http_message_t **request, php_http_message_t **response)
-static STATUS handle_response(void *arg, php_http_client_t *client, php_http_client_enqueue_t *e, php_http_message_t **response)
++static ZEND_RESULT_CODE handle_response(void *arg, php_http_client_t *client, php_http_client_enqueue_t *e, php_http_message_t **response)
{
zend_bool dequeue = 0;
zval zclient;
php_http_message_t *msg;
php_http_client_progress_state_t *progress;
- TSRMLS_FETCH_FROM_CTX(client->ts);
- INIT_PZVAL(&zclient);
- ZVAL_OBJVAL(&zclient, ((php_http_client_object_t*) arg)->zv, 0);
+ ZVAL_OBJ(&zclient, &((php_http_client_object_t*) arg)->zo);
if ((msg = *response)) {
php_http_message_object_t *msg_obj;
- zval *info, *zresponse, *zrequest;
+ zval info, zresponse, zrequest, rec_hist_tmp;
HashTable *info_ht;
/* 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 (z_is_true(zend_read_property(php_http_client_class_entry, &zclient, ZEND_STRL("recordHistory"), 0 TSRMLS_CC))) {
- handle_history(&zclient, e->request, *response TSRMLS_CC);
+ if (zend_is_true(zend_read_property(php_http_client_class_entry, &zclient, ZEND_STRL("recordHistory"), 0, &rec_hist_tmp))) {
- handle_history(&zclient, *request, *response);
++ handle_history(&zclient, e->request, *response);
}
/* hard detach, redirects etc. are in the history */
php_http_message_free(&msg->parent);
*response = NULL;
- MAKE_STD_ZVAL(zresponse);
- ZVAL_OBJVAL(zresponse, php_http_message_object_new_ex(php_http_client_response_class_entry, msg, &msg_obj TSRMLS_CC), 0);
-
- MAKE_STD_ZVAL(zrequest);
- ZVAL_OBJVAL(zrequest, ((php_http_message_object_t *) e->opaque)->zv, 1);
+ msg_obj = php_http_message_object_new_ex(php_http_client_response_class_entry, msg);
+ ZVAL_OBJ(&zresponse, &msg_obj->zo);
+ ZVAL_OBJECT(&zrequest, &((php_http_message_object_t *) e->opaque)->zo, 1);
- php_http_message_object_prepend(zresponse, zrequest, 1 TSRMLS_CC);
+ php_http_message_object_prepend(&zresponse, &zrequest, 1);
- MAKE_STD_ZVAL(info);
- object_init(info);
- info_ht = HASH_OF(info);
+ 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_client_response_class_entry, zresponse, ZEND_STRL("transferInfo"), info TSRMLS_CC);
+ zend_update_property(php_http_client_response_class_entry, &zresponse, ZEND_STRL("transferInfo"), &info);
zval_ptr_dtor(&info);
- zend_objects_store_add_ref_by_handle(msg_obj->zv.handle TSRMLS_CC);
+ Z_ADDREF(zresponse);
zend_llist_add_element(&client->responses, &msg_obj);
if (e->closure.fci.size) {
- zval *retval = NULL;
+ zval retval;
zend_error_handling zeh;
- zend_fcall_info_argn(&e->closure.fci TSRMLS_CC, 1, &zresponse);
- zend_replace_error_handling(EH_NORMAL, NULL, &zeh TSRMLS_CC);
- zend_fcall_info_call(&e->closure.fci, &e->closure.fcc, &retval, NULL TSRMLS_CC);
- zend_restore_error_handling(&zeh TSRMLS_CC);
- zend_fcall_info_argn(&e->closure.fci TSRMLS_CC, 0);
+ ZVAL_UNDEF(&retval);
+ zend_fcall_info_argn(&e->closure.fci, 1, &zresponse);
+ zend_replace_error_handling(EH_NORMAL, NULL, &zeh);
+ zend_fcall_info_call(&e->closure.fci, &e->closure.fcc, &retval, NULL);
+ zend_restore_error_handling(&zeh);
+ zend_fcall_info_argn(&e->closure.fci, 0);
- if (retval) {
- if (Z_TYPE_P(retval) == IS_BOOL) {
- dequeue = Z_BVAL_P(retval);
- }
- zval_ptr_dtor(&retval);
+ if (Z_TYPE(retval) == IS_TRUE) {
+ dequeue = 1;
}
+ zval_ptr_dtor(&retval);
}
zval_ptr_dtor(&zresponse);
static void handle_progress(void *arg, php_http_client_t *client, php_http_client_enqueue_t *e, php_http_client_progress_state_t *progress)
{
- zval zrequest, zprogress, retval, zclient;
- zval *zrequest, *zprogress, *zclient, **args[2];
++ zval zclient, args[2];
+ php_http_client_object_t *client_obj = arg;
zend_error_handling zeh;
- TSRMLS_FETCH_FROM_CTX(client->ts);
-
- MAKE_STD_ZVAL(zclient);
- ZVAL_OBJVAL(zclient, client_obj->zv, 1);
-
- MAKE_STD_ZVAL(zrequest);
- ZVAL_OBJVAL(zrequest, ((php_http_message_object_t *) e->opaque)->zv, 1);
- args[0] = &zrequest;
-
- MAKE_STD_ZVAL(zprogress);
- object_init(zprogress);
- add_property_bool(zprogress, "started", progress->started);
- add_property_bool(zprogress, "finished", progress->finished);
- add_property_string(zprogress, "info", STR_PTR(progress->info), 1);
- add_property_double(zprogress, "dltotal", progress->dl.total);
- add_property_double(zprogress, "dlnow", progress->dl.now);
- add_property_double(zprogress, "ultotal", progress->ul.total);
- add_property_double(zprogress, "ulnow", progress->ul.now);
- args[1] = &zprogress;
-
- zend_replace_error_handling(EH_NORMAL, NULL, &zeh TSRMLS_CC);
- php_http_object_method_call(&client_obj->notify, zclient, NULL, 2, args TSRMLS_CC);
- zend_restore_error_handling(&zeh TSRMLS_CC);
+
- ZVAL_UNDEF(&retval);
- ZVAL_OBJECT(&zclient, &((php_http_client_object_t *) arg)->zo, 1);
- ZVAL_OBJECT(&zrequest, &((php_http_message_object_t *) e->opaque)->zo, 1);
- object_init(&zprogress);
- add_property_bool(&zprogress, "started", progress->started);
- add_property_bool(&zprogress, "finished", progress->finished);
- add_property_string(&zprogress, "info", STR_PTR(progress->info));
- add_property_double(&zprogress, "dltotal", progress->dl.total);
- add_property_double(&zprogress, "dlnow", progress->dl.now);
- add_property_double(&zprogress, "ultotal", progress->ul.total);
- add_property_double(&zprogress, "ulnow", progress->ul.now);
++ ZVAL_OBJECT(&zclient, &client_obj->zo, 1);
++ ZVAL_OBJECT(&args[0], &((php_http_message_object_t *) e->opaque)->zo, 1);
++ object_init(&args[1]);
++ add_property_bool(&args[1], "started", progress->started);
++ add_property_bool(&args[1], "finished", progress->finished);
++ add_property_string(&args[1], "info", STR_PTR(progress->info));
++ add_property_double(&args[1], "dltotal", progress->dl.total);
++ add_property_double(&args[1], "dlnow", progress->dl.now);
++ add_property_double(&args[1], "ultotal", progress->ul.total);
++ add_property_double(&args[1], "ulnow", progress->ul.now);
++
+ zend_replace_error_handling(EH_NORMAL, NULL, &zeh);
- zend_call_method_with_2_params(&zclient, NULL, NULL, "notify", &retval, &zrequest, &zprogress);
++ php_http_object_method_call(&client_obj->notify, &zclient, NULL, 2, args);
+ zend_restore_error_handling(&zeh);
+
zval_ptr_dtor(&zclient);
-- zval_ptr_dtor(&zrequest);
-- zval_ptr_dtor(&zprogress);
- zval_ptr_dtor(&retval);
++ zval_ptr_dtor(&args[0]);
++ zval_ptr_dtor(&args[1]);
}
static void response_dtor(void *data)
{
php_http_message_object_t *msg_obj = *(php_http_message_object_t **) data;
- TSRMLS_FETCH_FROM_CTX(msg_obj->message->ts);
- zend_objects_store_del_ref_by_handle_ex(msg_obj->zv.handle, msg_obj->zv.handlers TSRMLS_CC);
+ zend_objects_store_del(&msg_obj->zo);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_construct, 0, 0, 0)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpClient, __construct)
{
- char *driver_str = NULL, *persistent_handle_str = NULL;
- int driver_len = 0, persistent_handle_len = 0;
- php_http_client_driver_t driver;
+ zend_string *driver_name = NULL, *persistent_handle_name = NULL;
+ php_http_client_driver_t *driver;
php_resource_factory_t *rf = NULL;
php_http_client_object_t *obj;
- zval *os;
+ zval os;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ss", &driver_str, &driver_len, &persistent_handle_str, &persistent_handle_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|S!S!", &driver_name, &persistent_handle_name), invalid_arg, return);
- if (SUCCESS != php_http_client_driver_get(driver_str, driver_len, &driver)) {
- php_http_throw(unexpected_val, "Failed to locate \"%s\" client request handler", driver_str);
+ if (!zend_hash_num_elements(&php_http_client_drivers)) {
+ php_http_throw(unexpected_val, "No http\\Client drivers available", NULL);
+ return;
+ }
+ if (!(driver = php_http_client_driver_get(driver_name))) {
+ php_http_throw(unexpected_val, "Failed to locate \"%s\" client request handler", driver_name ? driver_name->val : "default");
return;
}
- MAKE_STD_ZVAL(os);
- object_init_ex(os, spl_ce_SplObjectStorage);
- zend_update_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), os TSRMLS_CC);
+ object_init_ex(&os, spl_ce_SplObjectStorage);
+ zend_update_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), &os);
zval_ptr_dtor(&os);
- if (persistent_handle_len) {
- char *name_str;
- size_t name_len;
+ if (persistent_handle_name) {
php_persistent_handle_factory_t *pf;
- name_len = spprintf(&name_str, 0, "http\\Client\\%s", driver.name_str);
- php_http_pretty_key(name_str + sizeof("http\\Client"), driver.name_len, 1, 1);
-
- if ((pf = php_persistent_handle_concede(NULL , name_str, name_len, persistent_handle_str, persistent_handle_len, NULL, NULL TSRMLS_CC))) {
+ if ((pf = php_persistent_handle_concede(NULL, driver->client_name, persistent_handle_name, NULL, NULL))) {
rf = php_resource_factory_init(NULL, php_persistent_handle_get_resource_factory_ops(), pf, (void (*)(void *)) php_persistent_handle_abandon);
}
-
- efree(name_str);
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
- php_http_expect(obj->client = php_http_client_init(NULL, driver.client_ops, rf, NULL TSRMLS_CC), runtime, return);
+ php_http_expect(obj->client = php_http_client_init(NULL, driver->client_ops, rf, NULL), runtime, return);
- php_http_object_method_init(&obj->notify, getThis(), ZEND_STRL("notify") TSRMLS_CC);
++ php_http_object_method_init(&obj->notify, getThis(), ZEND_STRL("notify"));
+
obj->client->callback.response.func = handle_response;
obj->client->callback.response.arg = obj;
obj->client->callback.progress.func = handle_progress;
php_http_client_object_t *obj;
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
obj->iterator = 0;
php_http_client_reset(obj->client);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
-static HashTable *combined_options(zval *client, zval *request TSRMLS_DC)
+static HashTable *combined_options(zval *client, zval *request)
{
HashTable *options;
- int num_options = 0;
- zval *z_roptions = NULL, *z_coptions = zend_read_property(php_http_client_class_entry, client, ZEND_STRL("options"), 0 TSRMLS_CC);
+ 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);
if (Z_TYPE_P(z_coptions) == IS_ARRAY) {
num_options = zend_hash_num_elements(Z_ARRVAL_P(z_coptions));
}
- zend_call_method_with_0_params(&request, NULL, NULL, "getOptions", &z_roptions);
- if (z_roptions && Z_TYPE_P(z_roptions) == IS_ARRAY) {
- int num = zend_hash_num_elements(Z_ARRVAL_P(z_roptions));
+ ZVAL_UNDEF(&z_roptions);
+ zend_call_method_with_0_params(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) {
num_options = num;
}
if (Z_TYPE_P(z_coptions) == IS_ARRAY) {
array_copy(Z_ARRVAL_P(z_coptions), options);
}
- if (z_roptions) {
- if (Z_TYPE_P(z_roptions) == IS_ARRAY) {
- array_join(Z_ARRVAL_P(z_roptions), options, 0, 0);
- }
- zval_ptr_dtor(&z_roptions);
+ if (Z_TYPE(z_roptions) == IS_ARRAY) {
+ array_join(Z_ARRVAL(z_roptions), options, 0, 0);
}
+ zval_ptr_dtor(&z_roptions);
+
return options;
}
static void msg_queue_dtor(php_http_client_enqueue_t *e)
{
php_http_message_object_t *msg_obj = e->opaque;
- TSRMLS_FETCH_FROM_CTX(msg_obj->message->ts);
- zend_objects_store_del_ref_by_handle_ex(msg_obj->zv.handle, msg_obj->zv.handlers TSRMLS_CC);
+ zend_objects_store_del(&msg_obj->zo);
zend_hash_destroy(e->options);
FREE_HASHTABLE(e->options);
if (e->closure.fci.size) {
zval_ptr_dtor(&e->closure.fci.function_name);
- if (e->closure.fci.object_ptr) {
- zval_ptr_dtor(&e->closure.fci.object_ptr);
+ if (e->closure.fci.object) {
+ zend_objects_store_del(e->closure.fci.object);
}
}
}
php_http_message_object_t *msg_obj;
php_http_client_enqueue_t q;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|f", &request, php_http_client_request_class_entry, &fci, &fcc), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O|f", &request, php_http_client_request_class_entry, &fci, &fcc), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- msg_obj = zend_object_store_get_object(request TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
+ msg_obj = PHP_HTTP_OBJ(NULL, request);
if (php_http_client_enqueued(obj->client, msg_obj->message, NULL)) {
php_http_throw(bad_method_call, "Failed to enqueue request; request already in queue", NULL);
}
q.request = msg_obj->message;
- q.options = combined_options(getThis(), request TSRMLS_CC);
+ q.options = combined_options(getThis(), request);
q.dtor = msg_queue_dtor;
q.opaque = msg_obj;
q.closure.fci = fci;
q.closure.fcc = fcc;
if (fci.size) {
- Z_ADDREF_P(fci.function_name);
- if (fci.object_ptr) {
- Z_ADDREF_P(fci.object_ptr);
+ Z_TRY_ADDREF(fci.function_name);
+ if (fci.object) {
+ ++GC_REFCOUNT(fci.object);
}
}
- zend_objects_store_add_ref_by_handle(msg_obj->zv.handle TSRMLS_CC);
+ Z_ADDREF_P(request);
php_http_expect(SUCCESS == php_http_client_enqueue(obj->client, &q), runtime,
msg_queue_dtor(&q);
return;
);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_dequeue, 0, 0, 1)
php_http_client_object_t *obj;
php_http_message_object_t *msg_obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &request, php_http_client_request_class_entry), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &request, php_http_client_request_class_entry), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- msg_obj = zend_object_store_get_object(request TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
+ msg_obj = PHP_HTTP_OBJ(NULL, request);
if (!php_http_client_enqueued(obj->client, msg_obj->message, NULL)) {
php_http_throw(bad_method_call, "Failed to dequeue request; request not in queue", NULL);
php_http_expect(SUCCESS == php_http_client_dequeue(obj->client, msg_obj->message), runtime, return);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_requeue, 0, 0, 1)
php_http_message_object_t *msg_obj;
php_http_client_enqueue_t q;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|f", &request, php_http_client_request_class_entry, &fci, &fcc), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O|f", &request, php_http_client_request_class_entry, &fci, &fcc), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- msg_obj = zend_object_store_get_object(request TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
+ msg_obj = PHP_HTTP_OBJ(NULL, request);
if (php_http_client_enqueued(obj->client, msg_obj->message, NULL)) {
php_http_expect(SUCCESS == php_http_client_dequeue(obj->client, msg_obj->message), runtime, return);
}
q.request = msg_obj->message;
- q.options = combined_options(getThis(), request TSRMLS_CC);
+ q.options = combined_options(getThis(), request);
q.dtor = msg_queue_dtor;
q.opaque = msg_obj;
q.closure.fci = fci;
q.closure.fcc = fcc;
if (fci.size) {
- Z_ADDREF_P(fci.function_name);
- if (fci.object_ptr) {
- Z_ADDREF_P(fci.object_ptr);
+ Z_TRY_ADDREF(fci.function_name);
+ if (fci.object) {
+ ++GC_REFCOUNT(fci.object);
}
}
- zend_objects_store_add_ref_by_handle(msg_obj->zv.handle TSRMLS_CC);
+ Z_ADDREF_P(request);
php_http_expect(SUCCESS == php_http_client_enqueue(obj->client, &q), runtime,
msg_queue_dtor(&q);
return;
);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_count, 0, 0, 0)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpClient, count)
{
- long count_mode = -1;
+ zend_long count_mode = -1;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &count_mode)) {
- php_http_client_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &count_mode)) {
+ php_http_client_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
RETVAL_LONG(zend_llist_count(&obj->client->requests));
}
zval *zrequest = NULL;
php_http_client_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O", &zrequest, php_http_client_request_class_entry), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|O", &zrequest, php_http_client_request_class_entry), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
if (zrequest) {
/* lookup the response with the request */
zend_llist_element *el = NULL;
- php_http_message_object_t *req_obj = zend_object_store_get_object(zrequest TSRMLS_CC);
+ php_http_message_object_t *req_obj = PHP_HTTP_OBJ(NULL, zrequest);
for (el = obj->client->responses.head; el; el = el->next) {
php_http_message_object_t *response_obj = *(php_http_message_object_t **) el->data;
if (response_obj->message->parent == req_obj->message) {
- RETURN_OBJVAL(response_obj->zv, 1);
+ RETURN_OBJECT(&response_obj->zo, 1);
}
}
/* pop off and go */
if (response_obj) {
- RETVAL_OBJVAL(response_obj->zv, 1);
+ RETVAL_OBJECT(&response_obj->zo, 1);
zend_llist_remove_tail(&obj->client->responses);
}
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpClient, getHistory)
{
- zval *zhistory;
+ zval zhistory_tmp, *zhistory;
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 TSRMLS_CC);
- RETVAL_ZVAL(zhistory, 1, 0);
+ zhistory = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("history"), 0, &zhistory_tmp);
+ RETVAL_ZVAL_FAST(zhistory);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_send, 0, 0, 0)
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
php_http_expect(SUCCESS == php_http_client_exec(obj->client), runtime, return);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_once, 0, 0, 0)
static PHP_METHOD(HttpClient, once)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_client_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_client_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
RETURN_BOOL(0 < php_http_client_once(obj->client));
}
{
double timeout = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|d", &timeout)) {
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|d", &timeout)) {
struct timeval timeout_val;
- php_http_client_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_client_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
timeout_val.tv_sec = (time_t) timeout;
timeout_val.tv_usec = PHP_HTTP_USEC(timeout) % PHP_HTTP_MCROSEC;
zend_bool enable = 1;
php_http_client_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &enable), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &enable), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
php_http_expect(SUCCESS == php_http_client_setopt(obj->client, PHP_HTTP_CLIENT_OPT_ENABLE_PIPELINING, &enable), unexpected_val, return);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_enableEvents, 0, 0, 0)
zend_bool enable = 1;
php_http_client_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &enable), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &enable), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
php_http_expect(SUCCESS == php_http_client_setopt(obj->client, PHP_HTTP_CLIENT_OPT_USE_EVENTS, &enable), unexpected_val, return);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
- zval **args[3];
+ struct notify_arg {
+ php_http_object_method_t *cb;
-static int notify(zend_object_iterator *iter, void *puser TSRMLS_DC)
++ zval args[3];
+ int argc;
+ };
+
+static int notify(zend_object_iterator *iter, void *puser)
{
- zval *observer, *args = puser;
- zval **observer = NULL;
++ zval *observer;
+ struct notify_arg *arg = puser;
- iter->funcs->get_current_data(iter, &observer TSRMLS_CC);
- if (observer) {
- return php_http_object_method_call(arg->cb, *observer, NULL, arg->argc, arg->args TSRMLS_CC);
+ if ((observer = iter->funcs->get_current_data(iter))) {
- int num_args = !Z_ISUNDEF(args[0]) + !Z_ISUNDEF(args[1]) + !Z_ISUNDEF(args[2]);
- return php_http_method_call(observer, ZEND_STRL("update"), num_args, args, NULL);
++ return php_http_object_method_call(arg->cb, observer, NULL, arg->argc, arg->args);
}
return FAILURE;
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpClient, notify)
{
- zval *request = NULL, *zprogress = NULL, observers_tmp, *observers, args[3];
- zval *request = NULL, *zprogress = NULL, *observers;
++ zval *request = NULL, *zprogress = NULL, observers_tmp, *observers;
+ php_http_client_object_t *client_obj;
+ struct notify_arg arg = {NULL};
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O!o!", &request, php_http_client_request_class_entry, &zprogress), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|O!o!", &request, php_http_client_request_class_entry, &zprogress), invalid_arg, return);
- client_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0 TSRMLS_CC);
++ client_obj = PHP_HTTP_OBJ(NULL, getThis());
+ observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0, &observers_tmp);
if (Z_TYPE_P(observers) != IS_OBJECT) {
php_http_throw(unexpected_val, "Observer storage is corrupted", NULL);
return;
}
- ZVAL_COPY(&args[0], getThis());
- if (request) {
- ZVAL_COPY(&args[1], request);
- } else {
- ZVAL_UNDEF(&args[1]);
- }
- if (zprogress) {
- ZVAL_COPY(&args[2], zprogress);
- } else {
- ZVAL_UNDEF(&args[2]);
- }
+ if (client_obj->update) {
+ arg.cb = client_obj->update;
-
- Z_ADDREF_P(getThis());
- arg.args[0] = &getThis();
++ ZVAL_COPY(&arg.args[0], getThis());
+ arg.argc = 1;
- spl_iterator_apply(observers, notify, args);
+ if (request) {
- Z_ADDREF_P(request);
- arg.args[1] = &request;
++ ZVAL_COPY(&arg.args[1], request);
+ arg.argc += 1;
+ }
-
+ if (zprogress) {
- Z_ADDREF_P(zprogress);
- arg.args[2] = &zprogress;
++ ZVAL_COPY(&arg.args[2], zprogress);
+ arg.argc += 1;
+ }
- zval_ptr_dtor(getThis());
- if (request) {
- zval_ptr_dtor(request);
- }
- if (zprogress) {
- zval_ptr_dtor(zprogress);
- spl_iterator_apply(observers, notify, &arg TSRMLS_CC);
++ spl_iterator_apply(observers, notify, &arg);
+
- zval_ptr_dtor(&getThis());
++ zval_ptr_dtor(getThis());
+ if (request) {
- zval_ptr_dtor(&request);
++ zval_ptr_dtor(request);
+ }
+ if (zprogress) {
- zval_ptr_dtor(&zprogress);
++ zval_ptr_dtor(zprogress);
+ }
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_attach, 0, 0, 1)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpClient, attach)
{
- zval *observers, *observer, *retval = NULL;
+ zval observers_tmp, *observers, *observer, retval;
+ php_http_client_object_t *client_obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &observer, spl_ce_SplObserver), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &observer, spl_ce_SplObserver), invalid_arg, return);
- client_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0 TSRMLS_CC);
++ client_obj = PHP_HTTP_OBJ(NULL, getThis());
+ observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0, &observers_tmp);
if (Z_TYPE_P(observers) != IS_OBJECT) {
php_http_throw(unexpected_val, "Observer storage is corrupted", NULL);
return;
}
- client_obj->update = php_http_object_method_init(NULL, observer, ZEND_STRL("update") TSRMLS_CC);
+ if (!client_obj->update) {
- zend_call_method_with_1_params(&observers, NULL, NULL, "attach", &retval, observer);
- if (retval) {
- zval_ptr_dtor(&retval);
- }
++ client_obj->update = php_http_object_method_init(NULL, observer, ZEND_STRL("update"));
+ }
+
+ ZVAL_UNDEF(&retval);
+ zend_call_method_with_1_params(observers, NULL, NULL, "attach", &retval, observer);
+ zval_ptr_dtor(&retval);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_detach, 0, 0, 1)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpClient, detach)
{
- zval *observers, *observer, *retval = NULL;
+ zval observers_tmp, *observers, *observer, retval;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &observer, spl_ce_SplObserver), invalid_arg, return);
+ 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 TSRMLS_CC);
+ observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0, &observers_tmp);
if (Z_TYPE_P(observers) != IS_OBJECT) {
php_http_throw(unexpected_val, "Observer storage is corrupted", NULL);
return;
}
- zend_call_method_with_1_params(&observers, NULL, NULL, "detach", &retval, observer);
- if (retval) {
- zval_ptr_dtor(&retval);
- }
+ ZVAL_UNDEF(&retval);
+ zend_call_method_with_1_params(observers, NULL, NULL, "detach", &retval, observer);
+ zval_ptr_dtor(&retval);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_getObservers, 0, 0, 0)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpClient, getObservers)
{
- zval *observers;
+ zval observers_tmp, *observers;
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 TSRMLS_CC);
+ observers = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("observers"), 0, &observers_tmp);
if (Z_TYPE_P(observers) != IS_OBJECT) {
php_http_throw(unexpected_val, "Observer storage is corrupted", NULL);
return;
}
- RETVAL_ZVAL(observers, 1, 0);
+ RETVAL_ZVAL_FAST(observers);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_getProgressInfo, 0, 0, 1)
php_http_message_object_t *req_obj;
php_http_client_progress_state_t *progress;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &request, php_http_client_request_class_entry), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &request, php_http_client_request_class_entry), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- req_obj = zend_object_store_get_object(request TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
+ req_obj = PHP_HTTP_OBJ(NULL, request);
php_http_expect(SUCCESS == php_http_client_getopt(obj->client, PHP_HTTP_CLIENT_OPT_PROGRESS_INFO, req_obj->message, &progress), unexpected_val, return);
object_init(return_value);
add_property_bool(return_value, "started", progress->started);
add_property_bool(return_value, "finished", progress->finished);
- add_property_string(return_value, "info", STR_PTR(progress->info), 1);
+ add_property_string(return_value, "info", STR_PTR(progress->info));
add_property_double(return_value, "dltotal", progress->dl.total);
add_property_double(return_value, "dlnow", progress->dl.now);
add_property_double(return_value, "ultotal", progress->ul.total);
php_http_client_object_t *obj;
php_http_message_object_t *req_obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &request, php_http_client_request_class_entry), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &request, php_http_client_request_class_entry), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- req_obj = zend_object_store_get_object(request TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
+ req_obj = PHP_HTTP_OBJ(NULL, request);
object_init(return_value);
info = HASH_OF(return_value);
{
zval *opts = NULL;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!/", &opts), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|a!/", &opts), invalid_arg, return);
- php_http_client_options_set(getThis(), opts TSRMLS_CC);
+ php_http_client_options_set(getThis(), opts);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_getOptions, 0, 0, 0)
static PHP_METHOD(HttpClient, getOptions)
{
if (SUCCESS == zend_parse_parameters_none()) {
- zval *options = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
- RETVAL_ZVAL(options, 1, 0);
+ zval options_tmp, *options = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("options"), 0, &options_tmp);
+ RETVAL_ZVAL_FAST(options);
}
}
{
zval *opts = NULL;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!/", &opts), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|a!/", &opts), invalid_arg, return);
- php_http_client_options_set_subr(getThis(), ZEND_STRS("ssl"), opts, 1 TSRMLS_CC);
+ php_http_client_options_set_subr(getThis(), ZEND_STRL("ssl"), opts, 1);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_addSslOptions, 0, 0, 0)
{
zval *opts = NULL;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!/", &opts), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|a!/", &opts), invalid_arg, return);
- php_http_client_options_set_subr(getThis(), ZEND_STRS("ssl"), opts, 0 TSRMLS_CC);
+ php_http_client_options_set_subr(getThis(), ZEND_STRL("ssl"), opts, 0);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_getSslOptions, 0, 0, 0)
static PHP_METHOD(HttpClient, getSslOptions)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_client_options_get_subr(getThis(), ZEND_STRS("ssl"), return_value TSRMLS_CC);
+ php_http_client_options_get_subr(getThis(), ZEND_STRL("ssl"), return_value);
}
}
{
zval *opts = NULL;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!/", &opts), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|a!/", &opts), invalid_arg, return);
- php_http_client_options_set_subr(getThis(), ZEND_STRS("cookies"), opts, 1 TSRMLS_CC);
+ php_http_client_options_set_subr(getThis(), ZEND_STRL("cookies"), opts, 1);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_addCookies, 0, 0, 0)
{
zval *opts = NULL;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!/", &opts), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|a!/", &opts), invalid_arg, return);
- php_http_client_options_set_subr(getThis(), ZEND_STRS("cookies"), opts, 0 TSRMLS_CC);
+ php_http_client_options_set_subr(getThis(), ZEND_STRL("cookies"), opts, 0);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_getCookies, 0, 0, 0)
static PHP_METHOD(HttpClient, getCookies)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_client_options_get_subr(getThis(), ZEND_STRS("cookies"), return_value TSRMLS_CC);
+ php_http_client_options_get_subr(getThis(), ZEND_STRL("cookies"), return_value);
}
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_getAvailableDrivers, 0, 0, 0)
ZEND_END_ARG_INFO();
-static PHP_METHOD(HttpClient, getAvailableDrivers) {
+static PHP_METHOD(HttpClient, getAvailableDrivers)
+{
if (SUCCESS == zend_parse_parameters_none()) {
array_init(return_value);
- php_http_client_driver_list(Z_ARRVAL_P(return_value) TSRMLS_CC);
+ php_http_client_driver_list(Z_ARRVAL_P(return_value));
}
}
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http", "Client", php_http_client_methods);
- php_http_client_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
+ php_http_client_class_entry = zend_register_internal_class_ex(&ce, NULL);
php_http_client_class_entry->create_object = php_http_client_object_new;
- zend_class_implements(php_http_client_class_entry TSRMLS_CC, 2, spl_ce_SplSubject, spl_ce_Countable);
+ zend_class_implements(php_http_client_class_entry, 2, spl_ce_SplSubject, spl_ce_Countable);
memcpy(&php_http_client_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+ php_http_client_object_handlers.offset = XtOffsetOf(php_http_client_object_t, zo);
+ php_http_client_object_handlers.free_obj = php_http_client_object_free;
php_http_client_object_handlers.clone_obj = NULL;
- zend_declare_property_null(php_http_client_class_entry, ZEND_STRL("observers"), ZEND_ACC_PRIVATE TSRMLS_CC);
- zend_declare_property_null(php_http_client_class_entry, ZEND_STRL("options"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_client_class_entry, ZEND_STRL("history"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_bool(php_http_client_class_entry, ZEND_STRL("recordHistory"), 0, ZEND_ACC_PUBLIC TSRMLS_CC);
+ zend_declare_property_null(php_http_client_class_entry, ZEND_STRL("observers"), ZEND_ACC_PRIVATE);
+ zend_declare_property_null(php_http_client_class_entry, ZEND_STRL("options"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_client_class_entry, ZEND_STRL("history"), ZEND_ACC_PROTECTED);
+ zend_declare_property_bool(php_http_client_class_entry, ZEND_STRL("recordHistory"), 0, ZEND_ACC_PUBLIC);
- zend_hash_init(&php_http_client_drivers, 2, NULL, NULL, 1);
+ zend_hash_init(&php_http_client_drivers, 2, NULL, php_http_client_driver_hash_dtor, 1);
return SUCCESS;
}
typedef struct php_http_client *(*php_http_client_copy_func_t)(struct php_http_client *from, struct php_http_client *to);
typedef void (*php_http_client_dtor_func_t)(struct php_http_client *p);
typedef void (*php_http_client_reset_func_t)(struct php_http_client *p);
-typedef STATUS (*php_http_client_exec_func_t)(struct php_http_client *p);
+typedef ZEND_RESULT_CODE (*php_http_client_exec_func_t)(struct php_http_client *p);
typedef int (*php_http_client_once_func_t)(struct php_http_client *p);
-typedef STATUS (*php_http_client_wait_func_t)(struct php_http_client *p, struct timeval *custom_timeout);
-typedef STATUS (*php_http_client_enqueue_func_t)(struct php_http_client *p, php_http_client_enqueue_t *enqueue);
-typedef STATUS (*php_http_client_dequeue_func_t)(struct php_http_client *p, php_http_client_enqueue_t *enqueue);
-typedef STATUS (*php_http_client_setopt_func_t)(struct php_http_client *p, php_http_client_setopt_opt_t opt, void *arg);
-typedef STATUS (*php_http_client_getopt_func_t)(struct php_http_client *h, php_http_client_getopt_opt_t opt, void *arg, void **res);
+typedef ZEND_RESULT_CODE (*php_http_client_wait_func_t)(struct php_http_client *p, struct timeval *custom_timeout);
+typedef ZEND_RESULT_CODE (*php_http_client_enqueue_func_t)(struct php_http_client *p, php_http_client_enqueue_t *enqueue);
+typedef ZEND_RESULT_CODE (*php_http_client_dequeue_func_t)(struct php_http_client *p, php_http_client_enqueue_t *enqueue);
+typedef ZEND_RESULT_CODE (*php_http_client_setopt_func_t)(struct php_http_client *p, php_http_client_setopt_opt_t opt, void *arg);
+typedef ZEND_RESULT_CODE (*php_http_client_getopt_func_t)(struct php_http_client *h, php_http_client_getopt_opt_t opt, void *arg, void **res);
typedef struct php_http_client_ops {
php_resource_factory_ops_t *rsrc;
} php_http_client_ops_t;
typedef struct php_http_client_driver {
- const char *name_str;
- size_t name_len;
+ zend_string *driver_name;
+ zend_string *client_name;
+ zend_string *request_name;
php_http_client_ops_t *client_ops;
} php_http_client_driver_t;
-PHP_HTTP_API STATUS php_http_client_driver_add(php_http_client_driver_t *driver);
-PHP_HTTP_API STATUS php_http_client_driver_get(const char *name_str, size_t name_len, php_http_client_driver_t *driver);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_client_driver_add(php_http_client_driver_t *driver);
+PHP_HTTP_API php_http_client_driver_t *php_http_client_driver_get(zend_string *name);
typedef struct php_http_client_progress_state {
struct {
unsigned finished:1;
} php_http_client_progress_state_t;
- typedef ZEND_RESULT_CODE (*php_http_client_response_callback_t)(void *arg, struct php_http_client *client, php_http_client_enqueue_t *e, php_http_message_t **request, php_http_message_t **response);
-typedef STATUS (*php_http_client_response_callback_t)(void *arg, struct php_http_client *client, php_http_client_enqueue_t *e, php_http_message_t **response);
++typedef ZEND_RESULT_CODE (*php_http_client_response_callback_t)(void *arg, struct php_http_client *client, php_http_client_enqueue_t *e, php_http_message_t **response);
typedef void (*php_http_client_progress_callback_t)(void *arg, struct php_http_client *client, php_http_client_enqueue_t *e, php_http_client_progress_state_t *state);
typedef struct php_http_client {
zend_llist requests;
zend_llist responses;
-
-#ifdef ZTS
- void ***ts;
-#endif
} php_http_client_t;
PHP_HTTP_API zend_class_entry *php_http_client_class_entry;
typedef struct php_http_client_object {
- zend_object zo;
- zend_object_value zv;
php_http_client_t *client;
- long iterator;
+ php_http_object_method_t *update;
+ php_http_object_method_t notify;
+ long iterator;
+ zend_object zo;
} php_http_client_object_t;
-PHP_HTTP_API php_http_client_t *php_http_client_init(php_http_client_t *h, php_http_client_ops_t *ops, php_resource_factory_t *rf, void *init_arg TSRMLS_DC);
+PHP_HTTP_API php_http_client_t *php_http_client_init(php_http_client_t *h, php_http_client_ops_t *ops, php_resource_factory_t *rf, void *init_arg);
PHP_HTTP_API php_http_client_t *php_http_client_copy(php_http_client_t *from, php_http_client_t *to);
PHP_HTTP_API void php_http_client_dtor(php_http_client_t *h);
PHP_HTTP_API void php_http_client_free(php_http_client_t **h);
-PHP_HTTP_API STATUS php_http_client_enqueue(php_http_client_t *h, php_http_client_enqueue_t *enqueue);
-PHP_HTTP_API STATUS php_http_client_dequeue(php_http_client_t *h, php_http_message_t *request);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_client_enqueue(php_http_client_t *h, php_http_client_enqueue_t *enqueue);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_client_dequeue(php_http_client_t *h, php_http_message_t *request);
-PHP_HTTP_API STATUS php_http_client_wait(php_http_client_t *h, struct timeval *custom_timeout);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_client_wait(php_http_client_t *h, struct timeval *custom_timeout);
PHP_HTTP_API int php_http_client_once(php_http_client_t *h);
-PHP_HTTP_API STATUS php_http_client_exec(php_http_client_t *h);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_client_exec(php_http_client_t *h);
PHP_HTTP_API void php_http_client_reset(php_http_client_t *h);
-PHP_HTTP_API STATUS php_http_client_setopt(php_http_client_t *h, php_http_client_setopt_opt_t opt, void *arg);
-PHP_HTTP_API STATUS php_http_client_getopt(php_http_client_t *h, php_http_client_getopt_opt_t opt, void *arg, void *res_ptr);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_client_setopt(php_http_client_t *h, php_http_client_setopt_opt_t opt, void *arg);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_client_getopt(php_http_client_t *h, php_http_client_getopt_opt_t opt, void *arg, void *res_ptr);
typedef int (*php_http_client_enqueue_cmp_func_t)(php_http_client_enqueue_t *cmp, void *arg);
/* compare with request message pointer if compare_func is NULL */
#include "php_http_api.h"
#include "php_http_client.h"
-#if PHP_HTTP_HAVE_CURL
+#if 1||PHP_HTTP_HAVE_CURL
#if PHP_HTTP_HAVE_EVENT
# if !PHP_HTTP_HAVE_EVENT2 && /* just be really sure */ !(LIBEVENT_VERSION_NUMBER >= 0x02000000)
php_resource_factory_t *rf;
php_http_client_t *client;
php_http_client_progress_state_t progress;
-
php_http_client_enqueue_t queue;
struct {
- php_http_message_parser_t *parser;
- php_http_message_t *message;
- php_http_buffer_t *buffer;
- } request;
-
- struct {
- php_http_message_parser_t *parser;
- php_http_message_t *message;
- php_http_buffer_t *buffer;
+ php_http_buffer_t headers;
+ php_http_message_body_t *body;
} response;
struct {
HashTable cache;
+ struct curl_slist *proxyheaders;
struct curl_slist *headers;
struct curl_slist *resolve;
php_http_buffer_t cookies;
php_http_buffer_t ranges;
- long redirects;
- unsigned range_request:1;
- unsigned encode_cookies:1;
-
struct {
uint count;
double delay;
} retry;
+ long redirects;
+ unsigned range_request:1;
+ unsigned encode_cookies:1;
+
} options;
} php_http_client_curl_handler_t;
return st;
}
-static void *php_http_curle_ctor(void *opaque, void *init_arg TSRMLS_DC)
+static void *php_http_curle_ctor(void *opaque, void *init_arg)
{
void *ch;
return NULL;
}
-static void *php_http_curle_copy(void *opaque, void *handle TSRMLS_DC)
+static void *php_http_curle_copy(void *opaque, void *handle)
{
void *ch;
return NULL;
}
-static void php_http_curle_dtor(void *opaque, void *handle TSRMLS_DC)
+static void php_http_curle_dtor(void *opaque, void *handle)
{
php_http_curle_storage_t *st = php_http_curle_get_storage(handle);
php_http_curle_dtor
};
-static void *php_http_curlm_ctor(void *opaque, void *init_arg TSRMLS_DC)
+static void *php_http_curlm_ctor(void *opaque, void *init_arg)
{
return curl_multi_init();
}
-static void php_http_curlm_dtor(void *opaque, void *handle TSRMLS_DC)
+static void php_http_curlm_dtor(void *opaque, void *handle)
{
curl_multi_cleanup(handle);
}
{
php_http_message_body_t *body = ctx;
- if (body && body->stream_id) {
+ if (body && body->res) {
php_stream *s = php_http_message_body_stream(body);
if (s) {
- TSRMLS_FETCH_FROM_CTX(body->ts);
return php_stream_read(s, data, len * n);
} else abort();
}
return 0;
}
- static curlioerr php_http_curle_ioctl_callback(CURL *ch, curliocmd cmd, void *ctx)
+ static int php_http_curle_seek_callback(void *userdata, curl_off_t offset, int origin)
{
- php_http_message_body_t *body = ctx;
+ php_http_message_body_t *body = userdata;
+ TSRMLS_FETCH_FROM_CTX(body->ts);
- if (cmd != CURLIOCMD_RESTARTREAD) {
- return CURLIOE_UNKNOWNCMD;
+ if (!body) {
+ return 1;
}
-
- if (body && SUCCESS == php_stream_rewind(php_http_message_body_stream(body))) {
- return CURLIOE_OK;
+ if (0 == php_stream_seek(php_http_message_body_stream(body), offset, origin)) {
+ return 0;
}
-
- return CURLIOE_FAILRESTART;
+ return 2;
}
static int php_http_curle_raw_callback(CURL *ch, curl_infotype type, char *data, size_t length, void *ctx)
{
php_http_client_curl_handler_t *h = ctx;
- unsigned flags = 0;
/* catch progress */
switch (type) {
default:
break;
}
- /* process data */
- switch (type) {
- case CURLINFO_HEADER_IN:
- case CURLINFO_DATA_IN:
- php_http_buffer_append(h->response.buffer, data, length);
-
- if (h->options.redirects) {
- flags |= PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS;
- }
-
- if (PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE == php_http_message_parser_parse(h->response.parser, h->response.buffer, flags, &h->response.message)) {
- return -1;
- }
- break;
-
- case CURLINFO_HEADER_OUT:
- case CURLINFO_DATA_OUT:
- php_http_buffer_append(h->request.buffer, data, length);
-
- if (PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE == php_http_message_parser_parse(h->request.parser, h->request.buffer, flags, &h->request.message)) {
- return -1;
- }
- break;
- default:
- break;
- }
#if 0
/* debug */
return 0;
}
- static int php_http_curle_dummy_callback(char *data, size_t n, size_t l, void *s)
+ static int php_http_curle_header_callback(char *data, size_t n, size_t l, void *arg)
{
- return n*l;
+ php_http_client_curl_handler_t *h = arg;
+
+ return php_http_buffer_append(&h->response.headers, data, n * l);
+ }
+
+ static int php_http_curle_body_callback(char *data, size_t n, size_t l, void *arg)
+ {
+ php_http_client_curl_handler_t *h = arg;
+
+ return php_http_message_body_append(h->response.body, data, n*l);
}
-static STATUS php_http_curle_get_info(CURL *ch, HashTable *info)
+static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
{
- char *c;
- long l;
- double d;
- struct curl_slist *s, *p;
- zval *subarray, array;
- INIT_PZVAL_ARRAY(&array, info);
+ char *c = NULL;
+ long l = 0;
+ double d = 0;
+ struct curl_slist *s = NULL, *p = NULL;
+ zval tmp = {{0}};
/* BEGIN::CURLINFO */
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_EFFECTIVE_URL, &c)) {
- add_assoc_string_ex(&array, "effective_url", sizeof("effective_url"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "effective_url", lenof("effective_url"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_RESPONSE_CODE, &l)) {
- add_assoc_long_ex(&array, "response_code", sizeof("response_code"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "response_code", lenof("response_code"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_TOTAL_TIME, &d)) {
- add_assoc_double_ex(&array, "total_time", sizeof("total_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "total_time", lenof("total_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NAMELOOKUP_TIME, &d)) {
- add_assoc_double_ex(&array, "namelookup_time", sizeof("namelookup_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "namelookup_time", lenof("namelookup_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONNECT_TIME, &d)) {
- add_assoc_double_ex(&array, "connect_time", sizeof("connect_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "connect_time", lenof("connect_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRETRANSFER_TIME, &d)) {
- add_assoc_double_ex(&array, "pretransfer_time", sizeof("pretransfer_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "pretransfer_time", lenof("pretransfer_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_UPLOAD, &d)) {
- add_assoc_double_ex(&array, "size_upload", sizeof("size_upload"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "size_upload", lenof("size_upload"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_DOWNLOAD, &d)) {
- add_assoc_double_ex(&array, "size_download", sizeof("size_download"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "size_download", lenof("size_download"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SPEED_DOWNLOAD, &d)) {
- add_assoc_double_ex(&array, "speed_download", sizeof("speed_download"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "speed_download", lenof("speed_download"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SPEED_UPLOAD, &d)) {
- add_assoc_double_ex(&array, "speed_upload", sizeof("speed_upload"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "speed_upload", lenof("speed_upload"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HEADER_SIZE, &l)) {
- add_assoc_long_ex(&array, "header_size", sizeof("header_size"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "header_size", lenof("header_size"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REQUEST_SIZE, &l)) {
- add_assoc_long_ex(&array, "request_size", sizeof("request_size"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "request_size", lenof("request_size"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SSL_VERIFYRESULT, &l)) {
- add_assoc_long_ex(&array, "ssl_verifyresult", sizeof("ssl_verifyresult"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "ssl_verifyresult", lenof("ssl_verifyresult"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_FILETIME, &l)) {
- add_assoc_long_ex(&array, "filetime", sizeof("filetime"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "filetime", lenof("filetime"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d)) {
- add_assoc_double_ex(&array, "content_length_download", sizeof("content_length_download"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "content_length_download", lenof("content_length_download"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONTENT_LENGTH_UPLOAD, &d)) {
- add_assoc_double_ex(&array, "content_length_upload", sizeof("content_length_upload"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "content_length_upload", lenof("content_length_upload"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_STARTTRANSFER_TIME, &d)) {
- add_assoc_double_ex(&array, "starttransfer_time", sizeof("starttransfer_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "starttransfer_time", lenof("starttransfer_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONTENT_TYPE, &c)) {
- add_assoc_string_ex(&array, "content_type", sizeof("content_type"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "content_type", lenof("content_type"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_TIME, &d)) {
- add_assoc_double_ex(&array, "redirect_time", sizeof("redirect_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "redirect_time", lenof("redirect_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_COUNT, &l)) {
- add_assoc_long_ex(&array, "redirect_count", sizeof("redirect_count"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "redirect_count", lenof("redirect_count"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTP_CONNECTCODE, &l)) {
- add_assoc_long_ex(&array, "connect_code", sizeof("connect_code"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "connect_code", lenof("connect_code"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTPAUTH_AVAIL, &l)) {
- add_assoc_long_ex(&array, "httpauth_avail", sizeof("httpauth_avail"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "httpauth_avail", lenof("httpauth_avail"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PROXYAUTH_AVAIL, &l)) {
- add_assoc_long_ex(&array, "proxyauth_avail", sizeof("proxyauth_avail"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "proxyauth_avail", lenof("proxyauth_avail"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_OS_ERRNO, &l)) {
- add_assoc_long_ex(&array, "os_errno", sizeof("os_errno"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "os_errno", lenof("os_errno"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NUM_CONNECTS, &l)) {
- add_assoc_long_ex(&array, "num_connects", sizeof("num_connects"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "num_connects", lenof("num_connects"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SSL_ENGINES, &s)) {
- MAKE_STD_ZVAL(subarray);
- array_init(subarray);
+ array_init(&tmp);
for (p = s; p; p = p->next) {
if (p->data) {
- add_next_index_string(subarray, p->data, 1);
+ add_next_index_string(&tmp, p->data);
}
}
- add_assoc_zval_ex(&array, "ssl_engines", sizeof("ssl_engines"), subarray);
+ zend_hash_str_update(info, "ssl_engines", lenof("ssl_engines"), &tmp);
curl_slist_free_all(s);
}
- if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_COOKIELIST, &s)) {
- array_init(&tmp);
- for (p = s; p; p = p->next) {
- if (p->data) {
- add_next_index_string(&tmp, p->data);
- }
- }
- zend_hash_str_update(info, "cookies", lenof("cookies"), &tmp);
- curl_slist_free_all(s);
- }
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_URL, &c)) {
- add_assoc_string_ex(&array, "redirect_url", sizeof("redirect_url"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "redirect_url", lenof("redirect_url"), &tmp);
}
#if PHP_HTTP_CURL_VERSION(7,19,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRIMARY_IP, &c)) {
- add_assoc_string_ex(&array, "primary_ip", sizeof("primary_ip"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "primary_ip", lenof("primary_ip"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,19,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_APPCONNECT_TIME, &d)) {
- add_assoc_double_ex(&array, "appconnect_time", sizeof("appconnect_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "appconnect_time", lenof("appconnect_time"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,19,4)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONDITION_UNMET, &l)) {
- add_assoc_long_ex(&array, "condition_unmet", sizeof("condition_unmet"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "condition_unmet", lenof("condition_unmet"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,21,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRIMARY_PORT, &l)) {
- add_assoc_long_ex(&array, "primary_port", sizeof("primary_port"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "primary_port", lenof("primary_port"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,21,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_LOCAL_IP, &c)) {
- add_assoc_string_ex(&array, "local_ip", sizeof("local_ip"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "local_ip", lenof("local_ip"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,21,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_LOCAL_PORT, &l)) {
- add_assoc_long_ex(&array, "local_port", sizeof("local_port"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "local_port", lenof("local_port"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,34,0)
{
- zval *ti_array;
+ zval ti_array, subarray;
struct curl_tlssessioninfo *ti;
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_TLS_SESSION, &ti)) {
- const char *backend;
+ char *backend;
- MAKE_STD_ZVAL(subarray);
- ZVAL_NULL(subarray);
- MAKE_STD_ZVAL(ti_array);
- array_init(ti_array);
+ ZVAL_NULL(&subarray);
+ array_init(&ti_array);
switch (ti->backend) {
case CURLSSLBACKEND_NONE:
{
SSL_CTX *ctx = ti->internals;
- array_init(subarray);
- add_assoc_long_ex(subarray, ZEND_STRS("number"), SSL_CTX_sess_number(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("connect"), SSL_CTX_sess_connect(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("connect_good"), SSL_CTX_sess_connect_good(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("connect_renegotiate"), SSL_CTX_sess_connect_renegotiate(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("hits"), SSL_CTX_sess_hits(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("cache_full"), SSL_CTX_sess_cache_full(ctx));
+ array_init(&subarray);
+ add_assoc_long_ex(&subarray, ZEND_STRL("number"), SSL_CTX_sess_number(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("connect"), SSL_CTX_sess_connect(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("connect_good"), SSL_CTX_sess_connect_good(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("connect_renegotiate"), SSL_CTX_sess_connect_renegotiate(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("hits"), SSL_CTX_sess_hits(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("cache_full"), SSL_CTX_sess_cache_full(ctx));
}
#endif
break;
gnutls_session_t sess = ti->internals;
char *desc;
- array_init(subarray);
+ array_init(&subarray);
if ((desc = gnutls_session_get_desc(sess))) {
- add_assoc_string_ex(subarray, ZEND_STRS("desc"), desc, 1);
+ add_assoc_string_ex(&subarray, ZEND_STRL("desc"), desc);
gnutls_free(desc);
}
- add_assoc_bool_ex(subarray, ZEND_STRS("resumed"), gnutls_session_is_resumed(sess));
+ add_assoc_bool_ex(&subarray, ZEND_STRL("resumed"), gnutls_session_is_resumed(sess));
}
#endif
break;
default:
backend = "unknown";
}
- add_assoc_string_ex(ti_array, ZEND_STRS("backend"), estrdup(backend), 0);
- add_assoc_zval_ex(ti_array, ZEND_STRS("internals"), subarray);
- add_assoc_zval_ex(&array, "tls_session", sizeof("tls_session"), ti_array);
+ add_assoc_string_ex(&ti_array, ZEND_STRL("backend"), backend);
+ add_assoc_zval_ex(&ti_array, ZEND_STRL("internals"), &subarray);
+ zend_hash_str_update(info, "tls_session", lenof("tls_session"), &ti_array);
}
}
#endif
#if PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)
{
int i;
- zval *ci_array;
+ zval ci_array, subarray;
struct curl_certinfo *ci;
char *colon, *keyname;
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CERTINFO, &ci)) {
- MAKE_STD_ZVAL(ci_array);
- array_init(ci_array);
+ array_init(&ci_array);
for (i = 0; i < ci->num_of_certs; ++i) {
s = ci->certinfo[i];
- MAKE_STD_ZVAL(subarray);
- array_init(subarray);
+ array_init(&subarray);
for (p = s; p; p = p->next) {
if (p->data) {
if ((colon = strchr(p->data, ':'))) {
keyname = estrndup(p->data, colon - p->data);
- add_assoc_string_ex(subarray, keyname, colon - p->data + 1, colon + 1, 1);
+ add_assoc_string_ex(&subarray, keyname, colon - p->data, colon + 1);
efree(keyname);
} else {
- add_next_index_string(subarray, p->data, 1);
+ add_next_index_string(&subarray, p->data);
}
}
}
- add_next_index_zval(ci_array, subarray);
+ add_next_index_zval(&ci_array, &subarray);
}
- add_assoc_zval_ex(&array, "certinfo", sizeof("certinfo"), ci_array);
+ zend_hash_str_update(info, "certinfo", lenof("certinfo"), &ci_array);
}
}
#endif
{
php_http_curle_storage_t *st = php_http_curle_get_storage(ch);
- add_assoc_long_ex(&array, "curlcode", sizeof("curlcode"), st->errorcode);
- add_assoc_string_ex(&array, "error", sizeof("error"), st->errorbuffer, 1);
+ ZVAL_LONG(&tmp, st->errorcode);
+ zend_hash_str_update(info, "curlcode", lenof("curlcode"), &tmp);
+ ZVAL_STRING(&tmp, st->errorbuffer);
+ zend_hash_str_update(info, "error", lenof("error"), &tmp);
}
return SUCCESS;
return handle == ((php_http_client_curl_handler_t *) e->opaque)->handle;
}
- if ((zh = php_http_message_header(response, ZEND_STRL("Content-Length"), 1))) {
- zend_hash_update(&response->hdrs, "X-Original-Content-Length", sizeof("X-Original-Content-Length"), &zh, sizeof(zval *), NULL);
+ static php_http_message_t *php_http_curlm_responseparser(php_http_client_curl_handler_t *h TSRMLS_DC)
+ {
+ php_http_message_t *response;
+ php_http_header_parser_t parser;
+ zval *zh;
+
+ response = php_http_message_init(NULL, 0, h->response.body TSRMLS_CC);
+ php_http_header_parser_init(&parser TSRMLS_CC);
+ php_http_header_parser_parse(&parser, &h->response.headers, PHP_HTTP_HEADER_PARSER_CLEANUP, &response->hdrs, (php_http_info_callback_t) php_http_message_info_callback, (void *) &response);
+ php_http_header_parser_dtor(&parser);
+
+ /* move body to right message */
+ if (response->body != h->response.body) {
+ php_http_message_t *ptr = response;
+
+ while (ptr->parent) {
+ ptr = ptr->parent;
+ }
+ response->body = ptr->body;
+ ptr->body = NULL;
+ }
+ php_http_message_body_addref(h->response.body);
+
+ /* let's update the response headers */
- if ((zh = php_http_message_header(response, ZEND_STRL("Transfer-Encoding"), 0))) {
- zend_hash_update(&response->hdrs, "X-Original-Transfer-Encoding", sizeof("X-Original-Transfer-Encoding"), (void *) &zh, sizeof(zval *), NULL);
- zend_hash_del(&response->hdrs, "Transfer-Encoding", sizeof("Transfer-Encoding"));
++ if ((zh = php_http_message_header(response, ZEND_STRL("Content-Length")))) {
++ Z_TRY_ADDREF_P(zh);
++ zend_hash_str_update(&response->hdrs, "X-Original-Content-Length", lenof("X-Original-Content-Length"), zh);
+ }
- if ((zh = php_http_message_header(response, ZEND_STRL("Content-Range"), 0))) {
- zend_hash_update(&response->hdrs, "X-Original-Content-Range", sizeof("X-Original-Content-Range"), &zh, sizeof(zval *), NULL);
- zend_hash_del(&response->hdrs, "Content-Range", sizeof("Content-Range"));
++ if ((zh = php_http_message_header(response, ZEND_STRL("Transfer-Encoding")))) {
++ Z_TRY_ADDREF_P(zh);
++ zend_hash_str_update(&response->hdrs, "X-Original-Transfer-Encoding", lenof("X-Original-Transfer-Encoding"), zh);
++ zend_hash_str_del(&response->hdrs, "Transfer-Encoding", lenof("Transfer-Encoding"));
+ }
- if ((zh = php_http_message_header(response, ZEND_STRL("Content-Encoding"), 0))) {
- zend_hash_update(&response->hdrs, "X-Original-Content-Encoding", sizeof("X-Original-Content-Encoding"), &zh, sizeof(zval *), NULL);
- zend_hash_del(&response->hdrs, "Content-Encoding", sizeof("Content-Encoding"));
++ if ((zh = php_http_message_header(response, ZEND_STRL("Content-Range")))) {
++ Z_TRY_ADDREF_P(zh);
++ zend_hash_str_update(&response->hdrs, "X-Original-Content-Range", lenof("X-Original-Content-Range"), zh);
++ zend_hash_str_del(&response->hdrs, "Content-Range", lenof("Content-Range"));
+ }
++ if ((zh = php_http_message_header(response, ZEND_STRL("Content-Encoding")))) {
++ Z_TRY_ADDREF_P(zh);
++ zend_hash_str_update(&response->hdrs, "X-Original-Content-Encoding", lenof("X-Original-Content-Encoding"), zh);
++ zend_hash_str_del(&response->hdrs, "Content-Encoding", lenof("Content-Encoding"));
+ }
+ php_http_message_update_headers(response);
+
+ return response;
+ }
+
static void php_http_curlm_responsehandler(php_http_client_t *context)
{
int remaining = 0;
php_http_client_enqueue_t *enqueue;
php_http_client_curl_t *curl = context->ctx;
- TSRMLS_FETCH_FROM_CTX(context->ts);
do {
CURLMsg *msg = curl_multi_info_read(curl->handle, &remaining);
if (msg && CURLMSG_DONE == msg->msg) {
if (CURLE_OK != msg->data.result) {
php_http_curle_storage_t *st = php_http_curle_get_storage(msg->easy_handle);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s; %s (%s)", curl_easy_strerror(st->errorcode = msg->data.result), STR_PTR(st->errorbuffer), STR_PTR(st->url));
+ php_error_docref(NULL, E_WARNING, "%s; %s (%s)", curl_easy_strerror(st->errorcode = msg->data.result), STR_PTR(st->errorbuffer), STR_PTR(st->url));
}
if ((enqueue = php_http_client_enqueued(context, msg->easy_handle, compare_queue))) {
php_http_client_curl_handler_t *handler = enqueue->opaque;
+ php_http_message_t *response = php_http_curlm_responseparser(handler TSRMLS_CC);
- context->callback.response.func(context->callback.response.arg, context, &handler->queue, &handler->request.message, &handler->response.message);
+ if (response) {
+ context->callback.response.func(context->callback.response.arg, context, &handler->queue, &response);
+ php_http_message_free(&response);
+ }
}
}
} while (remaining);
#endif
if (curl->useevents) {
CURLMcode rc;
- TSRMLS_FETCH_FROM_CTX(context->ts);
/* ignore and use -1,0 on timeout */
(void) socket;
while (CURLM_CALL_MULTI_PERFORM == (rc = curl_multi_socket_action(curl->handle, CURL_SOCKET_TIMEOUT, 0, &curl->unfinished)));
if (CURLM_OK != rc) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", curl_multi_strerror(rc));
+ php_error_docref(NULL, E_WARNING, "%s", curl_multi_strerror(rc));
}
php_http_curlm_responsehandler(context);
#endif
if (curl->useevents) {
CURLMcode rc = CURLM_OK;
- TSRMLS_FETCH_FROM_CTX(context->ts);
while (CURLM_CALL_MULTI_PERFORM == (rc = curl_multi_socket_action(curl->handle, socket, etoca(action), &curl->unfinished)));
if (CURLM_OK != rc) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", curl_multi_strerror(rc));
+ php_error_docref(NULL, E_WARNING, "%s", curl_multi_strerror(rc));
}
php_http_curlm_responsehandler(context);
if (curl->useevents) {
int events = EV_PERSIST;
php_http_curlm_event_t *ev = assign_data;
- TSRMLS_FETCH_FROM_CTX(context->ts);
if (!ev) {
ev = ecalloc(1, sizeof(php_http_curlm_event_t));
return 0;
default:
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown socket action %d", action);
+ php_error_docref(NULL, E_WARNING, "Unknown socket action %d", action);
return -1;
}
#define PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR 0x0002
#define PHP_HTTP_CURLE_OPTION_TRANSFORM_MS 0x0004
-static STATUS php_http_curle_option_set_ssl_verifyhost(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_ssl_verifyhost(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_SSL_VERIFYHOST, Z_BVAL_P(val) ? 2 : 0)) {
+ if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_SSL_VERIFYHOST, Z_TYPE_P(val) == IS_TRUE ? 2 : 0)) {
return FAILURE;
}
return SUCCESS;
}
-static STATUS php_http_curle_option_set_cookiestore(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_cookiestore(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
if (storage->cookiestore) {
pefree(storage->cookiestore, 1);
}
- if (val && Z_STRLEN_P(val)) {
+ if (val && Z_TYPE_P(val) == IS_STRING && Z_STRLEN_P(val)) {
storage->cookiestore = pestrndup(Z_STRVAL_P(val), Z_STRLEN_P(val), 1);
} else {
storage->cookiestore = NULL;
return SUCCESS;
}
-static STATUS php_http_curle_option_set_cookies(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_cookies(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (val && Z_TYPE_P(val) != IS_NULL) {
+ HashTable *ht = HASH_OF(val);
+
if (curl->options.encode_cookies) {
- if (SUCCESS == php_http_url_encode_hash_ex(HASH_OF(val), &curl->options.cookies, ZEND_STRL(";"), ZEND_STRL("="), NULL, 0 TSRMLS_CC)) {
+ if (SUCCESS == php_http_url_encode_hash_ex(ht, &curl->options.cookies, ZEND_STRL(";"), ZEND_STRL("="), NULL, 0)) {
php_http_buffer_fix(&curl->options.cookies);
if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIE, curl->options.cookies.data)) {
return FAILURE;
return FAILURE;
}
} else {
- HashPosition pos;
- php_http_array_hashkey_t cookie_key = php_http_array_hashkey_init(0);
- zval **cookie_val;
+ php_http_arrkey_t cookie_key;
+ zval *cookie_val;
- FOREACH_KEYVAL(pos, val, cookie_key, cookie_val) {
- zval *zv = php_http_ztyp(IS_STRING, *cookie_val);
+ ZEND_HASH_FOREACH_KEY_VAL(ht, cookie_key.h, cookie_key.key, cookie_val)
+ {
+ zend_string *zs = zval_get_string(cookie_val);
- php_http_array_hashkey_stringify(&cookie_key);
- php_http_buffer_appendf(&curl->options.cookies, "%s=%s; ", cookie_key.str, Z_STRVAL_P(zv));
- php_http_array_hashkey_stringfree(&cookie_key);
+ php_http_arrkey_stringify(&cookie_key, NULL);
+ php_http_buffer_appendf(&curl->options.cookies, "%s=%s; ", cookie_key.key->val, zs->val);
+ php_http_arrkey_dtor(&cookie_key);
- zval_ptr_dtor(&zv);
+ zend_string_release(zs);
}
+ ZEND_HASH_FOREACH_END();
php_http_buffer_fix(&curl->options.cookies);
if (curl->options.cookies.used) {
return SUCCESS;
}
-static STATUS php_http_curle_option_set_encodecookies(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_encodecookies(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
- curl->options.encode_cookies = Z_BVAL_P(val);
+ curl->options.encode_cookies = Z_TYPE_P(val) == IS_TRUE;
return SUCCESS;
}
-static STATUS php_http_curle_option_set_lastmodified(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_lastmodified(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (Z_LVAL_P(val)) {
if (Z_LVAL_P(val) > 0) {
return FAILURE;
}
} else {
- if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, (long) sapi_get_request_time(TSRMLS_C) + Z_LVAL_P(val))) {
+ if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, (long) sapi_get_request_time() + Z_LVAL_P(val))) {
return FAILURE;
}
}
return SUCCESS;
}
-static STATUS php_http_curle_option_set_compress(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_compress(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
+ CURL *ch = curl->handle;
- if (Z_TYPE_P(val) == IS_TRUE) {
- curl->options.headers = curl_slist_append(curl->options.headers, "Accept-Encoding: gzip;q=1.0,deflate;q=0.5");
- if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_ACCEPT_ENCODING, Z_BVAL_P(val) ? "" : NULL)) {
++ if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_ACCEPT_ENCODING, Z_TYPE_P(val) == IS_TRUE ? "" : NULL)) {
+ return FAILURE;
}
return SUCCESS;
}
-static STATUS php_http_curle_option_set_etag(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_etag(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
php_http_buffer_t header;
- if (Z_STRLEN_P(val)) {
+ if (val && Z_TYPE_P(val) == IS_STRING && Z_STRLEN_P(val)) {
zend_bool is_quoted = !((Z_STRVAL_P(val)[0] != '"') || (Z_STRVAL_P(val)[Z_STRLEN_P(val)-1] != '"'));
php_http_buffer_init(&header);
php_http_buffer_appendf(&header, is_quoted?"%s: %s":"%s: \"%s\"", curl->options.range_request?"If-Match":"If-None-Match", Z_STRVAL_P(val));
return SUCCESS;
}
-static STATUS php_http_curle_option_set_range(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_range(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
php_http_buffer_reset(&curl->options.ranges);
if (val && Z_TYPE_P(val) != IS_NULL) {
- HashPosition pos;
- zval **rr, **rb, **re;
-
- FOREACH_VAL(pos, val, rr) {
- if (Z_TYPE_PP(rr) == IS_ARRAY) {
- if (2 == php_http_array_list(Z_ARRVAL_PP(rr) TSRMLS_CC, 2, &rb, &re)) {
- if ( ((Z_TYPE_PP(rb) == IS_LONG) || ((Z_TYPE_PP(rb) == IS_STRING) && is_numeric_string(Z_STRVAL_PP(rb), Z_STRLEN_PP(rb), NULL, NULL, 1))) &&
- ((Z_TYPE_PP(re) == IS_LONG) || ((Z_TYPE_PP(re) == IS_STRING) && is_numeric_string(Z_STRVAL_PP(re), Z_STRLEN_PP(re), NULL, NULL, 1)))) {
- zval *rbl = php_http_ztyp(IS_LONG, *rb);
- zval *rel = php_http_ztyp(IS_LONG, *re);
-
- if ((Z_LVAL_P(rbl) >= 0) && (Z_LVAL_P(rel) >= 0)) {
- php_http_buffer_appendf(&curl->options.ranges, "%ld-%ld,", Z_LVAL_P(rbl), Z_LVAL_P(rel));
+ zval *rr, *rb, *re;
+ zend_long rbl, rel;
+ HashTable *ht = HASH_OF(val);
+
+ ZEND_HASH_FOREACH_VAL(ht, rr)
+ {
+ if (Z_TYPE_P(rr) == IS_ARRAY) {
+ if (2 == php_http_array_list(Z_ARRVAL_P(rr), 2, &rb, &re)) {
+ if ( ((Z_TYPE_P(rb) == IS_LONG) || ((Z_TYPE_P(rb) == IS_STRING) && is_numeric_string(Z_STRVAL_P(rb), Z_STRLEN_P(rb), &rbl, NULL, 1))) &&
+ ((Z_TYPE_P(re) == IS_LONG) || ((Z_TYPE_P(re) == IS_STRING) && is_numeric_string(Z_STRVAL_P(re), Z_STRLEN_P(re), &rel, NULL, 1)))) {
+ if ((rbl >= 0) && (rel >= 0)) {
+ php_http_buffer_appendf(&curl->options.ranges, "%ld-%ld,", rbl, rel);
}
- zval_ptr_dtor(&rbl);
- zval_ptr_dtor(&rel);
}
}
}
}
+ ZEND_HASH_FOREACH_END();
if (curl->options.ranges.used) {
curl->options.range_request = 1;
return SUCCESS;
}
-static STATUS php_http_curle_option_set_resume(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_resume(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
return SUCCESS;
}
-static STATUS php_http_curle_option_set_retrydelay(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_retrydelay(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
return SUCCESS;
}
-static STATUS php_http_curle_option_set_retrycount(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_retrycount(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
return SUCCESS;
}
-static STATUS php_http_curle_option_set_redirect(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_redirect(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
return SUCCESS;
}
-static STATUS php_http_curle_option_set_portrange(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_portrange(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
long localport = 0, localportrange = 0;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (val && Z_TYPE_P(val) != IS_NULL) {
- zval **z_port_start, *zps_copy = NULL, **z_port_end, *zpe_copy = NULL;
+ zval *zps, *zpe;
- switch (php_http_array_list(Z_ARRVAL_P(val) TSRMLS_CC, 2, &z_port_start, &z_port_end)) {
+ switch (php_http_array_list(Z_ARRVAL_P(val), 2, &zps, &zpe)) {
case 2:
- zps_copy = php_http_ztyp(IS_LONG, *z_port_start);
- zpe_copy = php_http_ztyp(IS_LONG, *z_port_end);
- localportrange = labs(Z_LVAL_P(zps_copy)-Z_LVAL_P(zpe_copy))+1L;
+ localportrange = labs(zval_get_long(zps)-zval_get_long(zpe))+1L;
/* no break */
case 1:
- if (!zps_copy) {
- zps_copy = php_http_ztyp(IS_LONG, *z_port_start);
- }
- localport = (zpe_copy && Z_LVAL_P(zpe_copy) > 0) ? MIN(Z_LVAL_P(zps_copy), Z_LVAL_P(zpe_copy)) : Z_LVAL_P(zps_copy);
- zval_ptr_dtor(&zps_copy);
- if (zpe_copy) {
- zval_ptr_dtor(&zpe_copy);
- }
+ localport = (zval_get_long(zpe) > 0) ? MIN(zval_get_long(zps), zval_get_long(zpe)) : zval_get_long(zps);
break;
default:
break;
return SUCCESS;
}
-static STATUS php_http_curle_option_set_proxyheader(php_http_option_t *opt, zval *val, void *userdata)
+ #if PHP_HTTP_CURL_VERSION(7,37,0)
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
++static ZEND_RESULT_CODE php_http_curle_option_set_proxyheader(php_http_option_t *opt, zval *val, void *userdata)
+ {
+ php_http_client_curl_handler_t *curl = userdata;
- php_http_array_hashkey_t header_key = php_http_array_hashkey_init(0);
- zval **header_val, *header_cpy;
- HashPosition pos;
+
+ if (val && Z_TYPE_P(val) != IS_NULL) {
- FOREACH_KEYVAL(pos, val, header_key, header_val) {
- if (header_key.type == HASH_KEY_IS_STRING) {
- header_cpy = php_http_ztyp(IS_STRING, *header_val);
- php_http_buffer_appendf(&header, "%s: %s", header_key.str, Z_STRVAL_P(header_cpy));
++ php_http_arrkey_t header_key;
++ zval *header_val;
+ php_http_buffer_t header;
+
+ php_http_buffer_init(&header);
-
- zval_ptr_dtor(&header_cpy);
++ ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(val), header_key.h, header_key.key, header_val)
++ {
++ if (header_key.key) {
++ zend_string *zs = zval_get_string(header_val);
++ php_http_buffer_appendf(&header, "%s: %s", header_key.key->val, zs->val);
+ php_http_buffer_fix(&header);
+ curl->options.proxyheaders = curl_slist_append(curl->options.proxyheaders, header.data);
+ php_http_buffer_reset(&header);
++ zend_string_release(zs);
+ }
+ }
++ ZEND_HASH_FOREACH_END();
+ php_http_buffer_dtor(&header);
+ }
+ if (CURLE_OK != curl_easy_setopt(curl->handle, CURLOPT_PROXYHEADER, curl->options.proxyheaders)) {
+ return FAILURE;
+ }
+ if (CURLE_OK != curl_easy_setopt(curl->handle, CURLOPT_HEADEROPT, CURLHEADER_SEPARATE)) {
+ curl_easy_setopt(curl->handle, CURLOPT_PROXYHEADER, NULL);
+ return FAILURE;
+ }
+ return SUCCESS;
+ }
+ #endif
+
#if PHP_HTTP_CURL_VERSION(7,21,3)
-static STATUS php_http_curle_option_set_resolve(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_option_set_resolve(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (val && Z_TYPE_P(val) != IS_NULL) {
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
- HashPosition pos;
- zval **data;
+ HashTable *ht = HASH_OF(val);
+ zval *data;
- FOREACH_KEYVAL(pos, val, key, data) {
- zval *cpy = php_http_ztyp(IS_STRING, *data);
- curl->options.resolve = curl_slist_append(curl->options.resolve, Z_STRVAL_P(cpy));
- zval_ptr_dtor(&cpy);
+ ZEND_HASH_FOREACH_VAL(ht, data)
+ {
+ zend_string *zs = zval_get_string(data);
+ curl->options.resolve = curl_slist_append(curl->options.resolve, zs->val);
+ zend_string_release(zs);
}
+ ZEND_HASH_FOREACH_END();
if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_RESOLVE, curl->options.resolve)) {
return FAILURE;
}
#endif
-#if PHP_HTTP_CURL_VERSION(7,21,4)
-static STATUS php_http_curle_option_set_ssl_tlsauthtype(php_http_option_t *opt, zval *val, void *userdata)
++#if PHP_HTTP_CURL_VERSION(7,21,4) && defined(PHP_HTTP_CURL_TLSAUTH_SRP)
++static ZEND_RESULT_CODE php_http_curle_option_set_ssl_tlsauthtype(php_http_option_t *opt, zval *val, void *userdata)
+ {
+ php_http_client_curl_handler_t *curl = userdata;
+ CURL *ch = curl->handle;
+
+ if (val && Z_LVAL_P(val)) {
+ switch (Z_LVAL_P(val)) {
+ case CURL_TLSAUTH_SRP:
+ if (CURLE_OK == curl_easy_setopt(ch, CURLOPT_TLSAUTH_TYPE, PHP_HTTP_CURL_TLSAUTH_SRP)) {
+ return SUCCESS;
+ }
+ /* no break */
+ default:
+ return FAILURE;
+ }
+ }
+ if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TLSAUTH_TYPE, PHP_HTTP_CURL_TLSAUTH_DEF)) {
+ return FAILURE;
+ }
+ return SUCCESS;
+ }
+ #endif
+
-static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
+static void php_http_curle_options_init(php_http_options_t *registry)
{
php_http_option_t *opt;
if ((opt = php_http_option_register(registry, ZEND_STRL("proxyauthtype"), CURLOPT_PROXYAUTH, IS_LONG))) {
Z_LVAL(opt->defval) = CURLAUTH_ANYSAFE;
}
- php_http_option_register(registry, ZEND_STRL("proxytunnel"), CURLOPT_HTTPPROXYTUNNEL, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("proxytunnel"), CURLOPT_HTTPPROXYTUNNEL, _IS_BOOL);
#if PHP_HTTP_CURL_VERSION(7,19,4)
php_http_option_register(registry, ZEND_STRL("noproxy"), CURLOPT_NOPROXY, IS_STRING);
#endif
+ #if PHP_HTTP_CURL_VERSION(7,37,0)
+ if ((opt = php_http_option_register(registry, ZEND_STRL("proxyheader"), CURLOPT_PROXYHEADER, IS_ARRAY))) {
+ opt->setter = php_http_curle_option_set_proxyheader;
+ }
+ #endif
+
+ #if PHP_HTTP_CURL_VERSION(7,40,0)
+ if ((opt = php_http_option_register(registry, ZEND_STRL("unix_socket_path"), CURLOPT_UNIX_SOCKET_PATH, IS_STRING))) {
+ opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
+ opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
+ }
+ #endif
+
/* dns */
if ((opt = php_http_option_register(registry, ZEND_STRL("dns_cache_timeout"), CURLOPT_DNS_CACHE_TIMEOUT, IS_LONG))) {
Z_LVAL(opt->defval) = 60;
Z_LVAL(opt->defval) = 5;
}
*/
- php_http_option_register(registry, ZEND_STRL("fresh_connect"), CURLOPT_FRESH_CONNECT, IS_BOOL);
- php_http_option_register(registry, ZEND_STRL("forbid_reuse"), CURLOPT_FORBID_REUSE, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("fresh_connect"), CURLOPT_FRESH_CONNECT, _IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("forbid_reuse"), CURLOPT_FORBID_REUSE, _IS_BOOL);
/* outgoing interface */
php_http_option_register(registry, ZEND_STRL("interface"), CURLOPT_INTERFACE, IS_STRING);
if ((opt = php_http_option_register(registry, ZEND_STRL("redirect"), CURLOPT_FOLLOWLOCATION, IS_LONG))) {
opt->setter = php_http_curle_option_set_redirect;
}
- php_http_option_register(registry, ZEND_STRL("unrestricted_auth"), CURLOPT_UNRESTRICTED_AUTH, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("unrestricted_auth"), CURLOPT_UNRESTRICTED_AUTH, _IS_BOOL);
#if PHP_HTTP_CURL_VERSION(7,19,1)
php_http_option_register(registry, ZEND_STRL("postredir"), CURLOPT_POSTREDIR, IS_LONG);
#endif
if ((opt = php_http_option_register(registry, ZEND_STRL("referer"), CURLOPT_REFERER, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
}
- if ((opt = php_http_option_register(registry, ZEND_STRL("autoreferer"), CURLOPT_AUTOREFERER, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("autoreferer"), CURLOPT_AUTOREFERER, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
/* useragent */
if ((opt = php_http_option_register(registry, ZEND_STRL("useragent"), CURLOPT_USERAGENT, IS_STRING))) {
/* don't check strlen, to allow sending no useragent at all */
- ZVAL_STRING(&opt->defval,
+ ZVAL_PSTRING(&opt->defval,
"PECL_HTTP/" PHP_PECL_HTTP_VERSION " "
"PHP/" PHP_VERSION " "
- "libcurl/" LIBCURL_VERSION
- , 0);
+ "libcurl/" LIBCURL_VERSION);
}
/* resume */
}
/* compression */
- if ((opt = php_http_option_register(registry, ZEND_STRL("compress"), 0, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("compress"), 0, _IS_BOOL))) {
opt->setter = php_http_curle_option_set_compress;
}
}
/* cookies */
- if ((opt = php_http_option_register(registry, ZEND_STRL("encodecookies"), 0, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("encodecookies"), 0, _IS_BOOL))) {
opt->setter = php_http_curle_option_set_encodecookies;
ZVAL_BOOL(&opt->defval, 1);
}
}
/* cookiesession, don't load session cookies from cookiestore */
- php_http_option_register(registry, ZEND_STRL("cookiesession"), CURLOPT_COOKIESESSION, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("cookiesession"), CURLOPT_COOKIESESSION, _IS_BOOL);
/* cookiestore, read initial cookies from that file and store cookies back into that file */
if ((opt = php_http_option_register(registry, ZEND_STRL("cookiestore"), 0, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
#endif
/* tcp */
- php_http_option_register(registry, ZEND_STRL("tcp_nodelay"), CURLOPT_TCP_NODELAY, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("tcp_nodelay"), CURLOPT_TCP_NODELAY, _IS_BOOL);
#if PHP_HTTP_CURL_VERSION(7,25,0)
- php_http_option_register(registry, ZEND_STRL("tcp_keepalive"), CURLOPT_TCP_KEEPALIVE, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("tcp_keepalive"), CURLOPT_TCP_KEEPALIVE, _IS_BOOL);
if ((opt = php_http_option_register(registry, ZEND_STRL("tcp_keepidle"), CURLOPT_TCP_KEEPIDLE, IS_LONG))) {
Z_LVAL(opt->defval) = 60;
}
}
if ((opt = php_http_option_register(registry, ZEND_STRL("certtype"), CURLOPT_SSLCERTTYPE, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
- ZVAL_STRING(&opt->defval, "PEM", 0);
+ ZVAL_PSTRING(&opt->defval, "PEM");
}
if ((opt = php_http_option_register(registry, ZEND_STRL("key"), CURLOPT_SSLKEY, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
}
if ((opt = php_http_option_register(registry, ZEND_STRL("keytype"), CURLOPT_SSLKEYTYPE, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
- ZVAL_STRING(&opt->defval, "PEM", 0);
+ ZVAL_PSTRING(&opt->defval, "PEM");
}
if ((opt = php_http_option_register(registry, ZEND_STRL("keypasswd"), CURLOPT_SSLKEYPASSWD, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
}
php_http_option_register(registry, ZEND_STRL("engine"), CURLOPT_SSLENGINE, IS_STRING);
php_http_option_register(registry, ZEND_STRL("version"), CURLOPT_SSLVERSION, IS_LONG);
- if ((opt = php_http_option_register(registry, ZEND_STRL("verifypeer"), CURLOPT_SSL_VERIFYPEER, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("verifypeer"), CURLOPT_SSL_VERIFYPEER, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
- if ((opt = php_http_option_register(registry, ZEND_STRL("verifyhost"), CURLOPT_SSL_VERIFYHOST, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("verifyhost"), CURLOPT_SSL_VERIFYHOST, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
opt->setter = php_http_curle_option_set_ssl_verifyhost;
}
+ #if PHP_HTTP_CURL_VERSION(7,41,0)
+ php_http_option_register(registry, ZEND_STRL("verifystatus"), CURLOPT_SSL_VERIFYSTATUS, IS_BOOL);
+ #endif
php_http_option_register(registry, ZEND_STRL("cipher_list"), CURLOPT_SSL_CIPHER_LIST, IS_STRING);
if ((opt = php_http_option_register(registry, ZEND_STRL("cainfo"), CURLOPT_CAINFO, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
#ifdef PHP_HTTP_CURL_CAINFO
- ZVAL_STRING(&opt->defval, PHP_HTTP_CURL_CAINFO, 0);
+ ZVAL_PSTRING(&opt->defval, PHP_HTTP_CURL_CAINFO);
#endif
}
if ((opt = php_http_option_register(registry, ZEND_STRL("capath"), CURLOPT_CAPATH, IS_STRING))) {
# endif
#endif
#if PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)
- php_http_option_register(registry, ZEND_STRL("certinfo"), CURLOPT_CERTINFO, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("certinfo"), CURLOPT_CERTINFO, _IS_BOOL);
#endif
#if PHP_HTTP_CURL_VERSION(7,36,0)
- if ((opt = php_http_option_register(registry, ZEND_STRL("enable_npn"), CURLOPT_SSL_ENABLE_NPN, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("enable_npn"), CURLOPT_SSL_ENABLE_NPN, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
- if ((opt = php_http_option_register(registry, ZEND_STRL("enable_alpn"), CURLOPT_SSL_ENABLE_ALPN, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("enable_alpn"), CURLOPT_SSL_ENABLE_ALPN, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
-#if PHP_HTTP_CURL_VERSION(7,21,4)
+ #endif
+ #if PHP_HTTP_CURL_VERSION(7,39,0)
+ if ((opt = php_http_option_register(registry, ZEND_STRL("pinned_publickey"), CURLOPT_PINNEDPUBLICKEY, IS_STRING))) {
+ opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
+ opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
+ }
+ #endif
++#if PHP_HTTP_CURL_VERSION(7,21,4) && defined(PHP_HTTP_CURL_TLSAUTH_SRP)
+ if ((opt = php_http_option_register(registry, ZEND_STRL("tlsauthtype"), CURLOPT_TLSAUTH_TYPE, IS_LONG))) {
+ opt->setter = php_http_curle_option_set_ssl_tlsauthtype;
+ }
+ if ((opt = php_http_option_register(registry, ZEND_STRL("tlsauthuser"), CURLOPT_TLSAUTH_USERNAME, IS_STRING))) {
+ opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
+ }
+ if ((opt = php_http_option_register(registry, ZEND_STRL("tlsauthpass"), CURLOPT_TLSAUTH_PASSWORD, IS_STRING))) {
+ opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
+ }
#endif
}
}
zval *option;
if ((option = php_http_option_get(opt, options, NULL))) {
- option = php_http_ztyp(opt->type, option);
- zend_hash_quick_update(&curl->options.cache, opt->name.s, opt->name.l, opt->name.h, &option, sizeof(zval *), NULL);
++ Z_TRY_ADDREF_P(option);
+ convert_to_explicit_type_ex(option, opt->type);
+ zend_hash_update(&curl->options.cache, opt->name, option);
}
return option;
}
-static STATUS php_http_curle_set_option(php_http_option_t *opt, zval *val, void *userdata)
+static ZEND_RESULT_CODE php_http_curle_set_option(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
zval tmp;
CURLcode rc = CURLE_OK;
- STATUS rv = SUCCESS;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
+ ZEND_RESULT_CODE rv = SUCCESS;
if (!val) {
val = &opt->defval;
}
switch (opt->type) {
- case IS_BOOL:
+ case _IS_BOOL:
if (opt->setter) {
rv = opt->setter(opt, val, curl);
- } else if (CURLE_OK != curl_easy_setopt(ch, opt->option, (long) Z_BVAL_P(val))) {
+ } else if (CURLE_OK != curl_easy_setopt(ch, opt->option, (long) (Z_TYPE_P(val) == IS_TRUE))) {
rv = FAILURE;
}
break;
case IS_STRING:
if (opt->setter) {
rv = opt->setter(opt, val, curl);
+ } else if (!val || Z_TYPE_P(val) == IS_NULL) {
+ if (CURLE_OK != (rc = curl_easy_setopt(ch, opt->option, NULL))) {
+ rv = FAILURE;
+ }
} else if ((opt->flags & PHP_HTTP_CURLE_OPTION_CHECK_STRLEN) && !Z_STRLEN_P(val)) {
if (CURLE_OK != (rc = curl_easy_setopt(ch, opt->option, NULL))) {
rv = FAILURE;
}
- } else if ((opt->flags & PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR) && Z_STRVAL_P(val) && SUCCESS != php_check_open_basedir(Z_STRVAL_P(val) TSRMLS_CC)) {
+ } else if ((opt->flags & PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR) && Z_STRVAL_P(val) && SUCCESS != php_check_open_basedir(Z_STRVAL_P(val))) {
if (CURLE_OK != (rc = curl_easy_setopt(ch, opt->option, NULL))) {
rv = FAILURE;
}
break;
}
if (rv != SUCCESS) {
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_easy_strerror(rc));
+ php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_easy_strerror(rc));
}
return rv;
}
/* client ops */
-static STATUS php_http_client_curl_handler_reset(php_http_client_curl_handler_t *curl)
+static ZEND_RESULT_CODE php_http_client_curl_handler_reset(php_http_client_curl_handler_t *curl)
{
CURL *ch = curl->handle;
php_http_curle_storage_t *st;
curl_slist_free_all(curl->options.headers);
curl->options.headers = NULL;
}
+ if (curl->options.proxyheaders) {
+ curl_slist_free_all(curl->options.proxyheaders);
+ curl->options.proxyheaders = NULL;
+ }
php_http_buffer_reset(&curl->options.cookies);
php_http_buffer_reset(&curl->options.ranges);
{
void *handle;
php_http_client_curl_handler_t *handler;
- TSRMLS_FETCH_FROM_CTX(h->ts);
- if (!(handle = php_resource_factory_handle_ctor(rf, NULL TSRMLS_CC))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to initialize curl handle");
+ if (!(handle = php_resource_factory_handle_ctor(rf, NULL))) {
+ php_error_docref(NULL, E_WARNING, "Failed to initialize curl handle");
return NULL;
}
handler->rf = rf;
handler->client = h;
handler->handle = handle;
- handler->request.buffer = php_http_buffer_init(NULL);
- handler->request.parser = php_http_message_parser_init(NULL);
- handler->request.message = php_http_message_init(NULL, 0, NULL);
- handler->response.buffer = php_http_buffer_init(NULL);
- handler->response.parser = php_http_message_parser_init(NULL);
- handler->response.message = php_http_message_init(NULL, 0, NULL);
- handler->response.body = php_http_message_body_init(NULL, NULL TSRMLS_CC);
++ handler->response.body = php_http_message_body_init(NULL, NULL);
+ php_http_buffer_init(&handler->response.headers);
php_http_buffer_init(&handler->options.cookies);
php_http_buffer_init(&handler->options.ranges);
zend_hash_init(&handler->options.cache, 0, NULL, ZVAL_PTR_DTOR, 0);
curl_easy_setopt(handle, CURLOPT_AUTOREFERER, 1L);
curl_easy_setopt(handle, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(handle, CURLOPT_NOPROGRESS, 0L);
- curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, NULL);
- curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, php_http_curle_dummy_callback);
+ curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, php_http_curle_header_callback);
+ curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, php_http_curle_body_callback);
curl_easy_setopt(handle, CURLOPT_DEBUGFUNCTION, php_http_curle_raw_callback);
curl_easy_setopt(handle, CURLOPT_READFUNCTION, php_http_curle_read_callback);
- curl_easy_setopt(handle, CURLOPT_IOCTLFUNCTION, php_http_curle_ioctl_callback);
+ curl_easy_setopt(handle, CURLOPT_SEEKFUNCTION, php_http_curle_seek_callback);
#if PHP_HTTP_CURL_VERSION(7,32,0)
curl_easy_setopt(handle, CURLOPT_XFERINFOFUNCTION, php_http_curle_xferinfo_callback);
curl_easy_setopt(handle, CURLOPT_XFERINFODATA, handler);
curl_easy_setopt(handle, CURLOPT_PROGRESSDATA, handler);
#endif
curl_easy_setopt(handle, CURLOPT_DEBUGDATA, handler);
+ curl_easy_setopt(handle, CURLOPT_WRITEDATA, handler);
+ curl_easy_setopt(handle, CURLOPT_HEADERDATA, handler);
php_http_client_curl_handler_reset(handler);
}
-static STATUS php_http_client_curl_handler_prepare(php_http_client_curl_handler_t *curl, php_http_client_enqueue_t *enqueue)
+static ZEND_RESULT_CODE php_http_client_curl_handler_prepare(php_http_client_curl_handler_t *curl, php_http_client_enqueue_t *enqueue)
{
size_t body_size;
php_http_message_t *msg = enqueue->request;
php_http_curle_storage_t *storage = php_http_curle_get_storage(curl->handle);
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
/* request url */
if (!PHP_HTTP_INFO(msg).request.url) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot request empty URL");
+ php_error_docref(NULL, E_WARNING, "Cannot request empty URL");
return FAILURE;
}
storage->errorbuffer[0] = '\0';
if (PHP_HTTP_INFO(msg).request.method) {
curl_easy_setopt(curl->handle, CURLOPT_CUSTOMREQUEST, PHP_HTTP_INFO(msg).request.method);
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot use empty request method");
+ php_error_docref(NULL, E_WARNING, "Cannot use empty request method");
return FAILURE;
}
break;
}
}
+ /* apply options */
+ php_http_options_apply(&php_http_curle_options, enqueue->options, curl);
+
/* request headers */
php_http_message_update_headers(msg);
if (zend_hash_num_elements(&msg->hdrs)) {
- php_http_array_hashkey_t header_key = php_http_array_hashkey_init(0);
- zval **header_val, *header_cpy;
- HashPosition pos;
+ php_http_arrkey_t header_key;
+ zval *header_val;
+ zend_string *header_str;
php_http_buffer_t header;
#if !PHP_HTTP_CURL_VERSION(7,23,0)
- zval **ct = NULL;
-
- zend_hash_find(&msg->hdrs, ZEND_STRS("Content-Length"), (void *) &ct);
+ zval *ct = zend_hash_str_find(&msg->hdrs, ZEND_STRL("Content-Length"));
#endif
php_http_buffer_init(&header);
- FOREACH_HASH_KEYVAL(pos, &msg->hdrs, header_key, header_val) {
- if (header_key.type == HASH_KEY_IS_STRING) {
+ ZEND_HASH_FOREACH_KEY_VAL(&msg->hdrs, header_key.h, header_key.key, header_val)
+ {
+ if (header_key.key) {
#if !PHP_HTTP_CURL_VERSION(7,23,0)
/* avoid duplicate content-length header */
- if (ct && *ct == *header_val) {
+ if (ct && ct == header_val) {
continue;
}
#endif
- header_cpy = php_http_ztyp(IS_STRING, *header_val);
- php_http_buffer_appendf(&header, "%s: %s", header_key.str, Z_STRVAL_P(header_cpy));
+ header_str = zval_get_string(header_val);
+ php_http_buffer_appendf(&header, "%s: %s", header_key.key->val, header_str->val);
php_http_buffer_fix(&header);
curl->options.headers = curl_slist_append(curl->options.headers, header.data);
php_http_buffer_reset(&header);
-
- zval_ptr_dtor(&header_cpy);
+ zend_string_release(header_str);
}
}
+ ZEND_HASH_FOREACH_END();
php_http_buffer_dtor(&header);
}
curl_easy_setopt(curl->handle, CURLOPT_HTTPHEADER, curl->options.headers);
* does not allow a request body.
*/
php_stream_rewind(php_http_message_body_stream(msg->body));
- curl_easy_setopt(curl->handle, CURLOPT_IOCTLDATA, msg->body);
+ curl_easy_setopt(curl->handle, CURLOPT_SEEKDATA, msg->body);
curl_easy_setopt(curl->handle, CURLOPT_READDATA, msg->body);
curl_easy_setopt(curl->handle, CURLOPT_INFILESIZE, body_size);
curl_easy_setopt(curl->handle, CURLOPT_POSTFIELDSIZE, body_size);
} else {
- curl_easy_setopt(curl->handle, CURLOPT_IOCTLDATA, NULL);
+ curl_easy_setopt(curl->handle, CURLOPT_SEEKDATA, NULL);
curl_easy_setopt(curl->handle, CURLOPT_READDATA, NULL);
curl_easy_setopt(curl->handle, CURLOPT_INFILESIZE, 0L);
curl_easy_setopt(curl->handle, CURLOPT_POSTFIELDSIZE, 0L);
}
- php_http_options_apply(&php_http_curle_options, enqueue->options, curl);
-
return SUCCESS;
}
static void php_http_client_curl_handler_dtor(php_http_client_curl_handler_t *handler)
{
- TSRMLS_FETCH_FROM_CTX(handler->client->ts);
-
php_http_client_curl_handler_clear(handler);
- php_resource_factory_handle_dtor(handler->rf, handler->handle TSRMLS_CC);
+ php_resource_factory_handle_dtor(handler->rf, handler->handle);
php_resource_factory_free(&handler->rf);
- php_http_message_parser_free(&handler->request.parser);
- php_http_message_free(&handler->request.message);
- php_http_buffer_free(&handler->request.buffer);
- php_http_message_parser_free(&handler->response.parser);
- php_http_message_free(&handler->response.message);
- php_http_buffer_free(&handler->response.buffer);
+ php_http_message_body_free(&handler->response.body);
+ php_http_buffer_dtor(&handler->response.headers);
php_http_buffer_dtor(&handler->options.ranges);
php_http_buffer_dtor(&handler->options.cookies);
zend_hash_destroy(&handler->options.cache);
static php_http_client_t *php_http_client_curl_init(php_http_client_t *h, void *handle)
{
php_http_client_curl_t *curl;
- TSRMLS_FETCH_FROM_CTX(h->ts);
- if (!handle && !(handle = php_resource_factory_handle_ctor(h->rf, NULL TSRMLS_CC))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to initialize curl handle");
+ if (!handle && !(handle = php_resource_factory_handle_ctor(h->rf, NULL))) {
+ php_error_docref(NULL, E_WARNING, "Failed to initialize curl handle");
return NULL;
}
static void php_http_client_curl_dtor(php_http_client_t *h)
{
php_http_client_curl_t *curl = h->ctx;
- TSRMLS_FETCH_FROM_CTX(h->ts);
#if PHP_HTTP_HAVE_EVENT
if (curl->timeout) {
#endif
curl->unfinished = 0;
- php_resource_factory_handle_dtor(h->rf, curl->handle TSRMLS_CC);
+ php_resource_factory_handle_dtor(h->rf, curl->handle);
efree(curl);
h->ctx = NULL;
php_http_client_curl_handler_dtor(handler);
}
-static php_resource_factory_t *create_rf(php_http_url_t *url TSRMLS_DC)
+static php_resource_factory_t *create_rf(php_http_url_t *url)
{
php_persistent_handle_factory_t *pf;
php_resource_factory_t *rf = NULL;
+ zend_string *id;
char *id_str = NULL;
size_t id_len;
if (!url || (!url->host && !url->path)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot request empty URL");
+ php_error_docref(NULL, E_WARNING, "Cannot request empty URL");
return NULL;
}
id_len = spprintf(&id_str, 0, "%s:%d", STR_PTR(url->host), url->port ? url->port : 80);
+ id = php_http_cs2zs(id_str, id_len);
+
+ pf = php_persistent_handle_concede(NULL, PHP_HTTP_G->client.curl.driver.request_name, id, NULL, NULL);
+ zend_string_release(id);
- pf = php_persistent_handle_concede(NULL, ZEND_STRL("http\\Client\\Curl\\Request"), id_str, id_len, NULL, NULL TSRMLS_CC);
if (pf) {
rf = php_resource_factory_init(NULL, php_persistent_handle_get_resource_factory_ops(), pf, (void (*)(void*)) php_persistent_handle_abandon);
} else {
rf = php_resource_factory_init(NULL, &php_http_curle_resource_factory_ops, NULL, NULL);
}
- efree(id_str);
+ zend_string_release(id);
return rf;
}
-static STATUS php_http_client_curl_enqueue(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
+static ZEND_RESULT_CODE php_http_client_curl_enqueue(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
{
CURLMcode rs;
php_http_client_curl_t *curl = h->ctx;
php_http_client_curl_handler_t *handler;
php_http_client_progress_state_t *progress;
php_resource_factory_t *rf;
- TSRMLS_FETCH_FROM_CTX(h->ts);
- rf = create_rf(enqueue->request->http.info.request.url TSRMLS_CC);
+ rf = create_rf(enqueue->request->http.info.request.url);
if (!rf) {
return FAILURE;
}
return SUCCESS;
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not enqueue request: %s", curl_multi_strerror(rs));
+ php_error_docref(NULL, E_WARNING, "Could not enqueue request: %s", curl_multi_strerror(rs));
return FAILURE;
}
}
-static STATUS php_http_client_curl_dequeue(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
+static ZEND_RESULT_CODE php_http_client_curl_dequeue(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
{
CURLMcode rs;
php_http_client_curl_t *curl = h->ctx;
php_http_client_curl_handler_t *handler = enqueue->opaque;
- TSRMLS_FETCH_FROM_CTX(h->ts);
php_http_client_curl_handler_clear(handler);
if (CURLM_OK == (rs = curl_multi_remove_handle(curl->handle, handler->handle))) {
zend_llist_del_element(&h->requests, handler->handle, (int (*)(void *, void *)) compare_queue);
return SUCCESS;
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not dequeue request: %s", curl_multi_strerror(rs));
+ php_error_docref(NULL, E_WARNING, "Could not dequeue request: %s", curl_multi_strerror(rs));
}
return FAILURE;
# define SELECT_ERROR -1
#endif
-static STATUS php_http_client_curl_wait(php_http_client_t *h, struct timeval *custom_timeout)
+static ZEND_RESULT_CODE php_http_client_curl_wait(php_http_client_t *h, struct timeval *custom_timeout)
{
int MAX;
fd_set R, W, E;
}
-static STATUS php_http_client_curl_exec(php_http_client_t *h)
+static ZEND_RESULT_CODE php_http_client_curl_exec(php_http_client_t *h)
{
#if PHP_HTTP_HAVE_EVENT
php_http_client_curl_t *curl = h->ctx;
-#endif
- TSRMLS_FETCH_FROM_CTX(h->ts);
-#if PHP_HTTP_HAVE_EVENT
if (curl->useevents) {
php_http_curlm_timeout_callback(CURL_SOCKET_TIMEOUT, /*EV_READ|EV_WRITE*/0, h);
do {
#endif
if (ev_rc < 0) {
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in event_base_dispatch()");
+ php_error_docref(NULL, E_ERROR, "Error in event_base_dispatch()");
return FAILURE;
}
} while (curl->unfinished);
if (SUCCESS != php_http_client_curl_wait(h, NULL)) {
#ifdef PHP_WIN32
/* see http://msdn.microsoft.com/library/en-us/winsock/winsock/windows_sockets_error_codes_2.asp */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "WinSock error: %d", WSAGetLastError());
+ php_error_docref(NULL, E_WARNING, "WinSock error: %d", WSAGetLastError());
#else
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
+ php_error_docref(NULL, E_WARNING, "%s", strerror(errno));
#endif
return FAILURE;
}
return SUCCESS;
}
-static STATUS php_http_client_curl_setopt(php_http_client_t *h, php_http_client_setopt_opt_t opt, void *arg)
+static ZEND_RESULT_CODE php_http_client_curl_setopt(php_http_client_t *h, php_http_client_setopt_opt_t opt, void *arg)
{
php_http_client_curl_t *curl = h->ctx;
return SUCCESS;
}
-static STATUS php_http_client_curl_getopt(php_http_client_t *h, php_http_client_getopt_opt_t opt, void *arg, void **res)
+static ZEND_RESULT_CODE php_http_client_curl_getopt(php_http_client_t *h, php_http_client_getopt_opt_t opt, void *arg, void **res)
{
php_http_client_enqueue_t *enqueue;
PHP_MINIT_FUNCTION(http_client_curl)
{
php_http_options_t *options;
- php_http_client_driver_t driver;
- php_http_client_driver_t driver = {
- ZEND_STRL("curl"),
- &php_http_client_curl_ops
- };
- if (SUCCESS != php_http_client_driver_add(&driver)) {
- return FAILURE;
- }
+ PHP_HTTP_G->client.curl.driver.driver_name = zend_string_init(ZEND_STRL("curl"), 1);
+ PHP_HTTP_G->client.curl.driver.client_name = zend_string_init(ZEND_STRL("http\\Client\\Curl"), 1);
+ PHP_HTTP_G->client.curl.driver.request_name = zend_string_init(ZEND_STRL("http\\Client\\Curl\\Request"), 1);
+ PHP_HTTP_G->client.curl.driver.client_ops = &php_http_client_curl_ops;
+
+ if (SUCCESS != php_http_client_driver_add(&PHP_HTTP_G->client.curl.driver)) {
+ return FAILURE;
+ }
- if (SUCCESS != php_persistent_handle_provide(ZEND_STRL("http\\Client\\Curl"), &php_http_curlm_resource_factory_ops, NULL, NULL TSRMLS_CC)) {
+ if (SUCCESS != php_persistent_handle_provide(PHP_HTTP_G->client.curl.driver.client_name, &php_http_curlm_resource_factory_ops, NULL, NULL)) {
return FAILURE;
}
- if (SUCCESS != php_persistent_handle_provide(ZEND_STRL("http\\Client\\Curl\\Request"), &php_http_curle_resource_factory_ops, NULL, NULL TSRMLS_CC)) {
+ if (SUCCESS != php_persistent_handle_provide(PHP_HTTP_G->client.curl.driver.request_name, &php_http_curle_resource_factory_ops, NULL, NULL)) {
return FAILURE;
}
options->getter = php_http_curle_get_option;
options->setter = php_http_curle_set_option;
- php_http_curle_options_init(options TSRMLS_CC);
+ php_http_curle_options_init(options);
}
/*
*/
REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "HTTP_VERSION_1_0", CURL_HTTP_VERSION_1_0, CONST_CS|CONST_PERSISTENT);
REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "HTTP_VERSION_1_1", CURL_HTTP_VERSION_1_1, CONST_CS|CONST_PERSISTENT);
+ #if PHP_HTTP_CURL_VERSION(7,33,0)
+ REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "HTTP_VERSION_2_0", CURL_HTTP_VERSION_2_0, CONST_CS|CONST_PERSISTENT);
+ #endif
REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "HTTP_VERSION_ANY", CURL_HTTP_VERSION_NONE, CONST_CS|CONST_PERSISTENT);
/*
REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "SSL_VERSION_SSLv2", CURL_SSLVERSION_SSLv2, CONST_CS|CONST_PERSISTENT);
REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "SSL_VERSION_SSLv3", CURL_SSLVERSION_SSLv3, CONST_CS|CONST_PERSISTENT);
REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "SSL_VERSION_ANY", CURL_SSLVERSION_DEFAULT, CONST_CS|CONST_PERSISTENT);
+ #if PHP_HTTP_CURL_VERSION(7,21,4)
+ REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "TLSAUTH_SRP", CURL_TLSAUTH_SRP, CONST_CS|CONST_PERSISTENT);
+ #endif
/*
* DNS IPvX resolving
PHP_MSHUTDOWN_FUNCTION(http_client_curl)
{
- php_persistent_handle_cleanup(ZEND_STRL("http\\Client\\Curl"), NULL, 0 TSRMLS_CC);
- php_persistent_handle_cleanup(ZEND_STRL("http\\Client\\Curl\\Request"), NULL, 0 TSRMLS_CC);
+ php_persistent_handle_cleanup(PHP_HTTP_G->client.curl.driver.client_name, NULL);
+ php_persistent_handle_cleanup(PHP_HTTP_G->client.curl.driver.request_name, NULL);
+ zend_string_release(PHP_HTTP_G->client.curl.driver.client_name);
+ zend_string_release(PHP_HTTP_G->client.curl.driver.request_name);
+ zend_string_release(PHP_HTTP_G->client.curl.driver.driver_name);
php_http_options_dtor(&php_http_curle_options);
#include "php_http_api.h"
-php_http_cookie_list_t *php_http_cookie_list_init(php_http_cookie_list_t *list TSRMLS_DC)
+php_http_cookie_list_t *php_http_cookie_list_init(php_http_cookie_list_t *list)
{
if (!list) {
list = emalloc(sizeof(*list));
list->max_age = -1;
list->flags = 0;
- TSRMLS_SET_CTX(list->ts);
-
return list;
}
php_http_cookie_list_t *php_http_cookie_list_copy(php_http_cookie_list_t *from, php_http_cookie_list_t *to)
{
- TSRMLS_FETCH_FROM_CTX(from->ts);
-
- to = php_http_cookie_list_init(to TSRMLS_CC);
+ to = php_http_cookie_list_init(to);
array_copy(&from->cookies, &to->cookies);
array_copy(&from->extras, &to->extras);
}
}
-const char *php_http_cookie_list_get_cookie(php_http_cookie_list_t *list, const char *name, size_t name_len, zval **zcookie)
+const char *php_http_cookie_list_get_cookie(php_http_cookie_list_t *list, const char *name, size_t name_len, zval *zcookie)
{
- zval **cookie;
- if ((SUCCESS != zend_symtable_find(&list->cookies, name, name_len + 1, (void *) &cookie)) || (Z_TYPE_PP(cookie) != IS_STRING)) {
+ zval *cookie = zend_symtable_str_find(&list->cookies, name, name_len);
+
+ if (!cookie || (Z_TYPE_P(cookie) != IS_STRING)) {
return NULL;
}
if (zcookie) {
*zcookie = *cookie;
}
- return Z_STRVAL_PP(cookie);
+ return Z_STRVAL_P(cookie);
}
-const char *php_http_cookie_list_get_extra(php_http_cookie_list_t *list, const char *name, size_t name_len, zval **zextra)
+const char *php_http_cookie_list_get_extra(php_http_cookie_list_t *list, const char *name, size_t name_len, zval *zextra)
{
- zval **extra;
+ zval *extra = zend_symtable_str_find(&list->extras, name, name_len);
- if ((SUCCESS != zend_symtable_find(&list->extras, name, name_len + 1, (void *) &extra)) || (Z_TYPE_PP(extra) != IS_STRING)) {
+ if (!extra || (Z_TYPE_P(extra) != IS_STRING)) {
return NULL;
}
if (zextra) {
*zextra = *extra;
}
- return Z_STRVAL_PP(extra);
+ return Z_STRVAL_P(extra);
}
void php_http_cookie_list_add_cookie(php_http_cookie_list_t *list, const char *name, size_t name_len, const char *value, size_t value_len)
{
- zval *cookie_value;
+ zval cookie_value;
- MAKE_STD_ZVAL(cookie_value);
- ZVAL_STRINGL(cookie_value, estrndup(value, value_len), value_len, 0);
- zend_symtable_update(&list->cookies, name, name_len + 1, (void *) &cookie_value, sizeof(zval *), NULL);
+ ZVAL_STRINGL(&cookie_value, value, value_len);
+ zend_symtable_str_update(&list->cookies, name, name_len, &cookie_value);
}
void php_http_cookie_list_add_extra(php_http_cookie_list_t *list, const char *name, size_t name_len, const char *value, size_t value_len)
{
- zval *cookie_value;
+ zval extra_value;
- MAKE_STD_ZVAL(cookie_value);
- ZVAL_STRINGL(cookie_value, estrndup(value, value_len), value_len, 0);
- zend_symtable_update(&list->extras, name, name_len + 1, (void *) &cookie_value, sizeof(zval *), NULL);
+ ZVAL_STRINGL(&extra_value, value, value_len);
+ zend_symtable_str_update(&list->extras, name, name_len, &extra_value);
}
-#define _KEY_IS(s) (key->len == sizeof(s) && !strncasecmp(key->str, (s), key->len))
-static void add_entry(php_http_cookie_list_t *list, char **allowed_extras, long flags, php_http_array_hashkey_t *key, zval *val)
+#define _KEY_IS(s) (key->key && key->key->len == sizeof(s)-1 && !strncasecmp(key->key->val, (s), key->key->len))
+static void add_entry(php_http_cookie_list_t *list, char **allowed_extras, long flags, zend_hash_key *key, zval *val)
{
- zval *arg = php_http_zsep(1, IS_STRING, val);
+ zval arg;
+
+ ZVAL_DUP(&arg, val);
+ convert_to_string(&arg);
if (!(flags & PHP_HTTP_COOKIE_PARSE_RAW)) {
- Z_STRLEN_P(arg) = php_raw_url_decode(Z_STRVAL_P(arg), Z_STRLEN_P(arg));
+ Z_STRLEN(arg) = php_raw_url_decode(Z_STRVAL(arg), Z_STRLEN(arg));
+ zend_string_forget_hash_val(Z_STR(arg));
}
if _KEY_IS("path") {
- PTR_SET(list->path, estrndup(Z_STRVAL_P(arg), Z_STRLEN_P(arg)));
+ PTR_SET(list->path, estrndup(Z_STRVAL(arg), Z_STRLEN(arg)));
} else if _KEY_IS("domain") {
- PTR_SET(list->domain, estrndup(Z_STRVAL_P(arg), Z_STRLEN_P(arg)));
+ PTR_SET(list->domain, estrndup(Z_STRVAL(arg), Z_STRLEN(arg)));
} else if _KEY_IS("expires") {
- char *date = estrndup(Z_STRVAL_P(arg), Z_STRLEN_P(arg));
+ char *date = estrndup(Z_STRVAL(arg), Z_STRLEN(arg));
list->expires = php_parse_date(date, NULL);
efree(date);
} else if _KEY_IS("max-age") {
- list->max_age = strtol(Z_STRVAL_P(arg), NULL, 10);
+ list->max_age = zval_get_long(val);
} else if _KEY_IS("secure") {
list->flags |= PHP_HTTP_COOKIE_SECURE;
} else if _KEY_IS("httpOnly") {
list->flags |= PHP_HTTP_COOKIE_HTTPONLY;
} else {
+ php_http_arrkey_t tmp = {0};
+
+ php_http_arrkey_stringify(&tmp, key);
+
/* check for extra */
if (allowed_extras) {
char **ae = allowed_extras;
-
- php_http_array_hashkey_stringify(key);
for (; *ae; ++ae) {
- if (!strncasecmp(key->str, *ae, key->len)) {
- if (key->type == HASH_KEY_IS_LONG) {
- zend_hash_index_update(&list->extras, key->num, (void *) &arg, sizeof(zval *), NULL);
- } else {
- zend_hash_update(&list->extras, key->str, key->len, (void *) &arg, sizeof(zval *), NULL);
- }
- php_http_array_hashkey_stringfree(key);
+ if (!strncasecmp(*ae, tmp.key->val, tmp.key->len)) {
+ zend_symtable_update(&list->extras, tmp.key, &arg);
+ php_http_arrkey_dtor(&tmp);
return;
}
}
- php_http_array_hashkey_stringfree(key);
}
/* cookie */
- if (key->type == HASH_KEY_IS_LONG) {
- zend_hash_index_update(&list->cookies, key->num, (void *) &arg, sizeof(zval *), NULL);
- } else {
- zend_hash_update(&list->cookies, key->str, key->len, (void *) &arg, sizeof(zval *), NULL);
- }
+ zend_symtable_update(&list->cookies, tmp.key, &arg);
+
+ php_http_arrkey_dtor(&tmp);
return;
}
+
zval_ptr_dtor(&arg);
}
-php_http_cookie_list_t *php_http_cookie_list_parse(php_http_cookie_list_t *list, const char *str, size_t len, long flags, char **allowed_extras TSRMLS_DC)
+php_http_cookie_list_t *php_http_cookie_list_parse(php_http_cookie_list_t *list, const char *str, size_t len, long flags, char **allowed_extras)
{
php_http_params_opts_t opts;
HashTable params;
- HashPosition pos1, pos2;
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
- zval **param, **val, **args, **arg;
+ zend_hash_key k, arg_k;
+ zval *param, *val, *args, *arg;
php_http_params_opts_default_get(&opts);
opts.input.str = estrndup(str, len);
opts.input.len = len;
opts.param = NULL;
zend_hash_init(¶ms, 10, NULL, ZVAL_PTR_DTOR, 0);
- php_http_params_parse(¶ms, &opts TSRMLS_CC);
+ php_http_params_parse(¶ms, &opts);
efree(opts.input.str);
- list = php_http_cookie_list_init(list TSRMLS_CC);
- FOREACH_HASH_KEYVAL(pos1, ¶ms, key, param) {
- if (Z_TYPE_PP(param) == IS_ARRAY) {
- if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(param), ZEND_STRS("value"), (void *) &val)) {
- add_entry(list, NULL, flags, &key, *val);
+ list = php_http_cookie_list_init(list);
+ ZEND_HASH_FOREACH_KEY_VAL(¶ms, k.h, k.key, param)
+ {
+ if (Z_TYPE_P(param) == IS_ARRAY) {
+ if ((val = zend_hash_str_find(Z_ARRVAL_P(param), ZEND_STRL("value")))) {
+ add_entry(list, NULL, flags, &k, val);
}
- if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(param), ZEND_STRS("arguments"), (void *) &args) && Z_TYPE_PP(args) == IS_ARRAY) {
- FOREACH_KEYVAL(pos2, *args, key, arg) {
- add_entry(list, allowed_extras, flags, &key, *arg);
+ if ((args = zend_hash_str_find(Z_ARRVAL_P(param), ZEND_STRL("arguments"))) && Z_TYPE_P(args) == IS_ARRAY) {
+ ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(args), arg_k.h, arg_k.key, arg)
+ {
+ add_entry(list, allowed_extras, flags, &arg_k, arg);
}
+ ZEND_HASH_FOREACH_END();
}
}
}
+ ZEND_HASH_FOREACH_END();
+
zend_hash_destroy(¶ms);
return list;
void php_http_cookie_list_to_struct(php_http_cookie_list_t *list, zval *strct)
{
- zval array, *cookies, *extras;
- TSRMLS_FETCH_FROM_CTX(list->ts);
-
- INIT_PZVAL_ARRAY(&array, HASH_OF(strct));
+ zval cookies, extras, tmp;
+ HashTable *ht = HASH_OF(strct);
- MAKE_STD_ZVAL(cookies);
- array_init(cookies);
- zend_hash_copy(Z_ARRVAL_P(cookies), &list->cookies, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
- add_assoc_zval(&array, "cookies", cookies);
+ array_init_size(&cookies, zend_hash_num_elements(&list->cookies));
+ array_copy(&list->cookies, Z_ARRVAL(cookies));
+ zend_symtable_str_update(ht, ZEND_STRL("cookies"), &cookies);
- MAKE_STD_ZVAL(extras);
- array_init(extras);
- zend_hash_copy(Z_ARRVAL_P(extras), &list->extras, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
- add_assoc_zval(&array, "extras", extras);
+ array_init_size(&extras, zend_hash_num_elements(&list->extras));
+ array_copy(&list->extras, Z_ARRVAL(extras));
+ zend_symtable_str_update(ht, ZEND_STRL("extras"), &extras);
- add_assoc_long(&array, "flags", list->flags);
- add_assoc_long(&array, "expires", (long) list->expires);
- add_assoc_long(&array, "max-age", (long) list->max_age);
- add_assoc_string(&array, "path", STR_PTR(list->path), 1);
- add_assoc_string(&array, "domain", STR_PTR(list->domain), 1);
+ ZVAL_LONG(&tmp, list->flags);
+ zend_symtable_str_update(ht, ZEND_STRL("flags"), &tmp);
+ ZVAL_LONG(&tmp, list->expires);
+ zend_symtable_str_update(ht, ZEND_STRL("expires"), &tmp);
+ ZVAL_LONG(&tmp, list->max_age);
+ zend_symtable_str_update(ht, ZEND_STRL("max-age"), &tmp);
+ ZVAL_STRING(&tmp, STR_PTR(list->path));
+ zend_symtable_str_update(ht, ZEND_STRL("path"), &tmp);
+ ZVAL_STRING(&tmp, STR_PTR(list->domain));
+ zend_symtable_str_update(ht, ZEND_STRL("domain"), &tmp);
}
-php_http_cookie_list_t *php_http_cookie_list_from_struct(php_http_cookie_list_t *list, zval *strct TSRMLS_DC)
+php_http_cookie_list_t *php_http_cookie_list_from_struct(php_http_cookie_list_t *list, zval *strct)
{
- zval **tmp, *cpy;
- HashTable *ht = HASH_OF(strct);
-
- list = php_http_cookie_list_init(list TSRMLS_CC);
-
- if (SUCCESS == zend_hash_find(ht, "cookies", sizeof("cookies"), (void *) &tmp) && Z_TYPE_PP(tmp) == IS_ARRAY) {
- zend_hash_copy(&list->cookies, Z_ARRVAL_PP(tmp), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ zval *tmp;
+ HashTable *ht;
+
+ ht = HASH_OF(strct);
+ list = php_http_cookie_list_init(list);
+
+ if ((tmp = zend_hash_str_find_ind(ht, ZEND_STRL("cookies"))) && Z_TYPE_P(tmp) == IS_ARRAY){
+ array_copy(Z_ARRVAL_P(tmp), &list->cookies);
}
- if (SUCCESS == zend_hash_find(ht, "extras", sizeof("extras"), (void *) &tmp) && Z_TYPE_PP(tmp) == IS_ARRAY) {
- zend_hash_copy(&list->extras, Z_ARRVAL_PP(tmp), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ if ((tmp = zend_hash_str_find_ind(ht, ZEND_STRL("extras"))) && Z_TYPE_P(tmp) == IS_ARRAY){
+ array_copy(Z_ARRVAL_P(tmp), &list->extras);
}
- if (SUCCESS == zend_hash_find(ht, "flags", sizeof("flags"), (void *) &tmp)) {
- cpy = php_http_ztyp(IS_LONG, *tmp);
- list->flags = Z_LVAL_P(cpy);
- zval_ptr_dtor(&cpy);
+ if ((tmp = zend_hash_str_find_ind(ht, ZEND_STRL("flags")))) {
+ list->flags = zval_get_long(tmp);
}
- if (SUCCESS == zend_hash_find(ht, "expires", sizeof("expires"), (void *) &tmp)) {
- if (Z_TYPE_PP(tmp) == IS_LONG) {
- list->expires = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find_ind(ht, ZEND_STRL("expires")))) {
+ if (Z_TYPE_P(tmp) == IS_LONG) {
+ list->expires = Z_LVAL_P(tmp);
} else {
- long lval;
+ zend_long lval;
+ zend_string *lstr = zval_get_string(tmp);
- cpy = php_http_ztyp(IS_STRING, *tmp);
- if (IS_LONG == is_numeric_string(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy), &lval, NULL, 0)) {
+ if (IS_LONG == is_numeric_string(lstr->val, lstr->len, &lval, NULL, 0)) {
list->expires = lval;
} else {
- list->expires = php_parse_date(Z_STRVAL_P(cpy), NULL);
+ list->expires = php_parse_date(lstr->val, NULL);
}
- zval_ptr_dtor(&cpy);
+ zend_string_release(lstr);
}
}
- if (SUCCESS == zend_hash_find(ht, "max-age", sizeof("max-age"), (void *) &tmp)) {
- if (Z_TYPE_PP(tmp) == IS_LONG) {
- list->max_age = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find_ind(ht, ZEND_STRL("max-age")))) {
+ if (Z_TYPE_P(tmp) == IS_LONG) {
+ list->max_age = Z_LVAL_P(tmp);
} else {
- long lval;
+ zend_long lval;
+ zend_string *lstr = zval_get_string(tmp);
- cpy = php_http_ztyp(IS_STRING, *tmp);
- if (IS_LONG == is_numeric_string(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy), &lval, NULL, 0)) {
+ if (IS_LONG == is_numeric_string(lstr->val, lstr->len, &lval, NULL, 0)) {
list->max_age = lval;
}
- zval_ptr_dtor(&cpy);
+ zend_string_release(lstr);
}
}
- if (SUCCESS == zend_hash_find(ht, "path", sizeof("path"), (void *) &tmp) && Z_TYPE_PP(tmp) == IS_STRING) {
- list->path = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find_ind(ht, ZEND_STRL("path")))) {
+ zend_string *str = zval_get_string(tmp);
+
+ list->path = estrndup(str->val, str->len);
+ zend_string_release(str);
}
- if (SUCCESS == zend_hash_find(ht, "domain", sizeof("domain"), (void *) &tmp) && Z_TYPE_PP(tmp) == IS_STRING) {
- list->domain = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find_ind(ht, ZEND_STRL("domain")))) {
+ zend_string *str = zval_get_string(tmp);
+
+ list->domain = estrndup(str->val, str->len);
+ zend_string_release(str);
}
return list;
static inline void append_encoded(php_http_buffer_t *buf, const char *key, size_t key_len, const char *val, size_t val_len)
{
- char *enc_str[2];
- int enc_len[2];
+ zend_string *enc_str[2];
- enc_str[0] = php_raw_url_encode(key, key_len, &enc_len[0]);
- enc_str[1] = php_raw_url_encode(val, val_len, &enc_len[1]);
+ enc_str[0] = php_raw_url_encode(key, key_len);
+ enc_str[1] = php_raw_url_encode(val, val_len);
- php_http_buffer_append(buf, enc_str[0], enc_len[0]);
+ php_http_buffer_append(buf, enc_str[0]->val, enc_str[0]->len);
php_http_buffer_appends(buf, "=");
- php_http_buffer_append(buf, enc_str[1], enc_len[1]);
+ php_http_buffer_append(buf, enc_str[1]->val, enc_str[1]->len);
php_http_buffer_appends(buf, "; ");
- efree(enc_str[0]);
- efree(enc_str[1]);
+ zend_string_release(enc_str[0]);
+ zend_string_release(enc_str[1]);
}
void php_http_cookie_list_to_string(php_http_cookie_list_t *list, char **str, size_t *len)
{
php_http_buffer_t buf;
- zval **val;
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
- HashPosition pos;
- TSRMLS_FETCH_FROM_CTX(list->ts);
+ zend_hash_key key;
+ zval *val;
php_http_buffer_init(&buf);
-
- FOREACH_HASH_KEYVAL(pos, &list->cookies, key, val) {
- zval *tmp = php_http_ztyp(IS_STRING, *val);
- php_http_array_hashkey_stringify(&key);
- append_encoded(&buf, key.str, key.len-1, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
- php_http_array_hashkey_stringfree(&key);
+ ZEND_HASH_FOREACH_KEY_VAL(&list->cookies, key.h, key.key, val)
+ {
+ zend_string *str = zval_get_string(val);
+ php_http_arrkey_t arrkey = {0};
- zval_ptr_dtor(&tmp);
+ php_http_arrkey_stringify(&arrkey, &key);
+ append_encoded(&buf, arrkey.key->val, arrkey.key->len, str->val, str->len);
+ php_http_arrkey_dtor(&arrkey);
+ zend_string_release(str);
}
+ ZEND_HASH_FOREACH_END();
if (list->domain && *list->domain) {
php_http_buffer_appendf(&buf, "domain=%s; ", list->domain);
php_http_buffer_appendf(&buf, "path=%s; ", list->path);
}
if (list->expires >= 0) {
- char *date = php_format_date(ZEND_STRL(PHP_HTTP_DATE_FORMAT), list->expires, 0 TSRMLS_CC);
- php_http_buffer_appendf(&buf, "expires=%s; ", date);
- efree(date);
+ zend_string *date = php_format_date(ZEND_STRL(PHP_HTTP_DATE_FORMAT), list->expires, 0);
+ php_http_buffer_appendf(&buf, "expires=%s; ", date->val);
+ zend_string_release(date);
}
if (list->max_age >= 0) {
php_http_buffer_appendf(&buf, "max-age=%ld; ", list->max_age);
}
- FOREACH_HASH_KEYVAL(pos, &list->extras, key, val) {
- zval *tmp = php_http_ztyp(IS_STRING, *val);
-
- php_http_array_hashkey_stringify(&key);
- append_encoded(&buf, key.str, key.len-1, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
- php_http_array_hashkey_stringfree(&key);
-
- zval_ptr_dtor(&tmp);
+ ZEND_HASH_FOREACH_KEY_VAL(&list->extras, key.h, key.key, val)
+ {
+ zend_string *str = zval_get_string(val);
+ php_http_arrkey_t arrkey;
+
+ php_http_arrkey_stringify(&arrkey, &key);
+ append_encoded(&buf, arrkey.key->val, arrkey.key->len, str->val, str->len);
+ php_http_arrkey_dtor(&arrkey);
+ zend_string_release(str);
}
+ ZEND_HASH_FOREACH_END();
if (list->flags & PHP_HTTP_COOKIE_SECURE) {
php_http_buffer_appends(&buf, "secure; ");
static zend_object_handlers php_http_cookie_object_handlers;
-zend_object_value php_http_cookie_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *php_http_cookie_object_new(zend_class_entry *ce)
{
- return php_http_cookie_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+ return &php_http_cookie_object_new_ex(ce, NULL)->zo;
}
-zend_object_value php_http_cookie_object_new_ex(zend_class_entry *ce, php_http_cookie_list_t *list, php_http_cookie_object_t **ptr TSRMLS_DC)
+php_http_cookie_object_t *php_http_cookie_object_new_ex(zend_class_entry *ce, php_http_cookie_list_t *list)
{
php_http_cookie_object_t *o;
- o = ecalloc(sizeof(*o), 1);
- zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
- object_properties_init((zend_object *) o, ce);
+ if (!ce) {
+ ce = php_http_cookie_class_entry;
+ }
+
- o = ecalloc(sizeof(*o) + sizeof(zval) * (ce->default_properties_count - 1), 1);
++ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+ zend_object_std_init(&o->zo, ce);
+ object_properties_init(&o->zo, ce);
+ o->zo.handlers = &php_http_cookie_object_handlers;
if (list) {
o->list = list;
}
- if (ptr) {
- *ptr = o;
- }
-
- o->zv.handle = zend_objects_store_put(o, NULL, php_http_cookie_object_free, NULL TSRMLS_CC);
- o->zv.handlers = &php_http_cookie_object_handlers;
-
- return o->zv;
+ return o;
}
#define PHP_HTTP_COOKIE_OBJECT_INIT(obj) \
do { \
if (!obj->list) { \
- obj->list = php_http_cookie_list_init(NULL TSRMLS_CC); \
+ obj->list = php_http_cookie_list_init(NULL); \
} \
} while(0)
-zend_object_value php_http_cookie_object_clone(zval *this_ptr TSRMLS_DC)
+zend_object *php_http_cookie_object_clone(zval *obj)
{
- php_http_cookie_object_t *new_obj, *old_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- zend_object_value ov;
+ php_http_cookie_object_t *new_obj, *old_obj = PHP_HTTP_OBJ(NULL, obj);
PHP_HTTP_COOKIE_OBJECT_INIT(old_obj);
- ov = php_http_cookie_object_new_ex(old_obj->zo.ce, php_http_cookie_list_copy(old_obj->list, NULL), &new_obj TSRMLS_CC);
- zend_objects_clone_members((zend_object *) new_obj, ov, (zend_object *) old_obj, Z_OBJ_HANDLE_P(getThis()) TSRMLS_CC);
+ new_obj = php_http_cookie_object_new_ex(old_obj->zo.ce, php_http_cookie_list_copy(old_obj->list, NULL));
+ zend_objects_clone_members(&new_obj->zo, &old_obj->zo);
- return ov;
+ return &new_obj->zo;
}
-void php_http_cookie_object_free(void *object TSRMLS_DC)
+void php_http_cookie_object_free(zend_object *object TSRMLS_DC)
{
- php_http_cookie_object_t *obj = object;
+ php_http_cookie_object_t *obj = PHP_HTTP_OBJ(object, NULL);
php_http_cookie_list_free(&obj->list);
- zend_object_std_dtor((zend_object *) obj TSRMLS_CC);
- efree(obj);
+ zend_object_std_dtor(object);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie___construct, 0, 0, 0)
HashTable *allowed_extras = NULL;
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!lH", &zcookie, &flags, &allowed_extras), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|z!lH", &zcookie, &flags, &allowed_extras), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
- zend_replace_error_handling(EH_THROW, php_http_exception_runtime_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_runtime_class_entry, &zeh);
if (zcookie) {
if (allowed_extras && zend_hash_num_elements(allowed_extras)) {
char **ae_ptr = safe_emalloc(zend_hash_num_elements(allowed_extras) + 1, sizeof(char *), 0);
- HashPosition pos;
- zval **val;
+ zval *val;
ae = ae_ptr;
- FOREACH_HASH_VAL(pos, allowed_extras, val) {
- zval *cpy = php_http_ztyp(IS_STRING, *val);
+ ZEND_HASH_FOREACH_VAL(allowed_extras, val)
+ {
+ zend_string *str = zval_get_string(val);
- *ae_ptr++ = estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy));
- zval_ptr_dtor(&cpy);
+ *ae_ptr++ = estrndup(str->val, str->len);
+ zend_string_release(str);
}
+ ZEND_HASH_FOREACH_END();
*ae_ptr = NULL;
}
switch (Z_TYPE_P(zcookie)) {
case IS_OBJECT:
- if (instanceof_function(Z_OBJCE_P(zcookie), php_http_cookie_class_entry TSRMLS_CC)) {
- php_http_cookie_object_t *zco = zend_object_store_get_object(zcookie TSRMLS_CC);
+ if (instanceof_function(Z_OBJCE_P(zcookie), php_http_cookie_class_entry)) {
+ php_http_cookie_object_t *zco = PHP_HTTP_OBJ(NULL, zcookie);
if (zco->list) {
obj->list = php_http_cookie_list_copy(zco->list, NULL);
}
/* no break */
case IS_ARRAY:
- obj->list = php_http_cookie_list_from_struct(obj->list, zcookie TSRMLS_CC);
+ obj->list = php_http_cookie_list_from_struct(obj->list, zcookie);
break;
default: {
- zval *cpy = php_http_ztyp(IS_STRING, zcookie);
+ zend_string *str = zval_get_string(zcookie);
- obj->list = php_http_cookie_list_parse(obj->list, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy), flags, ae TSRMLS_CC);
- zval_ptr_dtor(&cpy);
+ obj->list = php_http_cookie_list_parse(obj->list, str->val, str->len, flags, ae);
+ zend_string_release(str);
break;
}
}
efree(ae);
}
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
}
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
- array_init(return_value);
+ array_init_size(return_value, zend_hash_num_elements(&obj->list->cookies));
array_copy(&obj->list->cookies, Z_ARRVAL_P(return_value));
}
HashTable *cookies = NULL;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|H", &cookies), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|H", &cookies), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
array_copy_strings(cookies, &obj->list->cookies);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETURN_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addCookies, 0, 0, 1)
HashTable *cookies = NULL;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &cookies), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "H", &cookies), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
array_join(cookies, &obj->list->cookies, 1, ARRAY_JOIN_STRONLY|ARRAY_JOIN_STRINGIFY);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getExtras, 0, 0, 0)
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
- array_init(return_value);
+ array_init_size(return_value, zend_hash_num_elements(&obj->list->extras));
array_copy(&obj->list->extras, Z_ARRVAL_P(return_value));
}
HashTable *extras = NULL;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|H", &extras), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|H", &extras), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
array_copy_strings(extras, &obj->list->extras);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addExtras, 0, 0, 1)
HashTable *extras = NULL;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &extras), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "H", &extras), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
array_join(extras, &obj->list->extras, 1, ARRAY_JOIN_STRONLY|ARRAY_JOIN_STRINGIFY);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getCookie, 0, 0, 1)
static PHP_METHOD(HttpCookie, getCookie)
{
char *name_str;
- int name_len;
- zval *zvalue;
+ size_t name_len;
+ zval zvalue;
php_http_cookie_object_t *obj;
- if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len)) {
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len)) {
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
if (php_http_cookie_list_get_cookie(obj->list, name_str, name_len, &zvalue)) {
- RETURN_ZVAL(zvalue, 1, 0);
+ RETURN_ZVAL_FAST(&zvalue);
}
}
static PHP_METHOD(HttpCookie, setCookie)
{
char *name_str, *value_str = NULL;
- int name_len, value_len = 0;
+ size_t name_len, value_len = 0;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
php_http_cookie_list_add_cookie(obj->list, name_str, name_len, value_str, value_len);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addCookie, 0, 0, 2)
static PHP_METHOD(HttpCookie, addCookie)
{
char *name_str, *value_str;
- int name_len, value_len;
+ size_t name_len, value_len;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
php_http_cookie_list_add_cookie(obj->list, name_str, name_len, value_str, value_len);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getExtra, 0, 0, 1)
static PHP_METHOD(HttpCookie, getExtra)
{
char *name_str;
- int name_len;
- zval *zvalue;
+ size_t name_len;
+ zval zvalue;
php_http_cookie_object_t *obj;
- if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len)) {
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len)) {
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
if (php_http_cookie_list_get_extra(obj->list, name_str, name_len, &zvalue)) {
- RETURN_ZVAL(zvalue, 1, 0);
+ RETURN_ZVAL_FAST(&zvalue);
}
}
static PHP_METHOD(HttpCookie, setExtra)
{
char *name_str, *value_str = NULL;
- int name_len, value_len = 0;
+ size_t name_len, value_len = 0;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
php_http_cookie_list_add_extra(obj->list, name_str, name_len, value_str, value_len);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addExtra, 0, 0, 2)
static PHP_METHOD(HttpCookie, addExtra)
{
char *name_str, *value_str;
- int name_len, value_len;
+ size_t name_len, value_len;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
php_http_cookie_list_add_extra(obj->list, name_str, name_len, value_str, value_len);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getDomain, 0, 0, 0)
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
if (obj->list->domain) {
- RETURN_STRING(obj->list->domain, 1);
+ RETURN_STRING(obj->list->domain);
}
}
static PHP_METHOD(HttpCookie, setDomain)
{
char *domain_str = NULL;
- int domain_len = 0;
+ size_t domain_len = 0;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &domain_str, &domain_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s!", &domain_str, &domain_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
PTR_SET(obj->list->domain, domain_str ? estrndup(domain_str, domain_len) : NULL);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getPath, 0, 0, 0)
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
if (obj->list->path) {
- RETURN_STRING(obj->list->path, 1);
+ RETURN_STRING(obj->list->path);
}
}
static PHP_METHOD(HttpCookie, setPath)
{
char *path_str = NULL;
- int path_len = 0;
+ size_t path_len = 0;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &path_str, &path_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s!", &path_str, &path_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
PTR_SET(obj->list->path, path_str ? estrndup(path_str, path_len) : NULL);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getExpires, 0, 0, 0)
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
long ts = -1;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &ts), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &ts), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
obj->list->expires = ts;
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getMaxAge, 0, 0, 0)
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpCookie, setMaxAge)
{
- long ts = -1;
+ long ma = -1;
php_http_cookie_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &ts), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &ma), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
- obj->list->max_age = ts;
+ obj->list->max_age = ma;
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getFlags, 0, 0, 0)
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
obj->list->flags = flags;
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_toString, 0, 0, 0)
RETURN_EMPTY_STRING();
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
php_http_cookie_list_to_string(obj->list, &str, &len);
- RETURN_STRINGL(str, len, 0);
+ RETURN_NEW_STR(php_http_cs2zs(str, len));
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_toArray, 0, 0, 0)
return;
}
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_COOKIE_OBJECT_INIT(obj);
- array_init(return_value);
+ array_init_size(return_value, 8);
php_http_cookie_list_to_struct(obj->list, return_value);
}
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http", "Cookie", php_http_cookie_methods);
- php_http_cookie_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+ php_http_cookie_class_entry = zend_register_internal_class(&ce);
php_http_cookie_class_entry->create_object = php_http_cookie_object_new;
memcpy(&php_http_cookie_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+ php_http_cookie_object_handlers.offset = XtOffsetOf(php_http_cookie_object_t, zo);
php_http_cookie_object_handlers.clone_obj = php_http_cookie_object_clone;
+ php_http_cookie_object_handlers.free_obj = php_http_cookie_object_free;
zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("PARSE_RAW"), PHP_HTTP_COOKIE_PARSE_RAW TSRMLS_CC);
zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("SECURE"), PHP_HTTP_COOKIE_SECURE TSRMLS_CC);
}
}
-const char *php_http_encoding_dechunk(const char *encoded, size_t encoded_len, char **decoded, size_t *decoded_len TSRMLS_DC)
+const char *php_http_encoding_dechunk(const char *encoded, size_t encoded_len, char **decoded, size_t *decoded_len)
{
int eol_len = 0;
char *n_ptr = NULL;
* not encoded data and return a copy
*/
if (e_ptr == encoded) {
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Data does not seem to be chunked encoded");
+ php_error_docref(NULL, E_NOTICE, "Data does not seem to be chunked encoded");
memcpy(*decoded, encoded, encoded_len);
*decoded_len = encoded_len;
return encoded + encoded_len;
} else {
efree(*decoded);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expected chunk size at pos %tu of %zu but got trash", n_ptr - encoded, encoded_len);
+ php_error_docref(NULL, E_WARNING, "Expected chunk size at pos %tu of %zu but got trash", n_ptr - encoded, encoded_len);
return NULL;
}
}
/* there should be CRLF after the chunk size, but we'll ignore SP+ too */
if (*n_ptr && !eol_match(&n_ptr, &eol_len)) {
if (eol_len == 2) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expected CRLF at pos %tu of %zu but got 0x%02X 0x%02X", n_ptr - encoded, encoded_len, *n_ptr, *(n_ptr + 1));
+ php_error_docref(NULL, E_WARNING, "Expected CRLF at pos %tu of %zu but got 0x%02X 0x%02X", n_ptr - encoded, encoded_len, *n_ptr, *(n_ptr + 1));
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expected LF at pos %tu of %zu but got 0x%02X", n_ptr - encoded, encoded_len, *n_ptr);
+ php_error_docref(NULL, E_WARNING, "Expected LF at pos %tu of %zu but got 0x%02X", n_ptr - encoded, encoded_len, *n_ptr);
}
}
n_ptr += eol_len;
/* chunk size pretends more data than we actually got, so it's probably a truncated message */
if (chunk_len > (rest = encoded + encoded_len - n_ptr)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Truncated message: chunk size %lu exceeds remaining data size %lu at pos %tu of %zu", chunk_len, rest, n_ptr - encoded, encoded_len);
+ php_error_docref(NULL, E_WARNING, "Truncated message: chunk size %lu exceeds remaining data size %lu at pos %tu of %zu", chunk_len, rest, n_ptr - encoded, encoded_len);
chunk_len = rest;
}
return status;
}
-STATUS php_http_encoding_deflate(int flags, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC)
+ZEND_RESULT_CODE php_http_encoding_deflate(int flags, const char *data, size_t data_len, char **encoded, size_t *encoded_len)
{
int status, level, wbits, strategy;
z_stream Z;
}
}
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not deflate data: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Could not deflate data: %s", zError(status));
return FAILURE;
}
-STATUS php_http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC)
+ZEND_RESULT_CODE php_http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len)
{
z_stream Z;
int status, wbits = PHP_HTTP_WINDOW_BITS_ANY;
}
}
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not inflate data: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Could not inflate data: %s", zError(status));
return FAILURE;
}
-php_http_encoding_stream_t *php_http_encoding_stream_init(php_http_encoding_stream_t *s, php_http_encoding_stream_ops_t *ops, unsigned flags TSRMLS_DC)
+php_http_encoding_stream_t *php_http_encoding_stream_init(php_http_encoding_stream_t *s, php_http_encoding_stream_ops_t *ops, unsigned flags)
{
int freeme;
memset(s, 0, sizeof(*s));
s->flags = flags;
- TSRMLS_SET_CTX(s->ts);
if ((s->ops = ops)) {
php_http_encoding_stream_t *ss = s->ops->init(s);
php_http_encoding_stream_t *php_http_encoding_stream_copy(php_http_encoding_stream_t *from, php_http_encoding_stream_t *to)
{
- TSRMLS_FETCH_FROM_CTX(from->ts);
-
if (from->ops->copy) {
int freeme;
php_http_encoding_stream_t *ns;
to->flags = from->flags;
to->ops = from->ops;
- TSRMLS_SET_CTX(to->ts);
if ((ns = to->ops->copy(from, to))) {
return ns;
return NULL;
}
-STATUS php_http_encoding_stream_reset(php_http_encoding_stream_t **s)
+ZEND_RESULT_CODE php_http_encoding_stream_reset(php_http_encoding_stream_t **s)
{
php_http_encoding_stream_t *ss;
+
if ((*s)->ops->dtor) {
(*s)->ops->dtor(*s);
}
return FAILURE;
}
-STATUS php_http_encoding_stream_update(php_http_encoding_stream_t *s, const char *in_str, size_t in_len, char **out_str, size_t *out_len)
+ZEND_RESULT_CODE php_http_encoding_stream_update(php_http_encoding_stream_t *s, const char *in_str, size_t in_len, char **out_str, size_t *out_len)
{
if (!s->ops->update) {
return FAILURE;
return s->ops->update(s, in_str, in_len, out_str, out_len);
}
-STATUS php_http_encoding_stream_flush(php_http_encoding_stream_t *s, char **out_str, size_t *out_len)
+ZEND_RESULT_CODE php_http_encoding_stream_flush(php_http_encoding_stream_t *s, char **out_str, size_t *out_len)
{
if (!s->ops->flush) {
*out_str = NULL;
return s->ops->done(s);
}
-STATUS php_http_encoding_stream_finish(php_http_encoding_stream_t *s, char **out_str, size_t *out_len)
+ZEND_RESULT_CODE php_http_encoding_stream_finish(php_http_encoding_stream_t *s, char **out_str, size_t *out_len)
{
if (!s->ops->finish) {
*out_str = NULL;
{
int status, level, wbits, strategy, p = (s->flags & PHP_HTTP_ENCODING_STREAM_PERSISTENT);
z_streamp ctx = pecalloc(1, sizeof(z_stream), p);
- TSRMLS_FETCH_FROM_CTX(s->ts);
PHP_HTTP_DEFLATE_LEVEL_SET(s->flags, level);
PHP_HTTP_DEFLATE_WBITS_SET(s->flags, wbits);
status = Z_MEM_ERROR;
}
pefree(ctx, p);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to initialize deflate encoding stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to initialize deflate encoding stream: %s", zError(status));
return NULL;
}
{
int status, wbits, p = (s->flags & PHP_HTTP_ENCODING_STREAM_PERSISTENT);
z_streamp ctx = pecalloc(1, sizeof(z_stream), p);
- TSRMLS_FETCH_FROM_CTX(s->ts);
PHP_HTTP_INFLATE_WBITS_SET(s->flags, wbits);
status = Z_MEM_ERROR;
}
pefree(ctx, p);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to initialize inflate stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to initialize inflate stream: %s", zError(status));
return NULL;
}
{
int status, p = to->flags & PHP_HTTP_ENCODING_STREAM_PERSISTENT;
z_streamp from_ctx = from->ctx, to_ctx = pecalloc(1, sizeof(*to_ctx), p);
- TSRMLS_FETCH_FROM_CTX(from->ts);
if (Z_OK == (status = deflateCopy(to_ctx, from_ctx))) {
if ((to_ctx->opaque = php_http_buffer_init_ex(NULL, PHP_HTTP_DEFLATE_BUFFER_SIZE, p ? PHP_HTTP_BUFFER_INIT_PERSISTENT : 0))) {
deflateEnd(to_ctx);
status = Z_MEM_ERROR;
}
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to copy deflate encoding stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to copy deflate encoding stream: %s", zError(status));
return NULL;
}
{
int status, p = from->flags & PHP_HTTP_ENCODING_STREAM_PERSISTENT;
z_streamp from_ctx = from->ctx, to_ctx = pecalloc(1, sizeof(*to_ctx), p);
- TSRMLS_FETCH_FROM_CTX(from->ts);
if (Z_OK == (status = inflateCopy(to_ctx, from_ctx))) {
if ((to_ctx->opaque = php_http_buffer_init_ex(NULL, PHP_HTTP_DEFLATE_BUFFER_SIZE, p ? PHP_HTTP_BUFFER_INIT_PERSISTENT : 0))) {
inflateEnd(to_ctx);
status = Z_MEM_ERROR;
}
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to copy inflate encoding stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to copy inflate encoding stream: %s", zError(status));
return NULL;
}
{
int p = from->flags & PHP_HTTP_ENCODING_STREAM_PERSISTENT;
struct dechunk_ctx *from_ctx = from->ctx, *to_ctx = pemalloc(sizeof(*to_ctx), p);
- TSRMLS_FETCH_FROM_CTX(from->ts);
if (php_http_buffer_init_ex(&to_ctx->buffer, PHP_HTTP_BUFFER_DEFAULT_SIZE, p ? PHP_HTTP_BUFFER_INIT_PERSISTENT : 0)) {
to_ctx->hexlen = from_ctx->hexlen;
return to;
}
pefree(to_ctx, p);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to copy inflate encoding stream: out of memory");
+ php_error_docref(NULL, E_WARNING, "Failed to copy inflate encoding stream: out of memory");
return NULL;
}
-static STATUS deflate_update(php_http_encoding_stream_t *s, const char *data, size_t data_len, char **encoded, size_t *encoded_len)
+static ZEND_RESULT_CODE deflate_update(php_http_encoding_stream_t *s, const char *data, size_t data_len, char **encoded, size_t *encoded_len)
{
int status;
z_streamp ctx = s->ctx;
- TSRMLS_FETCH_FROM_CTX(s->ts);
/* append input to our buffer */
php_http_buffer_append(PHP_HTTP_BUFFER(ctx->opaque), data, data_len);
PTR_SET(*encoded, NULL);
*encoded_len = 0;
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to update deflate stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to update deflate stream: %s", zError(status));
return FAILURE;
}
-static STATUS inflate_update(php_http_encoding_stream_t *s, const char *data, size_t data_len, char **decoded, size_t *decoded_len)
+static ZEND_RESULT_CODE inflate_update(php_http_encoding_stream_t *s, const char *data, size_t data_len, char **decoded, size_t *decoded_len)
{
int status;
z_streamp ctx = s->ctx;
- TSRMLS_FETCH_FROM_CTX(s->ts);
/* append input to buffer */
php_http_buffer_append(PHP_HTTP_BUFFER(ctx->opaque), data, data_len);
break;
}
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to update inflate stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to update inflate stream: %s", zError(status));
return FAILURE;
}
-static STATUS dechunk_update(php_http_encoding_stream_t *s, const char *data, size_t data_len, char **decoded, size_t *decoded_len)
+static ZEND_RESULT_CODE dechunk_update(php_http_encoding_stream_t *s, const char *data, size_t data_len, char **decoded, size_t *decoded_len)
{
php_http_buffer_t tmp;
struct dechunk_ctx *ctx = s->ctx;
- TSRMLS_FETCH_FROM_CTX(s->ts);
if (ctx->zeroed) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Dechunk encoding stream has already reached the end of chunked input");
+ php_error_docref(NULL, E_WARNING, "Dechunk encoding stream has already reached the end of chunked input");
return FAILURE;
}
if ((PHP_HTTP_BUFFER_NOMEM == php_http_buffer_append(&ctx->buffer, data, data_len)) || !php_http_buffer_fix(&ctx->buffer)) {
return SUCCESS;
}
-static STATUS deflate_flush(php_http_encoding_stream_t *s, char **encoded, size_t *encoded_len)
+static ZEND_RESULT_CODE deflate_flush(php_http_encoding_stream_t *s, char **encoded, size_t *encoded_len)
{
int status;
z_streamp ctx = s->ctx;
- TSRMLS_FETCH_FROM_CTX(s->ts);
*encoded_len = PHP_HTTP_DEFLATE_BUFFER_SIZE;
*encoded = emalloc(*encoded_len);
PTR_SET(*encoded, NULL);
*encoded_len = 0;
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to flush deflate stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to flush deflate stream: %s", zError(status));
return FAILURE;
}
-static STATUS dechunk_flush(php_http_encoding_stream_t *s, char **decoded, size_t *decoded_len)
+static ZEND_RESULT_CODE dechunk_flush(php_http_encoding_stream_t *s, char **decoded, size_t *decoded_len)
{
struct dechunk_ctx *ctx = s->ctx;
return SUCCESS;
}
-static STATUS deflate_finish(php_http_encoding_stream_t *s, char **encoded, size_t *encoded_len)
+static ZEND_RESULT_CODE deflate_finish(php_http_encoding_stream_t *s, char **encoded, size_t *encoded_len)
{
int status;
z_streamp ctx = s->ctx;
- TSRMLS_FETCH_FROM_CTX(s->ts);
*encoded_len = PHP_HTTP_DEFLATE_BUFFER_SIZE;
*encoded = emalloc(*encoded_len);
PTR_SET(*encoded, NULL);
*encoded_len = 0;
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to finish deflate stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to finish deflate stream: %s", zError(status));
return FAILURE;
}
-static STATUS inflate_finish(php_http_encoding_stream_t *s, char **decoded, size_t *decoded_len)
+static ZEND_RESULT_CODE inflate_finish(php_http_encoding_stream_t *s, char **decoded, size_t *decoded_len)
{
int status;
z_streamp ctx = s->ctx;
- TSRMLS_FETCH_FROM_CTX(s->ts);
if (!PHP_HTTP_BUFFER(ctx->opaque)->used) {
*decoded = NULL;
PTR_SET(*decoded, NULL);
*decoded_len = 0;
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to finish inflate stream: %s", zError(status));
+ php_error_docref(NULL, E_WARNING, "Failed to finish inflate stream: %s", zError(status));
return FAILURE;
}
static zend_object_handlers php_http_encoding_stream_object_handlers;
-zend_object_value php_http_encoding_stream_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *php_http_encoding_stream_object_new(zend_class_entry *ce)
{
- return php_http_encoding_stream_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+ return &php_http_encoding_stream_object_new_ex(ce, NULL)->zo;
}
-zend_object_value php_http_encoding_stream_object_new_ex(zend_class_entry *ce, php_http_encoding_stream_t *s, php_http_encoding_stream_object_t **ptr TSRMLS_DC)
+php_http_encoding_stream_object_t *php_http_encoding_stream_object_new_ex(zend_class_entry *ce, php_http_encoding_stream_t *s)
{
php_http_encoding_stream_object_t *o;
- o = ecalloc(1, sizeof(*o) + (ce->default_properties_count - 1) * sizeof(zval));
- o = ecalloc(1, sizeof(*o));
- zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
- object_properties_init((zend_object *) o, ce);
-
- if (ptr) {
- *ptr = o;
- }
++ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+ zend_object_std_init(&o->zo, ce);
+ object_properties_init(&o->zo, ce);
if (s) {
o->stream = s;
}
- o->zv.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_encoding_stream_object_free, NULL TSRMLS_CC);
- o->zv.handlers = &php_http_encoding_stream_object_handlers;
+ o->zo.handlers = &php_http_encoding_stream_object_handlers;
- return o->zv;
+ return o;
}
-zend_object_value php_http_encoding_stream_object_clone(zval *this_ptr TSRMLS_DC)
+zend_object *php_http_encoding_stream_object_clone(zval *object)
{
- zend_object_value new_ov;
- php_http_encoding_stream_object_t *new_obj = NULL, *old_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_encoding_stream_object_t *new_obj = NULL, *old_obj = PHP_HTTP_OBJ(NULL, object);
+ php_http_encoding_stream_t *cpy = php_http_encoding_stream_copy(old_obj->stream, NULL);
- new_ov = php_http_encoding_stream_object_new_ex(old_obj->zo.ce, php_http_encoding_stream_copy(old_obj->stream, NULL), &new_obj TSRMLS_CC);
- zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
+ new_obj = php_http_encoding_stream_object_new_ex(old_obj->zo.ce, cpy);
+ zend_objects_clone_members(&new_obj->zo, &old_obj->zo);
- return new_ov;
+ return &new_obj->zo;
}
-void php_http_encoding_stream_object_free(void *object TSRMLS_DC)
+void php_http_encoding_stream_object_free(zend_object *object)
{
- php_http_encoding_stream_object_t *o = (php_http_encoding_stream_object_t *) object;
+ php_http_encoding_stream_object_t *o = PHP_HTTP_OBJ(object, NULL);
if (o->stream) {
php_http_encoding_stream_free(&o->stream);
}
- zend_object_std_dtor((zend_object *) o TSRMLS_CC);
- efree(o);
+ zend_object_std_dtor(object);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEncodingStream___construct, 0, 0, 0)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpEncodingStream, __construct)
{
- long flags = 0;
+ zend_long flags = 0;
php_http_encoding_stream_object_t *obj;
php_http_encoding_stream_ops_t *ops;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &flags), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
if (obj->stream) {
php_http_throw(bad_method_call, "http\\Encoding\\Stream cannot be initialized twice", NULL);
return;
}
- if (instanceof_function(obj->zo.ce, php_http_deflate_stream_class_entry TSRMLS_CC)) {
+ if (instanceof_function(obj->zo.ce, php_http_deflate_stream_class_entry)) {
ops = &php_http_encoding_deflate_ops;
- } else if (instanceof_function(obj->zo.ce, php_http_inflate_stream_class_entry TSRMLS_CC)) {
+ } else if (instanceof_function(obj->zo.ce, php_http_inflate_stream_class_entry)) {
ops = &php_http_encoding_inflate_ops;
- } else if (instanceof_function(obj->zo.ce, php_http_dechunk_stream_class_entry TSRMLS_CC)) {
+ } else if (instanceof_function(obj->zo.ce, php_http_dechunk_stream_class_entry)) {
ops = &php_http_encoding_dechunk_ops;
} else {
- php_http_throw(runtime, "Unknown http\\Encoding\\Stream class '%s'", obj->zo.ce->name);
+ php_http_throw(runtime, "Unknown http\\Encoding\\Stream class '%s'", obj->zo.ce->name->val);
return;
}
- php_http_expect(obj->stream = php_http_encoding_stream_init(obj->stream, ops, flags TSRMLS_CC), runtime, return);
+ php_http_expect(obj->stream = php_http_encoding_stream_init(obj->stream, ops, flags), runtime, return);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEncodingStream_update, 0, 0, 1)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpEncodingStream, update)
{
- int data_len;
+ size_t data_len;
char *data_str;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data_str, &data_len)) {
- php_http_encoding_stream_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &data_str, &data_len)) {
+ php_http_encoding_stream_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
if (obj->stream) {
+ char *encoded_str = NULL;
size_t encoded_len;
- char *encoded_str;
if (SUCCESS == php_http_encoding_stream_update(obj->stream, data_str, data_len, &encoded_str, &encoded_len)) {
- RETURN_STRINGL(encoded_str, encoded_len, 0);
+ if (encoded_str) {
+ RETURN_STR(php_http_cs2zs(encoded_str, encoded_len));
+ } else {
+ RETURN_EMPTY_STRING();
+ }
}
}
}
static PHP_METHOD(HttpEncodingStream, flush)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_encoding_stream_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_encoding_stream_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
if (obj->stream) {
- char *encoded_str;
+ char *encoded_str = NULL;
size_t encoded_len;
if (SUCCESS == php_http_encoding_stream_flush(obj->stream, &encoded_str, &encoded_len)) {
if (encoded_str) {
- RETURN_STRINGL(encoded_str, encoded_len, 0);
+ RETURN_STR(php_http_cs2zs(encoded_str, encoded_len));
} else {
RETURN_EMPTY_STRING();
}
static PHP_METHOD(HttpEncodingStream, done)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_encoding_stream_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_encoding_stream_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
if (obj->stream) {
RETURN_BOOL(php_http_encoding_stream_done(obj->stream));
static PHP_METHOD(HttpEncodingStream, finish)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_encoding_stream_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_encoding_stream_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
if (obj->stream) {
- char *encoded_str;
+ char *encoded_str = NULL;
size_t encoded_len;
if (SUCCESS == php_http_encoding_stream_finish(obj->stream, &encoded_str, &encoded_len)) {
if (SUCCESS == php_http_encoding_stream_reset(&obj->stream)) {
if (encoded_str) {
- RETURN_STRINGL(encoded_str, encoded_len, 0);
+ RETURN_STR(php_http_cs2zs(encoded_str, encoded_len));
} else {
RETURN_EMPTY_STRING();
}
static PHP_METHOD(HttpDeflateStream, encode)
{
char *str;
- int len;
- long flags = 0;
+ size_t len;
+ zend_long flags = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &len, &flags)) {
- char *enc_str;
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &len, &flags)) {
+ char *enc_str = NULL;
size_t enc_len;
- if (SUCCESS == php_http_encoding_deflate(flags, str, len, &enc_str, &enc_len TSRMLS_CC)) {
- RETURN_STRINGL(enc_str, enc_len, 0);
+ if (SUCCESS == php_http_encoding_deflate(flags, str, len, &enc_str, &enc_len)) {
+ if (enc_str) {
+ RETURN_STR(php_http_cs2zs(enc_str, enc_len));
+ } else {
+ RETURN_EMPTY_STRING();
+ }
}
}
RETURN_FALSE;
static PHP_METHOD(HttpInflateStream, decode)
{
char *str;
- int len;
+ size_t len;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len)) {
- char *enc_str;
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &len)) {
+ char *enc_str = NULL;
size_t enc_len;
- if (SUCCESS == php_http_encoding_inflate(str, len, &enc_str, &enc_len TSRMLS_CC)) {
- RETURN_STRINGL(enc_str, enc_len, 0);
+ if (SUCCESS == php_http_encoding_inflate(str, len, &enc_str, &enc_len)) {
+ if (enc_str) {
+ RETURN_STR(php_http_cs2zs(enc_str, enc_len));
+ } else {
+ RETURN_EMPTY_STRING();
+ }
}
}
RETURN_FALSE;
static PHP_METHOD(HttpDechunkStream, decode)
{
char *str;
- int len;
+ size_t len;
zval *zlen = NULL;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z!", &str, &len, &zlen)) {
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|z!", &str, &len, &zlen)) {
const char *end_ptr;
- char *enc_str;
+ char *enc_str = NULL;
size_t enc_len;
- if ((end_ptr = php_http_encoding_dechunk(str, len, &enc_str, &enc_len TSRMLS_CC))) {
+ if ((end_ptr = php_http_encoding_dechunk(str, len, &enc_str, &enc_len))) {
if (zlen) {
+ ZVAL_DEREF(zlen);
zval_dtor(zlen);
ZVAL_LONG(zlen, str + len - end_ptr);
}
- RETURN_STRINGL(enc_str, enc_len, 0);
+ if (enc_str) {
+ RETURN_STR(php_http_cs2zs(enc_str, enc_len));
+ } else {
+ RETURN_EMPTY_STRING();
+ }
}
}
RETURN_FALSE;
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http\\Encoding", "Stream", php_http_encoding_stream_methods);
- php_http_encoding_stream_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+ php_http_encoding_stream_class_entry = zend_register_internal_class(&ce);
php_http_encoding_stream_class_entry->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
php_http_encoding_stream_class_entry->create_object = php_http_encoding_stream_object_new;
memcpy(&php_http_encoding_stream_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+ php_http_encoding_stream_object_handlers.offset = XtOffsetOf(php_http_encoding_stream_object_t, zo);
php_http_encoding_stream_object_handlers.clone_obj = php_http_encoding_stream_object_clone;
+ php_http_encoding_stream_object_handlers.free_obj = php_http_encoding_stream_object_free;
- zend_declare_class_constant_long(php_http_encoding_stream_class_entry, ZEND_STRL("FLUSH_NONE"), PHP_HTTP_ENCODING_STREAM_FLUSH_NONE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_encoding_stream_class_entry, ZEND_STRL("FLUSH_SYNC"), PHP_HTTP_ENCODING_STREAM_FLUSH_SYNC TSRMLS_CC);
- zend_declare_class_constant_long(php_http_encoding_stream_class_entry, ZEND_STRL("FLUSH_FULL"), PHP_HTTP_ENCODING_STREAM_FLUSH_FULL TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_encoding_stream_class_entry, ZEND_STRL("FLUSH_NONE"), PHP_HTTP_ENCODING_STREAM_FLUSH_NONE);
+ zend_declare_class_constant_long(php_http_encoding_stream_class_entry, ZEND_STRL("FLUSH_SYNC"), PHP_HTTP_ENCODING_STREAM_FLUSH_SYNC);
+ zend_declare_class_constant_long(php_http_encoding_stream_class_entry, ZEND_STRL("FLUSH_FULL"), PHP_HTTP_ENCODING_STREAM_FLUSH_FULL);
memset(&ce, 0, sizeof(ce));
INIT_NS_CLASS_ENTRY(ce, "http\\Encoding\\Stream", "Deflate", php_http_deflate_stream_methods);
- php_http_deflate_stream_class_entry = zend_register_internal_class_ex(&ce, php_http_encoding_stream_class_entry, NULL TSRMLS_CC);
-
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("TYPE_GZIP"), PHP_HTTP_DEFLATE_TYPE_GZIP TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("TYPE_ZLIB"), PHP_HTTP_DEFLATE_TYPE_ZLIB TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("TYPE_RAW"), PHP_HTTP_DEFLATE_TYPE_RAW TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("LEVEL_DEF"), PHP_HTTP_DEFLATE_LEVEL_DEF TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("LEVEL_MIN"), PHP_HTTP_DEFLATE_LEVEL_MIN TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("LEVEL_MAX"), PHP_HTTP_DEFLATE_LEVEL_MAX TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_DEF"), PHP_HTTP_DEFLATE_STRATEGY_DEF TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_FILT"), PHP_HTTP_DEFLATE_STRATEGY_FILT TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_HUFF"), PHP_HTTP_DEFLATE_STRATEGY_HUFF TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_RLE"), PHP_HTTP_DEFLATE_STRATEGY_RLE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_FIXED"), PHP_HTTP_DEFLATE_STRATEGY_FIXED TSRMLS_CC);
+ php_http_deflate_stream_class_entry = zend_register_internal_class_ex(&ce, php_http_encoding_stream_class_entry);
+ php_http_deflate_stream_class_entry->create_object = php_http_encoding_stream_object_new;
+
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("TYPE_GZIP"), PHP_HTTP_DEFLATE_TYPE_GZIP);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("TYPE_ZLIB"), PHP_HTTP_DEFLATE_TYPE_ZLIB);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("TYPE_RAW"), PHP_HTTP_DEFLATE_TYPE_RAW);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("LEVEL_DEF"), PHP_HTTP_DEFLATE_LEVEL_DEF);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("LEVEL_MIN"), PHP_HTTP_DEFLATE_LEVEL_MIN);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("LEVEL_MAX"), PHP_HTTP_DEFLATE_LEVEL_MAX);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_DEF"), PHP_HTTP_DEFLATE_STRATEGY_DEF);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_FILT"), PHP_HTTP_DEFLATE_STRATEGY_FILT);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_HUFF"), PHP_HTTP_DEFLATE_STRATEGY_HUFF);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_RLE"), PHP_HTTP_DEFLATE_STRATEGY_RLE);
+ zend_declare_class_constant_long(php_http_deflate_stream_class_entry, ZEND_STRL("STRATEGY_FIXED"), PHP_HTTP_DEFLATE_STRATEGY_FIXED);
memset(&ce, 0, sizeof(ce));
INIT_NS_CLASS_ENTRY(ce, "http\\Encoding\\Stream", "Inflate", php_http_inflate_stream_methods);
- php_http_inflate_stream_class_entry = zend_register_internal_class_ex(&ce, php_http_encoding_stream_class_entry, NULL TSRMLS_CC);
+ php_http_inflate_stream_class_entry = zend_register_internal_class_ex(&ce, php_http_encoding_stream_class_entry);
+ php_http_inflate_stream_class_entry->create_object = php_http_encoding_stream_object_new;
memset(&ce, 0, sizeof(ce));
INIT_NS_CLASS_ENTRY(ce, "http\\Encoding\\Stream", "Dechunk", php_http_dechunk_stream_methods);
- php_http_dechunk_stream_class_entry = zend_register_internal_class_ex(&ce, php_http_encoding_stream_class_entry, NULL TSRMLS_CC);
+ php_http_dechunk_stream_class_entry = zend_register_internal_class_ex(&ce, php_http_encoding_stream_class_entry);
+ php_http_dechunk_stream_class_entry->create_object = php_http_encoding_stream_object_new;
return SUCCESS;
}
#include "php_http_api.h"
-static void set_option(zval *options, const char *name_str, size_t name_len, int type, void *value_ptr, size_t value_len TSRMLS_DC)
+static void set_option(zval *options, const char *name_str, size_t name_len, int type, void *value_ptr, size_t value_len)
{
if (Z_TYPE_P(options) == IS_OBJECT) {
if (value_ptr) {
switch (type) {
case IS_DOUBLE:
- zend_update_property_double(Z_OBJCE_P(options), options, name_str, name_len, *(double *)value_ptr TSRMLS_CC);
+ zend_update_property_double(Z_OBJCE_P(options), 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, *(long *)value_ptr TSRMLS_CC);
+ zend_update_property_long(Z_OBJCE_P(options), 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 TSRMLS_CC);
+ zend_update_property_stringl(Z_OBJCE_P(options), 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 TSRMLS_CC);
+ zend_update_property(Z_OBJCE_P(options), options, name_str, name_len, value_ptr);
break;
}
} else {
- zend_update_property_null(Z_OBJCE_P(options), options, name_str, name_len TSRMLS_CC);
+ zend_update_property_null(Z_OBJCE_P(options), options, name_str, name_len);
}
} else {
convert_to_array(options);
if (value_ptr) {
switch (type) {
case IS_DOUBLE:
- add_assoc_double_ex(options, name_str, name_len + 1, *(double *)value_ptr);
+ add_assoc_double_ex(options, name_str, name_len, *(double *)value_ptr);
break;
case IS_LONG:
- add_assoc_long_ex(options, name_str, name_len + 1, *(long *)value_ptr);
+ add_assoc_long_ex(options, name_str, name_len, *(zend_long *)value_ptr);
break;
case IS_STRING: {
- char *value = estrndup(value_ptr, value_len);
- add_assoc_stringl_ex(options, name_str, name_len + 1, value, value_len, 0);
+ zend_string *value = zend_string_init(value_ptr, value_len, 0);
+ add_assoc_str_ex(options, name_str, name_len, value);
break;
case IS_ARRAY:
case IS_OBJECT:
Z_ADDREF_P(value_ptr);
- add_assoc_zval_ex(options, name_str, name_len + 1, value_ptr);
+ add_assoc_zval_ex(options, name_str, name_len, value_ptr);
break;
}
}
} else {
- add_assoc_null_ex(options, name_str, name_len + 1);
+ add_assoc_null_ex(options, name_str, name_len);
}
}
}
-static zval *get_option(zval *options, const char *name_str, size_t name_len TSRMLS_DC)
+static zval *get_option(zval *options, const char *name_str, size_t name_len, zval *tmp)
{
- zval *val, **valptr;
+ zval *val = NULL;
if (Z_TYPE_P(options) == IS_OBJECT) {
- val = zend_read_property(Z_OBJCE_P(options), options, name_str, name_len, 0 TSRMLS_CC);
+ val = zend_read_property(Z_OBJCE_P(options), options, name_str, name_len, 0, tmp);
+ } else if (Z_TYPE_P(options) == IS_ARRAY) {
+ val = zend_symtable_str_find(Z_ARRVAL_P(options), name_str, name_len);
} else {
- if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(options), name_str, name_len + 1, (void *) &valptr)) {
- val = *valptr;
- } else {
- val = NULL;
- }
+ abort();
}
if (val) {
- Z_ADDREF_P(val);
+ Z_TRY_ADDREF_P(val);
}
return val;
}
-static php_http_message_body_t *get_body(zval *options TSRMLS_DC)
+static php_http_message_body_t *get_body(zval *options)
{
- zval *zbody;
+ zval zbody_tmp, *zbody;
php_http_message_body_t *body = NULL;
- if ((zbody = get_option(options, ZEND_STRL("body") TSRMLS_CC))) {
- if ((Z_TYPE_P(zbody) == IS_OBJECT) && instanceof_function(Z_OBJCE_P(zbody), php_http_message_body_class_entry TSRMLS_CC)) {
- php_http_message_body_object_t *body_obj = zend_object_store_get_object(zbody TSRMLS_CC);
+ if ((zbody = get_option(options, ZEND_STRL("body"), &zbody_tmp))) {
+ if ((Z_TYPE_P(zbody) == IS_OBJECT) && instanceof_function(Z_OBJCE_P(zbody), php_http_message_body_class_entry)) {
+ php_http_message_body_object_t *body_obj = PHP_HTTP_OBJ(NULL, zbody);
body = body_obj->body;
}
- zval_ptr_dtor(&zbody);
+ Z_TRY_DELREF_P(zbody);
}
return body;
}
-static php_http_message_t *get_request(zval *options TSRMLS_DC)
+static php_http_message_t *get_request(zval *options)
{
- zval *zrequest;
+ zval zrequest_tmp, *zrequest;
php_http_message_t *request = NULL;
- if ((zrequest = get_option(options, ZEND_STRL("request") TSRMLS_CC))) {
- if (Z_TYPE_P(zrequest) == IS_OBJECT && instanceof_function(Z_OBJCE_P(zrequest), php_http_message_class_entry TSRMLS_CC)) {
- php_http_message_object_t *request_obj = zend_object_store_get_object(zrequest TSRMLS_CC);
+ if ((zrequest = get_option(options, ZEND_STRL("request"), &zrequest_tmp))) {
+ if (Z_TYPE_P(zrequest) == IS_OBJECT && instanceof_function(Z_OBJCE_P(zrequest), php_http_message_class_entry)) {
+ php_http_message_object_t *request_obj = PHP_HTTP_OBJ(NULL, zrequest);
request = request_obj->message;
}
- zval_ptr_dtor(&zrequest);
+ Z_TRY_DELREF_P(zrequest);
}
return request;
}
-static void set_cookie(zval *options, zval *zcookie_new TSRMLS_DC)
+static void set_cookie(zval *options, zval *zcookie_new)
{
- HashPosition pos;
- zval *zcookies_set;
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
- php_http_cookie_object_t *obj = zend_object_store_get_object(zcookie_new TSRMLS_CC);
-
- zcookies_set = get_option(options, ZEND_STRL("cookies") TSRMLS_CC);
- if (!zcookies_set || Z_TYPE_P(zcookies_set) != IS_ARRAY) {
- if (zcookies_set) {
- zval_ptr_dtor(&zcookies_set);
- }
- MAKE_STD_ZVAL(zcookies_set);
- array_init_size(zcookies_set, zend_hash_num_elements(&obj->list->cookies));
- } else {
- SEPARATE_ZVAL(&zcookies_set);
+ zval tmp, zcookies_set_tmp, *zcookies_set;
+ php_http_arrkey_t key;
+ php_http_cookie_object_t *obj = PHP_HTTP_OBJ(NULL, zcookie_new);
+
+ array_init(&tmp);
+ zcookies_set = get_option(options, ZEND_STRL("cookies"), &zcookies_set_tmp);
+ if (zcookies_set && Z_TYPE_P(zcookies_set) == IS_ARRAY) {
+ array_copy(Z_ARRVAL_P(zcookies_set), Z_ARRVAL(tmp));
+ zval_ptr_dtor(zcookies_set);
}
- FOREACH_HASH_KEY(pos, &obj->list->cookies, key) {
+ ZEND_HASH_FOREACH_KEY(&obj->list->cookies, key.h, key.key)
+ {
Z_ADDREF_P(zcookie_new);
- if (key.type == HASH_KEY_IS_STRING) {
- add_assoc_zval_ex(zcookies_set, key.str, key.len, zcookie_new);
+ if (key.key) {
+ add_assoc_zval_ex(&tmp, key.key->val, key.key->len, zcookie_new);
} else {
- add_index_zval(zcookies_set, key.num, zcookie_new);
+ add_index_zval(&tmp, key.h, zcookie_new);
}
}
+ ZEND_HASH_FOREACH_END();
- set_option(options, ZEND_STRL("cookies"), IS_ARRAY, zcookies_set, 0 TSRMLS_CC);
- zval_ptr_dtor(&zcookies_set);
+ set_option(options, ZEND_STRL("cookies"), IS_ARRAY, &tmp, 0);
+ zval_ptr_dtor(&tmp);
}
-php_http_cache_status_t php_http_env_is_response_cached_by_etag(zval *options, const char *header_str, size_t header_len, php_http_message_t *request TSRMLS_DC)
+php_http_cache_status_t php_http_env_is_response_cached_by_etag(zval *options, const char *header_str, size_t header_len, php_http_message_t *request)
{
php_http_cache_status_t ret = PHP_HTTP_CACHE_NO;
- int free_etag = 0;
- char *header = NULL, *etag;
+ char *header = NULL, *etag = NULL;
php_http_message_body_t *body;
- zval *zetag;
+ zval zetag_tmp, *zetag;
- if (!(body = get_body(options TSRMLS_CC))) {
+ if (!(body = get_body(options))) {
return ret;
}
- if ((zetag = get_option(options, ZEND_STRL("etag") TSRMLS_CC))) {
- zval *zetag_copy = php_http_ztyp(IS_STRING, zetag);
- zval_ptr_dtor(&zetag);
- zetag = zetag_copy;
+ if ((zetag = get_option(options, ZEND_STRL("etag"), &zetag_tmp)) && Z_TYPE_P(zetag) != IS_NULL) {
+ zend_string *zs = zval_get_string(zetag);
+ etag = estrndup(zs->val, zs->len);
+ zend_string_release(zs);
+ zval_ptr_dtor(zetag);
}
- if (zetag && Z_STRLEN_P(zetag)) {
- etag = Z_STRVAL_P(zetag);
- } else if ((etag = php_http_message_body_etag(body))) {
- set_option(options, ZEND_STRL("etag"), IS_STRING, etag, strlen(etag) TSRMLS_CC);
- free_etag = 1;
+ if (!etag && (etag = php_http_message_body_etag(body))) {
+ set_option(options, ZEND_STRL("etag"), IS_STRING, etag, strlen(etag));
}
- if (zetag) {
- zval_ptr_dtor(&zetag);
- }
-
- if (etag && (header = php_http_env_get_request_header(header_str, header_len, NULL, request TSRMLS_CC))) {
- ret = php_http_match(header, etag, PHP_HTTP_MATCH_WORD) ? PHP_HTTP_CACHE_HIT : PHP_HTTP_CACHE_MISS;
- }
-
- if (free_etag) {
- efree(etag);
+ if (etag && (header = php_http_env_get_request_header(header_str, header_len, NULL, request))) {
+ ret = php_http_match(header, etag, PHP_HTTP_MATCH_WORD) ? PHP_HTTP_CACHE_HIT : PHP_HTTP_CACHE_MISS;
}
+ PTR_FREE(etag);
PTR_FREE(header);
+
return ret;
}
-php_http_cache_status_t php_http_env_is_response_cached_by_last_modified(zval *options, const char *header_str, size_t header_len, php_http_message_t *request TSRMLS_DC)
+php_http_cache_status_t php_http_env_is_response_cached_by_last_modified(zval *options, const char *header_str, size_t header_len, php_http_message_t *request)
{
php_http_cache_status_t ret = PHP_HTTP_CACHE_NO;
char *header;
time_t ums, lm = 0;
php_http_message_body_t *body;
- zval *zlm;
+ zval zlm_tmp, *zlm;
- if (!(body = get_body(options TSRMLS_CC))) {
+ if (!(body = get_body(options))) {
return ret;
}
- if ((zlm = get_option(options, ZEND_STRL("lastModified") TSRMLS_CC))) {
- zval *zlm_copy = php_http_ztyp(IS_LONG, zlm);
- zval_ptr_dtor(&zlm);
- zlm = zlm_copy;
+ if ((zlm = get_option(options, ZEND_STRL("lastModified"), &zlm_tmp))) {
+ lm = zval_get_long(zlm);
+ zval_ptr_dtor(zlm);
}
- if (zlm && Z_LVAL_P(zlm) > 0) {
- lm = Z_LVAL_P(zlm);
- } else {
+ if (lm <= 0) {
lm = php_http_message_body_mtime(body);
- set_option(options, ZEND_STRL("lastModified"), IS_LONG, &lm, 0 TSRMLS_CC);
- }
-
- if (zlm) {
- zval_ptr_dtor(&zlm);
+ set_option(options, ZEND_STRL("lastModified"), IS_LONG, &lm, 0);
}
- if ((header = php_http_env_get_request_header(header_str, header_len, NULL, request TSRMLS_CC))) {
+ if ((header = php_http_env_get_request_header(header_str, header_len, NULL, request))) {
ums = php_parse_date(header, NULL);
if (ums > 0 && ums >= lm) {
static zend_bool php_http_env_response_is_cacheable(php_http_env_response_t *r, php_http_message_t *request)
{
- TSRMLS_FETCH_FROM_CTX(r->ts);
-
if (r->ops->get_status(r) >= 400) {
return 0;
}
- if (php_http_env_got_request_header(ZEND_STRL("Authorization"), request TSRMLS_CC)) {
+ if (php_http_env_got_request_header(ZEND_STRL("Authorization"), request)) {
return 0;
}
- if (-1 == php_http_select_str(php_http_env_get_request_method(request TSRMLS_CC), 2, "HEAD", "GET")) {
+ if (-1 == php_http_select_str(php_http_env_get_request_method(request), 2, "HEAD", "GET")) {
return 0;
}
return 1;
}
-static size_t output(void *context, char *buf, size_t len TSRMLS_DC)
+static size_t output(void *context, char *buf, size_t len)
{
php_http_env_response_t *r = context;
return len;
}
-#define php_http_env_response_send_done(r) php_http_env_response_send_data((r), NULL, 0)
-static STATUS php_http_env_response_send_data(php_http_env_response_t *r, const char *buf, size_t len)
+static ZEND_RESULT_CODE php_http_env_response_send_data(php_http_env_response_t *r, const char *buf, size_t len)
{
size_t chunks_sent, chunk = r->throttle.chunk ? r->throttle.chunk : PHP_HTTP_SENDBUF_SIZE;
- TSRMLS_FETCH_FROM_CTX(r->ts);
if (r->content.encoder) {
char *enc_str = NULL;
if (!enc_str) {
return SUCCESS;
}
- chunks_sent = php_http_buffer_chunked_output(&r->buffer, enc_str, enc_len, buf ? chunk : 0, output, r TSRMLS_CC);
+ chunks_sent = php_http_buffer_chunked_output(&r->buffer, enc_str, enc_len, buf ? chunk : 0, output, r);
PTR_FREE(enc_str);
} else {
- chunks_sent = php_http_buffer_chunked_output(&r->buffer, buf, len, buf ? chunk : 0, output, r TSRMLS_CC);
+ chunks_sent = php_http_buffer_chunked_output(&r->buffer, buf, len, buf ? chunk : 0, output, r);
}
return chunks_sent != (size_t) -1 ? SUCCESS : FAILURE;
}
-php_http_env_response_t *php_http_env_response_init(php_http_env_response_t *r, zval *options, php_http_env_response_ops_t *ops, void *init_arg TSRMLS_DC)
+static inline ZEND_RESULT_CODE php_http_env_response_send_done(php_http_env_response_t *r)
+{
+ return php_http_env_response_send_data(r, NULL, 0);
+}
+
+php_http_env_response_t *php_http_env_response_init(php_http_env_response_t *r, zval *options, php_http_env_response_ops_t *ops, void *init_arg)
{
zend_bool free_r;
r->buffer = php_http_buffer_init(NULL);
- Z_ADDREF_P(options);
- r->options = options;
-
- TSRMLS_SET_CTX(r->ts);
+ ZVAL_COPY(&r->options, options);
if (r->ops->init && (SUCCESS != r->ops->init(r, init_arg))) {
if (free_r) {
}
}
-static STATUS php_http_env_response_send_head(php_http_env_response_t *r, php_http_message_t *request)
+static ZEND_RESULT_CODE php_http_env_response_send_head(php_http_env_response_t *r, php_http_message_t *request)
{
- STATUS ret = SUCCESS;
- zval *zoption, *options = r->options;
- TSRMLS_FETCH_FROM_CTX(r->ts);
+ ZEND_RESULT_CODE ret = SUCCESS;
+ zval zoption_tmp, *zoption, *options = &r->options;
if (r->done) {
return ret;
}
- if ((zoption = get_option(options, ZEND_STRL("headers") TSRMLS_CC))) {
+ if ((zoption = get_option(options, ZEND_STRL("headers"), &zoption_tmp))) {
if (Z_TYPE_P(zoption) == IS_ARRAY) {
- php_http_header_to_callback(Z_ARRVAL_P(zoption), 0, (php_http_pass_format_callback_t) r->ops->set_header, r TSRMLS_CC);
+ php_http_header_to_callback(Z_ARRVAL_P(zoption), 0, (php_http_pass_format_callback_t) r->ops->set_header, r);
}
- zval_ptr_dtor(&zoption);
+ zval_ptr_dtor(zoption);
}
if (ret != SUCCESS) {
return ret;
}
- if ((zoption = get_option(options, ZEND_STRL("responseCode") TSRMLS_CC))) {
- zval *zoption_copy = php_http_ztyp(IS_LONG, zoption);
+ if ((zoption = get_option(options, ZEND_STRL("responseCode"), &zoption_tmp))) {
+ zend_long rc = zval_get_long(zoption);
- zval_ptr_dtor(&zoption);
- if (Z_LVAL_P(zoption_copy) > 0) {
- ret = r->ops->set_status(r, Z_LVAL_P(zoption_copy));
+ zval_ptr_dtor(zoption);
+ if (rc > 0) {
+ ret = r->ops->set_status(r, rc);
}
- zval_ptr_dtor(&zoption_copy);
}
if (ret != SUCCESS) {
return ret;
}
- if ((zoption = get_option(options, ZEND_STRL("httpVersion") TSRMLS_CC))) {
+ if ((zoption = get_option(options, ZEND_STRL("httpVersion"), &zoption_tmp))) {
php_http_version_t v;
- zval *zoption_copy = php_http_ztyp(IS_STRING, zoption);
+ zend_string *zs = zval_get_string(zoption);
- zval_ptr_dtor(&zoption);
- if (Z_STRLEN_P(zoption_copy) && php_http_version_parse(&v, Z_STRVAL_P(zoption_copy) TSRMLS_CC)) {
+ zval_ptr_dtor(zoption);
+ if (zs->len && php_http_version_parse(&v, zs->val)) {
ret = r->ops->set_protocol_version(r, &v);
php_http_version_dtor(&v);
}
- zval_ptr_dtor(&zoption_copy);
+ zend_string_release(zs);
}
if (ret != SUCCESS) {
return ret;
}
- if ((zoption = get_option(options, ZEND_STRL("cookies") TSRMLS_CC))) {
+ if ((zoption = get_option(options, ZEND_STRL("cookies"), &zoption_tmp))) {
if (Z_TYPE_P(zoption) == IS_ARRAY) {
- HashPosition pos;
- zval **zcookie;
+ zval *zcookie;
- FOREACH_VAL(pos, zoption, zcookie) {
- if (Z_TYPE_PP(zcookie) == IS_OBJECT && instanceof_function(Z_OBJCE_PP(zcookie), php_http_cookie_class_entry TSRMLS_CC)) {
- php_http_cookie_object_t *obj = zend_object_store_get_object(*zcookie TSRMLS_CC);
+ ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(zoption), zcookie)
+ {
+ if (Z_TYPE_P(zcookie) == IS_OBJECT && instanceof_function(Z_OBJCE_P(zcookie), php_http_cookie_class_entry)) {
+ php_http_cookie_object_t *obj = PHP_HTTP_OBJ(NULL, zcookie);
char *str;
size_t len;
efree(str);
}
}
+ ZEND_HASH_FOREACH_END();
}
- zval_ptr_dtor(&zoption);
+ zval_ptr_dtor(zoption);
}
if (ret != SUCCESS) {
return ret;
}
- if ((zoption = get_option(options, ZEND_STRL("contentType") TSRMLS_CC))) {
- zval *zoption_copy = php_http_ztyp(IS_STRING, zoption);
+ if ((zoption = get_option(options, ZEND_STRL("contentType"), &zoption_tmp))) {
+ zend_string *zs = zval_get_string(zoption);
- zval_ptr_dtor(&zoption);
- if (Z_STRLEN_P(zoption_copy) && strchr(Z_STRVAL_P(zoption_copy), '/')) {
- if (SUCCESS == (ret = r->ops->set_header(r, "Content-Type: %.*s", Z_STRLEN_P(zoption_copy), Z_STRVAL_P(zoption_copy)))) {
- r->content.type = estrndup(Z_STRVAL_P(zoption_copy), Z_STRLEN_P(zoption_copy));
+ zval_ptr_dtor(zoption);
+ if (zs->len && strchr(zs->val, '/')) {
+ if (SUCCESS == (ret = r->ops->set_header(r, "Content-Type: %.*s", zs->len, zs->val))) {
+ r->content.type = estrndup(zs->val, zs->len);
}
}
- zval_ptr_dtor(&zoption_copy);
+ zend_string_release(zs);
}
if (ret != SUCCESS) {
if (r->range.status == PHP_HTTP_RANGE_OK) {
if (zend_hash_num_elements(&r->range.values) == 1) {
- zval **range, **begin, **end;
+ zval *range, *begin, *end;
- if ( 1 == php_http_array_list(&r->range.values TSRMLS_CC, 1, &range)
- && 2 == php_http_array_list(Z_ARRVAL_PP(range) TSRMLS_CC, 2, &begin, &end)
+ if ( 1 == php_http_array_list(&r->range.values, 1, &range)
+ && 2 == php_http_array_list(Z_ARRVAL_P(range), 2, &begin, &end)
) {
if (SUCCESS == (ret = r->ops->set_status(r, 206))) {
- ret = r->ops->set_header(r, "Content-Range: bytes %ld-%ld/%zu", Z_LVAL_PP(begin), Z_LVAL_PP(end), r->content.length);
+ ret = r->ops->set_header(r, "Content-Range: bytes %ld-%ld/%zu", Z_LVAL_P(begin), Z_LVAL_P(end), r->content.length);
}
} else {
/* this should never happen */
ret = FAILURE;
}
} else {
- php_http_boundary(r->range.boundary, sizeof(r->range.boundary) TSRMLS_CC);
+ php_http_boundary(r->range.boundary, sizeof(r->range.boundary));
if (SUCCESS == (ret = r->ops->set_status(r, 206))) {
ret = r->ops->set_header(r, "Content-Type: multipart/byteranges; boundary=%s", r->range.boundary);
}
}
} else {
- if ((zoption = get_option(options, ZEND_STRL("cacheControl") TSRMLS_CC))) {
- zval *zoption_copy = php_http_ztyp(IS_STRING, zoption);
+ if ((zoption = get_option(options, ZEND_STRL("cacheControl"), &zoption_tmp))) {
+ zend_string *zs = zval_get_string(zoption);
- zval_ptr_dtor(&zoption);
- if (Z_STRLEN_P(zoption_copy)) {
- ret = r->ops->set_header(r, "Cache-Control: %.*s", Z_STRLEN_P(zoption_copy), Z_STRVAL_P(zoption_copy));
+ zval_ptr_dtor(zoption);
+ if (zs->len) {
+ ret = r->ops->set_header(r, "Cache-Control: %.*s", zs->len, zs->val);
}
- zval_ptr_dtor(&zoption_copy);
+ zend_string_release(zs);
}
if (ret != SUCCESS) {
return ret;
}
- if ((zoption = get_option(options, ZEND_STRL("contentDisposition") TSRMLS_CC))) {
- zval *zoption_copy = php_http_ztyp(IS_ARRAY, zoption);
- php_http_buffer_t buf;
+ if ((zoption = get_option(options, ZEND_STRL("contentDisposition"), &zoption_tmp))) {
- php_http_buffer_init(&buf);
- if (php_http_params_to_string(&buf, Z_ARRVAL_P(zoption_copy), ZEND_STRL(","), ZEND_STRL(";"), ZEND_STRL("="), PHP_HTTP_PARAMS_DEFAULT TSRMLS_CC)) {
- if (buf.used) {
- ret = r->ops->set_header(r, "Content-Disposition: %.*s", buf.used, buf.data);
+ if (Z_TYPE_P(zoption) == IS_ARRAY) {
+ php_http_buffer_t buf;
+
+ php_http_buffer_init(&buf);
+ if (php_http_params_to_string(&buf, Z_ARRVAL_P(zoption), ZEND_STRL(","), ZEND_STRL(";"), ZEND_STRL("="), PHP_HTTP_PARAMS_DEFAULT)) {
+ if (buf.used) {
+ ret = r->ops->set_header(r, "Content-Disposition: %.*s", buf.used, buf.data);
+ }
}
- }
- php_http_buffer_dtor(&buf);
- zval_ptr_dtor(&zoption_copy);
- zval_ptr_dtor(&zoption);
+ php_http_buffer_dtor(&buf);
+ }
+ zval_ptr_dtor(zoption);
}
if (ret != SUCCESS) {
return ret;
}
- if ((zoption = get_option(options, ZEND_STRL("contentEncoding") TSRMLS_CC))) {
- zval *zoption_copy = php_http_ztyp(IS_LONG, zoption);
+ if ((zoption = get_option(options, ZEND_STRL("contentEncoding"), &zoption_tmp))) {
+ zend_long ce = zval_get_long(zoption);
zval zsupported;
HashTable *result = NULL;
- zval_ptr_dtor(&zoption);
- switch (Z_LVAL_P(zoption_copy)) {
+ zval_ptr_dtor(zoption);
+ switch (ce) {
case PHP_HTTP_CONTENT_ENCODING_GZIP:
- INIT_PZVAL(&zsupported);
array_init(&zsupported);
- add_next_index_stringl(&zsupported, ZEND_STRL("none"), 1);
- add_next_index_stringl(&zsupported, ZEND_STRL("gzip"), 1);
- add_next_index_stringl(&zsupported, ZEND_STRL("deflate"), 1);
+ add_next_index_stringl(&zsupported, ZEND_STRL("none"));
+ add_next_index_stringl(&zsupported, ZEND_STRL("gzip"));
+ add_next_index_stringl(&zsupported, ZEND_STRL("deflate"));
- if ((result = php_http_negotiate_encoding(Z_ARRVAL(zsupported), request TSRMLS_CC))) {
- char *key_str = NULL;
- uint key_len = 0;
+ if ((result = php_http_negotiate_encoding(Z_ARRVAL(zsupported), request))) {
+ zend_string *key_str = NULL;
+ zend_ulong index = 0;
zend_hash_internal_pointer_reset(result);
- if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(result, &key_str, &key_len, NULL, 0, NULL)) {
- if (!strcmp(key_str, "gzip")) {
- if (!(r->content.encoder = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_deflate_ops(), PHP_HTTP_DEFLATE_TYPE_GZIP TSRMLS_CC))) {
+ if (HASH_KEY_IS_STRING == zend_hash_get_current_key(result, &key_str, &index)) {
+ if (zend_string_equals_literal(key_str, "gzip")) {
+ if (!(r->content.encoder = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_deflate_ops(), PHP_HTTP_DEFLATE_TYPE_GZIP))) {
ret = FAILURE;
} else if (SUCCESS == (ret = r->ops->set_header(r, "Content-Encoding: gzip"))) {
- r->content.encoding = estrndup(key_str, key_len - 1);
+ r->content.encoding = estrndup(key_str->val, key_str->len);
}
- } else if (!strcmp(key_str, "deflate")) {
- if (!(r->content.encoder = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_deflate_ops(), PHP_HTTP_DEFLATE_TYPE_ZLIB TSRMLS_CC))) {
+ } else if (zend_string_equals_literal(key_str, "deflate")) {
+ if (!(r->content.encoder = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_deflate_ops(), PHP_HTTP_DEFLATE_TYPE_ZLIB))) {
ret = FAILURE;
} else if (SUCCESS == (ret = r->ops->set_header(r, "Content-Encoding: deflate"))) {
- r->content.encoding = estrndup(key_str, key_len - 1);
+ r->content.encoding = estrndup(key_str->val, key_str->len);
}
} else {
ret = r->ops->del_header(r, ZEND_STRL("Content-Encoding"));
ret = r->ops->del_header(r, ZEND_STRL("Content-Encoding"));
break;
}
- zval_ptr_dtor(&zoption_copy);
}
if (SUCCESS != ret) {
}
if (php_http_env_response_is_cacheable(r, request)) {
- switch (php_http_env_is_response_cached_by_etag(options, ZEND_STRL("If-None-Match"), request TSRMLS_CC)) {
+ switch (php_http_env_is_response_cached_by_etag(options, ZEND_STRL("If-None-Match"), request)) {
case PHP_HTTP_CACHE_MISS:
break;
case PHP_HTTP_CACHE_NO:
- if (PHP_HTTP_CACHE_HIT != php_http_env_is_response_cached_by_last_modified(options, ZEND_STRL("If-Modified-Since"), request TSRMLS_CC)) {
+ if (PHP_HTTP_CACHE_HIT != php_http_env_is_response_cached_by_last_modified(options, ZEND_STRL("If-Modified-Since"), request)) {
break;
}
/* no break */
break;
}
- if ((zoption = get_option(options, ZEND_STRL("etag") TSRMLS_CC))) {
- zval *zoption_copy = php_http_ztyp(IS_STRING, zoption);
+ if ((zoption = get_option(options, ZEND_STRL("etag"), &zoption_tmp))) {
+ zend_string *zs = zval_get_string(zoption);
- zval_ptr_dtor(&zoption);
- if (*Z_STRVAL_P(zoption_copy) != '"' && strncmp(Z_STRVAL_P(zoption_copy), "W/\"", 3)) {
- ret = r->ops->set_header(r, "ETag: \"%s\"", Z_STRVAL_P(zoption_copy));
+ zval_ptr_dtor(zoption);
+ if (*zs->val != '"' && strncmp(zs->val, "W/\"", 3)) {
+ ret = r->ops->set_header(r, "ETag: \"%s\"", zs->val);
} else {
- ret = r->ops->set_header(r, "ETag: %s", Z_STRVAL_P(zoption_copy));
+ ret = r->ops->set_header(r, "ETag: %s", zs->val);
}
- zval_ptr_dtor(&zoption_copy);
+ zend_string_release(zs);
}
- if ((zoption = get_option(options, ZEND_STRL("lastModified") TSRMLS_CC))) {
- zval *zoption_copy = php_http_ztyp(IS_LONG, zoption);
+ if ((zoption = get_option(options, ZEND_STRL("lastModified"), &zoption_tmp))) {
+ zend_long lm = zval_get_long(zoption);
- zval_ptr_dtor(&zoption);
- if (Z_LVAL_P(zoption_copy)) {
- char *date = php_format_date(ZEND_STRL(PHP_HTTP_DATE_FORMAT), Z_LVAL_P(zoption_copy), 0 TSRMLS_CC);
+ zval_ptr_dtor(zoption);
+ if (lm) {
+ zend_string *date = php_format_date(ZEND_STRL(PHP_HTTP_DATE_FORMAT), lm, 0);
if (date) {
- ret = r->ops->set_header(r, "Last-Modified: %s", date);
- efree(date);
+ ret = r->ops->set_header(r, "Last-Modified: %s", date->val);
+ zend_string_release(date);
}
}
- zval_ptr_dtor(&zoption_copy);
}
}
}
return ret;
}
-static STATUS php_http_env_response_send_body(php_http_env_response_t *r)
+static ZEND_RESULT_CODE php_http_env_response_send_body(php_http_env_response_t *r)
{
- STATUS ret = SUCCESS;
- zval *zoption;
+ ZEND_RESULT_CODE ret = SUCCESS;
+ zval zoption_tmp, *zoption;
php_http_message_body_t *body;
- TSRMLS_FETCH_FROM_CTX(r->ts);
if (r->done) {
return ret;
}
- if ((body = get_body(r->options TSRMLS_CC))) {
- if ((zoption = get_option(r->options, ZEND_STRL("throttleDelay") TSRMLS_CC))) {
- if (Z_TYPE_P(zoption) == IS_DOUBLE) {
- r->throttle.delay = Z_DVAL_P(zoption);
- }
- zval_ptr_dtor(&zoption);
+ if ((body = get_body(&r->options))) {
+ if ((zoption = get_option(&r->options, ZEND_STRL("throttleDelay"), &zoption_tmp))) {
+ r->throttle.delay = zval_get_double(zoption);
+ zval_ptr_dtor(zoption);
}
- if ((zoption = get_option(r->options, ZEND_STRL("throttleChunk") TSRMLS_CC))) {
- if (Z_TYPE_P(zoption) == IS_LONG) {
- r->throttle.chunk = Z_LVAL_P(zoption);
- }
- zval_ptr_dtor(&zoption);
+ if ((zoption = get_option(&r->options, ZEND_STRL("throttleChunk"), &zoption_tmp))) {
+ r->throttle.chunk = zval_get_long(zoption);
+ zval_ptr_dtor(zoption);
}
if (r->range.status == PHP_HTTP_RANGE_OK) {
if (zend_hash_num_elements(&r->range.values) == 1) {
/* single range */
- zval **range, **begin, **end;
+ zval *range, *begin, *end;
- if ( 1 == php_http_array_list(&r->range.values TSRMLS_CC, 1, &range)
- && 2 == php_http_array_list(Z_ARRVAL_PP(range) TSRMLS_CC, 2, &begin, &end)
+ if ( 1 == php_http_array_list(&r->range.values, 1, &range)
+ && 2 == php_http_array_list(Z_ARRVAL_P(range), 2, &begin, &end)
) {
/* send chunk */
- ret = php_http_message_body_to_callback(body, (php_http_pass_callback_t) php_http_env_response_send_data, r, Z_LVAL_PP(begin), Z_LVAL_PP(end) - Z_LVAL_PP(begin) + 1);
+ ret = php_http_message_body_to_callback(body, (php_http_pass_callback_t) php_http_env_response_send_data, r, Z_LVAL_P(begin), Z_LVAL_P(end) - Z_LVAL_P(begin) + 1);
if (ret == SUCCESS) {
ret = php_http_env_response_send_done(r);
}
} else {
/* send multipart/byte-ranges message */
- HashPosition pos;
- zval **chunk;
+ zval *chunk;
- FOREACH_HASH_VAL(pos, &r->range.values, chunk) {
- zval **begin, **end;
+ ZEND_HASH_FOREACH_VAL(&r->range.values, chunk)
+ {
+ zval *begin, *end;
- if (2 == php_http_array_list(Z_ARRVAL_PP(chunk) TSRMLS_CC, 2, &begin, &end)) {
+ if (2 == php_http_array_list(Z_ARRVAL_P(chunk), 2, &begin, &end)) {
php_http_buffer_appendf(r->buffer,
PHP_HTTP_CRLF
"--%s" PHP_HTTP_CRLF
/* - */
r->range.boundary,
r->content.type ? r->content.type : "application/octet-stream",
- Z_LVAL_PP(begin),
- Z_LVAL_PP(end),
+ Z_LVAL_P(begin),
+ Z_LVAL_P(end),
r->content.length
);
- ret = php_http_message_body_to_callback(body, (php_http_pass_callback_t) php_http_env_response_send_data, r, Z_LVAL_PP(begin), Z_LVAL_PP(end) - Z_LVAL_PP(begin) + 1);
+ ret = php_http_message_body_to_callback(body, (php_http_pass_callback_t) php_http_env_response_send_data, r, Z_LVAL_P(begin), Z_LVAL_P(end) - Z_LVAL_P(begin) + 1);
}
}
+ ZEND_HASH_FOREACH_END();
if (ret == SUCCESS) {
php_http_buffer_appendf(r->buffer, PHP_HTTP_CRLF "--%s--", r->range.boundary);
return ret;
}
-STATUS php_http_env_response_send(php_http_env_response_t *r)
+ZEND_RESULT_CODE php_http_env_response_send(php_http_env_response_t *r)
{
php_http_message_t *request;
php_http_message_body_t *body;
- TSRMLS_FETCH_FROM_CTX(r->ts);
- request = get_request(r->options TSRMLS_CC);
+ request = get_request(&r->options);
/* check for ranges */
- if ((body = get_body(r->options TSRMLS_CC))) {
+ if ((body = get_body(&r->options))) {
r->content.length = php_http_message_body_size(body);
if (SUCCESS != r->ops->set_header(r, "Accept-Ranges: bytes")) {
return FAILURE;
} else {
- zend_hash_init(&r->range.values, 0, NULL, ZVAL_PTR_DTOR, 0);
- r->range.status = php_http_env_get_request_ranges(&r->range.values, r->content.length, request TSRMLS_CC);
+ ZEND_INIT_SYMTABLE_EX(&r->range.values, 0, 0);
+ r->range.status = php_http_env_get_request_ranges(&r->range.values, r->content.length, request);
switch (r->range.status) {
case PHP_HTTP_RANGE_NO:
break;
case PHP_HTTP_RANGE_ERR:
- if (php_http_env_got_request_header(ZEND_STRL("If-Range"), request TSRMLS_CC)) {
+ if (php_http_env_got_request_header(ZEND_STRL("If-Range"), request)) {
r->range.status = PHP_HTTP_RANGE_NO;
zend_hash_destroy(&r->range.values);
} else {
break;
case PHP_HTTP_RANGE_OK:
- if (PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_etag(r->options, ZEND_STRL("If-Range"), request TSRMLS_CC)
- || PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_last_modified(r->options, ZEND_STRL("If-Range"), request TSRMLS_CC)
+ if (PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_etag(&r->options, ZEND_STRL("If-Range"), request)
+ || PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_last_modified(&r->options, ZEND_STRL("If-Range"), request)
) {
r->range.status = PHP_HTTP_RANGE_NO;
zend_hash_destroy(&r->range.values);
break;
}
- if (PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_etag(r->options, ZEND_STRL("If-Match"), request TSRMLS_CC)
- || PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_last_modified(r->options, ZEND_STRL("If-Unmodified-Since"), request TSRMLS_CC)
- || PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_last_modified(r->options, ZEND_STRL("Unless-Modified-Since"), request TSRMLS_CC)
+ if (PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_etag(&r->options, ZEND_STRL("If-Match"), request)
+ || PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_last_modified(&r->options, ZEND_STRL("If-Unmodified-Since"), request)
+ || PHP_HTTP_CACHE_MISS == php_http_env_is_response_cached_by_last_modified(&r->options, ZEND_STRL("Unless-Modified-Since"), request)
) {
r->done = 1;
zend_hash_destroy(&r->range.values);
}
if (SUCCESS != php_http_env_response_send_head(r, request)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to send response headers");
+ php_error_docref(NULL, E_WARNING, "Failed to send response headers");
return FAILURE;
}
if (SUCCESS != php_http_env_response_send_body(r)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to send response body");
+ php_error_docref(NULL, E_WARNING, "Failed to send response body");
return FAILURE;
}
if (SUCCESS != r->ops->finish(r)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to finish response");
+ php_error_docref(NULL, E_WARNING, "Failed to finish response");
return FAILURE;
}
static long php_http_env_response_sapi_get_status(php_http_env_response_t *r)
{
- TSRMLS_FETCH_FROM_CTX(r->ts);
-
- return php_http_env_get_response_code(TSRMLS_C);
+ return php_http_env_get_response_code();
}
-static STATUS php_http_env_response_sapi_set_status(php_http_env_response_t *r, long http_code)
+static ZEND_RESULT_CODE php_http_env_response_sapi_set_status(php_http_env_response_t *r, long http_code)
{
- TSRMLS_FETCH_FROM_CTX(r->ts);
-
- return php_http_env_set_response_code(http_code TSRMLS_CC);
+ return php_http_env_set_response_code(http_code);
}
-static STATUS php_http_env_response_sapi_set_protocol_version(php_http_env_response_t *r, php_http_version_t *v)
+static ZEND_RESULT_CODE php_http_env_response_sapi_set_protocol_version(php_http_env_response_t *r, php_http_version_t *v)
{
- TSRMLS_FETCH_FROM_CTX(r->ts);
- return php_http_env_set_response_protocol_version(v TSRMLS_CC);
+ return php_http_env_set_response_protocol_version(v);
}
-static STATUS php_http_env_response_sapi_set_header(php_http_env_response_t *r, const char *fmt, ...)
+static ZEND_RESULT_CODE php_http_env_response_sapi_set_header(php_http_env_response_t *r, const char *fmt, ...)
{
- STATUS ret;
+ ZEND_RESULT_CODE ret;
va_list args;
- TSRMLS_FETCH_FROM_CTX(r->ts);
va_start(args, fmt);
- ret = php_http_env_set_response_header_va(0, 1, fmt, args TSRMLS_CC);
+ ret = php_http_env_set_response_header_va(0, 1, fmt, args);
va_end(args);
return ret;
}
-static STATUS php_http_env_response_sapi_add_header(php_http_env_response_t *r, const char *fmt, ...)
+static ZEND_RESULT_CODE php_http_env_response_sapi_add_header(php_http_env_response_t *r, const char *fmt, ...)
{
- STATUS ret;
+ ZEND_RESULT_CODE ret;
va_list args;
- TSRMLS_FETCH_FROM_CTX(r->ts);
va_start(args, fmt);
- ret = php_http_env_set_response_header_va(0, 0, fmt, args TSRMLS_CC);
+ ret = php_http_env_set_response_header_va(0, 0, fmt, args);
va_end(args);
return ret;
}
-static STATUS php_http_env_response_sapi_del_header(php_http_env_response_t *r, const char *header_str, size_t header_len)
+static ZEND_RESULT_CODE php_http_env_response_sapi_del_header(php_http_env_response_t *r, const char *header_str, size_t header_len)
{
- TSRMLS_FETCH_FROM_CTX(r->ts);
-
- return php_http_env_set_response_header_value(0, header_str, header_len, NULL, 1 TSRMLS_CC);
+ return php_http_env_set_response_header_value(0, header_str, header_len, NULL, 1);
}
-static STATUS php_http_env_response_sapi_write(php_http_env_response_t *r, const char *data_str, size_t data_len)
+static ZEND_RESULT_CODE php_http_env_response_sapi_write(php_http_env_response_t *r, const char *data_str, size_t data_len)
{
- TSRMLS_FETCH_FROM_CTX(r->ts);
-
if (0 < PHPWRITE(data_str, data_len)) {
return SUCCESS;
}
return FAILURE;
}
-static STATUS php_http_env_response_sapi_flush(php_http_env_response_t *r)
+static ZEND_RESULT_CODE php_http_env_response_sapi_flush(php_http_env_response_t *r)
{
- TSRMLS_FETCH_FROM_CTX(r->ts);
-
-#if PHP_VERSION_ID >= 50400
- if (php_output_get_level(TSRMLS_C)) {
- php_output_flush_all(TSRMLS_C);
+ if (php_output_get_level()) {
+ php_output_flush_all();
}
- if (!(php_output_get_status(TSRMLS_C) & PHP_OUTPUT_IMPLICITFLUSH)) {
- sapi_flush(TSRMLS_C);
+ if (!(php_output_get_status() & PHP_OUTPUT_IMPLICITFLUSH)) {
+ sapi_flush();
}
-#else
- php_end_ob_buffer(1, 1 TSRMLS_CC);
- sapi_flush(TSRMLS_C);
-#endif
return SUCCESS;
}
-static STATUS php_http_env_response_sapi_finish(php_http_env_response_t *r)
+static ZEND_RESULT_CODE php_http_env_response_sapi_finish(php_http_env_response_t *r)
{
return SUCCESS;
}
long status_code;
php_stream *stream;
+ php_http_message_t *request;
unsigned started:1;
unsigned finished:1;
+ unsigned chunked:1;
} php_http_env_response_stream_ctx_t;
-static STATUS php_http_env_response_stream_init(php_http_env_response_t *r, void *init_arg)
+static ZEND_RESULT_CODE php_http_env_response_stream_init(php_http_env_response_t *r, void *init_arg)
{
php_http_env_response_stream_ctx_t *ctx;
- TSRMLS_FETCH_FROM_CTX(r->ts);
ctx = ecalloc(1, sizeof(*ctx));
ctx->stream = init_arg;
- if (SUCCESS != zend_list_addref(ctx->stream->rsrc_id)) {
- efree(ctx);
- return FAILURE;
- }
- zend_hash_init(&ctx->header, 0, NULL, ZVAL_PTR_DTOR, 0);
- php_http_version_init(&ctx->version, 1, 1 TSRMLS_CC);
+ ++GC_REFCOUNT(ctx->stream->res);
+ ZEND_INIT_SYMTABLE(&ctx->header);
+ php_http_version_init(&ctx->version, 1, 1);
ctx->status_code = 200;
- ctx->request = get_request(r->options TSRMLS_CC);
+ ctx->chunked = 1;
++ ctx->request = get_request(&r->options);
+
+ /* there are some limitations regarding TE:chunked, see https://tools.ietf.org/html/rfc7230#section-3.3.1 */
+ if (ctx->request && ctx->request->http.version.major == 1 && ctx->request->http.version.minor == 0) {
+ ctx->version.minor = 0;
+ }
r->ctx = ctx;
static void php_http_env_response_stream_dtor(php_http_env_response_t *r)
{
php_http_env_response_stream_ctx_t *ctx = r->ctx;
- TSRMLS_FETCH_FROM_CTX(r->ts);
zend_hash_destroy(&ctx->header);
- zend_list_delete(ctx->stream->rsrc_id);
+ zend_list_delete(ctx->stream->res);
efree(ctx);
r->ctx = NULL;
}
-static void php_http_env_response_stream_header(php_http_env_response_stream_ctx_t *ctx, HashTable *header TSRMLS_DC)
+static void php_http_env_response_stream_header(php_http_env_response_stream_ctx_t *ctx, HashTable *header)
{
- HashPosition pos;
- zval **val;
+ zval *val;
- FOREACH_HASH_VAL(pos, header, val) {
- if (Z_TYPE_PP(val) == IS_ARRAY) {
- php_http_env_response_stream_header(ctx, Z_ARRVAL_PP(val) TSRMLS_CC);
+ ZEND_HASH_FOREACH_VAL(header, val)
+ {
+ if (Z_TYPE_P(val) == IS_ARRAY) {
+ php_http_env_response_stream_header(ctx, Z_ARRVAL_P(val));
} else {
- zval *tmp = php_http_ztyp(IS_STRING, *val);
+ zend_string *zs = zval_get_string(val);
- if (!strncasecmp(Z_STRVAL_P(tmp), "Content-Length:", lenof("Content-Length:"))) {
+ if (ctx->chunked) {
+ /* disable chunked transfer encoding if we've got an explicit content-length */
- php_stream_write(ctx->stream, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
++ if (!strncasecmp(zs->val, "Content-Length:", lenof("Content-Length:"))) {
+ ctx->chunked = 0;
+ }
+ }
+ php_stream_write(ctx->stream, zs->val, zs->len);
php_stream_write_string(ctx->stream, PHP_HTTP_CRLF);
- zval_ptr_dtor(&tmp);
+ zend_string_release(zs);
}
}
+ ZEND_HASH_FOREACH_END();
}
-static STATUS php_http_env_response_stream_start(php_http_env_response_stream_ctx_t *ctx TSRMLS_DC)
+static ZEND_RESULT_CODE php_http_env_response_stream_start(php_http_env_response_stream_ctx_t *ctx)
{
if (ctx->started || ctx->finished) {
return FAILURE;
}
-- php_stream_printf(ctx->stream TSRMLS_CC, "HTTP/%u.%u %ld %s" PHP_HTTP_CRLF, ctx->version.major, ctx->version.minor, ctx->status_code, php_http_env_get_response_status_for_code(ctx->status_code));
++ php_stream_printf(ctx->stream, "HTTP/%u.%u %ld %s" PHP_HTTP_CRLF, ctx->version.major, ctx->version.minor, ctx->status_code, php_http_env_get_response_status_for_code(ctx->status_code));
+
+ /* there are some limitations regarding TE:chunked, see https://tools.ietf.org/html/rfc7230#section-3.3.1 */
+ if (ctx->version.major == 1 && ctx->version.minor == 0) {
+ ctx->chunked = 0;
+ } else if (ctx->status_code == 204 || ctx->status_code/100 == 1) {
+ ctx->chunked = 0;
+ } else if (ctx->request && ctx->status_code/100 == 2 && !strcasecmp(ctx->request->http.info.request.method, "CONNECT")) {
+ ctx->chunked = 0;
+ }
+
- php_http_env_response_stream_header(ctx, &ctx->header TSRMLS_CC);
+ php_http_env_response_stream_header(ctx, &ctx->header);
+
+ /* enable chunked transfer encoding */
+ if (ctx->chunked) {
+ php_stream_write_string(ctx->stream, "Transfer-Encoding: chunked" PHP_HTTP_CRLF);
+ }
++
php_stream_write_string(ctx->stream, PHP_HTTP_CRLF);
+
ctx->started = 1;
+
return SUCCESS;
}
static long php_http_env_response_stream_get_status(php_http_env_response_t *r)
return ctx->status_code;
}
-static STATUS php_http_env_response_stream_set_status(php_http_env_response_t *r, long http_code)
+static ZEND_RESULT_CODE php_http_env_response_stream_set_status(php_http_env_response_t *r, long http_code)
{
php_http_env_response_stream_ctx_t *stream_ctx = r->ctx;
return SUCCESS;
}
-static STATUS php_http_env_response_stream_set_protocol_version(php_http_env_response_t *r, php_http_version_t *v)
+static ZEND_RESULT_CODE php_http_env_response_stream_set_protocol_version(php_http_env_response_t *r, php_http_version_t *v)
{
php_http_env_response_stream_ctx_t *stream_ctx = r->ctx;
return SUCCESS;
}
-static STATUS php_http_env_response_stream_set_header_ex(php_http_env_response_t *r, zend_bool replace, const char *fmt, va_list argv)
+static ZEND_RESULT_CODE php_http_env_response_stream_set_header_ex(php_http_env_response_t *r, zend_bool replace, const char *fmt, va_list argv)
{
php_http_env_response_stream_ctx_t *stream_ctx = r->ctx;
char *header_end, *header_str = NULL;
size_t header_len = 0;
- zval *zheader, **zheader_ptr;
+ zval zheader, *zheader_ptr;
+ zend_string *header_key;
+ ZEND_RESULT_CODE rv;
if (stream_ctx->started || stream_ctx->finished) {
return FAILURE;
return FAILURE;
}
- *header_end = '\0';
+ header_key = zend_string_init(header_str, header_end - header_str, 0);
- if (!replace && (SUCCESS == zend_hash_find(&stream_ctx->header, header_str, header_end - header_str + 1, (void *) &zheader_ptr))) {
- convert_to_array(*zheader_ptr);
- *header_end = ':';
- return add_next_index_stringl(*zheader_ptr, header_str, header_len, 0);
+ if (!replace && (zheader_ptr = zend_hash_find(&stream_ctx->header, header_key))) {
+ convert_to_array(zheader_ptr);
+ rv = add_next_index_str(zheader_ptr, php_http_cs2zs(header_str, header_len));
} else {
- MAKE_STD_ZVAL(zheader);
- ZVAL_STRINGL(zheader, header_str, header_len, 0);
-
- if (SUCCESS != zend_hash_update(&stream_ctx->header, header_str, header_end - header_str + 1, (void *) &zheader, sizeof(zval *), NULL)) {
- zval_ptr_dtor(&zheader);
- return FAILURE;
- }
+ ZVAL_STR(&zheader, php_http_cs2zs(header_str, header_len));
- *header_end = ':';
- return SUCCESS;
+ rv = zend_hash_update(&stream_ctx->header, header_key, &zheader)
+ ? SUCCESS : FAILURE;
}
+
+ zend_string_release(header_key);
+
+ return rv;
}
-static STATUS php_http_env_response_stream_set_header(php_http_env_response_t *r, const char *fmt, ...)
+static ZEND_RESULT_CODE php_http_env_response_stream_set_header(php_http_env_response_t *r, const char *fmt, ...)
{
- STATUS ret;
+ ZEND_RESULT_CODE ret;
va_list argv;
va_start(argv, fmt);
return ret;
}
-static STATUS php_http_env_response_stream_add_header(php_http_env_response_t *r, const char *fmt, ...)
+static ZEND_RESULT_CODE php_http_env_response_stream_add_header(php_http_env_response_t *r, const char *fmt, ...)
{
- STATUS ret;
+ ZEND_RESULT_CODE ret;
va_list argv;
va_start(argv, fmt);
return ret;
}
-static STATUS php_http_env_response_stream_del_header(php_http_env_response_t *r, const char *header_str, size_t header_len)
+static ZEND_RESULT_CODE php_http_env_response_stream_del_header(php_http_env_response_t *r, const char *header_str, size_t header_len)
{
php_http_env_response_stream_ctx_t *stream_ctx = r->ctx;
return FAILURE;
}
- zend_hash_del(&stream_ctx->header, header_str, header_len + 1);
+ zend_hash_str_del(&stream_ctx->header, header_str, header_len);
return SUCCESS;
}
-static STATUS php_http_env_response_stream_write(php_http_env_response_t *r, const char *data_str, size_t data_len)
+static ZEND_RESULT_CODE php_http_env_response_stream_write(php_http_env_response_t *r, const char *data_str, size_t data_len)
{
php_http_env_response_stream_ctx_t *stream_ctx = r->ctx;
- TSRMLS_FETCH_FROM_CTX(r->ts);
if (stream_ctx->finished) {
return FAILURE;
}
if (!stream_ctx->started) {
- if (SUCCESS != php_http_env_response_stream_start(stream_ctx TSRMLS_CC)) {
+ if (SUCCESS != php_http_env_response_stream_start(stream_ctx)) {
return FAILURE;
}
}
+ if (stream_ctx->chunked && 0 == php_stream_printf(stream_ctx->stream TSRMLS_CC, "%lx" PHP_HTTP_CRLF, (unsigned long) data_len)) {
+ return FAILURE;
+ }
+
if (data_len != php_stream_write(stream_ctx->stream, data_str, data_len)) {
return FAILURE;
}
+ if (stream_ctx->chunked && 2 != php_stream_write_string(stream_ctx->stream, PHP_HTTP_CRLF)) {
+ return FAILURE;
+ }
+
return SUCCESS;
}
-static STATUS php_http_env_response_stream_flush(php_http_env_response_t *r)
+static ZEND_RESULT_CODE php_http_env_response_stream_flush(php_http_env_response_t *r)
{
php_http_env_response_stream_ctx_t *stream_ctx = r->ctx;
- TSRMLS_FETCH_FROM_CTX(r->ts);
if (stream_ctx->finished) {
return FAILURE;
}
if (!stream_ctx->started) {
- if (SUCCESS != php_http_env_response_stream_start(stream_ctx TSRMLS_CC)) {
+ if (SUCCESS != php_http_env_response_stream_start(stream_ctx)) {
return FAILURE;
}
}
return php_stream_flush(stream_ctx->stream);
}
-static STATUS php_http_env_response_stream_finish(php_http_env_response_t *r)
+static ZEND_RESULT_CODE php_http_env_response_stream_finish(php_http_env_response_t *r)
{
php_http_env_response_stream_ctx_t *stream_ctx = r->ctx;
- TSRMLS_FETCH_FROM_CTX(r->ts);
if (stream_ctx->finished) {
return FAILURE;
}
if (!stream_ctx->started) {
- if (SUCCESS != php_http_env_response_stream_start(stream_ctx TSRMLS_CC)) {
+ if (SUCCESS != php_http_env_response_stream_start(stream_ctx)) {
return FAILURE;
}
}
+ if (stream_ctx->chunked && 5 != php_stream_write_string(stream_ctx->stream, "0" PHP_HTTP_CRLF PHP_HTTP_CRLF)) {
+ return FAILURE;
+ }
+
stream_ctx->finished = 1;
return SUCCESS;
#define PHP_HTTP_ENV_RESPONSE_OBJECT_INIT(obj) \
do { \
if (!obj->message) { \
- obj->message = php_http_message_init_env(NULL, PHP_HTTP_RESPONSE TSRMLS_CC); \
+ obj->message = php_http_message_init_env(NULL, PHP_HTTP_RESPONSE); \
} \
} while (0)
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
- php_http_expect(obj->message = php_http_message_init_env(obj->message, PHP_HTTP_RESPONSE TSRMLS_CC), unexpected_val, return);
+ php_http_expect(obj->message = php_http_message_init_env(obj->message, PHP_HTTP_RESPONSE), unexpected_val, return);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse___invoke, 0, 0, 1)
static PHP_METHOD(HttpEnvResponse, __invoke)
{
char *ob_str;
- int ob_len;
- long ob_flags = 0;
+ size_t ob_len;
+ zend_long ob_flags = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &ob_str, &ob_len, &ob_flags)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &ob_str, &ob_len, &ob_flags)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_ENV_RESPONSE_OBJECT_INIT(obj);
php_http_message_object_init_body_object(obj);
php_http_message_body_append(obj->message->body, ob_str, ob_len);
-#if PHP_VERSION_ID >= 50400
RETURN_TRUE;
-#else
- RETURN_EMPTY_STRING();
-#endif
}
}
{
zval *env_req = NULL;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O", &env_req, php_http_message_class_entry), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|O", &env_req, php_http_message_class_entry), invalid_arg, return);
- set_option(getThis(), ZEND_STRL("request"), IS_OBJECT, env_req, 0 TSRMLS_CC);
- RETVAL_ZVAL(getThis(), 1, 0);
+ set_option(getThis(), ZEND_STRL("request"), IS_OBJECT, env_req, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_setContentType, 0, 0, 1)
static PHP_METHOD(HttpEnvResponse, setContentType)
{
char *ct_str = NULL;
- int ct_len = 0;
+ size_t ct_len = 0;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!", &ct_str, &ct_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s!", &ct_str, &ct_len), invalid_arg, return);
- set_option(getThis(), ZEND_STRL("contentType"), IS_STRING, ct_str, ct_len TSRMLS_CC);
- RETVAL_ZVAL(getThis(), 1, 0);
+ set_option(getThis(), ZEND_STRL("contentType"), IS_STRING, ct_str, ct_len);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_setContentDisposition, 0, 0, 1)
{
zval *zdisposition;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &zdisposition), invalid_arg, return);
+ 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 TSRMLS_CC);
- RETVAL_ZVAL(getThis(), 1, 0);
+ zend_update_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("contentDisposition"), zdisposition);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_setContentEncoding, 0, 0, 1)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpEnvResponse, setContentEncoding)
{
- long ce;
+ zend_long ce;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ce), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "l", &ce), invalid_arg, return);
- set_option(getThis(), ZEND_STRL("contentEncoding"), IS_LONG, &ce, 0 TSRMLS_CC);
- RETVAL_ZVAL(getThis(), 1, 0);
+ set_option(getThis(), ZEND_STRL("contentEncoding"), IS_LONG, &ce, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_setCacheControl, 0, 0, 1)
static PHP_METHOD(HttpEnvResponse, setCacheControl)
{
char *cc_str = NULL;
- int cc_len = 0;
+ size_t cc_len = 0;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!", &cc_str, &cc_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s!", &cc_str, &cc_len), invalid_arg, return);
- set_option(getThis(), ZEND_STRL("cacheControl"), IS_STRING, cc_str, cc_len TSRMLS_CC);
- RETVAL_ZVAL(getThis(), 1, 0);
+ set_option(getThis(), ZEND_STRL("cacheControl"), IS_STRING, cc_str, cc_len);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_setLastModified, 0, 0, 1)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpEnvResponse, setLastModified)
{
- long last_modified;
+ zend_long last_modified;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &last_modified), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "l", &last_modified), invalid_arg, return);
- set_option(getThis(), ZEND_STRL("lastModified"), IS_LONG, &last_modified, 0 TSRMLS_CC);
- RETVAL_ZVAL(getThis(), 1, 0);
+ set_option(getThis(), ZEND_STRL("lastModified"), IS_LONG, &last_modified, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_isCachedByLastModified, 0, 0, 0)
static PHP_METHOD(HttpEnvResponse, isCachedByLastModified)
{
char *header_name_str = NULL;
- int header_name_len = 0;
+ size_t header_name_len = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &header_name_str, &header_name_len)) {
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s!", &header_name_str, &header_name_len)) {
if (!header_name_str || !header_name_len) {
header_name_str = "If-Modified-Since";
header_name_len = lenof("If-Modified-Since");
}
- RETURN_LONG(php_http_env_is_response_cached_by_last_modified(getThis(), header_name_str, header_name_len, get_request(getThis() TSRMLS_CC) TSRMLS_CC));
+ RETURN_LONG(php_http_env_is_response_cached_by_last_modified(getThis(), header_name_str, header_name_len, get_request(getThis())));
}
}
static PHP_METHOD(HttpEnvResponse, setEtag)
{
char *etag_str = NULL;
- int etag_len = 0;
+ size_t etag_len = 0;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!", &etag_str, &etag_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s!", &etag_str, &etag_len), invalid_arg, return);
- set_option(getThis(), ZEND_STRL("etag"), IS_STRING, etag_str, etag_len TSRMLS_CC);
- RETVAL_ZVAL(getThis(), 1, 0);
+ set_option(getThis(), ZEND_STRL("etag"), IS_STRING, etag_str, etag_len);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_isCachedByEtag, 0, 0, 0)
static PHP_METHOD(HttpEnvResponse, isCachedByEtag)
{
char *header_name_str = NULL;
- int header_name_len = 0;
+ size_t header_name_len = 0;
if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &header_name_str, &header_name_len)) {
if (!header_name_str || !header_name_len) {
header_name_str = "If-None-Match";
header_name_len = lenof("If-None-Match");
}
- RETURN_LONG(php_http_env_is_response_cached_by_etag(getThis(), header_name_str, header_name_len, get_request(getThis() TSRMLS_CC) TSRMLS_CC));
+ RETURN_LONG(php_http_env_is_response_cached_by_etag(getThis(), header_name_str, header_name_len, get_request(getThis())));
}
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpEnvResponse, setThrottleRate)
{
- long chunk_size;
+ zend_long chunk_size;
double delay = 1;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|d", &chunk_size, &delay), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "l|d", &chunk_size, &delay), invalid_arg, return);
- set_option(getThis(), ZEND_STRL("throttleDelay"), IS_DOUBLE, &delay, 0 TSRMLS_CC);
- set_option(getThis(), ZEND_STRL("throttleChunk"), IS_LONG, &chunk_size, 0 TSRMLS_CC);
- RETVAL_ZVAL(getThis(), 1, 0);
+ set_option(getThis(), ZEND_STRL("throttleDelay"), IS_DOUBLE, &delay, 0);
+ set_option(getThis(), ZEND_STRL("throttleChunk"), IS_LONG, &chunk_size, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_setCookie, 0, 0, 1)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpEnvResponse, setCookie)
{
- zval *zcookie_new;
+ zval *zcookie_new, tmp;
+ zend_string *zs;
zend_error_handling zeh;
php_http_cookie_list_t *list = NULL;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zcookie_new), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcookie_new), invalid_arg, return);
- zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh);
switch (Z_TYPE_P(zcookie_new)) {
case IS_OBJECT:
- if (instanceof_function(Z_OBJCE_P(zcookie_new), php_http_cookie_class_entry TSRMLS_CC)) {
+ if (instanceof_function(Z_OBJCE_P(zcookie_new), php_http_cookie_class_entry)) {
Z_ADDREF_P(zcookie_new);
break;
}
/* no break */
case IS_ARRAY:
- list = php_http_cookie_list_from_struct(NULL, zcookie_new TSRMLS_CC);
- MAKE_STD_ZVAL(zcookie_new);
- ZVAL_OBJVAL(zcookie_new, php_http_cookie_object_new_ex(php_http_cookie_class_entry, list, NULL TSRMLS_CC), 0);
+ list = php_http_cookie_list_from_struct(NULL, zcookie_new);
+ zcookie_new = &tmp;
+ ZVAL_OBJECT(zcookie_new, &php_http_cookie_object_new_ex(php_http_cookie_class_entry, list)->zo, 1);
break;
default:
- zcookie_new = php_http_ztyp(IS_STRING, zcookie_new);
- list = php_http_cookie_list_parse(NULL, Z_STRVAL_P(zcookie_new), Z_STRLEN_P(zcookie_new), 0, NULL TSRMLS_CC);
- zval_ptr_dtor(&zcookie_new);
- MAKE_STD_ZVAL(zcookie_new);
- ZVAL_OBJVAL(zcookie_new, php_http_cookie_object_new_ex(php_http_cookie_class_entry, list, NULL TSRMLS_CC), 0);
+ zs = zval_get_string(zcookie_new);
+ list = php_http_cookie_list_parse(NULL, zs->val, zs->len, 0, NULL);
+ zend_string_release(zs);
+ zcookie_new = &tmp;
+ ZVAL_OBJECT(zcookie_new, &php_http_cookie_object_new_ex(php_http_cookie_class_entry, list)->zo, 1);
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
- set_cookie(getThis(), zcookie_new TSRMLS_CC);
- zval_ptr_dtor(&zcookie_new);
+ set_cookie(getThis(), zcookie_new);
+ zval_ptr_dtor(zcookie_new);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnvResponse_send, 0, 0, 0)
zval *zstream = NULL;
php_stream *s = NULL;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &zstream)) {
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|r", &zstream)) {
/* first flush the output layer to avoid conflicting headers and output;
* also, ob_start($thisEnvResponse) might have been called */
-#if PHP_VERSION_ID >= 50400
- php_output_end_all(TSRMLS_C);
-#else
- php_end_ob_buffers(1 TSRMLS_CC);
-#endif
+ php_output_end_all();
if (zstream) {
php_http_env_response_t *r;
- php_stream_from_zval(s, &zstream);
- r = php_http_env_response_init(NULL, getThis(), php_http_env_response_get_stream_ops(), s TSRMLS_CC);
+ php_stream_from_zval(s, zstream);
+ r = php_http_env_response_init(NULL, getThis(), php_http_env_response_get_stream_ops(), s);
if (!r) {
RETURN_FALSE;
}
} else {
php_http_env_response_t r;
- if (!php_http_env_response_init(&r, getThis(), NULL, NULL TSRMLS_CC)) {
+ if (!php_http_env_response_init(&r, getThis(), NULL, NULL)) {
RETURN_FALSE;
}
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http\\Env", "Response", php_http_env_response_methods);
- php_http_env_response_class_entry = zend_register_internal_class_ex(&ce, php_http_message_class_entry, NULL TSRMLS_CC);
-
- zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CONTENT_ENCODING_NONE"), PHP_HTTP_CONTENT_ENCODING_NONE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CONTENT_ENCODING_GZIP"), PHP_HTTP_CONTENT_ENCODING_GZIP TSRMLS_CC);
-
- zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CACHE_NO"), PHP_HTTP_CACHE_NO TSRMLS_CC);
- zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CACHE_HIT"), PHP_HTTP_CACHE_HIT TSRMLS_CC);
- zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CACHE_MISS"), PHP_HTTP_CACHE_MISS TSRMLS_CC);
-
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("request"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("cookies"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("contentType"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("contentDisposition"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("contentEncoding"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("cacheControl"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("etag"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("lastModified"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("throttleDelay"), ZEND_ACC_PROTECTED TSRMLS_CC);
- zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("throttleChunk"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ php_http_env_response_class_entry = zend_register_internal_class_ex(&ce, php_http_message_class_entry);
+
+ zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CONTENT_ENCODING_NONE"), PHP_HTTP_CONTENT_ENCODING_NONE);
+ zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CONTENT_ENCODING_GZIP"), PHP_HTTP_CONTENT_ENCODING_GZIP);
+
+ zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CACHE_NO"), PHP_HTTP_CACHE_NO);
+ zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CACHE_HIT"), PHP_HTTP_CACHE_HIT);
+ zend_declare_class_constant_long(php_http_env_response_class_entry, ZEND_STRL("CACHE_MISS"), PHP_HTTP_CACHE_MISS);
+
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("request"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("cookies"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("contentType"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("contentDisposition"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("contentEncoding"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("cacheControl"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("etag"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("lastModified"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("throttleDelay"), ZEND_ACC_PROTECTED);
+ zend_declare_property_null(php_http_env_response_class_entry, ZEND_STRL("throttleChunk"), ZEND_ACC_PROTECTED);
return SUCCESS;
}
#include "php_http_api.h"
-php_http_info_t *php_http_info_init(php_http_info_t *i TSRMLS_DC)
+php_http_info_t *php_http_info_init(php_http_info_t *i)
{
if (!i) {
i = emalloc(sizeof(*i));
}
}
-php_http_info_t *php_http_info_parse(php_http_info_t *info, const char *pre_header TSRMLS_DC)
+php_http_info_t *php_http_info_parse(php_http_info_t *info, const char *pre_header)
{
const char *end, *http;
zend_bool free_info = !info;
}
/* there must be HTTP/1.x in the line */
- if (!(http = php_http_locate_str(pre_header, end - pre_header, "HTTP/1.", lenof("HTTP/1.")))) {
+ if (!(http = php_http_locate_str(pre_header, end - pre_header, "HTTP/", lenof("HTTP/")))) {
return NULL;
}
info = php_http_info_init(info TSRMLS_CC);
- /* and nothing than SPACE or NUL after HTTP/1.x */
+ /* and nothing than SPACE or NUL after HTTP/X.x */
- if (!php_http_version_parse(&info->http.version, http TSRMLS_CC)
+ if (!php_http_version_parse(&info->http.version, http)
- || (http[lenof("HTTP/1.1")] && (!PHP_HTTP_IS_CTYPE(space, http[lenof("HTTP/1.1")])))) {
+ || (http[lenof("HTTP/X.x")] && (!PHP_HTTP_IS_CTYPE(space, http[lenof("HTTP/X.x")])))) {
if (free_info) {
php_http_info_free(&info);
}
/* is response */
if (pre_header == http) {
- char *status = NULL;
- const char *code = http + sizeof("HTTP/1.1");
+ const char *status = NULL, *code = http + sizeof("HTTP/X.x");
info->type = PHP_HTTP_RESPONSE;
while (' ' == *code) ++code;
if (code && end > code) {
- PHP_HTTP_INFO(info).response.code = strtol(code, &status, 10);
+ /* rfc7230#3.1.2 The status-code element is a 3-digit integer code */
+ PHP_HTTP_INFO(info).response.code = 100*(*code++ - '0');
+ PHP_HTTP_INFO(info).response.code += 10*(*code++ - '0');
+ PHP_HTTP_INFO(info).response.code += *code++ - '0';
+ if (PHP_HTTP_INFO(info).response.code < 100 || PHP_HTTP_INFO(info).response.code > 599) {
+ if (free_info) {
+ php_http_info_free(&info);
+ }
+ return NULL;
+ }
+ status = code;
} else {
PHP_HTTP_INFO(info).response.code = 0;
}
}
/* is request */
- else if (*(http - 1) == ' ' && (!http[lenof("HTTP/1.x")] || http[lenof("HTTP/1.x")] == '\r' || http[lenof("HTTP/1.x")] == '\n')) {
+ else if (*(http - 1) == ' ' && (!http[lenof("HTTP/X.x")] || http[lenof("HTTP/X.x")] == '\r' || http[lenof("HTTP/X.x")] == '\n')) {
const char *url = strchr(pre_header, ' ');
info->type = PHP_HTTP_REQUEST;
if (url && http > url) {
- PHP_HTTP_INFO(info).request.method = estrndup(pre_header, url - pre_header);
+ size_t url_len = url - pre_header;
+
+ PHP_HTTP_INFO(info).request.method = estrndup(pre_header, url_len);
+
while (' ' == *url) ++url;
while (' ' == *(http-1)) --http;
+
if (http > url) {
- PHP_HTTP_INFO(info).request.url = php_http_url_parse(url, http - url, ~0);
+ /* CONNECT presents an authority only */
+ if (strcasecmp(PHP_HTTP_INFO(info).request.method, "CONNECT")) {
- PHP_HTTP_INFO(info).request.url = php_http_url_parse(url, http - url, ~0 TSRMLS_CC);
++ PHP_HTTP_INFO(info).request.url = php_http_url_parse(url, http - url, ~0);
+ } else {
- PHP_HTTP_INFO(info).request.url = php_http_url_parse_authority(url, http - url, ~0 TSRMLS_CC);
++ PHP_HTTP_INFO(info).request.url = php_http_url_parse_authority(url, http - url, ~0);
+ }
} else {
PTR_SET(PHP_HTTP_INFO(info).request.method, NULL);
return NULL;
return info;
}
- /* some darn header containing HTTP/1.x */
+ /* some darn header containing HTTP/X.x */
else {
if (free_info) {
php_http_info_free(&info);
#define PHP_HTTP_INFO_REQUEST_FMT_ARGS(_http_ptr, tmp, eol) "%s %s HTTP/%u.%u" eol, \
(_http_ptr)->info.request.method?(_http_ptr)->info.request.method:"UNKNOWN", \
- (_http_ptr)->info.request.url?php_http_url_to_string((_http_ptr)->info.request.url, &(tmp), NULL, 0):"/", \
+ (_http_ptr)->info.request.method&&!strcasecmp((_http_ptr)->info.request.method,"CONNECT")?( \
+ (_http_ptr)->info.request.url?php_http_url_authority_to_string((_http_ptr)->info.request.url, &(tmp), NULL):"0"):( \
+ (_http_ptr)->info.request.url?php_http_url_to_string((_http_ptr)->info.request.url, &(tmp), NULL, 0):"/"), \
(_http_ptr)->version.major||(_http_ptr)->version.major?(_http_ptr)->version.major:1, \
(_http_ptr)->version.major||(_http_ptr)->version.minor?(_http_ptr)->version.minor:1
PHP_HTTP_INFO_IMPL(http, type)
} php_http_info_t;
-typedef zend_bool (*php_http_info_callback_t)(void **callback_data, HashTable **headers, php_http_info_t *info TSRMLS_DC);
+typedef zend_bool (*php_http_info_callback_t)(void **callback_data, HashTable **headers, php_http_info_t *info);
-PHP_HTTP_API php_http_info_t *php_http_info_init(php_http_info_t *info TSRMLS_DC);
-PHP_HTTP_API php_http_info_t *php_http_info_parse(php_http_info_t *info, const char *pre_header TSRMLS_DC);
+PHP_HTTP_API php_http_info_t *php_http_info_init(php_http_info_t *info);
+PHP_HTTP_API php_http_info_t *php_http_info_parse(php_http_info_t *info, const char *pre_header);
PHP_HTTP_API void php_http_info_dtor(php_http_info_t *info);
PHP_HTTP_API void php_http_info_free(php_http_info_t **info);
static void message_headers(php_http_message_t *msg, php_http_buffer_t *str);
-zend_bool php_http_message_info_callback(php_http_message_t **message, HashTable **headers, php_http_info_t *info TSRMLS_DC)
+zend_bool php_http_message_info_callback(php_http_message_t **message, HashTable **headers, php_http_info_t *info)
{
php_http_message_t *old = *message;
/* advance message */
if (!old || old->type || zend_hash_num_elements(&old->hdrs)) {
- (*message) = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+ (*message) = php_http_message_init(NULL, 0, NULL);
(*message)->parent = old;
if (headers) {
(*headers) = &((*message)->hdrs);
return old != *message;
}
-php_http_message_t *php_http_message_init(php_http_message_t *message, php_http_message_type_t type, php_http_message_body_t *body TSRMLS_DC)
+php_http_message_t *php_http_message_init(php_http_message_t *message, php_http_message_type_t type, php_http_message_body_t *body)
{
if (!message) {
message = emalloc(sizeof(*message));
}
memset(message, 0, sizeof(*message));
- TSRMLS_SET_CTX(message->ts);
php_http_message_set_type(message, type);
message->http.version.major = 1;
message->http.version.minor = 1;
zend_hash_init(&message->hdrs, 0, NULL, ZVAL_PTR_DTOR, 0);
- message->body = body ? body : php_http_message_body_init(NULL, NULL TSRMLS_CC);
+ message->body = body ? body : php_http_message_body_init(NULL, NULL);
return message;
}
-php_http_message_t *php_http_message_init_env(php_http_message_t *message, php_http_message_type_t type TSRMLS_DC)
+php_http_message_t *php_http_message_init_env(php_http_message_t *message, php_http_message_type_t type)
{
int free_msg = !message;
zval *sval, tval;
switch (type) {
case PHP_HTTP_REQUEST:
- mbody = php_http_env_get_request_body(TSRMLS_C);
+ mbody = php_http_env_get_request_body();
php_http_message_body_addref(mbody);
- message = php_http_message_init(message, type, mbody TSRMLS_CC);
- if ((sval = php_http_env_get_server_var(ZEND_STRL("SERVER_PROTOCOL"), 1 TSRMLS_CC)) && !strncmp(Z_STRVAL_P(sval), "HTTP/", lenof("HTTP/"))) {
- php_http_version_parse(&message->http.version, Z_STRVAL_P(sval) TSRMLS_CC);
+ message = php_http_message_init(message, type, mbody);
+ if ((sval = php_http_env_get_server_var(ZEND_STRL("SERVER_PROTOCOL"), 1)) && !strncmp(Z_STRVAL_P(sval), "HTTP/", lenof("HTTP/"))) {
+ php_http_version_parse(&message->http.version, Z_STRVAL_P(sval));
}
- if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_METHOD"), 1 TSRMLS_CC))) {
+ if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_METHOD"), 1))) {
message->http.info.request.method = estrdup(Z_STRVAL_P(sval));
}
- if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_URI"), 1 TSRMLS_CC))) {
- message->http.info.request.url = php_http_url_parse(Z_STRVAL_P(sval), Z_STRLEN_P(sval), ~0 TSRMLS_CC);
+ if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_URI"), 1))) {
+ message->http.info.request.url = php_http_url_parse(Z_STRVAL_P(sval), Z_STRLEN_P(sval), ~0);
}
- php_http_env_get_request_headers(&message->hdrs TSRMLS_CC);
+ php_http_env_get_request_headers(&message->hdrs);
break;
case PHP_HTTP_RESPONSE:
- message = php_http_message_init(NULL, type, NULL TSRMLS_CC);
- if (!SG(sapi_headers).http_status_line || !php_http_info_parse((php_http_info_t *) &message->http, SG(sapi_headers).http_status_line TSRMLS_CC)) {
+ message = php_http_message_init(NULL, type, NULL);
+ if (!SG(sapi_headers).http_status_line || !php_http_info_parse((php_http_info_t *) &message->http, SG(sapi_headers).http_status_line)) {
if (!(message->http.info.response.code = SG(sapi_headers).http_response_code)) {
message->http.info.response.code = 200;
}
message->http.info.response.status = estrdup(php_http_env_get_response_status_for_code(message->http.info.response.code));
}
- php_http_env_get_response_headers(&message->hdrs TSRMLS_CC);
-#if PHP_VERSION_ID >= 50400
- if (php_output_get_level(TSRMLS_C)) {
- if (php_output_get_status(TSRMLS_C) & PHP_OUTPUT_SENT) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch response body, output has already been sent at %s:%d", php_output_get_start_filename(TSRMLS_C), php_output_get_start_lineno(TSRMLS_C));
+ php_http_env_get_response_headers(&message->hdrs);
+ if (php_output_get_level()) {
+ if (php_output_get_status() & PHP_OUTPUT_SENT) {
+ php_error_docref(NULL, E_WARNING, "Could not fetch response body, output has already been sent at %s:%d", php_output_get_start_filename(TSRMLS_C), php_output_get_start_lineno(TSRMLS_C));
goto error;
- } else if (SUCCESS != php_output_get_contents(&tval TSRMLS_CC)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch response body");
+ } else if (SUCCESS != php_output_get_contents(&tval)) {
+ php_error_docref(NULL, E_WARNING, "Could not fetch response body");
goto error;
} else {
php_http_message_body_append(message->body, Z_STRVAL(tval), Z_STRLEN(tval));
zval_dtor(&tval);
}
}
-#else
- if (OG(ob_nesting_level)) {
- if (php_get_output_start_filename(TSRMLS_C)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch response body, output has already been sent at %s:%d", php_get_output_start_filename(TSRMLS_C), php_get_output_start_lineno(TSRMLS_C));
- goto error;
- } else if (SUCCESS != php_ob_get_buffer(&tval TSRMLS_CC)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch response body");
- goto error;
- } else {
- php_http_message_body_append(message->body, Z_STRVAL(tval), Z_STRLEN(tval));
- zval_dtor(&tval);
- }
- }
-#endif
break;
default:
return message;
}
-php_http_message_t *php_http_message_parse(php_http_message_t *msg, const char *str, size_t len, zend_bool greedy TSRMLS_DC)
+php_http_message_t *php_http_message_parse(php_http_message_t *msg, const char *str, size_t len, zend_bool greedy)
{
php_http_message_parser_t p;
php_http_buffer_t buf;
int free_msg;
php_http_buffer_from_string_ex(&buf, str, len);
- php_http_message_parser_init(&p TSRMLS_CC);
+ php_http_message_parser_init(&p);
if ((free_msg = !msg)) {
- msg = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+ msg = php_http_message_init(NULL, 0, NULL);
}
if (greedy) {
return msg;
}
-zval *php_http_message_header(php_http_message_t *msg, const char *key_str, size_t key_len, int join)
+zval *php_http_message_header(php_http_message_t *msg, const char *key_str, size_t key_len)
{
- zval *ret = NULL, **header;
+ zval *ret;
char *key;
ALLOCA_FLAG(free_key);
key = do_alloca(key_len + 1, free_key);
+
memcpy(key, key_str, key_len);
key[key_len] = '\0';
php_http_pretty_key(key, key_len, 1, 1);
- if (SUCCESS == zend_symtable_find(&msg->hdrs, key, key_len + 1, (void *) &header)) {
- if (join && Z_TYPE_PP(header) == IS_ARRAY) {
- TSRMLS_FETCH_FROM_CTX(msg->ts);
-
- ret = php_http_header_value_to_string(*header TSRMLS_CC);
- } else {
- Z_ADDREF_PP(header);
- ret = *header;
- }
- }
+ ret = zend_symtable_str_find(&msg->hdrs, key, key_len);
free_alloca(key, free_key);
zend_bool php_http_message_is_multipart(php_http_message_t *msg, char **boundary)
{
- zval *ct = php_http_message_header(msg, ZEND_STRL("Content-Type"), 1);
+ zend_string *ct = php_http_message_header_string(msg, ZEND_STRL("Content-Type"));
zend_bool is_multipart = 0;
- TSRMLS_FETCH_FROM_CTX(msg->ts);
if (ct) {
php_http_params_opts_t popts;
ZEND_INIT_SYMTABLE(¶ms);
php_http_params_opts_default_get(&popts);
- popts.input.str = Z_STRVAL_P(ct);
- popts.input.len = Z_STRLEN_P(ct);
+ popts.input.str = ct->val;
+ popts.input.len = ct->len;
- if (php_http_params_parse(¶ms, &popts TSRMLS_CC)) {
- zval **cur, **arg;
- char *ct_str;
+ if (php_http_params_parse(¶ms, &popts)) {
+ zval *cur, *arg;
+ zend_string *ct_str;
+ zend_ulong index;
zend_hash_internal_pointer_reset(¶ms);
- if (SUCCESS == zend_hash_get_current_data(¶ms, (void *) &cur)
- && Z_TYPE_PP(cur) == IS_ARRAY
- && HASH_KEY_IS_STRING == zend_hash_get_current_key(¶ms, &ct_str, NULL, 0)
+ if ((cur = zend_hash_get_current_data(¶ms))
+ && (Z_TYPE_P(cur) == IS_ARRAY)
+ && (HASH_KEY_IS_STRING == zend_hash_get_current_key(¶ms, &ct_str, &index))
) {
- if (php_http_match(ct_str, "multipart", PHP_HTTP_MATCH_WORD)) {
+ if (php_http_match(ct_str->val, "multipart", PHP_HTTP_MATCH_WORD)) {
is_multipart = 1;
/* get boundary */
if (boundary
- && SUCCESS == zend_hash_find(Z_ARRVAL_PP(cur), ZEND_STRS("arguments"), (void *) &arg)
- && Z_TYPE_PP(arg) == IS_ARRAY
+ && (arg = zend_hash_str_find(Z_ARRVAL_P(cur), ZEND_STRL("arguments")))
+ && Z_TYPE_P(arg) == IS_ARRAY
) {
- zval **val;
- HashPosition pos;
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
+ zval *val;
+ php_http_arrkey_t key;
- FOREACH_KEYVAL(pos, *arg, key, val) {
- if (key.type == HASH_KEY_IS_STRING && !strcasecmp(key.str, "boundary")) {
- zval *bnd = php_http_ztyp(IS_STRING, *val);
+ ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(arg), key.h, key.key, val)
+ {
+ if (key.key && key.key->len == lenof("boundary") && !strcasecmp(key.key->val, "boundary")) {
+ zend_string *bnd = zval_get_string(val);
- if (Z_STRLEN_P(bnd)) {
- *boundary = estrndup(Z_STRVAL_P(bnd), Z_STRLEN_P(bnd));
+ if (bnd->len) {
+ *boundary = estrndup(bnd->val, bnd->len);
}
- zval_ptr_dtor(&bnd);
+ zend_string_release(bnd);
}
}
+ ZEND_HASH_FOREACH_END();
}
}
}
}
zend_hash_destroy(¶ms);
- zval_ptr_dtor(&ct);
+ zend_string_release(ct);
}
return is_multipart;
void php_http_message_update_headers(php_http_message_t *msg)
{
- zval *h;
+ zval h;
size_t size;
+ zend_string *cl;
if (php_http_message_body_stream(msg->body)->readfilters.head) {
/* if a read stream filter is attached to the body the caller must also care for the headers */
} else if ((size = php_http_message_body_size(msg->body))) {
- MAKE_STD_ZVAL(h);
- ZVAL_LONG(h, size);
- zend_hash_update(&msg->hdrs, "Content-Length", sizeof("Content-Length"), &h, sizeof(zval *), NULL);
+ ZVAL_LONG(&h, size);
+ zend_hash_str_update(&msg->hdrs, "Content-Length", lenof("Content-Length"), &h);
if (msg->body->boundary) {
char *str;
size_t len;
+ zend_string *ct;
- if (!(h = php_http_message_header(msg, ZEND_STRL("Content-Type"), 1))) {
+ if (!(ct = php_http_message_header_string(msg, ZEND_STRL("Content-Type")))) {
len = spprintf(&str, 0, "multipart/form-data; boundary=\"%s\"", msg->body->boundary);
- MAKE_STD_ZVAL(h);
- ZVAL_STRINGL(h, str, len, 0);
- zend_hash_update(&msg->hdrs, "Content-Type", sizeof("Content-Type"), &h, sizeof(zval *), NULL);
- } else if (!php_http_match(Z_STRVAL_P(h), "boundary=", PHP_HTTP_MATCH_WORD)) {
- zval_dtor(h);
- Z_STRLEN_P(h) = spprintf(&Z_STRVAL_P(h), 0, "%s; boundary=\"%s\"", Z_STRVAL_P(h), msg->body->boundary);
- zend_hash_update(&msg->hdrs, "Content-Type", sizeof("Content-Type"), &h, sizeof(zval *), NULL);
+ ZVAL_STR(&h, php_http_cs2zs(str, len));
+ zend_hash_str_update(&msg->hdrs, "Content-Type", lenof("Content-Type"), &h);
+ } else if (!php_http_match(ct->val, "boundary=", PHP_HTTP_MATCH_WORD)) {
+ len = spprintf(&str, 0, "%s; boundary=\"%s\"", ct->val, msg->body->boundary);
+ ZVAL_STR(&h, php_http_cs2zs(str, len));
+ zend_hash_str_update(&msg->hdrs, "Content-Type", lenof("Content-Type"), &h);
+ zend_string_release(ct);
} else {
- zval_ptr_dtor(&h);
+ zend_string_release(ct);
}
}
- } else if ((h = php_http_message_header(msg, ZEND_STRL("Content-Length"), 1))) {
- zval *h_cpy = php_http_ztyp(IS_LONG, h);
-
- zval_ptr_dtor(&h);
- if (Z_LVAL_P(h_cpy)) {
- zend_hash_del(&msg->hdrs, "Content-Length", sizeof("Content-Length"));
+ } else if ((cl = php_http_message_header_string(msg, ZEND_STRL("Content-Length")))) {
+ if (!zend_string_equals_literal(cl, "0")) {
+ zend_hash_str_del(&msg->hdrs, ZEND_STRL("Content-Length"));
}
- zval_ptr_dtor(&h_cpy);
+ zend_string_release(cl);
}
}
static void message_headers(php_http_message_t *msg, php_http_buffer_t *str)
{
char *tmp = NULL;
- TSRMLS_FETCH_FROM_CTX(msg->ts);
switch (msg->type) {
case PHP_HTTP_REQUEST:
}
php_http_message_update_headers(msg);
- php_http_header_to_string(str, &msg->hdrs TSRMLS_CC);
+ php_http_header_to_string(str, &msg->hdrs);
}
void php_http_message_to_callback(php_http_message_t *msg, php_http_pass_callback_t cb, void *cb_arg)
php_http_message_t *php_http_message_reverse(php_http_message_t *msg)
{
- int i, c = 0;
-
- php_http_message_count(c, msg);
+ size_t i, c = php_http_message_count(msg);
if (c > 1) {
php_http_message_t *tmp = msg, **arr;
return msg;
}
-php_http_message_t *php_http_message_zip(php_http_message_t *one, php_http_message_t *two)
+php_http_message_t *php_http_message_zip(php_http_message_t *dst, php_http_message_t *src)
{
- php_http_message_t *dst = php_http_message_copy(one, NULL), *src = php_http_message_copy(two, NULL), *tmp_dst, *tmp_src, *ret = dst;
+ php_http_message_t *tmp_dst, *tmp_src, *ret = dst;
- while(dst && src) {
+ while (dst && src) {
tmp_dst = dst->parent;
tmp_src = src->parent;
dst->parent = src;
{
php_http_message_t *temp, *copy = NULL;
php_http_info_t info;
- TSRMLS_FETCH_FROM_CTX(from->ts);
if (from) {
info.type = from->type;
info.http = from->http;
- copy = temp = php_http_message_init(to, 0, php_http_message_body_copy(from->body, NULL) TSRMLS_CC);
+ copy = temp = php_http_message_init(to, 0, php_http_message_body_copy(from->body, NULL));
php_http_message_set_info(temp, &info);
- zend_hash_copy(&temp->hdrs, &from->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ zend_hash_copy(&temp->hdrs, &from->hdrs, (copy_ctor_func_t) zval_add_ref);
if (parents) while (from->parent) {
info.type = from->parent->type;
info.http = from->parent->http;
- temp->parent = php_http_message_init(NULL, 0, php_http_message_body_copy(from->parent->body, NULL) TSRMLS_CC);
+ temp->parent = php_http_message_init(NULL, 0, php_http_message_body_copy(from->parent->body, NULL));
php_http_message_set_info(temp->parent, &info);
- zend_hash_copy(&temp->parent->hdrs, &from->parent->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ array_copy(&from->parent->hdrs, &temp->parent->hdrs);
temp = temp->parent;
from = from->parent;
return copy;
}
-php_http_message_t *php_http_message_copy(php_http_message_t *from, php_http_message_t *to)
-{
- return php_http_message_copy_ex(from, to, 1);
-}
-
void php_http_message_dtor(php_http_message_t *message)
{
if (message) {
}
}
-static zval *php_http_message_object_read_prop(zval *object, zval *member, int type PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC);
-static void php_http_message_object_write_prop(zval *object, zval *member, zval *value PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC);
-static HashTable *php_http_message_object_get_props(zval *object TSRMLS_DC);
+static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *rv);
+static void php_http_message_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot);
+static HashTable *php_http_message_object_get_props(zval *object);
static zend_object_handlers php_http_message_object_handlers;
static HashTable php_http_message_object_prophandlers;
-typedef void (*php_http_message_object_prophandler_func_t)(php_http_message_object_t *o, zval *v TSRMLS_DC);
+static void php_http_message_object_prophandler_hash_dtor(zval *pData)
+{
+ pefree(Z_PTR_P(pData), 1);
+}
+
+typedef void (*php_http_message_object_prophandler_func_t)(php_http_message_object_t *o, zval *v);
typedef struct php_http_message_object_prophandler {
php_http_message_object_prophandler_func_t read;
php_http_message_object_prophandler_func_t write;
} php_http_message_object_prophandler_t;
-static STATUS php_http_message_object_add_prophandler(const char *prop_str, size_t prop_len, php_http_message_object_prophandler_func_t read, php_http_message_object_prophandler_func_t write) {
+static ZEND_RESULT_CODE php_http_message_object_add_prophandler(const char *prop_str, size_t prop_len, php_http_message_object_prophandler_func_t read, php_http_message_object_prophandler_func_t write) {
php_http_message_object_prophandler_t h = { read, write };
- return zend_hash_add(&php_http_message_object_prophandlers, prop_str, prop_len + 1, (void *) &h, sizeof(h), NULL);
+ if (!zend_hash_str_add_mem(&php_http_message_object_prophandlers, prop_str, prop_len, (void *) &h, sizeof(h))) {
+ return FAILURE;
+ }
+ return SUCCESS;
}
-static STATUS php_http_message_object_get_prophandler(const char *prop_str, size_t prop_len, php_http_message_object_prophandler_t **handler) {
- return zend_hash_find(&php_http_message_object_prophandlers, prop_str, prop_len + 1, (void *) handler);
+static php_http_message_object_prophandler_t *php_http_message_object_get_prophandler(zend_string *name_str) {
+ return zend_hash_str_find_ptr(&php_http_message_object_prophandlers, name_str->val, name_str->len);
}
-static void php_http_message_object_prophandler_get_type(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_type(php_http_message_object_t *obj, zval *return_value) {
RETVAL_LONG(obj->message->type);
}
-static void php_http_message_object_prophandler_set_type(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- zval *cpy = php_http_ztyp(IS_LONG, value);
- php_http_message_set_type(obj->message, Z_LVAL_P(cpy));
- zval_ptr_dtor(&cpy);
+static void php_http_message_object_prophandler_set_type(php_http_message_object_t *obj, zval *value) {
+ php_http_message_set_type(obj->message, zval_get_long(value));
}
-static void php_http_message_object_prophandler_get_request_method(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_request_method(php_http_message_object_t *obj, zval *return_value) {
if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message) && obj->message->http.info.request.method) {
- RETVAL_STRING(obj->message->http.info.request.method, 1);
+ RETVAL_STRING(obj->message->http.info.request.method);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_request_method(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
+static void php_http_message_object_prophandler_set_request_method(php_http_message_object_t *obj, zval *value) {
if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message)) {
- zval *cpy = php_http_ztyp(IS_STRING, value);
- PTR_SET(obj->message->http.info.request.method, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
- zval_ptr_dtor(&cpy);
+ zend_string *zs = zval_get_string(value);
+ PTR_SET(obj->message->http.info.request.method, estrndup(zs->val, zs->len));
+ zend_string_release(zs);
}
}
-static void php_http_message_object_prophandler_get_request_url(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_request_url(php_http_message_object_t *obj, zval *return_value) {
char *url_str;
size_t url_len;
if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message) && obj->message->http.info.request.url && php_http_url_to_string(obj->message->http.info.request.url, &url_str, &url_len, 0)) {
- RETVAL_STRINGL(url_str, url_len, 0);
+ RETVAL_STR(php_http_cs2zs(url_str, url_len));
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_request_url(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
+static void php_http_message_object_prophandler_set_request_url(php_http_message_object_t *obj, zval *value) {
if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message)) {
- PTR_SET(obj->message->http.info.request.url, php_http_url_from_zval(value, ~0 TSRMLS_CC));
+ PTR_SET(obj->message->http.info.request.url, php_http_url_from_zval(value, ~0));
}
}
-static void php_http_message_object_prophandler_get_response_status(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_response_status(php_http_message_object_t *obj, zval *return_value) {
if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message) && obj->message->http.info.response.status) {
- RETVAL_STRING(obj->message->http.info.response.status, 1);
+ RETVAL_STRING(obj->message->http.info.response.status);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_response_status(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
+static void php_http_message_object_prophandler_set_response_status(php_http_message_object_t *obj, zval *value) {
if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
- zval *cpy = php_http_ztyp(IS_STRING, value);
- PTR_SET(obj->message->http.info.response.status, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
- zval_ptr_dtor(&cpy);
+ zend_string *zs = zval_get_string(value);
+ PTR_SET(obj->message->http.info.response.status, estrndup(zs->val, zs->len));
+ zend_string_release(zs);
}
}
-static void php_http_message_object_prophandler_get_response_code(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_response_code(php_http_message_object_t *obj, zval *return_value) {
if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
RETVAL_LONG(obj->message->http.info.response.code);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_response_code(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
+static void php_http_message_object_prophandler_set_response_code(php_http_message_object_t *obj, zval *value) {
if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
- zval *cpy = php_http_ztyp(IS_LONG, value);
- obj->message->http.info.response.code = Z_LVAL_P(cpy);
+ obj->message->http.info.response.code = zval_get_long(value);
PTR_SET(obj->message->http.info.response.status, estrdup(php_http_env_get_response_status_for_code(obj->message->http.info.response.code)));
- zval_ptr_dtor(&cpy);
}
}
-static void php_http_message_object_prophandler_get_http_version(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_http_version(php_http_message_object_t *obj, zval *return_value) {
char *version_str;
size_t version_len;
- php_http_version_to_string(&obj->message->http.version, &version_str, &version_len, NULL, NULL TSRMLS_CC);
- RETVAL_STRINGL(version_str, version_len, 0);
+ php_http_version_to_string(&obj->message->http.version, &version_str, &version_len, NULL, NULL);
+ RETVAL_STR(php_http_cs2zs(version_str, version_len));
}
-static void php_http_message_object_prophandler_set_http_version(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- zval *cpy = php_http_ztyp(IS_STRING, value);
- php_http_version_parse(&obj->message->http.version, Z_STRVAL_P(cpy) TSRMLS_CC);
- zval_ptr_dtor(&cpy);
+static void php_http_message_object_prophandler_set_http_version(php_http_message_object_t *obj, zval *value) {
+ zend_string *zs = zval_get_string(value);
+ php_http_version_parse(&obj->message->http.version, zs->val);
+ zend_string_release(zs);
}
-static void php_http_message_object_prophandler_get_headers(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_headers(php_http_message_object_t *obj, zval *return_value ) {
array_init(return_value);
- zend_hash_copy(Z_ARRVAL_P(return_value), &obj->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ array_copy(&obj->message->hdrs, Z_ARRVAL_P(return_value));
}
-static void php_http_message_object_prophandler_set_headers(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- zval *cpy = php_http_ztyp(IS_ARRAY, value);
+static void php_http_message_object_prophandler_set_headers(php_http_message_object_t *obj, zval *value) {
+ HashTable *headers;
+ zval *orig_value = value;
+
+ if (Z_TYPE_P(value) != IS_ARRAY && Z_TYPE_P(value) != IS_OBJECT) {
+ convert_to_array_ex(value);
- } else {
- headers = HASH_OF(value);
+ }
++ headers = HASH_OF(value);
zend_hash_clean(&obj->message->hdrs);
- zend_hash_copy(&obj->message->hdrs, Z_ARRVAL_P(cpy), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
- zval_ptr_dtor(&cpy);
+ array_copy(headers, &obj->message->hdrs);
+
+ if (orig_value != value) {
+ zval_ptr_dtor(value);
+ }
}
-static void php_http_message_object_prophandler_get_body(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_body(php_http_message_object_t *obj, zval *return_value) {
if (obj->body) {
- RETVAL_OBJVAL(obj->body->zv, 1);
+ RETVAL_OBJECT(&obj->body->zo, 1);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_body(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- php_http_message_object_set_body(obj, value TSRMLS_CC);
+static void php_http_message_object_prophandler_set_body(php_http_message_object_t *obj, zval *value) {
+ php_http_message_object_set_body(obj, value);
}
-static void php_http_message_object_prophandler_get_parent_message(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_parent_message(php_http_message_object_t *obj, zval *return_value) {
if (obj->message->parent) {
- RETVAL_OBJVAL(obj->parent->zv, 1);
+ RETVAL_OBJECT(&obj->parent->zo, 1);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_parent_message(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_message_class_entry TSRMLS_CC)) {
- php_http_message_object_t *parent_obj = zend_object_store_get_object(value TSRMLS_CC);
+static void php_http_message_object_prophandler_set_parent_message(php_http_message_object_t *obj, zval *value) {
+ if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_message_class_entry)) {
+ php_http_message_object_t *parent_obj = PHP_HTTP_OBJ(NULL, value);
if (obj->message->parent) {
- zend_objects_store_del_ref_by_handle(obj->parent->zv.handle TSRMLS_CC);
+ zend_objects_store_del(&obj->parent->zo);
}
- Z_OBJ_ADDREF_P(value);
+ Z_ADDREF_P(value);
obj->parent = parent_obj;
obj->message->parent = parent_obj->message;
}
#define PHP_HTTP_MESSAGE_OBJECT_INIT(obj) \
do { \
if (!obj->message) { \
- obj->message = php_http_message_init(NULL, 0, NULL TSRMLS_CC); \
+ obj->message = php_http_message_init(NULL, 0, NULL); \
} \
} while(0)
-void php_http_message_object_reverse(zval *this_ptr, zval *return_value TSRMLS_DC)
+void php_http_message_object_reverse(zval *zmsg, zval *return_value)
{
- int i = 0;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ size_t i;
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, zmsg);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
/* count */
- php_http_message_count(i, obj->message);
+ i = php_http_message_count(obj->message);
if (i > 1) {
php_http_message_object_t **objects;
objects[0]->parent = NULL;
/* add ref, because we previously have not been a parent message */
- Z_OBJ_ADDREF_P(getThis());
- RETVAL_OBJVAL(objects[last]->zv, 0);
+ Z_ADDREF_P(zmsg);
+ RETVAL_OBJECT(&objects[last]->zo, 1);
efree(objects);
} else {
- RETURN_ZVAL(getThis(), 1, 0);
+ RETURN_ZVAL_FAST(zmsg);
}
}
-void php_http_message_object_prepend(zval *this_ptr, zval *prepend, zend_bool top TSRMLS_DC)
+void php_http_message_object_prepend(zval *this_ptr, zval *prepend, zend_bool top)
{
- zval m;
php_http_message_t *save_parent_msg = NULL;
- php_http_message_object_t *save_parent_obj = NULL, *obj = zend_object_store_get_object(this_ptr TSRMLS_CC);
- php_http_message_object_t *prepend_obj = zend_object_store_get_object(prepend TSRMLS_CC);
-
- INIT_PZVAL(&m);
- m.type = IS_OBJECT;
+ php_http_message_object_t *save_parent_obj = NULL, *obj = PHP_HTTP_OBJ(NULL, this_ptr);
+ php_http_message_object_t *prepend_obj = PHP_HTTP_OBJ(NULL, prepend);
if (!top) {
save_parent_obj = obj->parent;
obj->message->parent = prepend_obj->message;
/* add ref */
- zend_objects_store_add_ref(prepend TSRMLS_CC);
+ Z_ADDREF_P(prepend);
if (!top) {
prepend_obj->parent = save_parent_obj;
}
}
-STATUS php_http_message_object_set_body(php_http_message_object_t *msg_obj, zval *zbody TSRMLS_DC)
+ZEND_RESULT_CODE php_http_message_object_set_body(php_http_message_object_t *msg_obj, zval *zbody)
{
- zval *tmp = NULL;
php_stream *s;
- zend_object_value ov;
+ zend_string *body_str;
php_http_message_body_t *body;
php_http_message_body_object_t *body_obj;
switch (Z_TYPE_P(zbody)) {
case IS_RESOURCE:
- php_stream_from_zval_no_verify(s, &zbody);
+ php_stream_from_zval_no_verify(s, zbody);
if (!s) {
php_http_throw(unexpected_val, "The stream is not a valid resource", NULL);
return FAILURE;
is_resource:
- body = php_http_message_body_init(NULL, s TSRMLS_CC);
- if (SUCCESS != php_http_new(&ov, php_http_message_body_class_entry, (php_http_new_t) php_http_message_body_object_new_ex, NULL, body, NULL TSRMLS_CC)) {
+ body = php_http_message_body_init(NULL, s);
+ if (!(body_obj = php_http_message_body_object_new_ex(php_http_message_body_class_entry, body))) {
php_http_message_body_free(&body);
return FAILURE;
}
- MAKE_STD_ZVAL(tmp);
- ZVAL_OBJVAL(tmp, ov, 0);
- zbody = tmp;
break;
case IS_OBJECT:
- if (instanceof_function(Z_OBJCE_P(zbody), php_http_message_body_class_entry TSRMLS_CC)) {
- Z_OBJ_ADDREF_P(zbody);
+ if (instanceof_function(Z_OBJCE_P(zbody), php_http_message_body_class_entry)) {
+ Z_ADDREF_P(zbody);
+ body_obj = PHP_HTTP_OBJ(NULL, zbody);
break;
}
/* no break */
default:
- tmp = php_http_ztyp(IS_STRING, zbody);
+ body_str = zval_get_string(zbody);
s = php_stream_temp_new();
- php_stream_write(s, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
- zval_ptr_dtor(&tmp);
- tmp = NULL;
+ php_stream_write(s, body_str->val, body_str->len);
+ zend_string_release(body_str);
goto is_resource;
}
- body_obj = zend_object_store_get_object(zbody TSRMLS_CC);
if (!body_obj->body) {
- body_obj->body = php_http_message_body_init(NULL, NULL TSRMLS_CC);
+ body_obj->body = php_http_message_body_init(NULL, NULL);
}
if (msg_obj->body) {
- zend_objects_store_del_ref_by_handle(msg_obj->body->zv.handle TSRMLS_CC);
+ zend_objects_store_del(&msg_obj->body->zo);
}
if (msg_obj->message) {
php_http_message_body_free(&msg_obj->message->body);
- msg_obj->message->body = php_http_message_body_init(&body_obj->body, NULL TSRMLS_CC);
+ msg_obj->message->body = php_http_message_body_init(&body_obj->body, NULL);
} else {
- msg_obj->message = php_http_message_init(NULL, 0, php_http_message_body_init(&body_obj->body, NULL TSRMLS_CC) TSRMLS_CC);
+ msg_obj->message = php_http_message_init(NULL, 0, php_http_message_body_init(&body_obj->body, NULL));
}
msg_obj->body = body_obj;
- if (tmp) {
- FREE_ZVAL(tmp);
- }
return SUCCESS;
}
-STATUS php_http_message_object_init_body_object(php_http_message_object_t *obj)
+ZEND_RESULT_CODE php_http_message_object_init_body_object(php_http_message_object_t *obj)
{
- TSRMLS_FETCH_FROM_CTX(obj->message->ts);
-
php_http_message_body_addref(obj->message->body);
- return php_http_new(NULL, php_http_message_body_class_entry, (php_http_new_t) php_http_message_body_object_new_ex, NULL, obj->message->body, (void *) &obj->body TSRMLS_CC);
+ return php_http_new((void *) &obj->body, php_http_message_body_class_entry, (php_http_new_t) php_http_message_body_object_new_ex, NULL, obj->message->body);
}
-zend_object_value php_http_message_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *php_http_message_object_new(zend_class_entry *ce)
{
- return php_http_message_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+ return &php_http_message_object_new_ex(ce, NULL)->zo;
}
-zend_object_value php_http_message_object_new_ex(zend_class_entry *ce, php_http_message_t *msg, php_http_message_object_t **ptr TSRMLS_DC)
+php_http_message_object_t *php_http_message_object_new_ex(zend_class_entry *ce, php_http_message_t *msg)
{
php_http_message_object_t *o;
- o = ecalloc(1, sizeof(php_http_message_object_t) + (ce->default_properties_count - 1) * sizeof(zval));
- o = ecalloc(1, sizeof(php_http_message_object_t));
- zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
- object_properties_init((zend_object *) o, ce);
-
- if (ptr) {
- *ptr = o;
- }
++ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+ zend_object_std_init(&o->zo, ce);
+ object_properties_init(&o->zo, ce);
if (msg) {
o->message = msg;
if (msg->parent) {
- php_http_message_object_new_ex(ce, msg->parent, &o->parent TSRMLS_CC);
+ o->parent = php_http_message_object_new_ex(ce, msg->parent);
}
- php_http_message_body_object_new_ex(php_http_message_body_class_entry, php_http_message_body_init(&msg->body, NULL TSRMLS_CC), &o->body TSRMLS_CC);
+ o->body = php_http_message_body_object_new_ex(php_http_message_body_class_entry, php_http_message_body_init(&msg->body, NULL));
}
- o->zv.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_message_object_free, NULL TSRMLS_CC);
- o->zv.handlers = &php_http_message_object_handlers;
+ o->zo.handlers = &php_http_message_object_handlers;
- return o->zv;
+ return o;
}
-zend_object_value php_http_message_object_clone(zval *this_ptr TSRMLS_DC)
+zend_object *php_http_message_object_clone(zval *this_ptr TSRMLS_DC)
{
- zend_object_value new_ov;
php_http_message_object_t *new_obj = NULL;
- php_http_message_object_t *old_obj = zend_object_store_get_object(this_ptr TSRMLS_CC);
+ php_http_message_object_t *old_obj = PHP_HTTP_OBJ(NULL, this_ptr);
- new_ov = php_http_message_object_new_ex(old_obj->zo.ce, php_http_message_copy(old_obj->message, NULL), &new_obj TSRMLS_CC);
- zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
+ 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);
- return new_ov;
+ return &new_obj->zo;
}
-void php_http_message_object_free(void *object TSRMLS_DC)
+void php_http_message_object_free(zend_object *object)
{
- php_http_message_object_t *o = (php_http_message_object_t *) object;
+ php_http_message_object_t *o = PHP_HTTP_OBJ(object, NULL);
- if (o->iterator) {
+ if (!Z_ISUNDEF(o->iterator)) {
zval_ptr_dtor(&o->iterator);
- o->iterator = NULL;
+ ZVAL_UNDEF(&o->iterator);
}
if (o->message) {
/* do NOT free recursivly */
o->message = NULL;
}
if (o->parent) {
- zend_objects_store_del_ref_by_handle(o->parent->zv.handle TSRMLS_CC);
+ zend_objects_store_del(&o->parent->zo);
o->parent = NULL;
}
if (o->body) {
- zend_objects_store_del_ref_by_handle(o->body->zv.handle TSRMLS_CC);
+ zend_objects_store_del(&o->body->zo);
o->body = NULL;
}
- zend_object_std_dtor((zend_object *) o TSRMLS_CC);
- efree(o);
+ zend_object_std_dtor(object);
}
-static zval *php_http_message_object_read_prop(zval *object, zval *member, int type PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC)
+static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *tmp)
{
- php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
- php_http_message_object_prophandler_t *handler;
- zval *return_value, *copy = php_http_ztyp(IS_STRING, member);
+ 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_INIT(obj);
+ if (!handler || type == BP_VAR_R || type == BP_VAR_IS) {
+ return_value = zend_get_std_object_handlers()->read_property(object, member, type, cache_slot, tmp);
- if (SUCCESS == php_http_message_object_get_prophandler(Z_STRVAL_P(copy), Z_STRLEN_P(copy), &handler)) {
- ALLOC_ZVAL(return_value);
- Z_SET_REFCOUNT_P(return_value, 0);
- Z_UNSET_ISREF_P(return_value);
+ if (handler) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
- if (type == BP_VAR_R) {
- handler->read(obj, return_value TSRMLS_CC);
- } else {
- php_property_proxy_t *proxy = php_property_proxy_init(object, Z_STRVAL_P(copy), Z_STRLEN_P(copy) TSRMLS_CC);
- RETVAL_OBJVAL(php_property_proxy_object_new_ex(php_property_proxy_get_class_entry(), proxy, NULL TSRMLS_CC), 0);
+ PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
+ handler->read(obj, tmp);
+
+ zval_ptr_dtor(return_value);
+ ZVAL_COPY_VALUE(return_value, tmp);
}
} else {
- return_value = zend_get_std_object_handlers()->read_property(object, member, type PHP_HTTP_ZEND_LITERAL_CC TSRMLS_CC);
+ return_value = php_property_proxy_zval(object, member_name);
}
- zval_ptr_dtor(©);
+ zend_string_release(member_name);
return return_value;
}
-static void php_http_message_object_write_prop(zval *object, zval *member, zval *value PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC)
+static void php_http_message_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot)
{
- php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
php_http_message_object_prophandler_t *handler;
- zval *copy = php_http_ztyp(IS_STRING, member);
+ zend_string *member_name = zval_get_string(member);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if (SUCCESS == php_http_message_object_get_prophandler(Z_STRVAL_P(copy), Z_STRLEN_P(copy), &handler)) {
- handler->write(obj, value TSRMLS_CC);
+ if ((handler = php_http_message_object_get_prophandler(member_name))) {
+ handler->write(obj, value);
} else {
- zend_get_std_object_handlers()->write_property(object, member, value PHP_HTTP_ZEND_LITERAL_CC TSRMLS_CC);
+ zend_get_std_object_handlers()->write_property(object, member, value, cache_slot);
}
- zval_ptr_dtor(©);
+ zend_string_release(member_name);
}
-static HashTable *php_http_message_object_get_props(zval *object TSRMLS_DC)
+static HashTable *php_http_message_object_get_props(zval *object)
{
- zval *headers;
- php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
- HashTable *props = zend_get_std_object_handlers()->get_properties(object TSRMLS_CC);
- zval array, *parent, *body;
+ zval tmp;
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+ HashTable *props = zend_get_std_object_handlers()->get_properties(object);
char *ver_str, *url_str = NULL;
size_t ver_len, url_len = 0;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- INIT_PZVAL_ARRAY(&array, props);
-#define ASSOC_PROP(ptype, n, val) \
+#define UPDATE_PROP(name_str, action_with_tmp) \
do { \
zend_property_info *pi; \
- if (SUCCESS == zend_hash_find(&obj->zo.ce->properties_info, n, sizeof(n), (void *) &pi)) { \
- add_assoc_ ##ptype## _ex(&array, pi->name, pi->name_length + 1, val); \
- } \
- } while(0) \
-
-#define ASSOC_STRING(name, val) ASSOC_STRINGL(name, val, strlen(val))
-#define ASSOC_STRINGL(name, val, len) ASSOC_STRINGL_EX(name, val, len, 1)
-#define ASSOC_STRINGL_EX(n, val, len, cpy) \
- do { \
- zend_property_info *pi; \
- if (SUCCESS == zend_hash_find(&obj->zo.ce->properties_info, n, sizeof(n), (void *) &pi)) { \
- add_assoc_stringl_ex(&array, pi->name, pi->name_length + 1, val, len, cpy); \
+ if ((pi = zend_hash_str_find_ptr(&obj->zo.ce->properties_info, name_str, lenof(name_str)))) { \
+ action_with_tmp; \
+ zend_hash_update(props, pi->name, &tmp); \
} \
} while(0)
- ASSOC_PROP(long, "type", obj->message->type);
+ UPDATE_PROP("type", ZVAL_LONG(&tmp, obj->message->type));
+
ver_len = spprintf(&ver_str, 0, "%u.%u", obj->message->http.version.major, obj->message->http.version.minor);
- ASSOC_STRINGL_EX("httpVersion", ver_str, ver_len, 0);
+ UPDATE_PROP("httpVersion", ZVAL_STR(&tmp, php_http_cs2zs(ver_str, ver_len)));
switch (obj->message->type) {
case PHP_HTTP_REQUEST:
- ASSOC_PROP(long, "responseCode", 0);
- ASSOC_STRINGL("responseStatus", "", 0);
- ASSOC_STRING("requestMethod", STR_PTR(obj->message->http.info.request.method));
+ UPDATE_PROP("responseCode", ZVAL_LONG(&tmp, 0));
+ UPDATE_PROP("responseStatus", ZVAL_EMPTY_STRING(&tmp));
+ UPDATE_PROP("requestMethod", ZVAL_STRING(&tmp, STR_PTR(obj->message->http.info.request.method)));
if (obj->message->http.info.request.url) {
php_http_url_to_string(obj->message->http.info.request.url, &url_str, &url_len, 0);
- ASSOC_STRINGL_EX("requestUrl", url_str, url_len, 0);
+ UPDATE_PROP("requestUrl", ZVAL_STR(&tmp, php_http_cs2zs(url_str, url_len)));
} else {
- ASSOC_STRINGL("requestUrl", "", 0);
+ UPDATE_PROP("requestUrl", ZVAL_EMPTY_STRING(&tmp));
}
break;
case PHP_HTTP_RESPONSE:
- ASSOC_PROP(long, "responseCode", obj->message->http.info.response.code);
- ASSOC_STRING("responseStatus", STR_PTR(obj->message->http.info.response.status));
- ASSOC_STRINGL("requestMethod", "", 0);
- ASSOC_STRINGL("requestUrl", "", 0);
+ UPDATE_PROP("responseCode", ZVAL_LONG(&tmp, obj->message->http.info.response.code));
+ UPDATE_PROP("responseStatus", ZVAL_STRING(&tmp, STR_PTR(obj->message->http.info.response.status)));
+ UPDATE_PROP("requestMethod", ZVAL_EMPTY_STRING(&tmp));
+ UPDATE_PROP("requestUrl", ZVAL_EMPTY_STRING(&tmp));
break;
case PHP_HTTP_NONE:
default:
- ASSOC_PROP(long, "responseCode", 0);
- ASSOC_STRINGL("responseStatus", "", 0);
- ASSOC_STRINGL("requestMethod", "", 0);
- ASSOC_STRINGL("requestUrl", "", 0);
+ UPDATE_PROP("responseCode", ZVAL_LONG(&tmp, 0));
+ UPDATE_PROP("responseStatus", ZVAL_EMPTY_STRING(&tmp));
+ UPDATE_PROP("requestMethod", ZVAL_EMPTY_STRING(&tmp));
+ UPDATE_PROP("requestUrl", ZVAL_EMPTY_STRING(&tmp));
break;
}
- MAKE_STD_ZVAL(headers);
- array_init(headers);
- zend_hash_copy(Z_ARRVAL_P(headers), &obj->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
- ASSOC_PROP(zval, "headers", headers);
+ UPDATE_PROP("headers",
+ array_init(&tmp);
+ array_copy(&obj->message->hdrs, Z_ARRVAL(tmp));
+ );
- MAKE_STD_ZVAL(body);
- if (obj->body) {
- ZVAL_OBJVAL(body, obj->body->zv, 1);
- } else {
- ZVAL_NULL(body);
- }
- ASSOC_PROP(zval, "body", body);
+ UPDATE_PROP("body",
+ if (obj->body) {
+ ZVAL_OBJECT(&tmp, &obj->body->zo, 1);
+ } else {
+ ZVAL_NULL(&tmp);
+ }
+ );
- MAKE_STD_ZVAL(parent);
- if (obj->message->parent) {
- ZVAL_OBJVAL(parent, obj->parent->zv, 1);
- } else {
- ZVAL_NULL(parent);
- }
- ASSOC_PROP(zval, "parentMessage", parent);
+ UPDATE_PROP("parentMessage",
+ if (obj->message->parent) {
+ ZVAL_OBJECT(&tmp, &obj->parent->zo, 1);
+ } else {
+ ZVAL_NULL(&tmp);
+ }
+ );
return props;
}
zend_bool greedy = 1;
zval *zmessage = NULL;
php_http_message_t *msg = NULL;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!b", &zmessage, &greedy), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|z!b", &zmessage, &greedy), invalid_arg, return);
- zend_replace_error_handling(EH_THROW, php_http_exception_bad_message_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_bad_message_class_entry, &zeh);
if (zmessage && Z_TYPE_P(zmessage) == IS_RESOURCE) {
php_stream *s;
php_http_message_parser_t p;
zend_error_handling zeh;
- zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh TSRMLS_CC);
- php_stream_from_zval(s, &zmessage);
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh);
+ php_stream_from_zval(s, zmessage);
+ zend_restore_error_handling(&zeh);
- if (s && php_http_message_parser_init(&p TSRMLS_CC)) {
+ if (s && php_http_message_parser_init(&p)) {
unsigned flags = (greedy ? PHP_HTTP_MESSAGE_PARSER_GREEDY : 0);
php_http_buffer_t buf;
php_http_throw(bad_message, "Empty message received from stream", NULL);
}
} else if (zmessage) {
- zmessage = php_http_ztyp(IS_STRING, zmessage);
- msg = php_http_message_parse(NULL, Z_STRVAL_P(zmessage), Z_STRLEN_P(zmessage), greedy TSRMLS_CC);
+ zend_string *zs_msg = zval_get_string(zmessage);
+
+ msg = php_http_message_parse(NULL, zs_msg->val, zs_msg->len, greedy);
if (!msg && !EG(exception)) {
- php_http_throw(bad_message, "Could not parse message: %.*s", MIN(25, Z_STRLEN_P(zmessage)), Z_STRVAL_P(zmessage));
+ php_http_throw(bad_message, "Could not parse message: %.*s", MIN(25, zs_msg->len), zs_msg->val);
}
- zval_ptr_dtor(&zmessage);
+ zend_string_release(zs_msg);
}
if (msg) {
php_http_message_dtor(obj->message);
obj->message = msg;
if (obj->message->parent) {
- php_http_message_object_new_ex(Z_OBJCE_P(getThis()), obj->message->parent, &obj->parent TSRMLS_CC);
+ obj->parent = php_http_message_object_new_ex(obj->zo.ce, obj->message->parent);
}
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
}
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (!obj->body) {
}
if (obj->body) {
- RETVAL_OBJVAL(obj->body->zv, 1);
+ RETVAL_OBJECT(&obj->body->zo, 1);
}
}
{
zval *zbody;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zbody, php_http_message_body_class_entry)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &zbody, php_http_message_body_class_entry)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_http_message_object_prophandler_set_body(obj, zbody TSRMLS_CC);
+ php_http_message_object_prophandler_set_body(obj, zbody);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_addBody, 0, 0, 1)
{
zval *new_body;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &new_body, php_http_message_body_class_entry)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- php_http_message_body_object_t *new_obj = zend_object_store_get_object(new_body TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &new_body, php_http_message_body_class_entry)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
+ php_http_message_body_object_t *new_obj = PHP_HTTP_OBJ(NULL, new_body);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
php_http_message_body_to_callback(new_obj->body, (php_http_pass_callback_t) php_http_message_body_append, obj->message->body, 0, 0);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getHeader, 0, 0, 1)
static PHP_METHOD(HttpMessage, getHeader)
{
char *header_str;
- int header_len;
+ size_t header_len;
zend_class_entry *header_ce = NULL;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|C!", &header_str, &header_len, &header_ce)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|C!", &header_str, &header_len, &header_ce)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
zval *header;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if ((header = php_http_message_header(obj->message, header_str, header_len, 0))) {
+ if ((header = php_http_message_header(obj->message, header_str, header_len))) {
if (!header_ce) {
RETURN_ZVAL(header, 1, 1);
- } else if (instanceof_function(header_ce, php_http_header_class_entry TSRMLS_CC)) {
+ } else if (instanceof_function(header_ce, php_http_header_class_entry)) {
+ php_http_object_method_t cb;
- zval *header_name, **argv[2];
+ zval argv[2];
- MAKE_STD_ZVAL(header_name);
- ZVAL_STRINGL(header_name, header_str, header_len, 1);
-
- argv[0] = &header_name;
- argv[1] = &header;
+ ZVAL_STRINGL(&argv[0], header_str, header_len);
+ ZVAL_COPY(&argv[1], header);
object_init_ex(return_value, header_ce);
- php_http_method_call(return_value, ZEND_STRL("__construct"), 2, argv, NULL);
- php_http_object_method_init(&cb, return_value, ZEND_STRL("__construct") TSRMLS_CC);
- php_http_object_method_call(&cb, return_value, NULL, 2, argv TSRMLS_CC);
++ php_http_object_method_init(&cb, return_value, ZEND_STRL("__construct"));
++ php_http_object_method_call(&cb, return_value, NULL, 2, argv);
+ php_http_object_method_dtor(&cb);
- zval_ptr_dtor(&header_name);
- zval_ptr_dtor(&header);
+ zval_ptr_dtor(&argv[0]);
+ zval_ptr_dtor(&argv[1]);
return;
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class '%s' is not as descendant of http\\Header", header_ce->name);
+ php_error_docref(NULL, E_WARNING, "Class '%s' is not as descendant of http\\Header", header_ce->name->val);
}
}
}
static PHP_METHOD(HttpMessage, getHeaders)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
{
zval *zvalue = NULL;
char *name_str;
- int name_len;
+ size_t name_len;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z!", &name_str, &name_len, &zvalue)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|z!", &name_str, &name_len, &zvalue)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *name = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (!zvalue) {
- zend_symtable_del(&obj->message->hdrs, name, name_len + 1);
+ zend_symtable_str_del(&obj->message->hdrs, name, name_len);
} else {
- Z_ADDREF_P(zvalue);
- zend_symtable_update(&obj->message->hdrs, name, name_len + 1, &zvalue, sizeof(void *), NULL);
+ Z_TRY_ADDREF_P(zvalue);
+ zend_symtable_str_update(&obj->message->hdrs, name, name_len, zvalue);
}
efree(name);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_setHeaders, 0, 0, 1)
{
zval *new_headers = NULL;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!", &new_headers)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "a/!", &new_headers)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
array_join(Z_ARRVAL_P(new_headers), &obj->message->hdrs, 0, ARRAY_JOIN_PRETTIFY|ARRAY_JOIN_STRONLY);
}
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_addHeader, 0, 0, 2)
{
zval *zvalue;
char *name_str;
- int name_len;
+ size_t name_len;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &name_str, &name_len, &zvalue)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "sz", &name_str, &name_len, &zvalue)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *name = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
zval *header;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- Z_ADDREF_P(zvalue);
- if ((header = php_http_message_header(obj->message, name, name_len, 0))) {
+ Z_TRY_ADDREF_P(zvalue);
+ if ((header = php_http_message_header(obj->message, name, name_len))) {
convert_to_array(header);
- zend_hash_next_index_insert(Z_ARRVAL_P(header), &zvalue, sizeof(void *), NULL);
- zval_ptr_dtor(&header);
+ zend_hash_next_index_insert(Z_ARRVAL_P(header), zvalue);
} else {
- zend_symtable_update(&obj->message->hdrs, name, name_len + 1, &zvalue, sizeof(void *), NULL);
+ zend_symtable_str_update(&obj->message->hdrs, name, name_len, zvalue);
}
efree(name);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_addHeaders, 0, 0, 1)
zval *new_headers;
zend_bool append = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|b", &new_headers, &append)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "a|b", &new_headers, &append)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
array_join(Z_ARRVAL_P(new_headers), &obj->message->hdrs, append, ARRAY_JOIN_STRONLY|ARRAY_JOIN_PRETTIFY);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getType, 0, 0, 0)
static PHP_METHOD(HttpMessage, getType)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, setType)
{
- long type;
+ zend_long type;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &type)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "l", &type)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
php_http_message_set_type(obj->message, type);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getInfo, 0, 0, 0)
static PHP_METHOD(HttpMessage, getInfo)
{
if (SUCCESS == zend_parse_parameters_none()) {
- char *tmp = NULL;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ char *str, *tmp = NULL;
+ size_t len;
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
switch (obj->message->type) {
case PHP_HTTP_REQUEST:
- Z_STRLEN_P(return_value) = spprintf(&Z_STRVAL_P(return_value), 0, PHP_HTTP_INFO_REQUEST_FMT_ARGS(&obj->message->http, tmp, ""));
+ len = spprintf(&str, 0, PHP_HTTP_INFO_REQUEST_FMT_ARGS(&obj->message->http, tmp, ""));
PTR_FREE(tmp);
break;
case PHP_HTTP_RESPONSE:
- Z_STRLEN_P(return_value) = spprintf(&Z_STRVAL_P(return_value), 0, PHP_HTTP_INFO_RESPONSE_FMT_ARGS(&obj->message->http, tmp, ""));
+ len = spprintf(&str, 0, PHP_HTTP_INFO_RESPONSE_FMT_ARGS(&obj->message->http, tmp, ""));
PTR_FREE(tmp);
break;
default:
RETURN_NULL();
break;
}
- Z_TYPE_P(return_value) = IS_STRING;
- return;
+
+ RETVAL_STR(php_http_cs2zs(str, len));
}
}
static PHP_METHOD(HttpMessage, setInfo)
{
char *str;
- int len;
+ size_t len;
php_http_message_object_t *obj;
php_http_info_t inf;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if (!php_http_info_parse(&inf, str TSRMLS_CC)) {
+ if (!php_http_info_parse(&inf, str)) {
php_http_throw(bad_header, "Could not parse message info '%s'", str);
return;
}
php_http_message_set_info(obj->message, &inf);
php_http_info_dtor(&inf);
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getHttpVersion, 0, 0, 0)
if (SUCCESS == zend_parse_parameters_none()) {
char *str;
size_t len;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_http_version_to_string(&obj->message->http.version, &str, &len, NULL, NULL TSRMLS_CC);
- RETURN_STRINGL(str, len, 0);
+ php_http_version_to_string(&obj->message->http.version, &str, &len, NULL, NULL);
+ RETURN_STR(php_http_cs2zs(str, len));
}
}
static PHP_METHOD(HttpMessage, setHttpVersion)
{
char *v_str;
- int v_len;
+ size_t v_len;
php_http_version_t version;
php_http_message_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &v_str, &v_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &v_str, &v_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_http_expect(php_http_version_parse(&version, v_str TSRMLS_CC), unexpected_val, return);
+ php_http_expect(php_http_version_parse(&version, v_str), unexpected_val, return);
obj->message->http.version = version;
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getResponseCode, 0, 0, 0)
static PHP_METHOD(HttpMessage, getResponseCode)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_RESPONSE) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "http\\Message is not if type response");
+ php_error_docref(NULL, E_WARNING, "http\\Message is not if type response");
RETURN_FALSE;
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, setResponseCode)
{
- long code;
+ zend_long code;
zend_bool strict = 1;
php_http_message_object_t *obj;
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b", &code, &strict), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_RESPONSE) {
obj->message->http.info.response.code = code;
PTR_SET(obj->message->http.info.response.status, estrdup(php_http_env_get_response_status_for_code(code)));
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getResponseStatus, 0, 0, 0)
static PHP_METHOD(HttpMessage, getResponseStatus)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_RESPONSE) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "http\\Message is not of type response");
+ php_error_docref(NULL, E_WARNING, "http\\Message is not of type response");
}
if (obj->message->http.info.response.status) {
- RETURN_STRING(obj->message->http.info.response.status, 1);
+ RETURN_STRING(obj->message->http.info.response.status);
} else {
RETURN_EMPTY_STRING();
}
static PHP_METHOD(HttpMessage, setResponseStatus)
{
char *status;
- int status_len;
+ size_t status_len;
php_http_message_object_t *obj;
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &status, &status_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
}
PTR_SET(obj->message->http.info.response.status, estrndup(status, status_len));
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getRequestMethod, 0, 0, 0)
static PHP_METHOD(HttpMessage, getRequestMethod)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_REQUEST) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "http\\Message is not of type request");
+ php_error_docref(NULL, E_WARNING, "http\\Message is not of type request");
RETURN_FALSE;
}
if (obj->message->http.info.request.method) {
- RETURN_STRING(obj->message->http.info.request.method, 1);
+ RETURN_STRING(obj->message->http.info.request.method);
} else {
RETURN_EMPTY_STRING();
}
static PHP_METHOD(HttpMessage, setRequestMethod)
{
char *method;
- int method_len;
+ size_t method_len;
php_http_message_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &method, &method_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &method, &method_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
}
PTR_SET(obj->message->http.info.request.method, estrndup(method, method_len));
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getRequestUrl, 0, 0, 0)
static PHP_METHOD(HttpMessage, getRequestUrl)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_REQUEST) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "http\\Message is not of type request");
+ php_error_docref(NULL, E_WARNING, "http\\Message is not of type request");
RETURN_FALSE;
}
size_t url_len;
php_http_url_to_string(obj->message->http.info.request.url, &url_str, &url_len, 0);
- RETURN_STRINGL(url_str, url_len, 0);
+ RETURN_STR(php_http_cs2zs(url_str, url_len));
} else {
RETURN_EMPTY_STRING();
}
php_http_message_object_t *obj;
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zurl), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zurl), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
return;
}
- zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh TSRMLS_CC);
- url = php_http_url_from_zval(zurl, ~0 TSRMLS_CC);
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh);
+ url = php_http_url_from_zval(zurl, ~0);
+ zend_restore_error_handling(&zeh);
if (php_http_url_is_empty(url)) {
php_http_url_free(&url);
PTR_SET(obj->message->http.info.request.url, url);
}
- RETVAL_ZVAL(getThis(), 1, 0);
+ RETVAL_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getParentMessage, 0, 0, 0)
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (!obj->message->parent) {
return;
}
- RETVAL_OBJVAL(obj->parent->zv, 1);
+ RETVAL_OBJECT(&obj->parent->zo, 1);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage___toString, 0, 0, 0)
{
zend_bool include_parent = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &include_parent)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &include_parent)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *string;
size_t length;
php_http_message_to_string(obj->message, &string, &length);
}
if (string) {
- RETURN_STRINGL(string, length, 0);
+ RETURN_STR(php_http_cs2zs(string, length));
}
}
RETURN_EMPTY_STRING();
{
zval *zstream;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstream)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "r", &zstream)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
php_stream *s;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_stream_from_zval(s, &zstream);
+ php_stream_from_zval(s, zstream);
php_http_message_to_callback(obj->message, (php_http_pass_callback_t) _php_stream_write, s);
}
}
{
php_http_pass_fcall_arg_t fcd;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fcd.fci, &fcd.fcc)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fcd.fci, &fcd.fcc)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- fcd.fcz = getThis();
- Z_ADDREF_P(fcd.fcz);
- TSRMLS_SET_CTX(fcd.ts);
-
+ ZVAL_COPY(&fcd.fcz, getThis());
php_http_message_to_callback(obj->message, php_http_pass_fcall_callback, &fcd);
zend_fcall_info_args_clear(&fcd.fci, 1);
-
zval_ptr_dtor(&fcd.fcz);
- RETURN_ZVAL(getThis(), 1, 0);
+
+ RETURN_ZVAL_FAST(getThis());
}
}
static PHP_METHOD(HttpMessage, serialize)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *string;
size_t length;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
php_http_message_serialize(obj->message, &string, &length);
- RETURN_STRINGL(string, length, 0);
+ RETURN_STR(php_http_cs2zs(string, length));
}
RETURN_EMPTY_STRING();
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, unserialize)
{
- int length;
+ size_t length;
char *serialized;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &serialized, &length)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &serialized, &length)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
php_http_message_t *msg;
if (obj->message) {
+ /* do not free recursively */
php_http_message_dtor(obj->message);
efree(obj->message);
}
- if ((msg = php_http_message_parse(NULL, serialized, (size_t) length, 1 TSRMLS_CC))) {
+ if ((msg = php_http_message_parse(NULL, serialized, length, 1))) {
obj->message = msg;
} else {
- obj->message = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+ obj->message = php_http_message_init(NULL, 0, NULL);
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not unserialize http\\Message");
}
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, detach)
{
- php_http_message_object_t *obj;
+ php_http_message_object_t *obj, *new_obj;
+ php_http_message_t *msg_cpy;
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- RETVAL_OBJVAL(php_http_message_object_new_ex(obj->zo.ce, php_http_message_copy_ex(obj->message, NULL, 0), NULL TSRMLS_CC), 0);
+ msg_cpy = php_http_message_copy_ex(obj->message, NULL, 0);
+ new_obj = php_http_message_object_new_ex(obj->zo.ce, msg_cpy);
+
+ RETVAL_OBJ(&new_obj->zo);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_prepend, 0, 0, 1)
php_http_message_t *msg[2];
php_http_message_object_t *obj, *prepend_obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &prepend, php_http_message_class_entry, &top), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O|b", &prepend, php_http_message_class_entry, &top), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- prepend_obj = zend_object_store_get_object(prepend TSRMLS_CC);
+ prepend_obj = PHP_HTTP_OBJ(NULL, prepend);
PHP_HTTP_MESSAGE_OBJECT_INIT(prepend_obj);
/* safety check */
}
}
- php_http_message_object_prepend(getThis(), prepend, top TSRMLS_CC);
- RETURN_ZVAL(getThis(), 1, 0);
+ php_http_message_object_prepend(getThis(), prepend, top);
+ RETURN_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_reverse, 0, 0, 0)
{
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- php_http_message_object_reverse(getThis(), return_value TSRMLS_CC);
+ php_http_message_object_reverse(getThis(), return_value);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_isMultipart, 0, 0, 0)
{
zval *zboundary = NULL;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &zboundary)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|z!", &zboundary)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *boundary = NULL;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- RETVAL_BOOL(php_http_message_is_multipart(obj->message, zboundary ? &boundary : NULL));
+ if (php_http_message_is_multipart(obj->message, zboundary ? &boundary : NULL)) {
+ RETVAL_TRUE;
+ } else {
+ RETVAL_FALSE;
+ }
if (zboundary && boundary) {
+ ZVAL_DEREF(zboundary);
zval_dtor(zboundary);
- ZVAL_STRING(zboundary, boundary, 0);
+ ZVAL_STR(zboundary, php_http_cs2zs(boundary, strlen(boundary)));
}
}
}
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (!php_http_message_is_multipart(obj->message, &boundary)) {
PTR_FREE(boundary);
- RETURN_OBJVAL(php_http_message_object_new_ex(php_http_message_class_entry, msg, NULL TSRMLS_CC), 0);
+ RETURN_OBJ(&php_http_message_object_new_ex(obj->zo.ce, msg)->zo);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_count, 0, 0, 0)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, count)
{
- long count_mode = -1;
+ zend_long count_mode = -1;
if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &count_mode)) {
- long i = 0;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_http_message_count(i, obj->message);
- RETURN_LONG(i);
+ RETURN_LONG(php_http_message_count(obj->message));
}
}
{
if (SUCCESS == zend_parse_parameters_none()) {
zval *zobj = getThis();
- php_http_message_object_t *obj = zend_object_store_get_object(zobj TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- if (obj->iterator) {
+ if (!Z_ISUNDEF(obj->iterator)) {
zval_ptr_dtor(&obj->iterator);
}
- Z_ADDREF_P(zobj);
- obj->iterator = zobj;
+ ZVAL_COPY(&obj->iterator, zobj);
}
}
static PHP_METHOD(HttpMessage, valid)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- RETURN_BOOL(obj->iterator != NULL);
+ RETURN_BOOL(!Z_ISUNDEF(obj->iterator));
}
}
static PHP_METHOD(HttpMessage, next)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- if (obj->iterator) {
- php_http_message_object_t *itr = zend_object_store_get_object(obj->iterator TSRMLS_CC);
+ if (!Z_ISUNDEF(obj->iterator)) {
+ php_http_message_object_t *itr = PHP_HTTP_OBJ(NULL, &obj->iterator);
- if (itr && itr->parent) {
- zval *old = obj->iterator;
- MAKE_STD_ZVAL(obj->iterator);
- ZVAL_OBJVAL(obj->iterator, itr->parent->zv, 1);
- zval_ptr_dtor(&old);
+ if (itr->parent) {
+ zval tmp;
+
+ ZVAL_OBJECT(&tmp, &itr->parent->zo, 1);
+ zval_ptr_dtor(&obj->iterator);
+ obj->iterator = tmp;
} else {
zval_ptr_dtor(&obj->iterator);
- obj->iterator = NULL;
+ ZVAL_UNDEF(&obj->iterator);
}
}
}
static PHP_METHOD(HttpMessage, key)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- RETURN_LONG(obj->iterator ? obj->iterator->value.obj.handle:0);
+ RETURN_LONG(Z_ISUNDEF(obj->iterator) ? 0 : Z_OBJ_HANDLE(obj->iterator));
}
}
static PHP_METHOD(HttpMessage, current)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- if (obj->iterator) {
- RETURN_ZVAL(obj->iterator, 1, 0);
+ if (!Z_ISUNDEF(obj->iterator)) {
+ RETURN_ZVAL_FAST(&obj->iterator);
}
}
}
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http", "Message", php_http_message_methods);
- php_http_message_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+ php_http_message_class_entry = zend_register_internal_class(&ce);
php_http_message_class_entry->create_object = php_http_message_object_new;
memcpy(&php_http_message_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+ php_http_message_object_handlers.offset = XtOffsetOf(php_http_message_object_t, zo);
php_http_message_object_handlers.clone_obj = php_http_message_object_clone;
+ php_http_message_object_handlers.free_obj = php_http_message_object_free;
php_http_message_object_handlers.read_property = php_http_message_object_read_prop;
php_http_message_object_handlers.write_property = php_http_message_object_write_prop;
php_http_message_object_handlers.get_properties = php_http_message_object_get_props;
php_http_message_object_handlers.get_property_ptr_ptr = NULL;
- zend_class_implements(php_http_message_class_entry TSRMLS_CC, 3, spl_ce_Countable, zend_ce_serializable, zend_ce_iterator);
+ zend_class_implements(php_http_message_class_entry, 3, spl_ce_Countable, zend_ce_serializable, zend_ce_iterator);
- zend_hash_init(&php_http_message_object_prophandlers, 9, NULL, NULL, 1);
- zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("type"), PHP_HTTP_NONE, ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_hash_init(&php_http_message_object_prophandlers, 9, NULL, php_http_message_object_prophandler_hash_dtor, 1);
+ zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("type"), PHP_HTTP_NONE, ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("type"), php_http_message_object_prophandler_get_type, php_http_message_object_prophandler_set_type);
- zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("body"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("body"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("body"), php_http_message_object_prophandler_get_body, php_http_message_object_prophandler_set_body);
- zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestMethod"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestMethod"), "", ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("requestMethod"), php_http_message_object_prophandler_get_request_method, php_http_message_object_prophandler_set_request_method);
- zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestUrl"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestUrl"), "", ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("requestUrl"), php_http_message_object_prophandler_get_request_url, php_http_message_object_prophandler_set_request_url);
- zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("responseStatus"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("responseStatus"), "", ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("responseStatus"), php_http_message_object_prophandler_get_response_status, php_http_message_object_prophandler_set_response_status);
- zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("responseCode"), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("responseCode"), 0, ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("responseCode"), php_http_message_object_prophandler_get_response_code, php_http_message_object_prophandler_set_response_code);
- zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("httpVersion"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("httpVersion"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("httpVersion"), php_http_message_object_prophandler_get_http_version, php_http_message_object_prophandler_set_http_version);
- zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("headers"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("headers"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("headers"), php_http_message_object_prophandler_get_headers, php_http_message_object_prophandler_set_headers);
- zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("parentMessage"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("parentMessage"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("parentMessage"), php_http_message_object_prophandler_get_parent_message, php_http_message_object_prophandler_set_parent_message);
- zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_NONE"), PHP_HTTP_NONE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_REQUEST"), PHP_HTTP_REQUEST TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_RESPONSE"), PHP_HTTP_RESPONSE TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_NONE"), PHP_HTTP_NONE);
+ zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_REQUEST"), PHP_HTTP_REQUEST);
+ zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_RESPONSE"), PHP_HTTP_RESPONSE);
return SUCCESS;
}
#define BOUNDARY_CLOSE(body) \
php_http_message_body_appendf(body, PHP_HTTP_CRLF "--%s--" PHP_HTTP_CRLF, php_http_message_body_boundary(body))
-static STATUS add_recursive_fields(php_http_message_body_t *body, const char *name, zval *value);
-static STATUS add_recursive_files(php_http_message_body_t *body, const char *name, zval *value);
+static ZEND_RESULT_CODE add_recursive_fields(php_http_message_body_t *body, const char *name, HashTable *fields);
+static ZEND_RESULT_CODE add_recursive_files(php_http_message_body_t *body, const char *name, HashTable *files);
-php_http_message_body_t *php_http_message_body_init(php_http_message_body_t **body_ptr, php_stream *stream TSRMLS_DC)
+php_http_message_body_t *php_http_message_body_init(php_http_message_body_t **body_ptr, php_stream *stream)
{
php_http_message_body_t *body;
body->refcount = 1;
if (stream) {
- php_stream_auto_cleanup(stream);
- body->stream_id = php_stream_get_resource_id(stream);
- zend_list_addref(body->stream_id);
+ body->res = stream->res;
+ ++GC_REFCOUNT(body->res);
} else {
stream = php_stream_temp_create(TEMP_STREAM_DEFAULT, 0xffff);
- php_stream_auto_cleanup(stream);
- body->stream_id = php_stream_get_resource_id(stream);
+ body->res = stream->res;
}
- TSRMLS_SET_CTX(body->ts);
+ php_stream_auto_cleanup(stream);
if (body_ptr) {
*body_ptr = body;
php_http_message_body_t *php_http_message_body_copy(php_http_message_body_t *from, php_http_message_body_t *to)
{
if (from) {
- TSRMLS_FETCH_FROM_CTX(from->ts);
-
if (to) {
php_stream_truncate_set_size(php_http_message_body_stream(to), 0);
} else {
- to = php_http_message_body_init(NULL, NULL TSRMLS_CC);
+ to = php_http_message_body_init(NULL, NULL);
}
php_http_message_body_to_stream(from, php_http_message_body_stream(to), 0, 0);
php_http_message_body_t *body = *body_ptr;
if (!--body->refcount) {
- TSRMLS_FETCH_FROM_CTX(body->ts);
/* NOFIXME: shows leakinfo in DEBUG mode */
- zend_list_delete(body->stream_id);
+ zend_list_delete(body->res);
PTR_FREE(body->boundary);
efree(body);
}
const php_stream_statbuf *php_http_message_body_stat(php_http_message_body_t *body)
{
- TSRMLS_FETCH_FROM_CTX(body->ts);
php_stream_stat(php_http_message_body_stream(body), &body->ssb);
return &body->ssb;
}
{
if (!body->boundary) {
union { double dbl; int num[2]; } data;
- TSRMLS_FETCH_FROM_CTX(body->ts);
data.dbl = php_combined_lcg(TSRMLS_C);
spprintf(&body->boundary, 0, "%x.%x", data.num[0], data.num[1]);
char *php_http_message_body_etag(php_http_message_body_t *body)
{
const php_stream_statbuf *ssb = php_http_message_body_stat(body);
- TSRMLS_FETCH_FROM_CTX(body->ts);
/* real file or temp buffer ? */
- if (ssb && ssb->sb.st_mtime) {
+ if (ssb->sb.st_mtime) {
char *etag;
spprintf(&etag, 0, "%lx-%lx-%lx", ssb->sb.st_ino, ssb->sb.st_mtime, ssb->sb.st_size);
return etag;
} else {
- php_http_etag_t *etag = php_http_etag_init(PHP_HTTP_G->env.etag_mode TSRMLS_CC);
+ php_http_etag_t *etag = php_http_etag_init(PHP_HTTP_G->env.etag_mode);
if (etag) {
php_http_message_body_to_callback(body, (php_http_pass_callback_t) php_http_etag_update, etag, 0, 0);
}
}
-void php_http_message_body_to_string(php_http_message_body_t *body, char **buf, size_t *len, off_t offset, size_t forlen)
+zend_string *php_http_message_body_to_string(php_http_message_body_t *body, off_t offset, size_t forlen)
{
php_stream *s = php_http_message_body_stream(body);
- TSRMLS_FETCH_FROM_CTX(body->ts);
php_stream_seek(s, offset, SEEK_SET);
if (!forlen) {
forlen = -1;
}
- *len = php_stream_copy_to_mem(s, buf, forlen, 0);
+ return php_stream_copy_to_mem(s, forlen, 0);
}
-STATUS php_http_message_body_to_stream(php_http_message_body_t *body, php_stream *dst, off_t offset, size_t forlen)
+ZEND_RESULT_CODE php_http_message_body_to_stream(php_http_message_body_t *body, php_stream *dst, off_t offset, size_t forlen)
{
php_stream *s = php_http_message_body_stream(body);
- TSRMLS_FETCH_FROM_CTX(body->ts);
php_stream_seek(s, offset, SEEK_SET);
return php_stream_copy_to_stream_ex(s, dst, forlen, NULL);
}
-STATUS php_http_message_body_to_callback(php_http_message_body_t *body, php_http_pass_callback_t cb, void *cb_arg, off_t offset, size_t forlen)
+ZEND_RESULT_CODE php_http_message_body_to_callback(php_http_message_body_t *body, php_http_pass_callback_t cb, void *cb_arg, off_t offset, size_t forlen)
{
php_stream *s = php_http_message_body_stream(body);
char *buf = emalloc(0x1000);
- TSRMLS_FETCH_FROM_CTX(body->ts);
php_stream_seek(s, offset, SEEK_SET);
{
php_stream *s;
size_t written;
- TSRMLS_FETCH_FROM_CTX(body->ts);
if (!(s = php_http_message_body_stream(body))) {
return -1;
return print_len;
}
-STATUS php_http_message_body_add_form(php_http_message_body_t *body, HashTable *fields, HashTable *files)
+ZEND_RESULT_CODE php_http_message_body_add_form(php_http_message_body_t *body, HashTable *fields, HashTable *files)
{
- zval tmp;
-
if (fields) {
- INIT_PZVAL_ARRAY(&tmp, fields);
- if (SUCCESS != add_recursive_fields(body, NULL, &tmp)) {
+ if (SUCCESS != add_recursive_fields(body, NULL, fields)) {
return FAILURE;
}
}
if (files) {
- INIT_PZVAL_ARRAY(&tmp, files);
- if (SUCCESS != add_recursive_files(body, NULL, &tmp)) {
+ if (SUCCESS != add_recursive_files(body, NULL, files)) {
return FAILURE;
}
}
void php_http_message_body_add_part(php_http_message_body_t *body, php_http_message_t *part)
{
- TSRMLS_FETCH_FROM_CTX(body->ts);
-
BOUNDARY_OPEN(body);
php_http_message_to_callback(part, (php_http_pass_callback_t) php_http_message_body_append, body);
BOUNDARY_CLOSE(body);
}
-STATUS php_http_message_body_add_form_field(php_http_message_body_t *body, const char *name, const char *value_str, size_t value_len)
+ZEND_RESULT_CODE php_http_message_body_add_form_field(php_http_message_body_t *body, const char *name, const char *value_str, size_t value_len)
{
- char *safe_name;
- TSRMLS_FETCH_FROM_CTX(body->ts);
+ zend_string *safe_name = zend_string_init(name, strlen(name), 0);
- safe_name = php_addslashes(estrdup(name), strlen(name), NULL, 1 TSRMLS_CC);
+ safe_name = php_addslashes(safe_name, 1);
BOUNDARY_OPEN(body);
php_http_message_body_appendf(
body,
"Content-Disposition: form-data; name=\"%s\"" PHP_HTTP_CRLF
"" PHP_HTTP_CRLF,
- safe_name
+ safe_name->val
);
php_http_message_body_append(body, value_str, value_len);
BOUNDARY_CLOSE(body);
- efree(safe_name);
+ zend_string_release(safe_name);
return SUCCESS;
}
-STATUS php_http_message_body_add_form_file(php_http_message_body_t *body, const char *name, const char *ctype, const char *path, php_stream *in)
+ZEND_RESULT_CODE php_http_message_body_add_form_file(php_http_message_body_t *body, const char *name, const char *ctype, const char *path, php_stream *in)
{
- char *safe_name, *path_dup = estrdup(path), *bname;
- size_t bname_len;
- TSRMLS_FETCH_FROM_CTX(body->ts);
+ size_t path_len = strlen(path);
+ char *path_dup = estrndup(path, path_len);
+ zend_string *base_name, *safe_name = zend_string_init(name, strlen(name), 0);
- safe_name = php_addslashes(estrdup(name), strlen(name), NULL, 1 TSRMLS_CC);
-
- php_basename(path_dup, strlen(path_dup), NULL, 0, &bname, &bname_len TSRMLS_CC);
+ safe_name = php_addslashes(safe_name, 1);
+ base_name = php_basename(path_dup, path_len, NULL, 0);
BOUNDARY_OPEN(body);
php_http_message_body_appendf(
"Content-Transfer-Encoding: binary" PHP_HTTP_CRLF
"Content-Type: %s" PHP_HTTP_CRLF
PHP_HTTP_CRLF,
- safe_name, bname, ctype
+ safe_name->val, base_name->val, ctype
);
php_stream_copy_to_stream_ex(in, php_http_message_body_stream(body), PHP_STREAM_COPY_ALL, NULL);
BOUNDARY_CLOSE(body);
- efree(safe_name);
+ zend_string_release(safe_name);
+ zend_string_release(base_name);
efree(path_dup);
- efree(bname);
return SUCCESS;
}
-static inline char *format_key(uint type, char *str, ulong num, const char *prefix) {
+static inline char *format_key(php_http_arrkey_t *key, const char *prefix) {
char *new_key = NULL;
if (prefix && *prefix) {
- if (type == HASH_KEY_IS_STRING) {
- spprintf(&new_key, 0, "%s[%s]", prefix, str);
+ if (key->key) {
+ spprintf(&new_key, 0, "%s[%s]", prefix, key->key->val);
} else {
- spprintf(&new_key, 0, "%s[%lu]", prefix, num);
+ spprintf(&new_key, 0, "%s[%lu]", prefix, key->h);
}
- } else if (type == HASH_KEY_IS_STRING) {
- new_key = estrdup(str);
+ } else if (key->key) {
+ new_key = estrdup(key->key->val);
} else {
new_key = estrdup("");
}
return new_key;
}
-static STATUS add_recursive_fields(php_http_message_body_t *body, const char *name, zval *value)
+static ZEND_RESULT_CODE add_recursive_field_value(php_http_message_body_t *body, const char *name, zval *value)
+{
+ zend_string *zs = zval_get_string(value);
+ ZEND_RESULT_CODE rc = php_http_message_body_add_form_field(body, name, zs->val, zs->len);
+ zend_string_release(zs);
+ return rc;
+}
+
+static ZEND_RESULT_CODE add_recursive_fields(php_http_message_body_t *body, const char *name, HashTable *fields)
{
- if (Z_TYPE_P(value) == IS_ARRAY || Z_TYPE_P(value) == IS_OBJECT) {
- zval **val;
- HashTable *ht;
- HashPosition pos;
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
- TSRMLS_FETCH_FROM_CTX(body->ts);
+ zval *val;
+ php_http_arrkey_t key;
+
+ if (!ZEND_HASH_GET_APPLY_COUNT(fields)) {
+ ZEND_HASH_INC_APPLY_COUNT(fields);
+ ZEND_HASH_FOREACH_KEY_VAL_IND(fields, key.h, key.key, val)
+ {
+ char *str = format_key(&key, name);
- ht = HASH_OF(value);
- if (!ht->nApplyCount) {
- ++ht->nApplyCount;
- FOREACH_KEYVAL(pos, value, key, val) {
- char *str = format_key(key.type, key.str, key.num, name);
- if (SUCCESS != add_recursive_fields(body, str, *val)) {
+ if (Z_TYPE_P(val) != IS_ARRAY && Z_TYPE_P(val) != IS_OBJECT) {
+ if (SUCCESS != add_recursive_field_value(body, str, val)) {
efree(str);
- ht->nApplyCount--;
+ ZEND_HASH_DEC_APPLY_COUNT(fields);
return FAILURE;
}
+ } else if (SUCCESS != add_recursive_fields(body, str, HASH_OF(val))) {
efree(str);
+ ZEND_HASH_DEC_APPLY_COUNT(fields);
+ return FAILURE;
}
- --ht->nApplyCount;
+ efree(str);
}
- } else {
- zval *cpy = php_http_ztyp(IS_STRING, value);
- php_http_message_body_add_form_field(body, name, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy));
- zval_ptr_dtor(&cpy);
+ ZEND_HASH_FOREACH_END();
+ ZEND_HASH_DEC_APPLY_COUNT(fields);
}
return SUCCESS;
}
-static STATUS add_recursive_files(php_http_message_body_t *body, const char *name, zval *value)
+static ZEND_RESULT_CODE add_recursive_files(php_http_message_body_t *body, const char *name, HashTable *files)
{
- zval **zdata = NULL, **zfile, **zname, **ztype;
- HashTable *ht;
- TSRMLS_FETCH_FROM_CTX(body->ts);
-
- if (Z_TYPE_P(value) != IS_ARRAY && Z_TYPE_P(value) != IS_OBJECT) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expected array or object (name, type, file) for message body file to add");
- return FAILURE;
- }
-
- ht = HASH_OF(value);
+ zval *zdata = NULL, *zfile, *zname, *ztype;
- if ((SUCCESS != zend_hash_find(ht, ZEND_STRS("name"), (void *) &zname))
- || (SUCCESS != zend_hash_find(ht, ZEND_STRS("type"), (void *) &ztype))
- || (SUCCESS != zend_hash_find(ht, ZEND_STRS("file"), (void *) &zfile))
+ /* single entry */
+ if (!(zname = zend_hash_str_find(files, ZEND_STRL("name")))
+ || !(ztype = zend_hash_str_find(files, ZEND_STRL("type")))
+ || !(zfile = zend_hash_str_find(files, ZEND_STRL("file")))
) {
- zval **val;
- HashPosition pos;
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
+ zval *val;
+ php_http_arrkey_t key;
- if (!ht->nApplyCount) {
- ++ht->nApplyCount;
- FOREACH_HASH_KEYVAL(pos, ht, key, val) {
- if (Z_TYPE_PP(val) == IS_ARRAY || Z_TYPE_PP(val) == IS_OBJECT) {
- char *str = format_key(key.type, key.str, key.num, name);
+ if (!ZEND_HASH_GET_APPLY_COUNT(files)) {
+ ZEND_HASH_INC_APPLY_COUNT(files);
+ ZEND_HASH_FOREACH_KEY_VAL_IND(files, key.h, key.key, val)
+ {
+ if (Z_TYPE_P(val) == IS_ARRAY || Z_TYPE_P(val) == IS_OBJECT) {
+ char *str = format_key(&key, name);
- if (SUCCESS != add_recursive_files(body, str, *val)) {
+ if (SUCCESS != add_recursive_files(body, str, HASH_OF(val))) {
efree(str);
- --ht->nApplyCount;
+ ZEND_HASH_DEC_APPLY_COUNT(files);
return FAILURE;
}
efree(str);
}
}
- --ht->nApplyCount;
+ ZEND_HASH_FOREACH_END();
+ ZEND_HASH_DEC_APPLY_COUNT(files);
}
return SUCCESS;
} else {
+ /* stream entry */
php_stream *stream;
- zval *zfc = php_http_ztyp(IS_STRING, *zfile);
+ zend_string *zfc = zval_get_string(zfile);
- if (SUCCESS == zend_hash_find(ht, ZEND_STRS("data"), (void *) &zdata)) {
- if (Z_TYPE_PP(zdata) == IS_RESOURCE) {
+ if ((zdata = zend_hash_str_find(files, ZEND_STRL("data")))) {
+ if (Z_TYPE_P(zdata) == IS_RESOURCE) {
php_stream_from_zval_no_verify(stream, zdata);
} else {
- zval *tmp = php_http_ztyp(IS_STRING, *zdata);
+ zend_string *tmp = zval_get_string(zdata);
- stream = php_stream_memory_open(TEMP_STREAM_READONLY, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
- zval_ptr_dtor(&tmp);
+ stream = php_stream_memory_open(TEMP_STREAM_READONLY, tmp->val, tmp->len);
+ zend_string_release(tmp);
}
} else {
- stream = php_stream_open_wrapper(Z_STRVAL_P(zfc), "r", REPORT_ERRORS|USE_PATH, NULL);
+ stream = php_stream_open_wrapper(zfc->val, "r", REPORT_ERRORS|USE_PATH, NULL);
}
if (!stream) {
- zval_ptr_dtor(&zfc);
+ zend_string_release(zfc);
return FAILURE;
} else {
- zval *znc = php_http_ztyp(IS_STRING, *zname), *ztc = php_http_ztyp(IS_STRING, *ztype);
- char *key = format_key(HASH_KEY_IS_STRING, Z_STRVAL_P(znc), 0, name);
- STATUS ret = php_http_message_body_add_form_file(body, key, Z_STRVAL_P(ztc), Z_STRVAL_P(zfc), stream);
+ zend_string *znc = zval_get_string(zname), *ztc = zval_get_string(ztype);
+ php_http_arrkey_t arrkey = {0, znc};
+ char *key = format_key(&arrkey, name);
+ ZEND_RESULT_CODE ret = php_http_message_body_add_form_file(body, key, ztc->val, zfc->val, stream);
efree(key);
- zval_ptr_dtor(&znc);
- zval_ptr_dtor(&ztc);
- zval_ptr_dtor(&zfc);
- if (!zdata || Z_TYPE_PP(zdata) != IS_RESOURCE) {
+ zend_string_release(znc);
+ zend_string_release(ztc);
+ zend_string_release(zfc);
+ if (!zdata || Z_TYPE_P(zdata) != IS_RESOURCE) {
php_stream_close(stream);
}
return ret;
size_t consumed;
};
-static size_t splitbody(void *opaque, char *buf, size_t len TSRMLS_DC)
+static size_t splitbody(void *opaque, char *buf, size_t len)
{
struct splitbody_arg *arg = opaque;
const char *boundary = NULL;
/* advance messages */
php_http_message_t *msg;
- msg = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+ msg = php_http_message_init(NULL, 0, NULL);
msg->parent = arg->parser->message;
arg->parser->message = msg;
}
len = 0;
} else {
/* let this be garbage */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Malformed multipart boundary at pos %zu", consumed);
+ php_error_docref(NULL, E_WARNING, "Malformed multipart boundary at pos %zu", consumed);
return -1;
}
}
php_http_buffer_t *tmp = NULL;
php_http_message_t *msg = NULL;
struct splitbody_arg arg;
- TSRMLS_FETCH_FROM_CTX(body->ts);
php_http_buffer_init(&arg.buf);
- arg.parser = php_http_message_parser_init(NULL TSRMLS_CC);
+ arg.parser = php_http_message_parser_init(NULL);
arg.boundary_len = spprintf(&arg.boundary_str, 0, "\n--%s", boundary);
arg.consumed = 0;
php_stream_rewind(s);
while (!php_stream_eof(s)) {
- php_http_buffer_passthru(&tmp, 0x1000, (php_http_buffer_pass_func_t) _php_stream_read, s, splitbody, &arg TSRMLS_CC);
+ php_http_buffer_passthru(&tmp, 0x1000, (php_http_buffer_pass_func_t) _php_stream_read, s, splitbody, &arg);
}
msg = arg.parser->message;
static zend_object_handlers php_http_message_body_object_handlers;
-zend_object_value php_http_message_body_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *php_http_message_body_object_new(zend_class_entry *ce)
{
- return php_http_message_body_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+ return &php_http_message_body_object_new_ex(ce, NULL)->zo;
}
-zend_object_value php_http_message_body_object_new_ex(zend_class_entry *ce, php_http_message_body_t *body, php_http_message_body_object_t **ptr TSRMLS_DC)
+php_http_message_body_object_t *php_http_message_body_object_new_ex(zend_class_entry *ce, php_http_message_body_t *body)
{
php_http_message_body_object_t *o;
- o = ecalloc(1, sizeof(php_http_message_body_object_t) + (ce->default_properties_count - 1) * sizeof(zval));
- o = ecalloc(1, sizeof(php_http_message_body_object_t));
- zend_object_std_init((zend_object *) o, php_http_message_body_class_entry TSRMLS_CC);
- object_properties_init((zend_object *) o, ce);
-
- if (ptr) {
- *ptr = o;
- }
++ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+ zend_object_std_init(&o->zo, php_http_message_body_class_entry);
+ object_properties_init(&o->zo, ce);
if (body) {
o->body = body;
}
- o->zv.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_message_body_object_free, NULL TSRMLS_CC);
- o->zv.handlers = &php_http_message_body_object_handlers;
+ o->zo.handlers = &php_http_message_body_object_handlers;
- return o->zv;
+ return o;
}
-zend_object_value php_http_message_body_object_clone(zval *object TSRMLS_DC)
+zend_object *php_http_message_body_object_clone(zval *object)
{
- zend_object_value new_ov;
php_http_message_body_object_t *new_obj = NULL;
- php_http_message_body_object_t *old_obj = zend_object_store_get_object(object TSRMLS_CC);
+ php_http_message_body_object_t *old_obj = PHP_HTTP_OBJ(NULL, object);
php_http_message_body_t *body = php_http_message_body_copy(old_obj->body, NULL);
- new_ov = php_http_message_body_object_new_ex(old_obj->zo.ce, body, &new_obj TSRMLS_CC);
- zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(object) TSRMLS_CC);
+ new_obj = php_http_message_body_object_new_ex(old_obj->zo.ce, body);
+ zend_objects_clone_members(&new_obj->zo, &old_obj->zo);
- return new_ov;
+ return &new_obj->zo;
}
-void php_http_message_body_object_free(void *object TSRMLS_DC)
+void php_http_message_body_object_free(zend_object *object)
{
- php_http_message_body_object_t *obj = object;
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(object, NULL);
php_http_message_body_free(&obj->body);
- zend_object_std_dtor((zend_object *) obj TSRMLS_CC);
- efree(obj);
+ zend_object_std_dtor(object TSRMLS_CC);
}
#define PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj) \
do { \
if (!obj->body) { \
- obj->body = php_http_message_body_init(NULL, NULL TSRMLS_CC); \
+ obj->body = php_http_message_body_init(NULL, NULL); \
} \
} while(0)
ZEND_END_ARG_INFO();
PHP_METHOD(HttpMessageBody, __construct)
{
- php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
zval *zstream = NULL;
php_stream *stream;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r!", &zstream), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|r!", &zstream), invalid_arg, return);
if (zstream) {
- php_http_expect(php_stream_from_zval_no_verify(stream, &zstream), unexpected_val, return);
+ php_http_expect(php_stream_from_zval_no_verify(stream, zstream), unexpected_val, return);
if (obj->body) {
php_http_message_body_free(&obj->body);
}
- obj->body = php_http_message_body_init(NULL, stream TSRMLS_CC);
+ obj->body = php_http_message_body_init(NULL, stream);
}
}
PHP_METHOD(HttpMessageBody, __toString)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- char *str;
- size_t len;
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
+ zend_string *zs;
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
- php_http_message_body_to_string(obj->body, &str, &len, 0, 0);
- if (str) {
- RETURN_STRINGL(str, len, 0);
+ zs = php_http_message_body_to_string(obj->body, 0, 0);
+ if (zs) {
+ RETURN_STR(zs);
}
}
RETURN_EMPTY_STRING();
PHP_METHOD(HttpMessageBody, unserialize)
{
char *us_str;
- int us_len;
+ size_t us_len;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &us_str, &us_len)) {
- php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &us_str, &us_len)) {
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
php_stream *s = php_stream_memory_open(0, us_str, us_len);
- obj->body = php_http_message_body_init(NULL, s TSRMLS_CC);
+ obj->body = php_http_message_body_init(NULL, s);
}
}
PHP_METHOD(HttpMessageBody, toStream)
{
zval *zstream;
- long offset = 0, forlen = 0;
+ zend_long offset = 0, forlen = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ll", &zstream, &offset, &forlen)) {
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "r|ll", &zstream, &offset, &forlen)) {
php_stream *stream;
- php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
- php_stream_from_zval(stream, &zstream);
+ php_stream_from_zval(stream, zstream);
php_http_message_body_to_stream(obj->body, stream, offset, forlen);
RETURN_ZVAL(getThis(), 1, 0);
}
PHP_METHOD(HttpMessageBody, toCallback)
{
php_http_pass_fcall_arg_t fcd;
- long offset = 0, forlen = 0;
+ zend_long offset = 0, forlen = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f|ll", &fcd.fci, &fcd.fcc, &offset, &forlen)) {
- php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "f|ll", &fcd.fci, &fcd.fcc, &offset, &forlen)) {
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
- fcd.fcz = getThis();
- Z_ADDREF_P(fcd.fcz);
- TSRMLS_SET_CTX(fcd.ts);
-
+ ZVAL_COPY(&fcd.fcz, getThis());
php_http_message_body_to_callback(obj->body, php_http_pass_fcall_callback, &fcd, offset, forlen);
zend_fcall_info_args_clear(&fcd.fci, 1);
-
zval_ptr_dtor(&fcd.fcz);
- RETURN_ZVAL(getThis(), 1, 0);
+ RETURN_ZVAL_FAST(getThis());
}
}
PHP_METHOD(HttpMessageBody, getResource)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
- zend_list_addref(obj->body->stream_id);
- RETVAL_RESOURCE(obj->body->stream_id);
+ ++GC_REFCOUNT(obj->body->res);
+ RETVAL_RES(obj->body->res);
}
}
PHP_METHOD(HttpMessageBody, getBoundary)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_body_object_t * obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_body_object_t * obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
if (obj->body->boundary) {
- RETURN_STRING(obj->body->boundary, 1);
+ RETURN_STRING(obj->body->boundary);
}
}
}
PHP_METHOD(HttpMessageBody, append)
{
char *str;
- int len;
+ size_t len;
php_http_message_body_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len), invalid_arg, return);
-
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &len), invalid_arg, return);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
php_http_expect(len == php_http_message_body_append(obj->body, str, len), runtime, return);
- RETURN_ZVAL(getThis(), 1, 0);
+ RETURN_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_addForm, 0, 0, 0)
HashTable *fields = NULL, *files = NULL;
php_http_message_body_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|h!h!", &fields, &files), invalid_arg, return);
-
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|h!h!", &fields, &files), invalid_arg, return);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
php_http_expect(SUCCESS == php_http_message_body_add_form(obj->body, fields, files), runtime, return);
- RETURN_ZVAL(getThis(), 1, 0);
+ RETURN_ZVAL_FAST(getThis());
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_addPart, 0, 0, 1)
php_http_message_object_t *mobj;
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zobj, php_http_message_class_entry), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &zobj, php_http_message_class_entry), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- mobj = zend_object_store_get_object(zobj TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
+ mobj = PHP_HTTP_OBJ(NULL, zobj);
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
- zend_replace_error_handling(EH_THROW, php_http_exception_runtime_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_runtime_class_entry, &zeh);
php_http_message_body_add_part(obj->body, mobj->message);
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
if (!EG(exception)) {
- RETURN_ZVAL(getThis(), 1, 0);
+ RETURN_ZVAL_FAST(getThis());
}
}
PHP_METHOD(HttpMessageBody, etag)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *etag;
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
if ((etag = php_http_message_body_etag(obj->body))) {
- RETURN_STRING(etag, 0);
+ RETURN_STR(php_http_cs2zs(etag, strlen(etag)));
} else {
RETURN_FALSE;
}
PHP_METHOD(HttpMessageBody, stat)
{
char *field_str = NULL;
- int field_len = 0;
+ size_t field_len = 0;
if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &field_str, &field_len)) {
- php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
const php_stream_statbuf *sb;
PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
RETURN_LONG(sb->sb.st_ctime);
break;
default:
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown stat field: '%s' (should be one of [s]ize, [a]time, [m]time or [c]time)", field_str);
+ php_error_docref(NULL, E_WARNING, "Unknown stat field: '%s' (should be one of [s]ize, [a]time, [m]time or [c]time)", field_str);
break;
}
} else {
object_init(return_value);
- add_property_long_ex(return_value, ZEND_STRS("size"), sb->sb.st_size TSRMLS_CC);
- add_property_long_ex(return_value, ZEND_STRS("atime"), sb->sb.st_atime TSRMLS_CC);
- add_property_long_ex(return_value, ZEND_STRS("mtime"), sb->sb.st_mtime TSRMLS_CC);
- add_property_long_ex(return_value, ZEND_STRS("ctime"), sb->sb.st_ctime TSRMLS_CC);
+ add_property_long_ex(return_value, ZEND_STRL("size"), sb->sb.st_size);
+ add_property_long_ex(return_value, ZEND_STRL("atime"), sb->sb.st_atime);
+ add_property_long_ex(return_value, ZEND_STRL("mtime"), sb->sb.st_mtime);
+ add_property_long_ex(return_value, ZEND_STRL("ctime"), sb->sb.st_ctime);
}
}
}
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http\\Message", "Body", php_http_message_body_methods);
- php_http_message_body_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+ php_http_message_body_class_entry = zend_register_internal_class(&ce);
php_http_message_body_class_entry->create_object = php_http_message_body_object_new;
memcpy(&php_http_message_body_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+ php_http_message_body_object_handlers.offset = XtOffsetOf(php_http_message_body_object_t, zo);
php_http_message_body_object_handlers.clone_obj = php_http_message_body_object_clone;
- zend_class_implements(php_http_message_body_class_entry TSRMLS_CC, 1, zend_ce_serializable);
+ php_http_message_body_object_handlers.free_obj = php_http_message_body_object_free;
+ zend_class_implements(php_http_message_body_class_entry, 1, zend_ce_serializable);
return SUCCESS;
}
}
#endif
-php_http_message_parser_t *php_http_message_parser_init(php_http_message_parser_t *parser TSRMLS_DC)
+php_http_message_parser_t *php_http_message_parser_init(php_http_message_parser_t *parser)
{
if (!parser) {
parser = emalloc(sizeof(*parser));
}
memset(parser, 0, sizeof(*parser));
- TSRMLS_SET_CTX(parser->ts);
-
- php_http_header_parser_init(&parser->header TSRMLS_CC);
+ php_http_header_parser_init(&parser->header);
return parser;
}
php_http_message_parser_state_t php_http_message_parser_parse_stream(php_http_message_parser_t *parser, php_http_buffer_t *buf, php_stream *s, unsigned flags, php_http_message_t **message)
{
php_http_message_parser_state_t state = PHP_HTTP_MESSAGE_PARSER_STATE_START;
- TSRMLS_FETCH_FROM_CTX(parser->ts);
if (!buf->data) {
php_http_buffer_resize_ex(buf, 0x1000, 1, 0);
}
+
while (!php_stream_eof(s)) {
size_t justread = 0;
#if DBG_PARSER
char *str = NULL;
size_t len = 0;
size_t cut = 0;
- TSRMLS_FETCH_FROM_CTX(parser->ts);
while (buffer->used || !php_http_message_parser_states[php_http_message_parser_state_is(parser)].need_data) {
#if DBG_PARSER
case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE:
{
- zval *h, *h_loc = NULL, *h_con = NULL, **h_cl = NULL, **h_cr = NULL, **h_te = NULL;
+ zval h, *h_ptr, *h_loc = NULL, *h_con = NULL, *h_ce;
+ zend_bool chunked = 0;
+ zend_long content_length = -1;
+ zend_string *content_range = NULL;
+
+ if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Transfer-Encoding")))) {
+ zend_string *zs = zval_get_string(h_ptr);
+
+ chunked = zend_string_equals_literal(zs, "chunked");
+ zend_string_release(zs);
+
+ Z_TRY_ADDREF_P(h_ptr);
+ zend_hash_str_update(&(*message)->hdrs, "X-Original-Transfer-Encoding", lenof("X-Original-Transfer-Encoding"), h_ptr);
+ zend_hash_str_del(&(*message)->hdrs, "Transfer-Encoding", lenof("Transfer-Encoding"));
- if ((h = php_http_message_header(*message, ZEND_STRL("Transfer-Encoding"), 1))) {
- zend_hash_update(&(*message)->hdrs, "X-Original-Transfer-Encoding", sizeof("X-Original-Transfer-Encoding"), &h, sizeof(zval *), (void *) &h_te);
- zend_hash_del(&(*message)->hdrs, "Transfer-Encoding", sizeof("Transfer-Encoding"));
}
- if ((h = php_http_message_header(*message, ZEND_STRL("Content-Length"), 1))) {
- zend_hash_update(&(*message)->hdrs, "X-Original-Content-Length", sizeof("X-Original-Content-Length"), &h, sizeof(zval *), (void *) &h_cl);
+ if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Content-Length")))) {
+ content_length = zval_get_long(h_ptr);
+
+ Z_TRY_ADDREF_P(h_ptr);
+ zend_hash_str_update(&(*message)->hdrs, "X-Original-Content-Length", lenof("X-Original-Content-Length"), h_ptr);
}
- if ((h = php_http_message_header(*message, ZEND_STRL("Content-Range"), 1))) {
- zend_hash_update(&(*message)->hdrs, "X-Original-Content-Range", sizeof("X-Original-Content-Range"), &h, sizeof(zval *), (void *) &h_cr);
- zend_hash_del(&(*message)->hdrs, "Content-Range", sizeof("Content-Range"));
+ if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Content-Range")))) {
+ content_range = zval_get_string(h_ptr);
+
+ Z_TRY_ADDREF_P(h_ptr);
+ zend_hash_str_update(&(*message)->hdrs, "X-Original-Content-Range", lenof("X-Original-Content-Range"), h_ptr);
+ zend_hash_str_del(&(*message)->hdrs, "Content-Range", lenof("Content-Range"));
}
/* default */
- MAKE_STD_ZVAL(h);
- ZVAL_LONG(h, 0);
- zend_hash_update(&(*message)->hdrs, "Content-Length", sizeof("Content-Length"), &h, sizeof(zval *), NULL);
+ ZVAL_LONG(&h, 0);
+ zend_hash_str_update(&(*message)->hdrs, "Content-Length", lenof("Content-Length"), &h);
/* so, if curl sees a 3xx code, a Location header and a Connection:close header
* it decides not to read the response body.
if ((flags & PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS)
&& (*message)->type == PHP_HTTP_RESPONSE
&& (*message)->http.info.response.code/100 == 3
- && (h_loc = php_http_message_header(*message, ZEND_STRL("Location"), 1))
- && (h_con = php_http_message_header(*message, ZEND_STRL("Connection"), 1))
+ && (h_loc = php_http_message_header(*message, ZEND_STRL("Location")))
+ && (h_con = php_http_message_header(*message, ZEND_STRL("Connection")))
) {
if (php_http_match(Z_STRVAL_P(h_con), "close", PHP_HTTP_MATCH_WORD)) {
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
- zval_ptr_dtor(&h_loc);
- zval_ptr_dtor(&h_con);
break;
}
}
- if (h_loc) {
- zval_ptr_dtor(&h_loc);
- }
- if (h_con) {
- zval_ptr_dtor(&h_con);
- }
- if ((h = php_http_message_header(*message, ZEND_STRL("Content-Encoding"), 1))) {
- if (php_http_match(Z_STRVAL_P(h), "gzip", PHP_HTTP_MATCH_WORD)
- || php_http_match(Z_STRVAL_P(h), "x-gzip", PHP_HTTP_MATCH_WORD)
- || php_http_match(Z_STRVAL_P(h), "deflate", PHP_HTTP_MATCH_WORD)
+ if ((h_ce = php_http_message_header(*message, ZEND_STRL("Content-Encoding")))) {
+ if (php_http_match(Z_STRVAL_P(h_ce), "gzip", PHP_HTTP_MATCH_WORD)
+ || php_http_match(Z_STRVAL_P(h_ce), "x-gzip", PHP_HTTP_MATCH_WORD)
+ || php_http_match(Z_STRVAL_P(h_ce), "deflate", PHP_HTTP_MATCH_WORD)
) {
if (parser->inflate) {
php_http_encoding_stream_reset(&parser->inflate);
} else {
- parser->inflate = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_inflate_ops(), 0 TSRMLS_CC);
+ parser->inflate = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_inflate_ops(), 0);
}
- zend_hash_update(&(*message)->hdrs, "X-Original-Content-Encoding", sizeof("X-Original-Content-Encoding"), &h, sizeof(zval *), NULL);
- zend_hash_del(&(*message)->hdrs, "Content-Encoding", sizeof("Content-Encoding"));
- } else {
- zval_ptr_dtor(&h);
+ Z_TRY_ADDREF_P(h_ce);
+ zend_hash_str_update(&(*message)->hdrs, "X-Original-Content-Encoding", lenof("X-Original-Content-Encoding"), h_ce);
+ zend_hash_str_del(&(*message)->hdrs, "Content-Encoding", lenof("Content-Encoding"));
}
}
if ((flags & PHP_HTTP_MESSAGE_PARSER_DUMB_BODIES)) {
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB);
} else {
- if (h_te) {
- if (strstr(Z_STRVAL_PP(h_te), "chunked")) {
- parser->dechunk = php_http_encoding_stream_init(parser->dechunk, php_http_encoding_stream_get_dechunk_ops(), 0 TSRMLS_CC);
- php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED);
- break;
- }
+ if (chunked) {
+ parser->dechunk = php_http_encoding_stream_init(parser->dechunk, php_http_encoding_stream_get_dechunk_ops(), 0);
+ php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED);
+ break;
}
- if (h_cl) {
- char *stop;
-
- if (Z_TYPE_PP(h_cl) == IS_STRING) {
- parser->body_length = strtoul(Z_STRVAL_PP(h_cl), &stop, 10);
-
- if (stop != Z_STRVAL_PP(h_cl)) {
- php_http_message_parser_state_push(parser, 1, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
- break;
- }
- } else if (Z_TYPE_PP(h_cl) == IS_LONG) {
- parser->body_length = Z_LVAL_PP(h_cl);
- php_http_message_parser_state_push(parser, 1, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
- break;
- }
+ if (content_length >= 0) {
+ parser->body_length = content_length;
+ php_http_message_parser_state_push(parser, 1, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
+ break;
}
- if (h_cr) {
+ if (content_range) {
ulong total = 0, start = 0, end = 0;
- if (!strncasecmp(Z_STRVAL_PP(h_cr), "bytes", lenof("bytes"))
- && ( Z_STRVAL_P(h)[lenof("bytes")] == ':'
- || Z_STRVAL_P(h)[lenof("bytes")] == ' '
- || Z_STRVAL_P(h)[lenof("bytes")] == '='
+ if (!strncasecmp(content_range->val, "bytes", lenof("bytes"))
+ && ( content_range->val[lenof("bytes")] == ':'
+ || content_range->val[lenof("bytes")] == ' '
+ || content_range->val[lenof("bytes")] == '='
)
) {
char *total_at = NULL, *end_at = NULL;
- char *start_at = Z_STRVAL_PP(h_cr) + sizeof("bytes");
+ char *start_at = content_range->val + sizeof("bytes");
start = strtoul(start_at, &end_at, 10);
if (end_at) {
if (end >= start && (!total || end < total)) {
parser->body_length = end + 1 - start;
php_http_message_parser_state_push(parser, 1, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
+ zend_string_release(content_range);
break;
}
}
}
+
+ zend_string_release(content_range);
}
case PHP_HTTP_MESSAGE_PARSER_STATE_BODY:
{
if (len) {
- zval *zcl;
+ zval zcl;
if (parser->inflate) {
char *dec_str = NULL;
php_stream_write(php_http_message_body_stream((*message)->body), str, len);
/* keep track */
- MAKE_STD_ZVAL(zcl);
- ZVAL_LONG(zcl, php_http_message_body_size((*message)->body));
- zend_hash_update(&(*message)->hdrs, "Content-Length", sizeof("Content-Length"), &zcl, sizeof(zval *), NULL);
+ ZVAL_LONG(&zcl, php_http_message_body_size((*message)->body));
+ zend_hash_str_update(&(*message)->hdrs, "Content-Length", lenof("Content-Length"), &zcl);
}
if (cut) {
zend_class_entry *php_http_message_parser_class_entry;
static zend_object_handlers php_http_message_parser_object_handlers;
-zend_object_value php_http_message_parser_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *php_http_message_parser_object_new(zend_class_entry *ce)
{
- return php_http_message_parser_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+ return &php_http_message_parser_object_new_ex(ce, NULL)->zo;
}
-zend_object_value php_http_message_parser_object_new_ex(zend_class_entry *ce, php_http_message_parser_t *parser, php_http_message_parser_object_t **ptr TSRMLS_DC)
+php_http_message_parser_object_t *php_http_message_parser_object_new_ex(zend_class_entry *ce, php_http_message_parser_t *parser)
{
php_http_message_parser_object_t *o;
- o = ecalloc(1, sizeof(php_http_message_parser_object_t) + (ce->default_properties_count - 1) * sizeof(zval));
- o = ecalloc(1, sizeof(php_http_message_parser_object_t));
- zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
- object_properties_init((zend_object *) o, ce);
-
- if (ptr) {
- *ptr = o;
- }
++ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+ zend_object_std_init(&o->zo, ce);
+ object_properties_init(&o->zo, ce);
if (parser) {
o->parser = parser;
} else {
- o->parser = php_http_message_parser_init(NULL TSRMLS_CC);
+ o->parser = php_http_message_parser_init(NULL);
}
- o->buffer = php_http_buffer_new();
-
- o->zv.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_message_parser_object_free, NULL TSRMLS_CC);
- o->zv.handlers = &php_http_message_parser_object_handlers;
+ php_http_buffer_init(&o->buffer);
+ o->zo.handlers = &php_http_message_parser_object_handlers;
- return o->zv;
+ return o;
}
-void php_http_message_parser_object_free(void *object TSRMLS_DC)
+void php_http_message_parser_object_free(zend_object *object)
{
- php_http_message_parser_object_t *o = (php_http_message_parser_object_t *) object;
+ php_http_message_parser_object_t *o = PHP_HTTP_OBJ(object, NULL);
if (o->parser) {
php_http_message_parser_free(&o->parser);
}
- if (o->buffer) {
- php_http_buffer_free(&o->buffer);
- }
- zend_object_std_dtor((zend_object *) o TSRMLS_CC);
- efree(o);
+ php_http_buffer_dtor(&o->buffer);
+ zend_object_std_dtor(object);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageParser_getState, 0, 0, 0)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessageParser, getState)
{
- php_http_message_parser_object_t *parser_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_parser_object_t *parser_obj = PHP_HTTP_OBJ(NULL, getThis());
zend_parse_parameters_none();
/* always return the real state */
php_http_message_parser_object_t *parser_obj;
zval *zmsg;
char *data_str;
- int data_len;
- long flags;
+ size_t data_len;
+ zend_long flags;
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slz", &data_str, &data_len, &flags, &zmsg), invalid_arg, return);
- parser_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- php_http_buffer_append(parser_obj->buffer, data_str, data_len);
- RETVAL_LONG(php_http_message_parser_parse(parser_obj->parser, parser_obj->buffer, flags, &parser_obj->parser->message));
+ parser_obj = PHP_HTTP_OBJ(NULL, getThis());
+ php_http_buffer_append(&parser_obj->buffer, data_str, data_len);
+ RETVAL_LONG(php_http_message_parser_parse(parser_obj->parser, &parser_obj->buffer, flags, &parser_obj->parser->message));
+ ZVAL_DEREF(zmsg);
zval_dtor(zmsg);
+ ZVAL_NULL(zmsg);
if (parser_obj->parser->message) {
- ZVAL_OBJVAL(zmsg, php_http_message_object_new_ex(php_http_message_class_entry, php_http_message_copy(parser_obj->parser->message, NULL), NULL TSRMLS_CC), 0);
+ php_http_message_t *msg_cpy = php_http_message_copy(parser_obj->parser->message, NULL);
+ php_http_message_object_t *msg_obj = php_http_message_object_new_ex(php_http_message_class_entry, msg_cpy);
+ ZVAL_OBJ(zmsg, &msg_obj->zo);
}
}
zend_error_handling zeh;
zval *zmsg, *zstream;
php_stream *s;
- long flags;
+ zend_long flags;
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &zstream, &flags, &zmsg), invalid_arg, return);
- zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh TSRMLS_CC);
- php_stream_from_zval(s, &zstream);
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh);
+ php_stream_from_zval(s, zstream);
+ zend_restore_error_handling(&zeh);
- parser_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- RETVAL_LONG(php_http_message_parser_parse_stream(parser_obj->parser, parser_obj->buffer, s, flags, &parser_obj->parser->message));
+ parser_obj = PHP_HTTP_OBJ(NULL, getThis());
+ RETVAL_LONG(php_http_message_parser_parse_stream(parser_obj->parser, &parser_obj->buffer, s, flags, &parser_obj->parser->message));
+ ZVAL_DEREF(zmsg);
zval_dtor(zmsg);
+ ZVAL_NULL(zmsg);
if (parser_obj->parser->message) {
- ZVAL_OBJVAL(zmsg, php_http_message_object_new_ex(php_http_message_class_entry, php_http_message_copy(parser_obj->parser->message, NULL), NULL TSRMLS_CC), 0);
+ php_http_message_t *msg_cpy = php_http_message_copy(parser_obj->parser->message, NULL);
+ php_http_message_object_t *msg_obj = php_http_message_object_new_ex(php_http_message_class_entry, msg_cpy);
+ ZVAL_OBJ(zmsg, &msg_obj->zo);
}
}
zend_class_entry ce;
INIT_NS_CLASS_ENTRY(ce, "http\\Message", "Parser", php_http_message_parser_methods);
- php_http_message_parser_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+ php_http_message_parser_class_entry = zend_register_internal_class(&ce);
memcpy(&php_http_message_parser_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
php_http_message_parser_class_entry->create_object = php_http_message_parser_object_new;
php_http_message_parser_object_handlers.clone_obj = NULL;
-
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("CLEANUP"), PHP_HTTP_MESSAGE_PARSER_CLEANUP TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("DUMB_BODIES"), PHP_HTTP_MESSAGE_PARSER_DUMB_BODIES TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("EMPTY_REDIRECTS"), PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("GREEDY"), PHP_HTTP_MESSAGE_PARSER_GREEDY TSRMLS_CC);
-
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_FAILURE"), PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_START"), PHP_HTTP_MESSAGE_PARSER_STATE_START TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_HEADER"), PHP_HTTP_MESSAGE_PARSER_STATE_HEADER TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_HEADER_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_DUMB"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_LENGTH"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_CHUNKED"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_DONE TSRMLS_CC);
+ php_http_message_parser_object_handlers.free_obj = php_http_message_parser_object_free;
+ php_http_message_parser_object_handlers.offset = XtOffsetOf(php_http_message_parser_object_t, zo);
+
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("CLEANUP"), PHP_HTTP_MESSAGE_PARSER_CLEANUP);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("DUMB_BODIES"), PHP_HTTP_MESSAGE_PARSER_DUMB_BODIES);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("EMPTY_REDIRECTS"), PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("GREEDY"), PHP_HTTP_MESSAGE_PARSER_GREEDY);
+
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_FAILURE"), PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_START"), PHP_HTTP_MESSAGE_PARSER_STATE_START);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_HEADER"), PHP_HTTP_MESSAGE_PARSER_STATE_HEADER);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_HEADER_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_DUMB"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_LENGTH"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_CHUNKED"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE);
+ zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
return SUCCESS;
}
#include "php_http_api.h"
-zend_object_value php_http_object_new(zend_class_entry *ce TSRMLS_DC)
+static zend_object_handlers php_http_object_handlers;
+
+zend_object *php_http_object_new(zend_class_entry *ce)
{
- return php_http_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+ return &php_http_object_new_ex(ce, NULL)->zo;
}
-zend_object_value php_http_object_new_ex(zend_class_entry *ce, void *nothing, php_http_object_t **ptr TSRMLS_DC)
+php_http_object_t *php_http_object_new_ex(zend_class_entry *ce, void *intern)
{
php_http_object_t *o;
- o = ecalloc(1, sizeof(php_http_object_t) + (ce->default_properties_count - 1) * sizeof(zval));
- o = ecalloc(1, sizeof(php_http_object_t));
- zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
- object_properties_init((zend_object *) o, ce);
++ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+ zend_object_std_init(&o->zo, ce);
+ object_properties_init(&o->zo, ce);
- if (ptr) {
- *ptr = o;
- }
+ o->intern = intern;
+ o->zo.handlers = &php_http_object_handlers;
- o->zv.handle = zend_objects_store_put(o, NULL, (zend_objects_free_object_storage_t) zend_objects_free_object_storage, NULL TSRMLS_CC);
- o->zv.handlers = zend_get_std_object_handlers();
+ return o;
+}
- return o->zv;
+void php_http_object_free(zend_object *object)
+{
- php_http_object_t *obj = PHP_HTTP_OBJ(object, NULL);
+ zend_object_std_dtor(object);
}
-STATUS php_http_new(zend_object_value *ovp, zend_class_entry *ce, php_http_new_t create, zend_class_entry *parent_ce, void *intern_ptr, void **obj_ptr TSRMLS_DC)
+ZEND_RESULT_CODE php_http_new(void **obj_ptr, zend_class_entry *ce, php_http_new_t create, zend_class_entry *parent_ce, void *intern_ptr)
{
- zend_object_value ov;
+ void *obj;
if (!ce) {
ce = parent_ce;
- } else if (parent_ce && !instanceof_function(ce, parent_ce TSRMLS_CC)) {
- php_http_throw(unexpected_val, "Class %s does not extend %s", ce->name, parent_ce->name);
+ } else if (parent_ce && !instanceof_function(ce, parent_ce)) {
+ php_http_throw(unexpected_val, "Class %s does not extend %s", ce->name->val, parent_ce->name->val);
return FAILURE;
}
- ov = create(ce, intern_ptr, obj_ptr TSRMLS_CC);
- if (ovp) {
- *ovp = ov;
+ obj = create(ce, intern_ptr);
+ if (obj_ptr) {
+ *obj_ptr = obj;
}
return SUCCESS;
}
- ZEND_RESULT_CODE php_http_method_call(zval *object, const char *method_str, size_t method_len, int argc, zval argv[], zval *retval_ptr)
-php_http_object_method_t *php_http_object_method_init(php_http_object_method_t *cb, zval *zobject, const char *method_str, size_t method_len TSRMLS_DC)
++php_http_object_method_t *php_http_object_method_init(php_http_object_method_t *cb, zval *zobject, const char *method_str, size_t method_len)
+ {
- zval *zfn;
-
+ if (!cb) {
+ cb = ecalloc(1, sizeof(*cb));
+ } else {
+ memset(cb, 0, sizeof(*cb));
+ }
+
- MAKE_STD_ZVAL(zfn);
- ZVAL_STRINGL(zfn, method_str, method_len, 1);
-
+ cb->fci.size = sizeof(cb->fci);
- cb->fci.function_name = zfn;
++ ZVAL_STRINGL(&cb->fci.function_name, method_str, method_len);
+ cb->fcc.initialized = 1;
+ cb->fcc.calling_scope = cb->fcc.called_scope = Z_OBJCE_P(zobject);
- cb->fcc.function_handler = Z_OBJ_HT_P(zobject)->get_method(&zobject, Z_STRVAL_P(cb->fci.function_name), Z_STRLEN_P(cb->fci.function_name), NULL TSRMLS_CC);
++ cb->fcc.function_handler = Z_OBJ_HT_P(zobject)->get_method(&Z_OBJ_P(zobject), Z_STR(cb->fci.function_name), NULL);
+
+ return cb;
+ }
+
+ void php_http_object_method_dtor(php_http_object_method_t *cb)
+ {
- if (cb->fci.function_name) {
- zval_ptr_dtor(&cb->fci.function_name);
- cb->fci.function_name = NULL;
- }
++ zval_ptr_dtor(&cb->fci.function_name);
+ }
+
+ void php_http_object_method_free(php_http_object_method_t **cb)
+ {
+ if (*cb) {
+ php_http_object_method_dtor(*cb);
+ efree(*cb);
+ *cb = NULL;
+ }
+ }
+
-STATUS php_http_object_method_call(php_http_object_method_t *cb, zval *zobject, zval **retval_ptr, int argc, zval ***args TSRMLS_DC)
++ZEND_RESULT_CODE php_http_object_method_call(php_http_object_method_t *cb, zval *zobject, zval *retval_ptr, int argc, zval *args)
{
- zend_fcall_info fci;
- zval retval;
- STATUS rv;
- zval *retval = NULL;
+ ZEND_RESULT_CODE rv;
++ zval retval;
- fci.size = sizeof(fci);
- fci.object = Z_OBJ_P(object);
- fci.retval = retval_ptr ? retval_ptr : &retval;
- fci.param_count = argc;
- fci.params = argv;
- fci.no_separation = 1;
- fci.symbol_table = NULL;
- fci.function_table = NULL;
-
- ZVAL_STRINGL(&fci.function_name, method_str, method_len);
- rv = zend_call_function(&fci, NULL TSRMLS_CC);
- zval_ptr_dtor(&fci.function_name);
-
- if (!retval_ptr) {
+ ZVAL_UNDEF(&retval);
- cb->fci.object_ptr = zobject;
- cb->fcc.object_ptr = zobject;
+ Z_ADDREF_P(zobject);
- cb->fci.retval_ptr_ptr = retval_ptr ? retval_ptr : &retval;
++ cb->fci.object = Z_OBJ_P(zobject);
++ cb->fcc.object = Z_OBJ_P(zobject);
+
- cb->fcc.function_handler = Z_OBJ_HT_P(zobject)->get_method(&zobject, Z_STRVAL_P(cb->fci.function_name), Z_STRLEN_P(cb->fci.function_name), NULL TSRMLS_CC);
++ cb->fci.retval = retval_ptr ? retval_ptr : &retval;
+
+ cb->fci.param_count = argc;
+ cb->fci.params = args;
+
+ if (cb->fcc.called_scope != Z_OBJCE_P(zobject)) {
+ cb->fcc.called_scope = Z_OBJCE_P(zobject);
- rv = zend_call_function(&cb->fci, &cb->fcc TSRMLS_CC);
++ cb->fcc.function_handler = Z_OBJ_HT_P(zobject)->get_method(&Z_OBJ_P(zobject), Z_STR(cb->fci.function_name), NULL);
+ }
+
- zval_ptr_dtor(&zobject);
- if (!retval_ptr && retval) {
++ rv = zend_call_function(&cb->fci, &cb->fcc);
+
++ zval_ptr_dtor(zobject);
++ if (!retval_ptr && !Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
+
return rv;
}
+PHP_MINIT_FUNCTION(http_object)
+{
+ memcpy(&php_http_object_handlers, zend_get_std_object_handlers(), sizeof(php_http_object_handlers));
+ php_http_object_handlers.offset = XtOffsetOf(php_http_object_t, zo);
+
+ return SUCCESS;
+}
+
/*
* Local variables:
* tab-width: 4
#define PHP_HTTP_OBJECT_H
typedef struct php_http_object {
+ void *intern;
zend_object zo;
- zend_object_value zv;
} php_http_object_t;
-zend_object_value php_http_object_new(zend_class_entry *ce TSRMLS_DC);
-zend_object_value php_http_object_new_ex(zend_class_entry *ce, void *nothing, php_http_object_t **ptr TSRMLS_DC);
+zend_object *php_http_object_new(zend_class_entry *ce TSRMLS_DC);
+php_http_object_t *php_http_object_new_ex(zend_class_entry *ce, void *nothing);
-typedef zend_object_value (*php_http_new_t)(zend_class_entry *ce, void *, void ** TSRMLS_DC);
+typedef void *(*php_http_new_t)(zend_class_entry *ce, void *);
-STATUS php_http_new(zend_object_value *ov, zend_class_entry *ce, php_http_new_t create, zend_class_entry *parent_ce, void *intern_ptr, void **obj_ptr TSRMLS_DC);
+ZEND_RESULT_CODE php_http_new(void **obj_ptr, zend_class_entry *ce, php_http_new_t create, zend_class_entry *parent_ce, void *intern_ptr);
- ZEND_RESULT_CODE php_http_method_call(zval *object, const char *method_str, size_t method_len, int argc, zval argv[], zval *retval_ptr);
+
+PHP_MINIT_FUNCTION(http_object);
-php_http_object_method_t *php_http_object_method_init(php_http_object_method_t *cb, zval *zobject, const char *method_str, size_t method_len TSRMLS_DC);
-STATUS php_http_object_method_call(php_http_object_method_t *cb, zval *zobject, zval **retval, int argc, zval ***args TSRMLS_DC);
+ typedef struct php_http_method {
+ zend_fcall_info fci;
+ zend_fcall_info_cache fcc;
+ } php_http_object_method_t;
+
++php_http_object_method_t *php_http_object_method_init(php_http_object_method_t *cb, zval *zobject, const char *method_str, size_t method_len);
++ZEND_RESULT_CODE php_http_object_method_call(php_http_object_method_t *cb, zval *zobject, zval *retval, int argc, zval *args);
+ void php_http_object_method_dtor(php_http_object_method_t *cb);
+ void php_http_object_method_free(php_http_object_method_t **cb);
+
#endif
return estrndup("localhost", lenof("localhost"));
}
- #define url(buf) ((php_http_url_t *) buf.data)
+ #define url(buf) ((php_http_url_t *) (buf).data)
-static php_http_url_t *php_http_url_from_env(TSRMLS_D)
+static php_http_url_t *php_http_url_from_env(void)
{
zval *https, *zhost, *zport;
long port;
/* scheme */
url(buf)->scheme = &buf.data[buf.used];
- https = php_http_env_get_server_var(ZEND_STRL("HTTPS"), 1 TSRMLS_CC);
+ https = php_http_env_get_server_var(ZEND_STRL("HTTPS"), 1);
if (https && !strcasecmp(Z_STRVAL_P(https), "ON")) {
php_http_buffer_append(&buf, "https", sizeof("https"));
} else {
/* host */
url(buf)->host = &buf.data[buf.used];
- if ((((zhost = php_http_env_get_server_var(ZEND_STRL("HTTP_HOST"), 1 TSRMLS_CC)) ||
- (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_NAME"), 1 TSRMLS_CC)) ||
- (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_ADDR"), 1 TSRMLS_CC)))) && Z_STRLEN_P(zhost)) {
+ if ((((zhost = php_http_env_get_server_var(ZEND_STRL("HTTP_HOST"), 1)) ||
+ (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_NAME"), 1)) ||
+ (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_ADDR"), 1)))) && Z_STRLEN_P(zhost)) {
size_t stop_at = strspn(Z_STRVAL_P(zhost), "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-.");
php_http_buffer_append(&buf, Z_STRVAL_P(zhost), stop_at);
}
/* port */
- zport = php_http_env_get_server_var(ZEND_STRL("SERVER_PORT"), 1 TSRMLS_CC);
+ zport = php_http_env_get_server_var(ZEND_STRL("SERVER_PORT"), 1);
if (zport && IS_LONG == is_numeric_string(Z_STRVAL_P(zport), Z_STRLEN_P(zport), &port, NULL, 0)) {
url(buf)->port = port;
}
return url(buf);
}
-void php_http_url(int flags, const php_url *old_url, const php_url *new_url, php_url **url_ptr, char **url_str, size_t *url_len TSRMLS_DC)
-{
- php_http_url_t *url = php_http_url_mod((const php_http_url_t *) old_url, (const php_http_url_t *) new_url, flags TSRMLS_CC);
-
- if (url_ptr) {
- *url_ptr = php_http_url_to_php_url(url);
- }
- if (url_str) {
- php_http_url_to_string(url, url_str, url_len, 0);
- }
-
- php_http_url_free(&url);
-}
-
#define url_isset(u,n) \
((u)&&(u)->n)
+ #define url_append(buf, append) do { \
+ char *_ptr = (buf)->data; \
+ php_http_url_t *_url = (php_http_url_t *) _ptr, _mem = *_url; \
+ append; \
+ /* relocate */ \
+ if (_ptr != (buf)->data) { \
+ ptrdiff_t diff = (buf)->data - _ptr; \
+ _url = (php_http_url_t *) (buf)->data; \
+ if (_mem.scheme) _url->scheme += diff; \
+ if (_mem.user) _url->user += diff; \
+ if (_mem.pass) _url->pass += diff; \
+ if (_mem.host) _url->host += diff; \
+ if (_mem.path) _url->path += diff; \
+ if (_mem.query) _url->query += diff; \
+ if (_mem.fragment) _url->fragment += diff; \
+ } \
+ } while (0)
#define url_copy(n) do { \
if (url_isset(new_url, n)) { \
url(buf)->n = &buf.data[buf.used]; \
- php_http_buffer_append(&buf, new_url->n, strlen(new_url->n) + 1); \
+ url_append(&buf, php_http_buffer_append(&buf, new_url->n, strlen(new_url->n) + 1)); \
} else if (url_isset(old_url, n)) { \
url(buf)->n = &buf.data[buf.used]; \
- php_http_buffer_append(&buf, old_url->n, strlen(old_url->n) + 1); \
+ url_append(&buf, php_http_buffer_append(&buf, old_url->n, strlen(old_url->n) + 1)); \
} \
} while (0)
-php_http_url_t *php_http_url_mod(const php_http_url_t *old_url, const php_http_url_t *new_url, unsigned flags TSRMLS_DC)
+php_http_url_t *php_http_url_mod(const php_http_url_t *old_url, const php_http_url_t *new_url, unsigned flags)
{
php_http_url_t *tmp_url = NULL;
php_http_buffer_t buf;
/* set from env if requested */
if (flags & PHP_HTTP_URL_FROM_ENV) {
- php_http_url_t *env_url = php_http_url_from_env(TSRMLS_C);
+ php_http_url_t *env_url = php_http_url_from_env();
- old_url = tmp_url = php_http_url_mod(env_url, old_url, flags ^ PHP_HTTP_URL_FROM_ENV TSRMLS_CC);
+ old_url = tmp_url = php_http_url_mod(env_url, old_url, flags ^ PHP_HTTP_URL_FROM_ENV);
php_http_url_free(&env_url);
}
url(buf)->path = &buf.data[buf.used];
if (path[0] != '/') {
- php_http_buffer_append(&buf, "/", 1);
+ url_append(&buf, php_http_buffer_append(&buf, "/", 1));
}
- php_http_buffer_append(&buf, path, strlen(path) + 1);
+ url_append(&buf, php_http_buffer_append(&buf, path, strlen(path) + 1));
efree(path);
} else {
const char *path = NULL;
if (path) {
url(buf)->path = &buf.data[buf.used];
- php_http_buffer_append(&buf, path, strlen(path) + 1);
+ url_append(&buf, php_http_buffer_append(&buf, path, strlen(path) + 1));
}
if ((flags & PHP_HTTP_URL_JOIN_QUERY) && url_isset(new_url, query) && url_isset(old_url, query)) {
zval qarr, qstr;
- INIT_PZVAL(&qstr);
- INIT_PZVAL(&qarr);
array_init(&qarr);
- ZVAL_STRING(&qstr, old_url->query, 0);
- php_http_querystring_update(&qarr, &qstr, NULL TSRMLS_CC);
- ZVAL_STRING(&qstr, new_url->query, 0);
- php_http_querystring_update(&qarr, &qstr, NULL TSRMLS_CC);
+ ZVAL_STRING(&qstr, old_url->query);
+ php_http_querystring_update(&qarr, &qstr, NULL);
+ zval_ptr_dtor(&qstr);
+ ZVAL_STRING(&qstr, new_url->query);
+ php_http_querystring_update(&qarr, &qstr, NULL);
+ zval_ptr_dtor(&qstr);
ZVAL_NULL(&qstr);
- php_http_querystring_update(&qarr, NULL, &qstr TSRMLS_CC);
+ php_http_querystring_update(&qarr, NULL, &qstr);
url(buf)->query = &buf.data[buf.used];
- php_http_buffer_append(&buf, Z_STRVAL(qstr), Z_STRLEN(qstr) + 1);
+ url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL(qstr), Z_STRLEN(qstr) + 1));
zval_dtor(&qstr);
zval_dtor(&qarr);
}
/* unset default ports */
if (url(buf)->port) {
- if ( ((url(buf)->port == 80) && !strcmp(url(buf)->scheme, "http"))
- || ((url(buf)->port ==443) && !strcmp(url(buf)->scheme, "https"))
+ if ( ((url(buf)->port == 80) && url(buf)->scheme && !strcmp(url(buf)->scheme, "http"))
+ || ((url(buf)->port ==443) && url(buf)->scheme && !strcmp(url(buf)->scheme, "https"))
) {
url(buf)->port = 0;
}
return buf.data;
}
-php_http_url_t *php_http_url_from_zval(zval *value, unsigned flags TSRMLS_DC)
+ char *php_http_url_authority_to_string(const php_http_url_t *url, char **url_str, size_t *url_len)
+ {
+ php_http_buffer_t buf;
+
+ php_http_buffer_init(&buf);
+
+ if (url->user && *url->user) {
+ php_http_buffer_appendl(&buf, url->user);
+ if (url->pass && *url->pass) {
+ php_http_buffer_appends(&buf, ":");
+ php_http_buffer_appendl(&buf, url->pass);
+ }
+ php_http_buffer_appends(&buf, "@");
+ }
+
+ if (url->host && *url->host) {
+ php_http_buffer_appendl(&buf, url->host);
+ if (url->port) {
+ php_http_buffer_appendf(&buf, ":%hu", url->port);
+ }
+ }
+
+ php_http_buffer_shrink(&buf);
+ php_http_buffer_fix(&buf);
+
+ if (url_len) {
+ *url_len = buf.used;
+ }
+
+ if (url_str) {
+ *url_str = buf.data;
+ }
+
+ return buf.data;
+ }
+
+php_http_url_t *php_http_url_from_zval(zval *value, unsigned flags)
{
- zval *zcpy;
+ zend_string *zs;
php_http_url_t *purl;
switch (Z_TYPE_P(value)) {
break;
default:
- zcpy = php_http_ztyp(IS_STRING, value);
- purl = php_http_url_parse(Z_STRVAL_P(zcpy), Z_STRLEN_P(zcpy), flags TSRMLS_CC);
- zval_ptr_dtor(&zcpy);
+ zs = zval_get_string(value);
+ purl = php_http_url_parse(zs->val, zs->len, flags);
+ zend_string_release(zs);
}
return purl;
php_http_url_t *php_http_url_from_struct(HashTable *ht)
{
- zval **e;
+ zval *e;
php_http_buffer_t buf;
php_http_buffer_init_ex(&buf, MAX(PHP_HTTP_BUFFER_DEFAULT_SIZE, sizeof(php_http_url_t)<<2), PHP_HTTP_BUFFER_INIT_PREALLOC);
php_http_buffer_account(&buf, sizeof(php_http_url_t));
memset(buf.data, 0, buf.used);
- if (SUCCESS == zend_hash_find(ht, "scheme", sizeof("scheme"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("scheme")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->scheme = &buf.data[buf.used];
- php_http_buffer_append(&buf, zs->val, zs->len + 1);
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
++ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "user", sizeof("user"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("user")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->user = &buf.data[buf.used];
- php_http_buffer_append(&buf, zs->val, zs->len + 1);
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
++ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "pass", sizeof("pass"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("pass")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->pass = &buf.data[buf.used];
- php_http_buffer_append(&buf, zs->val, zs->len + 1);
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
++ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "host", sizeof("host"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("host")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->host = &buf.data[buf.used];
- php_http_buffer_append(&buf, zs->val, zs->len + 1);
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
++ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "port", sizeof("port"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_LONG, *e);
- url(buf)->port = (unsigned short) Z_LVAL_P(cpy);
- zval_ptr_dtor(&cpy);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("port")))) {
+ url(buf)->port = (unsigned short) zval_get_long(e);
}
- if (SUCCESS == zend_hash_find(ht, "path", sizeof("path"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("path")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->path = &buf.data[buf.used];
- php_http_buffer_append(&buf, zs->val, zs->len + 1);
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
++ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "query", sizeof("query"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("query")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->query = &buf.data[buf.used];
- php_http_buffer_append(&buf, zs->val, zs->len + 1);
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
++ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "fragment", sizeof("fragment"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("fragment")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->fragment = &buf.data[buf.used];
- php_http_buffer_append(&buf, zs->val, zs->len + 1);
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
++ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
return url(buf);
}
-HashTable *php_http_url_to_struct(const php_http_url_t *url, zval *strct TSRMLS_DC)
+HashTable *php_http_url_to_struct(const php_http_url_t *url, zval *strct)
{
- zval arr;
+ HashTable *ht;
+ zval tmp;
if (strct) {
switch (Z_TYPE_P(strct)) {
/* no break */
case IS_ARRAY:
case IS_OBJECT:
- INIT_PZVAL_ARRAY((&arr), HASH_OF(strct));
+ ht = HASH_OF(strct);
break;
}
} else {
- INIT_PZVAL(&arr);
- array_init(&arr);
+ ALLOC_HASHTABLE(ht);
+ zend_hash_init(ht, 8, NULL, ZVAL_PTR_DTOR, 0);
+ }
+
+#define url_struct_add(part) \
+ if (Z_TYPE_P(strct) == IS_ARRAY) { \
+ zend_hash_str_update(Z_ARRVAL_P(strct), part, lenof(part), &tmp); \
+ } else { \
+ zend_update_property(Z_OBJCE_P(strct), strct, part, lenof(part), &tmp); \
+ zval_ptr_dtor(&tmp); \
}
if (url) {
if (url->scheme) {
- add_assoc_string(&arr, "scheme", url->scheme, 1);
+ ZVAL_STRING(&tmp, url->scheme);
+ url_struct_add("scheme");
}
if (url->user) {
- add_assoc_string(&arr, "user", url->user, 1);
+ ZVAL_STRING(&tmp, url->user);
+ url_struct_add("user");
}
if (url->pass) {
- add_assoc_string(&arr, "pass", url->pass, 1);
+ ZVAL_STRING(&tmp, url->pass);
+ url_struct_add("pass");
}
if (url->host) {
- add_assoc_string(&arr, "host", url->host, 1);
+ ZVAL_STRING(&tmp, url->host);
+ url_struct_add("host");
}
if (url->port) {
- add_assoc_long(&arr, "port", (long) url->port);
+ ZVAL_LONG(&tmp, url->port);
+ url_struct_add("port");
}
if (url->path) {
- add_assoc_string(&arr, "path", url->path, 1);
+ ZVAL_STRING(&tmp, url->path);
+ url_struct_add("path");
}
if (url->query) {
- add_assoc_string(&arr, "query", url->query, 1);
+ ZVAL_STRING(&tmp, url->query);
+ url_struct_add("query");
}
if (url->fragment) {
- add_assoc_string(&arr, "fragment", url->fragment, 1);
+ ZVAL_STRING(&tmp, url->fragment);
+ url_struct_add("fragment");
}
}
- return Z_ARRVAL(arr);
+ return ht;
}
-STATUS php_http_url_encode_hash(HashTable *hash, const char *pre_encoded_str, size_t pre_encoded_len, char **encoded_str, size_t *encoded_len TSRMLS_DC)
+ZEND_RESULT_CODE php_http_url_encode_hash(HashTable *hash, const char *pre_encoded_str, size_t pre_encoded_len, char **encoded_str, size_t *encoded_len)
{
const char *arg_sep_str;
size_t arg_sep_len;
php_http_buffer_t *qstr = php_http_buffer_new();
- php_http_url_argsep(&arg_sep_str, &arg_sep_len TSRMLS_CC);
+ php_http_url_argsep(&arg_sep_str, &arg_sep_len);
- if (SUCCESS != php_http_url_encode_hash_ex(hash, qstr, arg_sep_str, arg_sep_len, "=", 1, pre_encoded_str, pre_encoded_len TSRMLS_CC)) {
+ if (SUCCESS != php_http_url_encode_hash_ex(hash, qstr, arg_sep_str, arg_sep_len, "=", 1, pre_encoded_str, pre_encoded_len)) {
php_http_buffer_free(&qstr);
return FAILURE;
}
return SUCCESS;
}
-STATUS php_http_url_encode_hash_ex(HashTable *hash, php_http_buffer_t *qstr, const char *arg_sep_str, size_t arg_sep_len, const char *val_sep_str, size_t val_sep_len, const char *pre_encoded_str, size_t pre_encoded_len TSRMLS_DC)
+ZEND_RESULT_CODE php_http_url_encode_hash_ex(HashTable *hash, php_http_buffer_t *qstr, const char *arg_sep_str, size_t arg_sep_len, const char *val_sep_str, size_t val_sep_len, const char *pre_encoded_str, size_t pre_encoded_len)
{
if (pre_encoded_len && pre_encoded_str) {
php_http_buffer_append(qstr, pre_encoded_str, pre_encoded_len);
}
- if (!php_http_params_to_string(qstr, hash, arg_sep_str, arg_sep_len, "", 0, val_sep_str, val_sep_len, PHP_HTTP_PARAMS_QUERY TSRMLS_CC)) {
+ if (!php_http_params_to_string(qstr, hash, arg_sep_str, arg_sep_len, "", 0, val_sep_str, val_sep_len, PHP_HTTP_PARAMS_QUERY)) {
return FAILURE;
}
struct parse_state {
php_http_url_t url;
-#ifdef ZTS
- void ***ts;
-#endif
const char *ptr;
const char *end;
size_t maxlen;
}
if (!silent) {
- TSRMLS_FETCH_FROM_CTX(state->ts);
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse %s; unexpected byte 0x%02x at pos %u in '%s'",
parse_what[what], (unsigned char) *ptr, (unsigned) (ptr - begin), begin);
}
return 0;
}
-static STATUS parse_userinfo(struct parse_state *state, const char *ptr)
+static ZEND_RESULT_CODE parse_userinfo(struct parse_state *state, const char *ptr)
{
size_t mb;
const char *password = NULL, *end = state->ptr, *tmp = ptr;
- TSRMLS_FETCH_FROM_CTX(state->ts);
state->url.user = &state->buffer[state->offset];
switch (*ptr) {
case ':':
if (password) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse password; duplicate ':' at pos %u in '%s'",
(unsigned) (ptr - tmp), tmp);
return FAILURE;
case '%':
if (ptr[1] != '%' && (end - ptr <= 2 || !isxdigit(*(ptr+1)) || !isxdigit(*(ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse userinfo; invalid percent encoding at pos %u in '%s'",
(unsigned) (ptr - tmp), tmp);
return FAILURE;
return SUCCESS;
}
-static STATUS parse_hostinfo(struct parse_state *state, const char *ptr)
+static ZEND_RESULT_CODE parse_hostinfo(struct parse_state *state, const char *ptr)
{
size_t mb, len;
const char *end = state->ptr, *tmp = ptr, *port = NULL;
- TSRMLS_FETCH_FROM_CTX(state->ts);
#ifdef HAVE_INET_PTON
}
if (error) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse hostinfo; %s", error);
+ php_error_docref(NULL, E_WARNING, "Failed to parse hostinfo; %s", error);
return FAILURE;
}
}
switch (*ptr) {
case ':':
if (port) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse port; unexpected ':' at pos %u in '%s'",
(unsigned) (ptr - tmp), tmp);
return FAILURE;
case '%':
if (ptr[1] != '%' && (end - ptr <= 2 || !isxdigit(*(ptr+1)) || !isxdigit(*(ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse hostinfo; invalid percent encoding at pos %u in '%s'",
(unsigned) (ptr - tmp), tmp);
return FAILURE;
case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
case 'v': case 'w': case 'x': case 'y': case 'z':
if (port) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse port; unexpected char '%c' at pos %u in '%s'",
(unsigned char) *ptr, (unsigned) (ptr - tmp), tmp);
return FAILURE;
break;
default:
- if (port) {
+ if (ptr == end) {
+ break;
+ } else if (port) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse port; unexpected byte 0x%02x at pos %u in '%s'",
(unsigned char) *ptr, (unsigned) (ptr - tmp), tmp);
return FAILURE;
}
# endif
if (rv != IDNA_SUCCESS) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN; %s", idna_strerror(rv));
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN; %s", idna_strerror(rv));
return FAILURE;
} else {
size_t idnlen = strlen(idn);
case '@':
/* userinfo delimiter */
if (host) {
- TSRMLS_FETCH_FROM_CTX(state->ts);
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse userinfo; unexpected '@'");
return NULL;
}
case '?':
case '#':
case '\0':
+ EOD:
/* host delimiter */
if (tmp != state->ptr && SUCCESS != parse_hostinfo(state, tmp)) {
return NULL;
}
} while (++state->ptr <= state->end);
- return NULL;
+ --state->ptr;
+ goto EOD;
}
static const char *parse_path(struct parse_state *state)
{
size_t mb;
const char *tmp;
- TSRMLS_FETCH_FROM_CTX(state->ts);
/* is there actually a path to parse? */
if (!*state->ptr) {
case '%':
if (state->ptr[1] != '%' && (state->end - state->ptr <= 2 || !isxdigit(*(state->ptr+1)) || !isxdigit(*(state->ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse path; invalid percent encoding at pos %u in '%s'",
(unsigned) (state->ptr - tmp), tmp);
return NULL;
{
size_t mb;
const char *tmp = state->ptr + !!*state->ptr;
- TSRMLS_FETCH_FROM_CTX(state->ts);
/* is there actually a query to parse? */
if (*state->ptr != '?') {
case '%':
if (state->ptr[1] != '%' && (state->end - state->ptr <= 2 || !isxdigit(*(state->ptr+1)) || !isxdigit(*(state->ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse query; invalid percent encoding at pos %u in '%s'",
(unsigned) (state->ptr - tmp), tmp);
return NULL;
{
size_t mb;
const char *tmp;
- TSRMLS_FETCH_FROM_CTX(state->ts);
/* is there actually a fragment to parse? */
if (*state->ptr != '#') {
switch (*state->ptr) {
case '%':
if (state->ptr[1] != '%' && (state->end - state->ptr <= 2 || !isxdigit(*(state->ptr+1)) || !isxdigit(*(state->ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse fragment; invalid percent encoding at pos %u in '%s'",
(unsigned) (state->ptr - tmp), tmp);
return NULL;
return state->ptr = tmp;
}
-php_http_url_t *php_http_url_parse(const char *str, size_t len, unsigned flags TSRMLS_DC)
+php_http_url_t *php_http_url_parse(const char *str, size_t len, unsigned flags)
{
size_t maxlen = 3 * len;
struct parse_state *state = ecalloc(1, sizeof(*state) + maxlen);
state->ptr = str;
state->flags = flags;
state->maxlen = maxlen;
- TSRMLS_SET_CTX(state->ts);
if (!parse_scheme(state)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse URL scheme: '%s'", state->ptr);
+ php_error_docref(NULL, E_WARNING, "Failed to parse URL scheme: '%s'", state->ptr);
efree(state);
return NULL;
}
}
if (!parse_query(state)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse URL query: '%s'", state->ptr);
+ php_error_docref(NULL, E_WARNING, "Failed to parse URL query: '%s'", state->ptr);
efree(state);
return NULL;
}
if (!parse_fragment(state)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse URL fragment: '%s'", state->ptr);
+ php_error_docref(NULL, E_WARNING, "Failed to parse URL fragment: '%s'", state->ptr);
efree(state);
return NULL;
}
return (php_http_url_t *) state;
}
+ php_http_url_t *php_http_url_parse_authority(const char *str, size_t len, unsigned flags TSRMLS_DC)
+ {
+ size_t maxlen = 3 * len;
+ struct parse_state *state = ecalloc(1, sizeof(*state) + maxlen);
+
+ state->end = str + len;
+ state->ptr = str;
+ state->flags = flags;
+ state->maxlen = maxlen;
+ TSRMLS_SET_CTX(state->ts);
+
+ if (!(state->ptr = parse_authority(state))) {
+ efree(state);
+ return NULL;
+ }
+
+ if (state->ptr != state->end) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ "Failed to parse URL authority, unexpected character at pos %u in '%s'",
+ (unsigned) (state->ptr - str), str);
+ efree(state);
+ return NULL;
+ }
+
+ return (php_http_url_t *) state;
+ }
+
ZEND_BEGIN_ARG_INFO_EX(ai_HttpUrl___construct, 0, 0, 0)
ZEND_ARG_INFO(0, old_url)
ZEND_ARG_INFO(0, new_url)
PHP_METHOD(HttpUrl, __construct)
{
zval *new_url = NULL, *old_url = NULL;
- long flags = PHP_HTTP_URL_FROM_ENV;
+ zend_long flags = PHP_HTTP_URL_FROM_ENV;
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!z!l", &old_url, &new_url, &flags), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|z!z!l", &old_url, &new_url, &flags), invalid_arg, return);
- zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh);
{
php_http_url_t *res_purl, *new_purl = NULL, *old_purl = NULL;
if (new_url) {
- new_purl = php_http_url_from_zval(new_url, flags TSRMLS_CC);
+ new_purl = php_http_url_from_zval(new_url, flags);
if (!new_purl) {
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
return;
}
}
if (old_url) {
- old_purl = php_http_url_from_zval(old_url, flags TSRMLS_CC);
+ old_purl = php_http_url_from_zval(old_url, flags);
if (!old_purl) {
if (new_purl) {
php_http_url_free(&new_purl);
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
return;
}
}
- res_purl = php_http_url_mod(old_purl, new_purl, flags TSRMLS_CC);
- php_http_url_to_struct(res_purl, getThis() TSRMLS_CC);
+ res_purl = php_http_url_mod(old_purl, new_purl, flags);
+ php_http_url_to_struct(res_purl, getThis());
php_http_url_free(&res_purl);
if (old_purl) {
php_http_url_free(&new_purl);
}
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpUrl_mod, 0, 0, 1)
PHP_METHOD(HttpUrl, mod)
{
zval *new_url = NULL;
- long flags = PHP_HTTP_URL_JOIN_PATH | PHP_HTTP_URL_JOIN_QUERY;
+ zend_long flags = PHP_HTTP_URL_JOIN_PATH | PHP_HTTP_URL_JOIN_QUERY;
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!|l", &new_url, &flags), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z!|l", &new_url, &flags), invalid_arg, return);
- zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh);
{
php_http_url_t *new_purl = NULL, *old_purl = NULL;
if (new_url) {
- new_purl = php_http_url_from_zval(new_url, flags TSRMLS_CC);
+ new_purl = php_http_url_from_zval(new_url, flags);
if (!new_purl) {
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
return;
}
}
if ((old_purl = php_http_url_from_struct(HASH_OF(getThis())))) {
php_http_url_t *res_purl;
- ZVAL_OBJVAL(return_value, zend_objects_clone_obj(getThis() TSRMLS_CC), 0);
+ ZVAL_OBJ(return_value, zend_objects_clone_obj(getThis()));
- res_purl = php_http_url_mod(old_purl, new_purl, flags TSRMLS_CC);
- php_http_url_to_struct(res_purl, return_value TSRMLS_CC);
+ res_purl = php_http_url_mod(old_purl, new_purl, flags);
+ php_http_url_to_struct(res_purl, return_value);
php_http_url_free(&res_purl);
php_http_url_free(&old_purl);
php_http_url_free(&new_purl);
}
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpUrl_toString, 0, 0, 0)
php_http_url_to_string(purl, &str, &len, 0);
php_http_url_free(&purl);
- RETURN_STRINGL(str, len, 0);
+ RETURN_STR(php_http_cs2zs(str, len));
}
}
RETURN_EMPTY_STRING();
/* strip any non-URL properties */
purl = php_http_url_from_struct(HASH_OF(getThis()));
- php_http_url_to_struct(purl, return_value TSRMLS_CC);
+ php_http_url_to_struct(purl, return_value);
php_http_url_free(&purl);
}
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http", "Url", php_http_url_methods);
- php_http_url_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
-
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("scheme"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("user"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("pass"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("host"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("port"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("path"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("query"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("fragment"), ZEND_ACC_PUBLIC TSRMLS_CC);
-
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("REPLACE"), PHP_HTTP_URL_REPLACE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_PATH"), PHP_HTTP_URL_JOIN_PATH TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_QUERY"), PHP_HTTP_URL_JOIN_QUERY TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_USER"), PHP_HTTP_URL_STRIP_USER TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PASS"), PHP_HTTP_URL_STRIP_PASS TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_AUTH"), PHP_HTTP_URL_STRIP_AUTH TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PORT"), PHP_HTTP_URL_STRIP_PORT TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PATH"), PHP_HTTP_URL_STRIP_PATH TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_QUERY"), PHP_HTTP_URL_STRIP_QUERY TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_FRAGMENT"), PHP_HTTP_URL_STRIP_FRAGMENT TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_ALL"), PHP_HTTP_URL_STRIP_ALL TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("FROM_ENV"), PHP_HTTP_URL_FROM_ENV TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("SANITIZE_PATH"), PHP_HTTP_URL_SANITIZE_PATH TSRMLS_CC);
+ php_http_url_class_entry = zend_register_internal_class(&ce);
+
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("scheme"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("user"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("pass"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("host"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("port"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("path"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("query"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("fragment"), ZEND_ACC_PUBLIC);
+
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("REPLACE"), PHP_HTTP_URL_REPLACE);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_PATH"), PHP_HTTP_URL_JOIN_PATH);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_QUERY"), PHP_HTTP_URL_JOIN_QUERY);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_USER"), PHP_HTTP_URL_STRIP_USER);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PASS"), PHP_HTTP_URL_STRIP_PASS);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_AUTH"), PHP_HTTP_URL_STRIP_AUTH);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PORT"), PHP_HTTP_URL_STRIP_PORT);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PATH"), PHP_HTTP_URL_STRIP_PATH);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_QUERY"), PHP_HTTP_URL_STRIP_QUERY);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_FRAGMENT"), PHP_HTTP_URL_STRIP_FRAGMENT);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_ALL"), PHP_HTTP_URL_STRIP_ALL);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("FROM_ENV"), PHP_HTTP_URL_FROM_ENV);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("SANITIZE_PATH"), PHP_HTTP_URL_SANITIZE_PATH);
#ifdef PHP_HTTP_HAVE_WCHAR
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_MBLOC"), PHP_HTTP_URL_PARSE_MBLOC TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_MBLOC"), PHP_HTTP_URL_PARSE_MBLOC);
#endif
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_MBUTF8"), PHP_HTTP_URL_PARSE_MBUTF8 TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_MBUTF8"), PHP_HTTP_URL_PARSE_MBUTF8);
#ifdef PHP_HTTP_HAVE_IDN
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_TOIDN"), PHP_HTTP_URL_PARSE_TOIDN TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_TOIDN"), PHP_HTTP_URL_PARSE_TOIDN);
#endif
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_TOPCT"), PHP_HTTP_URL_PARSE_TOPCT TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_TOPCT"), PHP_HTTP_URL_PARSE_TOPCT);
return SUCCESS;
}
#include <ext/standard/url.h>
+ /* php_http_url_mod() */
#define PHP_HTTP_URL_REPLACE 0x000
#define PHP_HTTP_URL_JOIN_PATH 0x001
#define PHP_HTTP_URL_JOIN_QUERY 0x002
char *fragment;
} php_http_url_t;
-PHP_HTTP_API php_http_url_t *php_http_url_parse(const char *str, size_t len, unsigned flags TSRMLS_DC);
-PHP_HTTP_API php_http_url_t *php_http_url_parse_authority(const char *str, size_t len, unsigned flags TSRMLS_DC);
-/* deprecated */
-PHP_HTTP_API void php_http_url(int flags, const php_url *old_url, const php_url *new_url, php_url **url_ptr, char **url_str, size_t *url_len TSRMLS_DC);
-/* use this instead */
-PHP_HTTP_API php_http_url_t *php_http_url_mod(const php_http_url_t *old_url, const php_http_url_t *new_url, unsigned flags TSRMLS_DC);
+PHP_HTTP_API php_http_url_t *php_http_url_parse(const char *str, size_t len, unsigned flags);
++PHP_HTTP_API php_http_url_t *php_http_url_parse_authority(const char *str, size_t len, unsigned flags);
+PHP_HTTP_API php_http_url_t *php_http_url_mod(const php_http_url_t *old_url, const php_http_url_t *new_url, unsigned flags);
PHP_HTTP_API php_http_url_t *php_http_url_copy(const php_http_url_t *url, zend_bool persistent);
PHP_HTTP_API php_http_url_t *php_http_url_from_struct(HashTable *ht);
-PHP_HTTP_API php_http_url_t *php_http_url_from_zval(zval *value, unsigned flags TSRMLS_DC);
-PHP_HTTP_API HashTable *php_http_url_to_struct(const php_http_url_t *url, zval *strct TSRMLS_DC);
+PHP_HTTP_API php_http_url_t *php_http_url_from_zval(zval *value, unsigned flags);
+PHP_HTTP_API HashTable *php_http_url_to_struct(const php_http_url_t *url, zval *strct);
PHP_HTTP_API char *php_http_url_to_string(const php_http_url_t *url, char **url_str, size_t *url_len, zend_bool persistent);
+ PHP_HTTP_API char *php_http_url_authority_to_string(const php_http_url_t *url, char **url_str, size_t *url_len);
PHP_HTTP_API void php_http_url_free(php_http_url_t **url);
-
-PHP_HTTP_API STATUS php_http_url_encode_hash(HashTable *hash, const char *pre_encoded_str, size_t pre_encoded_len, char **encoded_str, size_t *encoded_len TSRMLS_DC);
-PHP_HTTP_API STATUS php_http_url_encode_hash_ex(HashTable *hash, php_http_buffer_t *qstr, const char *arg_sep_str, size_t arg_sep_len, const char *val_sep_str, size_t val_sep_len, const char *pre_encoded_str, size_t pre_encoded_len TSRMLS_DC);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_url_encode_hash(HashTable *hash, const char *pre_encoded_str, size_t pre_encoded_len, char **encoded_str, size_t *encoded_len);
+PHP_HTTP_API ZEND_RESULT_CODE php_http_url_encode_hash_ex(HashTable *hash, php_http_buffer_t *qstr, const char *arg_sep_str, size_t arg_sep_len, const char *val_sep_str, size_t val_sep_len, const char *pre_encoded_str, size_t pre_encoded_len);
-static inline void php_http_url_argsep(const char **str, size_t *len TSRMLS_DC)
+static inline void php_http_url_argsep(const char **str, size_t *len)
{
- if (SUCCESS != php_http_ini_entry(ZEND_STRL("arg_separator.output"), str, len, 0 TSRMLS_CC) || !*len) {
+ if (SUCCESS != php_http_ini_entry(ZEND_STRL("arg_separator.output"), str, len, 0) || !*len) {
*str = PHP_HTTP_URL_ARGSEP;
*len = lenof(PHP_HTTP_URL_ARGSEP);
}
#include "php_http_api.h"
-php_http_version_t *php_http_version_init(php_http_version_t *v, unsigned major, unsigned minor TSRMLS_DC)
+php_http_version_t *php_http_version_init(php_http_version_t *v, unsigned major, unsigned minor)
{
if (!v) {
v = emalloc(sizeof(*v));
return v;
}
-php_http_version_t *php_http_version_parse(php_http_version_t *v, const char *str TSRMLS_DC)
+php_http_version_t *php_http_version_parse(php_http_version_t *v, const char *str)
{
long major, minor;
- char separator = 0, *stop = NULL;
+ char separator = 0;
register const char *ptr = str;
switch (*ptr) {
++ptr;
/* no break */
default:
- major = strtol(ptr, &stop, 10);
- if (stop && stop != ptr && major != LONG_MIN && major != LONG_MAX) {
- separator = *stop;
+ /* rfc7230#2.6 The HTTP version number consists of two decimal digits separated by a "." (period or decimal point) */
+ major = *ptr++ - '0';
+ if (major >= 0 && major <= 9) {
+ separator = *ptr++;
if (separator) {
if (separator != '.' && separator != ',') {
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Non-standard version separator '%c' in HTTP protocol version '%s'", separator, ptr);
+ php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Non-standard version separator '%c' in HTTP protocol version '%s'", separator, ptr - 2);
}
- ptr = stop + 1;
- minor = strtol(ptr, &stop, 10);
- if (minor != LONG_MIN && minor != LONG_MAX) {
+ minor = *ptr - '0';
+ if (minor >= 0 && minor <= 9) {
return php_http_version_init(v, major, minor TSRMLS_CC);
}
}
return NULL;
}
-void php_http_version_to_string(php_http_version_t *v, char **str, size_t *len, const char *pre, const char *post TSRMLS_DC)
+void php_http_version_to_string(php_http_version_t *v, char **str, size_t *len, const char *pre, const char *post)
{
*len = spprintf(str, 0, "%s%u.%u%s", pre ? pre : "", v->major, v->minor, post ? post : "");
}
projects / m6w6 / ext-http / commitdiff
