- reimplement major parts of the request api
authorMichael Wallner <mike@php.net>
Sun, 11 Dec 2005 21:41:55 +0000 (21:41 +0000)
committerMichael Wallner <mike@php.net>
Sun, 11 Dec 2005 21:41:55 +0000 (21:41 +0000)
# this has not been run with a debug build or valgrind yet

17 files changed:
config.m4
config.w32
http.c
http.dsp
http_functions.c
http_headers_api.c
http_message_api.c
http_request_api.c
http_request_body_api.c [new file with mode: 0644]
http_request_object.c
http_request_pool_api.c
package2.xml
php_http.h
php_http_request_api.h
php_http_request_body_api.h [new file with mode: 0644]
php_http_request_object.h
php_http_request_pool_api.h

index 169aa15..6b79648 100644 (file)
--- a/config.m4
+++ b/config.m4
@@ -215,7 +215,7 @@ dnl ----
                http_api.c http_cache_api.c http_request_api.c http_date_api.c \
                http_headers_api.c http_message_api.c http_send_api.c http_url_api.c \
                http_info_api.c http_request_method_api.c http_encoding_api.c \
-               http_filter_api.c"
+               http_filter_api.c http_request_body_api.c"
        PHP_NEW_EXTENSION([http], $PHP_HTTP_SOURCES, $ext_shared)
        PHP_ADD_BUILD_DIR($ext_builddir/phpstr, 1)
        PHP_SUBST([HTTP_SHARED_LIBADD])
@@ -223,7 +223,7 @@ dnl ----
        PHP_HTTP_HEADERS="php_http_std_defs.h php_http.h php_http_api.h php_http_cache_api.h \
                php_http_date_api.h php_http_headers_api.h php_http_info_api.h php_http_message_api.h \
                php_http_request_api.h php_http_request_method_api.h php_http_send_api.h php_http_url_api.h \
-               php_http_encoding_api.h phpstr/phpstr.h missing.h"
+               php_http_encoding_api.h phpstr/phpstr.h missing.h php_http_request_body_api.h"
 
        ifdef([PHP_INSTALL_HEADERS], [
                PHP_INSTALL_HEADERS(ext/http, $PHP_HTTP_HEADERS)
index 9012de6..e18d586 100644 (file)
@@ -54,7 +54,7 @@ if (PHP_HTTP != "no") {
                "http_request_api.c http_date_api.c http_headers_api.c "+
                "http_message_api.c http_send_api.c http_url_api.c "+
                "http_info_api.c http_request_method_api.c http_encoding_api.c "+
-               "http_filter_api.c",
+               "http_filter_api.c http_request_body_api.c",
                null,
                "/I\"" + configure_module_dirname + "/phpstr\"");
        ADD_SOURCES(configure_module_dirname + "/phpstr", "phpstr.c", "http");
diff --git a/http.c b/http.c
index 0a75157..97587f8 100644 (file)
--- a/http.c
+++ b/http.c
@@ -162,12 +162,6 @@ static inline void http_globals_init(zend_http_globals *G)
 {
        G->send.buffer_size = HTTP_SENDBUF_SIZE;
        zend_hash_init(&G->request.methods.custom, 0, NULL, ZVAL_PTR_DTOR, 0);
-#ifdef HTTP_HAVE_CURL
-       zend_llist_init(&G->request.copies.strings, sizeof(char *), http_request_data_free_string, 0);
-       zend_llist_init(&G->request.copies.slists, sizeof(struct curl_slist *), http_request_data_free_slist, 0);
-       zend_llist_init(&G->request.copies.contexts, sizeof(http_request_callback_ctx *), http_request_data_free_context, 0);
-       zend_llist_init(&G->request.copies.convs, sizeof(http_request_conv *), http_request_data_free_conv, 0);
-#endif
 }
 
 static inline void http_globals_free(zend_http_globals *G)
@@ -175,12 +169,6 @@ static inline void http_globals_free(zend_http_globals *G)
        STR_SET(G->send.content_type, NULL);
        STR_SET(G->send.unquoted_etag, NULL);
        zend_hash_destroy(&G->request.methods.custom);
-#ifdef HTTP_HAVE_CURL
-       zend_llist_clean(&G->request.copies.strings);
-       zend_llist_clean(&G->request.copies.slists);
-       zend_llist_clean(&G->request.copies.contexts);
-       zend_llist_clean(&G->request.copies.convs);
-#endif
 }
 /* }}} */
 
index c52aec8..381ae70 100644 (file)
--- a/http.dsp
+++ b/http.dsp
@@ -110,6 +110,10 @@ SOURCE=.\http_request_api.c
 # End Source File\r
 # Begin Source File\r
 \r
+SOURCE=.\http_request_body_api.c\r
+# End Source File\r
+# Begin Source File\r
+\r
 SOURCE=.\http_request_method_api.c\r
 # End Source File\r
 # Begin Source File\r
@@ -170,6 +174,10 @@ SOURCE=.\php_http_request_api.h
 # End Source File\r
 # Begin Source File\r
 \r
+SOURCE=.\php_http_request_body_api.h\r
+# End Source File\r
+# Begin Source File\r
+\r
 SOURCE=.\php_http_request_method_api.h\r
 # End Source File\r
 # Begin Source File\r
index 5cb8a16..ade2654 100644 (file)
@@ -977,22 +977,20 @@ PHP_FUNCTION(http_match_request_header)
 /* {{{ HAVE_CURL */
 #ifdef HTTP_HAVE_CURL
 
-#define RETURN_RESPONSE_OR_BODY(response) \
+#define RETVAL_RESPONSE_OR_BODY(request) \
        { \
                zval **bodyonly; \
                 \
                /* check if only the body should be returned */ \
                if (options && (SUCCESS == zend_hash_find(Z_ARRVAL_P(options), "bodyonly", sizeof("bodyonly"), (void **) &bodyonly)) && zval_is_true(*bodyonly)) { \
-                       http_message *msg = http_message_parse(PHPSTR_VAL(&response), PHPSTR_LEN(&response)); \
+                       http_message *msg = http_message_parse(PHPSTR_VAL(&request.conv.response), PHPSTR_LEN(&request.conv.response)); \
                         \
                        if (msg) { \
                                RETVAL_STRINGL(PHPSTR_VAL(&msg->body), PHPSTR_LEN(&msg->body), 1); \
                                http_message_free(&msg); \
-                               phpstr_dtor(&response); \
-                               return; \
                        } \
                } else { \
-                       RETURN_PHPSTR_VAL(&response); \
+                       RETVAL_STRINGL(request.conv.response.data, request.conv.response.used, 1); \
                } \
        }
 
@@ -1072,7 +1070,7 @@ PHP_FUNCTION(http_get)
        zval *options = NULL, *info = NULL;
        char *URL;
        int URL_len;
-       phpstr response;
+       http_request request;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a/!z", &URL, &URL_len, &options, &info) != SUCCESS) {
                RETURN_FALSE;
@@ -1083,12 +1081,17 @@ PHP_FUNCTION(http_get)
                array_init(info);
        }
 
-       phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
-       if (SUCCESS == http_get(URL, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
-               RETURN_RESPONSE_OR_BODY(response);
+       RETVAL_FALSE;
+
+       http_request_init_ex(&request, NULL, HTTP_GET, URL);
+       if (SUCCESS == http_request_prepare(&request, options?Z_ARRVAL_P(options):NULL)) {
+               http_request_exec(&request);
+               if (info) {
+                       http_request_info(&request, Z_ARRVAL_P(info));
+               }
+               RETVAL_RESPONSE_OR_BODY(request);
        }
-       phpstr_dtor(&response);
-       RETURN_FALSE;
+       http_request_dtor(&request);
 }
 /* }}} */
 
@@ -1105,7 +1108,7 @@ PHP_FUNCTION(http_head)
        zval *options = NULL, *info = NULL;
        char *URL;
        int URL_len;
-       phpstr response;
+       http_request request;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a/!z", &URL, &URL_len, &options, &info) != SUCCESS) {
                RETURN_FALSE;
@@ -1116,12 +1119,17 @@ PHP_FUNCTION(http_head)
                array_init(info);
        }
 
-       phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
-       if (SUCCESS == http_head(URL, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
-               RETURN_RESPONSE_OR_BODY(response);
+       RETVAL_FALSE;
+
+       http_request_init_ex(&request, NULL, HTTP_HEAD, URL);
+       if (SUCCESS == http_request_prepare(&request, options?Z_ARRVAL_P(options):NULL)) {
+               http_request_exec(&request);
+               if (info) {
+                       http_request_info(&request, Z_ARRVAL_P(info));
+               }
+               RETVAL_RESPONSE_OR_BODY(request);
        }
-       phpstr_dtor(&response);
-       RETURN_FALSE;
+       http_request_dtor(&request);
 }
 /* }}} */
 
@@ -1139,8 +1147,8 @@ PHP_FUNCTION(http_post_data)
        zval *options = NULL, *info = NULL;
        char *URL, *postdata;
        int postdata_len, URL_len;
-       phpstr response;
        http_request_body body;
+       http_request request;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a/!z", &URL, &URL_len, &postdata, &postdata_len, &options, &info) != SUCCESS) {
                RETURN_FALSE;
@@ -1151,16 +1159,23 @@ PHP_FUNCTION(http_post_data)
                array_init(info);
        }
 
+       RETVAL_FALSE;
+
        body.type = HTTP_REQUEST_BODY_CSTRING;
        body.data = postdata;
        body.size = postdata_len;
 
-       phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
-       if (SUCCESS == http_post(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
-               RETURN_RESPONSE_OR_BODY(response);
+       http_request_init_ex(&request, NULL, HTTP_POST, URL);
+       request.body = &body;
+       if (SUCCESS == http_request_prepare(&request, options?Z_ARRVAL_P(options):NULL)) {
+               request.body = NULL;
+               http_request_exec(&request);
+               if (info) {
+                       http_request_info(&request, Z_ARRVAL_P(info));
+               }
+               RETVAL_RESPONSE_OR_BODY(request);
        }
-       phpstr_dtor(&response);
-       RETVAL_FALSE;
+       http_request_dtor(&request);
 }
 /* }}} */
 
@@ -1178,8 +1193,8 @@ PHP_FUNCTION(http_post_fields)
        zval *options = NULL, *info = NULL, *fields, *files = NULL;
        char *URL;
        int URL_len;
-       phpstr response;
        http_request_body body;
+       http_request request;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|aa/!z", &URL, &URL_len, &fields, &files, &options, &info) != SUCCESS) {
                RETURN_FALSE;
@@ -1194,14 +1209,21 @@ PHP_FUNCTION(http_post_fields)
                array_init(info);
        }
 
-       phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
-       if (SUCCESS == http_post(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
+       RETVAL_FALSE;
+
+       http_request_init_ex(&request, NULL, HTTP_POST, URL);
+       request.body = &body;
+       if (SUCCESS == http_request_prepare(&request, options?Z_ARRVAL_P(options):NULL)) {
+               request.body = NULL;
+               http_request_exec(&request);
                http_request_body_dtor(&body);
-               RETURN_RESPONSE_OR_BODY(response);
+               if (info) {
+                       http_request_info(&request, Z_ARRVAL_P(info));
+               }
+               RETVAL_RESPONSE_OR_BODY(request);
        }
        http_request_body_dtor(&body);
-       phpstr_dtor(&response);
-       RETURN_FALSE;
+       http_request_dtor(&request);
 }
 /* }}} */
 
@@ -1219,10 +1241,10 @@ PHP_FUNCTION(http_put_file)
        char *URL, *file;
        int URL_len, f_len;
        zval *options = NULL, *info = NULL;
-       phpstr response;
        php_stream *stream;
        php_stream_statbuf ssb;
        http_request_body body;
+       http_request request;
 
        if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a/!z", &URL, &URL_len, &file, &f_len, &options, &info)) {
                RETURN_FALSE;
@@ -1241,18 +1263,25 @@ PHP_FUNCTION(http_put_file)
                array_init(info);
        }
 
+       RETVAL_FALSE;
+
        body.type = HTTP_REQUEST_BODY_UPLOADFILE;
        body.data = stream;
        body.size = ssb.sb.st_size;
 
-       phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
-       if (SUCCESS == http_put(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
+       http_request_init_ex(&request, NULL, HTTP_PUT, URL);
+       request.body = &body;
+       if (SUCCESS == http_request_prepare(&request, options?Z_ARRVAL_P(options):NULL)) {
+               request.body = NULL;
+               http_request_exec(&request);
                http_request_body_dtor(&body);
-               RETURN_RESPONSE_OR_BODY(response);
+               if (info) {
+                       http_request_info(&request, Z_ARRVAL_P(info));
+               }
+               RETVAL_RESPONSE_OR_BODY(request);
        }
        http_request_body_dtor(&body);
-       phpstr_dtor(&response);
-       RETURN_FALSE;
+       http_request_dtor(&request);
 }
 /* }}} */
 
@@ -1271,10 +1300,10 @@ PHP_FUNCTION(http_put_stream)
        zval *resource, *options = NULL, *info = NULL;
        char *URL;
        int URL_len;
-       phpstr response;
        php_stream *stream;
        php_stream_statbuf ssb;
        http_request_body body;
+       http_request request;
 
        if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sr|a/!z", &URL, &URL_len, &resource, &options, &info)) {
                RETURN_FALSE;
@@ -1290,16 +1319,23 @@ PHP_FUNCTION(http_put_stream)
                array_init(info);
        }
 
+       RETVAL_FALSE;
+
        body.type = HTTP_REQUEST_BODY_UPLOADFILE;
        body.data = stream;
        body.size = ssb.sb.st_size;
 
-       phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
-       if (SUCCESS == http_put(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
-               RETURN_RESPONSE_OR_BODY(response);
+       http_request_init_ex(&request, NULL, HTTP_POST, URL);
+       request.body = &body;
+       if (SUCCESS == http_request_prepare(&request, options?Z_ARRVAL_P(options):NULL)) {
+               request.body = NULL;
+               http_request_exec(&request);
+               if (info) {
+                       http_request_info(&request, Z_ARRVAL_P(info));
+               }
+               RETVAL_RESPONSE_OR_BODY(request);
        }
-       phpstr_dtor(&response);
-       RETURN_FALSE;
+       http_request_dtor(&request);
 }
 /* }}} */
 #endif /* HTTP_HAVE_CURL */
index a45e282..444c8de 100644 (file)
@@ -360,7 +360,6 @@ PHP_HTTP_API STATUS _http_parse_headers_ex(const char *header, HashTable *header
        
        if (header_len) do {
                int value_len = 0;
-               /* note: valgrind may choke on that -- should be safe though */
                switch (*line++)
                {
                        case ':':
index 6b88cc5..5a2302b 100644 (file)
@@ -164,6 +164,8 @@ PHP_HTTP_API http_message *_http_message_parse_ex(http_message *msg, const char
                                MAKE_STD_ZVAL(len);
                                ZVAL_STRINGL(len, tmp, tmp_len, 0);
 
+                               ZVAL_ADDREF(c);
+                               zend_hash_add(&msg->hdrs, "X-Original-Transfer-Encoding", sizeof("X-Original-Transfer-Encoding"), (void *) &c, sizeof(zval *), NULL);
                                zend_hash_del(&msg->hdrs, "Transfer-Encoding", sizeof("Transfer-Encoding"));
                                zend_hash_del(&msg->hdrs, "Content-Length", sizeof("Content-Length"));
                                zend_hash_add(&msg->hdrs, "Content-Length", sizeof("Content-Length"), (void *) &len, sizeof(zval *), NULL);
@@ -493,6 +495,7 @@ PHP_HTTP_API STATUS _http_message_send(http_message *message TSRMLS_DC)
                {
 #ifdef HTTP_HAVE_CURL
                        char *uri = NULL;
+                       http_request request;
                        zval **zhost, options, headers;
 
                        INIT_PZVAL(&options);
@@ -523,21 +526,20 @@ PHP_HTTP_API STATUS _http_message_send(http_message *message TSRMLS_DC)
                                uri = http_absolute_uri(message->http.info.request.URI);
                        }
 
-                       if (!strcasecmp("POST", message->http.info.request.method)) {
+                       if (request.meth = http_request_method_exists(1, 0, message->http.info.request.method)) {
                                http_request_body body = {HTTP_REQUEST_BODY_CSTRING, PHPSTR_VAL(message), PHPSTR_LEN(message)};
-                               rs = http_post(uri, &body, Z_ARRVAL(options), NULL, NULL);
-                       } else
-                       if (!strcasecmp("GET", message->http.info.request.method)) {
-                               rs = http_get(uri, Z_ARRVAL(options), NULL, NULL);
-                       } else
-                       if (!strcasecmp("HEAD", message->http.info.request.method)) {
-                               rs = http_head(uri, Z_ARRVAL(options), NULL, NULL);
+                               
+                               http_request_init_ex(&request, NULL, request.meth, uri);
+                               request.body = &body;
+                               if (SUCCESS == (rs = http_request_prepare(&request, NULL))) {
+                                       http_request_exec(&request);
+                               }
+                               http_request_dtor(&request);
                        } else {
                                http_error_ex(HE_WARNING, HTTP_E_REQUEST_METHOD,
                                        "Cannot send HttpMessage. Request method %s not supported",
                                        message->http.info.request.method);
                        }
-
                        efree(uri);
 #else
                        http_error(HE_WARNING, HTTP_E_RUNTIME, "HTTP requests not supported - ext/http was not linked against libcurl.");
index 8d61558..3528d3c 100644 (file)
@@ -23,7 +23,6 @@
 
 #include "php_http_api.h"
 #include "php_http_request_api.h"
-#include "php_http_request_method_api.h"
 #include "php_http_url_api.h"
 
 #ifdef ZEND_ENGINE_2
@@ -114,8 +113,10 @@ PHP_MSHUTDOWN_FUNCTION(http_request)
                case CURLINFO_STRING: \
                { \
                        char *c; \
-                       if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_ ##I, &c)) { \
-                               add_assoc_string(&array, pretty_key(http_request_data_copy(COPY_STRING, #X), sizeof(#X)-1, 0, 0), c ? c : "", 1); \
+                       if (CURLE_OK == curl_easy_getinfo(request->ch, CURLINFO_ ##I, &c)) { \
+                               char *key = estrndup(#X, lenof(#X)); \
+                               add_assoc_string(&array, pretty_key(key, lenof(#X), 0, 0), c ? c : "", 1); \
+                               efree(key); \
                        } \
                } \
                break; \
@@ -123,8 +124,10 @@ PHP_MSHUTDOWN_FUNCTION(http_request)
                case CURLINFO_DOUBLE: \
                { \
                        double d; \
-                       if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_ ##I, &d)) { \
-                               add_assoc_double(&array, pretty_key(http_request_data_copy(COPY_STRING, #X), sizeof(#X)-1, 0, 0), d); \
+                       if (CURLE_OK == curl_easy_getinfo(request->ch, CURLINFO_ ##I, &d)) { \
+                               char *key = estrndup(#X, lenof(#X)); \
+                               add_assoc_double(&array, pretty_key(key, lenof(#X), 0, 0), d); \
+                               efree(key); \
                        } \
                } \
                break; \
@@ -132,8 +135,10 @@ PHP_MSHUTDOWN_FUNCTION(http_request)
                case CURLINFO_LONG: \
                { \
                        long l; \
-                       if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_ ##I, &l)) { \
-                               add_assoc_long(&array, pretty_key(http_request_data_copy(COPY_STRING, #X), sizeof(#X)-1, 0, 0), l); \
+                       if (CURLE_OK == curl_easy_getinfo(request->ch, CURLINFO_ ##I, &l)) { \
+                               char *key = estrndup(#X, lenof(#X)); \
+                               add_assoc_long(&array, pretty_key(key, lenof(#X), 0, 0), l); \
+                               efree(key); \
                        } \
                } \
                break; \
@@ -141,27 +146,29 @@ PHP_MSHUTDOWN_FUNCTION(http_request)
                case CURLINFO_SLIST: \
                { \
                        struct curl_slist *l, *p; \
-                       if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_ ##I, &l)) { \
+                       if (CURLE_OK == curl_easy_getinfo(request->ch, CURLINFO_ ##I, &l)) { \
                                zval *subarray; \
+                               char *key = estrndup(#X, lenof(#X)); \
                                MAKE_STD_ZVAL(subarray); \
                                array_init(subarray); \
                                for (p = l; p; p = p->next) { \
                                        add_next_index_string(subarray, p->data, 1); \
                                } \
-                               add_assoc_zval(&array, pretty_key(http_request_data_copy(COPY_STRING, #X), sizeof(#X)-1, 0, 0), subarray); \
+                               add_assoc_zval(&array, pretty_key(key, lenof(#X), 0, 0), subarray); \
                                curl_slist_free_all(l); \
+                               efree(key); \
                        } \
                } \
        }
 
-#define HTTP_CURL_OPT(OPTION, p) curl_easy_setopt(ch, CURLOPT_##OPTION, (p))
+#define HTTP_CURL_OPT(OPTION, p) curl_easy_setopt(request->ch, CURLOPT_##OPTION, (p))
 #define HTTP_CURL_OPT_STRING(keyname) HTTP_CURL_OPT_STRING_EX(keyname, keyname)
 #define HTTP_CURL_OPT_SSL_STRING(keyname) HTTP_CURL_OPT_STRING_EX(keyname, SSL##keyname)
 #define HTTP_CURL_OPT_SSL_STRING_(keyname) HTTP_CURL_OPT_STRING_EX(keyname, SSL_##keyname)
 #define HTTP_CURL_OPT_STRING_EX(keyname, optname) \
        if (!strcasecmp(key, #keyname)) { \
-               convert_to_string_ex(param); \
-               HTTP_CURL_OPT(optname, http_request_data_copy(COPY_STRING, Z_STRVAL_PP(param))); \
+               convert_to_string(*param); \
+               HTTP_CURL_OPT(optname, Z_STRVAL_PP(param)); \
                key = NULL; \
                continue; \
        }
@@ -170,375 +177,296 @@ PHP_MSHUTDOWN_FUNCTION(http_request)
 #define HTTP_CURL_OPT_SSL_LONG_(keyname) HTTP_CURL_OPT_LONG_EX(keyname, SSL_##keyname)
 #define HTTP_CURL_OPT_LONG_EX(keyname, optname) \
        if (!strcasecmp(key, #keyname)) { \
-               convert_to_long_ex(param); \
+               convert_to_long(*param); \
                HTTP_CURL_OPT(optname, Z_LVAL_PP(param)); \
                key = NULL; \
                continue; \
        }
 
-#define http_curl_getopt(o, k, t) _http_curl_getopt_ex((o), (k), sizeof(k), (t) TSRMLS_CC)
-#define http_curl_getopt_ex(o, k, l, t) _http_curl_getopt_ex((o), (k), (l), (t) TSRMLS_CC)
-static inline zval *_http_curl_getopt_ex(HashTable *options, char *key, size_t keylen, int type TSRMLS_DC);
-#define http_curl_defaults(ch) _http_curl_defaults((ch))
-static inline void _http_curl_defaults(CURL *ch);
+#define http_request_option(r, o, k, t) _http_request_option_ex((r), (o), (k), sizeof(k), (t) TSRMLS_CC)
+#define http_request_option_ex(r, o, k, l, t) _http_request_option_ex((r), (o), (k), (l), (t) TSRMLS_CC)
+static inline zval *_http_request_option_ex(http_request *request, HashTable *options, char *key, size_t keylen, int type TSRMLS_DC);
+
 static size_t http_curl_read_callback(void *, size_t, size_t, void *);
 static int http_curl_progress_callback(void *, double, double, double, double);
 static int http_curl_raw_callback(CURL *, curl_infotype, char *, size_t, void *);
 static int http_curl_dummy_callback(char *data, size_t n, size_t l, void *s) { return n*l; }
 static curlioerr http_curl_ioctl_callback(CURL *, curliocmd, void *);
 
-/* {{{ http_request_callback_ctx http_request_callback_data(void *) */
-http_request_callback_ctx *_http_request_callback_data_ex(void *data, zend_bool cpy TSRMLS_DC)
+PHP_HTTP_API http_request *_http_request_init_ex(http_request *request, CURL *ch, http_request_method meth, const char *url TSRMLS_DC)
 {
-       http_request_callback_ctx *ctx = emalloc(sizeof(http_request_callback_ctx));
-       
-       TSRMLS_SET_CTX(ctx->tsrm_ctx);
-       ctx->data = data;
+       http_request *r;
        
-       if (cpy) {
-               return http_request_data_copy(COPY_CONTEXT, ctx);
+       if (request) {
+               r = request;
        } else {
-               return ctx;
-       }
-}
-/* }}} */
-
-/* {{{ void *http_request_data_copy(int, void *) */
-void *_http_request_data_copy(int type, void *data TSRMLS_DC)
-{
-       switch (type)
-       {
-               case COPY_STRING:
-               {
-                       char *new_str = estrdup(data);
-                       zend_llist_add_element(&HTTP_G(request).copies.strings, &new_str);
-                       return new_str;
-               }
-
-               case COPY_SLIST:
-               {
-                       zend_llist_add_element(&HTTP_G(request).copies.slists, &data);
-                       return data;
-               }
-
-               case COPY_CONTEXT:
-               {
-                       zend_llist_add_element(&HTTP_G(request).copies.contexts, &data);
-                       return data;
-               }
-
-               case COPY_CONV:
-               {
-                       zend_llist_add_element(&HTTP_G(request).copies.convs, &data);
-                       return data;
-               }
-
-               default:
-               {
-                       return data;
-               }
+               r = emalloc(sizeof(http_request));
        }
+       memset(r, 0, sizeof(http_request));
+       
+       r->ch = ch;
+       r->url = (url && *url) ? estrdup(url) : NULL;
+       r->meth = (meth > 0) ? meth : HTTP_GET;
+       
+       phpstr_init(&r->conv.request);
+       phpstr_init_ex(&r->conv.response, HTTP_CURLBUF_SIZE, 0);
+       
+       zend_hash_init(&r->info, 0, NULL, ZVAL_PTR_DTOR, 0);
+       
+       phpstr_init(&r->_cache.cookies);
+       zend_hash_init(&r->_cache.options, 0, NULL, ZVAL_PTR_DTOR, 0);
+       
+       TSRMLS_SET_CTX(request->tsrm_ls);
+       
+       return r;
 }
-/* }}} */
-
-/* {{{ void http_request_data_free_string(char **) */
-void _http_request_data_free_string(void *string)
-{
-       efree(*((char **)string));
-}
-/* }}} */
-
-/* {{{ void http_request_data_free_slist(struct curl_slist **) */
-void _http_request_data_free_slist(void *list)
-{
-       curl_slist_free_all(*((struct curl_slist **) list));
-}
-/* }}} */
-
-/* {{{ _http_request_data_free_context(http_request_callback_ctx **) */
-void _http_request_data_free_context(void *context)
-{
-       efree(*((http_request_callback_ctx **) context));
-}
-/* }}} */
-
-/* {{{ _http_request_data_free_conv(http_request_conv **) */
-void _http_request_data_free_conv(void *conv)
-{
-       efree(*((http_request_conv **) conv));
-}
-/* }}} */
-
-/* {{{ http_request_body *http_request_body_new() */
-PHP_HTTP_API http_request_body *_http_request_body_new(TSRMLS_D)
-{
-       http_request_body *body = ecalloc(1, sizeof(http_request_body));
-       return body;
-}
-/* }}} */
 
-/* {{{ STATUS http_request_body_fill(http_request_body *body, HashTable *, HashTable *) */
-PHP_HTTP_API STATUS _http_request_body_fill(http_request_body *body, HashTable *fields, HashTable *files TSRMLS_DC)
+PHP_HTTP_API void _http_request_dtor(http_request *request)
 {
-       if (files && (zend_hash_num_elements(files) > 0)) {
-               char *key = NULL;
-               ulong idx;
-               zval **data;
-               HashPosition pos;
-               struct curl_httppost *http_post_data[2] = {NULL, NULL};
-
-               /* normal data */
-               FOREACH_HASH_KEYVAL(pos, fields, key, idx, data) {
-                       CURLcode err;
-                       if (key) {
-                               zval *orig = *data;
-                               
-                               convert_to_string_ex(data);
-                               err = curl_formadd(&http_post_data[0], &http_post_data[1],
-                                       CURLFORM_COPYNAME,                      key,
-                                       CURLFORM_COPYCONTENTS,          Z_STRVAL_PP(data),
-                                       CURLFORM_CONTENTSLENGTH,        (long) Z_STRLEN_PP(data),
-                                       CURLFORM_END
-                               );
-                               
-                               if (orig != *data) {
-                                       zval_ptr_dtor(data);
-                               }
-                               
-                               if (CURLE_OK != err) {
-                                       http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not encode post fields: %s", curl_easy_strerror(err));
-                                       curl_formfree(http_post_data[0]);
-                                       return FAILURE;
-                               }
-
-                               /* reset */
-                               key = NULL;
-                       }
-               }
-
-               /* file data */
-               FOREACH_HASH_VAL(pos, files, data) {
-                       zval **file, **type, **name;
-                       
-                       if (Z_TYPE_PP(data) != IS_ARRAY) {
-                               http_error(HE_NOTICE, HTTP_E_INVALID_PARAM, "Unrecognized type of post file array entry");
-                       } else if (     SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "name", sizeof("name"), (void **) &name) ||
-                                               SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "type", sizeof("type"), (void **) &type) ||
-                                               SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "file", sizeof("file"), (void **) &file)) {
-                               http_error(HE_NOTICE, HTTP_E_INVALID_PARAM, "Post file array entry misses either 'name', 'type' or 'file' entry");
-                       } else {
-                               CURLcode err = curl_formadd(&http_post_data[0], &http_post_data[1],
-                                       CURLFORM_COPYNAME,              Z_STRVAL_PP(name),
-                                       CURLFORM_FILE,                  Z_STRVAL_PP(file),
-                                       CURLFORM_CONTENTTYPE,   Z_STRVAL_PP(type),
-                                       CURLFORM_END
-                               );
-                               if (CURLE_OK != err) {
-                                       http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not encode post files: %s", curl_easy_strerror(err));
-                                       curl_formfree(http_post_data[0]);
-                                       return FAILURE;
-                               }
-                       }
-               }
-
-               body->type = HTTP_REQUEST_BODY_CURLPOST;
-               body->data = http_post_data[0];
-               body->size = 0;
-
-       } else {
-               char *encoded;
-               size_t encoded_len;
-
-               if (SUCCESS != http_urlencode_hash_ex(fields, 1, NULL, 0, &encoded, &encoded_len)) {
-                       http_error(HE_WARNING, HTTP_E_ENCODING, "Could not encode post data");
-                       return FAILURE;
-               }
-
-               body->type = HTTP_REQUEST_BODY_CSTRING;
-               body->data = encoded;
-               body->size = encoded_len;
+       TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
+       
+       if (request->ch) {
+               /* avoid nasty segfaults with already cleaned up callbacks */
+               curl_easy_setopt(request->ch, CURLOPT_NOPROGRESS, 1);
+               curl_easy_setopt(request->ch, CURLOPT_PROGRESSFUNCTION, NULL);
+               curl_easy_setopt(request->ch, CURLOPT_VERBOSE, 0);
+               curl_easy_setopt(request->ch, CURLOPT_DEBUGFUNCTION, NULL);
+               curl_easy_cleanup(request->ch);
+               request->ch = NULL;
        }
-
-       return SUCCESS;
-}
-/* }}} */
-
-/* {{{ void http_request_body_dtor(http_request_body *) */
-PHP_HTTP_API void _http_request_body_dtor(http_request_body *body TSRMLS_DC)
-{
-       if (body) {
-               switch (body->type)
-               {
-                       case HTTP_REQUEST_BODY_CSTRING:
-                               if (body->data) {
-                                       efree(body->data);
-                               }
-                       break;
-
-                       case HTTP_REQUEST_BODY_CURLPOST:
-                               curl_formfree(body->data);
-                       break;
-
-                       case HTTP_REQUEST_BODY_UPLOADFILE:
-                               php_stream_close(body->data);
-                       break;
-               }
+       
+       STR_SET(request->url, NULL);
+       
+       request->conv.last_type = 0;
+       phpstr_dtor(&request->conv.request);
+       phpstr_dtor(&request->conv.response);
+       
+       zend_hash_destroy(&request->info);
+       
+       phpstr_dtor(&request->_cache.cookies);
+       zend_hash_destroy(&request->_cache.options);
+       if (request->_cache.headers) {
+               curl_slist_free_all(request->_cache.headers);
+               request->_cache.headers = NULL;
        }
 }
-/* }}} */
 
-/* {{{ void http_request_body_free(http_request_body *) */
-PHP_HTTP_API void _http_request_body_free(http_request_body **body TSRMLS_DC)
+PHP_HTTP_API void _http_request_free(http_request **request)
 {
-       if (*body) {
-               http_request_body_dtor(*body);
-               efree(*body);
-               *body = NULL;
+       if (*request) {
+               TSRMLS_FETCH_FROM_CTX((*request)->tsrm_ls);
+               http_request_dtor(*request);
+               efree(*request);
+               *request = NULL;
        }
 }
-/* }}} */
 
-/* {{{ STATUS http_request_init(CURL *, http_request_method, char *, http_request_body *, HashTable *) */
-PHP_HTTP_API STATUS _http_request_init(CURL *ch, http_request_method meth, char *url, http_request_body *body, HashTable *options TSRMLS_DC)
+/* {{{ http_request_reset(http_request *) */
+PHP_HTTP_API void _http_request_reset(http_request *request)
 {
-       zval *zoption;
-       zend_bool range_req = 0;
-
-       /* reset CURL handle */
 #ifdef HAVE_CURL_EASY_RESET
-       curl_easy_reset(ch);
+       curl_easy_reset(request->ch);
 #endif
-       http_curl_defaults(ch);
 
-       /* set options */
-       if (url) {
-               HTTP_CURL_OPT(URL, http_request_data_copy(COPY_STRING, url));
-       }
+       STR_SET(request->url, NULL);
+       phpstr_dtor(&request->conv.request);
+       phpstr_dtor(&request->conv.response);
 
+#if defined(ZTS)
+       HTTP_CURL_OPT(NOSIGNAL, 1);
+#endif
        HTTP_CURL_OPT(HEADER, 0);
        HTTP_CURL_OPT(FILETIME, 1);
        HTTP_CURL_OPT(AUTOREFERER, 1);
+       HTTP_CURL_OPT(VERBOSE, 1);
+       HTTP_CURL_OPT(HEADERFUNCTION, NULL);
+       HTTP_CURL_OPT(DEBUGFUNCTION, http_curl_raw_callback);
        HTTP_CURL_OPT(READFUNCTION, http_curl_read_callback);
        HTTP_CURL_OPT(IOCTLFUNCTION, http_curl_ioctl_callback);
-       /* we'll get all data through the debug function */
        HTTP_CURL_OPT(WRITEFUNCTION, http_curl_dummy_callback);
-       HTTP_CURL_OPT(HEADERFUNCTION, NULL);
+       HTTP_CURL_OPT(URL, NULL);
+       HTTP_CURL_OPT(NOPROGRESS, 1);
+       HTTP_CURL_OPT(PROXY, NULL);
+       HTTP_CURL_OPT(PROXYPORT, 0);
+       HTTP_CURL_OPT(PROXYUSERPWD, NULL);
+       HTTP_CURL_OPT(PROXYAUTH, 0);
+       HTTP_CURL_OPT(INTERFACE, NULL);
+       HTTP_CURL_OPT(PORT, 0);
+       HTTP_CURL_OPT(USERPWD, NULL);
+       HTTP_CURL_OPT(HTTPAUTH, 0);
+       HTTP_CURL_OPT(ENCODING, 0);
+       HTTP_CURL_OPT(FOLLOWLOCATION, 0);
+       HTTP_CURL_OPT(UNRESTRICTED_AUTH, 0);
+       HTTP_CURL_OPT(REFERER, NULL);
+       HTTP_CURL_OPT(USERAGENT, "PECL::HTTP/" PHP_EXT_HTTP_VERSION " (PHP/" PHP_VERSION ")");
+       HTTP_CURL_OPT(HTTPHEADER, NULL);
+       HTTP_CURL_OPT(COOKIE, NULL);
+       HTTP_CURL_OPT(COOKIEFILE, NULL);
+       HTTP_CURL_OPT(COOKIEJAR, NULL);
+       HTTP_CURL_OPT(RESUME_FROM, 0);
+       HTTP_CURL_OPT(MAXFILESIZE, 0);
+       HTTP_CURL_OPT(TIMECONDITION, 0);
+       HTTP_CURL_OPT(TIMEVALUE, 0);
+       HTTP_CURL_OPT(TIMEOUT, 0);
+       HTTP_CURL_OPT(CONNECTTIMEOUT, 3);
+       HTTP_CURL_OPT(SSLCERT, NULL);
+       HTTP_CURL_OPT(SSLCERTTYPE, NULL);
+       HTTP_CURL_OPT(SSLCERTPASSWD, NULL);
+       HTTP_CURL_OPT(SSLKEY, NULL);
+       HTTP_CURL_OPT(SSLKEYTYPE, NULL);
+       HTTP_CURL_OPT(SSLKEYPASSWD, NULL);
+       HTTP_CURL_OPT(SSLENGINE, NULL);
+       HTTP_CURL_OPT(SSLVERSION, 0);
+       HTTP_CURL_OPT(SSL_VERIFYPEER, 0);
+       HTTP_CURL_OPT(SSL_VERIFYHOST, 0);
+       HTTP_CURL_OPT(SSL_CIPHER_LIST, NULL);
+       HTTP_CURL_OPT(CAINFO, NULL);
+       HTTP_CURL_OPT(CAPATH, NULL);
+       HTTP_CURL_OPT(RANDOM_FILE, NULL);
+       HTTP_CURL_OPT(EGDSOCKET, NULL);
+       HTTP_CURL_OPT(POSTFIELDS, NULL);
+       HTTP_CURL_OPT(POSTFIELDSIZE, 0);
+       HTTP_CURL_OPT(HTTPPOST, NULL);
+       HTTP_CURL_OPT(IOCTLDATA, NULL);
+       HTTP_CURL_OPT(READDATA, NULL);
+       HTTP_CURL_OPT(INFILESIZE, 0);
+}
+/* }}} */
 
-       HTTP_CURL_OPT(VERBOSE, 1);
-       HTTP_CURL_OPT(DEBUGFUNCTION, http_curl_raw_callback);
+PHP_HTTP_API STATUS _http_request_prepare(http_request *request, HashTable *options)
+{
+       zval *zoption;
+       zend_bool range_req = 0;
 
-#if defined(ZTS)
-       HTTP_CURL_OPT(NOSIGNAL, 1);
-#endif
+       TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
+       
+       HTTP_CHECK_CURL_INIT(request->ch, curl_easy_init(), return FAILURE);
+       
+       /* set options */
+       HTTP_CURL_OPT(DEBUGDATA, request);
+       HTTP_CURL_OPT(URL, request->url);
 
-       /* progress callback */
-       if ((zoption = http_curl_getopt(options, "onprogress", 0))) {
+       /* progress callback * /
+       if ((zoption = http_request_option(request, options, "onprogress", 0))) {
                HTTP_CURL_OPT(NOPROGRESS, 0);
                HTTP_CURL_OPT(PROGRESSFUNCTION, http_curl_progress_callback);
                HTTP_CURL_OPT(PROGRESSDATA,  http_request_callback_data(zoption));
        }
 
        /* proxy */
-       if ((zoption = http_curl_getopt(options, "proxyhost", IS_STRING))) {
-               HTTP_CURL_OPT(PROXY, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
+       if ((zoption = http_request_option(request, options, "proxyhost", IS_STRING))) {
+               HTTP_CURL_OPT(PROXY, Z_STRVAL_P(zoption));
                /* port */
-               if ((zoption = http_curl_getopt(options, "proxyport", IS_LONG))) {
+               if ((zoption = http_request_option(request, options, "proxyport", IS_LONG))) {
                        HTTP_CURL_OPT(PROXYPORT, Z_LVAL_P(zoption));
                }
                /* user:pass */
-               if ((zoption = http_curl_getopt(options, "proxyauth", IS_STRING))) {
-                       HTTP_CURL_OPT(PROXYUSERPWD, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
+               if ((zoption = http_request_option(request, options, "proxyauth", IS_STRING))) {
+                       HTTP_CURL_OPT(PROXYUSERPWD, Z_STRVAL_P(zoption));
                }
                /* auth method */
-               if ((zoption = http_curl_getopt(options, "proxyauthtype", IS_LONG))) {
+               if ((zoption = http_request_option(request, options, "proxyauthtype", IS_LONG))) {
                        HTTP_CURL_OPT(PROXYAUTH, Z_LVAL_P(zoption));
                }
        }
 
        /* outgoing interface */
-       if ((zoption = http_curl_getopt(options, "interface", IS_STRING))) {
-               HTTP_CURL_OPT(INTERFACE, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
+       if ((zoption = http_request_option(request, options, "interface", IS_STRING))) {
+               HTTP_CURL_OPT(INTERFACE, Z_STRVAL_P(zoption));
        }
 
        /* another port */
-       if ((zoption = http_curl_getopt(options, "port", IS_LONG))) {
+       if ((zoption = http_request_option(request, options, "port", IS_LONG))) {
                HTTP_CURL_OPT(PORT, Z_LVAL_P(zoption));
        }
 
        /* auth */
-       if ((zoption = http_curl_getopt(options, "httpauth", IS_STRING))) {
-               HTTP_CURL_OPT(USERPWD, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
+       if ((zoption = http_request_option(request, options, "httpauth", IS_STRING))) {
+               HTTP_CURL_OPT(USERPWD, Z_STRVAL_P(zoption));
        }
-       if ((zoption = http_curl_getopt(options, "httpauthtype", IS_LONG))) {
+       if ((zoption = http_request_option(request, options, "httpauthtype", IS_LONG))) {
                HTTP_CURL_OPT(HTTPAUTH, Z_LVAL_P(zoption));
        }
 
        /* compress, empty string enables all supported if libcurl was build with zlib support */
-       if ((zoption = http_curl_getopt(options, "compress", IS_BOOL)) && Z_LVAL_P(zoption)) {
+       if ((zoption = http_request_option(request, options, "compress", IS_BOOL)) && Z_LVAL_P(zoption)) {
 #ifdef HTTP_HAVE_CURL_ZLIB
-               HTTP_CURL_OPT(ENCODING, "");
+               HTTP_CURL_OPT(ENCODING, "gzip, deflate");
 #else
                HTTP_CURL_OPT(ENCODING, "gzip;q=1.0, deflate;q=0.5, *;q=0.1");
 #endif
        }
 
        /* redirects, defaults to 0 */
-       if ((zoption = http_curl_getopt(options, "redirect", IS_LONG))) {
+       if ((zoption = http_request_option(request, options, "redirect", IS_LONG))) {
                HTTP_CURL_OPT(FOLLOWLOCATION, Z_LVAL_P(zoption) ? 1 : 0);
                HTTP_CURL_OPT(MAXREDIRS, Z_LVAL_P(zoption));
-               if ((zoption = http_curl_getopt(options, "unrestrictedauth", IS_BOOL))) {
+               if ((zoption = http_request_option(request, options, "unrestrictedauth", IS_BOOL))) {
                        HTTP_CURL_OPT(UNRESTRICTED_AUTH, Z_LVAL_P(zoption));
                }
        }
 
        /* referer */
-       if ((zoption = http_curl_getopt(options, "referer", IS_STRING))) {
-               HTTP_CURL_OPT(REFERER, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
+       if ((zoption = http_request_option(request, options, "referer", IS_STRING))) {
+               HTTP_CURL_OPT(REFERER, Z_STRVAL_P(zoption));
        }
 
        /* useragent, default "PECL::HTTP/version (PHP/version)" */
-       if ((zoption = http_curl_getopt(options, "useragent", IS_STRING))) {
-               HTTP_CURL_OPT(USERAGENT, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
+       if ((zoption = http_request_option(request, options, "useragent", IS_STRING))) {
+               HTTP_CURL_OPT(USERAGENT, Z_STRVAL_P(zoption));
        }
 
        /* additional headers, array('name' => 'value') */
-       if ((zoption = http_curl_getopt(options, "headers", IS_ARRAY))) {
+       if ((zoption = http_request_option(request, options, "headers", IS_ARRAY))) {
                char *header_key;
                ulong header_idx;
                HashPosition pos;
-               struct curl_slist *headers = NULL;
 
+               if (request->_cache.headers) {
+                       curl_slist_free_all(request->_cache.headers);
+                       request->_cache.headers = NULL;
+               }
+               
                FOREACH_KEY(pos, zoption, header_key, header_idx) {
                        if (header_key) {
                                zval **header_val;
                                if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_P(zoption), (void **) &header_val, &pos)) {
                                        char header[1024] = {0};
-                                       snprintf(header, 1023, "%s: %s", header_key, Z_STRVAL_PP(header_val));
-                                       headers = curl_slist_append(headers, http_request_data_copy(COPY_STRING, header));
+                                       zval *cpy, *val = convert_to_type_ex(IS_STRING, *header_val, &cpy);
+                                       
+                                       snprintf(header, 1023, "%s: %s", header_key, Z_STRVAL_P(val));
+                                       request->_cache.headers = curl_slist_append(request->_cache.headers, header);
+                                       
+                                       if (cpy) {
+                                               zval_ptr_dtor(&cpy);
+                                       }
                                }
 
                                /* reset */
                                header_key = NULL;
                        }
                }
-
-               if (headers) {
-                       HTTP_CURL_OPT(HTTPHEADER, http_request_data_copy(COPY_SLIST, headers));
-               }
        }
 
        /* cookies, array('name' => 'value') */
-       if ((zoption = http_curl_getopt(options, "cookies", IS_ARRAY))) {
+       if ((zoption = http_request_option(request, options, "cookies", IS_ARRAY))) {
                char *cookie_key = NULL;
                ulong cookie_idx = 0;
                HashPosition pos;
-               phpstr *qstr = phpstr_new();
+               
+               phpstr_dtor(&request->_cache.cookies);
 
                FOREACH_KEY(pos, zoption, cookie_key, cookie_idx) {
                        if (cookie_key) {
                                zval **cookie_val;
                                if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_P(zoption), (void **) &cookie_val, &pos)) {
-                                       phpstr_appendf(qstr, "%s=%s; ", cookie_key, Z_STRVAL_PP(cookie_val));
+                                       zval *cpy, *val = convert_to_type_ex(IS_STRING, *cookie_val, &cpy);
+                                       
+                                       phpstr_appendf(&request->_cache.cookies, "%s=%s; ", cookie_key, Z_STRVAL_P(val));
+                                       
+                                       if (cpy) {
+                                               zval_ptr_dtor(&cpy);
+                                       }
                                }
 
                                /* reset */
@@ -546,15 +474,14 @@ PHP_HTTP_API STATUS _http_request_init(CURL *ch, http_request_method meth, char
                        }
                }
 
-               if (qstr->used) {
-                       phpstr_fix(qstr);
-                       HTTP_CURL_OPT(COOKIE, http_request_data_copy(COPY_STRING, qstr->data));
+               if (request->_cache.cookies.used) {
+                       phpstr_fix(&request->_cache.cookies);
+                       HTTP_CURL_OPT(COOKIE, request->_cache.cookies.data);
                }
-               phpstr_free(&qstr);
        }
 
        /* session cookies */
-       if ((zoption = http_curl_getopt(options, "cookiesession", IS_BOOL))) {
+       if ((zoption = http_request_option(request, options, "cookiesession", IS_BOOL))) {
                if (Z_LVAL_P(zoption)) {
                        /* accept cookies for this session */
                        HTTP_CURL_OPT(COOKIEFILE, "");
@@ -565,24 +492,24 @@ PHP_HTTP_API STATUS _http_request_init(CURL *ch, http_request_method meth, char
        }
 
        /* cookiestore, read initial cookies from that file and store cookies back into that file */
-       if ((zoption = http_curl_getopt(options, "cookiestore", IS_STRING)) && Z_STRLEN_P(zoption)) {
-               HTTP_CURL_OPT(COOKIEFILE, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
-               HTTP_CURL_OPT(COOKIEJAR, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
+       if ((zoption = http_request_option(request, options, "cookiestore", IS_STRING)) && Z_STRLEN_P(zoption)) {
+               HTTP_CURL_OPT(COOKIEFILE, Z_STRVAL_P(zoption));
+               HTTP_CURL_OPT(COOKIEJAR, Z_STRVAL_P(zoption));
        }
 
        /* resume */
-       if ((zoption = http_curl_getopt(options, "resume", IS_LONG)) && (Z_LVAL_P(zoption) != 0)) {
+       if ((zoption = http_request_option(request, options, "resume", IS_LONG)) && (Z_LVAL_P(zoption) != 0)) {
                range_req = 1;
                HTTP_CURL_OPT(RESUME_FROM, Z_LVAL_P(zoption));
        }
 
        /* maxfilesize */
-       if ((zoption = http_curl_getopt(options, "maxfilesize", IS_LONG))) {
+       if ((zoption = http_request_option(request, options, "maxfilesize", IS_LONG))) {
                HTTP_CURL_OPT(MAXFILESIZE, Z_LVAL_P(zoption));
        }
 
        /* lastmodified */
-       if ((zoption = http_curl_getopt(options, "lastmodified", IS_LONG))) {
+       if ((zoption = http_request_option(request, options, "lastmodified", IS_LONG))) {
                if (Z_LVAL_P(zoption)) {
                        if (Z_LVAL_P(zoption) > 0) {
                                HTTP_CURL_OPT(TIMEVALUE, Z_LVAL_P(zoption));
@@ -596,17 +523,17 @@ PHP_HTTP_API STATUS _http_request_init(CURL *ch, http_request_method meth, char
        }
 
        /* timeout, defaults to 0 */
-       if ((zoption = http_curl_getopt(options, "timeout", IS_LONG))) {
+       if ((zoption = http_request_option(request, options, "timeout", IS_LONG))) {
                HTTP_CURL_OPT(TIMEOUT, Z_LVAL_P(zoption));
        }
 
        /* connecttimeout, defaults to 3 */
-       if ((zoption = http_curl_getopt(options, "connecttimeout", IS_LONG))) {
+       if ((zoption = http_request_option(request, options, "connecttimeout", IS_LONG))) {
                HTTP_CURL_OPT(CONNECTTIMEOUT, Z_LVAL_P(zoption));
        }
 
        /* ssl */
-       if ((zoption = http_curl_getopt(options, "ssl", IS_ARRAY))) {
+       if ((zoption = http_request_option(request, options, "ssl", IS_ARRAY))) {
                ulong idx;
                char *key = NULL;
                zval **param;
@@ -641,56 +568,56 @@ PHP_HTTP_API STATUS _http_request_init(CURL *ch, http_request_method meth, char
        }
 
        /* request method */
-       switch (meth)
+       switch (request->meth)
        {
                case HTTP_GET:
-                       curl_easy_setopt(ch, CURLOPT_HTTPGET, 1);
+                       curl_easy_setopt(request->ch, CURLOPT_HTTPGET, 1);
                break;
 
                case HTTP_HEAD:
-                       curl_easy_setopt(ch, CURLOPT_NOBODY, 1);
+                       curl_easy_setopt(request->ch, CURLOPT_NOBODY, 1);
                break;
 
                case HTTP_POST:
-                       curl_easy_setopt(ch, CURLOPT_POST, 1);
+                       curl_easy_setopt(request->ch, CURLOPT_POST, 1);
                break;
 
                case HTTP_PUT:
-                       curl_easy_setopt(ch, CURLOPT_UPLOAD, 1);
+                       curl_easy_setopt(request->ch, CURLOPT_UPLOAD, 1);
                break;
 
                default:
-                       if (http_request_method_exists(0, meth, NULL)) {
-                               curl_easy_setopt(ch, CURLOPT_CUSTOMREQUEST, http_request_method_name(meth));
+                       if (http_request_method_exists(0, request->meth, NULL)) {
+                               curl_easy_setopt(request->ch, CURLOPT_CUSTOMREQUEST, http_request_method_name(request->meth));
                        } else {
-                               http_error_ex(HE_WARNING, HTTP_E_REQUEST_METHOD, "Unsupported request method: %d", meth);
+                               http_error_ex(HE_WARNING, HTTP_E_REQUEST_METHOD, "Unsupported request method: %d (%s)", request->meth, request->url);
                                return FAILURE;
                        }
                break;
        }
 
        /* attach request body */
-       if (body && (meth != HTTP_GET) && (meth != HTTP_HEAD)) {
-               switch (body->type)
+       if (request->body && (request->meth != HTTP_GET) && (request->meth != HTTP_HEAD)) {
+               switch (request->body->type)
                {
                        case HTTP_REQUEST_BODY_CSTRING:
-                               curl_easy_setopt(ch, CURLOPT_POSTFIELDS, body->data);
-                               curl_easy_setopt(ch, CURLOPT_POSTFIELDSIZE, body->size);
+                               curl_easy_setopt(request->ch, CURLOPT_POSTFIELDS, request->body->data);
+                               curl_easy_setopt(request->ch, CURLOPT_POSTFIELDSIZE, request->body->size);
                        break;
 
                        case HTTP_REQUEST_BODY_CURLPOST:
-                               curl_easy_setopt(ch, CURLOPT_HTTPPOST, (struct curl_httppost *) body->data);
+                               curl_easy_setopt(request->ch, CURLOPT_HTTPPOST, (struct curl_httppost *) request->body->data);
                        break;
 
                        case HTTP_REQUEST_BODY_UPLOADFILE:
-                               curl_easy_setopt(ch, CURLOPT_IOCTLDATA, http_request_callback_data(body));
-                               curl_easy_setopt(ch, CURLOPT_READDATA, http_request_callback_data(body));
-                               curl_easy_setopt(ch, CURLOPT_INFILESIZE, body->size);
+                               curl_easy_setopt(request->ch, CURLOPT_IOCTLDATA, request);
+                               curl_easy_setopt(request->ch, CURLOPT_READDATA, request);
+                               curl_easy_setopt(request->ch, CURLOPT_INFILESIZE, request->body->size);
                        break;
 
                        default:
                                /* shouldn't ever happen */
-                               http_error_ex(HE_ERROR, 0, "Unknown request body type: %d", body->type);
+                               http_error_ex(HE_ERROR, 0, "Unknown request body type: %d (%s)", request->body->type, request->url);
                                return FAILURE;
                        break;
                }
@@ -700,42 +627,21 @@ PHP_HTTP_API STATUS _http_request_init(CURL *ch, http_request_method meth, char
 }
 /* }}} */
 
-/* {{{ void http_request_conv(CURL *, phpstr *, phpstr *) */
-void _http_request_conv(CURL *ch, phpstr* response, phpstr *request TSRMLS_DC)
-{
-       http_request_conv *conv = emalloc(sizeof(http_request_conv));
-       conv->response = response;
-       conv->request = request;
-       conv->last_info = -1;
-       HTTP_CURL_OPT(DEBUGDATA, http_request_callback_data(http_request_data_copy(COPY_CONV, conv)));
-}
-/* }}} */
-
-/* {{{ STATUS http_request_exec(CURL *, HashTable *) */
-PHP_HTTP_API STATUS _http_request_exec(CURL *ch, HashTable *info, phpstr *response, phpstr *request TSRMLS_DC)
+PHP_HTTP_API void _http_request_exec(http_request *request)
 {
        CURLcode result;
-
-       http_request_conv(ch, response, request);
-
-       /* perform request */
-       if (CURLE_OK != (result = curl_easy_perform(ch))) {
-               http_error(HE_WARNING, HTTP_E_REQUEST, curl_easy_strerror(result));
-       }
-       /* get curl info */
-       if (info) {
-               http_request_info(ch, info);
+       TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
+       
+       if (CURLE_OK != (result = curl_easy_perform(request->ch))) {
+               http_error_ex(HE_WARNING, HTTP_E_REQUEST, "%s (%s)", curl_easy_strerror(result), request->url);
        }
-       /* always succeeds */
-       return SUCCESS;
 }
-/* }}} */
 
 /* {{{ void http_request_info(CURL *, HashTable *) */
-PHP_HTTP_API void _http_request_info(CURL *ch, HashTable *info TSRMLS_DC)
+PHP_HTTP_API void _http_request_info(http_request *request, HashTable *info)
 {
        zval array;
-       INIT_ZARR(array, info);
+       INIT_ZARR(array, &request->info);
 
        HTTP_CURL_INFO(EFFECTIVE_URL);
        HTTP_CURL_INFO(RESPONSE_CODE);
@@ -767,40 +673,27 @@ PHP_HTTP_API void _http_request_info(CURL *ch, HashTable *info TSRMLS_DC)
 #if LIBCURL_VERSION_NUM >= 0x070e01
        HTTP_CURL_INFO_EX(COOKIELIST, cookies);
 #endif
-}
-/* }}} */
-
-/* {{{ STATUS http_request_ex(CURL *, http_request_method, char *, http_request_body, HashTable, HashTable, phpstr *) */
-PHP_HTTP_API STATUS _http_request_ex(CURL *ch, http_request_method meth, char *url, http_request_body *body, HashTable *options, HashTable *info, phpstr *response TSRMLS_DC)
-{
-       STATUS status;
-       zend_bool clean_curl = !ch;
-
-       HTTP_CHECK_CURL_INIT(ch, curl_easy_init(), return FAILURE);
-
-       status =        ((SUCCESS == http_request_init(ch, meth, url, body, options)) &&
-                               (SUCCESS == http_request_exec(ch, info, response, NULL))) ? SUCCESS : FAILURE;
-
-       if (clean_curl) {
-               curl_easy_cleanup(ch);
+       
+       if (info) {
+               zend_hash_copy(info, &request->info, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
        }
-       return status;
 }
 /* }}} */
 
 /* {{{ static size_t http_curl_read_callback(void *, size_t, size_t, void *) */
-static size_t http_curl_read_callback(void *data, size_t len, size_t n, void *s)
+static size_t http_curl_read_callback(void *data, size_t len, size_t n, void *ctx)
 {
-       HTTP_REQUEST_CALLBACK_DATA(s, http_request_body *, body);
+       http_request *request = (http_request *) ctx;
+       TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
 
-       if (body->type != HTTP_REQUEST_BODY_UPLOADFILE) {
+       if (request->body == NULL || request->body->type != HTTP_REQUEST_BODY_UPLOADFILE) {
                return 0;
        }
-       return php_stream_read((php_stream *) body->data, data, len * n);
+       return php_stream_read((php_stream *) request->body->data, data, len * n);
 }
 /* }}} */
 
-/* {{{ static int http_curl_progress_callback(void *, double, double, double, double) */
+/* {{{ static int http_curl_progress_callback(void *, double, double, double, double) * /
 static int http_curl_progress_callback(void *data, double dltotal, double dlnow, double ultotal, double ulnow)
 {
        zval *params_pass[4], params_local[4], retval;
@@ -827,15 +720,15 @@ static int http_curl_progress_callback(void *data, double dltotal, double dlnow,
 /* {{{ static curlioerr http_curl_ioctl_callback(CURL *, curliocmd, void *) */
 static curlioerr http_curl_ioctl_callback(CURL *ch, curliocmd cmd, void *ctx)
 {
-       HTTP_REQUEST_CALLBACK_DATA(ctx, http_request_body *, body);
+       http_request *request = (http_request *) ctx;
+       TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
        
        if (cmd != CURLIOCMD_RESTARTREAD) {
                return CURLIOE_UNKNOWNCMD;
        }
-       if (body->type != HTTP_REQUEST_BODY_UPLOADFILE) {
-               return CURLIOE_FAILRESTART;
-       }
-       if (SUCCESS != php_stream_rewind((php_stream *) body->data)) {
+       if (    request->body == NULL || 
+                       request->body->type != HTTP_REQUEST_BODY_UPLOADFILE ||
+                       SUCCESS != php_stream_rewind((php_stream *) request->body->data)) {
                return CURLIOE_FAILRESTART;
        }
        return CURLIOE_OK;
@@ -845,27 +738,23 @@ static curlioerr http_curl_ioctl_callback(CURL *ch, curliocmd cmd, void *ctx)
 /* {{{ static int http_curl_raw_callback(CURL *, curl_infotype, char *, size_t, void *) */
 static int http_curl_raw_callback(CURL *ch, curl_infotype type, char *data, size_t length, void *ctx)
 {
-       HTTP_REQUEST_CALLBACK_DATA(ctx, http_request_conv *, conv);
+       http_request *request = (http_request *) ctx;
 
        switch (type)
        {
                case CURLINFO_DATA_IN:
-                       if (conv->response && conv->last_info == CURLINFO_HEADER_IN) {
-                               phpstr_appends(conv->response, HTTP_CRLF);
+                       if (request->conv.last_type == CURLINFO_HEADER_IN) {
+                               phpstr_appends(&request->conv.response, HTTP_CRLF);
                        }
                case CURLINFO_HEADER_IN:
-                       if (conv->response) {
-                               phpstr_append(conv->response, data, length);
-                       }
+                       phpstr_append(&request->conv.response, data, length);
                break;
                case CURLINFO_DATA_OUT:
-                       if (conv->request && conv->last_info == CURLINFO_HEADER_OUT) {
-                               phpstr_appends(conv->request, HTTP_CRLF);
+                       if (request->conv.last_type == CURLINFO_HEADER_OUT) {
+                               phpstr_appends(&request->conv.request, HTTP_CRLF);
                        }
                case CURLINFO_HEADER_OUT:
-                       if (conv->request) {
-                               phpstr_append(conv->request, data, length);
-                       }
+                       phpstr_append(&request->conv.request, data, length);
                break;
                default:
 #if 0
@@ -890,18 +779,19 @@ static int http_curl_raw_callback(CURL *ch, curl_infotype type, char *data, size
        }
 
        if (type) {
-               conv->last_info = type;
+               request->conv.last_type = type;
        }
        return 0;
 }
 /* }}} */
 
-/* {{{ static inline zval *http_curl_getopt(HashTable *, char *, size_t, int) */
-static inline zval *_http_curl_getopt_ex(HashTable *options, char *key, size_t keylen, int type TSRMLS_DC)
+/* {{{ static inline zval *http_request_option(http_request *, HashTable *, char *, size_t, int) */
+static inline zval *_http_request_option_ex(http_request *r, HashTable *options, char *key, size_t keylen, int type TSRMLS_DC)
 {
        zval **zoption;
+       ulong h = zend_get_hash_value(key, keylen);
 
-       if (!options || (SUCCESS != zend_hash_find(options, key, keylen, (void **) &zoption))) {
+       if (!options || (SUCCESS != zend_hash_quick_find(options, key, keylen, h, (void **) &zoption))) {
                return NULL;
        }
 
@@ -918,6 +808,10 @@ static inline zval *_http_curl_getopt_ex(HashTable *options, char *key, size_t k
                        break;
                }
        }
+       
+       ZVAL_ADDREF(*zoption);
+       _zend_hash_quick_add_or_update(&r->_cache.options, key, keylen, h, zoption, sizeof(zval *), NULL, 
+               zend_hash_quick_exists(&r->_cache.options, key, keylen, h)?HASH_UPDATE:HASH_ADD ZEND_FILE_LINE_CC);
 
        return *zoption;
 }
@@ -1022,58 +916,6 @@ static inline void http_ssl_cleanup(void)
 #endif /* HTTP_NEED_GNUTLS_TSL */
 /* }}} */
 
-/* {{{ http_curl_defaults(CURL *) */
-static inline void _http_curl_defaults(CURL *ch)
-{
-       HTTP_CURL_OPT(URL, NULL);
-       HTTP_CURL_OPT(NOPROGRESS, 1);
-       HTTP_CURL_OPT(PROXY, NULL);
-       HTTP_CURL_OPT(PROXYPORT, 0);
-       HTTP_CURL_OPT(PROXYUSERPWD, NULL);
-       HTTP_CURL_OPT(PROXYAUTH, 0);
-       HTTP_CURL_OPT(INTERFACE, NULL);
-       HTTP_CURL_OPT(PORT, 0);
-       HTTP_CURL_OPT(USERPWD, NULL);
-       HTTP_CURL_OPT(HTTPAUTH, 0);
-       HTTP_CURL_OPT(ENCODING, 0);
-       HTTP_CURL_OPT(FOLLOWLOCATION, 0);
-       HTTP_CURL_OPT(UNRESTRICTED_AUTH, 0);
-       HTTP_CURL_OPT(REFERER, NULL);
-       HTTP_CURL_OPT(USERAGENT, "PECL::HTTP/" PHP_EXT_HTTP_VERSION " (PHP/" PHP_VERSION ")");
-       HTTP_CURL_OPT(HTTPHEADER, NULL);
-       HTTP_CURL_OPT(COOKIE, NULL);
-       HTTP_CURL_OPT(COOKIEFILE, NULL);
-       HTTP_CURL_OPT(COOKIEJAR, NULL);
-       HTTP_CURL_OPT(RESUME_FROM, 0);
-       HTTP_CURL_OPT(MAXFILESIZE, 0);
-       HTTP_CURL_OPT(TIMECONDITION, 0);
-       HTTP_CURL_OPT(TIMEVALUE, 0);
-       HTTP_CURL_OPT(TIMEOUT, 0);
-       HTTP_CURL_OPT(CONNECTTIMEOUT, 3);
-       HTTP_CURL_OPT(SSLCERT, NULL);
-       HTTP_CURL_OPT(SSLCERTTYPE, NULL);
-       HTTP_CURL_OPT(SSLCERTPASSWD, NULL);
-       HTTP_CURL_OPT(SSLKEY, NULL);
-       HTTP_CURL_OPT(SSLKEYTYPE, NULL);
-       HTTP_CURL_OPT(SSLKEYPASSWD, NULL);
-       HTTP_CURL_OPT(SSLENGINE, NULL);
-       HTTP_CURL_OPT(SSLVERSION, 0);
-       HTTP_CURL_OPT(SSL_VERIFYPEER, 0);
-       HTTP_CURL_OPT(SSL_VERIFYHOST, 0);
-       HTTP_CURL_OPT(SSL_CIPHER_LIST, NULL);
-       HTTP_CURL_OPT(CAINFO, NULL);
-       HTTP_CURL_OPT(CAPATH, NULL);
-       HTTP_CURL_OPT(RANDOM_FILE, NULL);
-       HTTP_CURL_OPT(EGDSOCKET, NULL);
-       HTTP_CURL_OPT(POSTFIELDS, NULL);
-       HTTP_CURL_OPT(POSTFIELDSIZE, 0);
-       HTTP_CURL_OPT(HTTPPOST, NULL);
-       HTTP_CURL_OPT(IOCTLDATA, NULL);
-       HTTP_CURL_OPT(READDATA, NULL);
-       HTTP_CURL_OPT(INFILESIZE, 0);
-}
-/* }}} */
-
 #endif /* HTTP_HAVE_CURL */
 
 /*
diff --git a/http_request_body_api.c b/http_request_body_api.c
new file mode 100644 (file)
index 0000000..f797141
--- /dev/null
@@ -0,0 +1,167 @@
+/*
+    +--------------------------------------------------------------------+
+    | PECL :: http                                                       |
+    +--------------------------------------------------------------------+
+    | Redistribution and use in source and binary forms, with or without |
+    | modification, are permitted provided that the conditions mentioned |
+    | in the accompanying LICENSE file are met.                          |
+    +--------------------------------------------------------------------+
+    | Copyright (c) 2004-2005, Michael Wallner <mike@php.net>            |
+    +--------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifdef HAVE_CONFIG_H
+#      include "config.h"
+#endif
+
+#define HTTP_WANT_CURL
+#include "php_http.h"
+
+#ifdef HTTP_HAVE_CURL
+
+#include "php_http_api.h"
+#include "php_http_url_api.h"
+#include "php_http_request_body_api.h"
+
+ZEND_EXTERN_MODULE_GLOBALS(http);
+
+/* {{{ http_request_body *http_request_body_new() */
+PHP_HTTP_API http_request_body *_http_request_body_new(TSRMLS_D)
+{
+       return (http_request_body *) ecalloc(1, sizeof(http_request_body));
+}
+/* }}} */
+
+/* {{{ STATUS http_request_body_fill(http_request_body *body, HashTable *, HashTable *) */
+PHP_HTTP_API STATUS _http_request_body_fill(http_request_body *body, HashTable *fields, HashTable *files TSRMLS_DC)
+{
+       if (files && (zend_hash_num_elements(files) > 0)) {
+               char *key = NULL;
+               ulong idx;
+               zval **data;
+               HashPosition pos;
+               struct curl_httppost *http_post_data[2] = {NULL, NULL};
+
+               /* normal data */
+               FOREACH_HASH_KEYVAL(pos, fields, key, idx, data) {
+                       CURLcode err;
+                       if (key) {
+                               zval *orig = *data;
+                               
+                               convert_to_string_ex(data);
+                               err = curl_formadd(&http_post_data[0], &http_post_data[1],
+                                       CURLFORM_COPYNAME,                      key,
+                                       CURLFORM_COPYCONTENTS,          Z_STRVAL_PP(data),
+                                       CURLFORM_CONTENTSLENGTH,        (long) Z_STRLEN_PP(data),
+                                       CURLFORM_END
+                               );
+                               
+                               if (orig != *data) {
+                                       zval_ptr_dtor(data);
+                               }
+                               
+                               if (CURLE_OK != err) {
+                                       http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not encode post fields: %s", curl_easy_strerror(err));
+                                       curl_formfree(http_post_data[0]);
+                                       return FAILURE;
+                               }
+
+                               /* reset */
+                               key = NULL;
+                       }
+               }
+
+               /* file data */
+               FOREACH_HASH_VAL(pos, files, data) {
+                       zval **file, **type, **name;
+                       
+                       if (Z_TYPE_PP(data) != IS_ARRAY) {
+                               http_error(HE_NOTICE, HTTP_E_INVALID_PARAM, "Unrecognized type of post file array entry");
+                       } else if (     SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "name", sizeof("name"), (void **) &name) ||
+                                               SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "type", sizeof("type"), (void **) &type) ||
+                                               SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "file", sizeof("file"), (void **) &file)) {
+                               http_error(HE_NOTICE, HTTP_E_INVALID_PARAM, "Post file array entry misses either 'name', 'type' or 'file' entry");
+                       } else {
+                               CURLcode err = curl_formadd(&http_post_data[0], &http_post_data[1],
+                                       CURLFORM_COPYNAME,              Z_STRVAL_PP(name),
+                                       CURLFORM_FILE,                  Z_STRVAL_PP(file),
+                                       CURLFORM_CONTENTTYPE,   Z_STRVAL_PP(type),
+                                       CURLFORM_END
+                               );
+                               if (CURLE_OK != err) {
+                                       http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not encode post files: %s", curl_easy_strerror(err));
+                                       curl_formfree(http_post_data[0]);
+                                       return FAILURE;
+                               }
+                       }
+               }
+
+               body->type = HTTP_REQUEST_BODY_CURLPOST;
+               body->data = http_post_data[0];
+               body->size = 0;
+
+       } else {
+               char *encoded;
+               size_t encoded_len;
+
+               if (SUCCESS != http_urlencode_hash_ex(fields, 1, NULL, 0, &encoded, &encoded_len)) {
+                       http_error(HE_WARNING, HTTP_E_ENCODING, "Could not encode post data");
+                       return FAILURE;
+               }
+
+               body->type = HTTP_REQUEST_BODY_CSTRING;
+               body->data = encoded;
+               body->size = encoded_len;
+       }
+
+       return SUCCESS;
+}
+/* }}} */
+
+/* {{{ void http_request_body_dtor(http_request_body *) */
+PHP_HTTP_API void _http_request_body_dtor(http_request_body *body TSRMLS_DC)
+{
+       if (body) {
+               switch (body->type)
+               {
+                       case HTTP_REQUEST_BODY_CSTRING:
+                               if (body->data) {
+                                       efree(body->data);
+                               }
+                       break;
+
+                       case HTTP_REQUEST_BODY_CURLPOST:
+                               curl_formfree(body->data);
+                       break;
+
+                       case HTTP_REQUEST_BODY_UPLOADFILE:
+                               php_stream_close(body->data);
+                       break;
+               }
+       }
+}
+/* }}} */
+
+/* {{{ void http_request_body_free(http_request_body *) */
+PHP_HTTP_API void _http_request_body_free(http_request_body **body TSRMLS_DC)
+{
+       if (*body) {
+               http_request_body_dtor(*body);
+               efree(*body);
+               *body = NULL;
+       }
+}
+/* }}} */
+
+#endif /* HTTP_HAVE_CURL */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
index 2e34c91..ea4e9f6 100644 (file)
@@ -306,16 +306,13 @@ zend_object_value _http_request_object_new_ex(zend_class_entry *ce, CURL *ch, ht
 
        o = ecalloc(1, sizeof(http_request_object));
        o->zo.ce = ce;
-       o->ch = ch;
+       http_request_init_ex(&o->request, ch, 0, NULL);
+       phpstr_init(&o->history);
        
        if (ptr) {
                *ptr = o;
        }
 
-       phpstr_init(&o->history);
-       phpstr_init(&o->request);
-       phpstr_init_ex(&o->response, HTTP_CURLBUF_SIZE, 0);
-
        ALLOC_HASHTABLE(OBJ_PROP(o));
        zend_hash_init(OBJ_PROP(o), 0, NULL, ZVAL_PTR_DTOR, 0);
        zend_hash_copy(OBJ_PROP(o), &ce->default_properties, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
@@ -334,12 +331,12 @@ zend_object_value _http_request_object_clone_obj(zval *this_ptr TSRMLS_DC)
        getObject(http_request_object, old_obj);
        
        old_zo = zend_objects_get_address(this_ptr TSRMLS_CC);
-       new_ov = http_request_object_new_ex(old_zo->ce, curl_easy_duphandle(old_obj->ch), &new_obj);
+       new_ov = http_request_object_new_ex(old_zo->ce, curl_easy_duphandle(old_obj->request.ch), &new_obj);
        
        zend_objects_clone_members(&new_obj->zo, new_ov, old_zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
        phpstr_append(&new_obj->history, old_obj->history.data, old_obj->history.used);
-       phpstr_append(&new_obj->request, old_obj->request.data, old_obj->request.used);
-       phpstr_append(&new_obj->response, old_obj->response.data, old_obj->response.used);
+       phpstr_append(&new_obj->request.conv.request, old_obj->request.conv.request.data, old_obj->request.conv.request.used);
+       phpstr_append(&new_obj->request.conv.response, old_obj->request.conv.response.data, old_obj->request.conv.response.used);
        
        return new_ov;
 }
@@ -420,50 +417,33 @@ void _http_request_object_free(zend_object *object TSRMLS_DC)
                zend_hash_destroy(OBJ_PROP(o));
                FREE_HASHTABLE(OBJ_PROP(o));
        }
-       if (o->ch) {
-               /* avoid nasty segfaults with already cleaned up callbacks */
-               curl_easy_setopt(o->ch, CURLOPT_NOPROGRESS, 1);
-               curl_easy_setopt(o->ch, CURLOPT_PROGRESSFUNCTION, NULL);
-               curl_easy_setopt(o->ch, CURLOPT_VERBOSE, 0);
-               curl_easy_setopt(o->ch, CURLOPT_DEBUGFUNCTION, NULL);
-               curl_easy_cleanup(o->ch);
-       }
-       phpstr_dtor(&o->response);
-       phpstr_dtor(&o->request);
+       http_request_dtor(&o->request);
        phpstr_dtor(&o->history);
        efree(o);
 }
 
-STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_ptr, http_request_body *body TSRMLS_DC)
+STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_ptr TSRMLS_DC)
 {
-       zval *meth, *URL, *meth_p, *URL_p;
-       char *request_uri;
+       zval *URL, *URL_p, *meth_p;
        STATUS status = SUCCESS;
 
-       if (!body) {
-               return FAILURE;
-       }
-       HTTP_CHECK_CURL_INIT(obj->ch, curl_easy_init(), return FAILURE);
-
+       http_request_reset(&obj->request);
+       HTTP_CHECK_CURL_INIT(obj->request.ch, curl_easy_init(), return FAILURE);
+       
        URL = convert_to_type_ex(IS_STRING, GET_PROP(obj, url), &URL_p);
-       // HTTP_URI_MAXLEN+1 long char *
-       if (!(request_uri = http_absolute_uri_ex(Z_STRVAL_P(URL), Z_STRLEN_P(URL), NULL, 0, NULL, 0, 0))) {
-               if (URL_p) {
-                       zval_ptr_dtor(&URL_p);
-               }
-               return FAILURE;
-       }
+       obj->request.url = http_absolute_uri_ex(Z_STRVAL_P(URL), Z_STRLEN_P(URL), NULL, 0, NULL, 0, 0);
        if (URL_p) {
                zval_ptr_dtor(&URL_p);
        }
        
-       meth = convert_to_type_ex(IS_LONG, GET_PROP(obj, method), &meth_p);
-       switch (Z_LVAL_P(meth))
+       if (!obj->request.url) {
+               return FAILURE;
+       }
+       
+       switch (obj->request.meth = Z_LVAL_P(convert_to_type_ex(IS_LONG, GET_PROP(obj, method), &meth_p)))
        {
                case HTTP_GET:
                case HTTP_HEAD:
-                       body->type = -1;
-                       body = NULL;
                break;
 
                case HTTP_PUT:
@@ -472,9 +452,10 @@ STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_
                        php_stream *stream = php_stream_open_wrapper(Z_STRVAL_P(GET_PROP(obj, putFile)), "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
                        
                        if (stream && !php_stream_stat(stream, &ssb)) {
-                               body->type = HTTP_REQUEST_BODY_UPLOADFILE;
-                               body->data = stream;
-                               body->size = ssb.sb.st_size;
+                               obj->request.body = http_request_body_new();
+                               obj->request.body->type = HTTP_REQUEST_BODY_UPLOADFILE;
+                               obj->request.body->data = stream;
+                               obj->request.body->size = ssb.sb.st_size;
                        } else {
                                status = FAILURE;
                        }
@@ -487,6 +468,7 @@ STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_
                        /* check for raw post data */
                        zval *raw_data_p, *raw_data = convert_to_type_ex(IS_STRING, GET_PROP(obj, rawPostData), &raw_data_p);
                        
+                       obj->request.body = http_request_body_new();
                        if (Z_STRLEN_P(raw_data)) {
                                zval *ctype_p, *ctype = convert_to_type_ex(IS_STRING, GET_PROP(obj, contentType), &ctype_p);
                                
@@ -517,11 +499,11 @@ STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_
                                        zval_ptr_dtor(&ctype_p);
                                }
                                
-                               body->type = HTTP_REQUEST_BODY_CSTRING;
-                               body->data = estrndup(Z_STRVAL_P(raw_data), Z_STRLEN_P(raw_data));
-                               body->size = Z_STRLEN_P(raw_data);
+                               obj->request.body->type = HTTP_REQUEST_BODY_CSTRING;
+                               obj->request.body->data = estrndup(Z_STRVAL_P(raw_data), Z_STRLEN_P(raw_data));
+                               obj->request.body->size = Z_STRLEN_P(raw_data);
                        } else {
-                               status = http_request_body_fill(body, Z_ARRVAL_P(GET_PROP(obj, postFields)), Z_ARRVAL_P(GET_PROP(obj, postFiles)));
+                               status = http_request_body_fill(obj->request.body, Z_ARRVAL_P(GET_PROP(obj, postFields)), Z_ARRVAL_P(GET_PROP(obj, postFiles)));
                        }
 
                        if (raw_data_p) {
@@ -537,28 +519,26 @@ STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_
        
        if (status == SUCCESS) {
                zval *qdata_p, *qdata = convert_to_type_ex(IS_STRING, GET_PROP(obj, queryData), &qdata_p);
+               zval *opt_p, *options = convert_to_type_ex(IS_ARRAY, GET_PROP(obj, options), &opt_p);
                
                if (Z_STRLEN_P(qdata)) {
-                       if (!strchr(request_uri, '?')) {
-                               strlcat(request_uri, "?", HTTP_URI_MAXLEN);
+                       if (!strchr(obj->request.url, '?')) {
+                               strlcat(obj->request.url, "?", HTTP_URI_MAXLEN);
                        } else {
-                               strlcat(request_uri, "&", HTTP_URI_MAXLEN);
+                               strlcat(obj->request.url, "&", HTTP_URI_MAXLEN);
                        }
-                       strlcat(request_uri, Z_STRVAL_P(qdata), HTTP_URI_MAXLEN);
+                       strlcat(obj->request.url, Z_STRVAL_P(qdata), HTTP_URI_MAXLEN);
                }
                
+               http_request_prepare(&obj->request, Z_ARRVAL_P(options));
+               
+               if (opt_p) {
+                       zval_ptr_dtor(&opt_p);
+               }
                if (qdata_p) {
                        zval_ptr_dtor(&qdata_p);
                }
-               
-               status = http_request_init(obj->ch, Z_LVAL_P(meth), request_uri, body, Z_ARRVAL_P(GET_PROP(obj, options)));
        }
-       efree(request_uri);
-
-       /* clean previous response */
-       phpstr_dtor(&obj->response);
-       /* clean previous request */
-       phpstr_dtor(&obj->request);
 
        return status;
 }
@@ -566,11 +546,11 @@ STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_
 STATUS _http_request_object_responsehandler(http_request_object *obj, zval *this_ptr TSRMLS_DC)
 {
        http_message *msg;
-
-       phpstr_fix(&obj->request);
-       phpstr_fix(&obj->response);
        
-       msg = http_message_parse(PHPSTR_VAL(&obj->response), PHPSTR_LEN(&obj->response));
+       phpstr_fix(&obj->request.conv.request);
+       phpstr_fix(&obj->request.conv.response);
+       
+       msg = http_message_parse(PHPSTR_VAL(&obj->request.conv.response), PHPSTR_LEN(&obj->request.conv.response));
        
        if (!msg) {
                return FAILURE;
@@ -589,7 +569,7 @@ STATUS _http_request_object_responsehandler(http_request_object *obj, zval *this
                         * the requests and the responses in separate chains
                         * for redirects
                         */
-                       http_message *response = msg, *request = http_message_parse(PHPSTR_VAL(&obj->request), PHPSTR_LEN(&obj->request));
+                       http_message *response = msg, *request = http_message_parse(PHPSTR_VAL(&obj->request.conv.request), PHPSTR_LEN(&obj->request.conv.request));
                        http_message *free_msg = request;
 
                        do {
@@ -627,7 +607,7 @@ STATUS _http_request_object_responsehandler(http_request_object *obj, zval *this
                SET_PROP(obj, responseMessage, message);
                zval_ptr_dtor(&message);
 
-               http_request_info(obj->ch, Z_ARRVAL_P(info));
+               http_request_info(&obj->request, Z_ARRVAL_P(info));
                SET_PROP(obj, responseInfo, info);
 
                return SUCCESS;
@@ -1884,7 +1864,7 @@ PHP_METHOD(HttpRequest, getRequestMessage)
                getObject(http_request_object, obj);
 
                SET_EH_THROW_HTTP();
-               if ((msg = http_message_parse(PHPSTR_VAL(&obj->request), PHPSTR_LEN(&obj->request)))) {
+               if ((msg = http_message_parse(PHPSTR_VAL(&obj->request.conv.request), PHPSTR_LEN(&obj->request.conv.request)))) {
                        ZVAL_OBJVAL(return_value, http_message_object_new_ex(http_message_object_ce, msg, NULL));
                }
                SET_EH_NORMAL();
@@ -1988,7 +1968,6 @@ PHP_METHOD(HttpRequest, clearHistory)
  */
 PHP_METHOD(HttpRequest, send)
 {
-       http_request_body body = {0, NULL, 0};
        getObject(http_request_object, obj);
 
        NO_ARGS;
@@ -2003,12 +1982,12 @@ PHP_METHOD(HttpRequest, send)
 
        RETVAL_NULL();
        
-       if (    (SUCCESS == http_request_object_requesthandler(obj, getThis(), &body)) &&
-                       (SUCCESS == http_request_exec(obj->ch, NULL, &obj->response, &obj->request)) &&
-                       (SUCCESS == http_request_object_responsehandler(obj, getThis()))) {
-               RETVAL_OBJECT(GET_PROP(obj, responseMessage));
+       if (SUCCESS == http_request_object_requesthandler(obj, getThis())) {
+               http_request_exec(&obj->request);
+               if (SUCCESS == http_request_object_responsehandler(obj, getThis())) {
+                       RETVAL_OBJECT(GET_PROP(obj, responseMessage));
+               }
        }
-       http_request_body_dtor(&body);
 
        SET_EH_NORMAL();
 }
index 2a297d6..6bc4353 100644 (file)
@@ -38,7 +38,6 @@ ZEND_EXTERN_MODULE_GLOBALS(http);
 #      define curl_multi_strerror(dummy) "unknown error"
 #endif
 
-static void http_request_pool_freebody(http_request_callback_ctx **body);
 static int http_request_pool_compare_handles(void *h1, void *h2);
 
 /* {{{ http_request_pool *http_request_pool_init(http_request_pool *) */
@@ -66,7 +65,6 @@ PHP_HTTP_API http_request_pool *_http_request_pool_init(http_request_pool *pool
        pool->unfinished = 0;
        zend_llist_init(&pool->finished, sizeof(zval *), (llist_dtor_func_t) ZVAL_PTR_DTOR, 0);
        zend_llist_init(&pool->handles, sizeof(zval *), (llist_dtor_func_t) ZVAL_PTR_DTOR, 0);
-       zend_llist_init(&pool->bodies, sizeof(http_request_callback_ctx *), (llist_dtor_func_t) http_request_pool_freebody, 0);
        
 #if HTTP_DEBUG_REQPOOLS
        fprintf(stderr, "Initialized request pool %p\n", pool);
@@ -87,32 +85,24 @@ PHP_HTTP_API STATUS _http_request_pool_attach(http_request_pool *pool, zval *req
        
        if (req->pool) {
                http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "HttpRequest object(#%d) is already member of %s HttpRequestPool", Z_OBJ_HANDLE_P(request), req->pool == pool ? "this" : "another");
+       } else if (SUCCESS != http_request_object_requesthandler(req, request)) {
+               http_error_ex(HE_WARNING, HTTP_E_REQUEST, "Could not initialize HttpRequest object for attaching to the HttpRequestPool");
        } else {
-               http_request_callback_ctx *body = http_request_callback_data_ex(http_request_body_new(), 0);
+               CURLMcode code = curl_multi_add_handle(pool->ch, req->request.ch);
 
-               if (SUCCESS != http_request_pool_requesthandler(request, body->data)) {
-                       http_error_ex(HE_WARNING, HTTP_E_REQUEST, "Could not initialize HttpRequest object for attaching to the HttpRequestPool");
+               if ((CURLM_OK != code) && (CURLM_CALL_MULTI_PERFORM != code)) {
+                       http_error_ex(HE_WARNING, HTTP_E_REQUEST_POOL, "Could not attach HttpRequest object to the HttpRequestPool: %s", curl_multi_strerror(code));
                } else {
-                       CURLMcode code = curl_multi_add_handle(pool->ch, req->ch);
+                       req->pool = pool;
 
-                       if ((CURLM_OK != code) && (CURLM_CALL_MULTI_PERFORM != code)) {
-                               http_error_ex(HE_WARNING, HTTP_E_REQUEST_POOL, "Could not attach HttpRequest object to the HttpRequestPool: %s", curl_multi_strerror(code));
-                       } else {
-                               req->pool = pool;
-
-                               zend_llist_add_element(&pool->handles, &request);
-                               zend_llist_add_element(&pool->bodies, &body);
-
-                               ZVAL_ADDREF(request);
+                       ZVAL_ADDREF(request);
+                       zend_llist_add_element(&pool->handles, &request);
 
 #if HTTP_DEBUG_REQPOOLS
-                               fprintf(stderr, "> %d HttpRequests attached to pool %p\n", zend_llist_count(&pool->handles), pool);
+                       fprintf(stderr, "> %d HttpRequests attached to pool %p\n", zend_llist_count(&pool->handles), pool);
 #endif
-                               return SUCCESS;
-                       }
+                       return SUCCESS;
                }
-               efree(body->data);
-               efree(body);
        }
        return FAILURE;
 }
@@ -135,7 +125,7 @@ PHP_HTTP_API STATUS _http_request_pool_detach(http_request_pool *pool, zval *req
 #endif
        } else if (req->pool != pool) {
                http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "HttpRequest object(#%d) is not attached to this HttpRequestPool", Z_OBJ_HANDLE_P(request));
-       } else if (CURLM_OK != (code = curl_multi_remove_handle(pool->ch, req->ch))) {
+       } else if (CURLM_OK != (code = curl_multi_remove_handle(pool->ch, req->request.ch))) {
                http_error_ex(HE_WARNING, HTTP_E_REQUEST_POOL, "Could not detach HttpRequest object from the HttpRequestPool: %s", curl_multi_strerror(code));
        } else {
                req->pool = NULL;
@@ -186,13 +176,6 @@ PHP_HTTP_API void _http_request_pool_detach_all(http_request_pool *pool TSRMLS_D
                }
                efree(handles);
        }
-       
-#if HTTP_DEBUG_REQPOOLS
-       fprintf(stderr, "Destroying %d request bodies of pool %p\n", zend_llist_count(&pool->bodies), pool);
-#endif
-       
-       /* free created bodies too */
-       zend_llist_clean(&pool->bodies);
 }
 
 /* {{{ STATUS http_request_pool_send(http_request_pool *) */
@@ -231,7 +214,6 @@ PHP_HTTP_API void _http_request_pool_dtor(http_request_pool *pool TSRMLS_DC)
        pool->unfinished = 0;
        zend_llist_clean(&pool->finished);
        zend_llist_clean(&pool->handles);
-       zend_llist_clean(&pool->bodies);
        curl_multi_cleanup(pool->ch);
 }
 /* }}} */
@@ -288,24 +270,12 @@ PHP_HTTP_API int _http_request_pool_perform(http_request_pool *pool TSRMLS_DC)
 }
 /* }}} */
 
-/* {{{ STATUS http_request_pool_requesthandler(zval *, http_request_body *) */
-STATUS _http_request_pool_requesthandler(zval *request, http_request_body *body TSRMLS_DC)
-{
-       getObjectEx(http_request_object, req, request);
-       if (SUCCESS == http_request_object_requesthandler(req, request, body)) {
-               http_request_conv(req->ch, &req->response, &req->request);
-               return SUCCESS;
-       }
-       return FAILURE;
-}
-/* }}} */
-
 /* {{{ void http_request_pool_responsehandler(zval **) */
 void _http_request_pool_responsehandler(zval **req, CURL *ch TSRMLS_DC)
 {
        getObjectEx(http_request_object, obj, *req);
        
-       if (obj->ch == ch) {
+       if (obj->request.ch == ch) {
                
 #if HTTP_DEBUG_REQPOOLS
                fprintf(stderr, "Fetching data from HttpRequest(#%d) %p of pool %p\n", Z_OBJ_HANDLE_PP(req), obj, obj->pool);
@@ -380,16 +350,6 @@ void _http_request_pool_wrap_exception(zval *old_exception, zval *new_exception
 
 /*#*/
 
-/* {{{ static void http_request_pool_freebody(http_request_ctx **) */
-static void http_request_pool_freebody(http_request_callback_ctx **body)
-{
-       HTTP_REQUEST_CALLBACK_DATA(*body, http_request_body *, b);
-       http_request_body_free(&b);
-       efree(*body);
-       *body = NULL;
-}
-/* }}} */
-
 /* {{{ static int http_request_pool_compare_handles(void *, void *) */
 static int http_request_pool_compare_handles(void *h1, void *h2)
 {
index b963654..ab532d2 100644 (file)
@@ -43,8 +43,10 @@ HttpUtil, HttpMessage, HttpRequest, HttpRequestPool; HttpResponse (PHP-5.1)
  <license>BSD, revised</license>
  <notes><![CDATA[
 + Added 'bodyonly' request option
++ Added IOCTL callback for cURL
 
 * Fixed bug which caused GZIP encoded archives to be decoded
+* Fixed several memory leaks and inconspicuous access violations
 ]]></notes>
  <contents>
   <dir name="/">
index 3a64383..e646c20 100644 (file)
@@ -85,15 +85,6 @@ ZEND_BEGIN_MODULE_GLOBALS(http)
                        char *allowed;
                        HashTable custom;
                } methods;
-
-#ifdef HTTP_HAVE_CURL
-               struct _http_globals_request_copies {
-                       zend_llist strings;
-                       zend_llist slists;
-                       zend_llist contexts;
-                       zend_llist convs;
-               } copies;
-#endif /* HTTP_HAVE_CURL */
        } request;
 
 #ifdef ZEND_ENGINE_2
index 2da5f22..4a2de45 100644 (file)
 
 #ifdef HTTP_HAVE_CURL
 
+#include "php_http_request_body_api.h"
 #include "php_http_request_method_api.h"
 
 extern PHP_MINIT_FUNCTION(http_request);
 extern PHP_MSHUTDOWN_FUNCTION(http_request);
 
-#define HTTP_REQUEST_BODY_CSTRING              1
-#define HTTP_REQUEST_BODY_CURLPOST             2
-#define HTTP_REQUEST_BODY_UPLOADFILE   3
 typedef struct {
-       int type;
-       void *data;
-       size_t size;
-} http_request_body;
-
-typedef struct {
-       void ***tsrm_ctx;
-       void *data;
-} http_request_callback_ctx;
-
-typedef struct {
-       phpstr *response;
-       phpstr *request;
-       curl_infotype last_info;
-} http_request_conv;
-
-#define HTTP_REQUEST_CALLBACK_DATA(from, type, var) \
-       http_request_callback_ctx *__CTX = (http_request_callback_ctx *) (from); \
-       TSRMLS_FETCH_FROM_CTX(__CTX->tsrm_ctx); \
-       type (var) = (type) (__CTX->data)
-
-#define http_request_callback_data(data) _http_request_callback_data_ex((data), 1 TSRMLS_CC)
-#define http_request_callback_data_ex(data, copy) _http_request_callback_data_ex((data), (copy) TSRMLS_CC)
-extern http_request_callback_ctx *_http_request_callback_data_ex(void *data, zend_bool cpy TSRMLS_DC);
-
-
-#define COPY_STRING            1
-#define        COPY_SLIST              2
-#define COPY_CONTEXT   3
-#define COPY_CONV              4
-#define http_request_data_copy(type, data) _http_request_data_copy((type), (data) TSRMLS_CC)
-extern void *_http_request_data_copy(int type, void *data TSRMLS_DC);
-#define http_request_data_free_string _http_request_data_free_string
-extern void _http_request_data_free_string(void *string);
-#define http_request_data_free_slist _http_request_data_free_slist
-extern void _http_request_data_free_slist(void *list);
-#define http_request_data_free_context _http_request_data_free_context
-extern void _http_request_data_free_context(void *context);
-#define http_request_data_free_conv _http_request_data_free_conv
-extern void _http_request_data_free_conv(void *conv);
-
-#define http_request_conv(ch, rs, rq) _http_request_conv((ch), (rs), (rq) TSRMLS_CC)
-extern void _http_request_conv(CURL *ch, phpstr* response, phpstr *request TSRMLS_DC);
-
-#define http_request_body_new() _http_request_body_new(TSRMLS_C)
-PHP_HTTP_API http_request_body *_http_request_body_new(TSRMLS_D);
-
-#define http_request_body_fill(b, fields, files) _http_request_body_fill((b), (fields), (files) TSRMLS_CC)
-PHP_HTTP_API STATUS _http_request_body_fill(http_request_body *body, HashTable *fields, HashTable *files TSRMLS_DC);
-
-#define http_request_body_dtor(b) _http_request_body_dtor((b) TSRMLS_CC)
-PHP_HTTP_API void _http_request_body_dtor(http_request_body *body TSRMLS_DC);
-
-#define http_request_body_free(b) _http_request_body_free((b) TSRMLS_CC)
-PHP_HTTP_API void _http_request_body_free(http_request_body **body TSRMLS_DC);
+       CURL *ch;
+       char *url;
+       http_request_method meth;
+       http_request_body *body;
+       
+       struct {
+               curl_infotype last_type;
+               phpstr request;
+               phpstr response;
+       } conv;
+       
+       HashTable info;
+       
+       struct {
+               phpstr cookies;
+               HashTable options;
+               struct curl_slist *headers;
+       } _cache;
+
+#ifdef ZTS
+       void ***tsrm_ls;
+#endif
 
-#define http_request_init(ch, meth, url, body, options) _http_request_init((ch), (meth), (url), (body), (options) TSRMLS_CC)
-PHP_HTTP_API STATUS _http_request_init(CURL *ch, http_request_method meth, char *url, http_request_body *body, HashTable *options TSRMLS_DC);
+} http_request;
 
-#define http_request_exec(ch, i, response, request) _http_request_exec((ch), (i), (response), (request) TSRMLS_CC)
-PHP_HTTP_API STATUS _http_request_exec(CURL *ch, HashTable *info, phpstr *response, phpstr *request TSRMLS_DC);
+#define http_request_init(r) _http_request_init_ex((r), NULL, 0, NULL TSRMLS_CC)
+#define http_request_init_ex(r, c, m, u) _http_request_init_ex((r), (c), (m), (u) TSRMLS_CC)
+PHP_HTTP_API http_request *_http_request_init_ex(http_request *request, CURL *ch, http_request_method meth, const char *url TSRMLS_DC);
 
-#define http_request_info(ch, i) _http_request_info((ch), (i) TSRMLS_CC)
-PHP_HTTP_API void _http_request_info(CURL *ch, HashTable *info TSRMLS_DC);
+#define http_request_dtor(r) _http_request_dtor((r))
+PHP_HTTP_API void _http_request_dtor(http_request *request);
 
-#define http_request(meth, url, body, opt, info, resp) _http_request_ex(NULL, (meth), (url), (body), (opt), (info), (resp) TSRMLS_CC)
-#define http_request_ex(ch, meth, url, body, opt, info, resp) _http_request_ex((ch), (meth), (url), (body), (opt), (info), (resp) TSRMLS_CC)
-PHP_HTTP_API STATUS _http_request_ex(CURL *ch, http_request_method meth, char *URL, http_request_body *body, HashTable *options, HashTable *info, phpstr *response TSRMLS_DC);
+#define http_request_free(r) _http_request_free((r))
+PHP_HTTP_API void _http_request_free(http_request **request);
 
-#define http_get(u, o, i, r) _http_request_ex(NULL, HTTP_GET, (u), NULL, (o), (i), (r) TSRMLS_CC)
-#define http_get_ex(c, u, o, i, r) _http_request_ex((c), HTTP_GET, (u), NULL, (o), (i), (r) TSRMLS_CC)
+#define http_request_reset(r) _http_request_reset(r)
+PHP_HTTP_API void _http_request_reset(http_request *r);
 
-#define http_head(u, o, i, r) _http_request_ex(NULL, HTTP_HEAD, (u), NULL, (o), (i), (r) TSRMLS_CC)
-#define http_head_ex(c, u, o, i, r) _http_request_ex((c), HTTP_HEAD, (u), NULL, (o), (i), (r) TSRMLS_CC)
+#define http_request_prepare(r, o) _http_request_prepare((r), (o))
+PHP_HTTP_API STATUS _http_request_prepare(http_request *request, HashTable *options);
 
-#define http_post(u, b, o, i, r) _http_request_ex(NULL, HTTP_POST, (u), (b), (o), (i), (r) TSRMLS_CC)
-#define http_post_ex(c, u, b, o, i, r) _http_request_ex((c), HTTP_POST, (u), (b), (o), (i), (r) TSRMLS_CC)
+#define http_request_exec(r) _http_request_exec((r))
+PHP_HTTP_API void _http_request_exec(http_request *request);
 
-#define http_put(u, b, o, i, r) _http_request_ex(NULL, HTTP_PUT, (u), (b), (o), (i), (r) TSRMLS_CC)
-#define http_put_ex(c, u, b, o, i, r) _http_request_ex((c), HTTP_PUT, (u), (b), (o), (i), (r) TSRMLS_CC)
+#define http_request_info(r, i) _http_request_info((r), (i))
+PHP_HTTP_API void _http_request_info(r, i);
 
 #endif
 #endif
diff --git a/php_http_request_body_api.h b/php_http_request_body_api.h
new file mode 100644 (file)
index 0000000..cd6f6a4
--- /dev/null
@@ -0,0 +1,52 @@
+/*
+    +--------------------------------------------------------------------+
+    | PECL :: http                                                       |
+    +--------------------------------------------------------------------+
+    | Redistribution and use in source and binary forms, with or without |
+    | modification, are permitted provided that the conditions mentioned |
+    | in the accompanying LICENSE file are met.                          |
+    +--------------------------------------------------------------------+
+    | Copyright (c) 2004-2005, Michael Wallner <mike@php.net>            |
+    +--------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifndef PHP_HTTP_REQUEST_BODY_API_H
+#define PHP_HTTP_REQUEST_BODY_API_H
+
+#ifdef HTTP_HAVE_CURL
+
+#define HTTP_REQUEST_BODY_CSTRING              1
+#define HTTP_REQUEST_BODY_CURLPOST             2
+#define HTTP_REQUEST_BODY_UPLOADFILE   3
+typedef struct {
+       int type;
+       void *data;
+       size_t size;
+} http_request_body;
+
+#define http_request_body_new() _http_request_body_new(TSRMLS_C)
+PHP_HTTP_API http_request_body *_http_request_body_new(TSRMLS_D);
+
+#define http_request_body_fill(b, fields, files) _http_request_body_fill((b), (fields), (files) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_request_body_fill(http_request_body *body, HashTable *fields, HashTable *files TSRMLS_DC);
+
+#define http_request_body_dtor(b) _http_request_body_dtor((b) TSRMLS_CC)
+PHP_HTTP_API void _http_request_body_dtor(http_request_body *body TSRMLS_DC);
+
+#define http_request_body_free(b) _http_request_body_free((b) TSRMLS_CC)
+PHP_HTTP_API void _http_request_body_free(http_request_body **body TSRMLS_DC);
+
+#endif
+#endif
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
+
index d1ffb7e..c0aaebf 100644 (file)
 
 typedef struct {
        zend_object zo;
-       CURL *ch;
+       http_request request;
        http_request_pool *pool;
-       phpstr response;
-       phpstr request;
        phpstr history;
 } http_request_object;
 
@@ -42,8 +40,8 @@ extern zend_object_value _http_request_object_clone_obj(zval *zobject TSRMLS_DC)
 #define http_request_object_free(o) _http_request_object_free((o) TSRMLS_CC)
 extern void _http_request_object_free(zend_object *object TSRMLS_DC);
 
-#define http_request_object_requesthandler(req, this, body) _http_request_object_requesthandler((req), (this), (body) TSRMLS_CC)
-extern STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_ptr, http_request_body *body TSRMLS_DC);
+#define http_request_object_requesthandler(req, this) _http_request_object_requesthandler((req), (this) TSRMLS_CC)
+extern STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_ptr TSRMLS_DC);
 #define http_request_object_responsehandler(req, this) _http_request_object_responsehandler((req), (this) TSRMLS_CC)
 extern STATUS _http_request_object_responsehandler(http_request_object *obj, zval *this_ptr TSRMLS_DC);
 
index 1ae2056..78dbdb2 100644 (file)
@@ -20,14 +20,11 @@ typedef struct {
        CURLM *ch;
        zend_llist finished;
        zend_llist handles;
-       zend_llist bodies;
        int unfinished;
 } http_request_pool;
 
 #define http_request_pool_responsehandler _http_request_pool_responsehandler
 extern void _http_request_pool_responsehandler(zval **req, CURL *ch TSRMLS_DC);
-#define http_request_pool_requesthandler(r, b) _http_request_pool_requesthandler((r), (b) TSRMLS_CC)
-extern STATUS _http_request_pool_requesthandler(zval *request, http_request_body *body TSRMLS_DC);
 
 #define http_request_pool_try \
        { \