X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=src%2Fphp_http_message_body.c;h=b2e643be4b39491f4b4f90865e76edd530cdf06c;hp=c80c2389151b78ce0976dd23ba86f4796fb594d9;hb=50eaea1dac2be9bff7990a6f669b5b6dacc6889e;hpb=bdd6edb59194cda9e5fcb393c48ab4230fceb32a

diff --git a/src/php_http_message_body.c b/src/php_http_message_body.c
index c80c238..b2e643b 100644
--- a/src/php_http_message_body.c
+++ b/src/php_http_message_body.c
@@ -12,7 +12,7 @@
 
 #include "php_http_api.h"
 
-#include <ext/standard/php_lcg.h>
+#include "ext/standard/php_lcg.h"
 
 #define BOUNDARY_OPEN(body) \
 	do {\
@@ -28,32 +28,29 @@
 #define BOUNDARY_CLOSE(body) \
 		php_http_message_body_appendf(body, PHP_HTTP_CRLF "--%s--" PHP_HTTP_CRLF, php_http_message_body_boundary(body))
 
-static ZEND_RESULT_CODE add_recursive_fields(php_http_message_body_t *body, const char *name, zval *value);
-static ZEND_RESULT_CODE add_recursive_files(php_http_message_body_t *body, const char *name, zval *value);
+static ZEND_RESULT_CODE add_recursive_fields(php_http_message_body_t *body, const char *name, HashTable *fields);
+static ZEND_RESULT_CODE add_recursive_files(php_http_message_body_t *body, const char *name, HashTable *files);
 
-php_http_message_body_t *php_http_message_body_init(php_http_message_body_t **body_ptr, php_stream *stream TSRMLS_DC)
+php_http_message_body_t *php_http_message_body_init(php_http_message_body_t **body_ptr, php_stream *stream)
 {
 	php_http_message_body_t *body;
 
 	if (body_ptr && *body_ptr) {
 		body = *body_ptr;
-		++body->refcount;
+		php_http_message_body_addref(body);
 		return body;
 	}
-	
+
 	body = ecalloc(1, sizeof(php_http_message_body_t));
 	body->refcount = 1;
 
 	if (stream) {
-		php_stream_auto_cleanup(stream);
-		body->stream_id = php_stream_get_resource_id(stream);
-		zend_list_addref(body->stream_id);
+		body->res = stream->res;
+		GC_ADDREF(body->res);
 	} else {
-		stream = php_stream_temp_create(TEMP_STREAM_DEFAULT, 0xffff);
-		php_stream_auto_cleanup(stream);
-		body->stream_id = php_stream_get_resource_id(stream);
+		body->res = php_stream_temp_create(TEMP_STREAM_DEFAULT, 0xffff)->res;
 	}
-	TSRMLS_SET_CTX(body->ts);
+	php_stream_auto_cleanup(php_http_message_body_stream(body));
 
 	if (body_ptr) {
 		*body_ptr = body;
@@ -70,12 +67,10 @@ unsigned php_http_message_body_addref(php_http_message_body_t *body)
 php_http_message_body_t *php_http_message_body_copy(php_http_message_body_t *from, php_http_message_body_t *to)
 {
 	if (from) {
-		TSRMLS_FETCH_FROM_CTX(from->ts);
-		
 		if (to) {
 			php_stream_truncate_set_size(php_http_message_body_stream(to), 0);
 		} else {
-			to = php_http_message_body_init(NULL, NULL TSRMLS_CC);
+			to = php_http_message_body_init(NULL, NULL);
 		}
 		php_http_message_body_to_stream(from, php_http_message_body_stream(to), 0, 0);
 
@@ -95,11 +90,9 @@ void php_http_message_body_free(php_http_message_body_t **body_ptr)
 {
 	if (*body_ptr) {
 		php_http_message_body_t *body = *body_ptr;
-
 		if (!--body->refcount) {
-			TSRMLS_FETCH_FROM_CTX(body->ts);
-			/* NOFIXME: shows leakinfo in DEBUG mode */
-			zend_list_delete(body->stream_id);
+			zend_list_delete(body->res);
+			body->res = NULL;
 			PTR_FREE(body->boundary);
 			efree(body);
 		}
@@ -109,7 +102,6 @@ void php_http_message_body_free(php_http_message_body_t **body_ptr)
 
 const php_stream_statbuf *php_http_message_body_stat(php_http_message_body_t *body)
 {
-	TSRMLS_FETCH_FROM_CTX(body->ts);
 	php_stream_stat(php_http_message_body_stream(body), &body->ssb);
 	return &body->ssb;
 }
@@ -118,9 +110,8 @@ const char *php_http_message_body_boundary(php_http_message_body_t *body)
 {
 	if (!body->boundary) {
 		union { double dbl; int num[2]; } data;
-		TSRMLS_FETCH_FROM_CTX(body->ts);
 
-		data.dbl = php_combined_lcg(TSRMLS_C);
+		data.dbl = php_combined_lcg();
 		spprintf(&body->boundary, 0, "%x.%x", data.num[0], data.num[1]);
 	}
 	return body->boundary;
@@ -130,7 +121,6 @@ char *php_http_message_body_etag(php_http_message_body_t *body)
 {
 	php_http_etag_t *etag;
 	php_stream *s = php_http_message_body_stream(body);
-	TSRMLS_FETCH_FROM_CTX(body->ts);
 
 	/* real file or temp buffer ? */
 	if (s->ops != &php_stream_temp_ops && s->ops != &php_stream_memory_ops) {
@@ -145,7 +135,7 @@ char *php_http_message_body_etag(php_http_message_body_t *body)
 	}
 
 	/* content based */
-	if ((etag = php_http_etag_init(PHP_HTTP_G->env.etag_mode TSRMLS_CC))) {
+	if ((etag = php_http_etag_init(PHP_HTTP_G->env.etag_mode))) {
 		php_http_message_body_to_callback(body, (php_http_pass_callback_t) php_http_etag_update, etag, 0, 0);
 		return php_http_etag_finish(etag);
 	}
@@ -153,22 +143,20 @@ char *php_http_message_body_etag(php_http_message_body_t *body)
 	return NULL;
 }
 
-void php_http_message_body_to_string(php_http_message_body_t *body, char **buf, size_t *len, off_t offset, size_t forlen)
+zend_string *php_http_message_body_to_string(php_http_message_body_t *body, off_t offset, size_t forlen)
 {
 	php_stream *s = php_http_message_body_stream(body);
-	TSRMLS_FETCH_FROM_CTX(body->ts);
 
 	php_stream_seek(s, offset, SEEK_SET);
 	if (!forlen) {
 		forlen = -1;
 	}
-	*len = php_stream_copy_to_mem(s, buf, forlen, 0);
+	return php_stream_copy_to_mem(s, forlen, 0);
 }
 
 ZEND_RESULT_CODE php_http_message_body_to_stream(php_http_message_body_t *body, php_stream *dst, off_t offset, size_t forlen)
 {
 	php_stream *s = php_http_message_body_stream(body);
-	TSRMLS_FETCH_FROM_CTX(body->ts);
 
 	php_stream_seek(s, offset, SEEK_SET);
 
@@ -182,7 +170,6 @@ ZEND_RESULT_CODE php_http_message_body_to_callback(php_http_message_body_t *body
 {
 	php_stream *s = php_http_message_body_stream(body);
 	char *buf = emalloc(0x1000);
-	TSRMLS_FETCH_FROM_CTX(body->ts);
 
 	php_stream_seek(s, offset, SEEK_SET);
 
@@ -215,7 +202,6 @@ size_t php_http_message_body_append(php_http_message_body_t *body, const char *b
 {
 	php_stream *s;
 	size_t written;
-	TSRMLS_FETCH_FROM_CTX(body->ts);
 
 	if (!(s = php_http_message_body_stream(body))) {
 		return -1;
@@ -228,7 +214,7 @@ size_t php_http_message_body_append(php_http_message_body_t *body, const char *b
 	written = php_stream_write(s, buf, len);
 
 	if (written != len) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to append %zu bytes to body; wrote %zu", len, written);
+		php_error_docref(NULL, E_WARNING, "Failed to append %zu bytes to body; wrote %zu", len, written == (size_t) -1 ? 0 : written);
 	}
 
 	return len;
@@ -252,17 +238,13 @@ size_t php_http_message_body_appendf(php_http_message_body_t *body, const char *
 
 ZEND_RESULT_CODE php_http_message_body_add_form(php_http_message_body_t *body, HashTable *fields, HashTable *files)
 {
-	zval tmp;
-
 	if (fields) {
-		INIT_PZVAL_ARRAY(&tmp, fields);
-		if (SUCCESS != add_recursive_fields(body, NULL, &tmp)) {
+		if (SUCCESS != add_recursive_fields(body, NULL, fields)) {
 			return FAILURE;
 		}
 	}
 	if (files) {
-		INIT_PZVAL_ARRAY(&tmp, files);
-		if (SUCCESS != add_recursive_files(body, NULL, &tmp)) {
+		if (SUCCESS != add_recursive_files(body, NULL, files)) {
 			return FAILURE;
 		}
 	}
@@ -272,8 +254,6 @@ ZEND_RESULT_CODE php_http_message_body_add_form(php_http_message_body_t *body, H
 
 void php_http_message_body_add_part(php_http_message_body_t *body, php_http_message_t *part)
 {
-	TSRMLS_FETCH_FROM_CTX(body->ts);
-
 	BOUNDARY_OPEN(body);
 	php_http_message_to_callback(part, (php_http_pass_callback_t) php_http_message_body_append, body);
 	BOUNDARY_CLOSE(body);
@@ -282,34 +262,42 @@ void php_http_message_body_add_part(php_http_message_body_t *body, php_http_mess
 
 ZEND_RESULT_CODE php_http_message_body_add_form_field(php_http_message_body_t *body, const char *name, const char *value_str, size_t value_len)
 {
-	char *safe_name;
-	TSRMLS_FETCH_FROM_CTX(body->ts);
+	zend_string *safe_name, *zstr_name = zend_string_init(name, strlen(name), 0);
 
-	safe_name = php_addslashes(estrdup(name), strlen(name), NULL, 1 TSRMLS_CC);
+#if PHP_VERSION_ID < 70300
+	safe_name = php_addslashes(zstr_name, 1);
+#else
+	safe_name = php_addslashes(zstr_name);
+	zend_string_release_ex(zstr_name, 0);
+#endif
 
 	BOUNDARY_OPEN(body);
 	php_http_message_body_appendf(
 		body,
 		"Content-Disposition: form-data; name=\"%s\"" PHP_HTTP_CRLF
 		"" PHP_HTTP_CRLF,
-		safe_name
+		safe_name->val
 	);
 	php_http_message_body_append(body, value_str, value_len);
 	BOUNDARY_CLOSE(body);
 
-	efree(safe_name);
+	zend_string_release(safe_name);
 	return SUCCESS;
 }
 
 ZEND_RESULT_CODE php_http_message_body_add_form_file(php_http_message_body_t *body, const char *name, const char *ctype, const char *path, php_stream *in)
 {
-	char *safe_name, *path_dup = estrdup(path), *bname;
-	size_t bname_len;
-	TSRMLS_FETCH_FROM_CTX(body->ts);
+	size_t path_len = strlen(path);
+	char *path_dup = estrndup(path, path_len);
+	zend_string *base_name, *safe_name, *zstr_name = zend_string_init(name, strlen(name), 0);
 
-	safe_name = php_addslashes(estrdup(name), strlen(name), NULL, 1 TSRMLS_CC);
-	
-	php_basename(path_dup, strlen(path_dup), NULL, 0, &bname, &bname_len TSRMLS_CC); 
+#if PHP_VERSION_ID < 70300
+	safe_name = php_addslashes(zstr_name, 1);
+#else
+	safe_name = php_addslashes(zstr_name);
+	zend_string_release_ex(zstr_name, 0);
+#endif
+	base_name = php_basename(path_dup, path_len, NULL, 0);
 
 	BOUNDARY_OPEN(body);
 	php_http_message_body_appendf(
@@ -318,29 +306,29 @@ ZEND_RESULT_CODE php_http_message_body_add_form_file(php_http_message_body_t *bo
 		"Content-Transfer-Encoding: binary" PHP_HTTP_CRLF
 		"Content-Type: %s" PHP_HTTP_CRLF
 		PHP_HTTP_CRLF,
-		safe_name, bname, ctype
+		safe_name->val, base_name->val, ctype
 	);
 	php_stream_copy_to_stream_ex(in, php_http_message_body_stream(body), PHP_STREAM_COPY_ALL, NULL);
 	BOUNDARY_CLOSE(body);
 
-	efree(safe_name);
+	zend_string_release(safe_name);
+	zend_string_release(base_name);
 	efree(path_dup);
-	efree(bname);
 
 	return SUCCESS;
 }
 
-static inline char *format_key(uint type, char *str, ulong num, const char *prefix) {
+static inline char *format_key(php_http_arrkey_t *key, const char *prefix) {
 	char *new_key = NULL;
 
 	if (prefix && *prefix) {
-		if (type == HASH_KEY_IS_STRING) {
-			spprintf(&new_key, 0, "%s[%s]", prefix, str);
+		if (key->key) {
+			spprintf(&new_key, 0, "%s[%s]", prefix, key->key->val);
 		} else {
-			spprintf(&new_key, 0, "%s[%lu]", prefix, num);
+			spprintf(&new_key, 0, "%s[%lu]", prefix, key->h);
 		}
-	} else if (type == HASH_KEY_IS_STRING) {
-		new_key = estrdup(str);
+	} else if (key->key) {
+		new_key = estrdup(key->key->val);
 	} else {
 		new_key = estrdup("");
 	}
@@ -348,106 +336,108 @@ static inline char *format_key(uint type, char *str, ulong num, const char *pref
 	return new_key;
 }
 
-static ZEND_RESULT_CODE add_recursive_fields(php_http_message_body_t *body, const char *name, zval *value)
+static ZEND_RESULT_CODE add_recursive_field_value(php_http_message_body_t *body, const char *name, zval *value)
 {
-	if (Z_TYPE_P(value) == IS_ARRAY || Z_TYPE_P(value) == IS_OBJECT) {
-		zval **val;
-		HashTable *ht;
-		HashPosition pos;
-		php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
-		TSRMLS_FETCH_FROM_CTX(body->ts);
+	zend_string *zs = zval_get_string(value);
+	ZEND_RESULT_CODE rc = php_http_message_body_add_form_field(body, name, zs->val, zs->len);
+	zend_string_release(zs);
+	return rc;
+}
 
-		ht = HASH_OF(value);
-		if (!ht->nApplyCount) {
-			++ht->nApplyCount;
-			FOREACH_KEYVAL(pos, value, key, val) {
-				char *str = format_key(key.type, key.str, key.num, name);
-				if (SUCCESS != add_recursive_fields(body, str, *val)) {
+static ZEND_RESULT_CODE add_recursive_fields(php_http_message_body_t *body, const char *name, HashTable *fields)
+{
+	zval *val;
+	php_http_arrkey_t key;
+
+	if (!HT_IS_RECURSIVE(fields)) {
+		HT_PROTECT_RECURSION(fields);
+		ZEND_HASH_FOREACH_KEY_VAL_IND(fields, key.h, key.key, val)
+		{
+			char *str = format_key(&key, name);
+
+			if (Z_TYPE_P(val) != IS_ARRAY && Z_TYPE_P(val) != IS_OBJECT) {
+				if (SUCCESS != add_recursive_field_value(body, str, val)) {
 					efree(str);
-					ht->nApplyCount--;
+					HT_UNPROTECT_RECURSION(fields);
 					return FAILURE;
 				}
+			} else if (SUCCESS != add_recursive_fields(body, str, HASH_OF(val))) {
 				efree(str);
+				HT_UNPROTECT_RECURSION(fields);
+				return FAILURE;
 			}
-			--ht->nApplyCount;
+			efree(str);
 		}
-	} else {
-		zval *cpy = php_http_ztyp(IS_STRING, value);
-		php_http_message_body_add_form_field(body, name, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy));
-		zval_ptr_dtor(&cpy);
+		ZEND_HASH_FOREACH_END();
+		HT_UNPROTECT_RECURSION(fields);
 	}
 
 	return SUCCESS;
 }
 
-static ZEND_RESULT_CODE add_recursive_files(php_http_message_body_t *body, const char *name, zval *value)
+static ZEND_RESULT_CODE add_recursive_files(php_http_message_body_t *body, const char *name, HashTable *files)
 {
-	zval **zdata = NULL, **zfile, **zname, **ztype;
-	HashTable *ht;
-	TSRMLS_FETCH_FROM_CTX(body->ts);
-
-	if (Z_TYPE_P(value) != IS_ARRAY && Z_TYPE_P(value) != IS_OBJECT) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expected array or object (name, type, file) for message body file to add");
-		return FAILURE;
-	}
+	zval *zdata = NULL, *zfile, *zname, *ztype;
 
-	ht = HASH_OF(value);
-
-	if ((SUCCESS != zend_hash_find(ht, ZEND_STRS("name"), (void *) &zname))
-	||	(SUCCESS != zend_hash_find(ht, ZEND_STRS("type"), (void *) &ztype))
-	||	(SUCCESS != zend_hash_find(ht, ZEND_STRS("file"), (void *) &zfile))
+	/* single entry */
+	if (!(zname = zend_hash_str_find(files, ZEND_STRL("name")))
+	||	!(ztype = zend_hash_str_find(files, ZEND_STRL("type")))
+	||	!(zfile = zend_hash_str_find(files, ZEND_STRL("file")))
 	) {
-		zval **val;
-		HashPosition pos;
-		php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
+		zval *val;
+		php_http_arrkey_t key;
 
-		if (!ht->nApplyCount) {
-			++ht->nApplyCount;
-			FOREACH_HASH_KEYVAL(pos, ht, key, val) {
-				if (Z_TYPE_PP(val) == IS_ARRAY || Z_TYPE_PP(val) == IS_OBJECT) {
-					char *str = format_key(key.type, key.str, key.num, name);
+		if (!HT_IS_RECURSIVE(files)) {
+			HT_PROTECT_RECURSION(files);
+			ZEND_HASH_FOREACH_KEY_VAL_IND(files, key.h, key.key, val)
+			{
+				if (Z_TYPE_P(val) == IS_ARRAY || Z_TYPE_P(val) == IS_OBJECT) {
+					char *str = format_key(&key, name);
 
-					if (SUCCESS != add_recursive_files(body, str, *val)) {
+					if (SUCCESS != add_recursive_files(body, str, HASH_OF(val))) {
 						efree(str);
-						--ht->nApplyCount;
+						HT_UNPROTECT_RECURSION(files);
 						return FAILURE;
 					}
 					efree(str);
 				}
 			}
-			--ht->nApplyCount;
+			ZEND_HASH_FOREACH_END();
+			HT_UNPROTECT_RECURSION(files);
 		}
 		return SUCCESS;
 	} else {
+		/* stream entry */
 		php_stream *stream;
-		zval *zfc = php_http_ztyp(IS_STRING, *zfile);
+		zend_string *zfc = zval_get_string(zfile);
 
-		if (SUCCESS == zend_hash_find(ht, ZEND_STRS("data"), (void *) &zdata)) {
-			if (Z_TYPE_PP(zdata) == IS_RESOURCE) {
+		if ((zdata = zend_hash_str_find(files, ZEND_STRL("data")))) {
+			if (Z_TYPE_P(zdata) == IS_RESOURCE) {
 				php_stream_from_zval_no_verify(stream, zdata);
 			} else {
-				zval *tmp = php_http_ztyp(IS_STRING, *zdata);
+				zend_string *tmp = zval_get_string(zdata);
 
-				stream = php_stream_memory_open(TEMP_STREAM_READONLY, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
-				zval_ptr_dtor(&tmp);
+				stream = php_stream_memory_open(TEMP_STREAM_READONLY, tmp->val, tmp->len);
+				zend_string_release(tmp);
 			}
 		} else {
-			stream = php_stream_open_wrapper(Z_STRVAL_P(zfc), "r", REPORT_ERRORS|USE_PATH, NULL);
+			stream = php_stream_open_wrapper(zfc->val, "r", REPORT_ERRORS|USE_PATH, NULL);
 		}
 
 		if (!stream) {
-			zval_ptr_dtor(&zfc);
+			zend_string_release(zfc);
 			return FAILURE;
 		} else {
-			zval *znc = php_http_ztyp(IS_STRING, *zname), *ztc = php_http_ztyp(IS_STRING, *ztype);
-			char *key = format_key(HASH_KEY_IS_STRING, Z_STRVAL_P(znc), 0, name);
-			ZEND_RESULT_CODE ret =  php_http_message_body_add_form_file(body, key, Z_STRVAL_P(ztc), Z_STRVAL_P(zfc), stream);
+			zend_string *znc = zval_get_string(zname), *ztc = zval_get_string(ztype);
+			php_http_arrkey_t arrkey = {0, znc};
+			char *key = format_key(&arrkey, name);
+			ZEND_RESULT_CODE ret = php_http_message_body_add_form_file(body, key, ztc->val, zfc->val, stream);
 
 			efree(key);
-			zval_ptr_dtor(&znc);
-			zval_ptr_dtor(&ztc);
-			zval_ptr_dtor(&zfc);
-			if (!zdata || Z_TYPE_PP(zdata) != IS_RESOURCE) {
+			zend_string_release(znc);
+			zend_string_release(ztc);
+			zend_string_release(zfc);
+			if (!zdata || Z_TYPE_P(zdata) != IS_RESOURCE) {
 				php_stream_close(stream);
 			}
 			return ret;
@@ -464,7 +454,7 @@ struct splitbody_arg {
 	size_t consumed;
 };
 
-static size_t splitbody(void *opaque, char *buf, size_t len TSRMLS_DC)
+static size_t splitbody(void *opaque, char *buf, size_t len)
 {
 	struct splitbody_arg *arg = opaque;
 	const char *boundary = NULL;
@@ -507,7 +497,7 @@ static size_t splitbody(void *opaque, char *buf, size_t len TSRMLS_DC)
 					/* advance messages */
 					php_http_message_t *msg;
 
-					msg = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+					msg = php_http_message_init(NULL, 0, NULL);
 					msg->parent = arg->parser->message;
 					arg->parser->message = msg;
 				}
@@ -519,7 +509,7 @@ static size_t splitbody(void *opaque, char *buf, size_t len TSRMLS_DC)
 					len = 0;
 				} else {
 					/* let this be garbage */
-					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Malformed multipart boundary at pos %zu", consumed);
+					php_error_docref(NULL, E_WARNING, "Malformed multipart boundary at pos %zu", consumed);
 					return -1;
 				}
 			}
@@ -543,16 +533,15 @@ php_http_message_t *php_http_message_body_split(php_http_message_body_t *body, c
 	php_http_buffer_t *tmp = NULL;
 	php_http_message_t *msg = NULL;
 	struct splitbody_arg arg;
-	TSRMLS_FETCH_FROM_CTX(body->ts);
 
 	php_http_buffer_init(&arg.buf);
-	arg.parser = php_http_message_parser_init(NULL TSRMLS_CC);
+	arg.parser = php_http_message_parser_init(NULL);
 	arg.boundary_len = spprintf(&arg.boundary_str, 0, "\n--%s", boundary);
 	arg.consumed = 0;
 
 	php_stream_rewind(s);
 	while (!php_stream_eof(s)) {
-		php_http_buffer_passthru(&tmp, 0x1000, (php_http_buffer_pass_func_t) _php_stream_read, s, splitbody, &arg TSRMLS_CC);
+		php_http_buffer_passthru(&tmp, 0x1000, (php_http_buffer_pass_func_t) _php_stream_read, s, splitbody, &arg);
 	}
 
 	msg = arg.parser->message;
@@ -566,61 +555,93 @@ php_http_message_t *php_http_message_body_split(php_http_message_body_t *body, c
 	return msg;
 }
 
+static zend_class_entry *php_http_message_body_class_entry;
+zend_class_entry *php_http_get_message_body_class_entry(void)
+{
+	return php_http_message_body_class_entry;
+}
+
 static zend_object_handlers php_http_message_body_object_handlers;
 
-zend_object_value php_http_message_body_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *php_http_message_body_object_new(zend_class_entry *ce)
 {
-	return php_http_message_body_object_new_ex(ce, NULL, NULL TSRMLS_CC);
+	return &php_http_message_body_object_new_ex(ce, NULL)->zo;
 }
 
-zend_object_value php_http_message_body_object_new_ex(zend_class_entry *ce, php_http_message_body_t *body, php_http_message_body_object_t **ptr TSRMLS_DC)
+php_http_message_body_object_t *php_http_message_body_object_new_ex(zend_class_entry *ce, php_http_message_body_t *body)
 {
 	php_http_message_body_object_t *o;
 
-	o = ecalloc(1, sizeof(php_http_message_body_object_t));
-	zend_object_std_init((zend_object *) o, php_http_message_body_class_entry TSRMLS_CC);
-	object_properties_init((zend_object *) o, ce);
+	o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+	zend_object_std_init(&o->zo, php_http_message_body_class_entry);
+	object_properties_init(&o->zo, ce);
 
-	if (ptr) {
-		*ptr = o;
-	}
+	o->gc = emalloc(sizeof(zval));
 
 	if (body) {
 		o->body = body;
 	}
 
-	o->zv.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_message_body_object_free, NULL TSRMLS_CC);
-	o->zv.handlers = &php_http_message_body_object_handlers;
+	o->zo.handlers = &php_http_message_body_object_handlers;
 
-	return o->zv;
+	return o;
 }
 
-zend_object_value php_http_message_body_object_clone(zval *object TSRMLS_DC)
+zend_object *php_http_message_body_object_clone(zval *object)
 {
-	zend_object_value new_ov;
-	php_http_message_body_object_t *new_obj = NULL;
-	php_http_message_body_object_t *old_obj = zend_object_store_get_object(object TSRMLS_CC);
+	php_http_message_body_object_t *new_obj;
+	php_http_message_body_object_t *old_obj = PHP_HTTP_OBJ(NULL, object);
 	php_http_message_body_t *body = php_http_message_body_copy(old_obj->body, NULL);
 
-	new_ov = php_http_message_body_object_new_ex(old_obj->zo.ce, body, &new_obj TSRMLS_CC);
-	zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(object) TSRMLS_CC);
+	new_obj = php_http_message_body_object_new_ex(old_obj->zo.ce, body);
+	zend_objects_clone_members(&new_obj->zo, &old_obj->zo);
 
-	return new_ov;
+	return &new_obj->zo;
 }
 
-void php_http_message_body_object_free(void *object TSRMLS_DC)
+static HashTable *php_http_message_body_object_get_gc(zval *object, zval **table, int *n)
 {
-	php_http_message_body_object_t *obj = object;
+	php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+	HashTable *props = Z_OBJPROP_P(object);
+	uint32_t count = zend_hash_num_elements(props);
+
+	obj->gc = erealloc(obj->gc, (1 + count) * sizeof(zval));
 
+	if (php_http_message_body_stream(obj->body)) {
+		*n = 1;
+		php_stream_to_zval(php_http_message_body_stream(obj->body), obj->gc);
+	} else {
+		*n = 0;
+	}
+
+	if (count) {
+		zval *val;
+
+		ZEND_HASH_FOREACH_VAL(props, val)
+		{
+			ZVAL_COPY_VALUE(&obj->gc[(*n)++], val);
+		}
+		ZEND_HASH_FOREACH_END();
+	}
+	*table = obj->gc;
+
+	return NULL;
+}
+
+void php_http_message_body_object_free(zend_object *object)
+{
+	php_http_message_body_object_t *obj = PHP_HTTP_OBJ(object, NULL);
+
+	PTR_FREE(obj->gc);
 	php_http_message_body_free(&obj->body);
-	zend_object_std_dtor((zend_object *) obj TSRMLS_CC);
-	efree(obj);
+	zend_object_std_dtor(object);
 }
 
 #define PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj) \
 	do { \
 		if (!obj->body) { \
-			obj->body = php_http_message_body_init(NULL, NULL TSRMLS_CC); \
+			obj->body = php_http_message_body_init(NULL, NULL); \
+			php_stream_to_zval(php_http_message_body_stream(obj->body), obj->gc); \
 		} \
 	} while(0)
 
@@ -629,19 +650,20 @@ ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody___construct, 0, 0, 0)
 ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, __construct)
 {
-	php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+	php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
 	zval *zstream = NULL;
 	php_stream *stream;
 
-	php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r!", &zstream), invalid_arg, return);
+	php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|r!", &zstream), invalid_arg, return);
 
 	if (zstream) {
-		php_http_expect(php_stream_from_zval_no_verify(stream, &zstream), unexpected_val, return);
+		php_http_expect(php_stream_from_zval_no_verify(stream, zstream), unexpected_val, return);
 
 		if (obj->body) {
 			php_http_message_body_free(&obj->body);
 		}
-		obj->body = php_http_message_body_init(NULL, stream TSRMLS_CC);
+		obj->body = php_http_message_body_init(NULL, stream);
+		php_stream_to_zval(stream, obj->gc);
 	}
 }
 
@@ -650,15 +672,14 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, __toString)
 {
 	if (SUCCESS == zend_parse_parameters_none()) {
-		php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-		char *str;
-		size_t len;
+		php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
+		zend_string *zs;
 
 		PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
-		php_http_message_body_to_string(obj->body, &str, &len, 0, 0);
-		if (str) {
-			RETURN_STRINGL(str, len, 0);
+		zs = php_http_message_body_to_string(obj->body, 0, 0);
+		if (zs) {
+			RETURN_STR(zs);
 		}
 	}
 	RETURN_EMPTY_STRING();
@@ -670,13 +691,14 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, unserialize)
 {
 	char *us_str;
-	int us_len;
+	size_t us_len;
 
-	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &us_str, &us_len)) {
-		php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &us_str, &us_len)) {
+		php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
 		php_stream *s = php_stream_memory_open(0, us_str, us_len);
 
-		obj->body = php_http_message_body_init(NULL, s TSRMLS_CC);
+		obj->body = php_http_message_body_init(NULL, s);
+		php_stream_to_zval(s, obj->gc);
 	}
 }
 
@@ -688,15 +710,15 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, toStream)
 {
 	zval *zstream;
-	long offset = 0, forlen = 0;
+	zend_long offset = 0, forlen = 0;
 
-	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ll", &zstream, &offset, &forlen)) {
+	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "r|ll", &zstream, &offset, &forlen)) {
 		php_stream *stream;
-		php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+		php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
 
 		PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
-		php_stream_from_zval(stream, &zstream);
+		php_stream_from_zval(stream, zstream);
 		php_http_message_body_to_stream(obj->body, stream, offset, forlen);
 		RETURN_ZVAL(getThis(), 1, 0);
 	}
@@ -710,20 +732,16 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, toCallback)
 {
 	php_http_pass_fcall_arg_t fcd;
-	long offset = 0, forlen = 0;
+	zend_long offset = 0, forlen = 0;
 
-	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f|ll", &fcd.fci, &fcd.fcc, &offset, &forlen)) {
-		php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "f|ll", &fcd.fci, &fcd.fcc, &offset, &forlen)) {
+		php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
 
 		PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
-		fcd.fcz = getThis();
-		Z_ADDREF_P(fcd.fcz);
-		TSRMLS_SET_CTX(fcd.ts);
-
+		ZVAL_COPY(&fcd.fcz, getThis());
 		php_http_message_body_to_callback(obj->body, php_http_pass_fcall_callback, &fcd, offset, forlen);
 		zend_fcall_info_args_clear(&fcd.fci, 1);
-
 		zval_ptr_dtor(&fcd.fcz);
 		RETURN_ZVAL(getThis(), 1, 0);
 	}
@@ -734,12 +752,12 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, getResource)
 {
 	if (SUCCESS == zend_parse_parameters_none()) {
-		php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+		php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
 
 		PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
-		zend_list_addref(obj->body->stream_id);
-		RETVAL_RESOURCE(obj->body->stream_id);
+		php_stream_to_zval(php_http_message_body_stream(obj->body), return_value);
+		Z_ADDREF_P(return_value);
 	}
 }
 
@@ -748,12 +766,12 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, getBoundary)
 {
 	if (SUCCESS == zend_parse_parameters_none()) {
-		php_http_message_body_object_t * obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+		php_http_message_body_object_t * obj = PHP_HTTP_OBJ(NULL, getThis());
 
 		PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
 		if (obj->body->boundary) {
-			RETURN_STRING(obj->body->boundary, 1);
+			RETURN_STRING(obj->body->boundary);
 		}
 	}
 }
@@ -764,13 +782,12 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, append)
 {
 	char *str;
-	int len;
+	size_t len;
 	php_http_message_body_object_t *obj;
 
-	php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len), invalid_arg, return);
-
-	obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+	php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &len), invalid_arg, return);
 
+	obj = PHP_HTTP_OBJ(NULL, getThis());
 	PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
 	php_http_expect(len == php_http_message_body_append(obj->body, str, len), runtime, return);
@@ -787,10 +804,9 @@ PHP_METHOD(HttpMessageBody, addForm)
 	HashTable *fields = NULL, *files = NULL;
 	php_http_message_body_object_t *obj;
 
-	php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|h!h!", &fields, &files), invalid_arg, return);
-
-	obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+	php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|h!h!", &fields, &files), invalid_arg, return);
 
+	obj = PHP_HTTP_OBJ(NULL, getThis());
 	PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
 	php_http_expect(SUCCESS == php_http_message_body_add_form(obj->body, fields, files), runtime, return);
@@ -808,16 +824,16 @@ PHP_METHOD(HttpMessageBody, addPart)
 	php_http_message_object_t *mobj;
 	zend_error_handling zeh;
 
-	php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zobj, php_http_message_class_entry), invalid_arg, return);
+	php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &zobj, php_http_message_get_class_entry()), invalid_arg, return);
 
-	obj = zend_object_store_get_object(getThis() TSRMLS_CC);
-	mobj = zend_object_store_get_object(zobj TSRMLS_CC);
+	obj = PHP_HTTP_OBJ(NULL, getThis());
+	mobj = PHP_HTTP_OBJ(NULL, zobj);
 
 	PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
-	zend_replace_error_handling(EH_THROW, php_http_exception_runtime_class_entry, &zeh TSRMLS_CC);
+	zend_replace_error_handling(EH_THROW, php_http_get_exception_runtime_class_entry(), &zeh);
 	php_http_message_body_add_part(obj->body, mobj->message);
-	zend_restore_error_handling(&zeh TSRMLS_CC);
+	zend_restore_error_handling(&zeh);
 
 	if (!EG(exception)) {
 		RETURN_ZVAL(getThis(), 1, 0);
@@ -829,13 +845,13 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, etag)
 {
 	if (SUCCESS == zend_parse_parameters_none()) {
-		php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+		php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
 		char *etag;
 
 		PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
 
 		if ((etag = php_http_message_body_etag(obj->body))) {
-			RETURN_STRING(etag, 0);
+			RETURN_STR(php_http_cs2zs(etag, strlen(etag)));
 		} else {
 			RETURN_FALSE;
 		}
@@ -848,10 +864,10 @@ ZEND_END_ARG_INFO();
 PHP_METHOD(HttpMessageBody, stat)
 {
 	char *field_str = NULL;
-	int field_len = 0;
+	size_t field_len = 0;
 
-	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &field_str, &field_len)) {
-		php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_str, &field_len)) {
+		php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
 		const php_stream_statbuf *sb;
 
 		PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
@@ -876,22 +892,22 @@ PHP_METHOD(HttpMessageBody, stat)
 							RETURN_LONG(sb->sb.st_ctime);
 							break;
 						default:
-							php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown stat field: '%s' (should be one of [s]ize, [a]time, [m]time or [c]time)", field_str);
+							php_error_docref(NULL, E_WARNING, "Unknown stat field: '%s' (should be one of [s]ize, [a]time, [m]time or [c]time)", field_str);
 							break;
 					}
 			} else {
 				object_init(return_value);
-				add_property_long_ex(return_value, ZEND_STRS("size"), sb->sb.st_size TSRMLS_CC);
-				add_property_long_ex(return_value, ZEND_STRS("atime"), sb->sb.st_atime TSRMLS_CC);
-				add_property_long_ex(return_value, ZEND_STRS("mtime"), sb->sb.st_mtime TSRMLS_CC);
-				add_property_long_ex(return_value, ZEND_STRS("ctime"), sb->sb.st_ctime TSRMLS_CC);
+				add_property_long_ex(return_value, ZEND_STRL("size"), sb->sb.st_size);
+				add_property_long_ex(return_value, ZEND_STRL("atime"), sb->sb.st_atime);
+				add_property_long_ex(return_value, ZEND_STRL("mtime"), sb->sb.st_mtime);
+				add_property_long_ex(return_value, ZEND_STRL("ctime"), sb->sb.st_ctime);
 			}
 		}
 	}
 }
 
 static zend_function_entry php_http_message_body_methods[] = {
-	PHP_ME(HttpMessageBody, __construct,  ai_HttpMessageBody___construct,  ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
+	PHP_ME(HttpMessageBody, __construct,  ai_HttpMessageBody___construct,  ZEND_ACC_PUBLIC)
 	PHP_ME(HttpMessageBody, __toString,   ai_HttpMessageBody___toString,   ZEND_ACC_PUBLIC)
 	PHP_MALIAS(HttpMessageBody, toString, __toString, ai_HttpMessageBody___toString, ZEND_ACC_PUBLIC)
 	PHP_MALIAS(HttpMessageBody, serialize, __toString, ai_HttpMessageBody___toString, ZEND_ACC_PUBLIC)
@@ -908,18 +924,19 @@ static zend_function_entry php_http_message_body_methods[] = {
 	EMPTY_FUNCTION_ENTRY
 };
 
-zend_class_entry *php_http_message_body_class_entry;
-
 PHP_MINIT_FUNCTION(http_message_body)
 {
 	zend_class_entry ce = {0};
 
 	INIT_NS_CLASS_ENTRY(ce, "http\\Message", "Body", php_http_message_body_methods);
-	php_http_message_body_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+	php_http_message_body_class_entry = zend_register_internal_class(&ce);
 	php_http_message_body_class_entry->create_object = php_http_message_body_object_new;
 	memcpy(&php_http_message_body_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	php_http_message_body_object_handlers.offset = XtOffsetOf(php_http_message_body_object_t, zo);
 	php_http_message_body_object_handlers.clone_obj = php_http_message_body_object_clone;
-	zend_class_implements(php_http_message_body_class_entry TSRMLS_CC, 1, zend_ce_serializable);
+	php_http_message_body_object_handlers.free_obj = php_http_message_body_object_free;
+	php_http_message_body_object_handlers.get_gc = php_http_message_body_object_get_gc;
+	zend_class_implements(php_http_message_body_class_entry, 1, zend_ce_serializable);
 
 	return SUCCESS;
 }