X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=src%2Fphp_http_client_curl.c;h=94cdf474180549023805549a22230d02e20b3b4b;hp=0e79f197bd3255cda32398ea4ab0843f55811480;hb=refs%2Fheads%2Fmaster;hpb=ccd8182038d5a58e6d8f0eb6b3921ebb66baeed0

diff --git a/src/php_http_client_curl.c b/src/php_http_client_curl.c
index 0e79f19..4decc7a 100644
--- a/src/php_http_client_curl.c
+++ b/src/php_http_client_curl.c
@@ -17,6 +17,8 @@
 
 #if PHP_HTTP_HAVE_LIBCURL
 
+#define DEBUG_COOKIES 0
+
 #if PHP_HTTP_HAVE_LIBCURL_OPENSSL
 #	include <openssl/ssl.h>
 #endif
@@ -311,14 +313,14 @@ static int php_http_curle_raw_callback(CURL *ch, curl_infotype type, char *data,
 	return 0;
 }
 
-static int php_http_curle_header_callback(char *data, size_t n, size_t l, void *arg)
+static size_t php_http_curle_header_callback(char *data, size_t n, size_t l, void *arg)
 {
 	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)
+static size_t php_http_curle_body_callback(char *data, size_t n, size_t l, void *arg)
 {
 	php_http_client_curl_handler_t *h = arg;
 
@@ -365,18 +367,34 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
 		ZVAL_DOUBLE(&tmp, d);
 		zend_hash_str_update(info, "size_upload", lenof("size_upload"), &tmp);
 	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_UPLOAD_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "size_upload_t", lenof("size_upload_t"), &tmp);
+	}
 	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_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_SIZE_DOWNLOAD_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "size_download_t", lenof("size_download_t"), &tmp);
+	}
 	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_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_DOWNLOAD_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "speed_download_t", lenof("speed_download_t"), &tmp);
+	}
 	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_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_SPEED_UPLOAD_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "speed_upload_t", lenof("speed_upload_t"), &tmp);
+	}
 	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HEADER_SIZE, &l)) {
 		ZVAL_LONG(&tmp, l);
 		zend_hash_str_update(info, "header_size", lenof("header_size"), &tmp);
@@ -393,14 +411,26 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
 		ZVAL_LONG(&tmp, l);
 		zend_hash_str_update(info, "filetime", lenof("filetime"), &tmp);
 	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_FILETIME_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "filetime_t", lenof("filetime_t"), &tmp);
+	}
 	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_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_DOWNLOAD_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "content_length_download_t", lenof("content_length_download_t"), &tmp);
+	}
 	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_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_CONTENT_LENGTH_UPLOAD_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "content_length_upload_t", lenof("content_length_upload_t"), &tmp);
+	}
 	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_STARTTRANSFER_TIME, &d)) {
 		ZVAL_DOUBLE(&tmp, d);
 		zend_hash_str_update(info, "starttransfer_time", lenof("starttransfer_time"), &tmp);
@@ -511,6 +541,34 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
 		zend_hash_str_update(info, "scheme", lenof("scheme"), &tmp);
 	}
 #endif
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_TOTAL_TIME_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "total_time_t", lenof("total_time_t"), &tmp);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NAMELOOKUP_TIME_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "namelookup_time_t", lenof("namelookup_time_t"), &tmp);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONNECT_TIME_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "connect_time_t", lenof("connect_time_t"), &tmp);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRETRANSFER_TIME_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "pretransfer_time_t", lenof("pretransfer_time_t"), &tmp);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_STARTTRANSFER_TIME_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "starttransfer_time_t", lenof("starttransfer_time_t"), &tmp);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_TIME_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "redirect_time_t", lenof("redirect_time_t"), &tmp);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_APPCONNECT_TIME_T, &o)) {
+		ZVAL_LONG(&tmp, o);
+		zend_hash_str_update(info, "appconnect_time_t", lenof("appconnect_time_t"), &tmp);
+	}
 #if PHP_HTTP_CURL_VERSION(7,66,0)
 	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_RETRY_AFTER, &o)) {
 		ZVAL_LONG(&tmp, o);
@@ -529,6 +587,24 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
 		zend_hash_str_update(info, "proxy_error", lenof("proxy_error"), &tmp);
 	}
 #endif
+#if PHP_HTTP_CURL_VERSION(7,76,0)
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REFERER, &c)) {
+		ZVAL_STRING(&tmp, STR_PTR(c));
+		zend_hash_str_update(info, "referer", lenof("referer"), &tmp);
+	}
+#endif
+#if PHP_HTTP_CURL_VERSION(7,84,0)
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CAINFO, &c)) {
+		ZVAL_STRING(&tmp, STR_PTR(c));
+		zend_hash_str_update(info, "cainfo", lenof("cainfo"), &tmp);
+	}
+#endif
+#if PHP_HTTP_CURL_VERSION(7,84,0)
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CAPATH, &c)) {
+		ZVAL_STRING(&tmp, STR_PTR(c));
+		zend_hash_str_update(info, "capath", lenof("capath"), &tmp);
+	}
+#endif
 
 	/* END::CURLINFO */
 
@@ -628,8 +704,9 @@ static ZEND_RESULT_CODE php_http_curle_get_info(CURL *ch, HashTable *info)
 
 #if (PHP_HTTP_CURL_VERSION(7,19,1) && PHP_HTTP_HAVE_LIBCURL_OPENSSL) || \
 	(PHP_HTTP_CURL_VERSION(7,34,0) && PHP_HTTP_HAVE_LIBCURL_NSS) || \
+	(PHP_HTTP_CURL_VERSION(7,39,0) && PHP_HTTP_HAVE_LIBCURL_GSKIT) || \
 	(PHP_HTTP_CURL_VERSION(7,42,0) && PHP_HTTP_HAVE_LIBCURL_GNUTLS) || \
-	(PHP_HTTP_CURL_VERSION(7,39,0) && PHP_HTTP_HAVE_LIBCURL_GSKIT)
+	(PHP_HTTP_CURL_VERSION(7,79,0) && PHP_HTTP_HAVE_LIBCURL_SECURETRANSPORT)
 	{
 		int i;
 		zval ci_array, subarray;
@@ -834,6 +911,9 @@ static ZEND_RESULT_CODE php_http_curle_option_set_cookiesession(php_http_option_
 		return FAILURE;
 	}
 	if (Z_TYPE_P(val) == IS_TRUE) {
+#if DEBUG_COOKIES
+		fprintf(stderr, "CURLOPT_COOKIELIST: SESS\n");
+#endif
 		if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIELIST, "SESS")) {
 			return FAILURE;
 		}
@@ -856,9 +936,19 @@ static ZEND_RESULT_CODE php_http_curle_option_set_cookiestore(php_http_option_t
 	} else {
 		storage->cookiestore = NULL;
 	}
-	if (	CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIEFILE, storage->cookiestore ? storage->cookiestore : "")
-		||	CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIEJAR, storage->cookiestore)
-	) {
+
+#if DEBUG_COOKIES
+	fprintf(stderr, "CURLOPT_COOKIEFILE: %s\n", storage->cookiestore);
+#endif
+	// does NOT enable ch->data.cookies until transfer; adds to ch->stsate.cookielist
+	if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIEFILE, storage->cookiestore ? storage->cookiestore : "")) {
+		return FAILURE;
+	}
+#if DEBUG_COOKIES
+	fprintf(stderr, "CURLOPT_COOKIEJAR: %s\n", storage->cookiestore);
+#endif
+	// enables ch->data.cookies
+	if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIEJAR, storage->cookiestore)) {
 		return FAILURE;
 	}
 
@@ -1187,8 +1277,10 @@ static ZEND_RESULT_CODE php_http_curle_option_set_ssl_tlsauthtype(php_http_optio
 
 	if (val && Z_LVAL_P(val)) {
 		switch (Z_LVAL_P(val)) {
+		case CURL_TLSAUTH_NONE:
+			break;
 		case CURL_TLSAUTH_SRP:
-			if (CURLE_OK == curl_easy_setopt(ch, opt->option, PHP_HTTP_LIBCURL_TLSAUTH_SRP)) {
+			if (CURLE_OK == curl_easy_setopt(ch, opt->option, "SRP")) {
 				return SUCCESS;
 			}
 			/* no break */
@@ -1196,7 +1288,7 @@ static ZEND_RESULT_CODE php_http_curle_option_set_ssl_tlsauthtype(php_http_optio
 			return FAILURE;
 		}
 	}
-	if (CURLE_OK != curl_easy_setopt(ch, opt->option, PHP_HTTP_LIBCURL_TLSAUTH_DEF)) {
+	if (CURLE_OK != curl_easy_setopt(ch, opt->option, "NONE")) {
 		return FAILURE;
 	}
 	return SUCCESS;
@@ -1471,7 +1563,10 @@ static void php_http_curle_options_init(php_http_options_t *registry)
 	}
 #endif
 #if PHP_HTTP_CURL_VERSION(7,49,0)
+# if defined(linux) || defined(__APPLE__)
+	/* CURLOPT_TCP_FASTOPEN is not supported (yet) on Windows */
 	php_http_option_register(registry, ZEND_STRL("tcp_fastopen"), CURLOPT_TCP_FASTOPEN, _IS_BOOL);
+# endif
 #endif
 
 	/* ssl */
@@ -1587,7 +1682,7 @@ static void php_http_curle_options_init(php_http_options_t *registry)
 				opt->flags |= PHP_HTTP_CURLE_OPTION_IGNORE_RC;
 			}
 #endif
-#if PHP_HTTP_CURL_VERSION(7,61,0)
+#if PHP_HTTP_CURL_VERSION(7,61,0) && PHP_HTTP_HAVE_LIBCURL_TLS13_CIPHERS
 			if ((opt = php_http_option_register(ssl_registry, ZEND_STRL("tls13_ciphers"), CURLOPT_TLS13_CIPHERS, IS_STRING))) {
 				opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
 			}
@@ -1676,7 +1771,7 @@ static void php_http_curle_options_init(php_http_options_t *registry)
 				opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_BASEDIR;
 			}
 # endif
-# if PHP_HTTP_CURL_VERSION(7,61,0)
+# if PHP_HTTP_CURL_VERSION(7,61,0) && PHP_HTTP_HAVE_LIBCURL_TLS13_CIPHERS
 			if ((opt = php_http_option_register(proxy_registry, ZEND_STRL("tls13_ciphers"), CURLOPT_PROXY_TLS13_CIPHERS, IS_STRING))) {
 				opt->flags |= PHP_HTTP_CURLE_OPTION_CHECK_STRLEN;
 			}
@@ -1919,7 +2014,7 @@ static ZEND_RESULT_CODE php_http_curlm_option_set_share_cookies(php_http_option_
 	return SUCCESS;
 }
 
-#if PHP_HTTP_CURL_VERSION(7,23,0)
+#if PHP_HTTP_HAVE_LIBCURL_SHARE_SSL
 static ZEND_RESULT_CODE php_http_curlm_option_set_share_ssl(php_http_option_t *opt, zval *value, void *userdata)
 {
 	php_http_client_t *client = userdata;
@@ -1994,7 +2089,7 @@ static void php_http_curlm_options_init(php_http_options_t *registry)
 		opt->setter = php_http_curlm_option_set_share_cookies;
 		ZVAL_TRUE(&opt->defval);
 	}
-#if PHP_HTTP_CURL_VERSION(7,23,0)
+#if PHP_HTTP_HAVE_LIBCURL_SHARE_SSL
 	if ((opt = php_http_option_register(registry, ZEND_STRL("share_ssl"), 0, _IS_BOOL))) {
 		opt->setter = php_http_curlm_option_set_share_ssl;
 		ZVAL_TRUE(&opt->defval);
@@ -2052,9 +2147,10 @@ static ZEND_RESULT_CODE php_http_curlm_set_option(php_http_option_t *opt, zval *
 
 /* client ops */
 
-static ZEND_RESULT_CODE php_http_client_curl_handler_reset(php_http_client_curl_handler_t *curl)
+static ZEND_RESULT_CODE php_http_client_curl_handler_reset(php_http_client_curl_handler_t *handler)
 {
-	CURL *ch = curl->handle;
+	php_http_client_curl_t *curl = handler->client->ctx;
+	CURL *ch = handler->handle;
 	php_http_curle_storage_t *st;
 
 	if ((st = php_http_curle_get_storage(ch))) {
@@ -2083,27 +2179,61 @@ static ZEND_RESULT_CODE php_http_client_curl_handler_reset(php_http_client_curl_
 #endif
 
 #if PHP_HTTP_CURL_VERSION(7,21,3)
-	if (curl->options.resolve) {
-		curl_slist_free_all(curl->options.resolve);
-		curl->options.resolve = NULL;
+	if (handler->options.resolve) {
+		curl_slist_free_all(handler->options.resolve);
+		handler->options.resolve = NULL;
 	}
 #endif
-	curl->options.retry.count = 0;
-	curl->options.retry.delay = 0;
-	curl->options.redirects = 0;
-	curl->options.encode_cookies = 1;
+	handler->options.retry.count = 0;
+	handler->options.retry.delay = 0;
+	handler->options.redirects = 0;
+	handler->options.encode_cookies = 1;
 
-	if (curl->options.headers) {
-		curl_slist_free_all(curl->options.headers);
-		curl->options.headers = NULL;
+	if (handler->options.headers) {
+		curl_slist_free_all(handler->options.headers);
+		handler->options.headers = NULL;
 	}
-	if (curl->options.proxyheaders) {
-		curl_slist_free_all(curl->options.proxyheaders);
-		curl->options.proxyheaders = NULL;
+	if (handler->options.proxyheaders) {
+		curl_slist_free_all(handler->options.proxyheaders);
+		handler->options.proxyheaders = NULL;
 	}
 
-	php_http_buffer_reset(&curl->options.cookies);
-	php_http_buffer_reset(&curl->options.ranges);
+	php_http_buffer_reset(&handler->options.cookies);
+	php_http_buffer_reset(&handler->options.ranges);
+
+	if (php_http_message_body_size(handler->response.body)) {
+		php_http_message_body_free(&handler->response.body);
+		handler->response.body = php_http_message_body_init(NULL, NULL);
+	}
+	php_http_buffer_reset(&handler->response.headers);
+
+#if ZTS
+	curl_easy_setopt(ch, CURLOPT_NOSIGNAL, 1L);
+#endif
+	curl_easy_setopt(ch, CURLOPT_HEADER, 0L);
+	curl_easy_setopt(ch, CURLOPT_FILETIME, 1L);
+	curl_easy_setopt(ch, CURLOPT_AUTOREFERER, 1L);
+	curl_easy_setopt(ch, CURLOPT_VERBOSE, 1L);
+	curl_easy_setopt(ch, CURLOPT_NOPROGRESS, 0L);
+	curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, php_http_curle_header_callback);
+	curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, php_http_curle_body_callback);
+	curl_easy_setopt(ch, CURLOPT_DEBUGFUNCTION, php_http_curle_raw_callback);
+	curl_easy_setopt(ch, CURLOPT_READFUNCTION, php_http_curle_read_callback);
+	curl_easy_setopt(ch, CURLOPT_SEEKFUNCTION, php_http_curle_seek_callback);
+#if PHP_HTTP_CURL_VERSION(7,32,0)
+	curl_easy_setopt(ch, CURLOPT_XFERINFOFUNCTION, php_http_curle_xferinfo_callback);
+	curl_easy_setopt(ch, CURLOPT_XFERINFODATA, handler);
+#else
+	curl_easy_setopt(ch, CURLOPT_PROGRESSFUNCTION, php_http_curle_progress_callback);
+	curl_easy_setopt(ch, CURLOPT_PROGRESSDATA, handler);
+#endif
+	curl_easy_setopt(ch, CURLOPT_DEBUGDATA, handler);
+	curl_easy_setopt(ch, CURLOPT_WRITEDATA, handler);
+	curl_easy_setopt(ch, CURLOPT_HEADERDATA, handler);
+#if DEBUG_COOKIES
+	fprintf(stderr, "CURLOPT_SHARE: %p\n", curl->handle->share);
+#endif
+	curl_easy_setopt(ch, CURLOPT_SHARE, curl->handle->share);
 
 	return SUCCESS;
 }
@@ -2111,7 +2241,6 @@ static ZEND_RESULT_CODE php_http_client_curl_handler_reset(php_http_client_curl_
 static php_http_client_curl_handler_t *php_http_client_curl_handler_init(php_http_client_t *h, php_resource_factory_t *rf)
 {
 	void *handle;
-	php_http_client_curl_t *curl = h->ctx;
 	php_http_client_curl_handler_t *handler;
 
 	if (!(handle = php_resource_factory_handle_ctor(rf, NULL))) {
@@ -2129,31 +2258,6 @@ static php_http_client_curl_handler_t *php_http_client_curl_handler_init(php_htt
 	php_http_buffer_init(&handler->options.ranges);
 	zend_hash_init(&handler->options.cache, 0, NULL, ZVAL_PTR_DTOR, 0);
 
-#if ZTS
-	curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1L);
-#endif
-	curl_easy_setopt(handle, CURLOPT_HEADER, 0L);
-	curl_easy_setopt(handle, CURLOPT_FILETIME, 1L);
-	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, 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_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);
-#else
-	curl_easy_setopt(handle, CURLOPT_PROGRESSFUNCTION, php_http_curle_progress_callback);
-	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);
-	curl_easy_setopt(handle, CURLOPT_SHARE, curl->handle->share);
-
 	php_http_client_curl_handler_reset(handler);
 
 	return handler;
@@ -2179,7 +2283,9 @@ static ZEND_RESULT_CODE php_http_client_curl_handler_prepare(php_http_client_cur
 	curl_easy_setopt(curl->handle, CURLOPT_URL, storage->url);
 
 	/* apply options */
-	php_http_options_apply(&php_http_curle_options, enqueue->options, curl);
+	if (SUCCESS != php_http_options_apply(&php_http_curle_options, enqueue->options, curl)) {
+		return FAILURE;
+	}
 
 	/* request headers */
 	php_http_message_update_headers(msg);
@@ -2277,11 +2383,18 @@ static void php_http_client_curl_handler_clear(php_http_client_curl_handler_t *h
 #endif
 	curl_easy_setopt(handler->handle, CURLOPT_VERBOSE, 0L);
 	curl_easy_setopt(handler->handle, CURLOPT_DEBUGFUNCTION, NULL);
+	/* see gh issue #84 */
+#if DEBUG_COOKIES
+	fprintf(stderr, "CURLOPT_COOKIELIST: FLUSH\n");
+	fprintf(stderr, "CURLOPT_SHARE: (null)\n");
+#endif
 	curl_easy_setopt(handler->handle, CURLOPT_COOKIELIST, "FLUSH");
 	curl_easy_setopt(handler->handle, CURLOPT_SHARE, NULL);
-	/* see gh issue #84 */
 #if PHP_HTTP_CURL_VERSION(7,63,0) && !PHP_HTTP_CURL_VERSION(7,65,0)
-	curl_easy_setopt(handler->handle, CURLOPT_COOKIEJAR, NULL);
+	{
+		php_http_curle_storage_t *st = php_http_curle_get_storage(handler->handle);
+		curl_easy_setopt(handler->handle, CURLOPT_COOKIEJAR, st ? st->cookiestore : NULL);
+	}
 #endif
 }
 
@@ -2362,6 +2475,17 @@ static void queue_dtor(php_http_client_enqueue_t *e)
 	php_http_client_curl_handler_dtor(handler);
 }
 
+static void retire_ch(php_persistent_handle_factory_t *f, void **handle)
+{
+	CURL *ch = *handle;
+	/* erase all cookies */
+	if (ch) {
+		curl_easy_reset(ch);
+		curl_easy_setopt(ch, CURLOPT_COOKIELIST, "ALL");
+		curl_easy_setopt(ch, CURLOPT_COOKIEFILE, NULL);
+	}
+}
+
 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;
@@ -2392,7 +2516,7 @@ static php_resource_factory_t *create_rf(php_http_client_t *h, php_http_client_e
 
 		id_len = spprintf(&id_str, 0, "%.*s:%s:%d", (int) phf->ident->len, phf->ident->val, STR_PTR(url->host), port);
 		id = php_http_cs2zs(id_str, id_len);
-		pf = php_persistent_handle_concede(NULL, PHP_HTTP_G->client.curl.driver.request_name, id, NULL, NULL);
+		pf = php_persistent_handle_concede(NULL, PHP_HTTP_G->client.curl.driver.request_name, id, NULL, retire_ch);
 		zend_string_release(id);
 	}
 
@@ -2450,6 +2574,43 @@ static ZEND_RESULT_CODE php_http_client_curl_enqueue(php_http_client_t *h, php_h
 	return SUCCESS;
 }
 
+static ZEND_RESULT_CODE php_http_client_curl_requeue(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
+{
+	CURLMcode rs;
+	php_http_client_curl_t *curl = h->ctx;
+	php_http_client_curl_handler_t *handler = enqueue->opaque;
+	php_http_client_progress_state_t *progress;
+
+	if (SUCCESS != php_http_client_curl_handler_reset(handler)) {
+		return FAILURE;
+	}
+
+	if (SUCCESS != php_http_client_curl_handler_prepare(handler, enqueue)) {
+		return FAILURE;
+	}
+
+	if (CURLM_OK != (rs = curl_multi_remove_handle(curl->handle->multi, handler->handle))) {
+		php_error_docref(NULL, E_WARNING, "Could not dequeue request: %s", curl_multi_strerror(rs));
+		return FAILURE;
+	}
+
+	if (CURLM_OK != (rs = curl_multi_add_handle(curl->handle->multi, handler->handle))) {
+		zend_llist_del_element(&h->requests, handler->handle, (int (*)(void *, void *)) compare_queue);
+		php_error_docref(NULL, E_WARNING, "Could not enqueue request: %s", curl_multi_strerror(rs));
+		return FAILURE;
+	}
+
+	++curl->unfinished;
+
+	if (h->callback.progress.func && SUCCESS == php_http_client_getopt(h, PHP_HTTP_CLIENT_OPT_PROGRESS_INFO, enqueue->request, &progress)) {
+		progress->info = "start";
+		h->callback.progress.func(h->callback.progress.arg, h, &handler->queue, progress);
+		progress->started = 1;
+	}
+
+	return SUCCESS;
+}
+
 static ZEND_RESULT_CODE php_http_client_curl_dequeue(php_http_client_t *h, php_http_client_enqueue_t *enqueue)
 {
 	CURLMcode rs;
@@ -2566,6 +2727,8 @@ static ZEND_RESULT_CODE php_http_client_curl_setopt(php_http_client_t *h, php_ht
 {
 	php_http_client_curl_t *curl = h->ctx;
 
+	(void) curl;
+
 	switch (opt) {
 		case PHP_HTTP_CLIENT_OPT_CONFIGURATION:
 			return php_http_options_apply(&php_http_curlm_options, (HashTable *) arg,  h);
@@ -2670,6 +2833,7 @@ static php_http_client_ops_t php_http_client_curl_ops = {
 	php_http_client_curl_once,
 	php_http_client_curl_enqueue,
 	php_http_client_curl_dequeue,
+	php_http_client_curl_requeue,
 	php_http_client_curl_setopt,
 	php_http_client_curl_getopt
 };