Merge branch 'v2.6.x'
authorMichael Wallner <mike@php.net>
Mon, 12 Sep 2016 06:30:57 +0000 (08:30 +0200)
committerMichael Wallner <mike@php.net>
Mon, 12 Sep 2016 06:30:57 +0000 (08:30 +0200)
91 files changed:
.gitignore
.travis.yml
README.md
config.w32
config9.m4
package.xml
php_http.h
scripts/gen_curlinfo.php
scripts/gen_travis_yml.php
src/php_http.c
src/php_http_api.h
src/php_http_buffer.c
src/php_http_buffer.h
src/php_http_client.c
src/php_http_client.h
src/php_http_client_curl.c
src/php_http_client_curl.h
src/php_http_client_curl_event.c
src/php_http_client_curl_event.h
src/php_http_client_curl_user.c
src/php_http_client_curl_user.h
src/php_http_client_request.c
src/php_http_client_request.h
src/php_http_client_response.c
src/php_http_client_response.h
src/php_http_cookie.c
src/php_http_cookie.h
src/php_http_encoding.c
src/php_http_encoding.h
src/php_http_env.c
src/php_http_env.h
src/php_http_env_request.c
src/php_http_env_request.h
src/php_http_env_response.c
src/php_http_env_response.h
src/php_http_etag.c
src/php_http_etag.h
src/php_http_exception.c
src/php_http_exception.h
src/php_http_filter.c
src/php_http_header.c
src/php_http_header.h
src/php_http_header_parser.c
src/php_http_header_parser.h
src/php_http_info.c
src/php_http_info.h
src/php_http_message.c
src/php_http_message.h
src/php_http_message_body.c
src/php_http_message_body.h
src/php_http_message_parser.c
src/php_http_message_parser.h
src/php_http_misc.c
src/php_http_misc.h
src/php_http_negotiate.c
src/php_http_negotiate.h
src/php_http_object.c
src/php_http_object.h
src/php_http_options.c
src/php_http_options.h
src/php_http_params.c
src/php_http_params.h
src/php_http_querystring.c
src/php_http_querystring.h
src/php_http_url.c
src/php_http_url.h
src/php_http_version.c
src/php_http_version.h
tests/bug69313.phpt
tests/client008.phpt
tests/client025.phpt
tests/client026.phpt
tests/client028.phpt
tests/client029.phpt
tests/etag001.phpt
tests/gh-issue11.phpt [new file with mode: 0644]
tests/gh-issue47.phpt
tests/gh-issue50.phpt
tests/gh-issue7.phpt [deleted file]
tests/helper/proxy.inc
tests/helper/server.inc
tests/info001.phpt
tests/info002.phpt
tests/messagebody003.phpt
tests/messageparser002.phpt
tests/negotiate001.phpt
tests/phpinfo.phpt
tests/propertyproxy001.phpt
tests/querystring003.phpt
tests/url001.phpt
travis/pecl

index 45ac1a5..348538c 100644 (file)
@@ -40,7 +40,42 @@ tests/*.sh
 lcov_data
 *~
 *.phar
+!travis/*.phar
 vendor/
+<<<<<<< HEAD
+/php_http_api.h
+/php_http_buffer.h
+/php_http_client.h
+/php_http_client_curl.h
+/php_http_client_request.h
+/php_http_client_response.h
+/php_http_cookie.h
+/php_http_curl.h
+/php_http_encoding.h
+/php_http_env.h
+/php_http_env_request.h
+/php_http_env_response.h
+/php_http_etag.h
+/php_http_exception.h
+/php_http_filter.h
+/php_http_header.h
+/php_http_header_parser.h
+/php_http_info.h
+/php_http_message.h
+/php_http_message_body.h
+/php_http_message_parser.h
+/php_http_misc.h
+/php_http_negotiate.h
+/php_http_object.h
+/php_http_options.h
+/php_http_params.h
+/php_http_querystring.h
+/php_http_response_codes.h
+/php_http_url.h
+/php_http_utf8.h
+/php_http_version.h
+/tests/helper/server.log
+=======
 tests/helper/server.log
 php_http_api.h
 php_http_buffer.h
@@ -75,3 +110,4 @@ php_http_response_codes.h
 php_http_url.h
 php_http_utf8.h
 php_http_version.h
+>>>>>>> v2.6.x
index ab22f34..6b0ae60 100644 (file)
@@ -12,43 +12,27 @@ addons:
    - libevent-dev
 
 env:
- - PHP=5.3 enable_debug=no enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.4 enable_debug=no enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.5 enable_debug=no enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.6 enable_debug=no enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.3 enable_debug=yes enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.4 enable_debug=yes enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.5 enable_debug=yes enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.6 enable_debug=yes enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.3 enable_debug=no enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.4 enable_debug=no enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.5 enable_debug=no enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.6 enable_debug=no enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.3 enable_debug=yes enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.4 enable_debug=yes enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.5 enable_debug=yes enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.6 enable_debug=yes enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes
- - PHP=5.3 enable_debug=no enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.4 enable_debug=no enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.5 enable_debug=no enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.6 enable_debug=no enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.3 enable_debug=yes enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.4 enable_debug=yes enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.5 enable_debug=yes enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.6 enable_debug=yes enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.3 enable_debug=no enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.4 enable_debug=no enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.5 enable_debug=no enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.6 enable_debug=no enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.3 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.4 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.5 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
- - PHP=5.6 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes
+ - PHP=7.0 enable_debug=no enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=master enable_debug=no enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=7.0 enable_debug=yes enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=master enable_debug=yes enable_maintainer_zts=no enable_json=no enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=7.0 enable_debug=no enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=master enable_debug=no enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=7.0 enable_debug=yes enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=master enable_debug=yes enable_maintainer_zts=yes enable_json=no enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=7.0 enable_debug=no enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=master enable_debug=no enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=7.0 enable_debug=yes enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=master enable_debug=yes enable_maintainer_zts=no enable_json=yes enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=7.0 enable_debug=no enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=master enable_debug=no enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=7.0 enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
+ - PHP=master enable_debug=yes enable_maintainer_zts=yes enable_json=yes enable_hash=yes enable_iconv=yes enable_phar=yes enable_posix=yes
 
 before_script:
  - make -f travis/pecl/Makefile php
- - make -f travis/pecl/Makefile pecl PECL=raphf:raphf:1.1.1
- - make -f travis/pecl/Makefile pecl PECL=propro:propro:1.0.2
+ - make -f travis/pecl/Makefile pecl PECL=raphf:raphf:2.0.0
+ - make -f travis/pecl/Makefile pecl PECL=propro:propro:2.0.1
  - make -f travis/pecl/Makefile ext PECL=http
 
 script:
index e0bc0ca..96a7b31 100644 (file)
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # ext-http
 
-[![Build Status](https://travis-ci.org/m6w6/ext-http.svg?branch=v2.5.x)](https://travis-ci.org/m6w6/ext-http)
+[![Build Status](https://travis-ci.org/m6w6/ext-http.svg?branch=master)](https://travis-ci.org/m6w6/ext-http)
 [![Join the chat at https://gitter.im/m6w6/ext-http](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/m6w6/ext-http)
 
 Extended HTTP support. Again.
index fb5c7f7..7b63664 100644 (file)
@@ -45,20 +45,15 @@ function check_for_pecl_ext(ext, header)
 
 if (PHP_HTTP != "no") {
 
-       var PHP_HTTP_HEADERS=glob(configure_module_dirname + "/src/*.h");
-       for (var i=0; i<PHP_HTTP_HEADERS.length; ++i) {
-               var basename = FSO.GetFileName(PHP_HTTP_HEADERS[i]);
-               copy_and_subst("src/" + basename, basename, []);
-       }
        var PHP_HTTP_SRC_ARRAY = glob(configure_module_dirname + "/src/*.c");
        var PHP_HTTP_SOURCES="";
        for (var i=0; i<PHP_HTTP_SRC_ARRAY.length; ++i) {
                var basename = FSO.GetFileName(PHP_HTTP_SRC_ARRAY[i]);
-               copy_and_subst("src/" + basename, basename, []);
                PHP_HTTP_SOURCES = PHP_HTTP_SOURCES + " " + basename;
        }
-       EXTENSION("http", PHP_HTTP_SOURCES);
-
+       //EXTENSION("http");
+       ADD_SOURCES(configure_module_dirname + "/src", PHP_HTTP_SOURCES, "http");
+       EXTENSION("http", "src/php_http.c");
        AC_DEFINE("HAVE_HTTP", 1, "Have extended HTTP support");
        AC_DEFINE("HTTP_SHARED_DEPS", 1, "Depend on shared extensions");
 
@@ -119,6 +114,8 @@ if (PHP_HTTP != "no") {
                AC_DEFINE("PHP_HAVE_CURL_MULTI_SETOPT", 1, "");
                AC_DEFINE("PHP_HAVE_CURL_MULTI_TIMEOUT", 1, "");
                AC_DEFINE("PHP_HTTP_HAVE_CLIENT", 1, "Have HTTP client support");
+               ADD_FLAG("CFLAGS_HTTP", "/I" + configure_module_dirname + " ");
+
                if (CHECK_HEADER_ADD_INCLUDE("event2/event.h", "CFLAGS_HTTP") &&
                        CHECK_LIB("libevent.lib", "http", PHP_HTTP) &&
                        CHECK_LIB("libevent_core.lib", "http", PHP_HTTP) &&
index 6917fca..3c02edc 100644 (file)
@@ -627,4 +627,7 @@ dnl ----
        PHP_ADD_MAKEFILE_FRAGMENT
 
        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
index 7191f31..fe4e1b0 100644 (file)
@@ -33,8 +33,8 @@ https://mdref.m6w6.name/http
  </lead>
  <date>2016-09-12</date>
  <version>
-  <release>2.6.0RC1</release>
-  <api>2.6.0</api>
+  <release>3.1.0RC1</release>
+  <api>3.1.0</api>
  </version>
  <stability>
   <release>beta</release>
@@ -64,10 +64,9 @@ https://mdref.m6w6.name/http
 * Fix gh-issue #36: Unexpected cookies sent if persistent_handle_id is used (Mike, @rcanavan, @afflerbach)
 * Fix gh-issue #34: allow setting multiple headers with the same name (Mike, @rcanavan)
 * Fix gh-issue #33: allow setting prodyhost request option to NULL (Mike, @rcanavan)
-* Fix gh-issue #31: add/improve configure checks for default CA bundle/path (Mike, @rcanavan) 
+* Fix gh-issue #31: add/improve configure checks for default CA bundle/path (Mike, @rcanavan)
 
 Changes from beta1:
-* Fixed PHP-5.3 compatibility
 * Fixed recursive calls to the event loop dispatcher
 
 Changes from beta2:
@@ -282,7 +281,6 @@ Changes from beta2:
      <file role="test" name="filterchunked.phpt"/>
      <file role="test" name="filterzlib.phpt"/>
      <file role="test" name="gh-issue6.phpt"/>
-     <file role="test" name="gh-issue7.phpt"/>
      <file role="test" name="gh-issue12.phpt"/>
      <file role="test" name="gh-issue42.phpt"/>
      <file role="test" name="gh-issue47.phpt"/>
@@ -385,9 +383,7 @@ Changes from beta2:
  <dependencies>
   <required>
    <php>
-    <min>5.3.0</min>
-    <max>7.0.0</max>
-    <exclude>7.0.0</exclude>
+    <min>7.0.0</min>
    </php>
    <pearinstaller>
     <min>1.4.1</min>
@@ -395,17 +391,13 @@ Changes from beta2:
    <package>
     <name>raphf</name>
     <channel>pecl.php.net</channel>
-    <min>1.1.0</min>
-    <max>2.0.0dev</max>
-    <exclude>2.0.0dev</exclude>
+    <min>2.0.0dev</min>
     <providesextension>raphf</providesextension>
    </package>
    <package>
     <name>propro</name>
     <channel>pecl.php.net</channel>
-    <min>1.0.0</min>
-    <max>2.0.0dev</max>
-    <exclude>2.0.0dev</exclude>
+    <min>2.0.0dev</min>
     <providesextension>propro</providesextension>
    </package>
   </required>
index eb022ef..2151023 100644 (file)
@@ -13,7 +13,7 @@
 #ifndef PHP_EXT_HTTP_H
 #define PHP_EXT_HTTP_H
 
-#define PHP_PECL_HTTP_VERSION "2.6.0beta2"
+#define PHP_PECL_HTTP_VERSION "3.1.0beta2"
 
 extern zend_module_entry http_module_entry;
 #define phpext_http_ptr &http_module_entry
index 076a10d..2e2100f 100755 (executable)
@@ -1,6 +1,5 @@
 #!/usr/bin/env php
 <?php
-// $Id: gen_curlinfo.php 323304 2012-02-17 21:13:24Z mike $
 
 error_reporting(0);
 
@@ -53,29 +52,31 @@ $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);
        }
 ',
index 0bbda36..311a4cd 100755 (executable)
@@ -17,12 +17,12 @@ env:
 
 $gen = include "./travis/pecl/gen-matrix.php";
 $env = $gen([
-       "PHP" => ["5.3", "5.4", "5.5", "5.6"],
+       "PHP" => ["7.0", "master"],
        "enable_debug",
        "enable_maintainer_zts",
        "enable_json",
        "enable_hash" => ["yes"],
-       "enable_iconv" => ["yes"]
+       "enable_iconv" => ["yes"],
 ]);
 foreach ($env as $e) {
        printf(" - %s\n", $e);
@@ -32,8 +32,8 @@ foreach ($env as $e) {
 
 before_script:
  - make -f travis/pecl/Makefile php
- - make -f travis/pecl/Makefile pecl PECL=raphf:raphf:1.1.1
- - make -f travis/pecl/Makefile pecl PECL=propro:propro:1.0.2
+ - make -f travis/pecl/Makefile pecl PECL=raphf:raphf:2.0.0
+ - make -f travis/pecl/Makefile pecl PECL=propro:propro:2.0.1
  - make -f travis/pecl/Makefile ext PECL=http
 
 script:
index cdd0287..c376388 100644 (file)
@@ -106,23 +106,15 @@ static void php_http_globals_init_once(zend_php_http_globals *G)
 }
 
 #if 0
-static inline void php_http_globals_init(zend_php_http_globals *G TSRMLS_DC)
+static inline void php_http_globals_init(zend_php_http_globals *G)
 {
 }
 
-static inline void php_http_globals_free(zend_php_http_globals *G TSRMLS_DC)
+static inline void php_http_globals_free(zend_php_http_globals *G)
 {
 }
 #endif
 
-#if ZTS && PHP_DEBUG && !HAVE_GCOV
-zend_php_http_globals *php_http_globals(void)
-{
-       TSRMLS_FETCH();
-       return PHP_HTTP_G;
-}
-#endif
-
 PHP_INI_BEGIN()
        STD_PHP_INI_ENTRY("http.etag.mode", "crc32b", PHP_INI_ALL, OnUpdateString, env.etag_mode, zend_php_http_globals, php_http_globals)
 PHP_INI_END()
@@ -134,6 +126,7 @@ PHP_MINIT_FUNCTION(http)
        REGISTER_INI_ENTRIES();
        
        if (0
+       || SUCCESS != PHP_MINIT_CALL(http_object)
        || SUCCESS != PHP_MINIT_CALL(http_exception)
        || SUCCESS != PHP_MINIT_CALL(http_cookie)
        || SUCCESS != PHP_MINIT_CALL(http_encoding)
index 8c0b9be..7fe3d10 100644 (file)
@@ -23,8 +23,8 @@
 #include "php.h"
 #include "SAPI.h"
 
-#include "ext/raphf/php_raphf.h"
-#include "ext/propro/php_propro.h"
+#include "ext/raphf/php_raphf_api.h"
+#include "ext/propro/php_propro_api.h"
 #include "ext/standard/php_string.h"
 #include "ext/spl/spl_iterators.h"
 #include "ext/date/php_date.h"
 
 ZEND_BEGIN_MODULE_GLOBALS(php_http)
        struct php_http_env_globals env;
+#ifdef PHP_HTTP_HAVE_CLIENT
+       struct {
+#ifdef PHP_HTTP_HAVE_CURL
+               struct php_http_client_curl_globals curl;
+#endif
+       } client;
+#endif
 ZEND_END_MODULE_GLOBALS(php_http)
 
 ZEND_EXTERN_MODULE_GLOBALS(php_http);
 
 #ifdef ZTS
 #      include "TSRM/TSRM.h"
-#      define PHP_HTTP_G ((zend_php_http_globals *) (*((void ***) tsrm_ls))[TSRM_UNSHUFFLE_RSRC_ID(php_http_globals_id)])
+#      define PHP_HTTP_G ((zend_php_http_globals *) (*((void ***) tsrm_get_ls_cache()))[TSRM_UNSHUFFLE_RSRC_ID(php_http_globals_id)])
 #      undef TSRMLS_FETCH_FROM_CTX
-#      define TSRMLS_FETCH_FROM_CTX(ctx) void ***tsrm_ls = ((ctx)?(ctx):ts_resource_ex(0, NULL))
+#      define TSRMLS_FETCH_FROM_CTX(ctx) ERROR
 #else
 #      define PHP_HTTP_G (&php_http_globals)
 #endif
index eaebfa0..b214f1d 100644 (file)
@@ -13,7 +13,8 @@
 #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);
@@ -22,7 +23,8 @@ PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_init_ex(php_http_buffer_t
        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;
        }
@@ -30,10 +32,11 @@ PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_init_ex(php_http_buffer_t
        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;
                }
@@ -41,7 +44,9 @@ PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_from_string_ex(php_http_b
        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
@@ -55,7 +60,8 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_resize_ex(php_http_buffer_t *buf, siz
                }
                
                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);
                }
@@ -72,7 +78,8 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_resize_ex(php_http_buffer_t *buf, siz
        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)
 {
        assert(to_account <= buf->free);
 
@@ -98,9 +105,12 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_shrink(php_http_buffer_t *buf)
        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);
@@ -109,7 +119,8 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_append(php_http_buffer_t *buf, const
        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;
@@ -128,7 +139,8 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_appendf(php_http_buffer_t *buf, const
        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);
@@ -141,7 +153,8 @@ PHP_HTTP_BUFFER_API char *php_http_buffer_data(const php_http_buffer_t *buf, cha
        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;
@@ -149,15 +162,19 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_cut(php_http_buffer_t *buf, size_t of
        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';
@@ -189,14 +206,16 @@ PHP_HTTP_BUFFER_API void php_http_buffer_free(php_http_buffer_t **buf)
        }
 }
 
-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;
        
@@ -219,13 +238,15 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_chunk_buffer(php_http_buffer_t **s, c
        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;
                }
@@ -243,15 +264,19 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_chunked_output(php_http_buffer_t **s,
        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;
@@ -265,18 +290,20 @@ PHP_HTTP_BUFFER_API ssize_t php_http_buffer_passthru(php_http_buffer_t **s, size
        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;
@@ -290,7 +317,8 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_chunked_input(php_http_buffer_t **s,
 
 #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;
@@ -301,7 +329,8 @@ PHP_HTTP_BUFFER_API int php_http_buffer_cmp(php_http_buffer_t *left, php_http_bu
        }
 }
 
-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;
 
@@ -317,7 +346,8 @@ PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_copy(const php_http_buffe
        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;
@@ -329,7 +359,8 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_insert(php_http_buffer_t *buf, const
        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;
@@ -348,7 +379,8 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_insertf(php_http_buffer_t *buf, size_
        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;
@@ -360,7 +392,8 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_prepend(php_http_buffer_t *buf, const
        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;
@@ -379,13 +412,20 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_prependf(php_http_buffer_t *buf, cons
        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);
@@ -397,7 +437,8 @@ PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_sub(const php_http_buffer
        }
 }
 
-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);
@@ -407,7 +448,8 @@ PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_right(const php_http_buff
 }
 
 
-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);
@@ -424,7 +466,8 @@ PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_merge_va(php_http_buffer_
        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;
index faf8992..818c443 100644 (file)
                PTR = SET; \
        }
 #endif
-#ifndef TSRMLS_D
-#      define TSRMLS_D
-#      define TSRMLS_DC
-#      define TSRMLS_CC
-#      define TSRMLS_C
-#endif
 #ifdef PHP_ATTRIBUTE_FORMAT
 #      define PHP_HTTP_BUFFER_ATTRIBUTE_FORMAT(f, a, b) PHP_ATTRIBUTE_FORMAT(f, a, b)
 #else
@@ -84,7 +78,7 @@ static inline void *estrndup(void *p, size_t s)
        case PHP_HTTP_BUFFER_FREE_NOT: \
                break; \
        case PHP_HTTP_BUFFER_FREE_PTR: \
-               pefree(STR, STR->pmem); break; \
+               pefree(STR, STR->pmem); \
                break; \
        case PHP_HTTP_BUFFER_FREE_VAL: \
                php_http_buffer_dtor(STR); \
@@ -142,7 +136,7 @@ typedef enum php_http_buffer_free {
 #define php_http_buffer_new() php_http_buffer_init(NULL)
 #define php_http_buffer_init(b) php_http_buffer_init_ex(b, PHP_HTTP_BUFFER_DEFAULT_SIZE, 0)
 #define php_http_buffer_clone(from, to) php_http_buffer_init_ex((to), (from)->size, (from)->pmem ? PHP_HTTP_BUFFER_INIT_PERSISTENT:0)
-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);
 
 /* create a php_http_buffer_t from a zval or c-string */
 #define php_http_buffer_from_zval(z) php_http_buffer_from_string(Z_STRVAL(z), Z_STRLEN(z))
@@ -152,7 +146,7 @@ PHP_HTTP_BUFFER_API php_http_buffer_t *php_http_buffer_from_string_ex(php_http_b
 
 /* usually only called from within the internal functions */
 #define php_http_buffer_resize(b, s) php_http_buffer_resize_ex((b), (s), 0, 0)
-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);
 
 PHP_HTTP_BUFFER_API char *php_http_buffer_account(php_http_buffer_t *buf, size_t to_account);
 
@@ -162,6 +156,7 @@ PHP_HTTP_BUFFER_API size_t php_http_buffer_shrink(php_http_buffer_t *buf);
 /* append data to the php_http_buffer_t */
 #define php_http_buffer_appends(b, a) php_http_buffer_append((b), (a), sizeof(a)-1)
 #define php_http_buffer_appendl(b, a) php_http_buffer_append((b), (a), strlen(a))
+#define php_http_buffer_appendz(b, z) php_http_buffer_append((b), (z)->val, (z)->len)
 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_appendf(php_http_buffer_t *buf, const char *format, ...) PHP_HTTP_BUFFER_ATTRIBUTE_FORMAT(printf, 2, 3);
 
@@ -186,15 +181,15 @@ PHP_HTTP_BUFFER_API void php_http_buffer_free(php_http_buffer_t **buf);
 /* stores data in a php_http_buffer_t until it reaches 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);
 
-typedef size_t (*php_http_buffer_pass_func_t)(void *opaque, char *, size_t TSRMLS_DC);
+typedef size_t (*php_http_buffer_pass_func_t)(void *opaque, char *, size_t);
 
-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);
 
 /* wrapper around php_http_buffer_chunk_buffer, which passes available chunks to passthru() */
-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_size, 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_size, php_http_buffer_pass_func_t passout, void *opaque);
 
 /* write chunks directly into php_http_buffer_t buffer */
-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);
 
 
 #      ifdef PHP_HTTP_BUFFER_EXTENDED
index 453e43c..4118ab1 100644 (file)
  */
 static HashTable php_http_client_drivers;
 
+static void php_http_client_driver_hash_dtor(zval *pData)
+{
+       pefree(Z_PTR_P(pData), 1);
+}
+
 ZEND_RESULT_CODE php_http_client_driver_add(php_http_client_driver_t *driver)
 {
-       return zend_hash_add(&php_http_client_drivers, driver->name_str, driver->name_len + 1, (void *) driver, sizeof(php_http_client_driver_t), NULL);
+       return zend_hash_add_mem(&php_http_client_drivers, driver->driver_name, (void *) driver, sizeof(php_http_client_driver_t))
+                       ? SUCCESS : FAILURE;
 }
 
-ZEND_RESULT_CODE php_http_client_driver_get(const char *name_str, size_t name_len, php_http_client_driver_t *driver)
+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_COPY(&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)
+static zend_class_entry *php_http_client_class_entry;
+zend_class_entry *php_http_client_get_class_entry(void)
+{
+       return php_http_client_class_entry;
+}
+
+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(options, 1, 0);
        }
 }
 
@@ -157,7 +167,7 @@ static void queue_dtor(void *enqueued)
        }
 }
 
-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;
 
@@ -174,14 +184,11 @@ php_http_client_t *php_http_client_init(php_http_client_t *h, php_http_client_op
        }
        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);
                }
        }
 
@@ -220,11 +227,9 @@ void php_http_client_free(php_http_client_t **h) {
 
 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);
@@ -235,13 +240,11 @@ ZEND_RESULT_CODE php_http_client_enqueue(php_http_client_t *h, php_http_client_e
 
 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);
@@ -323,12 +326,13 @@ ZEND_RESULT_CODE php_http_client_getopt(php_http_client_t *h, php_http_client_ge
        return FAILURE;
 }
 
-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);
+
+       PTR_FREE(o->gc);
 
        php_http_client_free(&o->client);
        if (o->debug.fci.size > 0) {
@@ -338,49 +342,91 @@ void php_http_client_object_free(void *object TSRMLS_DC)
        }
        php_http_object_method_dtor(&o->notify);
        php_http_object_method_free(&o->update);
-       zend_object_std_dtor((zend_object *) o TSRMLS_CC);
-       efree(o);
+       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));
-       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->zo.handlers = &php_http_client_object_handlers;
 
-       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;
+       return o;
+}
 
-       return o->zv;
+zend_object *php_http_client_object_new(zend_class_entry *ce)
+{
+       return &php_http_client_object_new_ex(ce, NULL)->zo;
 }
 
-zend_object_value php_http_client_object_new(zend_class_entry *ce TSRMLS_DC)
+static HashTable *php_http_client_object_get_gc(zval *object, zval **table, int *n)
 {
-       return php_http_client_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+       php_http_client_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+       zend_llist_element *el = NULL;
+       HashTable *props = Z_OBJPROP_P(object);
+       uint32_t count = zend_hash_num_elements(props) + zend_llist_count(&obj->client->responses) + zend_llist_count(&obj->client->requests) + 2;
+       zval *val;
+
+       *n = 0;
+       *table = obj->gc = erealloc(obj->gc, sizeof(zval) * count);
+
+#if PHP_HTTP_HAVE_CURL
+       if (obj->client->ops == php_http_client_curl_get_ops()) {
+               php_http_client_curl_t *curl = obj->client->ctx;
+
+               if (curl->ev_ops == php_http_client_curl_user_ops_get()) {
+                       php_http_client_curl_user_context_t *ctx = curl->ev_ctx;
+
+                       ZVAL_COPY_VALUE(&obj->gc[(*n)++], &ctx->user);
+               }
+       }
+#endif
+
+       if (obj->debug.fci.size > 0) {
+               ZVAL_COPY_VALUE(&obj->gc[(*n)++], &obj->debug.fci.function_name);
+       }
+
+       for (el = obj->client->responses.head; el; el = el->next) {
+               php_http_message_object_t *response_obj = *(php_http_message_object_t **) el->data;
+               ZVAL_OBJ(&obj->gc[(*n)++], &response_obj->zo);
+       }
+
+       for (el = obj->client->requests.head; el; el = el->next) {
+               php_http_client_enqueue_t *q = (php_http_client_enqueue_t *) el->data;
+               php_http_message_object_t *request_obj = q->opaque; /* FIXME */
+               ZVAL_OBJ(&obj->gc[(*n)++], &request_obj->zo);
+       }
+
+       ZEND_HASH_FOREACH_VAL(props, val)
+       {
+               ZVAL_COPY_VALUE(&obj->gc[(*n)++], val);
+       }
+       ZEND_HASH_FOREACH_END();
+
+       return NULL;
 }
 
-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_get_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);
 }
 
@@ -390,63 +436,56 @@ static ZEND_RESULT_CODE handle_response(void *arg, php_http_client_t *client, ph
        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, 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_get_client_response_class_entry(), msg);
+               ZVAL_OBJECT(&zresponse, &msg_obj->zo, 1);
+               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_get_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);
                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);
+                       ZVAL_UNDEF(&retval);
+                       zend_fcall_info_argn(&e->closure.fci, 1, &zresponse);
+                       zend_replace_error_handling(EH_NORMAL, NULL, &zeh);
                        ++client->callback.depth;
-                       zend_fcall_info_call(&e->closure.fci, &e->closure.fcc, &retval, NULL TSRMLS_CC);
+                       zend_fcall_info_call(&e->closure.fci, &e->closure.fcc, &retval, NULL);
                        --client->callback.depth;
-                       zend_restore_error_handling(&zeh TSRMLS_CC);
-                       zend_fcall_info_argn(&e->closure.fci TSRMLS_CC, 0);
+                       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);
@@ -468,64 +507,51 @@ static ZEND_RESULT_CODE handle_response(void *arg, php_http_client_t *client, ph
 
 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, *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);
+
+       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);
        ++client->callback.depth;
-       php_http_object_method_call(&client_obj->notify, zclient, NULL, 2, args TSRMLS_CC);
+       php_http_object_method_call(&client_obj->notify, &zclient, NULL, 2, args);
        --client->callback.depth;
-       zend_restore_error_handling(&zeh TSRMLS_CC);
+       zend_restore_error_handling(&zeh);
 
        zval_ptr_dtor(&zclient);
-       zval_ptr_dtor(&zrequest);
-       zval_ptr_dtor(&zprogress);
+       zval_ptr_dtor(&args[0]);
+       zval_ptr_dtor(&args[1]);
 }
 
 static void handle_debug(void *arg, php_http_client_t *client, php_http_client_enqueue_t *e, unsigned type, const char *data, size_t size)
 {
-       zval *ztype, *zdata, *zreq, *zclient;
+       zval ztype, zdata, zreq, zclient;
        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(zreq);
-       ZVAL_OBJVAL(zreq, ((php_http_message_object_t *) e->opaque)->zv, 1);
-       MAKE_STD_ZVAL(ztype);
-       ZVAL_LONG(ztype, type);
-       MAKE_STD_ZVAL(zdata);
-       ZVAL_STRINGL(zdata, data, size, 1);
-
-       zend_replace_error_handling(EH_NORMAL, NULL, &zeh TSRMLS_CC);
-       if (SUCCESS == zend_fcall_info_argn(&client_obj->debug.fci TSRMLS_CC, 4, &zclient, &zreq, &ztype, &zdata)) {
-               ++client_obj->client->callback.depth;
-               zend_fcall_info_call(&client_obj->debug.fci, &client_obj->debug.fcc, NULL, NULL TSRMLS_CC);
-               --client_obj->client->callback.depth;
+
+       ZVAL_OBJECT(&zclient, &client_obj->zo, 1);
+       ZVAL_OBJECT(&zreq, &((php_http_message_object_t *) e->opaque)->zo, 1);
+       ZVAL_LONG(&ztype, type);
+       ZVAL_STRINGL(&zdata, data, size);
+
+       zend_replace_error_handling(EH_NORMAL, NULL, &zeh);
+       if (SUCCESS == zend_fcall_info_argn(&client_obj->debug.fci, 4, &zclient, &zreq, &ztype, &zdata)) {
+               ++client->callback.depth;
+               zend_fcall_info_call(&client_obj->debug.fci, &client_obj->debug.fcc, NULL, NULL);
+               --client->callback.depth;
                zend_fcall_info_args_clear(&client_obj->debug.fci, 0);
        }
-       zend_restore_error_handling(&zeh TSRMLS_CC);
+       zend_restore_error_handling(&zeh);
 
        zval_ptr_dtor(&zclient);
        zval_ptr_dtor(&zreq);
@@ -536,9 +562,8 @@ static void handle_debug(void *arg, php_http_client_t *client, php_http_client_e
 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_object_release(&msg_obj->zo);
 }
 
 ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_construct, 0, 0, 0)
@@ -547,45 +572,40 @@ 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_persistent_handle_resource_factory_init(NULL, pf);
                        }
-
-                       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;
@@ -602,7 +622,7 @@ static PHP_METHOD(HttpClient, reset)
        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);
@@ -610,18 +630,19 @@ static PHP_METHOD(HttpClient, reset)
        RETVAL_ZVAL(getThis(), 1, 0);
 }
 
-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;
                }
@@ -631,28 +652,26 @@ static HashTable *combined_options(zval *client, zval *request TSRMLS_DC)
        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_object_release(&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_object_release(e->closure.fci.object);
                }
        }
 }
@@ -670,10 +689,10 @@ static PHP_METHOD(HttpClient, enqueue)
        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_get_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);
@@ -681,20 +700,20 @@ static PHP_METHOD(HttpClient, enqueue)
        }
 
        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);
@@ -713,10 +732,10 @@ static PHP_METHOD(HttpClient, dequeue)
        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_get_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);
@@ -741,30 +760,30 @@ static PHP_METHOD(HttpClient, requeue)
        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_get_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);
@@ -778,10 +797,10 @@ 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));
        }
@@ -795,20 +814,20 @@ static PHP_METHOD(HttpClient, getResponse)
        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_get_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);
                        }
                }
 
@@ -823,7 +842,7 @@ static PHP_METHOD(HttpClient, getResponse)
 
                /* 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);
                }
        }
@@ -833,11 +852,11 @@ ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_getHistory, 0, 0, 0)
 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);
+       zhistory = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("history"), 0, &zhistory_tmp);
        RETVAL_ZVAL(zhistory, 1, 0);
 }
 
@@ -849,7 +868,7 @@ static PHP_METHOD(HttpClient, send)
 
        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);
 
@@ -861,7 +880,7 @@ ZEND_END_ARG_INFO();
 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));
        }
@@ -874,9 +893,9 @@ static PHP_METHOD(HttpClient, wait)
 {
        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;
@@ -893,8 +912,8 @@ static PHP_METHOD(HttpClient, configure)
        HashTable *settings = NULL;
        php_http_client_object_t *obj;
 
-       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|H!", &settings), invalid_arg, return);
-       obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|H!", &settings), invalid_arg, return);
+       obj = PHP_HTTP_OBJ(NULL, getThis());
 
        php_http_expect(SUCCESS == php_http_client_setopt(obj->client, PHP_HTTP_CLIENT_OPT_CONFIGURATION, settings), unexpected_val, return);
 
@@ -909,9 +928,9 @@ static PHP_METHOD(HttpClient, enablePipelining)
        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);
 
@@ -926,9 +945,9 @@ static PHP_METHOD(HttpClient, enableEvents)
        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);
 
@@ -937,20 +956,21 @@ static PHP_METHOD(HttpClient, enableEvents)
 
 struct notify_arg {
        php_http_object_method_t *cb;
-       zval **args[3];
+       zval args[3];
        int argc;
 };
 
-static int notify(zend_object_iterator *iter, void *puser TSRMLS_DC)
+static int notify(zend_object_iterator *iter, void *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))) {
+               if (SUCCESS == php_http_object_method_call(arg->cb, observer, NULL, arg->argc, arg->args)) {
+                       return ZEND_HASH_APPLY_KEEP;
+               }
        }
-       return FAILURE;
+       return ZEND_HASH_APPLY_STOP;
 }
 
 ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_notify, 0, 0, 0)
@@ -958,14 +978,14 @@ ZEND_BEGIN_ARG_INFO_EX(ai_HttpClient_notify, 0, 0, 0)
 ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClient, notify)
 {
-       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_get_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);
@@ -974,31 +994,26 @@ static PHP_METHOD(HttpClient, notify)
 
        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;
 
                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;
                }
 
-               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);
                }
        }
 
@@ -1010,13 +1025,13 @@ 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);
@@ -1024,13 +1039,12 @@ static PHP_METHOD(HttpClient, attach)
        }
 
        if (!client_obj->update) {
-               client_obj->update = php_http_object_method_init(NULL, observer, ZEND_STRL("update") TSRMLS_CC);
+               client_obj->update = php_http_object_method_init(NULL, observer, ZEND_STRL("update"));
        }
 
-       zend_call_method_with_1_params(&observers, NULL, NULL, "attach", &retval, observer);
-       if (retval) {
-               zval_ptr_dtor(&retval);
-       }
+       ZVAL_UNDEF(&retval);
+       zend_call_method_with_1_params(observers, NULL, NULL, "attach", &retval, observer);
+       zval_ptr_dtor(&retval);
 
        RETVAL_ZVAL(getThis(), 1, 0);
 }
@@ -1040,21 +1054,20 @@ 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);
 }
@@ -1063,11 +1076,11 @@ 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);
@@ -1087,17 +1100,17 @@ static PHP_METHOD(HttpClient, getProgressInfo)
        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_get_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);
@@ -1114,10 +1127,10 @@ static PHP_METHOD(HttpClient, getTransferInfo)
        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_get_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);
@@ -1131,9 +1144,9 @@ static PHP_METHOD(HttpClient, setOptions)
 {
        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);
 }
@@ -1143,7 +1156,7 @@ ZEND_END_ARG_INFO();
 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);
+               zval options_tmp, *options = zend_read_property(php_http_client_class_entry, getThis(), ZEND_STRL("options"), 0, &options_tmp);
                RETVAL_ZVAL(options, 1, 0);
        }
 }
@@ -1155,9 +1168,9 @@ static PHP_METHOD(HttpClient, setSslOptions)
 {
        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);
 }
@@ -1169,9 +1182,9 @@ static PHP_METHOD(HttpClient, addSslOptions)
 {
        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);
 }
@@ -1181,7 +1194,7 @@ ZEND_END_ARG_INFO();
 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);
        }
 }
 
@@ -1192,9 +1205,9 @@ static PHP_METHOD(HttpClient, setCookies)
 {
        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);
 }
@@ -1206,9 +1219,9 @@ static PHP_METHOD(HttpClient, addCookies)
 {
        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);
 }
@@ -1218,16 +1231,17 @@ ZEND_END_ARG_INFO();
 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));
        }
 }
 
@@ -1236,7 +1250,7 @@ ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClient, getAvailableOptions)
 {
        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());
 
                array_init(return_value);
                php_http_client_getopt(obj->client, PHP_HTTP_CLIENT_OPT_AVAILABLE_OPTIONS, NULL, &Z_ARRVAL_P(return_value));
@@ -1248,7 +1262,7 @@ ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClient, getAvailableConfiguration)
 {
        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());
 
                array_init(return_value);
                php_http_client_getopt(obj->client, PHP_HTTP_CLIENT_OPT_AVAILABLE_CONFIGURATION, NULL, &Z_ARRVAL_P(return_value));
@@ -1266,9 +1280,9 @@ static PHP_METHOD(HttpClient, setDebug)
        php_http_client_object_t *client_obj;
 
        fci.size = 0;
-       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|f", &fci, &fcc), invalid_arg, return);
+       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|f", &fci, &fcc), invalid_arg, return);
 
-       client_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+       client_obj = PHP_HTTP_OBJ(NULL, getThis());
 
        if (client_obj->debug.fci.size > 0) {
                zval_ptr_dtor(&client_obj->debug.fci.function_name);
@@ -1277,7 +1291,7 @@ static PHP_METHOD(HttpClient, setDebug)
        if (fci.size > 0) {
                memcpy(&client_obj->debug.fci, &fci, sizeof(fci));
                memcpy(&client_obj->debug.fcc, &fcc, sizeof(fcc));
-               Z_ADDREF_P(fci.function_name);
+               Z_ADDREF_P(&fci.function_name);
                client_obj->client->callback.debug.func = handle_debug;
                client_obj->client->callback.debug.arg = client_obj;
        } else {
@@ -1329,24 +1343,27 @@ PHP_MINIT_FUNCTION(http_client)
        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_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_INFO"), PHP_HTTP_CLIENT_DEBUG_INFO TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_IN"), PHP_HTTP_CLIENT_DEBUG_IN TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_OUT"), PHP_HTTP_CLIENT_DEBUG_OUT TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_HEADER"), PHP_HTTP_CLIENT_DEBUG_HEADER TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_BODY"), PHP_HTTP_CLIENT_DEBUG_BODY TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_SSL"), PHP_HTTP_CLIENT_DEBUG_SSL TSRMLS_CC);
-
-       zend_hash_init(&php_http_client_drivers, 2, NULL, NULL, 1);
+       php_http_client_object_handlers.get_gc = php_http_client_object_get_gc;
+       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_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_INFO"), PHP_HTTP_CLIENT_DEBUG_INFO);
+       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_IN"), PHP_HTTP_CLIENT_DEBUG_IN);
+       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_OUT"), PHP_HTTP_CLIENT_DEBUG_OUT);
+       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_HEADER"), PHP_HTTP_CLIENT_DEBUG_HEADER);
+       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_BODY"), PHP_HTTP_CLIENT_DEBUG_BODY);
+       zend_declare_class_constant_long(php_http_client_class_entry, ZEND_STRL("DEBUG_SSL"), PHP_HTTP_CLIENT_DEBUG_SSL);
+
+       zend_hash_init(&php_http_client_drivers, 2, NULL, php_http_client_driver_hash_dtor, 1);
 
        return SUCCESS;
 }
index 8c526bd..0edd1bb 100644 (file)
@@ -65,13 +65,14 @@ typedef struct php_http_client_ops {
 } 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 ZEND_RESULT_CODE php_http_client_driver_add(php_http_client_driver_t *driver);
-PHP_HTTP_API ZEND_RESULT_CODE php_http_client_driver_get(const char *name_str, size_t name_len, 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 {
@@ -121,28 +122,24 @@ 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;
+PHP_HTTP_API zend_class_entry *php_http_client_get_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;
        struct {
                zend_fcall_info fci;
                zend_fcall_info_cache fcc;
        } debug;
+       long iterator;
+       zval *gc;
+       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);
index b15fdd4..cf65353 100644 (file)
@@ -45,15 +45,15 @@ typedef struct php_http_client_curl_handler {
                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;
@@ -79,7 +79,7 @@ static inline php_http_curle_storage_t *php_http_curle_get_storage(CURL *ch) {
        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;
 
@@ -90,7 +90,7 @@ static void *php_http_curle_ctor(void *opaque, void *init_arg TSRMLS_DC)
        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;
 
@@ -102,7 +102,7 @@ static void *php_http_curle_copy(void *opaque, void *handle TSRMLS_DC)
        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);
 
@@ -125,7 +125,7 @@ static php_resource_factory_ops_t php_http_curle_resource_factory_ops = {
        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)
 {
        php_http_client_curl_handle_t *curl = calloc(1, sizeof(*curl));
 
@@ -143,7 +143,7 @@ static void *php_http_curlm_ctor(void *opaque, void *init_arg TSRMLS_DC)
        return curl;
 }
 
-static void php_http_curlm_dtor(void *opaque, void *handle TSRMLS_DC)
+static void php_http_curlm_dtor(void *opaque, void *handle)
 {
        php_http_client_curl_handle_t *curl = handle;
 
@@ -162,15 +162,10 @@ static php_resource_factory_ops_t php_http_curlm_resource_factory_ops = {
 
 static size_t php_http_curle_read_callback(void *data, size_t len, size_t n, void *ctx)
 {
-       php_http_message_body_t *body = ctx;
-
-       if (body && body->stream_id) {
-               php_stream *s = php_http_message_body_stream(body);
+       php_stream *s = php_http_message_body_stream(ctx);
 
-               if (s) {
-                       TSRMLS_FETCH_FROM_CTX(body->ts);
-                       return php_stream_read(s, data, len * n);
-               } else abort();
+       if (s) {
+               return php_stream_read(s, data, len * n);
        }
        return 0;
 }
@@ -204,7 +199,6 @@ static int php_http_curle_progress_callback(void *ctx, double dltotal, double dl
 static int php_http_curle_seek_callback(void *userdata, curl_off_t offset, int origin)
 {
        php_http_message_body_t *body = userdata;
-       TSRMLS_FETCH_FROM_CTX(body->ts);
 
        if (!body) {
                return 1;
@@ -323,131 +317,161 @@ static int php_http_curle_body_callback(char *data, size_t n, size_t l, void *ar
 
 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_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
 
@@ -455,16 +479,14 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
 
 #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:
@@ -476,13 +498,13 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
                                {
                                        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;
@@ -493,12 +515,12 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
                                        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;
@@ -529,9 +551,9 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
                        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
@@ -539,41 +561,41 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
 #if (PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)) || (PHP_HTTP_CURL_VERSION(7,34,0) && defined(PHP_HTTP_HAVE_NSS)) || (PHP_HTTP_CURL_VERSION(7,42,0) && defined(PHP_HTTP_HAVE_GNUTLS)) || (PHP_HTTP_CURL_VERSION(7,39,0) && defined(PHP_HTTP_HAVE_GSKIT))
        {
                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;
@@ -584,14 +606,14 @@ static int compare_queue(php_http_client_enqueue_t *e, void *handle)
        return handle == ((php_http_client_curl_handler_t *) e->opaque)->handle;
 }
 
-static php_http_message_t *php_http_curlm_responseparser(php_http_client_curl_handler_t *h TSRMLS_DC)
+static php_http_message_t *php_http_curlm_responseparser(php_http_client_curl_handler_t *h)
 {
        php_http_message_t *response;
        php_http_header_parser_t parser;
-       zval *zh;
+       zval *zh, tmp;
 
-       response = php_http_message_init(NULL, 0, h->response.body TSRMLS_CC);
-       php_http_header_parser_init(&parser TSRMLS_CC);
+       response = php_http_message_init(NULL, 0, h->response.body);
+       php_http_header_parser_init(&parser);
        while (h->response.headers.used) {
                php_http_header_parser_state_t st = php_http_header_parser_parse(&parser,
                                &h->response.headers, PHP_HTTP_HEADER_PARSER_CLEANUP, &response->hdrs,
@@ -616,20 +638,24 @@ static php_http_message_t *php_http_curlm_responseparser(php_http_client_curl_ha
        php_http_message_body_addref(h->response.body);
 
        /* let's update the response headers */
-       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);
+       if ((zh = php_http_message_header(response, ZEND_STRL("Content-Length")))) {
+               ZVAL_COPY(&tmp, zh);
+               zend_hash_str_update(&response->hdrs, "X-Original-Content-Length", lenof("X-Original-Content-Length"), &tmp);
        }
-       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("Transfer-Encoding")))) {
+               ZVAL_COPY(&tmp, zh);
+               zend_hash_str_del(&response->hdrs, "Transfer-Encoding", lenof("Transfer-Encoding"));
+               zend_hash_str_update(&response->hdrs, "X-Original-Transfer-Encoding", lenof("X-Original-Transfer-Encoding"), &tmp);
        }
-       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("Content-Range")))) {
+               ZVAL_COPY(&tmp, zh);
+               zend_hash_str_del(&response->hdrs, "Content-Range", lenof("Content-Range"));
+               zend_hash_str_update(&response->hdrs, "X-Original-Content-Range", lenof("X-Original-Content-Range"), &tmp);
        }
-       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-Encoding")))) {
+               ZVAL_COPY(&tmp, zh);
+               zend_hash_str_del(&response->hdrs, "Content-Encoding", lenof("Content-Encoding"));
+               zend_hash_str_update(&response->hdrs, "X-Original-Content-Encoding", lenof("X-Original-Content-Encoding"), &tmp);
        }
        php_http_message_update_headers(response);
 
@@ -642,7 +668,6 @@ void php_http_client_curl_responsehandler(php_http_client_t *context)
        php_http_curle_storage_t *st, *err = NULL;
        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->multi, &remaining);
@@ -665,7 +690,7 @@ void php_http_client_curl_responsehandler(php_http_client_t *context)
 
                        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);
+                               php_http_message_t *response = php_http_curlm_responseparser(handler);
 
                                if (response) {
                                        context->callback.response.func(context->callback.response.arg, context, &handler->queue, &response);
@@ -679,7 +704,7 @@ void php_http_client_curl_responsehandler(php_http_client_t *context)
                int i = 0;
 
                do {
-                       php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s; %s (%s)", curl_easy_strerror(err[i].errorcode), err[i].errorbuffer, STR_PTR(err[i].url));
+                       php_error_docref(NULL, E_WARNING, "%s; %s (%s)", curl_easy_strerror(err[i].errorcode), err[i].errorbuffer, STR_PTR(err[i].url));
                        if (err[i].url) {
                                efree(err[i].url);
                        }
@@ -693,7 +718,6 @@ void php_http_client_curl_loop(php_http_client_t *client, curl_socket_t s, int c
 {
        CURLMcode rc;
        php_http_client_curl_t *curl = client->ctx;
-       TSRMLS_FETCH_FROM_CTX(client->ts);
 
 #if DBG_EVENTS
        fprintf(stderr, "H");
@@ -704,7 +728,7 @@ void php_http_client_curl_loop(php_http_client_t *client, curl_socket_t s, int c
        } while (CURLM_CALL_MULTI_PERFORM == rc);
 
        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_client_curl_responsehandler(client);
@@ -723,7 +747,7 @@ static ZEND_RESULT_CODE php_http_curle_option_set_ssl_verifyhost(php_http_option
        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;
@@ -734,10 +758,10 @@ static ZEND_RESULT_CODE php_http_curle_option_set_cookiesession(php_http_option_
        php_http_client_curl_handler_t *curl = userdata;
        CURL *ch = curl->handle;
 
-       if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIESESSION, (long) Z_BVAL_P(val))) {
+       if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIESESSION, (long) (Z_TYPE_P(val) == IS_TRUE))) {
                return FAILURE;
        }
-       if (Z_BVAL_P(val)) {
+       if (Z_TYPE_P(val) == IS_TRUE) {
                if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIELIST, "SESS")) {
                        return FAILURE;
                }
@@ -755,7 +779,7 @@ static ZEND_RESULT_CODE php_http_curle_option_set_cookiestore(php_http_option_t
        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;
@@ -773,11 +797,12 @@ static ZEND_RESULT_CODE php_http_curle_option_set_cookies(php_http_option_t *opt
 {
        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;
@@ -786,19 +811,20 @@ static ZEND_RESULT_CODE php_http_curle_option_set_cookies(php_http_option_t *opt
                                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) {
@@ -820,7 +846,7 @@ static ZEND_RESULT_CODE php_http_curle_option_set_encodecookies(php_http_option_
 {
        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;
 }
 
@@ -828,7 +854,6 @@ static ZEND_RESULT_CODE php_http_curle_option_set_lastmodified(php_http_option_t
 {
        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) {
@@ -836,7 +861,7 @@ static ZEND_RESULT_CODE php_http_curle_option_set_lastmodified(php_http_option_t
                                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;
                        }
                }
@@ -861,7 +886,7 @@ static ZEND_RESULT_CODE php_http_curle_option_set_compress(php_http_option_t *op
 #if !PHP_HTTP_CURL_VERSION(7,21,6)
 #      define CURLOPT_ACCEPT_ENCODING CURLOPT_ENCODING
 #endif
-       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;
@@ -872,7 +897,7 @@ static ZEND_RESULT_CODE php_http_curle_option_set_etag(php_http_option_t *opt, z
        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));
@@ -887,32 +912,29 @@ static ZEND_RESULT_CODE php_http_curle_option_set_range(php_http_option_t *opt,
 {
        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;
@@ -975,26 +997,16 @@ static ZEND_RESULT_CODE php_http_curle_option_set_portrange(php_http_option_t *o
        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;
@@ -1012,26 +1024,28 @@ static ZEND_RESULT_CODE php_http_curle_option_set_portrange(php_http_option_t *o
 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;
-       TSRMLS_FETCH_FROM_CTX(curl->client->ts);
 
        if (val && Z_TYPE_P(val) != IS_NULL) {
-               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;
                php_http_buffer_t header;
 
                php_http_buffer_init(&header);
-               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));
+               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);
+                               zend_string_release(zs);
+
                                php_http_buffer_fix(&header);
                                curl->options.proxyheaders = curl_slist_append(curl->options.proxyheaders, header.data);
                                php_http_buffer_reset(&header);
 
-                               zval_ptr_dtor(&header_cpy);
                        }
                }
+               ZEND_HASH_FOREACH_END();
                php_http_buffer_dtor(&header);
        }
        if (CURLE_OK != curl_easy_setopt(curl->handle, CURLOPT_PROXYHEADER, curl->options.proxyheaders)) {
@@ -1050,18 +1064,18 @@ static ZEND_RESULT_CODE php_http_curle_option_set_resolve(php_http_option_t *opt
 {
        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;
-
-               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);
+               HashTable *ht = HASH_OF(val);
+               zval *data;
+
+               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;
@@ -1099,13 +1113,13 @@ static ZEND_RESULT_CODE php_http_curle_option_set_ssl_tlsauthtype(php_http_optio
 }
 #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;
 
        /* url options */
 #if PHP_HTTP_CURL_VERSION(7,42,0)
-       php_http_option_register(registry, ZEND_STRL("path_as_is"), CURLOPT_PATH_AS_IS, IS_BOOL);
+       php_http_option_register(registry, ZEND_STRL("path_as_is"), CURLOPT_PATH_AS_IS, _IS_BOOL);
 #endif
 
        /* proxy */
@@ -1118,7 +1132,7 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
        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
@@ -1189,8 +1203,8 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
                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);
@@ -1224,7 +1238,7 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
        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
@@ -1241,18 +1255,17 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
        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 */
@@ -1271,7 +1284,7 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
        }
 
        /* 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;
        }
 
@@ -1281,7 +1294,7 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
        }
 
        /* 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);
        }
@@ -1290,7 +1303,7 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
        }
 
        /* cookiesession, don't load session cookies from cookiestore */
-       if ((opt = php_http_option_register(registry, ZEND_STRL("cookiesession"), CURLOPT_COOKIESESSION, IS_BOOL))) {
+       if ((opt = php_http_option_register(registry, ZEND_STRL("cookiesession"), CURLOPT_COOKIESESSION, _IS_BOOL))) {
                opt->setter = php_http_curle_option_set_cookiesession;
        }
        /* cookiestore, read initial cookies from that file and store cookies back into that file */
@@ -1322,9 +1335,9 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
 #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;
        }
@@ -1344,7 +1357,7 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
                        }
                        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;
@@ -1352,36 +1365,36 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
                        }
                        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) && (defined(PHP_HTTP_HAVE_OPENSSL) || defined(PHP_HTTP_HAVE_NSS) || defined(PHP_HTTP_HAVE_GNUTLS))
-                       php_http_option_register(registry, ZEND_STRL("verifystatus"), CURLOPT_SSL_VERIFYSTATUS, IS_BOOL);
+               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))) {
                                opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
                                opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
 #ifdef PHP_HTTP_CURL_CAPATH
-                               ZVAL_STRING(&opt->defval, PHP_HTTP_CURL_CAPATH, 0);
+                       ZVAL_PSTRING(&opt->defval, PHP_HTTP_CURL_CAPATH);
 #endif
                }
                        if ((opt = php_http_option_register(registry, ZEND_STRL("random_file"), CURLOPT_RANDOM_FILE, IS_STRING))) {
@@ -1405,13 +1418,15 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
 #      endif
 #endif
 #if (PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)) || (PHP_HTTP_CURL_VERSION(7,34,0) && defined(PHP_HTTP_HAVE_NSS)) || (PHP_HTTP_CURL_VERSION(7,42,0) && defined(PHP_HTTP_HAVE_GNUTLS)) || (PHP_HTTP_CURL_VERSION(7,39,0) && defined(PHP_HTTP_HAVE_GSKIT))
-                       php_http_option_register(registry, ZEND_STRL("certinfo"), CURLOPT_CERTINFO, IS_BOOL);
+                       if ((opt = php_http_option_register(registry, ZEND_STRL("certinfo"), CURLOPT_CERTINFO, _IS_BOOL))) {
+                               ZVAL_FALSE(&opt->defval);
+                       }
 #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);
                        }
 #endif
@@ -1434,7 +1449,7 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
                        }
 #endif
 #if PHP_HTTP_CURL_VERSION(7,42,0) && (defined(PHP_HTTP_HAVE_NSS) || defined(PHP_HTTP_HAVE_DARWINSSL))
-                       php_http_option_register(registry, ZEND_STRL("falsestart"), CURLOPT_SSL_FALSESTART, IS_BOOL);
+               php_http_option_register(registry, ZEND_STRL("falsestart"), CURLOPT_SSL_FALSESTART, _IS_BOOL);
 #endif
                }
        }
@@ -1446,8 +1461,12 @@ static zval *php_http_curle_get_option(php_http_option_t *opt, HashTable *option
        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);
+               zval zopt;
+
+               ZVAL_DUP(&zopt, option);
+               convert_to_explicit_type(&zopt, opt->type);
+               zend_hash_update(&curl->options.cache, opt->name, &zopt);
+               return zend_hash_find(&curl->options.cache, opt->name);
        }
        return option;
 }
@@ -1459,17 +1478,16 @@ static ZEND_RESULT_CODE php_http_curle_set_option(php_http_option_t *opt, zval *
        zval tmp;
        CURLcode rc = CURLE_UNKNOWN_OPTION;
        ZEND_RESULT_CODE rv = SUCCESS;
-       TSRMLS_FETCH_FROM_CTX(curl->client->ts);
 
        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;
@@ -1485,11 +1503,15 @@ static ZEND_RESULT_CODE php_http_curle_set_option(php_http_option_t *opt, zval *
        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;
                        }
@@ -1528,7 +1550,7 @@ static ZEND_RESULT_CODE php_http_curle_set_option(php_http_option_t *opt, zval *
                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;
 }
@@ -1541,12 +1563,10 @@ static ZEND_RESULT_CODE php_http_curlm_option_set_pipelining_bl(php_http_option_
        CURLM *ch = curl->handle->multi;
        HashTable tmp_ht;
        char **bl = NULL;
-       TSRMLS_FETCH_FROM_CTX(client->ts);
 
        /* array of char *, ending with a NULL */
        if (value && Z_TYPE_P(value) != IS_NULL) {
-               zval **entry;
-               HashPosition pos;
+               zval *entry;
                HashTable *ht = HASH_OF(value);
                int c = zend_hash_num_elements(ht);
                char **ptr = ecalloc(c + 1, sizeof(char *));
@@ -1556,9 +1576,11 @@ static ZEND_RESULT_CODE php_http_curlm_option_set_pipelining_bl(php_http_option_
                zend_hash_init(&tmp_ht, c, NULL, ZVAL_PTR_DTOR, 0);
                array_join(ht, &tmp_ht, 0, ARRAY_JOIN_STRINGIFY);
 
-               FOREACH_HASH_VAL(pos, &tmp_ht, entry) {
-                       *ptr++ = Z_STRVAL_PP(entry);
+               ZEND_HASH_FOREACH_VAL(&tmp_ht, entry)
+               {
+                       *ptr++ = Z_STRVAL_P(entry);
                }
+               ZEND_HASH_FOREACH_END();
        }
 
        if (CURLM_OK != curl_multi_setopt(ch, opt->option, bl)) {
@@ -1604,12 +1626,11 @@ static ZEND_RESULT_CODE php_http_curlm_option_set_use_eventloop(php_http_option_
 {
        php_http_client_t *client = userdata;
        php_http_client_curl_ops_t *ev_ops = NULL;
-       TSRMLS_FETCH_FROM_CTX(client->ts);
 
-       if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_client_curl_user_class_entry TSRMLS_CC)) {
+       if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_client_curl_user_get_class_entry())) {
                ev_ops = php_http_client_curl_user_ops_get();
 #if PHP_HTTP_HAVE_EVENT
-       } else if (value && z_is_true(value)) {
+       } else if (value && zend_is_true(value)) {
                ev_ops = php_http_client_curl_event_ops_get();
 #endif
        }
@@ -1623,15 +1644,14 @@ static ZEND_RESULT_CODE php_http_curlm_option_set_share_cookies(php_http_option_
        php_http_client_curl_t *curl = client->ctx;
        CURLSHcode rc;
 
-       if (Z_BVAL_P(value)) {
+       if (Z_TYPE_P(value) == IS_TRUE) {
                rc = curl_share_setopt(curl->handle->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
        } else {
                rc = curl_share_setopt(curl->handle->share, CURLSHOPT_UNSHARE, CURL_LOCK_DATA_COOKIE);
        }
 
        if (CURLSHE_OK != rc) {
-               TSRMLS_FETCH_FROM_CTX(client->ts);
-               php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_share_strerror(rc));
+               php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_share_strerror(rc));
                return FAILURE;
        }
        return SUCCESS;
@@ -1644,22 +1664,21 @@ static ZEND_RESULT_CODE php_http_curlm_option_set_share_ssl(php_http_option_t *o
        php_http_client_curl_t *curl = client->ctx;
        CURLSHcode rc;
 
-       if (Z_BVAL_P(value)) {
+       if (Z_TYPE_P(value) == IS_TRUE) {
                rc = curl_share_setopt(curl->handle->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
        } else {
                rc = curl_share_setopt(curl->handle->share, CURLSHOPT_UNSHARE, CURL_LOCK_DATA_SSL_SESSION);
        }
 
        if (CURLSHE_OK != rc) {
-               TSRMLS_FETCH_FROM_CTX(client->ts);
-               php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_share_strerror(rc));
+               php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_share_strerror(rc));
                return FAILURE;
        }
        return SUCCESS;
 }
 #endif
 
-static void php_http_curlm_options_init(php_http_options_t *registry TSRMLS_DC)
+static void php_http_curlm_options_init(php_http_options_t *registry)
 {
        php_http_option_t *opt;
 
@@ -1683,7 +1702,7 @@ static void php_http_curlm_options_init(php_http_options_t *registry TSRMLS_DC)
        php_http_option_register(registry, ZEND_STRL("max_total_connections"), CURLMOPT_MAX_TOTAL_CONNECTIONS, IS_LONG);
 #endif
        /* enable/disable HTTP pipelining */
-       php_http_option_register(registry, ZEND_STRL("pipelining"), CURLMOPT_PIPELINING, IS_BOOL);
+       php_http_option_register(registry, ZEND_STRL("pipelining"), CURLMOPT_PIPELINING, _IS_BOOL);
        /* chunk length threshold for pipelining */
 #if PHP_HTTP_CURL_VERSION(7,30,0)
        php_http_option_register(registry, ZEND_STRL("chunk_length_penalty_size"), CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, IS_LONG);
@@ -1709,14 +1728,14 @@ static void php_http_curlm_options_init(php_http_options_t *registry TSRMLS_DC)
                opt->setter = php_http_curlm_option_set_use_eventloop;
        }
        /* share */
-       if ((opt = php_http_option_register(registry, ZEND_STRL("share_cookies"), 0, IS_BOOL))) {
+       if ((opt = php_http_option_register(registry, ZEND_STRL("share_cookies"), 0, _IS_BOOL))) {
                opt->setter = php_http_curlm_option_set_share_cookies;
-               ZVAL_BOOL(&opt->defval, 1);
+               ZVAL_TRUE(&opt->defval);
        }
 #if PHP_HTTP_CURL_VERSION(7,23,0)
-       if ((opt = php_http_option_register(registry, ZEND_STRL("share_ssl"), 0, IS_BOOL))) {
+       if ((opt = php_http_option_register(registry, ZEND_STRL("share_ssl"), 0, _IS_BOOL))) {
                opt->setter = php_http_curlm_option_set_share_ssl;
-               ZVAL_BOOL(&opt->defval, 1);
+               ZVAL_TRUE(&opt->defval);
        }
 #endif
 }
@@ -1729,39 +1748,43 @@ static ZEND_RESULT_CODE php_http_curlm_set_option(php_http_option_t *opt, zval *
        zval *orig = val;
        CURLMcode rc = CURLM_UNKNOWN_OPTION;
        ZEND_RESULT_CODE rv = SUCCESS;
-       TSRMLS_FETCH_FROM_CTX(client->ts);
 
        if (!val) {
                val = &opt->defval;
        } else if (opt->type && Z_TYPE_P(val) != opt->type && !(Z_TYPE_P(val) == IS_NULL && opt->type == IS_ARRAY)) {
-               val = php_http_ztyp(opt->type, val);
+               zval zopt;
+
+               ZVAL_DUP(&zopt, val);
+               convert_to_explicit_type(&zopt, opt->type);
+
+               val = &zopt;
        }
 
        if (opt->setter) {
                rv = opt->setter(opt, val, client);
        } else {
                switch (opt->type) {
-               case IS_BOOL:
-                       if (CURLM_OK != (rc = curl_multi_setopt(ch, opt->option, (long) Z_BVAL_P(val)))) {
+               case _IS_BOOL:
+                       if (CURLM_OK != (rc = curl_multi_setopt(ch, opt->option, (long) zend_is_true(val)))) {
                                rv = FAILURE;
-                               php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_multi_strerror(rc));
+                               php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_multi_strerror(rc));
                        }
                        break;
                case IS_LONG:
                        if (CURLM_OK != (rc = curl_multi_setopt(ch, opt->option, Z_LVAL_P(val)))) {
                                rv = FAILURE;
-                               php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_multi_strerror(rc));
+                               php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_multi_strerror(rc));
                        }
                        break;
                default:
                        rv = FAILURE;
-                       php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s", opt->name.s);
+                       php_error_docref(NULL, E_NOTICE, "Could not set option %s", opt->name->val);
                        break;
                }
        }
 
        if (val && val != orig && val != &opt->defval) {
-               zval_ptr_dtor(&val);
+               zval_ptr_dtor(val);
        }
 
        return rv;
@@ -1830,10 +1853,9 @@ static php_http_client_curl_handler_t *php_http_client_curl_handler_init(php_htt
        void *handle;
        php_http_client_curl_t *curl = h->ctx;
        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->multi");
+       if (!(handle = php_resource_factory_handle_ctor(rf, NULL))) {
+               php_error_docref(NULL, E_WARNING, "Failed to initialize curl handle");
                return NULL;
        }
 
@@ -1841,7 +1863,7 @@ static php_http_client_curl_handler_t *php_http_client_curl_handler_init(php_htt
        handler->rf = rf;
        handler->client = h;
        handler->handle = handle;
-       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);
@@ -1883,11 +1905,10 @@ static ZEND_RESULT_CODE php_http_client_curl_handler_prepare(php_http_client_cur
        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';
@@ -1903,34 +1924,33 @@ static ZEND_RESULT_CODE php_http_client_curl_handler_prepare(php_http_client_cur
        /* 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);
@@ -1980,7 +2000,7 @@ static ZEND_RESULT_CODE php_http_client_curl_handler_prepare(php_http_client_cur
                        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;
        }
 
@@ -2003,11 +2023,9 @@ static void php_http_client_curl_handler_clear(php_http_client_curl_handler_t *h
 
 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_body_free(&handler->response.body);
@@ -2016,21 +2034,32 @@ static void php_http_client_curl_handler_dtor(php_http_client_curl_handler_t *ha
        php_http_buffer_dtor(&handler->options.cookies);
        zend_hash_destroy(&handler->options.cache);
 
+#if PHP_HTTP_CURL_VERSION(7,21,3)
+       if (handler->options.resolve) {
+               curl_slist_free_all(handler->options.resolve);
+               handler->options.resolve = NULL;
+       }
+#endif
+
        if (handler->options.headers) {
                curl_slist_free_all(handler->options.headers);
                handler->options.headers = NULL;
        }
 
+       if (handler->options.proxyheaders) {
+               curl_slist_free_all(handler->options.proxyheaders);
+               handler->options.proxyheaders = NULL;
+       }
+
        efree(handler);
 }
 
 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->multi");
+       if (!handle && !(handle = php_resource_factory_handle_ctor(h->rf, NULL))) {
+               php_error_docref(NULL, E_WARNING, "Failed to initialize curl handle");
                return NULL;
        }
 
@@ -2045,7 +2074,6 @@ static php_http_client_t *php_http_client_curl_init(php_http_client_t *h, void *
 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 (curl->ev_ops) {
                curl->ev_ops->dtor(&curl->ev_ctx);
@@ -2053,7 +2081,7 @@ static void php_http_client_curl_dtor(php_http_client_t *h)
        }
        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;
@@ -2070,37 +2098,38 @@ static void queue_dtor(php_http_client_enqueue_t *e)
        php_http_client_curl_handler_dtor(handler);
 }
 
-static php_resource_factory_t *create_rf(php_http_client_t *h, php_http_client_enqueue_t *enqueue TSRMLS_DC)
+static php_resource_factory_t *create_rf(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
 {
        php_persistent_handle_factory_t *pf = NULL;
        php_resource_factory_t *rf = NULL;
        php_http_url_t *url = enqueue->request->http.info.request.url;
 
        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;
        }
 
        /* only if the client itself is setup for persistence */
        if (php_resource_factory_is_persistent(h->rf)) {
+               zend_string *id;
                char *id_str = NULL;
                size_t id_len;
                int port = url->port ? url->port : 80;
-               zval **zport;
+               zval *zport;
                php_persistent_handle_factory_t *phf = h->rf->data;
 
-               if (SUCCESS == zend_hash_find(enqueue->options, ZEND_STRS("port"), (void *) &zport)) {
-                       zval *zcpy = php_http_ztyp(IS_LONG, *zport);
+               if ((zport = zend_hash_str_find(enqueue->options, ZEND_STRL("port")))) {
+                       zend_long lport = zval_get_long(zport);
 
-                       if (Z_LVAL_P(zcpy)) {
-                               port = Z_LVAL_P(zcpy);
+                       if (lport > 0) {
+                               port = lport;
                        }
-                       zval_ptr_dtor(&zcpy);
                }
 
-               id_len = spprintf(&id_str, 0, "%.*s:%s:%d", (int) phf->ident.len, phf->ident.str, STR_PTR(url->host), port);
-               pf = php_persistent_handle_concede(NULL, ZEND_STRL("http\\Client\\Curl\\Request"), id_str, id_len, NULL, NULL TSRMLS_CC);
-               efree(id_str);
+               id_len = spprintf(&id_str, 0, "%.*s:%s:%d", (int) phf->ident->len, phf->ident->val, STR_PTR(url->host), port);
+               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);
        }
 
        if (pf) {
@@ -2119,9 +2148,8 @@ static ZEND_RESULT_CODE php_http_client_curl_enqueue(php_http_client_t *h, php_h
        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(h, enqueue TSRMLS_CC);
+       rf = create_rf(h, enqueue);
        if (!rf) {
                return FAILURE;
        }
@@ -2142,7 +2170,7 @@ static ZEND_RESULT_CODE php_http_client_curl_enqueue(php_http_client_t *h, php_h
 
        if (CURLM_OK != (rs = curl_multi_add_handle(curl->handle->multi, handler->handle))) {
                php_http_client_curl_handler_dtor(handler);
-               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;
        }
 
@@ -2163,10 +2191,9 @@ static ZEND_RESULT_CODE php_http_client_curl_dequeue(php_http_client_t *h, php_h
        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);
 
        if (h->callback.depth) {
-               php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not dequeue request while executing callbacks");
+               php_error_docref(NULL, E_WARNING, "Could not dequeue request while executing callbacks");
                return FAILURE;
        }
 
@@ -2175,7 +2202,7 @@ static ZEND_RESULT_CODE php_http_client_curl_dequeue(php_http_client_t *h, php_h
                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;
@@ -2249,7 +2276,6 @@ static int php_http_client_curl_once(php_http_client_t *h)
 static ZEND_RESULT_CODE php_http_client_curl_exec(php_http_client_t *h)
 {
        php_http_client_curl_t *curl = h->ctx;
-       TSRMLS_FETCH_FROM_CTX(h->ts);
 
        if (!h->callback.depth) {
                if (curl->ev_ops) {
@@ -2260,9 +2286,9 @@ static ZEND_RESULT_CODE php_http_client_curl_exec(php_http_client_t *h)
                        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;
                        }
@@ -2301,34 +2327,31 @@ static ZEND_RESULT_CODE php_http_client_curl_setopt(php_http_client_t *h, php_ht
        return SUCCESS;
 }
 
-static int apply_available_options(void *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+static int apply_available_options(zval *pDest, int num_args, va_list args, zend_hash_key *hash_key)
 {
-       php_http_option_t *opt = pDest;
+       php_http_option_t *opt = Z_PTR_P(pDest);
        HashTable *ht;
-       zval *entry;
+       zval entry;
        int c;
 
        ht = va_arg(args, HashTable*);
 
-       MAKE_STD_ZVAL(entry);
-
        if ((c = zend_hash_num_elements(&opt->suboptions.options))) {
-               array_init_size(entry, c);
-               zend_hash_apply_with_arguments(&opt->suboptions.options TSRMLS_CC, apply_available_options, 1, Z_ARRVAL_P(entry));
+               array_init_size(&entry, c);
+               zend_hash_apply_with_arguments(&opt->suboptions.options, apply_available_options, 1, Z_ARRVAL(entry));
        } else {
                /* catch deliberate NULL options */
                if (Z_TYPE(opt->defval) == IS_STRING && !Z_STRVAL(opt->defval)) {
-                       ZVAL_NULL(entry);
+                       ZVAL_NULL(&entry);
                } else {
-                       ZVAL_COPY_VALUE(entry, &opt->defval);
-                       zval_copy_ctor(entry);
+                       ZVAL_ZVAL(&entry, &opt->defval, 1, 0);
                }
        }
 
-       if (hash_key->nKeyLength) {
-               zend_hash_quick_update(ht, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void *) &entry, sizeof(zval *), NULL);
+       if (hash_key->key) {
+               zend_hash_update(ht, hash_key->key, &entry);
        } else {
-               zend_hash_index_update(ht, hash_key->h, (void *) &entry, sizeof(zval *), NULL);
+               zend_hash_index_update(ht, hash_key->h, &entry);
        }
 
        return ZEND_HASH_APPLY_KEEP;
@@ -2337,7 +2360,6 @@ static int apply_available_options(void *pDest TSRMLS_DC, int num_args, va_list
 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;
-       TSRMLS_FETCH_FROM_CTX(h->ts);
 
        switch (opt) {
        case PHP_HTTP_CLIENT_OPT_PROGRESS_INFO:
@@ -2359,11 +2381,11 @@ static ZEND_RESULT_CODE php_http_client_curl_getopt(php_http_client_t *h, php_ht
                break;
 
        case PHP_HTTP_CLIENT_OPT_AVAILABLE_OPTIONS:
-               zend_hash_apply_with_arguments(&php_http_curle_options.options TSRMLS_CC, apply_available_options, 1, *(HashTable **) res);
+               zend_hash_apply_with_arguments(&php_http_curle_options.options, apply_available_options, 1, *(HashTable **) res);
                break;
 
        case PHP_HTTP_CLIENT_OPT_AVAILABLE_CONFIGURATION:
-               zend_hash_apply_with_arguments(&php_http_curlm_options.options TSRMLS_CC, apply_available_options, 1, *(HashTable **) res);
+               zend_hash_apply_with_arguments(&php_http_curlm_options.options, apply_available_options, 1, *(HashTable **) res);
                break;
 
        default:
@@ -2398,19 +2420,20 @@ PHP_MINIT_FUNCTION(http_client_curl)
 {
        curl_version_info_data *info;
        php_http_options_t *options;
-       php_http_client_driver_t driver = {
-               ZEND_STRL("curl"),
-               &php_http_client_curl_ops
-       };
 
-       if (SUCCESS != php_http_client_driver_add(&driver)) {
+       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;
        }
 
@@ -2418,13 +2441,13 @@ PHP_MINIT_FUNCTION(http_client_curl)
                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);
        }
        if ((options = php_http_options_init(&php_http_curlm_options, 1))) {
                options->getter = php_http_option_get;
                options->setter = php_http_curlm_set_option;
 
-               php_http_curlm_options_init(options TSRMLS_CC);
+               php_http_curlm_options_init(options);
        }
 
        if ((info = curl_version_info(CURLVERSION_NOW))) {
@@ -2563,8 +2586,11 @@ PHP_MINIT_FUNCTION(http_client_curl)
 
 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);
        php_http_options_dtor(&php_http_curlm_options);
index beeb8df..abd8f99 100644 (file)
 
 #if PHP_HTTP_HAVE_CURL
 
+struct php_http_client_curl_globals {
+       php_http_client_driver_t driver;
+};
+
 typedef struct php_http_client_curl_handle {
        CURLM *multi;
        CURLSH *share;
@@ -50,9 +54,11 @@ static inline void php_http_client_curl_get_timeout(php_http_client_curl_t *curl
 
 PHP_HTTP_API void php_http_client_curl_responsehandler(php_http_client_t *client);
 PHP_HTTP_API void php_http_client_curl_loop(php_http_client_t *client, curl_socket_t s, int curl_action);
+PHP_HTTP_API php_http_client_ops_t *php_http_client_curl_get_ops(void);
 
 PHP_MINIT_FUNCTION(http_client_curl);
 PHP_MSHUTDOWN_FUNCTION(http_client_curl);
+
 #endif /* PHP_HTTP_HAVE_CURL */
 
 #endif /* PHP_HTTP_CLIENT_CURL_H */
index 058c51f..e1ba505 100644 (file)
@@ -11,8 +11,6 @@
 */
 
 #include "php_http_api.h"
-#include "php_http_client.h"
-#include "php_http_client_curl.h"
 
 #if PHP_HTTP_HAVE_CURL
 #if PHP_HTTP_HAVE_EVENT
@@ -67,7 +65,6 @@ static void php_http_client_curl_event_handler(void *context, curl_socket_t s, i
        CURLMcode rc;
        php_http_client_curl_event_context_t *ctx = context;
        php_http_client_curl_t *curl = ctx->client->ctx;
-       TSRMLS_FETCH_FROM_CTX(ctx->client->ts);
 
 #if DBG_EVENTS
        fprintf(stderr, "H");
@@ -78,7 +75,7 @@ static void php_http_client_curl_event_handler(void *context, curl_socket_t s, i
        } while (CURLM_CALL_MULTI_PERFORM == rc);
 
        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_client_curl_responsehandler(ctx->client);
@@ -144,7 +141,6 @@ static int php_http_client_curl_event_socket(CURL *easy, curl_socket_t sock, int
        php_http_client_curl_t *curl = ctx->client->ctx;
        int events = EV_PERSIST;
        php_http_client_curl_event_ev_t *ev = assign_data;
-       TSRMLS_FETCH_FROM_CTX(ctx->client->ts);
 
 #if DBG_EVENTS
        fprintf(stderr, "S");
@@ -176,7 +172,7 @@ static int php_http_client_curl_event_socket(CURL *easy, curl_socket_t sock, int
                        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;
        }
 
@@ -235,7 +231,6 @@ static ZEND_RESULT_CODE php_http_client_curl_event_exec(void *context)
 {
        php_http_client_curl_event_context_t *ctx = context;
        php_http_client_curl_t *curl = ctx->client->ctx;
-       TSRMLS_FETCH_FROM_CTX(ctx->client->ts);
 
 #if DBG_EVENTS
        fprintf(stderr, "E");
index d3b0928..4739f62 100644 (file)
@@ -10,6 +10,9 @@
     +--------------------------------------------------------------------+
 */
 
+#ifndef PHP_HTTP_CLIENT_CURL_EVENT_H
+#define PHP_HTTP_CLIENT_CURL_EVENT_H
+
 #if PHP_HTTP_HAVE_CURL
 #if PHP_HTTP_HAVE_EVENT
 
@@ -18,6 +21,8 @@ php_http_client_curl_ops_t *php_http_client_curl_event_ops_get();
 #endif
 #endif
 
+#endif
+
 /*
  * Local variables:
  * tab-width: 4
index f4a9958..66edae6 100644 (file)
 */
 
 #include "php_http_api.h"
-#include "php_http_client.h"
-#include "php_http_client_curl.h"
-#include "php_http_client_curl_user.h"
 
 #include "php_network.h"
 #include "zend_closures.h"
 
 #if PHP_HTTP_HAVE_CURL
 
-typedef struct php_http_client_curl_user_context {
-       php_http_client_t *client;
-       zval *user;
-       zend_function closure;
-       php_http_object_method_t timer;
-       php_http_object_method_t socket;
-       php_http_object_method_t once;
-       php_http_object_method_t wait;
-       php_http_object_method_t send;
-} php_http_client_curl_user_context_t;
-
 typedef struct php_http_client_curl_user_ev {
        php_stream *socket;
        php_http_client_curl_user_context_t *context;
@@ -45,13 +31,13 @@ static void php_http_client_curl_user_handler(INTERNAL_FUNCTION_PARAMETERS)
        php_http_client_object_t *client = NULL;
        php_http_client_curl_t *curl;
 
-       if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|rl", &zclient, php_http_client_class_entry, &zstream, &action)) {
+       if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "O|rl", &zclient, php_http_client_get_class_entry(), &zstream, &action)) {
                return;
        }
 
-       client = zend_object_store_get_object(zclient TSRMLS_CC);
+       client = PHP_HTTP_OBJ(NULL, zclient);
        if (zstream) {
-               php_stream_from_zval(stream, &zstream);
+               php_stream_from_zval(stream, zstream);
 
                if (SUCCESS != php_stream_cast(stream, PHP_STREAM_AS_SOCKETD, (void *) &fd, 1)) {
                        return;
@@ -74,14 +60,11 @@ static void php_http_client_curl_user_timer(CURLM *multi, long timeout_ms, void
        if (timeout_ms <= 0) {
                php_http_client_curl_loop(context->client, CURL_SOCKET_TIMEOUT, 0);
        } else if (timeout_ms > 0) {
-               zval **args[1], *ztimeout;
-               TSRMLS_FETCH_FROM_CTX(context->client->ts);
+               zval args[1], *ztimeout = &args[0];
 
-               MAKE_STD_ZVAL(ztimeout);
                ZVAL_LONG(ztimeout, timeout_ms);
-               args[0] = &ztimeout;
-               php_http_object_method_call(&context->timer, context->user, NULL, 1, args TSRMLS_CC);
-               zval_ptr_dtor(&ztimeout);
+               php_http_object_method_call(&context->timer, &context->user, NULL, 1, args);
+               zval_ptr_dtor(ztimeout);
        }
 }
 
@@ -90,8 +73,7 @@ static int php_http_client_curl_user_socket(CURL *easy, curl_socket_t sock, int
        php_http_client_curl_user_context_t *ctx = socket_data;
        php_http_client_curl_t *curl = ctx->client->ctx;
        php_http_client_curl_user_ev_t *ev = assign_data;
-       zval **args[2], *zaction, *zsocket;
-       TSRMLS_FETCH_FROM_CTX(ctx->client->ts);
+       zval args[2], *zaction = &args[1], *zsocket = &args[0];
 
 #if DBG_EVENTS
        fprintf(stderr, "S");
@@ -111,24 +93,23 @@ static int php_http_client_curl_user_socket(CURL *easy, curl_socket_t sock, int
                case CURL_POLL_INOUT:
                case CURL_POLL_REMOVE:
                case CURL_POLL_NONE:
-                       MAKE_STD_ZVAL(zsocket);
                        php_stream_to_zval(ev->socket, zsocket);
-                       args[0] = &zsocket;
-                       MAKE_STD_ZVAL(zaction);
+                       Z_TRY_ADDREF_P(zsocket);
                        ZVAL_LONG(zaction, action);
-                       args[1] = &zaction;
-                       php_http_object_method_call(&ctx->socket, ctx->user, NULL, 2, args TSRMLS_CC);
-                       zval_ptr_dtor(&zsocket);
-                       zval_ptr_dtor(&zaction);
+                       php_http_object_method_call(&ctx->socket, &ctx->user, NULL, 2, args);
+                       zval_ptr_dtor(zsocket);
+                       zval_ptr_dtor(zaction);
                        break;
 
                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;
        }
 
        if (action == CURL_POLL_REMOVE && ev) {
+               php_stream_close(ev->socket);
                efree(ev);
+               curl_multi_assign(curl->handle->multi, sock, NULL);
        }
        return 0;
 }
@@ -136,22 +117,20 @@ static int php_http_client_curl_user_socket(CURL *easy, curl_socket_t sock, int
 static ZEND_RESULT_CODE php_http_client_curl_user_once(void *context)
 {
        php_http_client_curl_user_context_t *ctx = context;
-       TSRMLS_FETCH_FROM_CTX(ctx->client->ts);
 
 #if DBG_EVENTS
        fprintf(stderr, "O");
 #endif
 
-       return php_http_object_method_call(&ctx->once, ctx->user, NULL, 0, NULL TSRMLS_CC);
+       return php_http_object_method_call(&ctx->once, &ctx->user, NULL, 0, NULL);
 }
 
 static ZEND_RESULT_CODE php_http_client_curl_user_wait(void *context, struct timeval *custom_timeout)
 {
        php_http_client_curl_user_context_t *ctx = context;
        struct timeval timeout;
-       zval **args[1], *ztimeout;
+       zval args[1], *ztimeout = &args[0];
        ZEND_RESULT_CODE rv;
-       TSRMLS_FETCH_FROM_CTX(ctx->client->ts);
 
 #if DBG_EVENTS
        fprintf(stderr, "W");
@@ -162,11 +141,9 @@ static ZEND_RESULT_CODE php_http_client_curl_user_wait(void *context, struct tim
                custom_timeout = &timeout;
        }
 
-       MAKE_STD_ZVAL(ztimeout);
        ZVAL_LONG(ztimeout, custom_timeout->tv_sec * 1000 + custom_timeout->tv_usec / 1000);
-       args[0] = &ztimeout;
-       rv = php_http_object_method_call(&ctx->wait, ctx->user, NULL, 1, args TSRMLS_CC);
-       zval_ptr_dtor(&ztimeout);
+       rv = php_http_object_method_call(&ctx->wait, &ctx->user, NULL, 1, args);
+       zval_ptr_dtor(ztimeout);
 
        return rv;
 }
@@ -175,7 +152,6 @@ static ZEND_RESULT_CODE php_http_client_curl_user_exec(void *context)
 {
        php_http_client_curl_user_context_t *ctx = context;
        php_http_client_curl_t *curl = ctx->client->ctx;
-       TSRMLS_FETCH_FROM_CTX(ctx->client->ts);
 
 #if DBG_EVENTS
        fprintf(stderr, "E");
@@ -185,7 +161,7 @@ static ZEND_RESULT_CODE php_http_client_curl_user_exec(void *context)
        php_http_client_curl_loop(ctx->client, CURL_SOCKET_TIMEOUT, 0);
 
        do {
-               if (SUCCESS != php_http_object_method_call(&ctx->send, ctx->user, NULL, 0, NULL TSRMLS_CC)) {
+               if (SUCCESS != php_http_object_method_call(&ctx->send, &ctx->user, NULL, 0, NULL)) {
                        return FAILURE;
                }
        } while (curl->unfinished && !EG(exception));
@@ -198,8 +174,7 @@ static void *php_http_client_curl_user_init(php_http_client_t *client, void *use
        php_http_client_curl_t *curl = client->ctx;
        php_http_client_curl_user_context_t *ctx;
        php_http_object_method_t init;
-       zval *zclosure, **args[1];
-       TSRMLS_FETCH_FROM_CTX(client->ts);
+       zval args[1], *zclosure = &args[0];
 
 #if DBG_EVENTS
        fprintf(stderr, "I");
@@ -207,32 +182,25 @@ static void *php_http_client_curl_user_init(php_http_client_t *client, void *use
 
        ctx = ecalloc(1, sizeof(*ctx));
        ctx->client = client;
-       ctx->user = user_data;
-       Z_ADDREF_P(ctx->user);
+       ZVAL_COPY(&ctx->user, user_data);
 
        memset(&ctx->closure, 0, sizeof(ctx->closure));
        ctx->closure.common.type = ZEND_INTERNAL_FUNCTION;
-       ctx->closure.common.function_name = "php_http_client_curl_user_handler";
+       ctx->closure.common.function_name = zend_string_init(ZEND_STRL("php_http_client_curl_user_handler"), 0);
        ctx->closure.internal_function.handler = php_http_client_curl_user_handler;
 
-       MAKE_STD_ZVAL(zclosure);
-#if PHP_VERSION_ID >= 50400
-       zend_create_closure(zclosure, &ctx->closure, NULL, NULL TSRMLS_CC);
-#else
-       zend_create_closure(zclosure, &ctx->closure TSRMLS_CC);
-#endif
-       args[0] = &zclosure;
+       zend_create_closure(zclosure, &ctx->closure, NULL, NULL, NULL);
 
-       php_http_object_method_init(&init, ctx->user, ZEND_STRL("init") TSRMLS_CC);
-       php_http_object_method_call(&init, ctx->user, NULL, 1, args TSRMLS_CC);
+       php_http_object_method_init(&init, &ctx->user, ZEND_STRL("init"));
+       php_http_object_method_call(&init, &ctx->user, NULL, 1, args);
        php_http_object_method_dtor(&init);
-       zval_ptr_dtor(&zclosure);
+       zval_ptr_dtor(zclosure);
 
-       php_http_object_method_init(&ctx->timer, ctx->user, ZEND_STRL("timer") TSRMLS_CC);
-       php_http_object_method_init(&ctx->socket, ctx->user, ZEND_STRL("socket") TSRMLS_CC);
-       php_http_object_method_init(&ctx->once, ctx->user, ZEND_STRL("once") TSRMLS_CC);
-       php_http_object_method_init(&ctx->wait, ctx->user, ZEND_STRL("wait") TSRMLS_CC);
-       php_http_object_method_init(&ctx->send, ctx->user, ZEND_STRL("send") TSRMLS_CC);
+       php_http_object_method_init(&ctx->timer, &ctx->user, ZEND_STRL("timer"));
+       php_http_object_method_init(&ctx->socket, &ctx->user, ZEND_STRL("socket"));
+       php_http_object_method_init(&ctx->once, &ctx->user, ZEND_STRL("once"));
+       php_http_object_method_init(&ctx->wait, &ctx->user, ZEND_STRL("wait"));
+       php_http_object_method_init(&ctx->send, &ctx->user, ZEND_STRL("send"));
 
        curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETDATA, ctx);
        curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETFUNCTION, php_http_client_curl_user_socket);
@@ -264,6 +232,7 @@ static void php_http_client_curl_user_dtor(void **context)
        php_http_object_method_dtor(&ctx->wait);
        php_http_object_method_dtor(&ctx->send);
 
+       zend_string_release(ctx->closure.common.function_name);
        zval_ptr_dtor(&ctx->user);
 
        efree(ctx);
@@ -283,7 +252,12 @@ php_http_client_curl_ops_t *php_http_client_curl_user_ops_get()
        return &php_http_client_curl_user_ops;
 }
 
-zend_class_entry *php_http_client_curl_user_class_entry;
+static zend_class_entry *php_http_client_curl_user_class_entry;
+
+zend_class_entry *php_http_client_curl_user_get_class_entry()
+{
+       return php_http_client_curl_user_class_entry;
+}
 
 ZEND_BEGIN_ARG_INFO_EX(ai_init, 0, 0, 1)
        /* using IS_CALLABLE type hint would create a forwards compatibility break */
@@ -297,11 +271,10 @@ ZEND_BEGIN_ARG_INFO_EX(ai_timer, 0, 0, 1)
 #endif
 ZEND_END_ARG_INFO();
 ZEND_BEGIN_ARG_INFO_EX(ai_socket, 0, 0, 2)
+       ZEND_ARG_INFO(0, socket)
 #if PHP_VERSION_ID >= 70000
-       ZEND_ARG_TYPE_INFO(0, socket, IS_RESOURCE, 0)
        ZEND_ARG_TYPE_INFO(0, action, IS_LONG, 0)
 #else
-       ZEND_ARG_INFO(0, socket)
        ZEND_ARG_INFO(0, action)
 #endif
 ZEND_END_ARG_INFO();
@@ -332,13 +305,13 @@ PHP_MINIT_FUNCTION(http_client_curl_user)
        zend_class_entry ce = {0};
 
        INIT_NS_CLASS_ENTRY(ce, "http\\Client\\Curl", "User", php_http_client_curl_user_methods);
-       php_http_client_curl_user_class_entry = zend_register_internal_interface(&ce TSRMLS_CC);
+       php_http_client_curl_user_class_entry = zend_register_internal_interface(&ce);
 
-       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_NONE"), CURL_POLL_NONE TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_IN"), CURL_POLL_IN TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_OUT"), CURL_POLL_OUT TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_INOUT"), CURL_POLL_INOUT TSRMLS_CC);
-       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_REMOVE"), CURL_POLL_REMOVE TSRMLS_CC);
+       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_NONE"), CURL_POLL_NONE);
+       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_IN"), CURL_POLL_IN);
+       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_OUT"), CURL_POLL_OUT);
+       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_INOUT"), CURL_POLL_INOUT);
+       zend_declare_class_constant_long(php_http_client_curl_user_class_entry, ZEND_STRL("POLL_REMOVE"), CURL_POLL_REMOVE);
 
        return SUCCESS;
 }
index e731f41..39364be 100644 (file)
     +--------------------------------------------------------------------+
 */
 
+#ifndef PHP_HTTP_CLIENT_CURL_USER_H
+#define PHP_HTTP_CLIENT_CURL_USER_H
+
 #if PHP_HTTP_HAVE_CURL
 
-PHP_HTTP_API zend_class_entry *php_http_client_curl_user_class_entry;
+typedef struct php_http_client_curl_user_context {
+       php_http_client_t *client;
+       zval user;
+       zend_function closure;
+       php_http_object_method_t timer;
+       php_http_object_method_t socket;
+       php_http_object_method_t once;
+       php_http_object_method_t wait;
+       php_http_object_method_t send;
+} php_http_client_curl_user_context_t;
+
+PHP_HTTP_API zend_class_entry *php_http_client_curl_user_get_class_entry();
 PHP_HTTP_API php_http_client_curl_ops_t *php_http_client_curl_user_ops_get();
 PHP_MINIT_FUNCTION(http_client_curl_user);
 
@@ -79,6 +93,8 @@ interface http\Client\Curl\User
 }
 #endif
 
+#endif
+
 /*
  * Local variables:
  * tab-width: 4
index 01e02b9..de7c0ff 100644 (file)
 
 #include "php_http_api.h"
 
-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(zval *this_ptr, zval *opts TSRMLS_DC);
-void php_http_client_options_get_subr(zval *this_ptr, char *key, size_t len, zval *return_value TSRMLS_DC);
+static zend_class_entry *php_http_client_request_class_entry;
+zend_class_entry *php_http_get_client_request_class_entry(void)
+{
+       return php_http_client_request_class_entry;
+}
+
+void php_http_client_options_set_subr(zval *this_ptr, char *key, size_t len, zval *opts, int overwrite);
+void php_http_client_options_set(zval *this_ptr, zval *opts);
+void php_http_client_options_get_subr(zval *this_ptr, char *key, size_t len, zval *return_value);
 
 #define PHP_HTTP_CLIENT_REQUEST_OBJECT_INIT(obj) \
        do { \
                if (!obj->message) { \
-                       obj->message = php_http_message_init(NULL, PHP_HTTP_REQUEST, NULL TSRMLS_CC); \
+                       obj->message = php_http_message_init(NULL, PHP_HTTP_REQUEST, NULL); \
                } \
        } while(0)
 
@@ -32,28 +38,28 @@ ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientRequest, __construct)
 {
        char *meth_str = NULL;
-       int meth_len = 0;
+       size_t meth_len = 0;
        zval *zheaders = NULL, *zbody = NULL, *zurl = NULL;
        php_http_message_object_t *obj;
 
-       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!z!a!O!", &meth_str, &meth_len, &zurl, &zheaders, &zbody, php_http_message_body_class_entry), invalid_arg, return);
+       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s!z!a!O!", &meth_str, &meth_len, &zurl, &zheaders, &zbody, php_http_get_message_body_class_entry()), invalid_arg, return);
 
-       obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+       obj = PHP_HTTP_OBJ(NULL, getThis());
 
        if (obj->message) {
                php_http_message_set_type(obj->message, PHP_HTTP_REQUEST);
        } else {
-               obj->message = php_http_message_init(NULL, PHP_HTTP_REQUEST, NULL TSRMLS_CC);
+               obj->message = php_http_message_init(NULL, PHP_HTTP_REQUEST, NULL);
        }
 
        if (zbody) {
-               php_http_expect(SUCCESS == php_http_message_object_set_body(obj, zbody TSRMLS_CC), unexpected_val, return);
+               php_http_expect(SUCCESS == php_http_message_object_set_body(obj, zbody), unexpected_val, return);
        }
        if (meth_str && meth_len) {
                PHP_HTTP_INFO(obj->message).request.method = estrndup(meth_str, meth_len);
        }
        if (zurl) {
-               PHP_HTTP_INFO(obj->message).request.url = php_http_url_from_zval(zurl, PHP_HTTP_URL_STDFLAGS TSRMLS_CC);
+               PHP_HTTP_INFO(obj->message).request.url = php_http_url_from_zval(zurl, PHP_HTTP_URL_STDFLAGS);
        }
        if (zheaders) {
                array_copy(Z_ARRVAL_P(zheaders), &obj->message->hdrs);
@@ -65,25 +71,22 @@ ZEND_BEGIN_ARG_INFO_EX(ai_HttpClientRequest_setContentType, 0, 0, 1)
 ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientRequest, setContentType)
 {
-       char *ct_str;
-       int ct_len;
+       zend_string *ct_str;
        php_http_message_object_t *obj;
-       zval *zct;
+       zval zct;
 
-       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), invalid_arg, return);
 
-       if (ct_len && !strchr(ct_str, '/')) {
-               php_http_throw(unexpected_val, "Content type \"%s\" does not seem to contain a primary and a secondary part", ct_str);
+       if (ct_str->len && !strchr(ct_str->val, '/')) {
+               php_http_throw(unexpected_val, "Content type \"%s\" does not seem to contain a primary and a secondary part", ct_str->val);
                return;
        }
 
-       obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+       obj = PHP_HTTP_OBJ(NULL, getThis());
        PHP_HTTP_CLIENT_REQUEST_OBJECT_INIT(obj);
 
-       MAKE_STD_ZVAL(zct);
-       ZVAL_STRINGL(zct, ct_str, ct_len, 1);
-       zend_hash_update(&obj->message->hdrs, "Content-Type", sizeof("Content-Type"), (void *) &zct, sizeof(void *), NULL);
+       ZVAL_STR_COPY(&zct, ct_str);
+       zend_hash_str_update(&obj->message->hdrs, "Content-Type", lenof("Content-Type"), &zct);
 
        RETVAL_ZVAL(getThis(), 1, 0);
 }
@@ -93,15 +96,15 @@ ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientRequest, getContentType)
 {
        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());
                zval *zct;
 
                PHP_HTTP_CLIENT_REQUEST_OBJECT_INIT(obj);
 
                php_http_message_update_headers(obj->message);
-               zct = php_http_message_header(obj->message, ZEND_STRL("Content-Type"), 1);
+               zct = php_http_message_header(obj->message, ZEND_STRL("Content-Type"));
                if (zct) {
-                       RETURN_ZVAL(zct, 0, 1);
+                       RETURN_ZVAL(zct, 1, 0);
                }
        }
 }
@@ -111,30 +114,25 @@ ZEND_BEGIN_ARG_INFO_EX(ai_HttpClientRequest_setQuery, 0, 0, 0)
 ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientRequest, setQuery)
 {
-       zval *qdata = NULL;
+       zval *qdata = NULL, arr, str;
        php_http_message_object_t *obj;
        php_http_url_t *old_url = NULL, new_url = {NULL};
-       char empty[] = "";
        unsigned flags = PHP_HTTP_URL_REPLACE;
 
-       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!", &qdata), invalid_arg, return);
-
-       obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z!", &qdata), invalid_arg, return);
 
+       obj = PHP_HTTP_OBJ(NULL, getThis());
        PHP_HTTP_CLIENT_REQUEST_OBJECT_INIT(obj);
 
+       ZVAL_NULL(&str);
        if (qdata) {
-               zval arr, str;
-
-               INIT_PZVAL(&arr);
                array_init(&arr);
-               INIT_PZVAL(&str);
-               ZVAL_NULL(&str);
 
-               php_http_expect(SUCCESS == php_http_querystring_update(&arr, qdata, &str TSRMLS_CC), bad_querystring,
+               php_http_expect(SUCCESS == php_http_querystring_update(&arr, qdata, &str), bad_querystring,
                                zval_dtor(&arr);
                                return;
                );
+
                new_url.query = Z_STRVAL(str);
                zval_dtor(&arr);
        } else {
@@ -145,14 +143,12 @@ static PHP_METHOD(HttpClientRequest, setQuery)
                old_url = obj->message->http.info.request.url;
        }
 
-       obj->message->http.info.request.url = php_http_url_mod(old_url, &new_url, flags TSRMLS_CC);
+       obj->message->http.info.request.url = php_http_url_mod(old_url, &new_url, flags);
 
        if (old_url) {
                php_http_url_free(&old_url);
        }
-       if (new_url.query != &empty[0]) {
-               PTR_FREE(new_url.query);
-       }
+       zval_ptr_dtor(&str);
 
        RETVAL_ZVAL(getThis(), 1, 0);
 }
@@ -162,12 +158,12 @@ ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientRequest, getQuery)
 {
        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_CLIENT_REQUEST_OBJECT_INIT(obj);
 
                if (obj->message->http.info.request.url && obj->message->http.info.request.url->query) {
-                       RETVAL_STRING(obj->message->http.info.request.url->query, 1);
+                       RETVAL_STRING(obj->message->http.info.request.url->query);
                }
        }
 }
@@ -181,18 +177,15 @@ static PHP_METHOD(HttpClientRequest, addQuery)
        php_http_message_object_t *obj;
        php_http_url_t *old_url = NULL, new_url = {NULL};
 
-       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &qdata), invalid_arg, return);
-
-       obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z", &qdata), invalid_arg, return);
 
+       obj = PHP_HTTP_OBJ(NULL, getThis());
        PHP_HTTP_CLIENT_REQUEST_OBJECT_INIT(obj);
 
-       INIT_PZVAL(&arr);
        array_init(&arr);
-       INIT_PZVAL(&str);
        ZVAL_NULL(&str);
 
-       php_http_expect(SUCCESS == php_http_querystring_update(&arr, qdata, &str TSRMLS_CC), bad_querystring,
+       php_http_expect(SUCCESS == php_http_querystring_update(&arr, qdata, &str), bad_querystring,
                        zval_dtor(&arr);
                        return;
        );
@@ -203,12 +196,12 @@ static PHP_METHOD(HttpClientRequest, addQuery)
                old_url = obj->message->http.info.request.url;
        }
 
-       obj->message->http.info.request.url = php_http_url_mod(old_url, &new_url, PHP_HTTP_URL_JOIN_QUERY TSRMLS_CC);
+       obj->message->http.info.request.url = php_http_url_mod(old_url, &new_url, PHP_HTTP_URL_JOIN_QUERY);
 
        if (old_url) {
                php_http_url_free(&old_url);
        }
-       PTR_FREE(new_url.query);
+       zval_ptr_dtor(&str);
 
        RETVAL_ZVAL(getThis(), 1, 0);
 }
@@ -220,9 +213,9 @@ static PHP_METHOD(HttpClientRequest, setOptions)
 {
        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);
 }
@@ -232,7 +225,7 @@ ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientRequest, getOptions)
 {
        if (SUCCESS == zend_parse_parameters_none()) {
-               zval *zoptions = zend_read_property(php_http_client_request_class_entry, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
+               zval tmp, *zoptions = zend_read_property(php_http_client_request_class_entry, getThis(), ZEND_STRL("options"), 0, &tmp);
                RETURN_ZVAL(zoptions, 1, 0);
        }
 }
@@ -244,9 +237,9 @@ static PHP_METHOD(HttpClientRequest, setSslOptions)
 {
        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);
 }
@@ -258,9 +251,9 @@ static PHP_METHOD(HttpClientRequest, addSslOptions)
 {
        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);
 }
@@ -270,7 +263,7 @@ ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientRequest, 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);
        }
 }
 
@@ -289,16 +282,14 @@ static zend_function_entry php_http_client_request_methods[] = {
        EMPTY_FUNCTION_ENTRY
 };
 
-zend_class_entry *php_http_client_request_class_entry;
-
 PHP_MINIT_FUNCTION(http_client_request)
 {
        zend_class_entry ce = {0};
 
        INIT_NS_CLASS_ENTRY(ce, "http\\Client", "Request", php_http_client_request_methods);
-       php_http_client_request_class_entry = zend_register_internal_class_ex(&ce, php_http_message_class_entry, NULL TSRMLS_CC);
+       php_http_client_request_class_entry = zend_register_internal_class_ex(&ce, php_http_message_get_class_entry());
 
-       zend_declare_property_null(php_http_client_request_class_entry, ZEND_STRL("options"), ZEND_ACC_PROTECTED TSRMLS_CC);
+       zend_declare_property_null(php_http_client_request_class_entry, ZEND_STRL("options"), ZEND_ACC_PROTECTED);
 
        return SUCCESS;
 }
index 474114b..aee4da5 100644 (file)
@@ -13,7 +13,7 @@
 #ifndef PHP_HTTP_CLIENT_REQUEST_H
 #define PHP_HTTP_CLIENT_REQUEST_H
 
-PHP_HTTP_API zend_class_entry *php_http_client_request_class_entry;
+PHP_HTTP_API zend_class_entry *php_http_get_client_request_class_entry(void);
 PHP_MINIT_FUNCTION(http_client_request);
 
 #endif /* PHP_HTTP_CLIENT_REQUEST_H */
index 8d512ec..5acddae 100644 (file)
 
 #include "php_http_api.h"
 
+static zend_class_entry *php_http_client_response_class_entry;
+zend_class_entry *php_http_get_client_response_class_entry(void)
+{
+       return php_http_client_response_class_entry;
+}
+
 ZEND_BEGIN_ARG_INFO_EX(ai_HttpClientResponse_getCookies, 0, 0, 0)
        ZEND_ARG_INFO(0, flags)
        ZEND_ARG_INFO(0, allowed_extras)
 ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientResponse, getCookies)
 {
-       long flags = 0;
+       zend_long flags = 0;
        zval *allowed_extras_array = NULL;
        int i = 0;
        char **allowed_extras = NULL;
-       zval *header = NULL, **entry = NULL;
-       HashPosition pos;
+       zval *header = NULL, *entry = NULL;
        php_http_message_object_t *msg;
 
-       if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|la!", &flags, &allowed_extras_array)) {
+       if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "|la!/", &flags, &allowed_extras_array)) {
                return;
        }
 
-       msg = zend_object_store_get_object(getThis() TSRMLS_CC);
+       msg = PHP_HTTP_OBJ(NULL, getThis());
        array_init(return_value);
 
        if (allowed_extras_array) {
+               /* FIXME: use zend_string** instead of char** */
                allowed_extras = ecalloc(zend_hash_num_elements(Z_ARRVAL_P(allowed_extras_array)) + 1, sizeof(char *));
-               FOREACH_VAL(pos, allowed_extras_array, entry) {
-                       zval *data = php_http_ztyp(IS_STRING, *entry);
-                       allowed_extras[i++] = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
-                       zval_ptr_dtor(&data);
+               ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(allowed_extras_array), entry)
+               {
+                       zend_string *zs = zval_get_string(entry);
+                       allowed_extras[i++] = estrndup(zs->val, zs->len);
+                       zend_string_release(zs);
                }
+               ZEND_HASH_FOREACH_END();
        }
 
-       if ((header = php_http_message_header(msg->message, ZEND_STRL("Set-Cookie"), 0))) {
+       if ((header = php_http_message_header(msg->message, ZEND_STRL("Set-Cookie")))) {
                php_http_cookie_list_t *list;
 
                if (Z_TYPE_P(header) == IS_ARRAY) {
-                       zval **single_header;
+                       zval *single_header;
 
-                       FOREACH_VAL(pos, header, single_header) {
-                               zval *data = php_http_ztyp(IS_STRING, *single_header);
+                       ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(header), single_header)
+                       {
+                               zend_string *zs = zval_get_string(single_header);
 
-                               if ((list = php_http_cookie_list_parse(NULL, Z_STRVAL_P(data), Z_STRLEN_P(data), flags, allowed_extras TSRMLS_CC))) {
-                                       zval *cookie;
+                               if ((list = php_http_cookie_list_parse(NULL, zs->val, zs->len, flags, allowed_extras))) {
+                                       zval cookie;
 
-                                       MAKE_STD_ZVAL(cookie);
-                                       ZVAL_OBJVAL(cookie, php_http_cookie_object_new_ex(php_http_cookie_class_entry, list, NULL TSRMLS_CC), 0);
-                                       add_next_index_zval(return_value, cookie);
+                                       ZVAL_OBJ(&cookie, &php_http_cookie_object_new_ex(php_http_cookie_get_class_entry(), list)->zo);
+                                       add_next_index_zval(return_value, &cookie);
                                }
-                               zval_ptr_dtor(&data);
+                               zend_string_release(zs);
                        }
+                       ZEND_HASH_FOREACH_END();
                } else {
-                       zval *data = php_http_ztyp(IS_STRING, header);
-                       if ((list = php_http_cookie_list_parse(NULL, Z_STRVAL_P(data), Z_STRLEN_P(data), flags, allowed_extras TSRMLS_CC))) {
-                               zval *cookie;
+                       zend_string *zs = zval_get_string(header);
 
-                               MAKE_STD_ZVAL(cookie);
-                               ZVAL_OBJVAL(cookie, php_http_cookie_object_new_ex(php_http_cookie_class_entry, list, NULL TSRMLS_CC), 0);
-                               add_next_index_zval(return_value, cookie);
+                       if ((list = php_http_cookie_list_parse(NULL, zs->val, zs->len, flags, allowed_extras))) {
+                               zval cookie;
+
+                               ZVAL_OBJ(&cookie, &php_http_cookie_object_new_ex(php_http_cookie_get_class_entry(), list)->zo);
+                               add_next_index_zval(return_value, &cookie);
                        }
-                       zval_ptr_dtor(&data);
+                       zend_string_release(zs);
                }
-               zval_ptr_dtor(&header);
        }
 
        if (allowed_extras) {
@@ -88,12 +96,12 @@ ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpClientResponse, getTransferInfo)
 {
        char *info_name = NULL;
-       int info_len = 0;
-       zval *info;
+       size_t info_len = 0;
+       zval info_tmp, info_name_tmp, *info;
 
-       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &info_name, &info_len), invalid_arg, return);
+       php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &info_name, &info_len), invalid_arg, return);
 
-       info = zend_read_property(php_http_client_response_class_entry, getThis(), ZEND_STRL("transferInfo"), 0 TSRMLS_CC);
+       info = zend_read_property(php_http_client_response_class_entry, getThis(), ZEND_STRL("transferInfo"), 0, &info_tmp);
 
        /* request completed? */
        if (Z_TYPE_P(info) != IS_OBJECT) {
@@ -102,7 +110,7 @@ static PHP_METHOD(HttpClientResponse, getTransferInfo)
        }
 
        if (info_len && info_name) {
-               info = zend_read_property(NULL, info, php_http_pretty_key(info_name, info_len, 0, 0), info_len, 0 TSRMLS_CC);
+               info = zend_read_property(NULL, info, php_http_pretty_key(info_name, info_len, 0, 0), info_len, 0, &info_name_tmp);
 
                if (!info) {
                        php_http_throw(unexpected_val, "Could not find transfer info with name '%s'", info_name);
@@ -119,15 +127,14 @@ static zend_function_entry php_http_client_response_methods[] = {
        EMPTY_FUNCTION_ENTRY
 };
 
-zend_class_entry *php_http_client_response_class_entry;
-
 PHP_MINIT_FUNCTION(http_client_response)
 {
        zend_class_entry ce = {0};
 
        INIT_NS_CLASS_ENTRY(ce, "http\\Client", "Response", php_http_client_response_methods);
-       php_http_client_response_class_entry = zend_register_internal_class_ex(&ce, php_http_message_class_entry, NULL TSRMLS_CC);
-       zend_declare_property_null(php_http_client_response_class_entry, ZEND_STRL("transferInfo"), ZEND_ACC_PROTECTED TSRMLS_CC);
+       php_http_client_response_class_entry = zend_register_internal_class_ex(&ce, php_http_message_get_class_entry());
+
+       zend_declare_property_null(php_http_client_response_class_entry, ZEND_STRL("transferInfo"), ZEND_ACC_PROTECTED);
 
        return SUCCESS;
 }
index 15d004e..7a47cbe 100644 (file)
@@ -13,7 +13,7 @@
 #ifndef PHP_HTTP_CLIENT_RESPONSE_H
 #define PHP_HTTP_CLIENT_RESPONSE_H
 
-PHP_HTTP_API zend_class_entry *php_http_client_response_class_entry;
+PHP_HTTP_API zend_class_entry *php_http_get_client_response_class_entry(void);
 PHP_MINIT_FUNCTION(http_client_response);
 
 #endif /* PHP_HTTP_CLIENT_RESPONSE_H */
index 354dfa6..2e29433 100644 (file)
@@ -12,7 +12,7 @@
 
 #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));
@@ -27,16 +27,12 @@ php_http_cookie_list_t *php_http_cookie_list_init(php_http_cookie_list_t *list T
        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);
@@ -72,132 +68,135 @@ void php_http_cookie_list_free(php_http_cookie_list_t **list)
        }
 }
 
-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(&params, 10, NULL, ZVAL_PTR_DTOR, 0);
-       php_http_params_parse(&params, &opts TSRMLS_CC);
+       php_http_params_parse(&params, &opts);
        efree(opts.input.str);
 
-       list = php_http_cookie_list_init(list TSRMLS_CC);
-       FOREACH_HASH_KEYVAL(pos1, &params, 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(&params, 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(&params);
 
        return list;
@@ -205,81 +204,87 @@ php_http_cookie_list_t *php_http_cookie_list_parse(php_http_cookie_list_t *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;
@@ -287,40 +292,39 @@ php_http_cookie_list_t *php_http_cookie_list_from_struct(php_http_cookie_list_t
 
 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);
@@ -329,23 +333,25 @@ void php_http_cookie_list_to_string(php_http_cookie_list_t *list, char **str, si
                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; ");
@@ -360,63 +366,64 @@ void php_http_cookie_list_to_string(php_http_cookie_list_t *list, char **str, si
 }
 
 
+static zend_class_entry *php_http_cookie_class_entry;
+zend_class_entry *php_http_cookie_get_class_entry(void)
+{
+       return php_http_cookie_class_entry;
+}
 
 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(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)
 {
-       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)
@@ -428,37 +435,38 @@ static PHP_METHOD(HttpCookie, __construct)
 {
        php_http_cookie_object_t *obj;
        zval *zcookie = NULL;
-       long flags = 0;
+       zend_long flags = 0;
        char **ae = NULL;
        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_get_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);
@@ -467,13 +475,13 @@ static PHP_METHOD(HttpCookie, __construct)
                                }
                                /* 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;
                        }
                }
@@ -487,7 +495,7 @@ static PHP_METHOD(HttpCookie, __construct)
                        efree(ae);
                }
        }
-       zend_restore_error_handling(&zeh TSRMLS_CC);
+       zend_restore_error_handling(&zeh);
 
        PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 }
@@ -502,11 +510,11 @@ static PHP_METHOD(HttpCookie, getCookies)
                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));
 }
 
@@ -518,9 +526,9 @@ static PHP_METHOD(HttpCookie, setCookies)
        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);
 
@@ -529,7 +537,7 @@ static PHP_METHOD(HttpCookie, setCookies)
                array_copy_strings(cookies, &obj->list->cookies);
        }
 
-       RETVAL_ZVAL(getThis(), 1, 0);
+       RETURN_ZVAL(getThis(), 1, 0);
 }
 
 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addCookies, 0, 0, 1)
@@ -540,9 +548,9 @@ static PHP_METHOD(HttpCookie, addCookies)
        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);
 
@@ -561,11 +569,11 @@ static PHP_METHOD(HttpCookie, getExtras)
                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));
 }
 
@@ -577,9 +585,9 @@ static PHP_METHOD(HttpCookie, setExtras)
        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);
 
@@ -599,9 +607,9 @@ static PHP_METHOD(HttpCookie, addExtras)
        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);
 
@@ -616,20 +624,20 @@ ZEND_END_ARG_INFO();
 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(&zvalue, 1, 0);
        }
 }
 
@@ -640,12 +648,12 @@ ZEND_END_ARG_INFO();
 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);
 
@@ -665,12 +673,12 @@ ZEND_END_ARG_INFO();
 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);
 
@@ -685,20 +693,20 @@ ZEND_END_ARG_INFO();
 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(&zvalue, 1, 0);
        }
 }
 
@@ -709,12 +717,12 @@ ZEND_END_ARG_INFO();
 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);
 
@@ -734,12 +742,12 @@ ZEND_END_ARG_INFO();
 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);
 
@@ -758,12 +766,12 @@ static PHP_METHOD(HttpCookie, getDomain)
                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);
        }
 }
 
@@ -773,12 +781,12 @@ ZEND_END_ARG_INFO();
 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);
 
@@ -797,12 +805,12 @@ static PHP_METHOD(HttpCookie, getPath)
                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);
        }
 }
 
@@ -812,12 +820,12 @@ ZEND_END_ARG_INFO();
 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);
 
@@ -836,7 +844,7 @@ static PHP_METHOD(HttpCookie, getExpires)
                return;
        }
 
-       obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+       obj = PHP_HTTP_OBJ(NULL, getThis());
 
        PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 
@@ -848,12 +856,12 @@ ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setExpires, 0, 0, 0)
 ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpCookie, setExpires)
 {
-       long ts = -1;
+       zend_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);
 
@@ -872,7 +880,7 @@ static PHP_METHOD(HttpCookie, getMaxAge)
                return;
        }
 
-       obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+       obj = PHP_HTTP_OBJ(NULL, getThis());
 
        PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 
@@ -884,16 +892,16 @@ ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setMaxAge, 0, 0, 0)
 ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpCookie, setMaxAge)
 {
-       long ts = -1;
+       zend_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);
 }
@@ -908,7 +916,7 @@ static PHP_METHOD(HttpCookie, getFlags)
                return;
        }
 
-       obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+       obj = PHP_HTTP_OBJ(NULL, getThis());
 
        PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 
@@ -920,12 +928,12 @@ ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setFlags, 0, 0, 0)
 ZEND_END_ARG_INFO();
 static PHP_METHOD(HttpCookie, setFlags)
 {
-       long flags = 0;
+       zend_long flags = 0;
        php_http_cookie_object_t *obj;
 
-       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());
 
        PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 
@@ -946,13 +954,13 @@ static PHP_METHOD(HttpCookie, toString)
                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)
@@ -965,11 +973,11 @@ static PHP_METHOD(HttpCookie, toArray)
                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);
 }
 
@@ -1007,21 +1015,21 @@ static zend_function_entry php_http_cookie_methods[] = {
        EMPTY_FUNCTION_ENTRY
 };
 
-zend_class_entry *php_http_cookie_class_entry;
-
 PHP_MINIT_FUNCTION(http_cookie)
 {
        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);
-       zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("HTTPONLY"), PHP_HTTP_COOKIE_HTTPONLY TSRMLS_CC);
+       zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("PARSE_RAW"), PHP_HTTP_COOKIE_PARSE_RAW);
+       zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("SECURE"), PHP_HTTP_COOKIE_SECURE);
+       zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("HTTPONLY"), PHP_HTTP_COOKIE_HTTPONLY);
 
        return SUCCESS;
 }
index 7cf00fe..e7b924e 100644 (file)
@@ -31,44 +31,39 @@ typedef struct php_http_cookie_list {
        char *domain;
        time_t expires;
        time_t max_age;
-
-#ifdef ZTS
-       void ***ts;
-#endif
 } php_http_cookie_list_t;
 
-PHP_HTTP_API php_http_cookie_list_t *php_http_cookie_list_init(php_http_cookie_list_t *list TSRMLS_DC);
-PHP_HTTP_API 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_API php_http_cookie_list_t *php_http_cookie_list_init(php_http_cookie_list_t *list);
+PHP_HTTP_API 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_API php_http_cookie_list_t *php_http_cookie_list_copy(php_http_cookie_list_t *from, php_http_cookie_list_t *to);
 PHP_HTTP_API void php_http_cookie_list_dtor(php_http_cookie_list_t *list);
 PHP_HTTP_API void php_http_cookie_list_free(php_http_cookie_list_t **list);
 
-#define php_http_cookie_list_has_cookie(list, name, name_len) zend_symtable_exists(&(list)->cookies, (name), (name_len)+1)
-#define php_http_cookie_list_del_cookie(list, name, name_len) zend_symtable_del(&(list)->cookies, (name), (name_len)+1)
+#define php_http_cookie_list_has_cookie(list, name, name_len) zend_symtable_str_exists(&(list)->cookies, (name), (name_len))
+#define php_http_cookie_list_del_cookie(list, name, name_len) zend_symtable_str_del(&(list)->cookies, (name), (name_len))
 PHP_HTTP_API 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);
-PHP_HTTP_API const char *php_http_cookie_list_get_cookie(php_http_cookie_list_t *list, const char *name, size_t name_len, zval **cookie);
+PHP_HTTP_API const char *php_http_cookie_list_get_cookie(php_http_cookie_list_t *list, const char *name, size_t name_len, zval *cookie);
 
-#define php_http_cookie_list_has_extra(list, name, name_len) zend_symtable_exists(&(list)->extras, (name), (name_len)+1)
-#define php_http_cookie_list_del_extra(list, name, name_len) zend_symtable_del(&(list)->extras, (name), (name_len)+1)
+#define php_http_cookie_list_has_extra(list, name, name_len) zend_symtable_str_exists(&(list)->extras, (name), (name_len))
+#define php_http_cookie_list_del_extra(list, name, name_len) zend_symtable_str_del(&(list)->extras, (name), (name_len))
 PHP_HTTP_API 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);
-PHP_HTTP_API const char *php_http_cookie_list_get_extra(php_http_cookie_list_t *list, const char *name, size_t name_len, zval **extra);
+PHP_HTTP_API const char *php_http_cookie_list_get_extra(php_http_cookie_list_t *list, const char *name, size_t name_len, zval *extra);
 
 PHP_HTTP_API void php_http_cookie_list_to_string(php_http_cookie_list_t *list, char **str, size_t *len);
-PHP_HTTP_API php_http_cookie_list_t *php_http_cookie_list_from_struct(php_http_cookie_list_t *list, zval *strct TSRMLS_DC);
+PHP_HTTP_API php_http_cookie_list_t *php_http_cookie_list_from_struct(php_http_cookie_list_t *list, zval *strct);
 PHP_HTTP_API void php_http_cookie_list_to_struct(php_http_cookie_list_t *list, zval *strct);
 
-PHP_HTTP_API zend_class_entry *php_http_cookie_class_entry;
+PHP_HTTP_API zend_class_entry *php_http_cookie_get_class_entry(void);
 
 typedef struct php_http_cookie_object {
-       zend_object zo;
-       zend_object_value zv;
        php_http_cookie_list_t *list;
+       zend_object zo;
 } php_http_cookie_object_t;
 
-zend_object_value php_http_cookie_object_new(zend_class_entry *ce TSRMLS_DC);
-zend_object_value php_http_cookie_object_new_ex(zend_class_entry *ce, php_http_cookie_list_t *list, php_http_cookie_object_t **obj TSRMLS_DC);
-zend_object_value php_http_cookie_object_clone(zval *this_ptr TSRMLS_DC);
-void php_http_cookie_object_free(void *object TSRMLS_DC);
+zend_object *php_http_cookie_object_new(zend_class_entry *ce);
+php_http_cookie_object_t *php_http_cookie_object_new_ex(zend_class_entry *ce, php_http_cookie_list_t *list);
+zend_object *php_http_cookie_object_clone(zval *this_ptr);
+void php_http_cookie_object_free(zend_object *object);
 
 PHP_MINIT_FUNCTION(http_cookie);
 
index 286f2b5..7fbe7c7 100644 (file)
@@ -28,7 +28,7 @@ static inline int eol_match(char **line, int *eol_len)
        }
 }
 
-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;
@@ -50,13 +50,13 @@ const char *php_http_encoding_dechunk(const char *encoded, size_t encoded_len, c
                         * 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;
                        }
                }
@@ -79,16 +79,16 @@ const char *php_http_encoding_dechunk(const char *encoded, size_t encoded_len, c
                /* 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;
                }
 
@@ -148,7 +148,7 @@ static inline int php_http_inflate_rounds(z_stream *Z, int flush, char **buf, si
        return status;
 }
 
-ZEND_RESULT_CODE 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;
@@ -185,11 +185,11 @@ ZEND_RESULT_CODE php_http_encoding_deflate(int flags, const char *data, size_t d
                }
        }
        
-       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;
 }
 
-ZEND_RESULT_CODE 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;
@@ -227,11 +227,11 @@ retry_raw_inflate:
                }
        }
        
-       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;
 
@@ -241,7 +241,6 @@ php_http_encoding_stream_t *php_http_encoding_stream_init(php_http_encoding_stre
        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);
@@ -261,8 +260,6 @@ php_http_encoding_stream_t *php_http_encoding_stream_init(php_http_encoding_stre
 
 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;
@@ -274,7 +271,6 @@ php_http_encoding_stream_t *php_http_encoding_stream_copy(php_http_encoding_stre
 
                to->flags = from->flags;
                to->ops = from->ops;
-               TSRMLS_SET_CTX(to->ts);
 
                if ((ns = to->ops->copy(from, to))) {
                        return ns;
@@ -293,6 +289,7 @@ php_http_encoding_stream_t *php_http_encoding_stream_copy(php_http_encoding_stre
 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);
        }
@@ -367,7 +364,6 @@ static php_http_encoding_stream_t *deflate_init(php_http_encoding_stream_t *s)
 {
        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);
@@ -382,7 +378,7 @@ static php_http_encoding_stream_t *deflate_init(php_http_encoding_stream_t *s)
                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;
 }
 
@@ -390,7 +386,6 @@ static php_http_encoding_stream_t *inflate_init(php_http_encoding_stream_t *s)
 {
        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);
        
@@ -403,7 +398,7 @@ static php_http_encoding_stream_t *inflate_init(php_http_encoding_stream_t *s)
                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;
 }
 
@@ -426,7 +421,6 @@ static php_http_encoding_stream_t *deflate_copy(php_http_encoding_stream_t *from
 {
        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))) {
@@ -437,7 +431,7 @@ static php_http_encoding_stream_t *deflate_copy(php_http_encoding_stream_t *from
                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;
 }
 
@@ -445,7 +439,6 @@ static php_http_encoding_stream_t *inflate_copy(php_http_encoding_stream_t *from
 {
        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))) {
@@ -456,7 +449,7 @@ static php_http_encoding_stream_t *inflate_copy(php_http_encoding_stream_t *from
                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;
 }
 
@@ -464,7 +457,6 @@ static php_http_encoding_stream_t *dechunk_copy(php_http_encoding_stream_t *from
 {
        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;
@@ -474,7 +466,7 @@ static php_http_encoding_stream_t *dechunk_copy(php_http_encoding_stream_t *from
                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;
 }
 
@@ -482,7 +474,6 @@ static ZEND_RESULT_CODE deflate_update(php_http_encoding_stream_t *s, const char
 {
        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);
@@ -515,7 +506,7 @@ static ZEND_RESULT_CODE deflate_update(php_http_encoding_stream_t *s, const char
        
        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;
 }
 
@@ -523,7 +514,6 @@ static ZEND_RESULT_CODE inflate_update(php_http_encoding_stream_t *s, const char
 {
        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);
@@ -554,7 +544,7 @@ retry_raw_inflate:
                        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;
 }
 
@@ -562,10 +552,9 @@ static ZEND_RESULT_CODE dechunk_update(php_http_encoding_stream_t *s, const char
 {
        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)) {