X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=php_http_curl_client.c;h=640f3bbf5cdf5365aebb45d913eabcfc1116dbe3;hp=a2e0d3fc4ceb07eb9524b0a49182e53ddf1a8032;hb=7b028d0cbb030f9610084314f67b77907d8474a2;hpb=efdbb46bf78df0d34936c536bd78b05abadd3a0d

diff --git a/php_http_curl_client.c b/php_http_curl_client.c
index a2e0d3f..640f3bb 100644
--- a/php_http_curl_client.c
+++ b/php_http_curl_client.c
@@ -12,37 +12,6 @@
 
 #include "php_http_api.h"
 
-#define PHP_HTTP_CURL_OPT_STRING(OPTION, ldiff, obdc) \
-	{ \
-		char *K = #OPTION; \
-		PHP_HTTP_CURL_OPT_STRING_EX(K+lenof("CURLOPT_KEY")+ldiff, OPTION, obdc); \
-	}
-#define PHP_HTTP_CURL_OPT_STRING_EX(keyname, optname, obdc) \
-	if (!strcasecmp(key.str, keyname)) { \
-		zval *copy = cache_option(&curl->options.cache, keyname, strlen(keyname)+1, 0, php_http_ztyp(IS_STRING, *param)); \
-		if (obdc) { \
-			if (SUCCESS != php_check_open_basedir(Z_STRVAL_P(copy) TSRMLS_CC)) { \
-				return FAILURE; \
-			} \
-		} \
-		curl_easy_setopt(ch, optname, Z_STRVAL_P(copy)); \
-		zval_ptr_dtor(&copy); \
-		continue; \
-	}
-#define PHP_HTTP_CURL_OPT_LONG(OPTION, ldiff) \
-	{ \
-		char *K = #OPTION; \
-		PHP_HTTP_CURL_OPT_LONG_EX(K+lenof("CURLOPT_KEY")+ldiff, OPTION); \
-	}
-#define PHP_HTTP_CURL_OPT_LONG_EX(keyname, optname) \
-	if (!strcasecmp(key.str, keyname)) { \
-		zval *copy = php_http_ztyp(IS_LONG, *param); \
-		curl_easy_setopt(ch, optname, Z_LVAL_P(copy)); \
-		zval_ptr_dtor(&copy); \
-		continue; \
-	}
-
-
 /* resource_factory ops */
 
 static void *php_http_curl_ctor(void *opaque TSRMLS_DC)
@@ -50,7 +19,7 @@ static void *php_http_curl_ctor(void *opaque TSRMLS_DC)
 	void *ch;
 
 	if ((ch = curl_easy_init())) {
-		get_storage(ch);
+		php_http_curl_client_get_storage(ch);
 		return ch;
 	}
 	return NULL;
@@ -62,7 +31,7 @@ static void *php_http_curl_copy(void *opaque, void *handle TSRMLS_DC)
 
 	if ((ch = curl_easy_duphandle(handle))) {
 		curl_easy_reset(ch);
-		get_storage(ch);
+		php_http_curl_client_get_storage(ch);
 		return ch;
 	}
 	return NULL;
@@ -70,7 +39,7 @@ static void *php_http_curl_copy(void *opaque, void *handle TSRMLS_DC)
 
 static void php_http_curl_dtor(void *opaque, void *handle TSRMLS_DC)
 {
-	php_http_curl_client_storage_t *st = get_storage(handle);
+	php_http_curl_client_storage_t *st = php_http_curl_client_get_storage(handle);
 
 	curl_easy_cleanup(handle);
 
@@ -175,15 +144,22 @@ static int php_http_curl_client_raw_callback(CURL *ch, curl_infotype type, char
 	switch (type) {
 		case CURLINFO_HEADER_IN:
 		case CURLINFO_DATA_IN:
-		case CURLINFO_HEADER_OUT:
-		case CURLINFO_DATA_OUT:
-			php_http_buffer_append(h->buffer, data, length);
+			php_http_buffer_append(h->response.buffer, data, length);
 
 			if (curl->options.redirects) {
 				flags |= PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS;
 			}
 
-			if (PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE == php_http_message_parser_parse(h->parser, h->buffer, flags, &h->message)) {
+			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;
@@ -204,593 +180,827 @@ static int php_http_curl_client_dummy_callback(char *data, size_t n, size_t l, v
 	return n*l;
 }
 
-static inline zval *cache_option(HashTable *cache, char *key, size_t keylen, ulong h, zval *opt)
+static STATUS get_info(CURL *ch, HashTable *info)
 {
-	Z_ADDREF_P(opt);
+	char *c;
+	long l;
+	double d;
+	struct curl_slist *s, *p;
+	zval *subarray, array;
+	INIT_PZVAL_ARRAY(&array, info);
 
-	if (h) {
-		zend_hash_quick_update(cache, key, keylen, h, &opt, sizeof(zval *), NULL);
-	} else {
-		zend_hash_update(cache, key, keylen, &opt, sizeof(zval *), NULL);
+	/* 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);
 	}
-
-	return opt;
-}
-
-static inline zval *get_option(HashTable *cache, HashTable *options, char *key, size_t keylen, int type)
-{
-	if (options) {
-		zval **zoption;
-		ulong h = zend_hash_func(key, keylen);
-
-		if (SUCCESS == zend_hash_quick_find(options, key, keylen, h, (void *) &zoption)) {
-			zval *option = php_http_ztyp(type, *zoption);
-
-			if (cache) {
-				zval *cached = cache_option(cache, key, keylen, h, option);
-
-				zval_ptr_dtor(&option);
-				return cached;
-			}
-			return option;
-		}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_RESPONSE_CODE, &l)) {
+		add_assoc_long_ex(&array, "response_code", sizeof("response_code"), l);
 	}
-
-	return NULL;
-}
-
-static STATUS set_options(php_http_client_t *h, HashTable *options)
-{
-	zval *zoption;
-	php_http_curl_client_t *curl = h->ctx;
-	CURL *ch = curl->handle;
-	TSRMLS_FETCH_FROM_CTX(h->ts);
-
-	/* proxy */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("proxyhost"), IS_STRING))) {
-		curl_easy_setopt(ch, CURLOPT_PROXY, Z_STRVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_TOTAL_TIME, &d)) {
+		add_assoc_double_ex(&array, "total_time", sizeof("total_time"), d);
 	}
-	/* type */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("proxytype"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_PROXYTYPE, Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NAMELOOKUP_TIME, &d)) {
+		add_assoc_double_ex(&array, "namelookup_time", sizeof("namelookup_time"), d);
 	}
-	/* port */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("proxyport"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_PROXYPORT, Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONNECT_TIME, &d)) {
+		add_assoc_double_ex(&array, "connect_time", sizeof("connect_time"), d);
 	}
-	/* user:pass */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("proxyauth"), IS_STRING)) && Z_STRLEN_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_PROXYUSERPWD, Z_STRVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRETRANSFER_TIME, &d)) {
+		add_assoc_double_ex(&array, "pretransfer_time", sizeof("pretransfer_time"), d);
 	}
-	/* auth method */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("proxyauthtype"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_PROXYAUTH, Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_UPLOAD, &d)) {
+		add_assoc_double_ex(&array, "size_upload", sizeof("size_upload"), d);
 	}
-	/* tunnel */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("proxytunnel"), IS_BOOL)) && Z_BVAL_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_HTTPPROXYTUNNEL, 1L);
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_DOWNLOAD, &d)) {
+		add_assoc_double_ex(&array, "size_download", sizeof("size_download"), d);
 	}
-#if PHP_HTTP_CURL_VERSION(7,19,4)
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("noproxy"), IS_STRING))) {
-		curl_easy_setopt(ch, CURLOPT_NOPROXY, Z_STRVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SPEED_DOWNLOAD, &d)) {
+		add_assoc_double_ex(&array, "speed_download", sizeof("speed_download"), d);
 	}
-#endif
-
-	/* dns */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("dns_cache_timeout"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_DNS_CACHE_TIMEOUT, Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SPEED_UPLOAD, &d)) {
+		add_assoc_double_ex(&array, "speed_upload", sizeof("speed_upload"), d);
 	}
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("ipresolve"), IS_LONG)) && Z_LVAL_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_IPRESOLVE, Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HEADER_SIZE, &l)) {
+		add_assoc_long_ex(&array, "header_size", sizeof("header_size"), l);
 	}
-#if PHP_HTTP_CURL_VERSION(7,21,3)
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("resolve"), IS_ARRAY))) {
-		php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
-		HashPosition pos;
-		zval **data;
-
-		FOREACH_KEYVAL(pos, zoption, 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);
-		}
-
-		curl_easy_setopt(ch, CURLOPT_RESOLVE, curl->options.resolve);
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REQUEST_SIZE, &l)) {
+		add_assoc_long_ex(&array, "request_size", sizeof("request_size"), l);
 	}
-#endif
-#if PHP_HTTP_CURL_VERSION(7,24,0)
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("dns_servers"), IS_STRING)) && Z_STRLEN_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_DNS_SERVERS, Z_STRVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SSL_VERIFYRESULT, &l)) {
+		add_assoc_long_ex(&array, "ssl_verifyresult", sizeof("ssl_verifyresult"), l);
 	}
-#endif
-
-	/* limits */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("low_speed_limit"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_LOW_SPEED_LIMIT, Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_FILETIME, &l)) {
+		add_assoc_long_ex(&array, "filetime", sizeof("filetime"), l);
 	}
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("low_speed_time"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_LOW_SPEED_TIME, Z_LVAL_P(zoption));
+	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);
 	}
-	/* LSF weirdance
-	if ((zoption = get_option(&curl->cache.options, options, ZEND_STRS("max_send_speed"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_MAX_SEND_SPEED_LARGE, (curl_off_t) Z_LVAL_P(zoption));
+	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);
 	}
-	if ((zoption = get_option(&curl->cache.options, options, ZEND_STRS("max_recv_speed"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_MAX_RECV_SPEED_LARGE, (curl_off_t) Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_STARTTRANSFER_TIME, &d)) {
+		add_assoc_double_ex(&array, "starttransfer_time", sizeof("starttransfer_time"), d);
 	}
-	*/
-	/* crashes
-	if ((zoption = get_option(&curl->cache.options, options, ZEND_STRS("maxconnects"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_MAXCONNECTS, Z_LVAL_P(zoption));
-	} */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("fresh_connect"), IS_BOOL)) && Z_BVAL_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_FRESH_CONNECT, 1L);
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONTENT_TYPE, &c)) {
+		add_assoc_string_ex(&array, "content_type", sizeof("content_type"), c ? c : "", 1);
 	}
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("forbid_reuse"), IS_BOOL)) && Z_BVAL_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_FORBID_REUSE, 1L);
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_TIME, &d)) {
+		add_assoc_double_ex(&array, "redirect_time", sizeof("redirect_time"), d);
 	}
-
-	/* outgoing interface */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("interface"), IS_STRING))) {
-		curl_easy_setopt(ch, CURLOPT_INTERFACE, Z_STRVAL_P(zoption));
-	}
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("portrange"), IS_ARRAY))) {
-		zval **prs, **pre;
-
-		zend_hash_internal_pointer_reset(Z_ARRVAL_P(zoption));
-		if (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zoption), (void *) &prs)) {
-			zend_hash_move_forward(Z_ARRVAL_P(zoption));
-			if (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zoption), (void *) &pre)) {
-				zval *prs_cpy = php_http_ztyp(IS_LONG, *prs);
-				zval *pre_cpy = php_http_ztyp(IS_LONG, *pre);
-
-				if (Z_LVAL_P(prs_cpy) && Z_LVAL_P(pre_cpy)) {
-					curl_easy_setopt(ch, CURLOPT_LOCALPORT, MIN(Z_LVAL_P(prs_cpy), Z_LVAL_P(pre_cpy)));
-					curl_easy_setopt(ch, CURLOPT_LOCALPORTRANGE, labs(Z_LVAL_P(prs_cpy)-Z_LVAL_P(pre_cpy))+1L);
-				}
-				zval_ptr_dtor(&prs_cpy);
-				zval_ptr_dtor(&pre_cpy);
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_COUNT, &l)) {
+		add_assoc_long_ex(&array, "redirect_count", sizeof("redirect_count"), l);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTP_CONNECTCODE, &l)) {
+		add_assoc_long_ex(&array, "connect_code", sizeof("connect_code"), l);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTPAUTH_AVAIL, &l)) {
+		add_assoc_long_ex(&array, "httpauth_avail", sizeof("httpauth_avail"), l);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PROXYAUTH_AVAIL, &l)) {
+		add_assoc_long_ex(&array, "proxyauth_avail", sizeof("proxyauth_avail"), l);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_OS_ERRNO, &l)) {
+		add_assoc_long_ex(&array, "os_errno", sizeof("os_errno"), l);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NUM_CONNECTS, &l)) {
+		add_assoc_long_ex(&array, "num_connects", sizeof("num_connects"), l);
+	}
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SSL_ENGINES, &s)) {
+		MAKE_STD_ZVAL(subarray);
+		array_init(subarray);
+		for (p = s; p; p = p->next) {
+			if (p->data) {
+				add_next_index_string(subarray, p->data, 1);
 			}
 		}
+		add_assoc_zval_ex(&array, "ssl_engines", sizeof("ssl_engines"), subarray);
+		curl_slist_free_all(s);
 	}
-
-	/* another port */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("port"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_PORT, Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_COOKIELIST, &s)) {
+		MAKE_STD_ZVAL(subarray);
+		array_init(subarray);
+		for (p = s; p; p = p->next) {
+			if (p->data) {
+				add_next_index_string(subarray, p->data, 1);
+			}
+		}
+		add_assoc_zval_ex(&array, "cookies", sizeof("cookies"), subarray);
+		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);
 	}
-
-	/* RFC4007 zone_id */
 #if PHP_HTTP_CURL_VERSION(7,19,0)
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("address_scope"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_ADDRESS_SCOPE, Z_LVAL_P(zoption));
+	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRIMARY_IP, &c)) {
+		add_assoc_string_ex(&array, "primary_ip", sizeof("primary_ip"), c ? c : "", 1);
 	}
 #endif
-
-	/* auth */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("httpauth"), IS_STRING)) && Z_STRLEN_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_USERPWD, Z_STRVAL_P(zoption));
+#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);
 	}
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("httpauthtype"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_HTTPAUTH, Z_LVAL_P(zoption));
+#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);
 	}
-
-	/* redirects, defaults to 0 */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("redirect"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_FOLLOWLOCATION, Z_LVAL_P(zoption) ? 1L : 0L);
-		curl_easy_setopt(ch, CURLOPT_MAXREDIRS, curl->options.redirects = Z_LVAL_P(zoption));
-		if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("unrestrictedauth"), IS_BOOL))) {
-			curl_easy_setopt(ch, CURLOPT_UNRESTRICTED_AUTH, Z_LVAL_P(zoption));
-		}
-		if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("postredir"), IS_BOOL))) {
-#if PHP_HTTP_CURL_VERSION(7,19,1)
-			curl_easy_setopt(ch, CURLOPT_POSTREDIR, Z_BVAL_P(zoption) ? 1L : 0L);
-#else
-			curl_easy_setopt(ch, CURLOPT_POST301, Z_BVAL_P(zoption) ? 1L : 0L);
 #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);
 	}
-
-	/* retries, defaults to 0 */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("retrycount"), IS_LONG))) {
-		curl->options.retry.count = Z_LVAL_P(zoption);
-		if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("retrydelay"), IS_DOUBLE))) {
-			curl->options.retry.delay = Z_DVAL_P(zoption);
-		}
+#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);
 	}
-
-	/* referer */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("referer"), IS_STRING)) && Z_STRLEN_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_REFERER, Z_STRVAL_P(zoption));
+#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);
 	}
+#endif
 
-	/* useragent, default "PECL::HTTP/version (PHP/version)" */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("useragent"), IS_STRING))) {
-		/* allow to send no user agent, not even default one */
-		if (Z_STRLEN_P(zoption)) {
-			curl_easy_setopt(ch, CURLOPT_USERAGENT, Z_STRVAL_P(zoption));
-		} else {
-			curl_easy_setopt(ch, CURLOPT_USERAGENT, NULL);
-		}
-	}
+	/* END::CURLINFO */
 
-	/* resume */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("resume"), IS_LONG)) && (Z_LVAL_P(zoption) > 0)) {
-		curl->options.range_request = 1;
-		curl_easy_setopt(ch, CURLOPT_RESUME_FROM, Z_LVAL_P(zoption));
-	}
-	/* or range of kind array(array(0,499), array(100,1499)) */
-	else if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("range"), IS_ARRAY)) && zend_hash_num_elements(Z_ARRVAL_P(zoption))) {
-		HashPosition pos1, pos2;
-		zval **rr, **rb, **re;
-		php_http_buffer_t rs;
+#if PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)
+	{
+		int i;
+		zval *ci_array;
+		struct curl_certinfo *ci;
+		char *colon, *keyname;
 
-		php_http_buffer_init(&rs);
-		FOREACH_VAL(pos1, zoption, rr) {
-			if (Z_TYPE_PP(rr) == IS_ARRAY) {
-				zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(rr), &pos2);
-				if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(rr), (void *) &rb, &pos2)) {
-					zend_hash_move_forward_ex(Z_ARRVAL_PP(rr), &pos2);
-					if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(rr), (void *) &re, &pos2)) {
-						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(&rs, "%ld-%ld,", Z_LVAL_P(rbl), Z_LVAL_P(rel));
-							}
-							zval_ptr_dtor(&rbl);
-							zval_ptr_dtor(&rel);
+		if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CERTINFO, &ci)) {
+			MAKE_STD_ZVAL(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);
+				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);
+							efree(keyname);
+						} else {
+							add_next_index_string(subarray, p->data, 1);
 						}
 					}
 				}
+				add_next_index_zval(ci_array, subarray);
 			}
+			add_assoc_zval_ex(&array, "certinfo", sizeof("certinfo"), ci_array);
 		}
+	}
+#endif
+	add_assoc_string_ex(&array, "error", sizeof("error"), php_http_curl_client_get_storage(ch)->errorbuffer, 1);
 
-		if (PHP_HTTP_BUFFER_LEN(&rs)) {
-			zval *cached_range;
+	return SUCCESS;
+}
 
-			curl->options.range_request = 1;
-			/* ditch last comma */
-			PHP_HTTP_BUFFER_VAL(&rs)[PHP_HTTP_BUFFER_LEN(&rs)-- -1] = '\0';
-			/* cache string */
-			MAKE_STD_ZVAL(cached_range);
-			ZVAL_STRINGL(cached_range, PHP_HTTP_BUFFER_VAL(&rs), PHP_HTTP_BUFFER_LEN(&rs), 0);
-			curl_easy_setopt(ch, CURLOPT_RANGE, Z_STRVAL_P(cache_option(&curl->options.cache, ZEND_STRS("range"), 0, cached_range)));
-			zval_ptr_dtor(&cached_range);
-		}
-	}
+/* curl client options */
 
-	/* etag */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("etag"), IS_STRING)) && Z_STRLEN_P(zoption)) {
-		zend_bool is_quoted = !((Z_STRVAL_P(zoption)[0] != '"') || (Z_STRVAL_P(zoption)[Z_STRLEN_P(zoption)-1] != '"'));
-		php_http_buffer_t header;
+static php_http_options_t php_http_curl_client_options;
 
-		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(zoption));
-		php_http_buffer_fix(&header);
-		curl->options.headers = curl_slist_append(curl->options.headers, PHP_HTTP_BUFFER_VAL(&header));
-		php_http_buffer_dtor(&header);
-	}
-	/* compression */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("compress"), IS_BOOL)) && Z_LVAL_P(zoption)) {
-		curl->options.headers = curl_slist_append(curl->options.headers, "Accept-Encoding: gzip;q=1.0,deflate;q=0.5");
+#define PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN	0x0001
+#define PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR	0x0002
+#define PHP_HTTP_CURL_CLIENT_OPTION_TRANSFORM_MS	0x0004
+
+static STATUS php_http_curl_client_option_set_ssl_verifyhost(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+
+	if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_SSL_VERIFYHOST, Z_BVAL_P(val) ? 2 : 0)) {
+		return FAILURE;
 	}
-	curl_easy_setopt(ch, CURLOPT_HTTPHEADER, curl->options.headers);
+	return SUCCESS;
+}
 
-	/* lastmodified */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("lastmodified"), IS_LONG))) {
-		if (Z_LVAL_P(zoption)) {
-			if (Z_LVAL_P(zoption) > 0) {
-				curl_easy_setopt(ch, CURLOPT_TIMEVALUE, Z_LVAL_P(zoption));
-			} else {
-				curl_easy_setopt(ch, CURLOPT_TIMEVALUE, (long) PHP_HTTP_G->env.request.time + Z_LVAL_P(zoption));
-			}
-			curl_easy_setopt(ch, CURLOPT_TIMECONDITION, (long) (curl->options.range_request ? CURL_TIMECOND_IFUNMODSINCE : CURL_TIMECOND_IFMODSINCE));
-		} else {
-			curl_easy_setopt(ch, CURLOPT_TIMECONDITION, CURL_TIMECOND_NONE);
+static STATUS php_http_curl_client_option_set_cookiestore(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+
+	if (val) {
+		php_http_curl_client_storage_t *storage = php_http_curl_client_get_storage(curl->handle);
+
+		if (storage->cookiestore) {
+			pefree(storage->cookiestore, 1);
+		}
+		storage->cookiestore = pestrndup(Z_STRVAL_P(val), Z_STRLEN_P(val), 1);
+		if (	CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIEFILE, storage->cookiestore)
+			||	CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIEJAR, storage->cookiestore)
+		) {
+			return FAILURE;
 		}
 	}
+	return SUCCESS;
+}
+
+static STATUS php_http_curl_client_option_set_cookies(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+	TSRMLS_FETCH_FROM_CTX(h->ts);
 
-	/* cookies, array('name' => 'value') */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("cookies"), IS_ARRAY))) {
-		if (zend_hash_num_elements(Z_ARRVAL_P(zoption))) {
-			zval *urlenc_cookies = NULL;
-			/* check whether cookies should not be urlencoded; default is to urlencode them */
-			if ((!(urlenc_cookies = get_option(&curl->options.cache, options, ZEND_STRS("encodecookies"), IS_BOOL))) || Z_BVAL_P(urlenc_cookies)) {
-				if (SUCCESS == php_http_url_encode_hash_ex(HASH_OF(zoption), &curl->options.cookies, ZEND_STRL(";"), ZEND_STRL("="), NULL, 0 TSRMLS_CC)) {
-					php_http_buffer_fix(&curl->options.cookies);
-					curl_easy_setopt(ch, CURLOPT_COOKIE, curl->options.cookies.data);
+	if (val && Z_TYPE_P(val) != IS_NULL) {
+		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)) {
+				php_http_buffer_fix(&curl->options.cookies);
+				if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIE, curl->options.cookies.data)) {
+					return FAILURE;
 				}
 			} else {
-				HashPosition pos;
-				php_http_array_hashkey_t cookie_key = php_http_array_hashkey_init(0);
-				zval **cookie_val;
-
-				FOREACH_KEYVAL(pos, zoption, cookie_key, cookie_val) {
-					if (cookie_key.type == HASH_KEY_IS_STRING) {
-						zval *val = php_http_ztyp(IS_STRING, *cookie_val);
-						php_http_buffer_appendf(&curl->options.cookies, "%s=%s; ", cookie_key.str, Z_STRVAL_P(val));
-						zval_ptr_dtor(&val);
-					}
-				}
+				return FAILURE;
+			}
+		} else {
+			HashPosition pos;
+			php_http_array_hashkey_t cookie_key = php_http_array_hashkey_init(0);
+			zval **cookie_val;
 
-				php_http_buffer_fix(&curl->options.cookies);
-				if (PHP_HTTP_BUFFER_LEN(&curl->options.cookies)) {
-					curl_easy_setopt(ch, CURLOPT_COOKIE, PHP_HTTP_BUFFER_VAL(&curl->options.cookies));
+			FOREACH_KEYVAL(pos, val, cookie_key, cookie_val) {
+				zval *zv = php_http_ztyp(IS_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);
+
+				zval_ptr_dtor(&zv);
+			}
+
+			php_http_buffer_fix(&curl->options.cookies);
+			if (PHP_HTTP_BUFFER_LEN(&curl->options.cookies)) {
+				if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_COOKIE, PHP_HTTP_BUFFER_VAL(&curl->options.cookies))) {
+					return FAILURE;
 				}
 			}
 		}
 	}
+	return SUCCESS;
+}
 
-	/* don't load session cookies from cookiestore */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("cookiesession"), IS_BOOL)) && Z_BVAL_P(zoption)) {
-		curl_easy_setopt(ch, CURLOPT_COOKIESESSION, 1L);
-	}
+static STATUS php_http_curl_client_option_set_encodecookies(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
 
-	/* cookiestore, read initial cookies from that file and store cookies back into that file */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("cookiestore"), IS_STRING))) {
-		php_http_curl_client_storage_t *storage = get_storage(curl->handle);
+	curl->options.encode_cookies = Z_BVAL_P(val);
+	return SUCCESS;
+}
+
+static STATUS php_http_curl_client_option_set_lastmodified(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+	TSRMLS_FETCH_FROM_CTX(h->ts);
 
-		if (Z_STRLEN_P(zoption)) {
-			if (SUCCESS != php_check_open_basedir(Z_STRVAL_P(zoption) TSRMLS_CC)) {
+	if (Z_LVAL_P(val)) {
+		if (Z_LVAL_P(val) > 0) {
+			if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, Z_LVAL_P(val))) {
+				return FAILURE;
+			}
+		} else {
+			if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, (long) PHP_HTTP_G->env.request.time + Z_LVAL_P(val))) {
 				return FAILURE;
 			}
 		}
-		if (storage->cookiestore) {
-			pefree(storage->cookiestore, 1);
+		if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMECONDITION, (long) (curl->options.range_request ? CURL_TIMECOND_IFUNMODSINCE : CURL_TIMECOND_IFMODSINCE))) {
+			return FAILURE;
+		}
+	} else {
+		if (	CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMEVALUE, 0)
+			||	CURLE_OK != curl_easy_setopt(ch, CURLOPT_TIMECONDITION, 0)
+		) {
+			return FAILURE;
 		}
-		storage->cookiestore = pestrndup(Z_STRVAL_P(zoption), Z_STRLEN_P(zoption), 1);
-		curl_easy_setopt(ch, CURLOPT_COOKIEFILE, storage->cookiestore);
-		curl_easy_setopt(ch, CURLOPT_COOKIEJAR, storage->cookiestore);
 	}
+	return SUCCESS;
+}
 
-	/* maxfilesize */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("maxfilesize"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_MAXFILESIZE, Z_LVAL_P(zoption));
+static STATUS php_http_curl_client_option_set_compress(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+
+	if (Z_BVAL_P(val)) {
+		curl->options.headers = curl_slist_append(curl->options.headers, "Accept-Encoding: gzip;q=1.0,deflate;q=0.5");
+	}
+	return SUCCESS;
+}
+
+static STATUS php_http_curl_client_option_set_etag(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	php_http_buffer_t header;
+	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_buffer_fix(&header);
+	curl->options.headers = curl_slist_append(curl->options.headers, PHP_HTTP_BUFFER_VAL(&header));
+	php_http_buffer_dtor(&header);
+	return SUCCESS;
+}
+
+static STATUS php_http_curl_client_option_set_range(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+	TSRMLS_FETCH_FROM_CTX(h->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_ptr_dtor(&rbl);
+						zval_ptr_dtor(&rel);
+					}
+
+				}
+			}
+		}
+
+		if (PHP_HTTP_BUFFER_LEN(&curl->options.ranges)) {
+			curl->options.range_request = 1;
+			/* ditch last comma */
+			PHP_HTTP_BUFFER_VAL(&curl->options.ranges)[PHP_HTTP_BUFFER_LEN(&curl->options.ranges)-- -1] = '\0';
+		}
 	}
 
-	/* http protocol */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("protocol"), IS_LONG))) {
-		curl_easy_setopt(ch, CURLOPT_HTTP_VERSION, Z_LVAL_P(zoption));
+	if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_RANGE, PHP_HTTP_BUFFER_VAL(&curl->options.ranges))) {
+		return FAILURE;
 	}
+	return SUCCESS;
+}
 
-	/* timeout, defaults to 0 */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("timeout"), IS_DOUBLE))) {
-		curl_easy_setopt(ch, CURLOPT_TIMEOUT_MS, (long)(Z_DVAL_P(zoption)*1000));
+static STATUS php_http_curl_client_option_set_resume(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+
+	if (Z_LVAL_P(val) > 0) {
+		curl->options.range_request = 1;
 	}
-	/* connecttimeout, defaults to 0 */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("connecttimeout"), IS_DOUBLE))) {
-		curl_easy_setopt(ch, CURLOPT_CONNECTTIMEOUT_MS, (long)(Z_DVAL_P(zoption)*1000));
+	if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_RESUME_FROM, Z_LVAL_P(val))) {
+		return FAILURE;
 	}
+	return SUCCESS;
+}
 
-	/* ssl */
-	if ((zoption = get_option(&curl->options.cache, options, ZEND_STRS("ssl"), IS_ARRAY))) {
-		php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
-		zval **param;
-		HashPosition pos;
+static STATUS php_http_curl_client_option_set_retrydelay(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
 
-		FOREACH_KEYVAL(pos, zoption, key, param) {
-			if (key.type == HASH_KEY_IS_STRING) {
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_SSLCERT, 0, 1);
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_SSLCERTTYPE, 0, 0);
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_SSLCERTPASSWD, 0, 0);
+	curl->options.retry.delay = Z_DVAL_P(val);
+	return SUCCESS;
+}
 
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_SSLKEY, 0, 0);
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_SSLKEYTYPE, 0, 0);
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_SSLKEYPASSWD, 0, 0);
+static STATUS php_http_curl_client_option_set_retrycount(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
 
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_SSLENGINE, 0, 0);
-				PHP_HTTP_CURL_OPT_LONG(CURLOPT_SSLVERSION, 0);
+	curl->options.retry.count = Z_LVAL_P(val);
+	return SUCCESS;
+}
 
-				PHP_HTTP_CURL_OPT_LONG(CURLOPT_SSL_VERIFYPEER, 1);
-				PHP_HTTP_CURL_OPT_LONG(CURLOPT_SSL_VERIFYHOST, 1);
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_SSL_CIPHER_LIST, 1, 0);
+static STATUS php_http_curl_client_option_set_redirect(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
 
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_CAINFO, -3, 1);
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_CAPATH, -3, 1);
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_RANDOM_FILE, -3, 1);
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_EGDSOCKET, -3, 1);
-#if PHP_HTTP_CURL_VERSION(7,19,0)
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_ISSUERCERT, -3, 1);
-	#if defined(PHP_HTTP_HAVE_OPENSSL)
-				PHP_HTTP_CURL_OPT_STRING(CURLOPT_CRLFILE, -3, 1);
-	#endif
-#endif
-#if PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)
-				PHP_HTTP_CURL_OPT_LONG(CURLOPT_CERTINFO, -3);
-#endif
-			}
-		}
+	if (	CURLE_OK != curl_easy_setopt(ch, CURLOPT_FOLLOWLOCATION, Z_LVAL_P(val) ? 1L : 0L)
+		||	CURLE_OK != curl_easy_setopt(ch, CURLOPT_MAXREDIRS, curl->options.redirects = Z_LVAL_P(val))
+	) {
+		return FAILURE;
 	}
 	return SUCCESS;
 }
 
-static STATUS get_info(CURL *ch, HashTable *info)
+static STATUS php_http_curl_client_option_set_portrange(php_http_option_t *opt, zval *val, void *userdata)
 {
-	char *c;
-	long l;
-	double d;
-	struct curl_slist *s, *p;
-	zval *subarray, array;
-	INIT_PZVAL_ARRAY(&array, info);
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+	long localport = 0, localportrange = 0;
+	TSRMLS_FETCH_FROM_CTX(h->ts);
 
-	/* 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);
-	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_RESPONSE_CODE, &l)) {
-		add_assoc_long_ex(&array, "response_code", sizeof("response_code"), l);
+	if (val && Z_TYPE_P(val) != IS_NULL) {
+		zval **z_port_start, *zps_copy = NULL, **z_port_end, *zpe_copy = NULL;
+
+		switch (php_http_array_list(Z_ARRVAL_P(val) TSRMLS_CC, 2, &z_port_start, &z_port_end)) {
+		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;
+			/* 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);
+			}
+			break;
+		default:
+			break;
+		}
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_TOTAL_TIME, &d)) {
-		add_assoc_double_ex(&array, "total_time", sizeof("total_time"), d);
+	if (	CURLE_OK != curl_easy_setopt(ch, CURLOPT_LOCALPORT, localport)
+		||	CURLE_OK != curl_easy_setopt(ch, CURLOPT_LOCALPORTRANGE, localportrange)
+	) {
+		return FAILURE;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NAMELOOKUP_TIME, &d)) {
-		add_assoc_double_ex(&array, "namelookup_time", sizeof("namelookup_time"), d);
+	return SUCCESS;
+}
+
+static STATUS php_http_curl_client_option_set_resolve(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+	TSRMLS_FETCH_FROM_CTX(h->ts);
+
+	if (val && Z_TYPE_P(val) != IS_NULL) {
+		php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
+		HashPosition pos;
+		zval **data;
+
+		FOREACH_KEYVAL(pos, val, key, data) {
+			zval *cpy = php_http_ztyp(IS_STRING, *data);
+			curl->options.resolve = curl_slist_append(curl->options.resolve, Z_STRVAL_P(cpy));
+			zval_ptr_dtor(&cpy);
+		}
+
+		if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_RESOLVE, curl->options.resolve)) {
+			return FAILURE;
+		}
+	} else {
+		if (CURLE_OK != curl_easy_setopt(ch, CURLOPT_RESOLVE, NULL)) {
+			return FAILURE;
+		}
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONNECT_TIME, &d)) {
-		add_assoc_double_ex(&array, "connect_time", sizeof("connect_time"), d);
+	return SUCCESS;
+}
+
+static void php_http_curl_client_options_init(php_http_options_t *registry TSRMLS_DC)
+{
+	php_http_option_t *opt;
+
+	/* proxy */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("proxyhost"), CURLOPT_PROXY, IS_STRING))) {
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PRETRANSFER_TIME, &d)) {
-		add_assoc_double_ex(&array, "pretransfer_time", sizeof("pretransfer_time"), d);
+	php_http_option_register(registry, ZEND_STRL("proxytype"), CURLOPT_PROXYTYPE, IS_LONG);
+	php_http_option_register(registry, ZEND_STRL("proxyport"), CURLOPT_PROXYPORT, IS_LONG);
+	if ((opt = php_http_option_register(registry, ZEND_STRL("proxyauth"), CURLOPT_PROXYUSERPWD, IS_STRING))) {
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_UPLOAD, &d)) {
-		add_assoc_double_ex(&array, "size_upload", sizeof("size_upload"), d);
+	php_http_option_register(registry, ZEND_STRL("proxyauthtype"), CURLOPT_PROXYAUTH, IS_LONG);
+	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
+
+	/* dns */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("dns_cache_timeout"), CURLOPT_DNS_CACHE_TIMEOUT, IS_LONG))) {
+		Z_LVAL(opt->defval) = 60;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SIZE_DOWNLOAD, &d)) {
-		add_assoc_double_ex(&array, "size_download", sizeof("size_download"), d);
+	php_http_option_register(registry, ZEND_STRL("ipresolve"), CURLOPT_IPRESOLVE, IS_LONG);
+#if PHP_HTTP_CURL_VERSION(7,21,3)
+	if ((opt = php_http_option_register(registry, ZEND_STRL("resolve"), CURLOPT_RESOLVE, IS_ARRAY))) {
+		opt->setter = php_http_curl_client_option_set_resolve;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SPEED_DOWNLOAD, &d)) {
-		add_assoc_double_ex(&array, "speed_download", sizeof("speed_download"), d);
+#endif
+#if PHP_HTTP_CURL_VERSION(7,24,0)
+	if ((opt = php_http_option_register(registry, ZEND_STRL("dns_servers"), CURLOPT_DNS_SERVERS, IS_STRING))) {
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SPEED_UPLOAD, &d)) {
-		add_assoc_double_ex(&array, "speed_upload", sizeof("speed_upload"), d);
+#endif
+
+	/* limits */
+	php_http_option_register(registry, ZEND_STRL("low_speed_limit"), CURLOPT_LOW_SPEED_LIMIT, IS_LONG);
+	php_http_option_register(registry, ZEND_STRL("low_speed_time"), CURLOPT_LOW_SPEED_TIME, IS_LONG);
+
+	/* LSF weirdance
+	php_http_option_register(registry, ZEND_STRL("max_send_speed"), CURLOPT_MAX_SEND_SPEED_LARGE, IS_LONG);
+	php_http_option_register(registry, ZEND_STRL("max_recv_speed"), CURLOPT_MAX_RECV_SPEED_LARGE, IS_LONG);
+	*/
+
+	/* connection handling */
+	/* crashes
+	if ((opt = php_http_option_register(registry, ZEND_STRL("maxconnects"), CURLOPT_MAXCONNECTS, IS_LONG))) {
+		Z_LVAL(opt->defval) = 5;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HEADER_SIZE, &l)) {
-		add_assoc_long_ex(&array, "header_size", sizeof("header_size"), l);
+	*/
+	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("portrange"), CURLOPT_LOCALPORT, IS_ARRAY))) {
+		opt->setter = php_http_curl_client_option_set_portrange;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REQUEST_SIZE, &l)) {
-		add_assoc_long_ex(&array, "request_size", sizeof("request_size"), l);
+
+	/* another endpoint port */
+	php_http_option_register(registry, ZEND_STRL("port"), CURLOPT_PORT, IS_LONG);
+
+	/* RFC4007 zone_id */
+#if PHP_HTTP_CURL_VERSION(7,19,0)
+	php_http_option_register(registry, ZEND_STRL("address_scope"), CURLOPT_ADDRESS_SCOPE, IS_LONG);
+#endif
+
+	/* auth */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("httpauth"), CURLOPT_USERPWD, IS_STRING))) {
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SSL_VERIFYRESULT, &l)) {
-		add_assoc_long_ex(&array, "ssl_verifyresult", sizeof("ssl_verifyresult"), l);
+	php_http_option_register(registry, ZEND_STRL("httpauthtype"), CURLOPT_HTTPAUTH, IS_LONG);
+
+	/* redirects */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("redirect"), CURLOPT_FOLLOWLOCATION, IS_LONG))) {
+		opt->setter = php_http_curl_client_option_set_redirect;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_FILETIME, &l)) {
-		add_assoc_long_ex(&array, "filetime", sizeof("filetime"), l);
+	php_http_option_register(registry, ZEND_STRL("unrestrictedauth"), CURLOPT_UNRESTRICTED_AUTH, IS_BOOL);
+#if PHP_HTTP_CURL_VERSION(7,19,1)
+	php_http_option_register(registry, ZEND_STRL("postredir"), CURLOPT_POSTREDIR, IS_BOOL);
+#else
+	php_http_option_register(registry, ZEND_STRL("postredir"), CURLOPT_POST301, IS_BOOL);
+#endif
+
+	/* retries */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("retrycount"), 0, IS_LONG))) {
+		opt->setter = php_http_curl_client_option_set_retrycount;
 	}
-	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);
+	if ((opt = php_http_option_register(registry, ZEND_STRL("retrydelay"), 0, IS_DOUBLE))) {
+		opt->setter = php_http_curl_client_option_set_retrydelay;
 	}
-	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);
+
+	/* referer */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("referer"), CURLOPT_REFERER, IS_STRING))) {
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_STARTTRANSFER_TIME, &d)) {
-		add_assoc_double_ex(&array, "starttransfer_time", sizeof("starttransfer_time"), d);
+	if ((opt = php_http_option_register(registry, ZEND_STRL("autoreferer"), CURLOPT_AUTOREFERER, IS_BOOL))) {
+		ZVAL_BOOL(&opt->defval, 1);
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CONTENT_TYPE, &c)) {
-		add_assoc_string_ex(&array, "content_type", sizeof("content_type"), c ? c : "", 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, "PECL::HTTP/" PHP_HTTP_EXT_VERSION " (PHP/" PHP_VERSION ")", 0);
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_TIME, &d)) {
-		add_assoc_double_ex(&array, "redirect_time", sizeof("redirect_time"), d);
+
+	/* resume */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("resume"), CURLOPT_RESUME_FROM, IS_LONG))) {
+		opt->setter = php_http_curl_client_option_set_resume;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_COUNT, &l)) {
-		add_assoc_long_ex(&array, "redirect_count", sizeof("redirect_count"), l);
+	/* ranges */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("range"), CURLOPT_RANGE, IS_ARRAY))) {
+		opt->setter = php_http_curl_client_option_set_range;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTP_CONNECTCODE, &l)) {
-		add_assoc_long_ex(&array, "connect_code", sizeof("connect_code"), l);
+
+	/* etag */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("etag"), 0, IS_STRING))) {
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
+		opt->setter = php_http_curl_client_option_set_etag;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_HTTPAUTH_AVAIL, &l)) {
-		add_assoc_long_ex(&array, "httpauth_avail", sizeof("httpauth_avail"), l);
+
+	/* compression */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("compress"), 0, IS_BOOL))) {
+		opt->setter = php_http_curl_client_option_set_compress;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_PROXYAUTH_AVAIL, &l)) {
-		add_assoc_long_ex(&array, "proxyauth_avail", sizeof("proxyauth_avail"), l);
+
+	/* lastmodified */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("lastmodified"), 0, IS_LONG))) {
+		opt->setter = php_http_curl_client_option_set_lastmodified;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_OS_ERRNO, &l)) {
-		add_assoc_long_ex(&array, "os_errno", sizeof("os_errno"), l);
+
+	/* cookies */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("encodecookies"), 0, IS_BOOL))) {
+		opt->setter = php_http_curl_client_option_set_encodecookies;
+		ZVAL_BOOL(&opt->defval, 1);
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_NUM_CONNECTS, &l)) {
-		add_assoc_long_ex(&array, "num_connects", sizeof("num_connects"), l);
+	if ((opt = php_http_option_register(registry, ZEND_STRL("cookies"), 0, IS_ARRAY))) {
+		opt->setter = php_http_curl_client_option_set_cookies;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_SSL_ENGINES, &s)) {
-		MAKE_STD_ZVAL(subarray);
-		array_init(subarray);
-		for (p = s; p; p = p->next) {
-			if (p->data) {
-				add_next_index_string(subarray, p->data, 1);
-			}
-		}
-		add_assoc_zval_ex(&array, "ssl_engines", sizeof("ssl_engines"), subarray);
-		curl_slist_free_all(s);
+
+	/* cookiesession, don't load session cookies from cookiestore */
+	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_CURL_CLIENT_OPTION_CHECK_STRLEN;
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+		opt->setter = php_http_curl_client_option_set_cookiestore;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_COOKIELIST, &s)) {
-		MAKE_STD_ZVAL(subarray);
-		array_init(subarray);
-		for (p = s; p; p = p->next) {
-			if (p->data) {
-				add_next_index_string(subarray, p->data, 1);
-			}
-		}
-		add_assoc_zval_ex(&array, "cookies", sizeof("cookies"), subarray);
-		curl_slist_free_all(s);
+
+	/* maxfilesize */
+	php_http_option_register(registry, ZEND_STRL("maxfilesize"), CURLOPT_MAXFILESIZE, IS_LONG);
+
+	/* http protocol version */
+	php_http_option_register(registry, ZEND_STRL("protocol"), CURLOPT_HTTP_VERSION, IS_LONG);
+
+	/* timeouts */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("timeout"), CURLOPT_TIMEOUT_MS, IS_DOUBLE))) {
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_TRANSFORM_MS;
 	}
-	if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_REDIRECT_URL, &c)) {
-		add_assoc_string_ex(&array, "redirect_url", sizeof("redirect_url"), c ? c : "", 1);
+	if ((opt = php_http_option_register(registry, ZEND_STRL("connecttimeout"), CURLOPT_CONNECTTIMEOUT_MS, IS_DOUBLE))) {
+		opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_TRANSFORM_MS;
+		Z_DVAL(opt->defval) = 3;
 	}
-#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);
+
+	/* tcp */
+#if PHP_HTTP_CURL_VERSION(7,25,0)
+	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;
 	}
-#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);
+	if ((opt = php_http_option_register(registry, ZEND_STRL("tcp_keepintvl"), CURLOPT_TCP_KEEPINTVL, IS_LONG))) {
+		Z_LVAL(opt->defval) = 60;
 	}
 #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);
-	}
+
+	/* ssl */
+	if ((opt = php_http_option_register(registry, ZEND_STRL("ssl"), 0, IS_ARRAY))) {
+		registry = &opt->suboptions;
+
+		if ((opt = php_http_option_register(registry, ZEND_STRL("cert"), CURLOPT_SSLCERT, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+		}
+		php_http_option_register(registry, ZEND_STRL("certtype"), CURLOPT_SSLCERTTYPE, IS_STRING);
+		php_http_option_register(registry, ZEND_STRL("certpasswd"), CURLOPT_SSLCERTPASSWD, IS_STRING);
+
+		if ((opt = php_http_option_register(registry, ZEND_STRL("key"), CURLOPT_SSLKEY, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+		}
+		php_http_option_register(registry, ZEND_STRL("keytype"), CURLOPT_SSLKEYTYPE, IS_STRING);
+		php_http_option_register(registry, ZEND_STRL("keypasswd"), CURLOPT_SSLKEYPASSWD, IS_STRING);
+		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))) {
+			ZVAL_BOOL(&opt->defval, 1);
+		}
+		if ((opt = php_http_option_register(registry, ZEND_STRL("verifyhost"), CURLOPT_SSL_VERIFYHOST, IS_BOOL))) {
+			ZVAL_BOOL(&opt->defval, 1);
+			opt->setter = php_http_curl_client_option_set_ssl_verifyhost;
+		}
+		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_CURL_CLIENT_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+#ifdef PHP_HTTP_CURL_CAINFO
+			ZVAL_STRING(&opt->defval, PHP_HTTP_CURL_CAINFO, 0);
 #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);
-	}
+		}
+		if ((opt = php_http_option_register(registry, ZEND_STRL("capath"), CURLOPT_CAPATH, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+		}
+		if ((opt = php_http_option_register(registry, ZEND_STRL("random_file"), CURLOPT_RANDOM_FILE, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+		}
+		if ((opt = php_http_option_register(registry, ZEND_STRL("egdsocket"), CURLOPT_EGDSOCKET, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+		}
+#if PHP_HTTP_CURL_VERSION(7,19,0)
+		if ((opt = php_http_option_register(registry, ZEND_STRL("issuercert"), CURLOPT_ISSUERCERT, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+		}
+#	ifdef PHP_HTTP_HAVE_OPENSSL
+		if ((opt = php_http_option_register(registry, ZEND_STRL("crlfile"), CURLOPT_CRLFILE, IS_STRING))) {
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN;
+			opt->flags |= PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR;
+		}
+#	endif
 #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);
-	}
+#if PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)
+		php_http_option_register(registry, ZEND_STRL("certinfo"), CURLOPT_CERTINFO, IS_BOOL);
 #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);
 	}
-#endif
+}
 
-	/* END::CURLINFO */
+static zval *php_http_curl_client_get_option(php_http_option_t *opt, HashTable *options, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	zval *option;
 
-#if PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)
-	{
-		int i;
-		zval *ci_array;
-		struct curl_certinfo *ci;
-		char *colon, *keyname;
+	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);
+	}
+	return option;
+}
 
-		if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_CERTINFO, &ci)) {
-			MAKE_STD_ZVAL(ci_array);
-			array_init(ci_array);
+static STATUS php_http_curl_client_set_option(php_http_option_t *opt, zval *val, void *userdata)
+{
+	php_http_client_t *h = userdata;
+	php_http_curl_client_t *curl = h->ctx;
+	CURL *ch = curl->handle;
+	zval tmp;
+	STATUS rv = SUCCESS;
+	TSRMLS_FETCH_FROM_CTX(h->ts);
 
-			for (i = 0; i < ci->num_of_certs; ++i) {
-				s = ci->certinfo[i];
+	if (!val) {
+		val = &opt->defval;
+	}
 
-				MAKE_STD_ZVAL(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);
-							efree(keyname);
-						} else {
-							add_next_index_string(subarray, p->data, 1);
-						}
-					}
+	switch (opt->type) {
+	case IS_BOOL:
+		if (opt->setter) {
+			rv = opt->setter(opt, val, h);
+		} else if (CURLE_OK != curl_easy_setopt(ch, opt->option, (long) Z_BVAL_P(val))) {
+			rv = FAILURE;
+		}
+		break;
+
+	case IS_LONG:
+		if (opt->setter) {
+			rv = opt->setter(opt, val, h);
+		} else if (CURLE_OK != curl_easy_setopt(ch, opt->option, Z_LVAL_P(val))) {
+			rv = FAILURE;
+		}
+		break;
+
+	case IS_STRING:
+		if (!(opt->flags & PHP_HTTP_CURL_CLIENT_OPTION_CHECK_STRLEN) || Z_STRLEN_P(val)) {
+			if (!(opt->flags & PHP_HTTP_CURL_CLIENT_OPTION_CHECK_BASEDIR) || !Z_STRVAL_P(val) || SUCCESS == php_check_open_basedir(Z_STRVAL_P(val) TSRMLS_CC)) {
+				if (opt->setter) {
+					rv = opt->setter(opt, val, h);
+				} else if (CURLE_OK != curl_easy_setopt(ch, opt->option, Z_STRVAL_P(val))) {
+					rv = FAILURE;
 				}
-				add_next_index_zval(ci_array, subarray);
 			}
-			add_assoc_zval_ex(&array, "certinfo", sizeof("certinfo"), ci_array);
 		}
-	}
-#endif
-	add_assoc_string_ex(&array, "error", sizeof("error"), get_storage(ch)->errorbuffer, 1);
+		break;
 
-	return SUCCESS;
-}
+	case IS_DOUBLE:
+		if (opt->flags & PHP_HTTP_CURL_CLIENT_OPTION_TRANSFORM_MS) {
+			tmp = *val;
+			Z_DVAL(tmp) *= 1000;
+			val = &tmp;
+		}
+		if (opt->setter) {
+			rv = opt->setter(opt, val, h);
+		} else if (CURLE_OK != curl_easy_setopt(ch, opt->option, (long) Z_DVAL_P(val))) {
+			rv = FAILURE;
+		}
+		break;
+
+	case IS_ARRAY:
+		if (opt->setter) {
+			rv = opt->setter(opt, val, h);
+		} else if (Z_TYPE_P(val) != IS_NULL) {
+			rv = php_http_options_apply(&opt->suboptions, Z_ARRVAL_P(val), h);
+		}
+		break;
 
+	default:
+		if (opt->setter) {
+			rv = opt->setter(opt, val, h);
+		} else {
+			rv = FAILURE;
+		}
+		break;
+	}
+	if (rv != SUCCESS) {
+		php_http_error(HE_NOTICE, PHP_HTTP_E_CLIENT, "Could not set option %s", opt->name.s);
+	}
+	return rv;
+}
 
-/* request handler ops */
+/* client ops */
 
 static STATUS php_http_curl_client_reset(php_http_client_t *h);
 
@@ -807,6 +1017,7 @@ static php_http_client_t *php_http_curl_client_init(php_http_client_t *h, void *
 	ctx = ecalloc(1, sizeof(*ctx));
 	ctx->handle = handle;
 	php_http_buffer_init(&ctx->options.cookies);
+	php_http_buffer_init(&ctx->options.ranges);
 	zend_hash_init(&ctx->options.cache, 0, NULL, ZVAL_PTR_DTOR, 0);
 	h->ctx = ctx;
 
@@ -861,6 +1072,7 @@ static void php_http_curl_client_dtor(php_http_client_t *h)
 
 	php_http_resource_factory_handle_dtor(h->rf, ctx->handle TSRMLS_CC);
 
+	php_http_buffer_dtor(&ctx->options.ranges);
 	php_http_buffer_dtor(&ctx->options.cookies);
 	zend_hash_destroy(&ctx->options.cache);
 
@@ -873,13 +1085,14 @@ static void php_http_curl_client_dtor(php_http_client_t *h)
 	efree(ctx);
 	h->ctx = NULL;
 }
+
 static STATUS php_http_curl_client_reset(php_http_client_t *h)
 {
 	php_http_curl_client_t *curl = h->ctx;
 	CURL *ch = curl->handle;
 	php_http_curl_client_storage_t *st;
 
-	if ((st = get_storage(ch))) {
+	if ((st = php_http_curl_client_get_storage(ch))) {
 		if (st->url) {
 			pefree(st->url, 1);
 			st->url = NULL;
@@ -892,117 +1105,13 @@ static STATUS php_http_curl_client_reset(php_http_client_t *h)
 	}
 
 	curl_easy_setopt(ch, CURLOPT_URL, NULL);
-#if PHP_HTTP_CURL_VERSION(7,19,4)
-	curl_easy_setopt(ch, CURLOPT_NOPROXY, NULL);
-#endif
-	curl_easy_setopt(ch, CURLOPT_PROXY, NULL);
-	curl_easy_setopt(ch, CURLOPT_PROXYPORT, 0L);
-	curl_easy_setopt(ch, CURLOPT_PROXYTYPE, 0L);
 	/* libcurl < 7.19.6 does not clear auth info with USERPWD set to NULL */
 #if PHP_HTTP_CURL_VERSION(7,19,1)
 	curl_easy_setopt(ch, CURLOPT_PROXYUSERNAME, NULL);
 	curl_easy_setopt(ch, CURLOPT_PROXYPASSWORD, NULL);
-#endif
-	curl_easy_setopt(ch, CURLOPT_PROXYAUTH, 0L);
-	curl_easy_setopt(ch, CURLOPT_HTTPPROXYTUNNEL, 0L);
-	curl_easy_setopt(ch, CURLOPT_DNS_CACHE_TIMEOUT, 60L);
-	curl_easy_setopt(ch, CURLOPT_IPRESOLVE, 0);
-#if PHP_HTTP_CURL_VERSION(7,21,3)
-	curl_easy_setopt(ch, CURLOPT_RESOLVE, NULL);
-#endif
-#if PHP_HTTP_CURL_VERSION(7,24,0)
-	curl_easy_setopt(ch, CURLOPT_DNS_SERVERS, NULL);
-#endif
-	curl_easy_setopt(ch, CURLOPT_LOW_SPEED_LIMIT, 0L);
-	curl_easy_setopt(ch, CURLOPT_LOW_SPEED_TIME, 0L);
-	/* LFS weirdance
-	curl_easy_setopt(ch, CURLOPT_MAX_SEND_SPEED_LARGE, (curl_off_t) 0);
-	curl_easy_setopt(ch, CURLOPT_MAX_RECV_SPEED_LARGE, (curl_off_t) 0);
-	*/
-	/* crashes
-	curl_easy_setopt(ch, CURLOPT_MAXCONNECTS, 5L); */
-	curl_easy_setopt(ch, CURLOPT_FRESH_CONNECT, 0L);
-	curl_easy_setopt(ch, CURLOPT_FORBID_REUSE, 0L);
-	curl_easy_setopt(ch, CURLOPT_INTERFACE, NULL);
-	curl_easy_setopt(ch, CURLOPT_PORT, 0L);
-#if PHP_HTTP_CURL_VERSION(7,19,0)
-	curl_easy_setopt(ch, CURLOPT_ADDRESS_SCOPE, 0L);
-#endif
-	curl_easy_setopt(ch, CURLOPT_LOCALPORT, 0L);
-	curl_easy_setopt(ch, CURLOPT_LOCALPORTRANGE, 0L);
-	/* libcurl < 7.19.6 does not clear auth info with USERPWD set to NULL */
-#if PHP_HTTP_CURL_VERSION(7,19,1)
 	curl_easy_setopt(ch, CURLOPT_USERNAME, NULL);
 	curl_easy_setopt(ch, CURLOPT_PASSWORD, NULL);
 #endif
-	curl_easy_setopt(ch, CURLOPT_HTTPAUTH, 0L);
-	curl_easy_setopt(ch, CURLOPT_ENCODING, NULL);
-	/* we do this ourself anyway */
-	curl_easy_setopt(ch, CURLOPT_HTTP_CONTENT_DECODING, 0L);
-	curl_easy_setopt(ch, CURLOPT_HTTP_TRANSFER_DECODING, 0L);
-	curl_easy_setopt(ch, CURLOPT_FOLLOWLOCATION, 0L);
-#if PHP_HTTP_CURL_VERSION(7,19,1)
-	curl_easy_setopt(ch, CURLOPT_POSTREDIR, 0L);
-#else
-	curl_easy_setopt(ch, CURLOPT_POST301, 0L);
-#endif
-	curl_easy_setopt(ch, CURLOPT_UNRESTRICTED_AUTH, 0L);
-	curl_easy_setopt(ch, CURLOPT_REFERER, NULL);
-	curl_easy_setopt(ch, CURLOPT_USERAGENT, "PECL::HTTP/" PHP_HTTP_EXT_VERSION " (PHP/" PHP_VERSION ")");
-	curl_easy_setopt(ch, CURLOPT_HTTPHEADER, NULL);
-	curl_easy_setopt(ch, CURLOPT_COOKIE, NULL);
-	curl_easy_setopt(ch, CURLOPT_COOKIESESSION, 0L);
-	/* these options would enable curl's cookie engine by default which we don't want
-	curl_easy_setopt(ch, CURLOPT_COOKIEFILE, NULL);
-	curl_easy_setopt(ch, CURLOPT_COOKIEJAR, NULL); */
-	curl_easy_setopt(ch, CURLOPT_COOKIELIST, NULL);
-	curl_easy_setopt(ch, CURLOPT_RANGE, NULL);
-	curl_easy_setopt(ch, CURLOPT_RESUME_FROM, 0L);
-	curl_easy_setopt(ch, CURLOPT_MAXFILESIZE, 0L);
-	curl_easy_setopt(ch, CURLOPT_TIMECONDITION, 0L);
-	curl_easy_setopt(ch, CURLOPT_TIMEVALUE, 0L);
-	curl_easy_setopt(ch, CURLOPT_TIMEOUT, 0L);
-	curl_easy_setopt(ch, CURLOPT_CONNECTTIMEOUT, 3);
-	curl_easy_setopt(ch, CURLOPT_SSLCERT, NULL);
-	curl_easy_setopt(ch, CURLOPT_SSLCERTTYPE, NULL);
-	curl_easy_setopt(ch, CURLOPT_SSLCERTPASSWD, NULL);
-	curl_easy_setopt(ch, CURLOPT_SSLKEY, NULL);
-	curl_easy_setopt(ch, CURLOPT_SSLKEYTYPE, NULL);
-	curl_easy_setopt(ch, CURLOPT_SSLKEYPASSWD, NULL);
-	curl_easy_setopt(ch, CURLOPT_SSLENGINE, NULL);
-	curl_easy_setopt(ch, CURLOPT_SSLVERSION, 0L);
-	curl_easy_setopt(ch, CURLOPT_SSL_VERIFYPEER, 0L);
-	curl_easy_setopt(ch, CURLOPT_SSL_VERIFYHOST, 0L);
-	curl_easy_setopt(ch, CURLOPT_SSL_CIPHER_LIST, NULL);
-#if PHP_HTTP_CURL_VERSION(7,19,0)
-	curl_easy_setopt(ch, CURLOPT_ISSUERCERT, NULL);
-#if defined(PHP_HTTP_HAVE_OPENSSL)
-	curl_easy_setopt(ch, CURLOPT_CRLFILE, NULL);
-#endif
-#endif
-#if PHP_HTTP_CURL_VERSION(7,19,1) && defined(PHP_HTTP_HAVE_OPENSSL)
-	curl_easy_setopt(ch, CURLOPT_CERTINFO, NULL);
-#endif
-#ifdef PHP_HTTP_CURL_CAINFO
-	curl_easy_setopt(ch, CURLOPT_CAINFO, PHP_HTTP_CURL_CAINFO);
-#else
-	curl_easy_setopt(ch, CURLOPT_CAINFO, NULL);
-#endif
-	curl_easy_setopt(ch, CURLOPT_CAPATH, NULL);
-	curl_easy_setopt(ch, CURLOPT_RANDOM_FILE, NULL);
-	curl_easy_setopt(ch, CURLOPT_EGDSOCKET, NULL);
-	curl_easy_setopt(ch, CURLOPT_POSTFIELDS, NULL);
-	curl_easy_setopt(ch, CURLOPT_POSTFIELDSIZE, 0L);
-	curl_easy_setopt(ch, CURLOPT_HTTPPOST, NULL);
-	curl_easy_setopt(ch, CURLOPT_IOCTLDATA, NULL);
-	curl_easy_setopt(ch, CURLOPT_READDATA, NULL);
-	curl_easy_setopt(ch, CURLOPT_INFILESIZE, 0L);
-	curl_easy_setopt(ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_NONE);
-	curl_easy_setopt(ch, CURLOPT_CUSTOMREQUEST, NULL);
-	curl_easy_setopt(ch, CURLOPT_NOBODY, 0L);
-	curl_easy_setopt(ch, CURLOPT_POST, 0L);
-	curl_easy_setopt(ch, CURLOPT_UPLOAD, 0L);
-	curl_easy_setopt(ch, CURLOPT_HTTPGET, 1L);
 
 #if PHP_HTTP_CURL_VERSION(7,21,3)
 	if (curl->options.resolve) {
@@ -1013,6 +1122,7 @@ static STATUS php_http_curl_client_reset(php_http_client_t *h)
 	curl->options.retry.count = 0;
 	curl->options.retry.delay = 0;
 	curl->options.redirects = 0;
+	curl->options.encode_cookies = 1;
 
 	if (curl->options.headers) {
 		curl_slist_free_all(curl->options.headers);
@@ -1020,15 +1130,16 @@ static STATUS php_http_curl_client_reset(php_http_client_t *h)
 	}
 
 	php_http_buffer_reset(&curl->options.cookies);
+	php_http_buffer_reset(&curl->options.ranges);
 
 	return SUCCESS;
 }
 
-STATUS php_http_curl_client_prepare(php_http_client_t *h, php_http_message_t *msg)
+PHP_HTTP_API STATUS php_http_curl_client_prepare(php_http_client_t *h, php_http_message_t *msg)
 {
 	size_t body_size;
 	php_http_curl_client_t *curl = h->ctx;
-	php_http_curl_client_storage_t *storage = get_storage(curl->handle);
+	php_http_curl_client_storage_t *storage = php_http_curl_client_get_storage(curl->handle);
 	TSRMLS_FETCH_FROM_CTX(h->ts);
 
 	/* request url */
@@ -1073,6 +1184,7 @@ STATUS php_http_curl_client_prepare(php_http_client_t *h, php_http_message_t *ms
 	}
 
 	/* 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;
@@ -1119,7 +1231,7 @@ static STATUS php_http_curl_client_exec(php_http_client_t *h, php_http_message_t
 	uint tries = 0;
 	CURLcode result;
 	php_http_curl_client_t *curl = h->ctx;
-	php_http_curl_client_storage_t *storage = get_storage(curl->handle);
+	php_http_curl_client_storage_t *storage = php_http_curl_client_get_storage(curl->handle);
 	TSRMLS_FETCH_FROM_CTX(h->ts);
 
 	if (SUCCESS != php_http_curl_client_prepare(h, msg)) {
@@ -1171,7 +1283,7 @@ static STATUS php_http_curl_client_setopt(php_http_client_t *h, php_http_client_
 
 	switch (opt) {
 		case PHP_HTTP_CLIENT_OPT_SETTINGS:
-			return set_options(h, arg);
+			return php_http_options_apply(&php_http_curl_client_options, arg, h);
 			break;
 
 		case PHP_HTTP_CLIENT_OPT_PROGRESS_CALLBACK:
@@ -1187,7 +1299,7 @@ static STATUS php_http_curl_client_setopt(php_http_client_t *h, php_http_client_
 
 		case PHP_HTTP_CLIENT_OPT_COOKIES_ENABLE:
 			/* are cookies already enabled anyway? */
-			if (!get_storage(curl->handle)->cookiestore) {
+			if (!php_http_curl_client_get_storage(curl->handle)->cookiestore) {
 				if (CURLE_OK != curl_easy_setopt(curl->handle, CURLOPT_COOKIEFILE, "")) {
 					return FAILURE;
 				}
@@ -1245,11 +1357,6 @@ static php_http_resource_factory_ops_t php_http_curl_client_resource_factory_ops
 	php_http_curl_dtor
 };
 
-static zend_class_entry *get_class_entry(void)
-{
-	return php_http_curl_client_class_entry;
-}
-
 static php_http_client_ops_t php_http_curl_client_ops = {
 	&php_http_curl_client_resource_factory_ops,
 	php_http_curl_client_init,
@@ -1260,7 +1367,7 @@ static php_http_client_ops_t php_http_curl_client_ops = {
 	php_http_curl_client_setopt,
 	php_http_curl_client_getopt,
 	(php_http_new_t) php_http_curl_client_object_new_ex,
-	get_class_entry
+	php_http_curl_client_get_class_entry
 };
 
 PHP_HTTP_API php_http_client_ops_t *php_http_curl_client_get_ops(void)
@@ -1274,12 +1381,18 @@ PHP_HTTP_API php_http_client_ops_t *php_http_curl_client_get_ops(void)
 #define PHP_HTTP_CURL_CLIENT_ME(method, visibility)	PHP_ME(HttpClientCURL, method, PHP_HTTP_ARGS(HttpClientCURL, method), visibility)
 #define PHP_HTTP_CURL_CLIENT_CLIENT_MALIAS(me, vis)	ZEND_FENTRY(me, ZEND_MN(HttpClient_##me), PHP_HTTP_ARGS(HttpClientCURL, me), vis)
 
-PHP_HTTP_BEGIN_ARGS(send, 1)
+PHP_HTTP_BEGIN_ARGS(send, 0)
 	PHP_HTTP_ARG_VAL(request, 0)
 PHP_HTTP_END_ARGS;
 
-zend_class_entry *php_http_curl_client_class_entry;
-zend_function_entry php_http_curl_client_method_entry[] = {
+static zend_class_entry *php_http_curl_client_class_entry;
+
+zend_class_entry *php_http_curl_client_get_class_entry(void)
+{
+	return php_http_curl_client_class_entry;
+}
+
+static zend_function_entry php_http_curl_client_method_entry[] = {
 	PHP_HTTP_CURL_CLIENT_CLIENT_MALIAS(send, ZEND_ACC_PUBLIC)
 	EMPTY_FUNCTION_ENTRY
 };
@@ -1315,10 +1428,19 @@ zend_object_value php_http_curl_client_object_new_ex(zend_class_entry *ce, php_h
 
 PHP_MINIT_FUNCTION(http_curl_client)
 {
+	php_http_options_t *options;
+
 	if (SUCCESS != php_http_persistent_handle_provide(ZEND_STRL("http_client.curl"), &php_http_curl_client_resource_factory_ops, NULL, NULL)) {
 		return FAILURE;
 	}
 
+	if ((options = php_http_options_init(&php_http_curl_client_options, 1))) {
+		options->getter = php_http_curl_client_get_option;
+		options->setter = php_http_curl_client_set_option;
+
+		php_http_curl_client_options_init(options TSRMLS_CC);
+	}
+
 	PHP_HTTP_REGISTER_CLASS(http\\Curl, Client, http_curl_client, php_http_client_get_class_entry(), 0);
 	php_http_curl_client_class_entry->create_object = php_http_curl_client_object_new;
 
@@ -1381,6 +1503,12 @@ PHP_MINIT_FUNCTION(http_curl_client)
 	return SUCCESS;
 }
 
+PHP_MSHUTDOWN_FUNCTION(http_curl_client)
+{
+	php_http_options_dtor(&php_http_curl_client_options);
+	return SUCCESS;
+}
+
 /*
  * Local variables:
  * tab-width: 4