php_http_buffer_t cookies;
php_http_buffer_t ranges;
- long redirects;
- unsigned range_request:1;
- unsigned encode_cookies:1;
-
struct {
uint count;
double delay;
} retry;
+ long redirects;
+ unsigned range_request:1;
+ unsigned encode_cookies:1;
+
} options;
} php_http_client_curl_handler_t;
return st;
}
-static void *php_http_curle_ctor(void *opaque, void *init_arg TSRMLS_DC)
+static void *php_http_curle_ctor(void *opaque, void *init_arg)
{
void *ch;
return NULL;
}
-static void *php_http_curle_copy(void *opaque, void *handle TSRMLS_DC)
+static void *php_http_curle_copy(void *opaque, void *handle)
{
void *ch;
return NULL;
}
-static void php_http_curle_dtor(void *opaque, void *handle TSRMLS_DC)
+static void php_http_curle_dtor(void *opaque, void *handle)
{
php_http_curle_storage_t *st = php_http_curle_get_storage(handle);
php_http_curle_dtor
};
-static void *php_http_curlm_ctor(void *opaque, void *init_arg TSRMLS_DC)
+static void *php_http_curlm_ctor(void *opaque, void *init_arg)
{
return curl_multi_init();
}
-static void php_http_curlm_dtor(void *opaque, void *handle TSRMLS_DC)
+static void php_http_curlm_dtor(void *opaque, void *handle)
{
curl_multi_cleanup(handle);
}
{
php_http_message_body_t *body = ctx;
- if (body && body->stream_id) {
+ if (body && body->res) {
php_stream *s = php_http_message_body_stream(body);
if (s) {
- TSRMLS_FETCH_FROM_CTX(body->ts);
return php_stream_read(s, data, len * n);
} else abort();
}
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 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,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;
- 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")))) {
+ Z_TRY_ADDREF_P(zh);
+ zend_hash_str_update(&response->hdrs, "X-Original-Content-Length", lenof("X-Original-Content-Length"), zh);
}
- if ((zh = php_http_message_header(response, ZEND_STRL("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")))) {
+ Z_TRY_ADDREF_P(zh);
+ zend_hash_str_update(&response->hdrs, "X-Original-Transfer-Encoding", lenof("X-Original-Transfer-Encoding"), zh);
+ zend_hash_str_del(&response->hdrs, "Transfer-Encoding", lenof("Transfer-Encoding"));
}
- if ((zh = php_http_message_header(response, ZEND_STRL("Content-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")))) {
+ Z_TRY_ADDREF_P(zh);
+ zend_hash_str_update(&response->hdrs, "X-Original-Content-Range", lenof("X-Original-Content-Range"), zh);
+ zend_hash_str_del(&response->hdrs, "Content-Range", lenof("Content-Range"));
}
- if ((zh = php_http_message_header(response, ZEND_STRL("Content-Encoding"), 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")))) {
+ Z_TRY_ADDREF_P(zh);
+ zend_hash_str_update(&response->hdrs, "X-Original-Content-Encoding", lenof("X-Original-Content-Encoding"), zh);
+ zend_hash_str_del(&response->hdrs, "Content-Encoding", lenof("Content-Encoding"));
}
php_http_message_update_headers(response);
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, &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);
}
#endif
if (curl->useevents) {
CURLMcode rc;
- TSRMLS_FETCH_FROM_CTX(context->ts);
/* ignore and use -1,0 on timeout */
(void) socket;
while (CURLM_CALL_MULTI_PERFORM == (rc = curl_multi_socket_action(curl->handle, CURL_SOCKET_TIMEOUT, 0, &curl->unfinished)));
if (CURLM_OK != rc) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", curl_multi_strerror(rc));
+ php_error_docref(NULL, E_WARNING, "%s", curl_multi_strerror(rc));
}
php_http_curlm_responsehandler(context);
#endif
if (curl->useevents) {
CURLMcode rc = CURLM_OK;
- TSRMLS_FETCH_FROM_CTX(context->ts);
while (CURLM_CALL_MULTI_PERFORM == (rc = curl_multi_socket_action(curl->handle, socket, etoca(action), &curl->unfinished)));
if (CURLM_OK != rc) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", curl_multi_strerror(rc));
+ php_error_docref(NULL, E_WARNING, "%s", curl_multi_strerror(rc));
}
php_http_curlm_responsehandler(context);
if (curl->useevents) {
int events = EV_PERSIST;
php_http_curlm_event_t *ev = assign_data;
- TSRMLS_FETCH_FROM_CTX(context->ts);
if (!ev) {
ev = ecalloc(1, sizeof(php_http_curlm_event_t));
return 0;
default:
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown socket action %d", action);
+ php_error_docref(NULL, E_WARNING, "Unknown socket action %d", action);
return -1;
}
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;
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;
+ zend_long rbl, rel;
+ HashTable *ht = HASH_OF(val);
+
+ ZEND_HASH_FOREACH_VAL(ht, rr)
+ {
+ if (Z_TYPE_P(rr) == IS_ARRAY) {
+ if (2 == php_http_array_list(Z_ARRVAL_P(rr), 2, &rb, &re)) {
+ if ( ((Z_TYPE_P(rb) == IS_LONG) || ((Z_TYPE_P(rb) == IS_STRING) && is_numeric_string(Z_STRVAL_P(rb), Z_STRLEN_P(rb), &rbl, NULL, 1))) &&
+ ((Z_TYPE_P(re) == IS_LONG) || ((Z_TYPE_P(re) == IS_STRING) && is_numeric_string(Z_STRVAL_P(re), Z_STRLEN_P(re), &rel, NULL, 1)))) {
+ if ((rbl >= 0) && (rel >= 0)) {
+ php_http_buffer_appendf(&curl->options.ranges, "%ld-%ld,", rbl, rel);
}
- zval_ptr_dtor(&rbl);
- zval_ptr_dtor(&rel);
}
}
}
}
+ ZEND_HASH_FOREACH_END();
if (curl->options.ranges.used) {
curl->options.range_request = 1;
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;
+ HashTable *ht = HASH_OF(val);
+ zval *data;
- FOREACH_KEYVAL(pos, val, key, data) {
- zval *cpy = php_http_ztyp(IS_STRING, *data);
- curl->options.resolve = curl_slist_append(curl->options.resolve, Z_STRVAL_P(cpy));
- zval_ptr_dtor(&cpy);
+ ZEND_HASH_FOREACH_VAL(ht, data)
+ {
+ zend_string *zs = zval_get_string(data);
+ curl->options.resolve = curl_slist_append(curl->options.resolve, zs->val);
+ zend_string_release(zs);
}
+ ZEND_HASH_FOREACH_END();
if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_RESOLVE, curl->options.resolve)) {
return FAILURE;
}
#endif
-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);
+ #endif
+
/* proxy */
if ((opt = php_http_option_register(registry, ZEND_STRL("proxyhost"), CURLOPT_PROXY, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
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 */
- php_http_option_register(registry, ZEND_STRL("cookiesession"), CURLOPT_COOKIESESSION, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("cookiesession"), CURLOPT_COOKIESESSION, _IS_BOOL);
/* cookiestore, read initial cookies from that file and store cookies back into that file */
if ((opt = php_http_option_register(registry, ZEND_STRL("cookiestore"), 0, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
#endif
/* tcp */
- php_http_option_register(registry, ZEND_STRL("tcp_nodelay"), CURLOPT_TCP_NODELAY, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("tcp_nodelay"), CURLOPT_TCP_NODELAY, _IS_BOOL);
#if PHP_HTTP_CURL_VERSION(7,25,0)
- php_http_option_register(registry, ZEND_STRL("tcp_keepalive"), CURLOPT_TCP_KEEPALIVE, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("tcp_keepalive"), CURLOPT_TCP_KEEPALIVE, _IS_BOOL);
if ((opt = php_http_option_register(registry, ZEND_STRL("tcp_keepidle"), CURLOPT_TCP_KEEPIDLE, IS_LONG))) {
Z_LVAL(opt->defval) = 60;
}
}
if ((opt = php_http_option_register(registry, ZEND_STRL("certtype"), CURLOPT_SSLCERTTYPE, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
- ZVAL_STRING(&opt->defval, "PEM", 0);
+ ZVAL_PSTRING(&opt->defval, "PEM");
}
if ((opt = php_http_option_register(registry, ZEND_STRL("key"), CURLOPT_SSLKEY, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
}
if ((opt = php_http_option_register(registry, ZEND_STRL("keytype"), CURLOPT_SSLKEYTYPE, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
- ZVAL_STRING(&opt->defval, "PEM", 0);
+ ZVAL_PSTRING(&opt->defval, "PEM");
}
if ((opt = php_http_option_register(registry, ZEND_STRL("keypasswd"), CURLOPT_SSLKEYPASSWD, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
}
php_http_option_register(registry, ZEND_STRL("engine"), CURLOPT_SSLENGINE, IS_STRING);
php_http_option_register(registry, ZEND_STRL("version"), CURLOPT_SSLVERSION, IS_LONG);
- if ((opt = php_http_option_register(registry, ZEND_STRL("verifypeer"), CURLOPT_SSL_VERIFYPEER, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("verifypeer"), CURLOPT_SSL_VERIFYPEER, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
}
- if ((opt = php_http_option_register(registry, ZEND_STRL("verifyhost"), CURLOPT_SSL_VERIFYHOST, IS_BOOL))) {
+ if ((opt = php_http_option_register(registry, ZEND_STRL("verifyhost"), CURLOPT_SSL_VERIFYHOST, _IS_BOOL))) {
ZVAL_BOOL(&opt->defval, 1);
opt->setter = php_http_curle_option_set_ssl_verifyhost;
}
#if PHP_HTTP_CURL_VERSION(7,41,0)
- php_http_option_register(registry, ZEND_STRL("verifystatus"), CURLOPT_SSL_VERIFYSTATUS, IS_BOOL);
+ php_http_option_register(registry, ZEND_STRL("verifystatus"), CURLOPT_SSL_VERIFYSTATUS, _IS_BOOL);
#endif
php_http_option_register(registry, ZEND_STRL("cipher_list"), CURLOPT_SSL_CIPHER_LIST, IS_STRING);
if ((opt = php_http_option_register(registry, ZEND_STRL("cainfo"), CURLOPT_CAINFO, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
#ifdef PHP_HTTP_CURL_CAINFO
- ZVAL_STRING(&opt->defval, PHP_HTTP_CURL_CAINFO, 0);
+ ZVAL_PSTRING(&opt->defval, PHP_HTTP_CURL_CAINFO);
#endif
}
if ((opt = php_http_option_register(registry, ZEND_STRL("capath"), CURLOPT_CAPATH, IS_STRING))) {
# endif
#endif
#if (PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)) || (PHP_HTTP_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
#if PHP_HTTP_CURL_VERSION(7,39,0)
+ /* FIXME: see http://curl.haxx.se/libcurl/c/CURLOPT_PINNEDPUBLICKEY.html#AVAILABILITY */
if ((opt = php_http_option_register(registry, ZEND_STRL("pinned_publickey"), CURLOPT_PINNEDPUBLICKEY, IS_STRING))) {
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
}
#endif
#if PHP_HTTP_CURL_VERSION(7,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_OK;
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;
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)) {
{
php_http_client_t *client = userdata;
- return php_http_curlm_use_eventloop(client, value && Z_BVAL_P(value));
+ return php_http_curlm_use_eventloop(client, value && Z_TYPE_P(value) == IS_TRUE);
}
#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, _IS_BOOL))) {
opt->setter = php_http_curlm_option_set_use_eventloop;
}
#endif
zval *orig = val;
CURLMcode rc = CURLM_UNKNOWN_OPTION;
ZEND_RESULT_CODE rv = SUCCESS;
- TSRMLS_FETCH_FROM_CTX(client->ts);
if (!val) {
val = &opt->defval;
} else if (opt->type && Z_TYPE_P(val) != opt->type && !(Z_TYPE_P(val) == IS_NULL && opt->type == IS_ARRAY)) {
- val = php_http_ztyp(opt->type, val);
+ zval zopt;
+
+ ZVAL_DUP(&zopt, val);
+ convert_to_explicit_type(&zopt, opt->type);
+
+ val = &zopt;
}
if (opt->setter) {
rv = opt->setter(opt, val, client);
} else {
switch (opt->type) {
- case IS_BOOL:
- if (CURLM_OK != (rc = curl_multi_setopt(ch, opt->option, (long) Z_BVAL_P(val)))) {
+ case _IS_BOOL:
+ if (CURLM_OK != (rc = curl_multi_setopt(ch, opt->option, (long) zend_is_true(val)))) {
rv = FAILURE;
}
break;
}
if (val && val != orig && val != &opt->defval) {
- zval_ptr_dtor(&val);
+ zval_ptr_dtor(val);
}
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;
}
{
void *handle;
php_http_client_curl_handler_t *handler;
- TSRMLS_FETCH_FROM_CTX(h->ts);
- if (!(handle = php_resource_factory_handle_ctor(rf, NULL TSRMLS_CC))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to initialize curl handle");
+ if (!(handle = php_resource_factory_handle_ctor(rf, NULL))) {
+ php_error_docref(NULL, E_WARNING, "Failed to initialize curl handle");
return NULL;
}
handler->rf = rf;
handler->client = h;
handler->handle = handle;
- handler->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);
* See also https://tools.ietf.org/html/rfc7231#section-5.1.1
*/
if (PHP_HTTP_INFO(msg).request.method) {
- if (!strcasecmp("PUT", PHP_HTTP_INFO(msg).request.method)) {
+ switch(php_http_select_str(PHP_HTTP_INFO(msg).request.method, 2, "HEAD", "PUT")) {
+ case 0:
+ curl_easy_setopt(curl->handle, CURLOPT_NOBODY, 1L);
+ break;
+ case 1:
curl_easy_setopt(curl->handle, CURLOPT_UPLOAD, 1L);
- } else {
+ break;
+ default:
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");
+ if (!handle && !(handle = php_resource_factory_handle_ctor(h->rf, NULL))) {
+ php_error_docref(NULL, E_WARNING, "Failed to initialize curl handle");
return NULL;
}
static void php_http_client_curl_dtor(php_http_client_t *h)
{
php_http_client_curl_t *curl = h->ctx;
- TSRMLS_FETCH_FROM_CTX(h->ts);
#if PHP_HTTP_HAVE_EVENT
if (curl->timeout) {
#endif
curl->unfinished = 0;
- php_resource_factory_handle_dtor(h->rf, curl->handle TSRMLS_CC);
+ php_resource_factory_handle_dtor(h->rf, curl->handle);
efree(curl);
h->ctx = NULL;
php_http_client_curl_handler_dtor(handler);
}
-static php_resource_factory_t *create_rf(php_http_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;
- 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:%d", 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 = 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;
}
return SUCCESS;
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not enqueue request: %s", curl_multi_strerror(rs));
+ php_error_docref(NULL, E_WARNING, "Could not enqueue request: %s", curl_multi_strerror(rs));
return FAILURE;
}
}
CURLMcode rs;
php_http_client_curl_t *curl = h->ctx;
php_http_client_curl_handler_t *handler = enqueue->opaque;
- TSRMLS_FETCH_FROM_CTX(h->ts);
php_http_client_curl_handler_clear(handler);
if (CURLM_OK == (rs = curl_multi_remove_handle(curl->handle, handler->handle))) {
zend_llist_del_element(&h->requests, handler->handle, (int (*)(void *, void *)) compare_queue);
return SUCCESS;
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not dequeue request: %s", curl_multi_strerror(rs));
+ php_error_docref(NULL, E_WARNING, "Could not dequeue request: %s", curl_multi_strerror(rs));
}
return FAILURE;
{
#if PHP_HTTP_HAVE_EVENT
php_http_client_curl_t *curl = h->ctx;
-#endif
- TSRMLS_FETCH_FROM_CTX(h->ts);
-#if PHP_HTTP_HAVE_EVENT
if (curl->useevents) {
php_http_curlm_timeout_callback(CURL_SOCKET_TIMEOUT, /*EV_READ|EV_WRITE*/0, h);
do {
#endif
if (ev_rc < 0) {
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error in event_base_dispatch()");
+ php_error_docref(NULL, E_ERROR, "Error in event_base_dispatch()");
return FAILURE;
}
} while (curl->unfinished && !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;
}
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:
PHP_MINIT_FUNCTION(http_client_curl)
{
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);
}
/*
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);
#include "php_http_api.h"
-php_http_info_t *php_http_info_init(php_http_info_t *i TSRMLS_DC)
+php_http_info_t *php_http_info_init(php_http_info_t *i)
{
if (!i) {
i = emalloc(sizeof(*i));
}
}
-php_http_info_t *php_http_info_parse(php_http_info_t *info, const char *pre_header TSRMLS_DC)
+php_http_info_t *php_http_info_parse(php_http_info_t *info, const char *pre_header)
{
const char *end, *http;
zend_bool free_info = !info;
return NULL;
}
- info = php_http_info_init(info TSRMLS_CC);
+ info = php_http_info_init(info);
/* and nothing than SPACE or NUL after HTTP/X.x */
- if (!php_http_version_parse(&info->http.version, http TSRMLS_CC)
+ if (!php_http_version_parse(&info->http.version, http)
|| (http[lenof("HTTP/X.x")] && (!PHP_HTTP_IS_CTYPE(space, http[lenof("HTTP/X.x")])))) {
if (free_info) {
php_http_info_free(&info);
const char *status = NULL, *code = http + sizeof("HTTP/X.x");
info->type = PHP_HTTP_RESPONSE;
- while (' ' == *code) ++code;
+ while (code < end && ' ' == *code) ++code;
if (code && end > code) {
/* rfc7230#3.1.2 The status-code element is a 3-digit integer code */
PHP_HTTP_INFO(info).response.code = 100*(*code++ - '0');
if (http > url) {
/* CONNECT presents an authority only */
if (strcasecmp(PHP_HTTP_INFO(info).request.method, "CONNECT")) {
- PHP_HTTP_INFO(info).request.url = php_http_url_parse(url, http - url, ~0 TSRMLS_CC);
+ PHP_HTTP_INFO(info).request.url = php_http_url_parse(url, http - url, ~0);
} else {
- PHP_HTTP_INFO(info).request.url = php_http_url_parse_authority(url, http - url, ~0 TSRMLS_CC);
+ PHP_HTTP_INFO(info).request.url = php_http_url_parse_authority(url, http - url, ~0);
}
+ if (!PHP_HTTP_INFO(info).request.url) {
+ PTR_SET(PHP_HTTP_INFO(info).request.method, NULL);
+ return NULL;
+ }
} else {
PTR_SET(PHP_HTTP_INFO(info).request.method, NULL);
return NULL;
static void message_headers(php_http_message_t *msg, php_http_buffer_t *str);
-zend_bool php_http_message_info_callback(php_http_message_t **message, HashTable **headers, php_http_info_t *info TSRMLS_DC)
+zend_bool php_http_message_info_callback(php_http_message_t **message, HashTable **headers, php_http_info_t *info)
{
php_http_message_t *old = *message;
/* advance message */
if (!old || old->type || zend_hash_num_elements(&old->hdrs)) {
- (*message) = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+ (*message) = php_http_message_init(NULL, 0, NULL);
(*message)->parent = old;
if (headers) {
(*headers) = &((*message)->hdrs);
return old != *message;
}
-php_http_message_t *php_http_message_init(php_http_message_t *message, php_http_message_type_t type, php_http_message_body_t *body TSRMLS_DC)
+php_http_message_t *php_http_message_init(php_http_message_t *message, php_http_message_type_t type, php_http_message_body_t *body)
{
if (!message) {
message = emalloc(sizeof(*message));
}
memset(message, 0, sizeof(*message));
- TSRMLS_SET_CTX(message->ts);
php_http_message_set_type(message, type);
message->http.version.major = 1;
message->http.version.minor = 1;
zend_hash_init(&message->hdrs, 0, NULL, ZVAL_PTR_DTOR, 0);
- message->body = body ? body : php_http_message_body_init(NULL, NULL TSRMLS_CC);
+ message->body = body ? body : php_http_message_body_init(NULL, NULL);
return message;
}
-php_http_message_t *php_http_message_init_env(php_http_message_t *message, php_http_message_type_t type TSRMLS_DC)
+php_http_message_t *php_http_message_init_env(php_http_message_t *message, php_http_message_type_t type)
{
int free_msg = !message;
zval *sval, tval;
switch (type) {
case PHP_HTTP_REQUEST:
- mbody = php_http_env_get_request_body(TSRMLS_C);
+ mbody = php_http_env_get_request_body();
php_http_message_body_addref(mbody);
- message = php_http_message_init(message, type, mbody TSRMLS_CC);
- if ((sval = php_http_env_get_server_var(ZEND_STRL("SERVER_PROTOCOL"), 1 TSRMLS_CC)) && !strncmp(Z_STRVAL_P(sval), "HTTP/", lenof("HTTP/"))) {
- php_http_version_parse(&message->http.version, Z_STRVAL_P(sval) TSRMLS_CC);
+ message = php_http_message_init(message, type, mbody);
+ if ((sval = php_http_env_get_server_var(ZEND_STRL("SERVER_PROTOCOL"), 1)) && !strncmp(Z_STRVAL_P(sval), "HTTP/", lenof("HTTP/"))) {
+ php_http_version_parse(&message->http.version, Z_STRVAL_P(sval));
}
- if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_METHOD"), 1 TSRMLS_CC))) {
+ if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_METHOD"), 1))) {
message->http.info.request.method = estrdup(Z_STRVAL_P(sval));
}
- if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_URI"), 1 TSRMLS_CC))) {
- message->http.info.request.url = php_http_url_parse(Z_STRVAL_P(sval), Z_STRLEN_P(sval), ~0 TSRMLS_CC);
+ if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_URI"), 1))) {
+ message->http.info.request.url = php_http_url_parse(Z_STRVAL_P(sval), Z_STRLEN_P(sval), ~0);
}
- php_http_env_get_request_headers(&message->hdrs TSRMLS_CC);
+ php_http_env_get_request_headers(&message->hdrs);
break;
case PHP_HTTP_RESPONSE:
- message = php_http_message_init(NULL, type, NULL TSRMLS_CC);
- if (!SG(sapi_headers).http_status_line || !php_http_info_parse((php_http_info_t *) &message->http, SG(sapi_headers).http_status_line TSRMLS_CC)) {
+ message = php_http_message_init(NULL, type, NULL);
+ if (!SG(sapi_headers).http_status_line || !php_http_info_parse((php_http_info_t *) &message->http, SG(sapi_headers).http_status_line)) {
if (!(message->http.info.response.code = SG(sapi_headers).http_response_code)) {
message->http.info.response.code = 200;
}
message->http.info.response.status = estrdup(php_http_env_get_response_status_for_code(message->http.info.response.code));
}
- php_http_env_get_response_headers(&message->hdrs TSRMLS_CC);
-#if PHP_VERSION_ID >= 50400
- if (php_output_get_level(TSRMLS_C)) {
- if (php_output_get_status(TSRMLS_C) & PHP_OUTPUT_SENT) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch response body, output has already been sent at %s:%d", php_output_get_start_filename(TSRMLS_C), php_output_get_start_lineno(TSRMLS_C));
+ php_http_env_get_response_headers(&message->hdrs);
+ if (php_output_get_level()) {
+ if (php_output_get_status() & PHP_OUTPUT_SENT) {
+ php_error_docref(NULL, E_WARNING, "Could not fetch response body, output has already been sent at %s:%d", php_output_get_start_filename(), php_output_get_start_lineno());
goto error;
- } else if (SUCCESS != php_output_get_contents(&tval TSRMLS_CC)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch response body");
+ } else if (SUCCESS != php_output_get_contents(&tval)) {
+ php_error_docref(NULL, E_WARNING, "Could not fetch response body");
goto error;
} else {
php_http_message_body_append(message->body, Z_STRVAL(tval), Z_STRLEN(tval));
zval_dtor(&tval);
}
}
-#else
- if (OG(ob_nesting_level)) {
- if (php_get_output_start_filename(TSRMLS_C)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch response body, output has already been sent at %s:%d", php_get_output_start_filename(TSRMLS_C), php_get_output_start_lineno(TSRMLS_C));
- goto error;
- } else if (SUCCESS != php_ob_get_buffer(&tval TSRMLS_CC)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not fetch response body");
- goto error;
- } else {
- php_http_message_body_append(message->body, Z_STRVAL(tval), Z_STRLEN(tval));
- zval_dtor(&tval);
- }
- }
-#endif
break;
default:
return message;
}
-php_http_message_t *php_http_message_parse(php_http_message_t *msg, const char *str, size_t len, zend_bool greedy TSRMLS_DC)
+php_http_message_t *php_http_message_parse(php_http_message_t *msg, const char *str, size_t len, zend_bool greedy)
{
php_http_message_parser_t p;
php_http_buffer_t buf;
int free_msg;
php_http_buffer_from_string_ex(&buf, str, len);
- php_http_message_parser_init(&p TSRMLS_CC);
+ php_http_message_parser_init(&p);
if ((free_msg = !msg)) {
- msg = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+ msg = php_http_message_init(NULL, 0, NULL);
}
if (greedy) {
return msg;
}
-zval *php_http_message_header(php_http_message_t *msg, const char *key_str, size_t key_len, int join)
+zval *php_http_message_header(php_http_message_t *msg, const char *key_str, size_t key_len)
{
- zval *ret = NULL, **header;
+ zval *ret;
char *key;
ALLOCA_FLAG(free_key);
key = do_alloca(key_len + 1, free_key);
+
memcpy(key, key_str, key_len);
key[key_len] = '\0';
php_http_pretty_key(key, key_len, 1, 1);
- if (SUCCESS == zend_symtable_find(&msg->hdrs, key, key_len + 1, (void *) &header)) {
- if (join && Z_TYPE_PP(header) == IS_ARRAY) {
- TSRMLS_FETCH_FROM_CTX(msg->ts);
-
- ret = php_http_header_value_to_string(*header TSRMLS_CC);
- } else {
- Z_ADDREF_PP(header);
- ret = *header;
- }
- }
+ ret = zend_symtable_str_find(&msg->hdrs, key, key_len);
free_alloca(key, free_key);
zend_bool php_http_message_is_multipart(php_http_message_t *msg, char **boundary)
{
- zval *ct = php_http_message_header(msg, ZEND_STRL("Content-Type"), 1);
+ zend_string *ct = php_http_message_header_string(msg, ZEND_STRL("Content-Type"));
zend_bool is_multipart = 0;
- TSRMLS_FETCH_FROM_CTX(msg->ts);
if (ct) {
php_http_params_opts_t popts;
ZEND_INIT_SYMTABLE(¶ms);
php_http_params_opts_default_get(&popts);
- popts.input.str = Z_STRVAL_P(ct);
- popts.input.len = Z_STRLEN_P(ct);
+ popts.input.str = ct->val;
+ popts.input.len = ct->len;
- if (php_http_params_parse(¶ms, &popts TSRMLS_CC)) {
- zval **cur, **arg;
- char *ct_str;
+ if (php_http_params_parse(¶ms, &popts)) {
+ zval *cur, *arg;
+ zend_string *ct_str;
+ zend_ulong index;
zend_hash_internal_pointer_reset(¶ms);
- if (SUCCESS == zend_hash_get_current_data(¶ms, (void *) &cur)
- && Z_TYPE_PP(cur) == IS_ARRAY
- && HASH_KEY_IS_STRING == zend_hash_get_current_key(¶ms, &ct_str, NULL, 0)
+ if ((cur = zend_hash_get_current_data(¶ms))
+ && (Z_TYPE_P(cur) == IS_ARRAY)
+ && (HASH_KEY_IS_STRING == zend_hash_get_current_key(¶ms, &ct_str, &index))
) {
- if (php_http_match(ct_str, "multipart", PHP_HTTP_MATCH_WORD)) {
+ if (php_http_match(ct_str->val, "multipart", PHP_HTTP_MATCH_WORD)) {
is_multipart = 1;
/* get boundary */
if (boundary
- && SUCCESS == zend_hash_find(Z_ARRVAL_PP(cur), ZEND_STRS("arguments"), (void *) &arg)
- && Z_TYPE_PP(arg) == IS_ARRAY
+ && (arg = zend_hash_str_find(Z_ARRVAL_P(cur), ZEND_STRL("arguments")))
+ && Z_TYPE_P(arg) == IS_ARRAY
) {
- zval **val;
- HashPosition pos;
- php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
+ zval *val;
+ php_http_arrkey_t key;
- FOREACH_KEYVAL(pos, *arg, key, val) {
- if (key.type == HASH_KEY_IS_STRING && !strcasecmp(key.str, "boundary")) {
- zval *bnd = php_http_ztyp(IS_STRING, *val);
+ ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(arg), key.h, key.key, val)
+ {
+ if (key.key && key.key->len == lenof("boundary") && !strcasecmp(key.key->val, "boundary")) {
+ zend_string *bnd = zval_get_string(val);
- if (Z_STRLEN_P(bnd)) {
- *boundary = estrndup(Z_STRVAL_P(bnd), Z_STRLEN_P(bnd));
+ if (bnd->len) {
+ *boundary = estrndup(bnd->val, bnd->len);
}
- zval_ptr_dtor(&bnd);
+ zend_string_release(bnd);
}
}
+ ZEND_HASH_FOREACH_END();
}
}
}
}
zend_hash_destroy(¶ms);
- zval_ptr_dtor(&ct);
+ zend_string_release(ct);
}
return is_multipart;
void php_http_message_update_headers(php_http_message_t *msg)
{
- zval *h;
+ zval h;
size_t size;
+ zend_string *cl;
if (php_http_message_body_stream(msg->body)->readfilters.head) {
/* if a read stream filter is attached to the body the caller must also care for the headers */
- } else if ((h = php_http_message_header(msg, ZEND_STRL("Content-Range"), 0))) {
+ } else if (php_http_message_header(msg, ZEND_STRL("Content-Range"))) {
/* don't mess around with a Content-Range message */
- zval_ptr_dtor(&h);
} else if ((size = php_http_message_body_size(msg->body))) {
- MAKE_STD_ZVAL(h);
- ZVAL_LONG(h, size);
- zend_hash_update(&msg->hdrs, "Content-Length", sizeof("Content-Length"), &h, sizeof(zval *), NULL);
+ ZVAL_LONG(&h, size);
+ zend_hash_str_update(&msg->hdrs, "Content-Length", lenof("Content-Length"), &h);
if (msg->body->boundary) {
char *str;
size_t len;
+ zend_string *ct;
- if (!(h = php_http_message_header(msg, ZEND_STRL("Content-Type"), 1))) {
+ if (!(ct = php_http_message_header_string(msg, ZEND_STRL("Content-Type")))) {
len = spprintf(&str, 0, "multipart/form-data; boundary=\"%s\"", msg->body->boundary);
- MAKE_STD_ZVAL(h);
- ZVAL_STRINGL(h, str, len, 0);
- zend_hash_update(&msg->hdrs, "Content-Type", sizeof("Content-Type"), &h, sizeof(zval *), NULL);
- } else if (!php_http_match(Z_STRVAL_P(h), "boundary=", PHP_HTTP_MATCH_WORD)) {
- zval_dtor(h);
- Z_STRLEN_P(h) = spprintf(&Z_STRVAL_P(h), 0, "%s; boundary=\"%s\"", Z_STRVAL_P(h), msg->body->boundary);
- zend_hash_update(&msg->hdrs, "Content-Type", sizeof("Content-Type"), &h, sizeof(zval *), NULL);
+ ZVAL_STR(&h, php_http_cs2zs(str, len));
+ zend_hash_str_update(&msg->hdrs, "Content-Type", lenof("Content-Type"), &h);
+ } else if (!php_http_match(ct->val, "boundary=", PHP_HTTP_MATCH_WORD)) {
+ len = spprintf(&str, 0, "%s; boundary=\"%s\"", ct->val, msg->body->boundary);
+ ZVAL_STR(&h, php_http_cs2zs(str, len));
+ zend_hash_str_update(&msg->hdrs, "Content-Type", lenof("Content-Type"), &h);
+ zend_string_release(ct);
} else {
- zval_ptr_dtor(&h);
+ zend_string_release(ct);
}
}
- } else if ((h = php_http_message_header(msg, ZEND_STRL("Content-Length"), 1))) {
- zval *h_cpy = php_http_ztyp(IS_LONG, h);
-
- zval_ptr_dtor(&h);
- if (Z_LVAL_P(h_cpy)) {
+ } else if ((cl = php_http_message_header_string(msg, ZEND_STRL("Content-Length")))) {
+ if (!zend_string_equals_literal(cl, "0")) {
/* body->size == 0, so get rid of old Content-Length */
- zend_hash_del(&msg->hdrs, "Content-Length", sizeof("Content-Length"));
+ zend_hash_str_del(&msg->hdrs, ZEND_STRL("Content-Length"));
}
- zval_ptr_dtor(&h_cpy);
+ zend_string_release(cl);
}
}
static void message_headers(php_http_message_t *msg, php_http_buffer_t *str)
{
char *tmp = NULL;
- TSRMLS_FETCH_FROM_CTX(msg->ts);
switch (msg->type) {
case PHP_HTTP_REQUEST:
}
php_http_message_update_headers(msg);
- php_http_header_to_string(str, &msg->hdrs TSRMLS_CC);
+ php_http_header_to_string(str, &msg->hdrs);
}
void php_http_message_to_callback(php_http_message_t *msg, php_http_pass_callback_t cb, void *cb_arg)
php_http_message_t *php_http_message_reverse(php_http_message_t *msg)
{
- int i, c = 0;
-
- php_http_message_count(c, msg);
+ size_t i, c = php_http_message_count(msg);
if (c > 1) {
php_http_message_t *tmp = msg, **arr;
return msg;
}
-php_http_message_t *php_http_message_zip(php_http_message_t *one, php_http_message_t *two)
+php_http_message_t *php_http_message_zip(php_http_message_t *dst, php_http_message_t *src)
{
- php_http_message_t *dst = php_http_message_copy(one, NULL), *src = php_http_message_copy(two, NULL), *tmp_dst, *tmp_src, *ret = dst;
+ php_http_message_t *tmp_dst, *tmp_src, *ret = dst;
- while(dst && src) {
+ while (dst && src) {
tmp_dst = dst->parent;
tmp_src = src->parent;
dst->parent = src;
{
php_http_message_t *temp, *copy = NULL;
php_http_info_t info;
- TSRMLS_FETCH_FROM_CTX(from->ts);
if (from) {
info.type = from->type;
info.http = from->http;
- copy = temp = php_http_message_init(to, 0, php_http_message_body_copy(from->body, NULL) TSRMLS_CC);
+ copy = temp = php_http_message_init(to, 0, php_http_message_body_copy(from->body, NULL));
php_http_message_set_info(temp, &info);
- zend_hash_copy(&temp->hdrs, &from->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ zend_hash_copy(&temp->hdrs, &from->hdrs, (copy_ctor_func_t) zval_add_ref);
if (parents) while (from->parent) {
info.type = from->parent->type;
info.http = from->parent->http;
- temp->parent = php_http_message_init(NULL, 0, php_http_message_body_copy(from->parent->body, NULL) TSRMLS_CC);
+ temp->parent = php_http_message_init(NULL, 0, php_http_message_body_copy(from->parent->body, NULL));
php_http_message_set_info(temp->parent, &info);
- zend_hash_copy(&temp->parent->hdrs, &from->parent->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ array_copy(&from->parent->hdrs, &temp->parent->hdrs);
temp = temp->parent;
from = from->parent;
return copy;
}
-php_http_message_t *php_http_message_copy(php_http_message_t *from, php_http_message_t *to)
-{
- return php_http_message_copy_ex(from, to, 1);
-}
-
void php_http_message_dtor(php_http_message_t *message)
{
if (message) {
}
}
-static zval *php_http_message_object_read_prop(zval *object, zval *member, int type PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC);
-static void php_http_message_object_write_prop(zval *object, zval *member, zval *value PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC);
-static HashTable *php_http_message_object_get_props(zval *object TSRMLS_DC);
+static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *rv);
+static void php_http_message_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot);
static zend_object_handlers php_http_message_object_handlers;
static HashTable php_http_message_object_prophandlers;
-typedef void (*php_http_message_object_prophandler_func_t)(php_http_message_object_t *o, zval *v TSRMLS_DC);
+static void php_http_message_object_prophandler_hash_dtor(zval *pData)
+{
+ pefree(Z_PTR_P(pData), 1);
+}
+
+typedef void (*php_http_message_object_prophandler_func_t)(php_http_message_object_t *o, zval *v);
typedef struct php_http_message_object_prophandler {
php_http_message_object_prophandler_func_t read;
static ZEND_RESULT_CODE php_http_message_object_add_prophandler(const char *prop_str, size_t prop_len, php_http_message_object_prophandler_func_t read, php_http_message_object_prophandler_func_t write) {
php_http_message_object_prophandler_t h = { read, write };
- return zend_hash_add(&php_http_message_object_prophandlers, prop_str, prop_len + 1, (void *) &h, sizeof(h), NULL);
+ if (!zend_hash_str_add_mem(&php_http_message_object_prophandlers, prop_str, prop_len, (void *) &h, sizeof(h))) {
+ return FAILURE;
+ }
+ return SUCCESS;
}
-static ZEND_RESULT_CODE php_http_message_object_get_prophandler(const char *prop_str, size_t prop_len, php_http_message_object_prophandler_t **handler) {
- return zend_hash_find(&php_http_message_object_prophandlers, prop_str, prop_len + 1, (void *) handler);
+static php_http_message_object_prophandler_t *php_http_message_object_get_prophandler(zend_string *name_str) {
+ return zend_hash_str_find_ptr(&php_http_message_object_prophandlers, name_str->val, name_str->len);
}
-static void php_http_message_object_prophandler_get_type(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_type(php_http_message_object_t *obj, zval *return_value) {
RETVAL_LONG(obj->message->type);
}
-static void php_http_message_object_prophandler_set_type(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- zval *cpy = php_http_ztyp(IS_LONG, value);
- php_http_message_set_type(obj->message, Z_LVAL_P(cpy));
- zval_ptr_dtor(&cpy);
+static void php_http_message_object_prophandler_set_type(php_http_message_object_t *obj, zval *value) {
+ php_http_message_set_type(obj->message, zval_get_long(value));
}
-static void php_http_message_object_prophandler_get_request_method(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_request_method(php_http_message_object_t *obj, zval *return_value) {
if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message) && obj->message->http.info.request.method) {
- RETVAL_STRING(obj->message->http.info.request.method, 1);
+ RETVAL_STRING(obj->message->http.info.request.method);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_request_method(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
+static void php_http_message_object_prophandler_set_request_method(php_http_message_object_t *obj, zval *value) {
if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message)) {
- zval *cpy = php_http_ztyp(IS_STRING, value);
- PTR_SET(obj->message->http.info.request.method, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
- zval_ptr_dtor(&cpy);
+ zend_string *zs = zval_get_string(value);
+ PTR_SET(obj->message->http.info.request.method, estrndup(zs->val, zs->len));
+ zend_string_release(zs);
}
}
-static void php_http_message_object_prophandler_get_request_url(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_request_url(php_http_message_object_t *obj, zval *return_value) {
char *url_str;
size_t url_len;
if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message) && obj->message->http.info.request.url && php_http_url_to_string(obj->message->http.info.request.url, &url_str, &url_len, 0)) {
- RETVAL_STRINGL(url_str, url_len, 0);
+ RETVAL_STR(php_http_cs2zs(url_str, url_len));
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_request_url(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
+static void php_http_message_object_prophandler_set_request_url(php_http_message_object_t *obj, zval *value) {
if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message)) {
- PTR_SET(obj->message->http.info.request.url, php_http_url_from_zval(value, ~0 TSRMLS_CC));
+ PTR_SET(obj->message->http.info.request.url, php_http_url_from_zval(value, ~0));
}
}
-static void php_http_message_object_prophandler_get_response_status(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_response_status(php_http_message_object_t *obj, zval *return_value) {
if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message) && obj->message->http.info.response.status) {
- RETVAL_STRING(obj->message->http.info.response.status, 1);
+ RETVAL_STRING(obj->message->http.info.response.status);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_response_status(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
+static void php_http_message_object_prophandler_set_response_status(php_http_message_object_t *obj, zval *value) {
if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
- zval *cpy = php_http_ztyp(IS_STRING, value);
- PTR_SET(obj->message->http.info.response.status, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
- zval_ptr_dtor(&cpy);
+ zend_string *zs = zval_get_string(value);
+ PTR_SET(obj->message->http.info.response.status, estrndup(zs->val, zs->len));
+ zend_string_release(zs);
}
}
-static void php_http_message_object_prophandler_get_response_code(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_response_code(php_http_message_object_t *obj, zval *return_value) {
if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
RETVAL_LONG(obj->message->http.info.response.code);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_response_code(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
+static void php_http_message_object_prophandler_set_response_code(php_http_message_object_t *obj, zval *value) {
if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
- zval *cpy = php_http_ztyp(IS_LONG, value);
- obj->message->http.info.response.code = Z_LVAL_P(cpy);
+ obj->message->http.info.response.code = zval_get_long(value);
PTR_SET(obj->message->http.info.response.status, estrdup(php_http_env_get_response_status_for_code(obj->message->http.info.response.code)));
- zval_ptr_dtor(&cpy);
}
}
-static void php_http_message_object_prophandler_get_http_version(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_http_version(php_http_message_object_t *obj, zval *return_value) {
char *version_str;
size_t version_len;
- php_http_version_to_string(&obj->message->http.version, &version_str, &version_len, NULL, NULL TSRMLS_CC);
- RETVAL_STRINGL(version_str, version_len, 0);
+ php_http_version_to_string(&obj->message->http.version, &version_str, &version_len, NULL, NULL);
+ RETVAL_STR(php_http_cs2zs(version_str, version_len));
}
-static void php_http_message_object_prophandler_set_http_version(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- zval *cpy = php_http_ztyp(IS_STRING, value);
- php_http_version_parse(&obj->message->http.version, Z_STRVAL_P(cpy) TSRMLS_CC);
- zval_ptr_dtor(&cpy);
+static void php_http_message_object_prophandler_set_http_version(php_http_message_object_t *obj, zval *value) {
+ zend_string *zs = zval_get_string(value);
+ php_http_version_parse(&obj->message->http.version, zs->val);
+ zend_string_release(zs);
}
-static void php_http_message_object_prophandler_get_headers(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_headers(php_http_message_object_t *obj, zval *return_value ) {
array_init(return_value);
- zend_hash_copy(Z_ARRVAL_P(return_value), &obj->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ array_copy(&obj->message->hdrs, Z_ARRVAL_P(return_value));
}
-static void php_http_message_object_prophandler_set_headers(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- zval *cpy = php_http_ztyp(IS_ARRAY, value);
+static void php_http_message_object_prophandler_set_headers(php_http_message_object_t *obj, zval *value) {
+ HashTable *headers;
+ zval *orig_value = value;
+
+ if (Z_TYPE_P(value) != IS_ARRAY && Z_TYPE_P(value) != IS_OBJECT) {
+ convert_to_array_ex(value);
+ }
+ headers = HASH_OF(value);
zend_hash_clean(&obj->message->hdrs);
- zend_hash_copy(&obj->message->hdrs, Z_ARRVAL_P(cpy), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
- zval_ptr_dtor(&cpy);
+ array_copy(headers, &obj->message->hdrs);
+
+ if (orig_value != value) {
+ zval_ptr_dtor(value);
+ }
}
-static void php_http_message_object_prophandler_get_body(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_body(php_http_message_object_t *obj, zval *return_value) {
if (obj->body) {
- RETVAL_OBJVAL(obj->body->zv, 1);
+ RETVAL_OBJECT(&obj->body->zo, 1);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_body(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- php_http_message_object_set_body(obj, value TSRMLS_CC);
+static void php_http_message_object_prophandler_set_body(php_http_message_object_t *obj, zval *value) {
+ php_http_message_object_set_body(obj, value);
}
-static void php_http_message_object_prophandler_get_parent_message(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
+static void php_http_message_object_prophandler_get_parent_message(php_http_message_object_t *obj, zval *return_value) {
if (obj->message->parent) {
- RETVAL_OBJVAL(obj->parent->zv, 1);
+ RETVAL_OBJECT(&obj->parent->zo, 1);
} else {
RETVAL_NULL();
}
}
-static void php_http_message_object_prophandler_set_parent_message(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
- if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_message_class_entry TSRMLS_CC)) {
- php_http_message_object_t *parent_obj = zend_object_store_get_object(value TSRMLS_CC);
+static void php_http_message_object_prophandler_set_parent_message(php_http_message_object_t *obj, zval *value) {
+ if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_message_class_entry)) {
+ php_http_message_object_t *parent_obj = PHP_HTTP_OBJ(NULL, value);
if (obj->message->parent) {
- zend_objects_store_del_ref_by_handle(obj->parent->zv.handle TSRMLS_CC);
+ zend_objects_store_del(&obj->parent->zo);
}
- Z_OBJ_ADDREF_P(value);
+ Z_ADDREF_P(value);
obj->parent = parent_obj;
obj->message->parent = parent_obj->message;
}
#define PHP_HTTP_MESSAGE_OBJECT_INIT(obj) \
do { \
if (!obj->message) { \
- obj->message = php_http_message_init(NULL, 0, NULL TSRMLS_CC); \
+ obj->message = php_http_message_init(NULL, 0, NULL); \
} \
} while(0)
-void php_http_message_object_reverse(zval *this_ptr, zval *return_value TSRMLS_DC)
+void php_http_message_object_reverse(zval *zmsg, zval *return_value)
{
- int i = 0;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ size_t i;
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, zmsg);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
/* count */
- php_http_message_count(i, obj->message);
+ i = php_http_message_count(obj->message);
if (i > 1) {
php_http_message_object_t **objects;
objects[0]->parent = NULL;
/* add ref, because we previously have not been a parent message */
- Z_OBJ_ADDREF_P(getThis());
- RETVAL_OBJVAL(objects[last]->zv, 0);
+ Z_ADDREF_P(zmsg);
+ /* no addref, because we've been a parent message previously */
+ RETVAL_OBJECT(&objects[last]->zo, 0);
efree(objects);
} else {
- RETURN_ZVAL(getThis(), 1, 0);
+ RETURN_ZVAL(zmsg, 1, 0);
}
}
-void php_http_message_object_prepend(zval *this_ptr, zval *prepend, zend_bool top TSRMLS_DC)
+void php_http_message_object_prepend(zval *this_ptr, zval *prepend, zend_bool top)
{
- zval m;
php_http_message_t *save_parent_msg = NULL;
- php_http_message_object_t *save_parent_obj = NULL, *obj = zend_object_store_get_object(this_ptr TSRMLS_CC);
- php_http_message_object_t *prepend_obj = zend_object_store_get_object(prepend TSRMLS_CC);
-
- INIT_PZVAL(&m);
- m.type = IS_OBJECT;
+ php_http_message_object_t *save_parent_obj = NULL, *obj = PHP_HTTP_OBJ(NULL, this_ptr);
+ php_http_message_object_t *prepend_obj = PHP_HTTP_OBJ(NULL, prepend);
if (!top) {
save_parent_obj = obj->parent;
obj->message->parent = prepend_obj->message;
/* add ref */
- zend_objects_store_add_ref(prepend TSRMLS_CC);
+ Z_ADDREF_P(prepend);
if (!top) {
prepend_obj->parent = save_parent_obj;
}
}
-ZEND_RESULT_CODE php_http_message_object_set_body(php_http_message_object_t *msg_obj, zval *zbody TSRMLS_DC)
+ZEND_RESULT_CODE php_http_message_object_set_body(php_http_message_object_t *msg_obj, zval *zbody)
{
- zval *tmp = NULL;
php_stream *s;
- zend_object_value ov;
+ zend_string *body_str;
php_http_message_body_t *body;
php_http_message_body_object_t *body_obj;
switch (Z_TYPE_P(zbody)) {
case IS_RESOURCE:
- php_stream_from_zval_no_verify(s, &zbody);
+ php_stream_from_zval_no_verify(s, zbody);
if (!s) {
php_http_throw(unexpected_val, "The stream is not a valid resource", NULL);
return FAILURE;
is_resource:
- body = php_http_message_body_init(NULL, s TSRMLS_CC);
- if (SUCCESS != php_http_new(&ov, php_http_message_body_class_entry, (php_http_new_t) php_http_message_body_object_new_ex, NULL, body, NULL TSRMLS_CC)) {
+ body = php_http_message_body_init(NULL, s);
+ if (!(body_obj = php_http_message_body_object_new_ex(php_http_message_body_class_entry, body))) {
php_http_message_body_free(&body);
return FAILURE;
}
- MAKE_STD_ZVAL(tmp);
- ZVAL_OBJVAL(tmp, ov, 0);
- zbody = tmp;
break;
case IS_OBJECT:
- if (instanceof_function(Z_OBJCE_P(zbody), php_http_message_body_class_entry TSRMLS_CC)) {
- Z_OBJ_ADDREF_P(zbody);
+ if (instanceof_function(Z_OBJCE_P(zbody), php_http_message_body_class_entry)) {
+ Z_ADDREF_P(zbody);
+ body_obj = PHP_HTTP_OBJ(NULL, zbody);
break;
}
/* no break */
default:
- tmp = php_http_ztyp(IS_STRING, zbody);
+ body_str = zval_get_string(zbody);
s = php_stream_temp_new();
- php_stream_write(s, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
- zval_ptr_dtor(&tmp);
- tmp = NULL;
+ php_stream_write(s, body_str->val, body_str->len);
+ zend_string_release(body_str);
goto is_resource;
}
- body_obj = zend_object_store_get_object(zbody TSRMLS_CC);
if (!body_obj->body) {
- body_obj->body = php_http_message_body_init(NULL, NULL TSRMLS_CC);
+ body_obj->body = php_http_message_body_init(NULL, NULL);
}
if (msg_obj->body) {
- zend_objects_store_del_ref_by_handle(msg_obj->body->zv.handle TSRMLS_CC);
+ zend_objects_store_del(&msg_obj->body->zo);
}
if (msg_obj->message) {
php_http_message_body_free(&msg_obj->message->body);
- msg_obj->message->body = php_http_message_body_init(&body_obj->body, NULL TSRMLS_CC);
+ msg_obj->message->body = body_obj->body;
} else {
- msg_obj->message = php_http_message_init(NULL, 0, php_http_message_body_init(&body_obj->body, NULL TSRMLS_CC) TSRMLS_CC);
+ msg_obj->message = php_http_message_init(NULL, 0, body_obj->body);
}
+ php_http_message_body_addref(body_obj->body);
msg_obj->body = body_obj;
- if (tmp) {
- FREE_ZVAL(tmp);
- }
return SUCCESS;
}
ZEND_RESULT_CODE php_http_message_object_init_body_object(php_http_message_object_t *obj)
{
- TSRMLS_FETCH_FROM_CTX(obj->message->ts);
-
php_http_message_body_addref(obj->message->body);
- return php_http_new(NULL, php_http_message_body_class_entry, (php_http_new_t) php_http_message_body_object_new_ex, NULL, obj->message->body, (void *) &obj->body TSRMLS_CC);
+ return php_http_new((void *) &obj->body, php_http_message_body_class_entry, (php_http_new_t) php_http_message_body_object_new_ex, NULL, obj->message->body);
}
-zend_object_value php_http_message_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *php_http_message_object_new(zend_class_entry *ce)
{
- return php_http_message_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+ return &php_http_message_object_new_ex(ce, NULL)->zo;
}
-zend_object_value php_http_message_object_new_ex(zend_class_entry *ce, php_http_message_t *msg, php_http_message_object_t **ptr TSRMLS_DC)
+php_http_message_object_t *php_http_message_object_new_ex(zend_class_entry *ce, php_http_message_t *msg)
{
php_http_message_object_t *o;
- o = ecalloc(1, sizeof(php_http_message_object_t));
- zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
- object_properties_init((zend_object *) o, ce);
-
- if (ptr) {
- *ptr = o;
- }
+ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+ zend_object_std_init(&o->zo, ce);
+ object_properties_init(&o->zo, ce);
if (msg) {
o->message = msg;
if (msg->parent) {
- php_http_message_object_new_ex(ce, msg->parent, &o->parent TSRMLS_CC);
+ o->parent = php_http_message_object_new_ex(ce, msg->parent);
}
- php_http_message_body_object_new_ex(php_http_message_body_class_entry, php_http_message_body_init(&msg->body, NULL TSRMLS_CC), &o->body TSRMLS_CC);
+ o->body = php_http_message_body_object_new_ex(php_http_message_body_class_entry, php_http_message_body_init(&msg->body, NULL));
}
- o->zv.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_message_object_free, NULL TSRMLS_CC);
- o->zv.handlers = &php_http_message_object_handlers;
+ o->zo.handlers = &php_http_message_object_handlers;
- return o->zv;
+ return o;
}
-zend_object_value php_http_message_object_clone(zval *this_ptr TSRMLS_DC)
+zend_object *php_http_message_object_clone(zval *this_ptr)
{
- zend_object_value new_ov;
php_http_message_object_t *new_obj = NULL;
- php_http_message_object_t *old_obj = zend_object_store_get_object(this_ptr TSRMLS_CC);
+ php_http_message_object_t *old_obj = PHP_HTTP_OBJ(NULL, this_ptr);
- new_ov = php_http_message_object_new_ex(old_obj->zo.ce, php_http_message_copy(old_obj->message, NULL), &new_obj TSRMLS_CC);
- zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
+ new_obj = php_http_message_object_new_ex(old_obj->zo.ce, php_http_message_copy(old_obj->message, NULL));
+ zend_objects_clone_members(&new_obj->zo, &old_obj->zo);
- return new_ov;
+ return &new_obj->zo;
}
-void php_http_message_object_free(void *object TSRMLS_DC)
+void php_http_message_object_free(zend_object *object)
{
- php_http_message_object_t *o = (php_http_message_object_t *) object;
+ php_http_message_object_t *o = PHP_HTTP_OBJ(object, NULL);
- if (o->iterator) {
+ if (!Z_ISUNDEF(o->iterator)) {
zval_ptr_dtor(&o->iterator);
- o->iterator = NULL;
+ ZVAL_UNDEF(&o->iterator);
}
if (o->message) {
/* do NOT free recursivly */
o->message = NULL;
}
if (o->parent) {
- zend_objects_store_del_ref_by_handle(o->parent->zv.handle TSRMLS_CC);
+ if (GC_REFCOUNT(&o->parent->zo) == 1) {
+ zend_objects_store_del(&o->parent->zo);
+ }
+ zend_objects_store_del(&o->parent->zo);
o->parent = NULL;
}
if (o->body) {
- zend_objects_store_del_ref_by_handle(o->body->zv.handle TSRMLS_CC);
+ if (GC_REFCOUNT(&o->body->zo) == 1) {
+ zend_objects_store_del(&o->body->zo);
+ }
+ zend_objects_store_del(&o->body->zo);
o->body = NULL;
}
- zend_object_std_dtor((zend_object *) o TSRMLS_CC);
- efree(o);
+ zend_object_std_dtor(object);
}
-static zval *php_http_message_object_read_prop(zval *object, zval *member, int type PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC)
+static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *tmp)
{
- php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
- php_http_message_object_prophandler_t *handler;
- zval *return_value, *copy = php_http_ztyp(IS_STRING, member);
+ zval *return_value;
+ zend_string *member_name = zval_get_string(member);
+ php_http_message_object_prophandler_t *handler = php_http_message_object_get_prophandler(member_name);
- PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
+ if (!handler || type == BP_VAR_R || type == BP_VAR_IS) {
+ return_value = zend_get_std_object_handlers()->read_property(object, member, type, cache_slot, tmp);
- if (SUCCESS == php_http_message_object_get_prophandler(Z_STRVAL_P(copy), Z_STRLEN_P(copy), &handler)) {
- ALLOC_ZVAL(return_value);
- Z_SET_REFCOUNT_P(return_value, 0);
- Z_UNSET_ISREF_P(return_value);
+ if (handler) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
- if (type == BP_VAR_R) {
- handler->read(obj, return_value TSRMLS_CC);
- } else {
- php_property_proxy_t *proxy = php_property_proxy_init(object, Z_STRVAL_P(copy), Z_STRLEN_P(copy) TSRMLS_CC);
- RETVAL_OBJVAL(php_property_proxy_object_new_ex(php_property_proxy_get_class_entry(), proxy, NULL TSRMLS_CC), 0);
+ PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
+ handler->read(obj, tmp);
+
+ zval_ptr_dtor(return_value);
+ ZVAL_COPY_VALUE(return_value, tmp);
}
+ zend_string_release(member_name);
+ return return_value;
} else {
- return_value = zend_get_std_object_handlers()->read_property(object, member, type PHP_HTTP_ZEND_LITERAL_CC TSRMLS_CC);
- }
+ php_property_proxy_t *proxy;
+ php_property_proxy_object_t *proxy_obj;
- zval_ptr_dtor(©);
+ proxy = php_property_proxy_init(object, member_name);
+ proxy_obj = php_property_proxy_object_new_ex(NULL, proxy);
- return return_value;
+ ZVAL_OBJ(tmp, &proxy_obj->zo);
+ zend_string_release(member_name);
+ return tmp;
+ }
}
-static void php_http_message_object_write_prop(zval *object, zval *member, zval *value PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC)
+static void php_http_message_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot)
{
- php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
php_http_message_object_prophandler_t *handler;
- zval *copy = php_http_ztyp(IS_STRING, member);
+ zend_string *member_name = zval_get_string(member);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if (SUCCESS == php_http_message_object_get_prophandler(Z_STRVAL_P(copy), Z_STRLEN_P(copy), &handler)) {
- handler->write(obj, value TSRMLS_CC);
+ if ((handler = php_http_message_object_get_prophandler(member_name))) {
+ handler->write(obj, value);
} else {
- zend_get_std_object_handlers()->write_property(object, member, value PHP_HTTP_ZEND_LITERAL_CC TSRMLS_CC);
+ zend_get_std_object_handlers()->write_property(object, member, value, cache_slot);
}
- zval_ptr_dtor(©);
+ zend_string_release(member_name);
}
-static HashTable *php_http_message_object_get_props(zval *object TSRMLS_DC)
+static HashTable *php_http_message_object_get_debug_info(zval *object, int *is_temp)
{
- zval *headers;
- php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
- HashTable *props = zend_get_std_object_handlers()->get_properties(object TSRMLS_CC);
- zval array, *parent, *body;
+ zval tmp;
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+ HashTable *props = zend_get_std_object_handlers()->get_properties(object);
char *ver_str, *url_str = NULL;
size_t ver_len, url_len = 0;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- INIT_PZVAL_ARRAY(&array, props);
+ *is_temp = 0;
-#define ASSOC_PROP(ptype, n, val) \
- do { \
- zend_property_info *pi; \
- if (SUCCESS == zend_hash_find(&obj->zo.ce->properties_info, n, sizeof(n), (void *) &pi)) { \
- add_assoc_ ##ptype## _ex(&array, pi->name, pi->name_length + 1, val); \
- } \
- } while(0) \
-
-#define ASSOC_STRING(name, val) ASSOC_STRINGL(name, val, strlen(val))
-#define ASSOC_STRINGL(name, val, len) ASSOC_STRINGL_EX(name, val, len, 1)
-#define ASSOC_STRINGL_EX(n, val, len, cpy) \
+#define UPDATE_PROP(name_str, action_with_tmp) \
do { \
zend_property_info *pi; \
- if (SUCCESS == zend_hash_find(&obj->zo.ce->properties_info, n, sizeof(n), (void *) &pi)) { \
- add_assoc_stringl_ex(&array, pi->name, pi->name_length + 1, val, len, cpy); \
+ if ((pi = zend_hash_str_find_ptr(&obj->zo.ce->properties_info, name_str, lenof(name_str)))) { \
+ action_with_tmp; \
+ zend_hash_update_ind(props, pi->name, &tmp); \
} \
} while(0)
- ASSOC_PROP(long, "type", obj->message->type);
+ UPDATE_PROP("type", ZVAL_LONG(&tmp, obj->message->type));
+
ver_len = spprintf(&ver_str, 0, "%u.%u", obj->message->http.version.major, obj->message->http.version.minor);
- ASSOC_STRINGL_EX("httpVersion", ver_str, ver_len, 0);
+ UPDATE_PROP("httpVersion", ZVAL_STR(&tmp, php_http_cs2zs(ver_str, ver_len)));
switch (obj->message->type) {
case PHP_HTTP_REQUEST:
- ASSOC_PROP(long, "responseCode", 0);
- ASSOC_STRINGL("responseStatus", "", 0);
- ASSOC_STRING("requestMethod", STR_PTR(obj->message->http.info.request.method));
+ UPDATE_PROP("responseCode", ZVAL_LONG(&tmp, 0));
+ UPDATE_PROP("responseStatus", ZVAL_EMPTY_STRING(&tmp));
+ UPDATE_PROP("requestMethod", ZVAL_STRING(&tmp, STR_PTR(obj->message->http.info.request.method)));
if (obj->message->http.info.request.url) {
php_http_url_to_string(obj->message->http.info.request.url, &url_str, &url_len, 0);
- ASSOC_STRINGL_EX("requestUrl", url_str, url_len, 0);
+ UPDATE_PROP("requestUrl", ZVAL_STR(&tmp, php_http_cs2zs(url_str, url_len)));
} else {
- ASSOC_STRINGL("requestUrl", "", 0);
+ UPDATE_PROP("requestUrl", ZVAL_EMPTY_STRING(&tmp));
}
break;
case PHP_HTTP_RESPONSE:
- ASSOC_PROP(long, "responseCode", obj->message->http.info.response.code);
- ASSOC_STRING("responseStatus", STR_PTR(obj->message->http.info.response.status));
- ASSOC_STRINGL("requestMethod", "", 0);
- ASSOC_STRINGL("requestUrl", "", 0);
+ UPDATE_PROP("responseCode", ZVAL_LONG(&tmp, obj->message->http.info.response.code));
+ UPDATE_PROP("responseStatus", ZVAL_STRING(&tmp, STR_PTR(obj->message->http.info.response.status)));
+ UPDATE_PROP("requestMethod", ZVAL_EMPTY_STRING(&tmp));
+ UPDATE_PROP("requestUrl", ZVAL_EMPTY_STRING(&tmp));
break;
case PHP_HTTP_NONE:
default:
- ASSOC_PROP(long, "responseCode", 0);
- ASSOC_STRINGL("responseStatus", "", 0);
- ASSOC_STRINGL("requestMethod", "", 0);
- ASSOC_STRINGL("requestUrl", "", 0);
+ UPDATE_PROP("responseCode", ZVAL_LONG(&tmp, 0));
+ UPDATE_PROP("responseStatus", ZVAL_EMPTY_STRING(&tmp));
+ UPDATE_PROP("requestMethod", ZVAL_EMPTY_STRING(&tmp));
+ UPDATE_PROP("requestUrl", ZVAL_EMPTY_STRING(&tmp));
break;
}
- MAKE_STD_ZVAL(headers);
- array_init(headers);
- zend_hash_copy(Z_ARRVAL_P(headers), &obj->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
- ASSOC_PROP(zval, "headers", headers);
+ UPDATE_PROP("headers",
+ array_init(&tmp);
+ array_copy(&obj->message->hdrs, Z_ARRVAL(tmp));
+ );
- MAKE_STD_ZVAL(body);
- if (obj->body) {
- ZVAL_OBJVAL(body, obj->body->zv, 1);
- } else {
- ZVAL_NULL(body);
- }
- ASSOC_PROP(zval, "body", body);
+ UPDATE_PROP("body",
+ if (obj->body) {
+ ZVAL_OBJECT(&tmp, &obj->body->zo, 1);
+ } else {
+ ZVAL_NULL(&tmp);
+ }
+ );
- MAKE_STD_ZVAL(parent);
- if (obj->message->parent) {
- ZVAL_OBJVAL(parent, obj->parent->zv, 1);
- } else {
- ZVAL_NULL(parent);
- }
- ASSOC_PROP(zval, "parentMessage", parent);
+ UPDATE_PROP("parentMessage",
+ if (obj->message->parent) {
+ ZVAL_OBJECT(&tmp, &obj->parent->zo, 1);
+ } else {
+ ZVAL_NULL(&tmp);
+ }
+ );
return props;
}
zend_bool greedy = 1;
zval *zmessage = NULL;
php_http_message_t *msg = NULL;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!b", &zmessage, &greedy), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|z!b", &zmessage, &greedy), invalid_arg, return);
- zend_replace_error_handling(EH_THROW, php_http_exception_bad_message_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_bad_message_class_entry, &zeh);
if (zmessage && Z_TYPE_P(zmessage) == IS_RESOURCE) {
php_stream *s;
php_http_message_parser_t p;
zend_error_handling zeh;
- zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh TSRMLS_CC);
- php_stream_from_zval(s, &zmessage);
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh);
+ php_stream_from_zval(s, zmessage);
+ zend_restore_error_handling(&zeh);
- if (s && php_http_message_parser_init(&p TSRMLS_CC)) {
+ if (s && php_http_message_parser_init(&p)) {
unsigned flags = (greedy ? PHP_HTTP_MESSAGE_PARSER_GREEDY : 0);
php_http_buffer_t buf;
php_http_throw(bad_message, "Empty message received from stream", NULL);
}
} else if (zmessage) {
- zmessage = php_http_ztyp(IS_STRING, zmessage);
- msg = php_http_message_parse(NULL, Z_STRVAL_P(zmessage), Z_STRLEN_P(zmessage), greedy TSRMLS_CC);
+ zend_string *zs_msg = zval_get_string(zmessage);
+
+ msg = php_http_message_parse(NULL, zs_msg->val, zs_msg->len, greedy);
if (!msg && !EG(exception)) {
- php_http_throw(bad_message, "Could not parse message: %.*s", MIN(25, Z_STRLEN_P(zmessage)), Z_STRVAL_P(zmessage));
+ php_http_throw(bad_message, "Could not parse message: %.*s", MIN(25, zs_msg->len), zs_msg->val);
}
- zval_ptr_dtor(&zmessage);
+ zend_string_release(zs_msg);
}
if (msg) {
php_http_message_dtor(obj->message);
obj->message = msg;
if (obj->message->parent) {
- php_http_message_object_new_ex(Z_OBJCE_P(getThis()), obj->message->parent, &obj->parent TSRMLS_CC);
+ obj->parent = php_http_message_object_new_ex(obj->zo.ce, obj->message->parent);
}
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
}
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (!obj->body) {
}
if (obj->body) {
- RETVAL_OBJVAL(obj->body->zv, 1);
+ RETVAL_OBJECT(&obj->body->zo, 1);
}
}
{
zval *zbody;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zbody, php_http_message_body_class_entry)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &zbody, php_http_message_body_class_entry)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_http_message_object_prophandler_set_body(obj, zbody TSRMLS_CC);
+ php_http_message_object_prophandler_set_body(obj, zbody);
}
RETVAL_ZVAL(getThis(), 1, 0);
}
{
zval *new_body;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &new_body, php_http_message_body_class_entry)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
- php_http_message_body_object_t *new_obj = zend_object_store_get_object(new_body TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &new_body, php_http_message_body_class_entry)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
+ php_http_message_body_object_t *new_obj = PHP_HTTP_OBJ(NULL, new_body);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
php_http_message_body_to_callback(new_obj->body, (php_http_pass_callback_t) php_http_message_body_append, obj->message->body, 0, 0);
static PHP_METHOD(HttpMessage, getHeader)
{
char *header_str;
- int header_len;
+ size_t header_len;
zend_class_entry *header_ce = NULL;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|C!", &header_str, &header_len, &header_ce)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|C!", &header_str, &header_len, &header_ce)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
zval *header;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if ((header = php_http_message_header(obj->message, header_str, header_len, 0))) {
+ if ((header = php_http_message_header(obj->message, header_str, header_len))) {
if (!header_ce) {
- RETURN_ZVAL(header, 1, 1);
- } else if (instanceof_function(header_ce, php_http_header_class_entry TSRMLS_CC)) {
+ RETURN_ZVAL(header, 1, 0);
+ } else if (instanceof_function(header_ce, php_http_header_class_entry)) {
php_http_object_method_t cb;
- zval *header_name, **argv[2];
-
- MAKE_STD_ZVAL(header_name);
- ZVAL_STRINGL(header_name, header_str, header_len, 1);
+ zval argv[2];
- argv[0] = &header_name;
- argv[1] = &header;
+ ZVAL_STRINGL(&argv[0], header_str, header_len);
+ ZVAL_COPY(&argv[1], header);
object_init_ex(return_value, header_ce);
- php_http_object_method_init(&cb, return_value, ZEND_STRL("__construct") TSRMLS_CC);
- php_http_object_method_call(&cb, return_value, NULL, 2, argv TSRMLS_CC);
+ php_http_object_method_init(&cb, return_value, ZEND_STRL("__construct"));
+ php_http_object_method_call(&cb, return_value, NULL, 2, argv);
php_http_object_method_dtor(&cb);
- zval_ptr_dtor(&header_name);
- zval_ptr_dtor(&header);
+ zval_ptr_dtor(&argv[0]);
+ zval_ptr_dtor(&argv[1]);
return;
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class '%s' is not as descendant of http\\Header", header_ce->name);
+ php_error_docref(NULL, E_WARNING, "Class '%s' is not as descendant of http\\Header", header_ce->name->val);
}
}
}
static PHP_METHOD(HttpMessage, getHeaders)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
{
zval *zvalue = NULL;
char *name_str;
- int name_len;
+ size_t name_len;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z!", &name_str, &name_len, &zvalue)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|z!", &name_str, &name_len, &zvalue)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *name = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (!zvalue) {
- zend_symtable_del(&obj->message->hdrs, name, name_len + 1);
+ zend_symtable_str_del(&obj->message->hdrs, name, name_len);
} else {
- Z_ADDREF_P(zvalue);
- zend_symtable_update(&obj->message->hdrs, name, name_len + 1, &zvalue, sizeof(void *), NULL);
+ Z_TRY_ADDREF_P(zvalue);
+ zend_symtable_str_update(&obj->message->hdrs, name, name_len, zvalue);
}
efree(name);
}
{
zval *new_headers = NULL;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!", &new_headers)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "a/!", &new_headers)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
{
zval *zvalue;
char *name_str;
- int name_len;
+ size_t name_len;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &name_str, &name_len, &zvalue)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "sz", &name_str, &name_len, &zvalue)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *name = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
zval *header;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- Z_ADDREF_P(zvalue);
- if ((header = php_http_message_header(obj->message, name, name_len, 0))) {
+ Z_TRY_ADDREF_P(zvalue);
+ if ((header = php_http_message_header(obj->message, name, name_len))) {
convert_to_array(header);
- zend_hash_next_index_insert(Z_ARRVAL_P(header), &zvalue, sizeof(void *), NULL);
- zval_ptr_dtor(&header);
+ zend_hash_next_index_insert(Z_ARRVAL_P(header), zvalue);
} else {
- zend_symtable_update(&obj->message->hdrs, name, name_len + 1, &zvalue, sizeof(void *), NULL);
+ zend_symtable_str_update(&obj->message->hdrs, name, name_len, zvalue);
}
efree(name);
}
zval *new_headers;
zend_bool append = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|b", &new_headers, &append)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "a|b", &new_headers, &append)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
static PHP_METHOD(HttpMessage, getType)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, setType)
{
- long type;
+ zend_long type;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &type)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "l", &type)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
static PHP_METHOD(HttpMessage, getInfo)
{
if (SUCCESS == zend_parse_parameters_none()) {
- char *tmp = NULL;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ char *str, *tmp = NULL;
+ size_t len;
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
switch (obj->message->type) {
case PHP_HTTP_REQUEST:
- Z_STRLEN_P(return_value) = spprintf(&Z_STRVAL_P(return_value), 0, PHP_HTTP_INFO_REQUEST_FMT_ARGS(&obj->message->http, tmp, ""));
+ len = spprintf(&str, 0, PHP_HTTP_INFO_REQUEST_FMT_ARGS(&obj->message->http, tmp, ""));
PTR_FREE(tmp);
break;
case PHP_HTTP_RESPONSE:
- Z_STRLEN_P(return_value) = spprintf(&Z_STRVAL_P(return_value), 0, PHP_HTTP_INFO_RESPONSE_FMT_ARGS(&obj->message->http, tmp, ""));
+ len = spprintf(&str, 0, PHP_HTTP_INFO_RESPONSE_FMT_ARGS(&obj->message->http, tmp, ""));
PTR_FREE(tmp);
break;
default:
RETURN_NULL();
break;
}
- Z_TYPE_P(return_value) = IS_STRING;
- return;
+
+ RETVAL_STR(php_http_cs2zs(str, len));
}
}
static PHP_METHOD(HttpMessage, setInfo)
{
char *str;
- int len;
+ size_t len;
php_http_message_object_t *obj;
php_http_info_t inf;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if (!php_http_info_parse(&inf, str TSRMLS_CC)) {
+ if (!php_http_info_parse(&inf, str)) {
php_http_throw(bad_header, "Could not parse message info '%s'", str);
return;
}
if (SUCCESS == zend_parse_parameters_none()) {
char *str;
size_t len;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_http_version_to_string(&obj->message->http.version, &str, &len, NULL, NULL TSRMLS_CC);
- RETURN_STRINGL(str, len, 0);
+ php_http_version_to_string(&obj->message->http.version, &str, &len, NULL, NULL);
+ RETURN_STR(php_http_cs2zs(str, len));
}
}
static PHP_METHOD(HttpMessage, setHttpVersion)
{
char *v_str;
- int v_len;
+ size_t v_len;
php_http_version_t version;
php_http_message_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &v_str, &v_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &v_str, &v_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_http_expect(php_http_version_parse(&version, v_str TSRMLS_CC), unexpected_val, return);
+ php_http_expect(php_http_version_parse(&version, v_str), unexpected_val, return);
obj->message->http.version = version;
static PHP_METHOD(HttpMessage, getResponseCode)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_RESPONSE) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "http\\Message is not if type response");
+ php_error_docref(NULL, E_WARNING, "http\\Message is not if type response");
RETURN_FALSE;
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, setResponseCode)
{
- long code;
+ zend_long code;
zend_bool strict = 1;
php_http_message_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b", &code, &strict), invalid_arg, return);
-
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "l|b", &code, &strict), invalid_arg, return);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_RESPONSE) {
static PHP_METHOD(HttpMessage, getResponseStatus)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_RESPONSE) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "http\\Message is not of type response");
+ php_error_docref(NULL, E_WARNING, "http\\Message is not of type response");
}
if (obj->message->http.info.response.status) {
- RETURN_STRING(obj->message->http.info.response.status, 1);
+ RETURN_STRING(obj->message->http.info.response.status);
} else {
RETURN_EMPTY_STRING();
}
static PHP_METHOD(HttpMessage, setResponseStatus)
{
char *status;
- int status_len;
+ size_t status_len;
php_http_message_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &status, &status_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &status, &status_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
static PHP_METHOD(HttpMessage, getRequestMethod)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_REQUEST) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "http\\Message is not of type request");
+ php_error_docref(NULL, E_WARNING, "http\\Message is not of type request");
RETURN_FALSE;
}
if (obj->message->http.info.request.method) {
- RETURN_STRING(obj->message->http.info.request.method, 1);
+ RETURN_STRING(obj->message->http.info.request.method);
} else {
RETURN_EMPTY_STRING();
}
static PHP_METHOD(HttpMessage, setRequestMethod)
{
char *method;
- int method_len;
+ size_t method_len;
php_http_message_object_t *obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &method, &method_len), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &method, &method_len), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
static PHP_METHOD(HttpMessage, getRequestUrl)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (obj->message->type != PHP_HTTP_REQUEST) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "http\\Message is not of type request");
+ php_error_docref(NULL, E_WARNING, "http\\Message is not of type request");
RETURN_FALSE;
}
size_t url_len;
php_http_url_to_string(obj->message->http.info.request.url, &url_str, &url_len, 0);
- RETURN_STRINGL(url_str, url_len, 0);
+ RETURN_STR(php_http_cs2zs(url_str, url_len));
} else {
RETURN_EMPTY_STRING();
}
php_http_message_object_t *obj;
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zurl), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zurl), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
return;
}
- zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh TSRMLS_CC);
- url = php_http_url_from_zval(zurl, ~0 TSRMLS_CC);
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh);
+ url = php_http_url_from_zval(zurl, ~0);
+ zend_restore_error_handling(&zeh);
- if (php_http_url_is_empty(url)) {
+ if (url && php_http_url_is_empty(url)) {
php_http_url_free(&url);
php_http_throw(invalid_arg, "Cannot set http\\Message's request url to an empty string", NULL);
- } else {
+ } else if (url) {
PTR_SET(obj->message->http.info.request.url, url);
}
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (!obj->message->parent) {
return;
}
- RETVAL_OBJVAL(obj->parent->zv, 1);
+ RETVAL_OBJECT(&obj->parent->zo, 1);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage___toString, 0, 0, 0)
{
zend_bool include_parent = 0;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &include_parent)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &include_parent)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *string;
size_t length;
php_http_message_to_string(obj->message, &string, &length);
}
if (string) {
- RETURN_STRINGL(string, length, 0);
+ RETURN_STR(php_http_cs2zs(string, length));
}
}
RETURN_EMPTY_STRING();
}
-#ifdef ZTS
-static size_t write_to_stream(void *s, const char *str, size_t len)
-{
- TSRMLS_FETCH();
- return php_stream_write(s, str, len);
-}
-#else
-# define write_to_stream (php_http_pass_callback_t)_php_stream_write
-#endif
-
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_toStream, 0, 0, 1)
ZEND_ARG_INFO(0, stream)
ZEND_END_ARG_INFO();
{
zval *zstream;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstream)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "r", &zstream)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
php_stream *s;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_stream_from_zval(s, &zstream);
- php_http_message_to_callback(obj->message, write_to_stream, s);
+ php_stream_from_zval(s, zstream);
+ php_http_message_to_callback(obj->message, (php_http_pass_callback_t) _php_stream_write, s);
}
}
{
php_http_pass_fcall_arg_t fcd;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fcd.fci, &fcd.fcc)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fcd.fci, &fcd.fcc)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- fcd.fcz = getThis();
- Z_ADDREF_P(fcd.fcz);
- TSRMLS_SET_CTX(fcd.ts);
-
+ ZVAL_COPY(&fcd.fcz, getThis());
php_http_message_to_callback(obj->message, php_http_pass_fcall_callback, &fcd);
zend_fcall_info_args_clear(&fcd.fci, 1);
-
zval_ptr_dtor(&fcd.fcz);
+
RETURN_ZVAL(getThis(), 1, 0);
}
}
static PHP_METHOD(HttpMessage, serialize)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *string;
size_t length;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
php_http_message_serialize(obj->message, &string, &length);
- RETURN_STRINGL(string, length, 0);
+ RETURN_STR(php_http_cs2zs(string, length));
}
RETURN_EMPTY_STRING();
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, unserialize)
{
- int length;
+ size_t length;
char *serialized;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &serialized, &length)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &serialized, &length)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
php_http_message_t *msg;
if (obj->message) {
+ /* do not free recursively */
php_http_message_dtor(obj->message);
efree(obj->message);
}
- if ((msg = php_http_message_parse(NULL, serialized, (size_t) length, 1 TSRMLS_CC))) {
+ if ((msg = php_http_message_parse(NULL, serialized, length, 1))) {
obj->message = msg;
} else {
- obj->message = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not unserialize http\\Message");
+ obj->message = php_http_message_init(NULL, 0, NULL);
+ php_error_docref(NULL, E_ERROR, "Could not unserialize http\\Message");
}
}
}
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, detach)
{
- php_http_message_object_t *obj;
+ php_http_message_object_t *obj, *new_obj;
+ php_http_message_t *msg_cpy;
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- RETVAL_OBJVAL(php_http_message_object_new_ex(obj->zo.ce, php_http_message_copy_ex(obj->message, NULL, 0), NULL TSRMLS_CC), 0);
+ msg_cpy = php_http_message_copy_ex(obj->message, NULL, 0);
+ new_obj = php_http_message_object_new_ex(obj->zo.ce, msg_cpy);
+
+ RETVAL_OBJ(&new_obj->zo);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_prepend, 0, 0, 1)
php_http_message_t *msg[2];
php_http_message_object_t *obj, *prepend_obj;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &prepend, php_http_message_class_entry, &top), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O|b", &prepend, php_http_message_class_entry, &top), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- prepend_obj = zend_object_store_get_object(prepend TSRMLS_CC);
+ prepend_obj = PHP_HTTP_OBJ(NULL, prepend);
PHP_HTTP_MESSAGE_OBJECT_INIT(prepend_obj);
/* safety check */
}
}
- php_http_message_object_prepend(getThis(), prepend, top TSRMLS_CC);
+ php_http_message_object_prepend(getThis(), prepend, top);
RETURN_ZVAL(getThis(), 1, 0);
}
{
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- php_http_message_object_reverse(getThis(), return_value TSRMLS_CC);
+ php_http_message_object_reverse(getThis(), return_value);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_isMultipart, 0, 0, 0)
{
zval *zboundary = NULL;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &zboundary)) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|z!", &zboundary)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
char *boundary = NULL;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- RETVAL_BOOL(php_http_message_is_multipart(obj->message, zboundary ? &boundary : NULL));
+ if (php_http_message_is_multipart(obj->message, zboundary ? &boundary : NULL)) {
+ RETVAL_TRUE;
+ } else {
+ RETVAL_FALSE;
+ }
if (zboundary && boundary) {
+ ZVAL_DEREF(zboundary);
zval_dtor(zboundary);
- ZVAL_STRING(zboundary, boundary, 0);
+ ZVAL_STR(zboundary, php_http_cs2zs(boundary, strlen(boundary)));
}
}
}
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
- obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-
+ obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
if (!php_http_message_is_multipart(obj->message, &boundary)) {
PTR_FREE(boundary);
- RETURN_OBJVAL(php_http_message_object_new_ex(php_http_message_class_entry, msg, NULL TSRMLS_CC), 0);
+ RETURN_OBJ(&php_http_message_object_new_ex(obj->zo.ce, msg)->zo);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_count, 0, 0, 0)
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, count)
{
- long count_mode = -1;
+ zend_long count_mode = -1;
- if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &count_mode)) {
- long i = 0;
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &count_mode)) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- php_http_message_count(i, obj->message);
- RETURN_LONG(i);
+ RETURN_LONG(php_http_message_count(obj->message));
}
}
{
if (SUCCESS == zend_parse_parameters_none()) {
zval *zobj = getThis();
- php_http_message_object_t *obj = zend_object_store_get_object(zobj TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- if (obj->iterator) {
+ if (!Z_ISUNDEF(obj->iterator)) {
zval_ptr_dtor(&obj->iterator);
}
- Z_ADDREF_P(zobj);
- obj->iterator = zobj;
+ ZVAL_COPY(&obj->iterator, zobj);
}
}
static PHP_METHOD(HttpMessage, valid)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- RETURN_BOOL(obj->iterator != NULL);
+ RETURN_BOOL(!Z_ISUNDEF(obj->iterator));
}
}
static PHP_METHOD(HttpMessage, next)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- if (obj->iterator) {
- php_http_message_object_t *itr = zend_object_store_get_object(obj->iterator TSRMLS_CC);
+ if (!Z_ISUNDEF(obj->iterator)) {
+ php_http_message_object_t *itr = PHP_HTTP_OBJ(NULL, &obj->iterator);
- if (itr && itr->parent) {
- zval *old = obj->iterator;
- MAKE_STD_ZVAL(obj->iterator);
- ZVAL_OBJVAL(obj->iterator, itr->parent->zv, 1);
- zval_ptr_dtor(&old);
+ if (itr->parent) {
+ zval tmp;
+
+ ZVAL_OBJECT(&tmp, &itr->parent->zo, 1);
+ zval_ptr_dtor(&obj->iterator);
+ obj->iterator = tmp;
} else {
zval_ptr_dtor(&obj->iterator);
- obj->iterator = NULL;
+ ZVAL_UNDEF(&obj->iterator);
}
}
}
static PHP_METHOD(HttpMessage, key)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- RETURN_LONG(obj->iterator ? obj->iterator->value.obj.handle:0);
+ RETURN_LONG(Z_ISUNDEF(obj->iterator) ? 0 : Z_OBJ_HANDLE(obj->iterator));
}
}
static PHP_METHOD(HttpMessage, current)
{
if (SUCCESS == zend_parse_parameters_none()) {
- php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
- if (obj->iterator) {
- RETURN_ZVAL(obj->iterator, 1, 0);
+ if (!Z_ISUNDEF(obj->iterator)) {
+ RETURN_ZVAL(&obj->iterator, 1, 0);
}
}
}
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http", "Message", php_http_message_methods);
- php_http_message_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+ php_http_message_class_entry = zend_register_internal_class(&ce);
php_http_message_class_entry->create_object = php_http_message_object_new;
memcpy(&php_http_message_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+ php_http_message_object_handlers.offset = XtOffsetOf(php_http_message_object_t, zo);
php_http_message_object_handlers.clone_obj = php_http_message_object_clone;
+ php_http_message_object_handlers.free_obj = php_http_message_object_free;
php_http_message_object_handlers.read_property = php_http_message_object_read_prop;
php_http_message_object_handlers.write_property = php_http_message_object_write_prop;
- php_http_message_object_handlers.get_properties = php_http_message_object_get_props;
+ php_http_message_object_handlers.get_debug_info = php_http_message_object_get_debug_info;
php_http_message_object_handlers.get_property_ptr_ptr = NULL;
- zend_class_implements(php_http_message_class_entry TSRMLS_CC, 3, spl_ce_Countable, zend_ce_serializable, zend_ce_iterator);
+ zend_class_implements(php_http_message_class_entry, 3, spl_ce_Countable, zend_ce_serializable, zend_ce_iterator);
- zend_hash_init(&php_http_message_object_prophandlers, 9, NULL, NULL, 1);
- zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("type"), PHP_HTTP_NONE, ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_hash_init(&php_http_message_object_prophandlers, 9, NULL, php_http_message_object_prophandler_hash_dtor, 1);
+ zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("type"), PHP_HTTP_NONE, ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("type"), php_http_message_object_prophandler_get_type, php_http_message_object_prophandler_set_type);
- zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("body"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("body"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("body"), php_http_message_object_prophandler_get_body, php_http_message_object_prophandler_set_body);
- zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestMethod"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestMethod"), "", ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("requestMethod"), php_http_message_object_prophandler_get_request_method, php_http_message_object_prophandler_set_request_method);
- zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestUrl"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestUrl"), "", ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("requestUrl"), php_http_message_object_prophandler_get_request_url, php_http_message_object_prophandler_set_request_url);
- zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("responseStatus"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("responseStatus"), "", ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("responseStatus"), php_http_message_object_prophandler_get_response_status, php_http_message_object_prophandler_set_response_status);
- zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("responseCode"), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("responseCode"), 0, ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("responseCode"), php_http_message_object_prophandler_get_response_code, php_http_message_object_prophandler_set_response_code);
- zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("httpVersion"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("httpVersion"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("httpVersion"), php_http_message_object_prophandler_get_http_version, php_http_message_object_prophandler_set_http_version);
- zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("headers"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("headers"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("headers"), php_http_message_object_prophandler_get_headers, php_http_message_object_prophandler_set_headers);
- zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("parentMessage"), ZEND_ACC_PROTECTED TSRMLS_CC);
+ zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("parentMessage"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("parentMessage"), php_http_message_object_prophandler_get_parent_message, php_http_message_object_prophandler_set_parent_message);
- zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_NONE"), PHP_HTTP_NONE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_REQUEST"), PHP_HTTP_REQUEST TSRMLS_CC);
- zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_RESPONSE"), PHP_HTTP_RESPONSE TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_NONE"), PHP_HTTP_NONE);
+ zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_REQUEST"), PHP_HTTP_REQUEST);
+ zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_RESPONSE"), PHP_HTTP_RESPONSE);
return SUCCESS;
}
#define url(buf) ((php_http_url_t *) (buf).data)
-static php_http_url_t *php_http_url_from_env(TSRMLS_D)
+static php_http_url_t *php_http_url_from_env(void)
{
zval *https, *zhost, *zport;
long port;
/* scheme */
url(buf)->scheme = &buf.data[buf.used];
- https = php_http_env_get_server_var(ZEND_STRL("HTTPS"), 1 TSRMLS_CC);
+ https = php_http_env_get_server_var(ZEND_STRL("HTTPS"), 1);
if (https && !strcasecmp(Z_STRVAL_P(https), "ON")) {
php_http_buffer_append(&buf, "https", sizeof("https"));
} else {
/* host */
url(buf)->host = &buf.data[buf.used];
- if ((((zhost = php_http_env_get_server_var(ZEND_STRL("HTTP_HOST"), 1 TSRMLS_CC)) ||
- (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_NAME"), 1 TSRMLS_CC)) ||
- (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_ADDR"), 1 TSRMLS_CC)))) && Z_STRLEN_P(zhost)) {
+ if ((((zhost = php_http_env_get_server_var(ZEND_STRL("HTTP_HOST"), 1)) ||
+ (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_NAME"), 1)) ||
+ (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_ADDR"), 1)))) && Z_STRLEN_P(zhost)) {
size_t stop_at = strspn(Z_STRVAL_P(zhost), "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-.");
php_http_buffer_append(&buf, Z_STRVAL_P(zhost), stop_at);
}
/* port */
- zport = php_http_env_get_server_var(ZEND_STRL("SERVER_PORT"), 1 TSRMLS_CC);
+ zport = php_http_env_get_server_var(ZEND_STRL("SERVER_PORT"), 1);
if (zport && IS_LONG == is_numeric_string(Z_STRVAL_P(zport), Z_STRLEN_P(zport), &port, NULL, 0)) {
url(buf)->port = port;
}
} \
} while (0)
-php_http_url_t *php_http_url_mod(const php_http_url_t *old_url, const php_http_url_t *new_url, unsigned flags TSRMLS_DC)
+php_http_url_t *php_http_url_mod(const php_http_url_t *old_url, const php_http_url_t *new_url, unsigned flags)
{
php_http_url_t *tmp_url = NULL;
php_http_buffer_t buf;
/* set from env if requested */
if (flags & PHP_HTTP_URL_FROM_ENV) {
- php_http_url_t *env_url = php_http_url_from_env(TSRMLS_C);
+ php_http_url_t *env_url = php_http_url_from_env();
- old_url = tmp_url = php_http_url_mod(env_url, old_url, flags ^ PHP_HTTP_URL_FROM_ENV TSRMLS_CC);
+ old_url = tmp_url = php_http_url_mod(env_url, old_url, flags ^ PHP_HTTP_URL_FROM_ENV);
php_http_url_free(&env_url);
}
if ((flags & PHP_HTTP_URL_JOIN_QUERY) && url_isset(new_url, query) && url_isset(old_url, query)) {
zval qarr, qstr;
- INIT_PZVAL(&qstr);
- INIT_PZVAL(&qarr);
array_init(&qarr);
- ZVAL_STRING(&qstr, old_url->query, 0);
- php_http_querystring_update(&qarr, &qstr, NULL TSRMLS_CC);
- ZVAL_STRING(&qstr, new_url->query, 0);
- php_http_querystring_update(&qarr, &qstr, NULL TSRMLS_CC);
+ ZVAL_STRING(&qstr, old_url->query);
+ php_http_querystring_update(&qarr, &qstr, NULL);
+ zval_ptr_dtor(&qstr);
+ ZVAL_STRING(&qstr, new_url->query);
+ php_http_querystring_update(&qarr, &qstr, NULL);
+ zval_ptr_dtor(&qstr);
ZVAL_NULL(&qstr);
- php_http_querystring_update(&qarr, NULL, &qstr TSRMLS_CC);
+ php_http_querystring_update(&qarr, NULL, &qstr);
url(buf)->query = &buf.data[buf.used];
url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL(qstr), Z_STRLEN(qstr) + 1));
return buf.data;
}
-php_http_url_t *php_http_url_from_zval(zval *value, unsigned flags TSRMLS_DC)
+php_http_url_t *php_http_url_from_zval(zval *value, unsigned flags)
{
- zval *zcpy;
+ zend_string *zs;
php_http_url_t *purl;
switch (Z_TYPE_P(value)) {
break;
default:
- zcpy = php_http_ztyp(IS_STRING, value);
- purl = php_http_url_parse(Z_STRVAL_P(zcpy), Z_STRLEN_P(zcpy), flags TSRMLS_CC);
- zval_ptr_dtor(&zcpy);
+ zs = zval_get_string(value);
+ purl = php_http_url_parse(zs->val, zs->len, flags);
+ zend_string_release(zs);
}
return purl;
php_http_url_t *php_http_url_from_struct(HashTable *ht)
{
- zval **e;
+ zval *e;
php_http_buffer_t buf;
php_http_buffer_init_ex(&buf, MAX(PHP_HTTP_BUFFER_DEFAULT_SIZE, sizeof(php_http_url_t)<<2), PHP_HTTP_BUFFER_INIT_PREALLOC);
php_http_buffer_account(&buf, sizeof(php_http_url_t));
memset(buf.data, 0, buf.used);
- if (SUCCESS == zend_hash_find(ht, "scheme", sizeof("scheme"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("scheme")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->scheme = &buf.data[buf.used];
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
+ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "user", sizeof("user"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("user")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->user = &buf.data[buf.used];
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
+ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "pass", sizeof("pass"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("pass")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->pass = &buf.data[buf.used];
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
+ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "host", sizeof("host"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("host")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->host = &buf.data[buf.used];
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
+ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "port", sizeof("port"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_LONG, *e);
- url(buf)->port = (unsigned short) Z_LVAL_P(cpy);
- zval_ptr_dtor(&cpy);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("port")))) {
+ url(buf)->port = (unsigned short) zval_get_long(e);
}
- if (SUCCESS == zend_hash_find(ht, "path", sizeof("path"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("path")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->path = &buf.data[buf.used];
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
+ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "query", sizeof("query"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("query")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->query = &buf.data[buf.used];
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
+ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
- if (SUCCESS == zend_hash_find(ht, "fragment", sizeof("fragment"), (void *) &e)) {
- zval *cpy = php_http_ztyp(IS_STRING, *e);
+ if ((e = zend_hash_str_find_ind(ht, ZEND_STRL("fragment")))) {
+ zend_string *zs = zval_get_string(e);
url(buf)->fragment = &buf.data[buf.used];
- url_append(&buf, php_http_buffer_append(&buf, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy) + 1));
- zval_ptr_dtor(&cpy);
+ url_append(&buf, php_http_buffer_append(&buf, zs->val, zs->len + 1));
+ zend_string_release(zs);
}
return url(buf);
}
-HashTable *php_http_url_to_struct(const php_http_url_t *url, zval *strct TSRMLS_DC)
+HashTable *php_http_url_to_struct(const php_http_url_t *url, zval *strct)
{
- zval arr;
+ HashTable *ht;
+ zval tmp;
if (strct) {
switch (Z_TYPE_P(strct)) {
/* no break */
case IS_ARRAY:
case IS_OBJECT:
- INIT_PZVAL_ARRAY((&arr), HASH_OF(strct));
+ ht = HASH_OF(strct);
break;
}
} else {
- INIT_PZVAL(&arr);
- array_init(&arr);
+ ALLOC_HASHTABLE(ht);
+ zend_hash_init(ht, 8, NULL, ZVAL_PTR_DTOR, 0);
+ }
+
+#define url_struct_add(part) \
+ if (Z_TYPE_P(strct) == IS_ARRAY) { \
+ zend_hash_str_update(Z_ARRVAL_P(strct), part, lenof(part), &tmp); \
+ } else { \
+ zend_update_property(Z_OBJCE_P(strct), strct, part, lenof(part), &tmp); \
+ zval_ptr_dtor(&tmp); \
}
if (url) {
if (url->scheme) {
- add_assoc_string(&arr, "scheme", url->scheme, 1);
+ ZVAL_STRING(&tmp, url->scheme);
+ url_struct_add("scheme");
}
if (url->user) {
- add_assoc_string(&arr, "user", url->user, 1);
+ ZVAL_STRING(&tmp, url->user);
+ url_struct_add("user");
}
if (url->pass) {
- add_assoc_string(&arr, "pass", url->pass, 1);
+ ZVAL_STRING(&tmp, url->pass);
+ url_struct_add("pass");
}
if (url->host) {
- add_assoc_string(&arr, "host", url->host, 1);
+ ZVAL_STRING(&tmp, url->host);
+ url_struct_add("host");
}
if (url->port) {
- add_assoc_long(&arr, "port", (long) url->port);
+ ZVAL_LONG(&tmp, url->port);
+ url_struct_add("port");
}
if (url->path) {
- add_assoc_string(&arr, "path", url->path, 1);
+ ZVAL_STRING(&tmp, url->path);
+ url_struct_add("path");
}
if (url->query) {
- add_assoc_string(&arr, "query", url->query, 1);
+ ZVAL_STRING(&tmp, url->query);
+ url_struct_add("query");
}
if (url->fragment) {
- add_assoc_string(&arr, "fragment", url->fragment, 1);
+ ZVAL_STRING(&tmp, url->fragment);
+ url_struct_add("fragment");
}
}
- return Z_ARRVAL(arr);
+ return ht;
}
-ZEND_RESULT_CODE php_http_url_encode_hash(HashTable *hash, const char *pre_encoded_str, size_t pre_encoded_len, char **encoded_str, size_t *encoded_len TSRMLS_DC)
+ZEND_RESULT_CODE php_http_url_encode_hash(HashTable *hash, const char *pre_encoded_str, size_t pre_encoded_len, char **encoded_str, size_t *encoded_len)
{
const char *arg_sep_str = "&";
size_t arg_sep_len = 1;
php_http_buffer_t *qstr = php_http_buffer_new();
- php_http_url_argsep(&arg_sep_str, &arg_sep_len TSRMLS_CC);
+ php_http_url_argsep(&arg_sep_str, &arg_sep_len);
- if (SUCCESS != php_http_url_encode_hash_ex(hash, qstr, arg_sep_str, arg_sep_len, "=", 1, pre_encoded_str, pre_encoded_len TSRMLS_CC)) {
+ if (SUCCESS != php_http_url_encode_hash_ex(hash, qstr, arg_sep_str, arg_sep_len, "=", 1, pre_encoded_str, pre_encoded_len)) {
php_http_buffer_free(&qstr);
return FAILURE;
}
return SUCCESS;
}
-ZEND_RESULT_CODE php_http_url_encode_hash_ex(HashTable *hash, php_http_buffer_t *qstr, const char *arg_sep_str, size_t arg_sep_len, const char *val_sep_str, size_t val_sep_len, const char *pre_encoded_str, size_t pre_encoded_len TSRMLS_DC)
+ZEND_RESULT_CODE php_http_url_encode_hash_ex(HashTable *hash, php_http_buffer_t *qstr, const char *arg_sep_str, size_t arg_sep_len, const char *val_sep_str, size_t val_sep_len, const char *pre_encoded_str, size_t pre_encoded_len)
{
if (pre_encoded_len && pre_encoded_str) {
php_http_buffer_append(qstr, pre_encoded_str, pre_encoded_len);
}
- if (!php_http_params_to_string(qstr, hash, arg_sep_str, arg_sep_len, "", 0, val_sep_str, val_sep_len, PHP_HTTP_PARAMS_QUERY TSRMLS_CC)) {
+ if (!php_http_params_to_string(qstr, hash, arg_sep_str, arg_sep_len, "", 0, val_sep_str, val_sep_len, PHP_HTTP_PARAMS_QUERY)) {
return FAILURE;
}
struct parse_state {
php_http_url_t url;
-#ifdef ZTS
- void ***ts;
-#endif
const char *ptr;
const char *end;
size_t maxlen;
}
if (!silent) {
- TSRMLS_FETCH_FROM_CTX(state->ts);
if (consumed) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse %s; unexpected multibyte sequence 0x%x at pos %u in '%s'",
parse_what[what], wchar, (unsigned) (ptr - begin), begin);
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse %s; unexpected byte 0x%02x at pos %u in '%s'",
parse_what[what], (unsigned char) *ptr, (unsigned) (ptr - begin), begin);
}
{
size_t mb;
const char *password = NULL, *end = state->ptr, *tmp = ptr;
- TSRMLS_FETCH_FROM_CTX(state->ts);
state->url.user = &state->buffer[state->offset];
switch (*ptr) {
case ':':
if (password) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse password; duplicate ':' at pos %u in '%s'",
(unsigned) (ptr - tmp), tmp);
return FAILURE;
case '%':
if (ptr[1] != '%' && (end - ptr <= 2 || !isxdigit(*(ptr+1)) || !isxdigit(*(ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse userinfo; invalid percent encoding at pos %u in '%s'",
(unsigned) (ptr - tmp), tmp);
return FAILURE;
#if defined(PHP_WIN32) || defined(HAVE_UIDNA_IDNTOASCII)
typedef size_t (*parse_mb_func)(unsigned *wc, const char *ptr, const char *end);
-static ZEND_RESULT_CODE to_utf16(parse_mb_func fn, const char *u8, uint16_t **u16, size_t *len TSRMLS_DC)
+static ZEND_RESULT_CODE to_utf16(parse_mb_func fn, const char *u8, uint16_t **u16, size_t *len)
{
size_t offset = 0, u8_len = strlen(u8);
if (!consumed) {
efree(*u16);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse UTF-8 at pos %zu of '%s'", offset, u8);
+ php_error_docref(NULL, E_WARNING, "Failed to parse UTF-8 at pos %zu of '%s'", offset, u8);
return FAILURE;
} else {
offset += consumed;
case 0:
default:
efree(*u16);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to convert UTF-32 'U+%X' to UTF-16", wc);
+ php_error_docref(NULL, E_WARNING, "Failed to convert UTF-32 'U+%X' to UTF-16", wc);
return FAILURE;
}
}
{
char *idn = NULL;
int rv = -1;
- TSRMLS_FETCH_FROM_CTX(state->ts);
if (state->flags & PHP_HTTP_URL_PARSE_MBUTF8) {
rv = idn2_lookup_u8((const unsigned char *) state->url.host, (unsigned char **) &idn, IDN2_NFC_INPUT);
}
# endif
if (rv != IDN2_OK) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN; %s", idn2_strerror(rv));
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN; %s", idn2_strerror(rv));
return FAILURE;
} else {
size_t idnlen = strlen(idn);
{
char *idn = NULL;
int rv = -1;
- TSRMLS_FETCH_FROM_CTX(state->ts);
if (state->flags & PHP_HTTP_URL_PARSE_MBUTF8) {
rv = idna_to_ascii_8z(state->url.host, &idn, IDNA_ALLOW_UNASSIGNED|IDNA_USE_STD3_ASCII_RULES);
}
# endif
if (rv != IDNA_SUCCESS) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN; %s", idna_strerror(rv));
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN; %s", idna_strerror(rv));
return FAILURE;
} else {
size_t idnlen = strlen(idn);
uint16_t *uhost_str, ahost_str[MAXHOSTNAMELEN], *ahost_ptr;
size_t uhost_len, ahost_len;
UErrorCode error = U_ZERO_ERROR;
- TSRMLS_FETCH_FROM_CTX(state->ts);
if (state->flags & PHP_HTTP_URL_PARSE_MBUTF8) {
- if (SUCCESS != to_utf16(parse_mb_utf8, state->url.host, &uhost_str, &uhost_len TSRMLS_CC)) {
+ if (SUCCESS != to_utf16(parse_mb_utf8, state->url.host, &uhost_str, &uhost_len)) {
return FAILURE;
}
#ifdef PHP_HTTP_HAVE_WCHAR
} else if (state->flags & PHP_HTTP_URL_PARSE_MBLOC) {
- if (SUCCESS != to_utf16(parse_mb_loc, state->url.host, &uhost_str, &uhost_len TSRMLS_CC)) {
+ if (SUCCESS != to_utf16(parse_mb_loc, state->url.host, &uhost_str, &uhost_len)) {
return FAILURE;
}
#endif
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN; codepage not specified");
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN; codepage not specified");
return FAILURE;
}
efree(uhost_str);
if (error != U_ZERO_ERROR) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN; ICU error %d", error);
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN; ICU error %d", error);
return FAILURE;
}
char *host_ptr;
uint16_t *uhost_str, ahost_str[MAXHOSTNAMELEN], *ahost_ptr;
size_t uhost_len;
- TSRMLS_FETCH_FROM_CTX(state->ts);
if (state->flags & PHP_HTTP_URL_PARSE_MBUTF8) {
if (SUCCESS != to_utf16(parse_mb_utf8, state->url.host, &uhost_str, &uhost_len)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN");
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN");
return FAILURE;
}
#ifdef PHP_HTTP_HAVE_WCHAR
} else if (state->flags & PHP_HTTP_URL_PARSE_MBLOC) {
if (SUCCESS != to_utf16(parse_mb_loc, state->url.host, &uhost_str, &uhost_len)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN");
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN");
return FAILURE;
}
#endif
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN");
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN");
return FAILURE;
}
if (!IdnToAscii(IDN_ALLOW_UNASSIGNED|IDN_USE_STD3_ASCII_RULES, uhost_str, uhost_len, ahost_str, MAXHOSTNAMELEN)) {
efree(uhost_str);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse IDN");
+ php_error_docref(NULL, E_WARNING, "Failed to parse IDN");
return FAILURE;
}
}
#endif
- static ZEND_RESULT_CODE parse_hostinfo(struct parse_state *state, const char *ptr)
+ #ifdef HAVE_INET_PTON
+ static const char *parse_ip6(struct parse_state *state, const char *ptr)
{
- const char *end = state->ptr, *tmp = ptr, *port = NULL;
-
- #ifdef HAVE_INET_PTON
- if (*ptr == '[') {
- char *error = NULL, *tmp = memchr(ptr, ']', end - ptr);
-
- if (tmp) {
- size_t addrlen = tmp - ptr + 1;
- char buf[16], *addr = estrndup(ptr + 1, addrlen - 2);
- int rv = inet_pton(AF_INET6, addr, buf);
-
- efree(addr);
- if (rv == 1) {
- state->buffer[state->offset] = '[';
- state->url.host = &state->buffer[state->offset];
- inet_ntop(AF_INET6, buf, state->url.host + 1, state->maxlen - state->offset);
- state->offset += strlen(state->url.host);
- state->buffer[state->offset++] = ']';
- state->buffer[state->offset++] = 0;
- ptr = tmp + 1;
- } else if (rv == -1) {
- error = strerror(errno);
- } else {
- error = "unexpected '['";
- }
+ size_t mb, len;
- TSRMLS_FETCH_FROM_CTX(state->ts);
+ const char *error = NULL, *end = state->ptr, *tmp = memchr(ptr, ']', end - ptr);
+
+ if (tmp) {
+ size_t addrlen = tmp - ptr + 1;
+ char buf[16], *addr = estrndup(ptr + 1, addrlen - 2);
+ int rv = inet_pton(AF_INET6, addr, buf);
+
+ if (rv == 1) {
+ state->buffer[state->offset] = '[';
+ state->url.host = &state->buffer[state->offset];
+ inet_ntop(AF_INET6, buf, state->url.host + 1, state->maxlen - state->offset);
+ state->offset += strlen(state->url.host);
+ state->buffer[state->offset++] = ']';
+ state->buffer[state->offset++] = 0;
+ ptr = tmp + 1;
+ } else if (rv == -1) {
+ error = strerror(errno);
} else {
- error = "expected ']'";
+ error = "unexpected '['";
}
+ efree(addr);
+ } else {
+ error = "expected ']'";
+ }
- if (error) {
- php_error_docref(NULL, E_WARNING, "Failed to parse hostinfo; %s", error);
- return FAILURE;
- }
+ if (error) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse hostinfo; %s", error);
++ php_error_docref(NULL, E_WARNING, "Failed to parse hostinfo; %s", error);
+ return NULL;
+ }
+
+ return ptr;
+ }
+ #endif
+
+ static ZEND_RESULT_CODE parse_hostinfo(struct parse_state *state, const char *ptr)
+ {
+ size_t mb, len;
+ const char *end = state->ptr, *tmp = ptr, *port = NULL, *label = NULL;
- TSRMLS_FETCH_FROM_CTX(state->ts);
+
+ #ifdef HAVE_INET_PTON
+ if (*ptr == '[' && !(ptr = parse_ip6(state, ptr))) {
+ return FAILURE;
}
#endif
+
if (ptr != end) do {
switch (*ptr) {
case ':':
if (port) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse port; unexpected ':' at pos %u in '%s'",
(unsigned) (ptr - tmp), tmp);
return FAILURE;
case '%':
if (ptr[1] != '%' && (end - ptr <= 2 || !isxdigit(*(ptr+1)) || !isxdigit(*(ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse hostinfo; invalid percent encoding at pos %u in '%s'",
(unsigned) (ptr - tmp), tmp);
return FAILURE;
case '!': case '$': case '&': case '\'': case '(': case ')': case '*':
case '+': case ',': case ';': case '=': /* sub-delims */
case '-': case '.': case '_': case '~': /* unreserved */
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ if (port || !label) {
+ /* sort of a compromise, just ensure we don't end up
+ * with a dot at the beginning or two consecutive dots
+ */
++ php_error_docref(NULL, E_WARNING,
+ "Failed to parse %s; unexpected '%c' at pos %u in '%s'",
+ port ? "port" : "host",
+ (unsigned char) *ptr, (unsigned) (ptr - tmp), tmp);
+ return FAILURE;
+ }
+ state->buffer[state->offset++] = *ptr;
+ label = NULL;
+ break;
+
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
case 'v': case 'w': case 'x': case 'y': case 'z':
if (port) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse port; unexpected char '%c' at pos %u in '%s'",
(unsigned char) *ptr, (unsigned) (ptr - tmp), tmp);
return FAILURE;
state->url.port *= 10;
state->url.port += *ptr - '0';
} else {
+ label = ptr;
state->buffer[state->offset++] = *ptr;
}
break;
if (ptr == end) {
break;
} else if (port) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse port; unexpected byte 0x%02x at pos %u in '%s'",
(unsigned char) *ptr, (unsigned) (ptr - tmp), tmp);
return FAILURE;
} else if (!(mb = parse_mb(state, PARSE_HOSTINFO, ptr, end, tmp, 0))) {
return FAILURE;
}
+ label = ptr;
ptr += mb - 1;
}
} while (++ptr != end);
case '@':
/* userinfo delimiter */
if (host) {
- TSRMLS_FETCH_FROM_CTX(state->ts);
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse userinfo; unexpected '@'");
return NULL;
}
{
size_t mb;
const char *tmp;
- TSRMLS_FETCH_FROM_CTX(state->ts);
/* is there actually a path to parse? */
if (!*state->ptr) {
case '%':
if (state->ptr[1] != '%' && (state->end - state->ptr <= 2 || !isxdigit(*(state->ptr+1)) || !isxdigit(*(state->ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse path; invalid percent encoding at pos %u in '%s'",
(unsigned) (state->ptr - tmp), tmp);
return NULL;
{
size_t mb;
const char *tmp = state->ptr + !!*state->ptr;
- TSRMLS_FETCH_FROM_CTX(state->ts);
/* is there actually a query to parse? */
if (*state->ptr != '?') {
case '%':
if (state->ptr[1] != '%' && (state->end - state->ptr <= 2 || !isxdigit(*(state->ptr+1)) || !isxdigit(*(state->ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse query; invalid percent encoding at pos %u in '%s'",
(unsigned) (state->ptr - tmp), tmp);
return NULL;
{
size_t mb;
const char *tmp;
- TSRMLS_FETCH_FROM_CTX(state->ts);
/* is there actually a fragment to parse? */
if (*state->ptr != '#') {
switch (*state->ptr) {
case '%':
if (state->ptr[1] != '%' && (state->end - state->ptr <= 2 || !isxdigit(*(state->ptr+1)) || !isxdigit(*(state->ptr+2)))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse fragment; invalid percent encoding at pos %u in '%s'",
(unsigned) (state->ptr - tmp), tmp);
return NULL;
return state->ptr = tmp;
}
-php_http_url_t *php_http_url_parse(const char *str, size_t len, unsigned flags TSRMLS_DC)
+php_http_url_t *php_http_url_parse(const char *str, size_t len, unsigned flags)
{
size_t maxlen = 3 * len;
struct parse_state *state = ecalloc(1, sizeof(*state) + maxlen);
state->ptr = str;
state->flags = flags;
state->maxlen = maxlen;
- TSRMLS_SET_CTX(state->ts);
if (!parse_scheme(state)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse URL scheme: '%s'", state->ptr);
+ php_error_docref(NULL, E_WARNING, "Failed to parse URL scheme: '%s'", state->ptr);
efree(state);
return NULL;
}
}
if (!parse_query(state)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse URL query: '%s'", state->ptr);
+ php_error_docref(NULL, E_WARNING, "Failed to parse URL query: '%s'", state->ptr);
efree(state);
return NULL;
}
if (!parse_fragment(state)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse URL fragment: '%s'", state->ptr);
+ php_error_docref(NULL, E_WARNING, "Failed to parse URL fragment: '%s'", state->ptr);
efree(state);
return NULL;
}
return (php_http_url_t *) state;
}
-php_http_url_t *php_http_url_parse_authority(const char *str, size_t len, unsigned flags TSRMLS_DC)
+php_http_url_t *php_http_url_parse_authority(const char *str, size_t len, unsigned flags)
{
size_t maxlen = 3 * len;
struct parse_state *state = ecalloc(1, sizeof(*state) + maxlen);
state->ptr = str;
state->flags = flags;
state->maxlen = maxlen;
- TSRMLS_SET_CTX(state->ts);
if (!(state->ptr = parse_authority(state))) {
efree(state);
}
if (state->ptr != state->end) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ php_error_docref(NULL, E_WARNING,
"Failed to parse URL authority, unexpected character at pos %u in '%s'",
(unsigned) (state->ptr - str), str);
efree(state);
PHP_METHOD(HttpUrl, __construct)
{
zval *new_url = NULL, *old_url = NULL;
- long flags = PHP_HTTP_URL_FROM_ENV;
+ zend_long flags = PHP_HTTP_URL_FROM_ENV;
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!z!l", &old_url, &new_url, &flags), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|z!z!l", &old_url, &new_url, &flags), invalid_arg, return);
- zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh);
{
php_http_url_t *res_purl, *new_purl = NULL, *old_purl = NULL;
if (new_url) {
- new_purl = php_http_url_from_zval(new_url, flags TSRMLS_CC);
+ new_purl = php_http_url_from_zval(new_url, flags);
if (!new_purl) {
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
return;
}
}
if (old_url) {
- old_purl = php_http_url_from_zval(old_url, flags TSRMLS_CC);
+ old_purl = php_http_url_from_zval(old_url, flags);
if (!old_purl) {
if (new_purl) {
php_http_url_free(&new_purl);
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
return;
}
}
- res_purl = php_http_url_mod(old_purl, new_purl, flags TSRMLS_CC);
- php_http_url_to_struct(res_purl, getThis() TSRMLS_CC);
+ res_purl = php_http_url_mod(old_purl, new_purl, flags);
+ php_http_url_to_struct(res_purl, getThis());
php_http_url_free(&res_purl);
if (old_purl) {
php_http_url_free(&new_purl);
}
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpUrl_mod, 0, 0, 1)
PHP_METHOD(HttpUrl, mod)
{
zval *new_url = NULL;
- long flags = PHP_HTTP_URL_JOIN_PATH | PHP_HTTP_URL_JOIN_QUERY | PHP_HTTP_URL_SANITIZE_PATH;
+ zend_long flags = PHP_HTTP_URL_JOIN_PATH | PHP_HTTP_URL_JOIN_QUERY | PHP_HTTP_URL_SANITIZE_PATH;
zend_error_handling zeh;
- php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!|l", &new_url, &flags), invalid_arg, return);
+ php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z!|l", &new_url, &flags), invalid_arg, return);
- zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh TSRMLS_CC);
+ zend_replace_error_handling(EH_THROW, php_http_exception_bad_url_class_entry, &zeh);
{
php_http_url_t *new_purl = NULL, *old_purl = NULL;
if (new_url) {
- new_purl = php_http_url_from_zval(new_url, flags TSRMLS_CC);
+ new_purl = php_http_url_from_zval(new_url, flags);
if (!new_purl) {
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
return;
}
}
if ((old_purl = php_http_url_from_struct(HASH_OF(getThis())))) {
php_http_url_t *res_purl;
- ZVAL_OBJVAL(return_value, zend_objects_clone_obj(getThis() TSRMLS_CC), 0);
+ ZVAL_OBJ(return_value, zend_objects_clone_obj(getThis()));
- res_purl = php_http_url_mod(old_purl, new_purl, flags TSRMLS_CC);
- php_http_url_to_struct(res_purl, return_value TSRMLS_CC);
+ res_purl = php_http_url_mod(old_purl, new_purl, flags);
+ php_http_url_to_struct(res_purl, return_value);
php_http_url_free(&res_purl);
php_http_url_free(&old_purl);
php_http_url_free(&new_purl);
}
}
- zend_restore_error_handling(&zeh TSRMLS_CC);
+ zend_restore_error_handling(&zeh);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpUrl_toString, 0, 0, 0)
php_http_url_to_string(purl, &str, &len, 0);
php_http_url_free(&purl);
- RETURN_STRINGL(str, len, 0);
+ RETURN_STR(php_http_cs2zs(str, len));
}
}
RETURN_EMPTY_STRING();
/* strip any non-URL properties */
purl = php_http_url_from_struct(HASH_OF(getThis()));
- php_http_url_to_struct(purl, return_value TSRMLS_CC);
+ php_http_url_to_struct(purl, return_value);
php_http_url_free(&purl);
}
zend_class_entry ce = {0};
INIT_NS_CLASS_ENTRY(ce, "http", "Url", php_http_url_methods);
- php_http_url_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
-
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("scheme"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("user"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("pass"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("host"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("port"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("path"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("query"), ZEND_ACC_PUBLIC TSRMLS_CC);
- zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("fragment"), ZEND_ACC_PUBLIC TSRMLS_CC);
-
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("REPLACE"), PHP_HTTP_URL_REPLACE TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_PATH"), PHP_HTTP_URL_JOIN_PATH TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_QUERY"), PHP_HTTP_URL_JOIN_QUERY TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_USER"), PHP_HTTP_URL_STRIP_USER TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PASS"), PHP_HTTP_URL_STRIP_PASS TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_AUTH"), PHP_HTTP_URL_STRIP_AUTH TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PORT"), PHP_HTTP_URL_STRIP_PORT TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PATH"), PHP_HTTP_URL_STRIP_PATH TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_QUERY"), PHP_HTTP_URL_STRIP_QUERY TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_FRAGMENT"), PHP_HTTP_URL_STRIP_FRAGMENT TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_ALL"), PHP_HTTP_URL_STRIP_ALL TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("FROM_ENV"), PHP_HTTP_URL_FROM_ENV TSRMLS_CC);
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("SANITIZE_PATH"), PHP_HTTP_URL_SANITIZE_PATH TSRMLS_CC);
+ php_http_url_class_entry = zend_register_internal_class(&ce);
+
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("scheme"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("user"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("pass"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("host"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("port"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("path"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("query"), ZEND_ACC_PUBLIC);
+ zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("fragment"), ZEND_ACC_PUBLIC);
+
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("REPLACE"), PHP_HTTP_URL_REPLACE);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_PATH"), PHP_HTTP_URL_JOIN_PATH);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_QUERY"), PHP_HTTP_URL_JOIN_QUERY);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_USER"), PHP_HTTP_URL_STRIP_USER);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PASS"), PHP_HTTP_URL_STRIP_PASS);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_AUTH"), PHP_HTTP_URL_STRIP_AUTH);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PORT"), PHP_HTTP_URL_STRIP_PORT);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PATH"), PHP_HTTP_URL_STRIP_PATH);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_QUERY"), PHP_HTTP_URL_STRIP_QUERY);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_FRAGMENT"), PHP_HTTP_URL_STRIP_FRAGMENT);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_ALL"), PHP_HTTP_URL_STRIP_ALL);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("FROM_ENV"), PHP_HTTP_URL_FROM_ENV);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("SANITIZE_PATH"), PHP_HTTP_URL_SANITIZE_PATH);
#ifdef PHP_HTTP_HAVE_WCHAR
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_MBLOC"), PHP_HTTP_URL_PARSE_MBLOC TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_MBLOC"), PHP_HTTP_URL_PARSE_MBLOC);
#endif
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_MBUTF8"), PHP_HTTP_URL_PARSE_MBUTF8 TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_MBUTF8"), PHP_HTTP_URL_PARSE_MBUTF8);
#if defined(PHP_HTTP_HAVE_IDN2) || defined(PHP_HTTP_HAVE_IDN) || defined(HAVE_UIDNA_IDNTOASCII)
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_TOIDN"), PHP_HTTP_URL_PARSE_TOIDN TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_TOIDN"), PHP_HTTP_URL_PARSE_TOIDN);
#endif
- zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_TOPCT"), PHP_HTTP_URL_PARSE_TOPCT TSRMLS_CC);
+ zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("PARSE_TOPCT"), PHP_HTTP_URL_PARSE_TOPCT);
return SUCCESS;
}