#include "php_http_api.h"
#include "php_http_client.h"
+#include "php_http_client_curl_event.h"
+#include "php_http_client_curl_user.h"
#if PHP_HTTP_HAVE_CURL
-#if PHP_HTTP_HAVE_EVENT
-# if !PHP_HTTP_HAVE_EVENT2 && /* just be really sure */ !(LIBEVENT_VERSION_NUMBER >= 0x02000000)
-# include <event.h>
-# define event_base_new event_init
-# define event_assign(e, b, s, a, cb, d) do {\
- event_set(e, s, a, cb, d); \
- event_base_set(b, e); \
- } while(0)
-# else
-# if PHP_HTTP_HAVE_EVENT2
-# include <event2/event.h>
-# include <event2/event_struct.h>
-# else
-# error "libevent presence is unknown"
-# endif
-# endif
-# ifndef DBG_EVENTS
-# define DBG_EVENTS 0
-# endif
-#endif
-
#ifdef PHP_HTTP_HAVE_OPENSSL
# include <openssl/ssl.h>
#endif
# include <gnutls.h>
#endif
-typedef struct php_http_client_curl_handle {
- CURLM *multi;
- CURLSH *share;
-} php_http_client_curl_handle_t;
-
-typedef struct php_http_client_curl {
- php_http_client_curl_handle_t *handle;
-
- int unfinished; /* int because of curl_multi_perform() */
-
-#if PHP_HTTP_HAVE_EVENT
- struct event_base *evbase;
- struct event *timeout;
- unsigned useevents:1;
-#endif
-} php_http_client_curl_t;
-
typedef struct php_http_client_curl_handler {
CURL *handle;
php_resource_factory_t *rf;
php_http_buffer_t cookies;
php_http_buffer_t ranges;
- long redirects;
- unsigned range_request:1;
- unsigned encode_cookies:1;
-
struct {
uint count;
double delay;
} retry;
+ long redirects;
+ unsigned range_request:1;
+ unsigned encode_cookies:1;
+
} options;
} php_http_client_curl_handler_t;
return st;
}
-static void *php_http_curle_ctor(void *opaque, void *init_arg TSRMLS_DC)
+static void *php_http_curle_ctor(void *opaque, void *init_arg)
{
void *ch;
return NULL;
}
-static void *php_http_curle_copy(void *opaque, void *handle TSRMLS_DC)
+static void *php_http_curle_copy(void *opaque, void *handle)
{
void *ch;
return NULL;
}
-static void php_http_curle_dtor(void *opaque, void *handle TSRMLS_DC)
+static void php_http_curle_dtor(void *opaque, void *handle)
{
php_http_curle_storage_t *st = php_http_curle_get_storage(handle);
php_http_curle_dtor
};
-static void *php_http_curlm_ctor(void *opaque, void *init_arg TSRMLS_DC)
+static void *php_http_curlm_ctor(void *opaque, void *init_arg)
{
php_http_client_curl_handle_t *curl = calloc(1, sizeof(*curl));
return curl;
}
-static void php_http_curlm_dtor(void *opaque, void *handle TSRMLS_DC)
+static void php_http_curlm_dtor(void *opaque, void *handle)
{
php_http_client_curl_handle_t *curl = handle;
static size_t php_http_curle_read_callback(void *data, size_t len, size_t n, void *ctx)
{
- php_http_message_body_t *body = ctx;
-
- if (body && body->stream_id) {
- php_stream *s = php_http_message_body_stream(body);
+ php_stream *s = php_http_message_body_stream(ctx);
- if (s) {
- TSRMLS_FETCH_FROM_CTX(body->ts);
- return php_stream_read(s, data, len * n);
- } else abort();
+ if (s) {
+ return php_stream_read(s, data, len * n);
}
return 0;
}
#endif
{
php_http_client_curl_handler_t *h = ctx;
- zend_bool update = 0;
if (h->progress.dl.total != dltotal
|| h->progress.dl.now != dlnow
|| h->progress.ul.total != ultotal
|| h->progress.ul.now != ulnow
) {
- update = 1;
-
h->progress.dl.total = dltotal;
h->progress.dl.now = dlnow;
h->progress.ul.total = ultotal;
h->progress.ul.now = ulnow;
}
- if (update && h->client->callback.progress.func) {
+ if (h->client->callback.progress.func) {
h->client->callback.progress.func(h->client->callback.progress.arg, h->client, &h->queue, &h->progress);
}
static int php_http_curle_seek_callback(void *userdata, curl_off_t offset, int origin)
{
php_http_message_body_t *body = userdata;
- TSRMLS_FETCH_FROM_CTX(body->ts);
if (!body) {
return 1;
static int php_http_curle_raw_callback(CURL *ch, curl_infotype type, char *data, size_t length, void *ctx)
{
php_http_client_curl_handler_t *h = ctx;
+ unsigned utype = PHP_HTTP_CLIENT_DEBUG_INFO;
/* catch progress */
switch (type) {
h->client->callback.progress.func(h->client->callback.progress.arg, h->client, &h->queue, &h->progress);
}
break;
+
case CURLINFO_HEADER_OUT:
- case CURLINFO_DATA_OUT:
+ utype |= PHP_HTTP_CLIENT_DEBUG_HEADER;
+ goto data_out;
+
case CURLINFO_SSL_DATA_OUT:
+ utype |= PHP_HTTP_CLIENT_DEBUG_SSL;
+ goto data_out;
+
+ case CURLINFO_DATA_OUT:
+ data_out:
+ utype |= PHP_HTTP_CLIENT_DEBUG_OUT;
h->progress.info = "send";
break;
+
case CURLINFO_HEADER_IN:
- case CURLINFO_DATA_IN:
+ utype |= PHP_HTTP_CLIENT_DEBUG_HEADER;
+ goto data_in;
+
case CURLINFO_SSL_DATA_IN:
+ utype |= PHP_HTTP_CLIENT_DEBUG_SSL;
+ goto data_in;
+
+ case CURLINFO_DATA_IN:
+ data_in:
+ utype |= PHP_HTTP_CLIENT_DEBUG_IN;
h->progress.info = "receive";
break;
+
default:
break;
}
+ if (h->client->callback.debug.func) {
+ h->client->callback.debug.func(h->client->callback.debug.arg, h->client, &h->queue, utype, data, length);
+ }
+
#if 0
/* debug */
_dpf(type, data, length);
static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
{
- char *c;
- long l;
- double d;
- struct curl_slist *s, *p;
- zval *subarray, array;
- INIT_PZVAL_ARRAY(&array, info);
+ char *c = NULL;
+ long l = 0;
+ double d = 0;
+ struct curl_slist *s = NULL, *p = NULL;
+ zval tmp = {{0}};
/* BEGIN::CURLINFO */
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_EFFECTIVE_URL, &c)) {
- add_assoc_string_ex(&array, "effective_url", sizeof("effective_url"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "effective_url", lenof("effective_url"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_RESPONSE_CODE, &l)) {
- add_assoc_long_ex(&array, "response_code", sizeof("response_code"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "response_code", lenof("response_code"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_TOTAL_TIME, &d)) {
- add_assoc_double_ex(&array, "total_time", sizeof("total_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "total_time", lenof("total_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NAMELOOKUP_TIME, &d)) {
- add_assoc_double_ex(&array, "namelookup_time", sizeof("namelookup_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "namelookup_time", lenof("namelookup_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONNECT_TIME, &d)) {
- add_assoc_double_ex(&array, "connect_time", sizeof("connect_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "connect_time", lenof("connect_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRETRANSFER_TIME, &d)) {
- add_assoc_double_ex(&array, "pretransfer_time", sizeof("pretransfer_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "pretransfer_time", lenof("pretransfer_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_UPLOAD, &d)) {
- add_assoc_double_ex(&array, "size_upload", sizeof("size_upload"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "size_upload", lenof("size_upload"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_DOWNLOAD, &d)) {
- add_assoc_double_ex(&array, "size_download", sizeof("size_download"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "size_download", lenof("size_download"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SPEED_DOWNLOAD, &d)) {
- add_assoc_double_ex(&array, "speed_download", sizeof("speed_download"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "speed_download", lenof("speed_download"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SPEED_UPLOAD, &d)) {
- add_assoc_double_ex(&array, "speed_upload", sizeof("speed_upload"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "speed_upload", lenof("speed_upload"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HEADER_SIZE, &l)) {
- add_assoc_long_ex(&array, "header_size", sizeof("header_size"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "header_size", lenof("header_size"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REQUEST_SIZE, &l)) {
- add_assoc_long_ex(&array, "request_size", sizeof("request_size"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "request_size", lenof("request_size"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SSL_VERIFYRESULT, &l)) {
- add_assoc_long_ex(&array, "ssl_verifyresult", sizeof("ssl_verifyresult"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "ssl_verifyresult", lenof("ssl_verifyresult"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_FILETIME, &l)) {
- add_assoc_long_ex(&array, "filetime", sizeof("filetime"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "filetime", lenof("filetime"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d)) {
- add_assoc_double_ex(&array, "content_length_download", sizeof("content_length_download"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "content_length_download", lenof("content_length_download"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONTENT_LENGTH_UPLOAD, &d)) {
- add_assoc_double_ex(&array, "content_length_upload", sizeof("content_length_upload"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "content_length_upload", lenof("content_length_upload"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_STARTTRANSFER_TIME, &d)) {
- add_assoc_double_ex(&array, "starttransfer_time", sizeof("starttransfer_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "starttransfer_time", lenof("starttransfer_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONTENT_TYPE, &c)) {
- add_assoc_string_ex(&array, "content_type", sizeof("content_type"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "content_type", lenof("content_type"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_TIME, &d)) {
- add_assoc_double_ex(&array, "redirect_time", sizeof("redirect_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "redirect_time", lenof("redirect_time"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_COUNT, &l)) {
- add_assoc_long_ex(&array, "redirect_count", sizeof("redirect_count"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "redirect_count", lenof("redirect_count"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTP_CONNECTCODE, &l)) {
- add_assoc_long_ex(&array, "connect_code", sizeof("connect_code"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "connect_code", lenof("connect_code"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTPAUTH_AVAIL, &l)) {
- add_assoc_long_ex(&array, "httpauth_avail", sizeof("httpauth_avail"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "httpauth_avail", lenof("httpauth_avail"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PROXYAUTH_AVAIL, &l)) {
- add_assoc_long_ex(&array, "proxyauth_avail", sizeof("proxyauth_avail"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "proxyauth_avail", lenof("proxyauth_avail"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_OS_ERRNO, &l)) {
- add_assoc_long_ex(&array, "os_errno", sizeof("os_errno"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "os_errno", lenof("os_errno"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NUM_CONNECTS, &l)) {
- add_assoc_long_ex(&array, "num_connects", sizeof("num_connects"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "num_connects", lenof("num_connects"), &tmp);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SSL_ENGINES, &s)) {
- MAKE_STD_ZVAL(subarray);
- array_init(subarray);
+ array_init(&tmp);
for (p = s; p; p = p->next) {
if (p->data) {
- add_next_index_string(subarray, p->data, 1);
+ add_next_index_string(&tmp, p->data);
}
}
- add_assoc_zval_ex(&array, "ssl_engines", sizeof("ssl_engines"), subarray);
+ zend_hash_str_update(info, "ssl_engines", lenof("ssl_engines"), &tmp);
curl_slist_free_all(s);
}
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_URL, &c)) {
- add_assoc_string_ex(&array, "redirect_url", sizeof("redirect_url"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "redirect_url", lenof("redirect_url"), &tmp);
}
#if PHP_HTTP_CURL_VERSION(7,19,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRIMARY_IP, &c)) {
- add_assoc_string_ex(&array, "primary_ip", sizeof("primary_ip"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "primary_ip", lenof("primary_ip"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,19,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_APPCONNECT_TIME, &d)) {
- add_assoc_double_ex(&array, "appconnect_time", sizeof("appconnect_time"), d);
+ ZVAL_DOUBLE(&tmp, d);
+ zend_hash_str_update(info, "appconnect_time", lenof("appconnect_time"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,19,4)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONDITION_UNMET, &l)) {
- add_assoc_long_ex(&array, "condition_unmet", sizeof("condition_unmet"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "condition_unmet", lenof("condition_unmet"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,21,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRIMARY_PORT, &l)) {
- add_assoc_long_ex(&array, "primary_port", sizeof("primary_port"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "primary_port", lenof("primary_port"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,21,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_LOCAL_IP, &c)) {
- add_assoc_string_ex(&array, "local_ip", sizeof("local_ip"), c ? c : "", 1);
+ ZVAL_STRING(&tmp, STR_PTR(c));
+ zend_hash_str_update(info, "local_ip", lenof("local_ip"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,21,0)
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_LOCAL_PORT, &l)) {
- add_assoc_long_ex(&array, "local_port", sizeof("local_port"), l);
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "local_port", lenof("local_port"), &tmp);
+ }
+#endif
+#if PHP_HTTP_CURL_VERSION(7,50,0)
+ if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTP_VERSION, &l)) {
+ ZVAL_LONG(&tmp, l);
+ zend_hash_str_update(info, "http_version", lenof("http_version"), &tmp);
}
#endif
#if PHP_HTTP_CURL_VERSION(7,34,0)
{
- zval *ti_array;
+ zval ti_array, subarray;
struct curl_tlssessioninfo *ti;
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_TLS_SESSION, &ti)) {
- const char *backend;
+ char *backend;
- MAKE_STD_ZVAL(subarray);
- ZVAL_NULL(subarray);
- MAKE_STD_ZVAL(ti_array);
- array_init(ti_array);
+ ZVAL_NULL(&subarray);
+ array_init(&ti_array);
switch (ti->backend) {
case CURLSSLBACKEND_NONE:
{
SSL_CTX *ctx = ti->internals;
- array_init(subarray);
- add_assoc_long_ex(subarray, ZEND_STRS("number"), SSL_CTX_sess_number(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("connect"), SSL_CTX_sess_connect(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("connect_good"), SSL_CTX_sess_connect_good(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("connect_renegotiate"), SSL_CTX_sess_connect_renegotiate(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("hits"), SSL_CTX_sess_hits(ctx));
- add_assoc_long_ex(subarray, ZEND_STRS("cache_full"), SSL_CTX_sess_cache_full(ctx));
+ array_init(&subarray);
+ add_assoc_long_ex(&subarray, ZEND_STRL("number"), SSL_CTX_sess_number(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("connect"), SSL_CTX_sess_connect(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("connect_good"), SSL_CTX_sess_connect_good(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("connect_renegotiate"), SSL_CTX_sess_connect_renegotiate(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("hits"), SSL_CTX_sess_hits(ctx));
+ add_assoc_long_ex(&subarray, ZEND_STRL("cache_full"), SSL_CTX_sess_cache_full(ctx));
}
#endif
break;
gnutls_session_t sess = ti->internals;
char *desc;
- array_init(subarray);
+ array_init(&subarray);
if ((desc = gnutls_session_get_desc(sess))) {
- add_assoc_string_ex(subarray, ZEND_STRS("desc"), desc, 1);
+ add_assoc_string_ex(&subarray, ZEND_STRL("desc"), desc);
gnutls_free(desc);
}
- add_assoc_bool_ex(subarray, ZEND_STRS("resumed"), gnutls_session_is_resumed(sess));
+ add_assoc_bool_ex(&subarray, ZEND_STRL("resumed"), gnutls_session_is_resumed(sess));
}
#endif
break;
default:
backend = "unknown";
}
- add_assoc_string_ex(ti_array, ZEND_STRS("backend"), estrdup(backend), 0);
- add_assoc_zval_ex(ti_array, ZEND_STRS("internals"), subarray);
- add_assoc_zval_ex(&array, "tls_session", sizeof("tls_session"), ti_array);
+ add_assoc_string_ex(&ti_array, ZEND_STRL("backend"), backend);
+ add_assoc_zval_ex(&ti_array, ZEND_STRL("internals"), &subarray);
+ zend_hash_str_update(info, "tls_session", lenof("tls_session"), &ti_array);
}
}
#endif
#if (PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)) || (PHP_HTTP_CURL_VERSION(7,34,0) && defined(PHP_HTTP_HAVE_NSS)) || (PHP_HTTP_CURL_VERSION(7,42,0) && defined(PHP_HTTP_HAVE_GNUTLS)) || (PHP_HTTP_CURL_VERSION(7,39,0) && defined(PHP_HTTP_HAVE_GSKIT))
{
int i;
- zval *ci_array;
+ zval ci_array, subarray;
struct curl_certinfo *ci;
char *colon, *keyname;
if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CERTINFO, &ci)) {
- MAKE_STD_ZVAL(ci_array);
- array_init(ci_array);
+ array_init(&ci_array);
for (i = 0; i < ci->num_of_certs; ++i) {
s = ci->certinfo[i];
- MAKE_STD_ZVAL(subarray);
- array_init(subarray);
+ array_init(&subarray);
for (p = s; p; p = p->next) {
if (p->data) {
if ((colon = strchr(p->data, ':'))) {
keyname = estrndup(p->data, colon - p->data);
- add_assoc_string_ex(subarray, keyname, colon - p->data + 1, colon + 1, 1);
+ add_assoc_string_ex(&subarray, keyname, colon - p->data, colon + 1);
efree(keyname);
} else {
- add_next_index_string(subarray, p->data, 1);
+ add_next_index_string(&subarray, p->data);
}
}
}
- add_next_index_zval(ci_array, subarray);
+ add_next_index_zval(&ci_array, &subarray);
}
- add_assoc_zval_ex(&array, "certinfo", sizeof("certinfo"), ci_array);
+ zend_hash_str_update(info, "certinfo", lenof("certinfo"), &ci_array);
}
}
#endif
{
php_http_curle_storage_t *st = php_http_curle_get_storage(ch);
- add_assoc_long_ex(&array, "curlcode", sizeof("curlcode"), st->errorcode);
- add_assoc_string_ex(&array, "error", sizeof("error"), st->errorbuffer, 1);
+ ZVAL_LONG(&tmp, st->errorcode);
+ zend_hash_str_update(info, "curlcode", lenof("curlcode"), &tmp);
+ ZVAL_STRING(&tmp, st->errorbuffer);
+ zend_hash_str_update(info, "error", lenof("error"), &tmp);
}
return SUCCESS;
return handle == ((php_http_client_curl_handler_t *) e->opaque)->handle;
}
-static php_http_message_t *php_http_curlm_responseparser(php_http_client_curl_handler_t *h TSRMLS_DC)
+static php_http_message_t *php_http_curlm_responseparser(php_http_client_curl_handler_t *h)
{
php_http_message_t *response;
php_http_header_parser_t parser;
- zval *zh;
+ zval *zh, tmp;
- response = php_http_message_init(NULL, 0, h->response.body TSRMLS_CC);
- php_http_header_parser_init(&parser TSRMLS_CC);
+ response = php_http_message_init(NULL, 0, h->response.body);
+ php_http_header_parser_init(&parser);
while (h->response.headers.used) {
php_http_header_parser_state_t st = php_http_header_parser_parse(&parser,
&h->response.headers, PHP_HTTP_HEADER_PARSER_CLEANUP, &response->hdrs,
php_http_message_body_addref(h->response.body);
/* let's update the response headers */
- if ((zh = php_http_message_header(response, ZEND_STRL("Content-Length"), 1))) {
- zend_hash_update(&response->hdrs, "X-Original-Content-Length", sizeof("X-Original-Content-Length"), &zh, sizeof(zval *), NULL);
+ if ((zh = php_http_message_header(response, ZEND_STRL("Content-Length")))) {
+ ZVAL_COPY(&tmp, zh);
+ zend_hash_str_update(&response->hdrs, "X-Original-Content-Length", lenof("X-Original-Content-Length"), &tmp);
}
- if ((zh = php_http_message_header(response, ZEND_STRL("Transfer-Encoding"), 0))) {
- zend_hash_update(&response->hdrs, "X-Original-Transfer-Encoding", sizeof("X-Original-Transfer-Encoding"), (void *) &zh, sizeof(zval *), NULL);
- zend_hash_del(&response->hdrs, "Transfer-Encoding", sizeof("Transfer-Encoding"));
+ if ((zh = php_http_message_header(response, ZEND_STRL("Transfer-Encoding")))) {
+ ZVAL_COPY(&tmp, zh);
+ zend_hash_str_del(&response->hdrs, "Transfer-Encoding", lenof("Transfer-Encoding"));
+ zend_hash_str_update(&response->hdrs, "X-Original-Transfer-Encoding", lenof("X-Original-Transfer-Encoding"), &tmp);
}
- if ((zh = php_http_message_header(response, ZEND_STRL("Content-Range"), 0))) {
- zend_hash_update(&response->hdrs, "X-Original-Content-Range", sizeof("X-Original-Content-Range"), &zh, sizeof(zval *), NULL);
- zend_hash_del(&response->hdrs, "Content-Range", sizeof("Content-Range"));
+ if ((zh = php_http_message_header(response, ZEND_STRL("Content-Range")))) {
+ ZVAL_COPY(&tmp, zh);
+ zend_hash_str_del(&response->hdrs, "Content-Range", lenof("Content-Range"));
+ zend_hash_str_update(&response->hdrs, "X-Original-Content-Range", lenof("X-Original-Content-Range"), &tmp);
}
- if ((zh = php_http_message_header(response, ZEND_STRL("Content-Encoding"), 0))) {
- zend_hash_update(&response->hdrs, "X-Original-Content-Encoding", sizeof("X-Original-Content-Encoding"), &zh, sizeof(zval *), NULL);
- zend_hash_del(&response->hdrs, "Content-Encoding", sizeof("Content-Encoding"));
+ if ((zh = php_http_message_header(response, ZEND_STRL("Content-Encoding")))) {
+ ZVAL_COPY(&tmp, zh);
+ zend_hash_str_del(&response->hdrs, "Content-Encoding", lenof("Content-Encoding"));
+ zend_hash_str_update(&response->hdrs, "X-Original-Content-Encoding", lenof("X-Original-Content-Encoding"), &tmp);
}
php_http_message_update_headers(response);
return response;
}
-static void php_http_curlm_responsehandler(php_http_client_t *context)
+void php_http_client_curl_responsehandler(php_http_client_t *context)
{
int err_count = 0, remaining = 0;
php_http_curle_storage_t *st, *err = NULL;
php_http_client_enqueue_t *enqueue;
php_http_client_curl_t *curl = context->ctx;
- TSRMLS_FETCH_FROM_CTX(context->ts);
do {
CURLMsg *msg = curl_multi_info_read(curl->handle->multi, &remaining);
if ((enqueue = php_http_client_enqueued(context, msg->easy_handle, compare_queue))) {
php_http_client_curl_handler_t *handler = enqueue->opaque;
- php_http_message_t *response = php_http_curlm_responseparser(handler TSRMLS_CC);
+ php_http_message_t *response = php_http_curlm_responseparser(handler);
if (response) {
context->callback.response.func(context->callback.response.arg, context, &handler->queue, &response);
int i = 0;
do {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s; %s (%s)", curl_easy_strerror(err[i].errorcode), err[i].errorbuffer, STR_PTR(err[i].url));
+ php_error_docref(NULL, E_WARNING, "%s; %s (%s)", curl_easy_strerror(err[i].errorcode), err[i].errorbuffer, STR_PTR(err[i].url));
if (err[i].url) {
efree(err[i].url);
}
}
}
-#if PHP_HTTP_HAVE_EVENT
-
-typedef struct php_http_curlm_event {
- struct event evnt;
- php_http_client_t *context;
-} php_http_curlm_event_t;
-
-static inline int etoca(short action) {
- switch (action & (EV_READ|EV_WRITE)) {
- case EV_READ:
- return CURL_CSELECT_IN;
- break;
- case EV_WRITE:
- return CURL_CSELECT_OUT;
- break;
- case EV_READ|EV_WRITE:
- return CURL_CSELECT_IN|CURL_CSELECT_OUT;
- break;
- default:
- return 0;
- }
-}
-
-static void php_http_curlm_timeout_callback(int socket, short action, void *event_data)
+void php_http_client_curl_loop(php_http_client_t *client, curl_socket_t s, int curl_action)
{
- php_http_client_t *context = event_data;
- php_http_client_curl_t *curl = context->ctx;
-
-#if DBG_EVENTS
- fprintf(stderr, "T");
-#endif
- if (curl->useevents) {
- CURLMcode rc;
- TSRMLS_FETCH_FROM_CTX(context->ts);
-
- /* ignore and use -1,0 on timeout */
- (void) socket;
- (void) action;
-
- while (CURLM_CALL_MULTI_PERFORM == (rc = curl_multi_socket_action(curl->handle->multi, CURL_SOCKET_TIMEOUT, 0, &curl->unfinished)));
-
- if (CURLM_OK != rc) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", curl_multi_strerror(rc));
- }
-
- php_http_curlm_responsehandler(context);
- }
-}
-
-static void php_http_curlm_event_callback(int socket, short action, void *event_data)
-{
- php_http_client_t *context = event_data;
- php_http_client_curl_t *curl = context->ctx;
-
-#if DBG_EVENTS
- fprintf(stderr, "E");
-#endif
- if (curl->useevents) {
- CURLMcode rc = CURLM_OK;
- TSRMLS_FETCH_FROM_CTX(context->ts);
-
- while (CURLM_CALL_MULTI_PERFORM == (rc = curl_multi_socket_action(curl->handle->multi, socket, etoca(action), &curl->unfinished)));
-
- if (CURLM_OK != rc) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", curl_multi_strerror(rc));
- }
-
- php_http_curlm_responsehandler(context);
-
- /* remove timeout if there are no transfers left */
- if (!curl->unfinished && event_initialized(curl->timeout) && event_pending(curl->timeout, EV_TIMEOUT, NULL)) {
- event_del(curl->timeout);
- }
- }
-}
-
-static int php_http_curlm_socket_callback(CURL *easy, curl_socket_t sock, int action, void *socket_data, void *assign_data)
-{
- php_http_client_t *context = socket_data;
- php_http_client_curl_t *curl = context->ctx;
+ CURLMcode rc;
+ php_http_client_curl_t *curl = client->ctx;
#if DBG_EVENTS
- fprintf(stderr, "S");
+ fprintf(stderr, "H");
#endif
- if (curl->useevents) {
- int events = EV_PERSIST;
- php_http_curlm_event_t *ev = assign_data;
- TSRMLS_FETCH_FROM_CTX(context->ts);
-
- if (!ev) {
- ev = ecalloc(1, sizeof(php_http_curlm_event_t));
- ev->context = context;
- curl_multi_assign(curl->handle->multi, sock, ev);
- } else {
- event_del(&ev->evnt);
- }
-
- switch (action) {
- case CURL_POLL_IN:
- events |= EV_READ;
- break;
- case CURL_POLL_OUT:
- events |= EV_WRITE;
- break;
- case CURL_POLL_INOUT:
- events |= EV_READ|EV_WRITE;
- break;
- case CURL_POLL_REMOVE:
- efree(ev);
- /* no break */
- case CURL_POLL_NONE:
- return 0;
-
- default:
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown socket action %d", action);
- return -1;
- }
+ do {
+ rc = curl_multi_socket_action(curl->handle->multi, s, curl_action, &curl->unfinished);
+ } while (CURLM_CALL_MULTI_PERFORM == rc);
- event_assign(&ev->evnt, curl->evbase, sock, events, php_http_curlm_event_callback, context);
- event_add(&ev->evnt, NULL);
+ if (CURLM_OK != rc) {
+ php_error_docref(NULL, E_WARNING, "%s", curl_multi_strerror(rc));
}
- return 0;
-}
-
-static void php_http_curlm_timer_callback(CURLM *multi, long timeout_ms, void *timer_data)
-{
- php_http_client_t *context = timer_data;
- php_http_client_curl_t *curl = context->ctx;
-
-#if DBG_EVENTS
- fprintf(stderr, "\ntimer <- timeout_ms: %ld\n", timeout_ms);
-#endif
- if (curl->useevents) {
-
- if (timeout_ms < 0) {
- php_http_curlm_timeout_callback(CURL_SOCKET_TIMEOUT, /*EV_READ|EV_WRITE*/0, context);
- } else if (timeout_ms > 0 || !event_initialized(curl->timeout) || !event_pending(curl->timeout, EV_TIMEOUT, NULL)) {
- struct timeval timeout;
-
- if (!event_initialized(curl->timeout)) {
- event_assign(curl->timeout, curl->evbase, CURL_SOCKET_TIMEOUT, 0, php_http_curlm_timeout_callback, context);
- }
-
- timeout.tv_sec = timeout_ms / 1000;
- timeout.tv_usec = (timeout_ms % 1000) * 1000;
-
- event_add(curl->timeout, &timeout);
- }
- }
+ php_http_client_curl_responsehandler(client);
}
-#endif /* HAVE_EVENT */
-
/* curl options */
static php_http_options_t php_http_curle_options, php_http_curlm_options;
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_SSL_VERIFYHOST, Z_BVAL_P(val) ? 2 : 0)) {
+ if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_SSL_VERIFYHOST, Z_TYPE_P(val) == IS_TRUE ? 2 : 0)) {
return FAILURE;
}
return SUCCESS;
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIESESSION, (long) Z_BVAL_P(val))) {
+ if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIESESSION, (long) (Z_TYPE_P(val) == IS_TRUE))) {
return FAILURE;
}
- if (Z_BVAL_P(val)) {
+ if (Z_TYPE_P(val) == IS_TRUE) {
if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIELIST, "SESS")) {
return FAILURE;
}
if (storage->cookiestore) {
pefree(storage->cookiestore, 1);
}
- if (val && Z_STRLEN_P(val)) {
+ if (val && Z_TYPE_P(val) == IS_STRING && Z_STRLEN_P(val)) {
storage->cookiestore = pestrndup(Z_STRVAL_P(val), Z_STRLEN_P(val), 1);
} else {
storage->cookiestore = NULL;
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (val && Z_TYPE_P(val) != IS_NULL) {
+ HashTable *ht = HASH_OF(val);
+
if (curl->options.encode_cookies) {
- if (SUCCESS == php_http_url_encode_hash_ex(HASH_OF(val), &curl->options.cookies, ZEND_STRL(";"), ZEND_STRL("="), NULL, 0 TSRMLS_CC)) {
+ if (SUCCESS == php_http_url_encode_hash_ex(ht, &curl->options.cookies, ZEND_STRL(";"), ZEND_STRL("="), NULL, 0)) {
php_http_buffer_fix(&curl->options.cookies);
if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIE, curl->options.cookies.data)) {
return FAILURE;
return FAILURE;
}
} else {
- HashPosition pos;
- php_http_array_hashkey_t cookie_key = php_http_array_hashkey_init(0);
- zval **cookie_val;
+ php_http_arrkey_t cookie_key;
+ zval *cookie_val;
- FOREACH_KEYVAL(pos, val, cookie_key, cookie_val) {
- zval *zv = php_http_ztyp(IS_STRING, *cookie_val);
+ ZEND_HASH_FOREACH_KEY_VAL(ht, cookie_key.h, cookie_key.key, cookie_val)
+ {
+ zend_string *zs = zval_get_string(cookie_val);
- php_http_array_hashkey_stringify(&cookie_key);
- php_http_buffer_appendf(&curl->options.cookies, "%s=%s; ", cookie_key.str, Z_STRVAL_P(zv));
- php_http_array_hashkey_stringfree(&cookie_key);
+ php_http_arrkey_stringify(&cookie_key, NULL);
+ php_http_buffer_appendf(&curl->options.cookies, "%s=%s; ", cookie_key.key->val, zs->val);
+ php_http_arrkey_dtor(&cookie_key);
- zval_ptr_dtor(&zv);
+ zend_string_release(zs);
}
+ ZEND_HASH_FOREACH_END();
php_http_buffer_fix(&curl->options.cookies);
if (curl->options.cookies.used) {
{
php_http_client_curl_handler_t *curl = userdata;
- curl->options.encode_cookies = Z_BVAL_P(val);
+ curl->options.encode_cookies = Z_TYPE_P(val) == IS_TRUE;
return SUCCESS;
}
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (Z_LVAL_P(val)) {
if (Z_LVAL_P(val) > 0) {
return FAILURE;
}
} else {
- if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, (long) sapi_get_request_time(TSRMLS_C) + Z_LVAL_P(val))) {
+ if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, (long) sapi_get_request_time() + Z_LVAL_P(val))) {
return FAILURE;
}
}
#if !PHP_HTTP_CURL_VERSION(7,21,6)
# define CURLOPT_ACCEPT_ENCODING CURLOPT_ENCODING
#endif
- if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_ACCEPT_ENCODING, Z_BVAL_P(val) ? "" : NULL)) {
+ if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_ACCEPT_ENCODING, Z_TYPE_P(val) == IS_TRUE ? "" : NULL)) {
return FAILURE;
}
return SUCCESS;
php_http_client_curl_handler_t *curl = userdata;
php_http_buffer_t header;
- if (Z_STRLEN_P(val)) {
+ if (val && Z_TYPE_P(val) == IS_STRING && Z_STRLEN_P(val)) {
zend_bool is_quoted = !((Z_STRVAL_P(val)[0] != '"') || (Z_STRVAL_P(val)[Z_STRLEN_P(val)-1] != '"'));
php_http_buffer_init(&header);
php_http_buffer_appendf(&header, is_quoted?"%s: %s":"%s: \"%s\"", curl->options.range_request?"If-Match":"If-None-Match", Z_STRVAL_P(val));
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
php_http_buffer_reset(&curl->options.ranges);
if (val && Z_TYPE_P(val) != IS_NULL) {
- HashPosition pos;
- zval **rr, **rb, **re;
-
- FOREACH_VAL(pos, val, rr) {
- if (Z_TYPE_PP(rr) == IS_ARRAY) {
- if (2 == php_http_array_list(Z_ARRVAL_PP(rr) TSRMLS_CC, 2, &rb, &re)) {
- if ( ((Z_TYPE_PP(rb) == IS_LONG) || ((Z_TYPE_PP(rb) == IS_STRING) && is_numeric_string(Z_STRVAL_PP(rb), Z_STRLEN_PP(rb), NULL, NULL, 1))) &&
- ((Z_TYPE_PP(re) == IS_LONG) || ((Z_TYPE_PP(re) == IS_STRING) && is_numeric_string(Z_STRVAL_PP(re), Z_STRLEN_PP(re), NULL, NULL, 1)))) {
- zval *rbl = php_http_ztyp(IS_LONG, *rb);
- zval *rel = php_http_ztyp(IS_LONG, *re);
-
- if ((Z_LVAL_P(rbl) >= 0) && (Z_LVAL_P(rel) >= 0)) {
- php_http_buffer_appendf(&curl->options.ranges, "%ld-%ld,", Z_LVAL_P(rbl), Z_LVAL_P(rel));
+ zval *rr, *rb, *re;
+ HashTable *ht = HASH_OF(val);
+
+ ZEND_HASH_FOREACH_VAL(ht, rr)
+ {
+ if (Z_TYPE_P(rr) == IS_ARRAY) {
+ if (2 == php_http_array_list(Z_ARRVAL_P(rr), 2, &rb, &re)) {
+ zend_long rbl = zval_get_long(rb), rel = zval_get_long(re);
+
+ if (rbl >= 0) {
+ if (rel > 0) {
+ php_http_buffer_appendf(&curl->options.ranges, "%ld-%ld,", rbl, rel);
+ } else {
+ php_http_buffer_appendf(&curl->options.ranges, "%ld-", rbl);
}
- zval_ptr_dtor(&rbl);
- zval_ptr_dtor(&rel);
+ } else if (rel > 0) {
+ php_http_buffer_appendf(&curl->options.ranges, "-%ld", rel);
}
-
}
}
}
+ ZEND_HASH_FOREACH_END();
if (curl->options.ranges.used) {
curl->options.range_request = 1;
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
long localport = 0, localportrange = 0;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (val && Z_TYPE_P(val) != IS_NULL) {
- zval **z_port_start, *zps_copy = NULL, **z_port_end, *zpe_copy = NULL;
+ zval *zps, *zpe;
- switch (php_http_array_list(Z_ARRVAL_P(val) TSRMLS_CC, 2, &z_port_start, &z_port_end)) {
+ switch (php_http_array_list(Z_ARRVAL_P(val), 2, &zps, &zpe)) {
case 2:
- zps_copy = php_http_ztyp(IS_LONG, *z_port_start);
- zpe_copy = php_http_ztyp(IS_LONG, *z_port_end);
- localportrange = labs(Z_LVAL_P(zps_copy)-Z_LVAL_P(zpe_copy))+1L;
+ localportrange = labs(zval_get_long(zps)-zval_get_long(zpe))+1L;
/* no break */
case 1:
- if (!zps_copy) {
- zps_copy = php_http_ztyp(IS_LONG, *z_port_start);
- }
- localport = (zpe_copy && Z_LVAL_P(zpe_copy) > 0) ? MIN(Z_LVAL_P(zps_copy), Z_LVAL_P(zpe_copy)) : Z_LVAL_P(zps_copy);
- zval_ptr_dtor(&zps_copy);
- if (zpe_copy) {
- zval_ptr_dtor(&zpe_copy);
- }
+ localport = (zval_get_long(zpe) > 0) ? MIN(zval_get_long(zps), zval_get_long(zpe)) : zval_get_long(zps);
break;
default:
break;
static ZEND_RESULT_CODE php_http_curle_option_set_proxyheader(php_http_option_t *opt, zval *val, void *userdata)
{
php_http_client_curl_handler_t *curl = userdata;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (val && Z_TYPE_P(val) != IS_NULL) {
- php_http_array_hashkey_t header_key = php_http_array_hashkey_init(0);
- zval **header_val, *header_cpy;
- HashPosition pos;
+ php_http_arrkey_t header_key;
+ zval *header_val;
php_http_buffer_t header;
php_http_buffer_init(&header);
- FOREACH_KEYVAL(pos, val, header_key, header_val) {
- if (header_key.type == HASH_KEY_IS_STRING) {
- header_cpy = php_http_ztyp(IS_STRING, *header_val);
- php_http_buffer_appendf(&header, "%s: %s", header_key.str, Z_STRVAL_P(header_cpy));
+ ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(val), header_key.h, header_key.key, header_val)
+ {
+ if (header_key.key) {
+ zend_string *zs = zval_get_string(header_val);
+
+ php_http_buffer_appendf(&header, "%s: %s", header_key.key->val, zs->val);
+ zend_string_release(zs);
+
php_http_buffer_fix(&header);
curl->options.proxyheaders = curl_slist_append(curl->options.proxyheaders, header.data);
php_http_buffer_reset(&header);
- zval_ptr_dtor(&header_cpy);
}
}
+ ZEND_HASH_FOREACH_END();
php_http_buffer_dtor(&header);
}
if (CURLE_OK != curl_easy_setopt(curl->handle, CURLOPT_PROXYHEADER, curl->options.proxyheaders)) {
{
php_http_client_curl_handler_t *curl = userdata;
CURL *ch = curl->handle;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (val && Z_TYPE_P(val) != IS_NULL) {
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
- HashPosition pos;
- zval **data;
-
- FOREACH_KEYVAL(pos, val, key, data) {
- zval *cpy = php_http_ztyp(IS_STRING, *data);
- curl->options.resolve = curl_slist_append(curl->options.resolve, Z_STRVAL_P(cpy));
- zval_ptr_dtor(&cpy);
+ HashTable *ht = HASH_OF(val);
+ zval *data;
+
+ ZEND_HASH_FOREACH_VAL(ht, data)
+ {
+ zend_string *zs = zval_get_string(data);
+ curl->options.resolve = curl_slist_append(curl->options.resolve, zs->val);
+ zend_string_release(zs);
}
+ ZEND_HASH_FOREACH_END();
if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_RESOLVE, curl->options.resolve)) {
return FAILURE;
}
#endif
-static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
+static void php_http_curle_options_init(php_http_options_t *registry)
{
php_http_option_t *opt;
/* url options */
#if PHP_HTTP_CURL_VERSION(7,42,0)
- php_http_option_register(registry, ZEND_STRL("path_as_is"), CURLOPT_PATH_AS_IS, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("path_as_is"), CURLOPT_PATH_AS_IS, _IS_BOOL);
#endif
/* proxy */
if ((opt = php_http_option_register(registry, ZEND_STRL("proxyauthtype"), CURLOPT_PROXYAUTH, IS_LONG))) {
Z_LVAL(opt->defval) = CURLAUTH_ANYSAFE;
}
- php_http_option_register(registry, ZEND_STRL("proxytunnel"), CURLOPT_HTTPPROXYTUNNEL, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("proxytunnel"), CURLOPT_HTTPPROXYTUNNEL, _IS_BOOL);
#if PHP_HTTP_CURL_VERSION(7,19,4)
php_http_option_register(registry, ZEND_STRL("noproxy"), CURLOPT_NOPROXY, IS_STRING);
#endif
Z_LVAL(opt->defval) = 5;
}
*/
- php_http_option_register(registry, ZEND_STRL("fresh_connect"), CURLOPT_FRESH_CONNECT, IS_BOOL);
- php_http_option_register(registry, ZEND_STRL("forbid_reuse"), CURLOPT_FORBID_REUSE, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("fresh_connect"), CURLOPT_FRESH_CONNECT, _IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("forbid_reuse"), CURLOPT_FORBID_REUSE, _IS_BOOL);
/* outgoing interface */
php_http_option_register(registry, ZEND_STRL("interface"), CURLOPT_INTERFACE, IS_STRING);
if ((opt = php_http_option_register(registry, ZEND_STRL("redirect"), CURLOPT_FOLLOWLOCATION, IS_LONG))) {
opt->setter = php_http_curle_option_set_redirect;
}
- php_http_option_register(registry, ZEND_STRL("unrestricted_auth"), CURLOPT_UNRESTRICTED_AUTH, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("unrestricted_auth"), CURLOPT_UNRESTRICTED_AUTH, _IS_BOOL);
#if PHP_HTTP_CURL_VERSION(7,19,1)
php_http_option_register(registry, ZEND_STRL("postredir"), CURLOPT_POSTREDIR, IS_LONG);
#endif
if ((opt = php_http_option_register(registry, ZEND_STRL("referer"), CURLOPT_REFERER, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
}
- if ((opt = php_http_option_register(registry, ZEND_STRL("autoreferer"), CURLOPT_AUTOREFERER, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("autoreferer"), CURLOPT_AUTOREFERER, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
/* useragent */
if ((opt = php_http_option_register(registry, ZEND_STRL("useragent"), CURLOPT_USERAGENT, IS_STRING))) {
/* don't check strlen, to allow sending no useragent at all */
- ZVAL_STRING(&opt->defval,
+ ZVAL_PSTRING(&opt->defval,
"PECL_HTTP/" PHP_PECL_HTTP_VERSION " "
"PHP/" PHP_VERSION " "
- "libcurl/" LIBCURL_VERSION
- , 0);
+ "libcurl/" LIBCURL_VERSION);
}
/* resume */
}
/* compression */
- if ((opt = php_http_option_register(registry, ZEND_STRL("compress"), 0, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("compress"), 0, _IS_BOOL))) {
opt->setter = php_http_curle_option_set_compress;
}
}
/* cookies */
- if ((opt = php_http_option_register(registry, ZEND_STRL("encodecookies"), 0, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("encodecookies"), 0, _IS_BOOL))) {
opt->setter = php_http_curle_option_set_encodecookies;
ZVAL_BOOL(&opt->defval, 1);
}
}
/* cookiesession, don't load session cookies from cookiestore */
- if ((opt = php_http_option_register(registry, ZEND_STRL("cookiesession"), CURLOPT_COOKIESESSION, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("cookiesession"), CURLOPT_COOKIESESSION, _IS_BOOL))) {
opt->setter = php_http_curle_option_set_cookiesession;
}
/* cookiestore, read initial cookies from that file and store cookies back into that file */
#endif
/* tcp */
- php_http_option_register(registry, ZEND_STRL("tcp_nodelay"), CURLOPT_TCP_NODELAY, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("tcp_nodelay"), CURLOPT_TCP_NODELAY, _IS_BOOL);
#if PHP_HTTP_CURL_VERSION(7,25,0)
- php_http_option_register(registry, ZEND_STRL("tcp_keepalive"), CURLOPT_TCP_KEEPALIVE, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("tcp_keepalive"), CURLOPT_TCP_KEEPALIVE, _IS_BOOL);
if ((opt = php_http_option_register(registry, ZEND_STRL("tcp_keepidle"), CURLOPT_TCP_KEEPIDLE, IS_LONG))) {
Z_LVAL(opt->defval) = 60;
}
}
if ((opt = php_http_option_register(registry, ZEND_STRL("certtype"), CURLOPT_SSLCERTTYPE, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
- ZVAL_STRING(&opt->defval, "PEM", 0);
+ ZVAL_PSTRING(&opt->defval, "PEM");
}
if ((opt = php_http_option_register(registry, ZEND_STRL("key"), CURLOPT_SSLKEY, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
}
if ((opt = php_http_option_register(registry, ZEND_STRL("keytype"), CURLOPT_SSLKEYTYPE, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
- ZVAL_STRING(&opt->defval, "PEM", 0);
+ ZVAL_PSTRING(&opt->defval, "PEM");
}
if ((opt = php_http_option_register(registry, ZEND_STRL("keypasswd"), CURLOPT_SSLKEYPASSWD, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
}
php_http_option_register(registry, ZEND_STRL("engine"), CURLOPT_SSLENGINE, IS_STRING);
php_http_option_register(registry, ZEND_STRL("version"), CURLOPT_SSLVERSION, IS_LONG);
- if ((opt = php_http_option_register(registry, ZEND_STRL("verifypeer"), CURLOPT_SSL_VERIFYPEER, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("verifypeer"), CURLOPT_SSL_VERIFYPEER, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
- if ((opt = php_http_option_register(registry, ZEND_STRL("verifyhost"), CURLOPT_SSL_VERIFYHOST, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("verifyhost"), CURLOPT_SSL_VERIFYHOST, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
opt->setter = php_http_curle_option_set_ssl_verifyhost;
}
#if PHP_HTTP_CURL_VERSION(7,41,0) && (defined(PHP_HTTP_HAVE_OPENSSL) || defined(PHP_HTTP_HAVE_NSS) || defined(PHP_HTTP_HAVE_GNUTLS))
- php_http_option_register(registry, ZEND_STRL("verifystatus"), CURLOPT_SSL_VERIFYSTATUS, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("verifystatus"), CURLOPT_SSL_VERIFYSTATUS, _IS_BOOL);
#endif
php_http_option_register(registry, ZEND_STRL("cipher_list"), CURLOPT_SSL_CIPHER_LIST, IS_STRING);
if ((opt = php_http_option_register(registry, ZEND_STRL("cainfo"), CURLOPT_CAINFO, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
#ifdef PHP_HTTP_CURL_CAINFO
- ZVAL_STRING(&opt->defval, PHP_HTTP_CURL_CAINFO, 0);
+ ZVAL_PSTRING(&opt->defval, PHP_HTTP_CURL_CAINFO);
#endif
}
if ((opt = php_http_option_register(registry, ZEND_STRL("capath"), CURLOPT_CAPATH, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
#ifdef PHP_HTTP_CURL_CAPATH
- ZVAL_STRING(&opt->defval, PHP_HTTP_CURL_CAPATH, 0);
+ ZVAL_PSTRING(&opt->defval, PHP_HTTP_CURL_CAPATH);
#endif
}
if ((opt = php_http_option_register(registry, ZEND_STRL("random_file"), CURLOPT_RANDOM_FILE, IS_STRING))) {
# endif
#endif
#if (PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)) || (PHP_HTTP_CURL_VERSION(7,34,0) && defined(PHP_HTTP_HAVE_NSS)) || (PHP_HTTP_CURL_VERSION(7,42,0) && defined(PHP_HTTP_HAVE_GNUTLS)) || (PHP_HTTP_CURL_VERSION(7,39,0) && defined(PHP_HTTP_HAVE_GSKIT))
- php_http_option_register(registry, ZEND_STRL("certinfo"), CURLOPT_CERTINFO, IS_BOOL);
+ if ((opt = php_http_option_register(registry, ZEND_STRL("certinfo"), CURLOPT_CERTINFO, _IS_BOOL))) {
+ ZVAL_FALSE(&opt->defval);
+ }
#endif
#if PHP_HTTP_CURL_VERSION(7,36,0)
- if ((opt = php_http_option_register(registry, ZEND_STRL("enable_npn"), CURLOPT_SSL_ENABLE_NPN, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("enable_npn"), CURLOPT_SSL_ENABLE_NPN, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
- if ((opt = php_http_option_register(registry, ZEND_STRL("enable_alpn"), CURLOPT_SSL_ENABLE_ALPN, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("enable_alpn"), CURLOPT_SSL_ENABLE_ALPN, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
#endif
}
#endif
#if PHP_HTTP_CURL_VERSION(7,42,0) && (defined(PHP_HTTP_HAVE_NSS) || defined(PHP_HTTP_HAVE_DARWINSSL))
- php_http_option_register(registry, ZEND_STRL("falsestart"), CURLOPT_SSL_FALSESTART, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("falsestart"), CURLOPT_SSL_FALSESTART, _IS_BOOL);
#endif
}
}
zval *option;
if ((option = php_http_option_get(opt, options, NULL))) {
- option = php_http_ztyp(opt->type, option);
- zend_hash_quick_update(&curl->options.cache, opt->name.s, opt->name.l, opt->name.h, &option, sizeof(zval *), NULL);
+ zval zopt;
+
+ ZVAL_DUP(&zopt, option);
+ convert_to_explicit_type(&zopt, opt->type);
+ zend_hash_update(&curl->options.cache, opt->name, &zopt);
+ return zend_hash_find(&curl->options.cache, opt->name);
}
return option;
}
zval tmp;
CURLcode rc = CURLE_UNKNOWN_OPTION;
ZEND_RESULT_CODE rv = SUCCESS;
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
if (!val) {
val = &opt->defval;
}
switch (opt->type) {
- case IS_BOOL:
+ case _IS_BOOL:
if (opt->setter) {
rv = opt->setter(opt, val, curl);
- } else if (CURLE_OK != curl_easy_setopt(ch, opt->option, (long) Z_BVAL_P(val))) {
+ } else if (CURLE_OK != curl_easy_setopt(ch, opt->option, (long) (Z_TYPE_P(val) == IS_TRUE))) {
rv = FAILURE;
}
break;
case IS_STRING:
if (opt->setter) {
rv = opt->setter(opt, val, curl);
+ } else if (!val || Z_TYPE_P(val) == IS_NULL) {
+ if (CURLE_OK != (rc = curl_easy_setopt(ch, opt->option, NULL))) {
+ rv = FAILURE;
+ }
} else if ((opt->flags & PHP_HTTP_CURLE_OPTION_CHECK_STRLEN) && !Z_STRLEN_P(val)) {
if (CURLE_OK != (rc = curl_easy_setopt(ch, opt->option, NULL))) {
rv = FAILURE;
}
- } else if ((opt->flags & PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR) && Z_STRVAL_P(val) && SUCCESS != php_check_open_basedir(Z_STRVAL_P(val) TSRMLS_CC)) {
+ } else if ((opt->flags & PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR) && Z_STRVAL_P(val) && SUCCESS != php_check_open_basedir(Z_STRVAL_P(val))) {
if (CURLE_OK != (rc = curl_easy_setopt(ch, opt->option, NULL))) {
rv = FAILURE;
}
break;
}
if (rv != SUCCESS) {
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_easy_strerror(rc));
+ php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_easy_strerror(rc));
}
return rv;
}
CURLM *ch = curl->handle->multi;
HashTable tmp_ht;
char **bl = NULL;
- TSRMLS_FETCH_FROM_CTX(client->ts);
/* array of char *, ending with a NULL */
if (value && Z_TYPE_P(value) != IS_NULL) {
- zval **entry;
- HashPosition pos;
+ zval *entry;
HashTable *ht = HASH_OF(value);
int c = zend_hash_num_elements(ht);
char **ptr = ecalloc(c + 1, sizeof(char *));
zend_hash_init(&tmp_ht, c, NULL, ZVAL_PTR_DTOR, 0);
array_join(ht, &tmp_ht, 0, ARRAY_JOIN_STRINGIFY);
- FOREACH_HASH_VAL(pos, &tmp_ht, entry) {
- *ptr++ = Z_STRVAL_PP(entry);
+ ZEND_HASH_FOREACH_VAL(&tmp_ht, entry)
+ {
+ *ptr++ = Z_STRVAL_P(entry);
}
+ ZEND_HASH_FOREACH_END();
}
if (CURLM_OK != curl_multi_setopt(ch, opt->option, bl)) {
}
#endif
-#if PHP_HTTP_HAVE_EVENT
-static inline ZEND_RESULT_CODE php_http_curlm_use_eventloop(php_http_client_t *h, zend_bool enable)
+static inline ZEND_RESULT_CODE php_http_curlm_use_eventloop(php_http_client_t *h, php_http_client_curl_ops_t *ev_ops, zval *init_data)
{
php_http_client_curl_t *curl = h->ctx;
+ void *ev_ctx;
- if ((curl->useevents = enable)) {
- if (!curl->evbase) {
- curl->evbase = event_base_new();
- }
- if (!curl->timeout) {
- curl->timeout = ecalloc(1, sizeof(struct event));
+ if (ev_ops) {
+ if (!(ev_ctx = ev_ops->init(h, init_data))) {
+ return FAILURE;
}
- curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETDATA, h);
- curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETFUNCTION, php_http_curlm_socket_callback);
- curl_multi_setopt(curl->handle->multi, CURLMOPT_TIMERDATA, h);
- curl_multi_setopt(curl->handle->multi, CURLMOPT_TIMERFUNCTION, php_http_curlm_timer_callback);
+ curl->ev_ctx = ev_ctx;
+ curl->ev_ops = ev_ops;
} else {
- curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETDATA, NULL);
- curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETFUNCTION, NULL);
- curl_multi_setopt(curl->handle->multi, CURLMOPT_TIMERDATA, NULL);
- curl_multi_setopt(curl->handle->multi, CURLMOPT_TIMERFUNCTION, NULL);
+ if (curl->ev_ops) {
+ if (curl->ev_ctx) {
+ curl->ev_ops->dtor(&curl->ev_ctx);
+ }
+ curl->ev_ops = NULL;
+ }
}
return SUCCESS;
static ZEND_RESULT_CODE php_http_curlm_option_set_use_eventloop(php_http_option_t *opt, zval *value, void *userdata)
{
php_http_client_t *client = userdata;
+ php_http_client_curl_ops_t *ev_ops = NULL;
- return php_http_curlm_use_eventloop(client, value && Z_BVAL_P(value));
-}
+ if (value && Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_client_curl_user_get_class_entry())) {
+ ev_ops = php_http_client_curl_user_ops_get();
+#if PHP_HTTP_HAVE_EVENT
+ } else if (value && zend_is_true(value)) {
+ ev_ops = php_http_client_curl_event_ops_get();
#endif
+ }
+
+ return php_http_curlm_use_eventloop(client, ev_ops, value);
+}
static ZEND_RESULT_CODE php_http_curlm_option_set_share_cookies(php_http_option_t *opt, zval *value, void *userdata)
{
php_http_client_curl_t *curl = client->ctx;
CURLSHcode rc;
- if (Z_BVAL_P(value)) {
+ if (Z_TYPE_P(value) == IS_TRUE) {
rc = curl_share_setopt(curl->handle->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
} else {
rc = curl_share_setopt(curl->handle->share, CURLSHOPT_UNSHARE, CURL_LOCK_DATA_COOKIE);
}
if (CURLSHE_OK != rc) {
- TSRMLS_FETCH_FROM_CTX(client->ts);
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_share_strerror(rc));
+ php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_share_strerror(rc));
return FAILURE;
}
return SUCCESS;
}
+#if PHP_HTTP_CURL_VERSION(7,23,0)
static ZEND_RESULT_CODE php_http_curlm_option_set_share_ssl(php_http_option_t *opt, zval *value, void *userdata)
{
php_http_client_t *client = userdata;
php_http_client_curl_t *curl = client->ctx;
CURLSHcode rc;
- if (Z_BVAL_P(value)) {
+ if (Z_TYPE_P(value) == IS_TRUE) {
rc = curl_share_setopt(curl->handle->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
} else {
rc = curl_share_setopt(curl->handle->share, CURLSHOPT_UNSHARE, CURL_LOCK_DATA_SSL_SESSION);
}
if (CURLSHE_OK != rc) {
- TSRMLS_FETCH_FROM_CTX(client->ts);
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_share_strerror(rc));
+ php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_share_strerror(rc));
return FAILURE;
}
return SUCCESS;
}
+#endif
-static void php_http_curlm_options_init(php_http_options_t *registry TSRMLS_DC)
+static void php_http_curlm_options_init(php_http_options_t *registry)
{
php_http_option_t *opt;
php_http_option_register(registry, ZEND_STRL("max_total_connections"), CURLMOPT_MAX_TOTAL_CONNECTIONS, IS_LONG);
#endif
/* enable/disable HTTP pipelining */
- php_http_option_register(registry, ZEND_STRL("pipelining"), CURLMOPT_PIPELINING, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("pipelining"), CURLMOPT_PIPELINING, _IS_BOOL);
/* chunk length threshold for pipelining */
#if PHP_HTTP_CURL_VERSION(7,30,0)
php_http_option_register(registry, ZEND_STRL("chunk_length_penalty_size"), CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, IS_LONG);
}
#endif
/* events */
-#if PHP_HTTP_HAVE_EVENT
- if ((opt = php_http_option_register(registry, ZEND_STRL("use_eventloop"), 0, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("use_eventloop"), 0, 0))) {
opt->setter = php_http_curlm_option_set_use_eventloop;
}
-#endif
/* share */
- if ((opt = php_http_option_register(registry, ZEND_STRL("share_cookies"), 0, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("share_cookies"), 0, _IS_BOOL))) {
opt->setter = php_http_curlm_option_set_share_cookies;
- ZVAL_BOOL(&opt->defval, 1);
+ ZVAL_TRUE(&opt->defval);
}
- if ((opt = php_http_option_register(registry, ZEND_STRL("share_ssl"), 0, IS_BOOL))) {
+#if PHP_HTTP_CURL_VERSION(7,23,0)
+ if ((opt = php_http_option_register(registry, ZEND_STRL("share_ssl"), 0, _IS_BOOL))) {
opt->setter = php_http_curlm_option_set_share_ssl;
- ZVAL_BOOL(&opt->defval, 1);
+ ZVAL_TRUE(&opt->defval);
}
+#endif
}
static ZEND_RESULT_CODE php_http_curlm_set_option(php_http_option_t *opt, zval *val, void *userdata)
php_http_client_t *client = userdata;
php_http_client_curl_t *curl = client->ctx;
CURLM *ch = curl->handle->multi;
- zval *orig = val;
+ zval zopt, *orig = val;
CURLMcode rc = CURLM_UNKNOWN_OPTION;
ZEND_RESULT_CODE rv = SUCCESS;
- TSRMLS_FETCH_FROM_CTX(client->ts);
if (!val) {
val = &opt->defval;
} else if (opt->type && Z_TYPE_P(val) != opt->type && !(Z_TYPE_P(val) == IS_NULL && opt->type == IS_ARRAY)) {
- val = php_http_ztyp(opt->type, val);
+ ZVAL_DUP(&zopt, val);
+ convert_to_explicit_type(&zopt, opt->type);
+
+ val = &zopt;
}
if (opt->setter) {
rv = opt->setter(opt, val, client);
} else {
switch (opt->type) {
- case IS_BOOL:
- if (CURLM_OK != (rc = curl_multi_setopt(ch, opt->option, (long) Z_BVAL_P(val)))) {
+ case _IS_BOOL:
+ if (CURLM_OK != (rc = curl_multi_setopt(ch, opt->option, (long) zend_is_true(val)))) {
rv = FAILURE;
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_multi_strerror(rc));
+ php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_multi_strerror(rc));
}
break;
case IS_LONG:
if (CURLM_OK != (rc = curl_multi_setopt(ch, opt->option, Z_LVAL_P(val)))) {
rv = FAILURE;
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s (%s)", opt->name.s, curl_multi_strerror(rc));
+ php_error_docref(NULL, E_NOTICE, "Could not set option %s (%s)", opt->name->val, curl_multi_strerror(rc));
}
break;
default:
rv = FAILURE;
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not set option %s", opt->name.s);
+ php_error_docref(NULL, E_NOTICE, "Could not set option %s", opt->name->val);
break;
}
}
if (val && val != orig && val != &opt->defval) {
- zval_ptr_dtor(&val);
+ zval_ptr_dtor(val);
}
return rv;
void *handle;
php_http_client_curl_t *curl = h->ctx;
php_http_client_curl_handler_t *handler;
- TSRMLS_FETCH_FROM_CTX(h->ts);
- if (!(handle = php_resource_factory_handle_ctor(rf, NULL TSRMLS_CC))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to initialize curl handle->multi");
+ if (!(handle = php_resource_factory_handle_ctor(rf, NULL))) {
+ php_error_docref(NULL, E_WARNING, "Failed to initialize curl handle");
return NULL;
}
handler->rf = rf;
handler->client = h;
handler->handle = handle;
- handler->response.body = php_http_message_body_init(NULL, NULL TSRMLS_CC);
+ handler->response.body = php_http_message_body_init(NULL, NULL);
php_http_buffer_init(&handler->response.headers);
php_http_buffer_init(&handler->options.cookies);
php_http_buffer_init(&handler->options.ranges);
size_t body_size;
php_http_message_t *msg = enqueue->request;
php_http_curle_storage_t *storage = php_http_curle_get_storage(curl->handle);
- TSRMLS_FETCH_FROM_CTX(curl->client->ts);
/* request url */
if (!PHP_HTTP_INFO(msg).request.url) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot request empty URL");
+ php_error_docref(NULL, E_WARNING, "Cannot request empty URL");
return FAILURE;
}
storage->errorbuffer[0] = '\0';
/* request headers */
php_http_message_update_headers(msg);
if (zend_hash_num_elements(&msg->hdrs)) {
- php_http_array_hashkey_t header_key = php_http_array_hashkey_init(0);
- zval **header_val, *header_cpy;
- HashPosition pos;
+ php_http_arrkey_t header_key;
+ zval *header_val;
+ zend_string *header_str;
php_http_buffer_t header;
#if !PHP_HTTP_CURL_VERSION(7,23,0)
- zval **ct = NULL;
-
- zend_hash_find(&msg->hdrs, ZEND_STRS("Content-Length"), (void *) &ct);
+ zval *ct = zend_hash_str_find(&msg->hdrs, ZEND_STRL("Content-Length"));
#endif
php_http_buffer_init(&header);
- FOREACH_HASH_KEYVAL(pos, &msg->hdrs, header_key, header_val) {
- if (header_key.type == HASH_KEY_IS_STRING) {
+ ZEND_HASH_FOREACH_KEY_VAL(&msg->hdrs, header_key.h, header_key.key, header_val)
+ {
+ if (header_key.key) {
#if !PHP_HTTP_CURL_VERSION(7,23,0)
/* avoid duplicate content-length header */
- if (ct && *ct == *header_val) {
+ if (ct && ct == header_val) {
continue;
}
#endif
- header_cpy = php_http_ztyp(IS_STRING, *header_val);
- php_http_buffer_appendf(&header, "%s: %s", header_key.str, Z_STRVAL_P(header_cpy));
+ header_str = zval_get_string(header_val);
+ php_http_buffer_appendf(&header, "%s: %s", header_key.key->val, header_str->val);
php_http_buffer_fix(&header);
curl->options.headers = curl_slist_append(curl->options.headers, header.data);
php_http_buffer_reset(&header);
-
- zval_ptr_dtor(&header_cpy);
+ zend_string_release(header_str);
}
}
+ ZEND_HASH_FOREACH_END();
php_http_buffer_dtor(&header);
}
curl_easy_setopt(curl->handle, CURLOPT_HTTPHEADER, curl->options.headers);
curl_easy_setopt(curl->handle, CURLOPT_CUSTOMREQUEST, PHP_HTTP_INFO(msg).request.method);
}
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot use empty request method");
+ php_error_docref(NULL, E_WARNING, "Cannot use empty request method");
return FAILURE;
}
static void php_http_client_curl_handler_dtor(php_http_client_curl_handler_t *handler)
{
- TSRMLS_FETCH_FROM_CTX(handler->client->ts);
-
php_http_client_curl_handler_clear(handler);
- php_resource_factory_handle_dtor(handler->rf, handler->handle TSRMLS_CC);
+ php_resource_factory_handle_dtor(handler->rf, handler->handle);
php_resource_factory_free(&handler->rf);
php_http_message_body_free(&handler->response.body);
php_http_buffer_dtor(&handler->options.cookies);
zend_hash_destroy(&handler->options.cache);
+#if PHP_HTTP_CURL_VERSION(7,21,3)
+ if (handler->options.resolve) {
+ curl_slist_free_all(handler->options.resolve);
+ handler->options.resolve = NULL;
+ }
+#endif
+
if (handler->options.headers) {
curl_slist_free_all(handler->options.headers);
handler->options.headers = NULL;
}
+ if (handler->options.proxyheaders) {
+ curl_slist_free_all(handler->options.proxyheaders);
+ handler->options.proxyheaders = NULL;
+ }
+
efree(handler);
}
static php_http_client_t *php_http_client_curl_init(php_http_client_t *h, void *handle)
{
php_http_client_curl_t *curl;
- TSRMLS_FETCH_FROM_CTX(h->ts);
- if (!handle && !(handle = php_resource_factory_handle_ctor(h->rf, NULL TSRMLS_CC))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to initialize curl handle->multi");
+ if (!handle && !(handle = php_resource_factory_handle_ctor(h->rf, NULL))) {
+ php_error_docref(NULL, E_WARNING, "Failed to initialize curl handle");
return NULL;
}
static void php_http_client_curl_dtor(php_http_client_t *h)
{
php_http_client_curl_t *curl = h->ctx;
- TSRMLS_FETCH_FROM_CTX(h->ts);
-#if PHP_HTTP_HAVE_EVENT
- if (curl->timeout) {
- if (event_initialized(curl->timeout) && event_pending(curl->timeout, EV_TIMEOUT, NULL)) {
- event_del(curl->timeout);
- }
- efree(curl->timeout);
- curl->timeout = NULL;
- }
- if (curl->evbase) {
- event_base_free(curl->evbase);
- curl->evbase = NULL;
+ if (curl->ev_ops) {
+ curl->ev_ops->dtor(&curl->ev_ctx);
+ curl->ev_ops = NULL;
}
-#endif
curl->unfinished = 0;
- php_resource_factory_handle_dtor(h->rf, curl->handle TSRMLS_CC);
+ php_resource_factory_handle_dtor(h->rf, curl->handle);
efree(curl);
h->ctx = NULL;
php_http_client_curl_handler_dtor(handler);
}
-static php_resource_factory_t *create_rf(php_http_client_t *h, php_http_client_enqueue_t *enqueue TSRMLS_DC)
+static php_resource_factory_t *create_rf(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
{
php_persistent_handle_factory_t *pf = NULL;
php_resource_factory_t *rf = NULL;
php_http_url_t *url = enqueue->request->http.info.request.url;
if (!url || (!url->host && !url->path)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot request empty URL");
+ php_error_docref(NULL, E_WARNING, "Cannot request empty URL");
return NULL;
}
/* only if the client itself is setup for persistence */
if (php_resource_factory_is_persistent(h->rf)) {
+ zend_string *id;
char *id_str = NULL;
size_t id_len;
int port = url->port ? url->port : 80;
- zval **zport;
+ zval *zport;
php_persistent_handle_factory_t *phf = h->rf->data;
- if (SUCCESS == zend_hash_find(enqueue->options, ZEND_STRS("port"), (void *) &zport)) {
- zval *zcpy = php_http_ztyp(IS_LONG, *zport);
+ if ((zport = zend_hash_str_find(enqueue->options, ZEND_STRL("port")))) {
+ zend_long lport = zval_get_long(zport);
- if (Z_LVAL_P(zcpy)) {
- port = Z_LVAL_P(zcpy);
+ if (lport > 0) {
+ port = lport;
}
- zval_ptr_dtor(&zcpy);
}
- id_len = spprintf(&id_str, 0, "%.*s:%s:%d", (int) phf->ident.len, phf->ident.str, STR_PTR(url->host), port);
- pf = php_persistent_handle_concede(NULL, ZEND_STRL("http\\Client\\Curl\\Request"), id_str, id_len, NULL, NULL TSRMLS_CC);
- efree(id_str);
+ id_len = spprintf(&id_str, 0, "%.*s:%s:%d", (int) phf->ident->len, phf->ident->val, STR_PTR(url->host), port);
+ id = php_http_cs2zs(id_str, id_len);
+ pf = php_persistent_handle_concede(NULL, PHP_HTTP_G->client.curl.driver.request_name, id, NULL, NULL);
+ zend_string_release(id);
}
if (pf) {
php_http_client_curl_handler_t *handler;
php_http_client_progress_state_t *progress;
php_resource_factory_t *rf;
- TSRMLS_FETCH_FROM_CTX(h->ts);
- rf = create_rf(h, enqueue TSRMLS_CC);
+ rf = create_rf(h, enqueue);
if (!rf) {
return FAILURE;
}
if (CURLM_OK != (rs = curl_multi_add_handle(curl->handle->multi, handler->handle))) {
php_http_client_curl_handler_dtor(handler);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not enqueue request: %s", curl_multi_strerror(rs));
+ php_error_docref(NULL, E_WARNING, "Could not enqueue request: %s", curl_multi_strerror(rs));
return FAILURE;
}
CURLMcode rs;
php_http_client_curl_t *curl = h->ctx;
php_http_client_curl_handler_t *handler = enqueue->opaque;
- TSRMLS_FETCH_FROM_CTX(h->ts);
+
+ if (h->callback.depth) {
+ php_error_docref(NULL, E_WARNING, "Could not dequeue request while executing callbacks");
+ return FAILURE;
+ }
php_http_client_curl_handler_clear(handler);
if (CURLM_OK == (rs = curl_multi_remove_handle(curl->handle->multi, handler->handle))) {
zend_llist_del_element(&h->requests, handler->handle, (int (*)(void *, void *)) compare_queue);
return SUCCESS;
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not dequeue request: %s", curl_multi_strerror(rs));
+ php_error_docref(NULL, E_WARNING, "Could not dequeue request: %s", curl_multi_strerror(rs));
}
return FAILURE;
}
}
-static inline void php_http_client_curl_get_timeout(php_http_client_curl_t *curl, long max_tout, struct timeval *timeout)
-{
- if ((CURLM_OK == curl_multi_timeout(curl->handle->multi, &max_tout)) && (max_tout > 0)) {
- timeout->tv_sec = max_tout / 1000;
- timeout->tv_usec = (max_tout % 1000) * 1000;
- } else {
- timeout->tv_sec = 0;
- timeout->tv_usec = 1000;
- }
-}
-
#ifdef PHP_WIN32
# define SELECT_ERROR SOCKET_ERROR
#else
struct timeval timeout;
php_http_client_curl_t *curl = h->ctx;
-#if PHP_HTTP_HAVE_EVENT
- if (curl->useevents) {
- if (!event_initialized(curl->timeout)) {
- event_assign(curl->timeout, curl->evbase, CURL_SOCKET_TIMEOUT, 0, php_http_curlm_timeout_callback, h);
- } else if (custom_timeout && timerisset(custom_timeout)) {
- event_add(curl->timeout, custom_timeout);
- } else if (!event_pending(curl->timeout, EV_TIMEOUT, NULL)) {
- php_http_client_curl_get_timeout(curl, 1000, &timeout);
- event_add(curl->timeout, &timeout);
- }
-
- event_base_loop(curl->evbase, EVLOOP_ONCE);
-
- return SUCCESS;
+ if (curl->ev_ops) {
+ return curl->ev_ops->wait(curl->ev_ctx, custom_timeout);
}
-#endif
FD_ZERO(&R);
FD_ZERO(&W);
{
php_http_client_curl_t *curl = h->ctx;
-#if PHP_HTTP_HAVE_EVENT
- if (curl->useevents) {
- event_base_loop(curl->evbase, EVLOOP_NONBLOCK);
- } else
-#endif
- while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(curl->handle->multi, &curl->unfinished));
+ if (!h->callback.depth) {
+ if (curl->ev_ops) {
+ curl->ev_ops->once(curl->ev_ctx);
+ } else {
+ while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(curl->handle->multi, &curl->unfinished));
+ }
- php_http_curlm_responsehandler(h);
+ php_http_client_curl_responsehandler(h);
+ }
return curl->unfinished;
-
}
static ZEND_RESULT_CODE php_http_client_curl_exec(php_http_client_t *h)
{
-#if PHP_HTTP_HAVE_EVENT
php_http_client_curl_t *curl = h->ctx;
-#endif
- TSRMLS_FETCH_FROM_CTX(h->ts);
-
-#if PHP_HTTP_HAVE_EVENT
- if (curl->useevents) {
- php_http_curlm_timeout_callback(CURL_SOCKET_TIMEOUT, /*EV_READ|EV_WRITE*/0, h);
- do {
- int ev_rc = event_base_dispatch(curl->evbase);
-#if DBG_EVENTS
- fprintf(stderr, "%c", "X.0"[ev_rc+1]);
-#endif
+ if (!h->callback.depth) {
+ if (curl->ev_ops) {
+ return curl->ev_ops->exec(curl->ev_ctx);
+ }
- if (ev_rc < 0) {
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in event_base_dispatch()");
- return FAILURE;
- }
- } while (curl->unfinished && !EG(exception));
- } else
-#endif
- {
while (php_http_client_curl_once(h) && !EG(exception)) {
if (SUCCESS != php_http_client_curl_wait(h, NULL)) {
#ifdef PHP_WIN32
/* see http://msdn.microsoft.com/library/en-us/winsock/winsock/windows_sockets_error_codes_2.asp */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "WinSock error: %d", WSAGetLastError());
+ php_error_docref(NULL, E_WARNING, "WinSock error: %d", WSAGetLastError());
#else
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
+ php_error_docref(NULL, E_WARNING, "%s", strerror(errno));
#endif
return FAILURE;
}
case PHP_HTTP_CLIENT_OPT_USE_EVENTS:
#if PHP_HTTP_HAVE_EVENT
- return php_http_curlm_use_eventloop(h, *(zend_bool *) arg);
+ return php_http_curlm_use_eventloop(h, (*(zend_bool *) arg)
+ ? php_http_client_curl_event_ops_get()
+ : NULL, NULL);
break;
#endif
return SUCCESS;
}
-static int apply_available_options(void *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+static int apply_available_options(zval *pDest, int num_args, va_list args, zend_hash_key *hash_key)
{
- php_http_option_t *opt = pDest;
+ php_http_option_t *opt = Z_PTR_P(pDest);
HashTable *ht;
- zval *entry;
+ zval entry;
int c;
ht = va_arg(args, HashTable*);
- MAKE_STD_ZVAL(entry);
-
if ((c = zend_hash_num_elements(&opt->suboptions.options))) {
- array_init_size(entry, c);
- zend_hash_apply_with_arguments(&opt->suboptions.options TSRMLS_CC, apply_available_options, 1, Z_ARRVAL_P(entry));
+ array_init_size(&entry, c);
+ zend_hash_apply_with_arguments(&opt->suboptions.options, apply_available_options, 1, Z_ARRVAL(entry));
} else {
/* catch deliberate NULL options */
if (Z_TYPE(opt->defval) == IS_STRING && !Z_STRVAL(opt->defval)) {
- ZVAL_NULL(entry);
+ ZVAL_NULL(&entry);
} else {
- ZVAL_COPY_VALUE(entry, &opt->defval);
- zval_copy_ctor(entry);
+ ZVAL_ZVAL(&entry, &opt->defval, 1, 0);
}
}
- if (hash_key->nKeyLength) {
- zend_hash_quick_update(ht, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void *) &entry, sizeof(zval *), NULL);
+ if (hash_key->key) {
+ zend_hash_update(ht, hash_key->key, &entry);
} else {
- zend_hash_index_update(ht, hash_key->h, (void *) &entry, sizeof(zval *), NULL);
+ zend_hash_index_update(ht, hash_key->h, &entry);
}
return ZEND_HASH_APPLY_KEEP;
static ZEND_RESULT_CODE php_http_client_curl_getopt(php_http_client_t *h, php_http_client_getopt_opt_t opt, void *arg, void **res)
{
php_http_client_enqueue_t *enqueue;
- TSRMLS_FETCH_FROM_CTX(h->ts);
switch (opt) {
case PHP_HTTP_CLIENT_OPT_PROGRESS_INFO:
break;
case PHP_HTTP_CLIENT_OPT_AVAILABLE_OPTIONS:
- zend_hash_apply_with_arguments(&php_http_curle_options.options TSRMLS_CC, apply_available_options, 1, *(HashTable **) res);
+ zend_hash_apply_with_arguments(&php_http_curle_options.options, apply_available_options, 1, *(HashTable **) res);
break;
case PHP_HTTP_CLIENT_OPT_AVAILABLE_CONFIGURATION:
- zend_hash_apply_with_arguments(&php_http_curlm_options.options TSRMLS_CC, apply_available_options, 1, *(HashTable **) res);
+ zend_hash_apply_with_arguments(&php_http_curlm_options.options, apply_available_options, 1, *(HashTable **) res);
break;
default:
return &php_http_client_curl_ops;
}
+
PHP_MINIT_FUNCTION(http_client_curl)
{
curl_version_info_data *info;
php_http_options_t *options;
- php_http_client_driver_t driver = {
- ZEND_STRL("curl"),
- &php_http_client_curl_ops
- };
- if (SUCCESS != php_http_client_driver_add(&driver)) {
+ PHP_HTTP_G->client.curl.driver.driver_name = zend_string_init(ZEND_STRL("curl"), 1);
+ PHP_HTTP_G->client.curl.driver.client_name = zend_string_init(ZEND_STRL("http\\Client\\Curl"), 1);
+ PHP_HTTP_G->client.curl.driver.request_name = zend_string_init(ZEND_STRL("http\\Client\\Curl\\Request"), 1);
+ PHP_HTTP_G->client.curl.driver.client_ops = &php_http_client_curl_ops;
+
+ if (SUCCESS != php_http_client_driver_add(&PHP_HTTP_G->client.curl.driver)) {
return FAILURE;
}
- if (SUCCESS != php_persistent_handle_provide(ZEND_STRL("http\\Client\\Curl"), &php_http_curlm_resource_factory_ops, NULL, NULL TSRMLS_CC)) {
+ if (SUCCESS != php_persistent_handle_provide(PHP_HTTP_G->client.curl.driver.client_name, &php_http_curlm_resource_factory_ops, NULL, NULL)) {
return FAILURE;
}
- if (SUCCESS != php_persistent_handle_provide(ZEND_STRL("http\\Client\\Curl\\Request"), &php_http_curle_resource_factory_ops, NULL, NULL TSRMLS_CC)) {
+ if (SUCCESS != php_persistent_handle_provide(PHP_HTTP_G->client.curl.driver.request_name, &php_http_curle_resource_factory_ops, NULL, NULL)) {
return FAILURE;
}
options->getter = php_http_curle_get_option;
options->setter = php_http_curle_set_option;
- php_http_curle_options_init(options TSRMLS_CC);
+ php_http_curle_options_init(options);
}
if ((options = php_http_options_init(&php_http_curlm_options, 1))) {
options->getter = php_http_option_get;
options->setter = php_http_curlm_set_option;
- php_http_curlm_options_init(options TSRMLS_CC);
+ php_http_curlm_options_init(options);
}
if ((info = curl_version_info(CURLVERSION_NOW))) {
PHP_MSHUTDOWN_FUNCTION(http_client_curl)
{
- php_persistent_handle_cleanup(ZEND_STRL("http\\Client\\Curl"), NULL, 0 TSRMLS_CC);
- php_persistent_handle_cleanup(ZEND_STRL("http\\Client\\Curl\\Request"), NULL, 0 TSRMLS_CC);
+ php_persistent_handle_cleanup(PHP_HTTP_G->client.curl.driver.client_name, NULL);
+ php_persistent_handle_cleanup(PHP_HTTP_G->client.curl.driver.request_name, NULL);
+ zend_string_release(PHP_HTTP_G->client.curl.driver.client_name);
+ zend_string_release(PHP_HTTP_G->client.curl.driver.request_name);
+ zend_string_release(PHP_HTTP_G->client.curl.driver.driver_name);
php_http_options_dtor(&php_http_curle_options);
php_http_options_dtor(&php_http_curlm_options);