X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=php_http_client_curl.c;h=26a29943f8942dc35b24d84271110e0217ec1074;hp=48deae38df4c00772ce77a85b13e9030018289e7;hb=892669e5fa183ae8a3e8d2511121dcc3ac029d1c;hpb=bc44fc3f4d04566f85f11eb25289d8ae4f88d3fd

diff --git a/php_http_client_curl.c b/php_http_client_curl.c
index 48deae3..26a2994 100644
--- a/php_http_client_curl.c
+++ b/php_http_client_curl.c
@@ -60,24 +60,17 @@ typedef struct php_http_client_curl_handler {
 	php_resource_factory_t *rf;
 	php_http_client_t *client;
 	php_http_client_progress_state_t progress;
-
 	php_http_client_enqueue_t queue;
 
 	struct {
-		php_http_message_parser_t *parser;
-		php_http_message_t *message;
-		php_http_buffer_t *buffer;
-	} request;
-
-	struct {
-		php_http_message_parser_t *parser;
-		php_http_message_t *message;
-		php_http_buffer_t *buffer;
+		php_http_buffer_t headers;
+		php_http_message_body_t *body;
 	} response;
 
 	struct {
 		HashTable cache;
 
+		struct curl_slist *proxyheaders;
 		struct curl_slist *headers;
 		struct curl_slist *resolve;
 		php_http_buffer_t cookies;
@@ -225,29 +218,23 @@ static int php_http_curle_progress_callback(void *ctx, double dltotal, double dl
 	return 0;
 }
 
-static curlioerr php_http_curle_ioctl_callback(CURL *ch, curliocmd cmd, void *ctx)
+static int php_http_curle_seek_callback(void *userdata, curl_off_t offset, int origin)
 {
-	php_http_message_body_t *body = ctx;
+	php_http_message_body_t *body = userdata;
+	TSRMLS_FETCH_FROM_CTX(body->ts);
 
-	if (cmd != CURLIOCMD_RESTARTREAD) {
-		return CURLIOE_UNKNOWNCMD;
+	if (!body) {
+		return 1;
 	}
-
-	if (body) {
-		TSRMLS_FETCH_FROM_CTX(body->ts);
-
-		if (SUCCESS == php_stream_rewind(php_http_message_body_stream(body))) {
-			return CURLIOE_OK;
-		}
+	if (0 == php_stream_seek(php_http_message_body_stream(body), offset, origin)) {
+		return 0;
 	}
-
-	return CURLIOE_FAILRESTART;
+	return 2;
 }
 
 static int php_http_curle_raw_callback(CURL *ch, curl_infotype type, char *data, size_t length, void *ctx)
 {
 	php_http_client_curl_handler_t *h = ctx;
-	unsigned flags = 0;
 
 	/* catch progress */
 	switch (type) {
@@ -282,7 +269,7 @@ static int php_http_curle_raw_callback(CURL *ch, curl_infotype type, char *data,
 			} else if (php_memnstr(data, ZEND_STRL("Operation timed out"), data + length)) {
 				h->progress.info = "timeout";
 			} else {
-#if PHP_DEBUG
+#if 0
 				h->progress.info = data;
 				data[length - 1] = '\0';
 #endif
@@ -304,32 +291,6 @@ static int php_http_curle_raw_callback(CURL *ch, curl_infotype type, char *data,
 		default:
 			break;
 	}
-	/* process data */
-	switch (type) {
-		case CURLINFO_HEADER_IN:
-		case CURLINFO_DATA_IN:
-			php_http_buffer_append(h->response.buffer, data, length);
-
-			if (h->options.redirects) {
-				flags |= PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS;
-			}
-
-			if (PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE == php_http_message_parser_parse(h->response.parser, h->response.buffer, flags, &h->response.message)) {
-				return -1;
-			}
-			break;
-
-		case CURLINFO_HEADER_OUT:
-		case CURLINFO_DATA_OUT:
-			php_http_buffer_append(h->request.buffer, data, length);
-
-			if (PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE == php_http_message_parser_parse(h->request.parser, h->request.buffer, flags, &h->request.message)) {
-				return -1;
-			}
-			break;
-		default:
-			break;
-	}
 
 #if 0
 	/* debug */
@@ -339,9 +300,18 @@ static int php_http_curle_raw_callback(CURL *ch, curl_infotype type, char *data,
 	return 0;
 }
 
-static int php_http_curle_dummy_callback(char *data, size_t n, size_t l, void *s)
+static int php_http_curle_header_callback(char *data, size_t n, size_t l, void *arg)
 {
-	return n*l;
+	php_http_client_curl_handler_t *h = arg;
+
+	return php_http_buffer_append(&h->response.headers, data, n * l);
+}
+
+static int php_http_curle_body_callback(char *data, size_t n, size_t l, void *arg)
+{
+	php_http_client_curl_handler_t *h = arg;
+
+	return php_http_message_body_append(h->response.body, data, n*l);
 }
 
 static STATUS php_http_curle_get_info(CURL *ch, HashTable *info)
@@ -617,6 +587,50 @@ static int compare_queue(php_http_client_enqueue_t *e, void *handle)
 	return handle == ((php_http_client_curl_handler_t *) e->opaque)->handle;
 }
 
+static php_http_message_t *php_http_curlm_responseparser(php_http_client_curl_handler_t *h TSRMLS_DC)
+{
+	php_http_message_t *response;
+	php_http_header_parser_t parser;
+	zval *zh;
+
+	response = php_http_message_init(NULL, 0, h->response.body TSRMLS_CC);
+	php_http_header_parser_init(&parser TSRMLS_CC);
+	php_http_header_parser_parse(&parser, &h->response.headers, PHP_HTTP_HEADER_PARSER_CLEANUP, &response->hdrs, (php_http_info_callback_t) php_http_message_info_callback, (void *) &response);
+	php_http_header_parser_dtor(&parser);
+
+	/* move body to right message */
+	if (response->body != h->response.body) {
+		php_http_message_t *ptr = response;
+
+		while (ptr->parent) {
+			ptr = ptr->parent;
+		}
+		response->body = ptr->body;
+		ptr->body = NULL;
+	}
+	php_http_message_body_addref(h->response.body);
+
+	/* let's update the response headers */
+	if ((zh = php_http_message_header(response, ZEND_STRL("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("Transfer-Encoding"), 0))) {
+		zend_hash_update(&response->hdrs, "X-Original-Transfer-Encoding", sizeof("X-Original-Transfer-Encoding"), (void *) &zh, sizeof(zval *), NULL);
+		zend_hash_del(&response->hdrs, "Transfer-Encoding", sizeof("Transfer-Encoding"));
+	}
+	if ((zh = php_http_message_header(response, ZEND_STRL("Content-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-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"));
+	}
+	php_http_message_update_headers(response);
+
+	return response;
+}
+
 static void php_http_curlm_responsehandler(php_http_client_t *context)
 {
 	int remaining = 0;
@@ -635,8 +649,12 @@ static void php_http_curlm_responsehandler(php_http_client_t *context)
 
 			if ((enqueue = php_http_client_enqueued(context, msg->easy_handle, compare_queue))) {
 				php_http_client_curl_handler_t *handler = enqueue->opaque;
+				php_http_message_t *response = php_http_curlm_responseparser(handler TSRMLS_CC);
 
-				context->callback.response.func(context->callback.response.arg, context, &handler->queue, &handler->request.message, &handler->response.message);
+				if (response) {
+					context->callback.response.func(context->callback.response.arg, context, &handler->queue, &response);
+					php_http_message_free(&response);
+				}
 			}
 		}
 	} while (remaining);
@@ -785,8 +803,6 @@ static void php_http_curlm_timer_callback(CURLM *multi, long timeout_ms, void *t
 
 			if (!event_initialized(curl->timeout)) {
 				event_assign(curl->timeout, curl->evbase, CURL_SOCKET_TIMEOUT, 0, php_http_curlm_timeout_callback, context);
-			} else if (event_pending(curl->timeout, EV_TIMEOUT, NULL)) {
-				event_del(curl->timeout);
 			}
 
 			timeout.tv_sec = timeout_ms / 1000;
@@ -907,7 +923,7 @@ static STATUS php_http_curle_option_set_lastmodified(php_http_option_t *opt, zva
 				return FAILURE;
 			}
 		} else {
-			if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, (long) PHP_HTTP_G->env.request.time + Z_LVAL_P(val))) {
+			if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, (long) sapi_get_request_time(TSRMLS_C) + Z_LVAL_P(val))) {
 				return FAILURE;
 			}
 		}
@@ -927,9 +943,10 @@ static STATUS php_http_curle_option_set_lastmodified(php_http_option_t *opt, zva
 static STATUS php_http_curle_option_set_compress(php_http_option_t *opt, zval *val, void *userdata)
 {
 	php_http_client_curl_handler_t *curl = userdata;
+	CURL *ch = curl->handle;
 
-	if (Z_BVAL_P(val)) {
-		curl->options.headers = curl_slist_append(curl->options.headers, "Accept-Encoding: gzip;q=1.0,deflate;q=0.5");
+	if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_ACCEPT_ENCODING, Z_BVAL_P(val) ? "" : NULL)) {
+		return FAILURE;
 	}
 	return SUCCESS;
 }
@@ -1075,6 +1092,43 @@ static STATUS php_http_curle_option_set_portrange(php_http_option_t *opt, zval *
 	return SUCCESS;
 }
 
+#if PHP_HTTP_CURL_VERSION(7,37,0)
+static STATUS 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_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));
+				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);
+			}
+		}
+		php_http_buffer_dtor(&header);
+	}
+	if (CURLE_OK != curl_easy_setopt(curl->handle, CURLOPT_PROXYHEADER, curl->options.proxyheaders)) {
+		return FAILURE;
+	}
+	if (CURLE_OK != curl_easy_setopt(curl->handle, CURLOPT_HEADEROPT, CURLHEADER_SEPARATE)) {
+		curl_easy_setopt(curl->handle, CURLOPT_PROXYHEADER, NULL);
+		return FAILURE;
+	}
+	return SUCCESS;
+}
+#endif
+
 #if PHP_HTTP_CURL_VERSION(7,21,3)
 static STATUS php_http_curle_option_set_resolve(php_http_option_t *opt, zval *val, void *userdata)
 {
@@ -1105,6 +1159,30 @@ static STATUS php_http_curle_option_set_resolve(php_http_option_t *opt, zval *va
 }
 #endif
 
+#if PHP_HTTP_CURL_VERSION(7,21,4)
+static STATUS php_http_curle_option_set_ssl_tlsauthtype(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_curl_handler_t *curl = userdata;
+	CURL *ch = curl->handle;
+
+	if (val && Z_LVAL_P(val)) {
+		switch (Z_LVAL_P(val)) {
+		case CURL_TLSAUTH_SRP:
+			if (CURLE_OK == curl_easy_setopt(ch, CURLOPT_TLSAUTH_TYPE, PHP_HTTP_CURL_TLSAUTH_SRP)) {
+				return SUCCESS;
+			}
+			/* no break */
+		default:
+			return FAILURE;
+		}
+	}
+	if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TLSAUTH_TYPE, PHP_HTTP_CURL_TLSAUTH_DEF)) {
+		return FAILURE;
+	}
+	return SUCCESS;
+}
+#endif
+
 static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
 {
 	php_http_option_t *opt;
@@ -1126,6 +1204,19 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
 	php_http_option_register(registry, ZEND_STRL("noproxy"), CURLOPT_NOPROXY, IS_STRING);
 #endif
 
+#if PHP_HTTP_CURL_VERSION(7,37,0)
+	if ((opt = php_http_option_register(registry, ZEND_STRL("proxyheader"), CURLOPT_PROXYHEADER, IS_ARRAY))) {
+		opt->setter = php_http_curle_option_set_proxyheader;
+	}
+#endif
+
+#if PHP_HTTP_CURL_VERSION(7,40,0)
+	if ((opt = php_http_option_register(registry, ZEND_STRL("unix_socket_path"), CURLOPT_UNIX_SOCKET_PATH, IS_STRING))) {
+		opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
+		opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
+	}
+#endif
+
 	/* dns */
 	if ((opt = php_http_option_register(registry, ZEND_STRL("dns_cache_timeout"), CURLOPT_DNS_CACHE_TIMEOUT, IS_LONG))) {
 		Z_LVAL(opt->defval) = 60;
@@ -1338,6 +1429,9 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
 			ZVAL_BOOL(&opt->defval, 1);
 			opt->setter = php_http_curle_option_set_ssl_verifyhost;
 		}
+#if PHP_HTTP_CURL_VERSION(7,41,0)
+		php_http_option_register(registry, ZEND_STRL("verifystatus"), CURLOPT_SSL_VERIFYSTATUS, IS_BOOL);
+#endif
 		php_http_option_register(registry, ZEND_STRL("cipher_list"), CURLOPT_SSL_CIPHER_LIST, IS_STRING);
 		if ((opt = php_http_option_register(registry, ZEND_STRL("cainfo"), CURLOPT_CAINFO, IS_STRING))) {
 			opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
@@ -1380,6 +1474,23 @@ static void php_http_curle_options_init(php_http_options_t *registry TSRMLS_DC)
 		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)
+		if ((opt = php_http_option_register(registry, ZEND_STRL("pinned_publickey"), CURLOPT_PINNEDPUBLICKEY, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
+		}
+#endif
+#if PHP_HTTP_CURL_VERSION(7,21,4)
+		if ((opt = php_http_option_register(registry, ZEND_STRL("tlsauthtype"), CURLOPT_TLSAUTH_TYPE, IS_LONG))) {
+			opt->setter = php_http_curle_option_set_ssl_tlsauthtype;
+		}
+		if ((opt = php_http_option_register(registry, ZEND_STRL("tlsauthuser"), CURLOPT_TLSAUTH_USERNAME, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
+		}
+		if ((opt = php_http_option_register(registry, ZEND_STRL("tlsauthpass"), CURLOPT_TLSAUTH_PASSWORD, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
+		}
 #endif
 	}
 }
@@ -1524,6 +1635,10 @@ static STATUS php_http_client_curl_handler_reset(php_http_client_curl_handler_t
 		curl_slist_free_all(curl->options.headers);
 		curl->options.headers = NULL;
 	}
+	if (curl->options.proxyheaders) {
+		curl_slist_free_all(curl->options.proxyheaders);
+		curl->options.proxyheaders = NULL;
+	}
 
 	php_http_buffer_reset(&curl->options.cookies);
 	php_http_buffer_reset(&curl->options.ranges);
@@ -1546,12 +1661,8 @@ static php_http_client_curl_handler_t *php_http_client_curl_handler_init(php_htt
 	handler->rf = rf;
 	handler->client = h;
 	handler->handle = handle;
-	handler->request.buffer = php_http_buffer_init(NULL);
-	handler->request.parser = php_http_message_parser_init(NULL TSRMLS_CC);
-	handler->request.message = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
-	handler->response.buffer = php_http_buffer_init(NULL);
-	handler->response.parser = php_http_message_parser_init(NULL TSRMLS_CC);
-	handler->response.message = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+	handler->response.body = php_http_message_body_init(NULL, NULL TSRMLS_CC);
+	php_http_buffer_init(&handler->response.headers);
 	php_http_buffer_init(&handler->options.cookies);
 	php_http_buffer_init(&handler->options.ranges);
 	zend_hash_init(&handler->options.cache, 0, NULL, ZVAL_PTR_DTOR, 0);
@@ -1564,11 +1675,11 @@ static php_http_client_curl_handler_t *php_http_client_curl_handler_init(php_htt
 	curl_easy_setopt(handle, CURLOPT_AUTOREFERER, 1L);
 	curl_easy_setopt(handle, CURLOPT_VERBOSE, 1L);
 	curl_easy_setopt(handle, CURLOPT_NOPROGRESS, 0L);
-	curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, NULL);
-	curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, php_http_curle_dummy_callback);
+	curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, php_http_curle_header_callback);
+	curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, php_http_curle_body_callback);
 	curl_easy_setopt(handle, CURLOPT_DEBUGFUNCTION, php_http_curle_raw_callback);
 	curl_easy_setopt(handle, CURLOPT_READFUNCTION, php_http_curle_read_callback);
-	curl_easy_setopt(handle, CURLOPT_IOCTLFUNCTION, php_http_curle_ioctl_callback);
+	curl_easy_setopt(handle, CURLOPT_SEEKFUNCTION, php_http_curle_seek_callback);
 #if PHP_HTTP_CURL_VERSION(7,32,0)
 	curl_easy_setopt(handle, CURLOPT_XFERINFOFUNCTION, php_http_curle_xferinfo_callback);
 	curl_easy_setopt(handle, CURLOPT_XFERINFODATA, handler);
@@ -1577,6 +1688,8 @@ static php_http_client_curl_handler_t *php_http_client_curl_handler_init(php_htt
 	curl_easy_setopt(handle, CURLOPT_PROGRESSDATA, handler);
 #endif
 	curl_easy_setopt(handle, CURLOPT_DEBUGDATA, handler);
+	curl_easy_setopt(handle, CURLOPT_WRITEDATA, handler);
+	curl_easy_setopt(handle, CURLOPT_HEADERDATA, handler);
 
 	php_http_client_curl_handler_reset(handler);
 
@@ -1600,7 +1713,7 @@ static STATUS php_http_client_curl_handler_prepare(php_http_client_curl_handler_
 	if (storage->url) {
 		pefree(storage->url, 1);
 	}
-	storage->url = pestrdup(PHP_HTTP_INFO(msg).request.url, 1);
+	php_http_url_to_string(PHP_HTTP_INFO(msg).request.url, &storage->url, NULL, 1);
 	curl_easy_setopt(curl->handle, CURLOPT_URL, storage->url);
 
 	/* request method */
@@ -1632,19 +1745,32 @@ static STATUS php_http_client_curl_handler_prepare(php_http_client_curl_handler_
 		}
 	}
 
+	/* apply options */
+	php_http_options_apply(&php_http_curle_options, enqueue->options, curl);
+
 	/* request headers */
 	php_http_message_update_headers(msg);
 	if (zend_hash_num_elements(&msg->hdrs)) {
 		php_http_array_hashkey_t header_key = php_http_array_hashkey_init(0);
-		zval **header_val;
+		zval **header_val, *header_cpy;
 		HashPosition pos;
 		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);
+#endif
 
 		php_http_buffer_init(&header);
 		FOREACH_HASH_KEYVAL(pos, &msg->hdrs, header_key, header_val) {
 			if (header_key.type == HASH_KEY_IS_STRING) {
-				zval *header_cpy = php_http_ztyp(IS_STRING, *header_val);
-
+#if !PHP_HTTP_CURL_VERSION(7,23,0)
+				/* avoid duplicate content-length header */
+				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));
 				php_http_buffer_fix(&header);
 				curl->options.headers = curl_slist_append(curl->options.headers, header.data);
@@ -1666,19 +1792,17 @@ static STATUS php_http_client_curl_handler_prepare(php_http_client_curl_handler_
 		 * does not allow a request body.
 		 */
 		php_stream_rewind(php_http_message_body_stream(msg->body));
-		curl_easy_setopt(curl->handle, CURLOPT_IOCTLDATA, msg->body);
+		curl_easy_setopt(curl->handle, CURLOPT_SEEKDATA, msg->body);
 		curl_easy_setopt(curl->handle, CURLOPT_READDATA, msg->body);
 		curl_easy_setopt(curl->handle, CURLOPT_INFILESIZE, body_size);
 		curl_easy_setopt(curl->handle, CURLOPT_POSTFIELDSIZE, body_size);
 	} else {
-		curl_easy_setopt(curl->handle, CURLOPT_IOCTLDATA, NULL);
+		curl_easy_setopt(curl->handle, CURLOPT_SEEKDATA, NULL);
 		curl_easy_setopt(curl->handle, CURLOPT_READDATA, NULL);
 		curl_easy_setopt(curl->handle, CURLOPT_INFILESIZE, 0L);
 		curl_easy_setopt(curl->handle, CURLOPT_POSTFIELDSIZE, 0L);
 	}
 
-	php_http_options_apply(&php_http_curle_options, enqueue->options, curl);
-
 	return SUCCESS;
 }
 
@@ -1703,12 +1827,8 @@ static void php_http_client_curl_handler_dtor(php_http_client_curl_handler_t *ha
 	php_resource_factory_handle_dtor(handler->rf, handler->handle TSRMLS_CC);
 	php_resource_factory_free(&handler->rf);
 
-	php_http_message_parser_free(&handler->request.parser);
-	php_http_message_free(&handler->request.message);
-	php_http_buffer_free(&handler->request.buffer);
-	php_http_message_parser_free(&handler->response.parser);
-	php_http_message_free(&handler->response.message);
-	php_http_buffer_free(&handler->response.buffer);
+	php_http_message_body_free(&handler->response.body);
+	php_http_buffer_dtor(&handler->response.headers);
 	php_http_buffer_dtor(&handler->options.ranges);
 	php_http_buffer_dtor(&handler->options.cookies);
 	zend_hash_destroy(&handler->options.cache);
@@ -1776,38 +1896,29 @@ static void queue_dtor(php_http_client_enqueue_t *e)
 	php_http_client_curl_handler_dtor(handler);
 }
 
-static php_resource_factory_t *create_rf(const char *url TSRMLS_DC)
+static php_resource_factory_t *create_rf(php_http_url_t *url TSRMLS_DC)
 {
-	php_url *purl;
+	php_persistent_handle_factory_t *pf;
 	php_resource_factory_t *rf = NULL;
+	char *id_str = NULL;
+	size_t id_len;
 
-	if (!url || !*url) {
+	if (!url || (!url->host && !url->path)) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot request empty URL");
 		return NULL;
 	}
 
-	purl = php_url_parse(url);
+	id_len = spprintf(&id_str, 0, "%s:%d", STR_PTR(url->host), url->port ? url->port : 80);
 
-	if (!purl) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not parse URL '%s'", url);
-		return NULL;
+	pf = php_persistent_handle_concede(NULL, ZEND_STRL("http\\Client\\Curl\\Request"), id_str, id_len, NULL, NULL TSRMLS_CC);
+	if (pf) {
+		rf = php_resource_factory_init(NULL, php_persistent_handle_get_resource_factory_ops(), pf, (void (*)(void*)) php_persistent_handle_abandon);
 	} else {
-		char *id_str = NULL;
-		size_t id_len = spprintf(&id_str, 0, "%s:%d", STR_PTR(purl->host), purl->port ? purl->port : 80);
-		php_persistent_handle_factory_t *pf = php_persistent_handle_concede(NULL, ZEND_STRL("http\\Client\\Curl\\Request"), id_str, id_len, NULL, NULL TSRMLS_CC);
-
-		if (pf) {
-			rf = php_resource_factory_init(NULL, php_persistent_handle_get_resource_factory_ops(), pf, (void (*)(void*)) php_persistent_handle_abandon);
-		}
-
-		php_url_free(purl);
-		efree(id_str);
-	}
-
-	if (!rf) {
 		rf = php_resource_factory_init(NULL, &php_http_curle_resource_factory_ops, NULL, NULL);
 	}
 
+	efree(id_str);
+
 	return rf;
 }
 
@@ -1884,6 +1995,17 @@ static void php_http_client_curl_reset(php_http_client_t *h)
 	}
 }
 
+static inline void php_http_client_curl_get_timeout(php_http_client_curl_t *curl, long max_tout, struct timeval *timeout)
+{
+	if ((CURLM_OK == curl_multi_timeout(curl->handle, &max_tout)) && (max_tout > 0)) {
+		timeout->tv_sec = max_tout / 1000;
+		timeout->tv_usec = (max_tout % 1000) * 1000;
+	} else {
+		timeout->tv_sec = 0;
+		timeout->tv_usec = 1000;
+	}
+}
+
 #ifdef PHP_WIN32
 #	define SELECT_ERROR SOCKET_ERROR
 #else
@@ -1899,10 +2021,18 @@ static STATUS php_http_client_curl_wait(php_http_client_t *h, struct timeval *cu
 
 #if PHP_HTTP_HAVE_EVENT
 	if (curl->useevents) {
-		TSRMLS_FETCH_FROM_CTX(h->ts);
+		if (!event_initialized(curl->timeout)) {
+			event_assign(curl->timeout, curl->evbase, CURL_SOCKET_TIMEOUT, 0, php_http_curlm_timeout_callback, h);
+		} else if (custom_timeout && timerisset(custom_timeout)) {
+			event_add(curl->timeout, custom_timeout);
+		} else if (!event_pending(curl->timeout, EV_TIMEOUT, NULL)) {
+			php_http_client_curl_get_timeout(curl, 1000, &timeout);
+			event_add(curl->timeout, &timeout);
+		}
 
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "not implemented");
-		return FAILURE;
+		event_base_loop(curl->evbase, EVLOOP_ONCE);
+
+		return SUCCESS;
 	}
 #endif
 
@@ -1914,15 +2044,7 @@ static STATUS php_http_client_curl_wait(php_http_client_t *h, struct timeval *cu
 		if (custom_timeout && timerisset(custom_timeout)) {
 			timeout = *custom_timeout;
 		} else {
-			long max_tout = 1000;
-
-			if ((CURLM_OK == curl_multi_timeout(curl->handle, &max_tout)) && (max_tout > 0)) {
-				timeout.tv_sec = max_tout / 1000;
-				timeout.tv_usec = (max_tout % 1000) * 1000;
-			} else {
-				timeout.tv_sec = 0;
-				timeout.tv_usec = 1000;
-			}
+			php_http_client_curl_get_timeout(curl, 1000, &timeout);
 		}
 
 		if (MAX == -1) {
@@ -1941,12 +2063,9 @@ static int php_http_client_curl_once(php_http_client_t *h)
 
 #if PHP_HTTP_HAVE_EVENT
 	if (curl->useevents) {
-		TSRMLS_FETCH_FROM_CTX(h->ts);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "not implemented");
-		return FAILURE;
-	}
+		event_base_loop(curl->evbase, EVLOOP_NONBLOCK);
+	} else
 #endif
-
 	while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(curl->handle, &curl->unfinished));
 
 	php_http_curlm_responsehandler(h);
@@ -2116,6 +2235,9 @@ PHP_MINIT_FUNCTION(http_client_curl)
 	*/
 	REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "HTTP_VERSION_1_0", CURL_HTTP_VERSION_1_0, CONST_CS|CONST_PERSISTENT);
 	REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "HTTP_VERSION_1_1", CURL_HTTP_VERSION_1_1, CONST_CS|CONST_PERSISTENT);
+#if PHP_HTTP_CURL_VERSION(7,33,0)
+	REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "HTTP_VERSION_2_0", CURL_HTTP_VERSION_2_0, CONST_CS|CONST_PERSISTENT);
+#endif
 	REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "HTTP_VERSION_ANY", CURL_HTTP_VERSION_NONE, CONST_CS|CONST_PERSISTENT);
 
 	/*
@@ -2130,6 +2252,9 @@ PHP_MINIT_FUNCTION(http_client_curl)
 	REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "SSL_VERSION_SSLv2", CURL_SSLVERSION_SSLv2, CONST_CS|CONST_PERSISTENT);
 	REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "SSL_VERSION_SSLv3", CURL_SSLVERSION_SSLv3, CONST_CS|CONST_PERSISTENT);
 	REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "SSL_VERSION_ANY", CURL_SSLVERSION_DEFAULT, CONST_CS|CONST_PERSISTENT);
+#if PHP_HTTP_CURL_VERSION(7,21,4)
+	REGISTER_NS_LONG_CONSTANT("http\\Client\\Curl", "TLSAUTH_SRP", CURL_TLSAUTH_SRP, CONST_CS|CONST_PERSISTENT);
+#endif
 
 	/*
 	* DNS IPvX resolving