Merge branch 'phpng' of git.php.net:php-src into phpng

# By Xinchen Hui (3) and Dmitry Stogov (2)
# Via Xinchen Hui (3) and Dmitry Stogov (2)
* 'phpng' of git.php.net:php-src:
  Fixed iterator destruction
  Fixed uninitialized value used
  Finish ext/pdo_pgsql (3 tests fail, 1 due to knew issue, 2 also fails in trunk)
  Fixed memory leaks
  Fixed several test failed

4 files changed, 52 insertions, 33 deletions

diff --git a/ext/pdo_pgsql/pgsql_driver.c b/ext/pdo_pgsql/pgsql_driver.c
index 2b7f217418..4ab3bdb6d6 100644
--- a/ext/pdo_pgsql/pgsql_driver.c
+++ b/ext/pdo_pgsql/pgsql_driver.c
@@ -1092,8 +1092,8 @@ static const zend_function_entry dbh_methods[] = {
 	PHP_ME(PDO, pgsqlCopyFromFile, NULL, ZEND_ACC_PUBLIC)
 	PHP_ME(PDO, pgsqlCopyToArray, NULL, ZEND_ACC_PUBLIC)
 	PHP_ME(PDO, pgsqlCopyToFile, NULL, ZEND_ACC_PUBLIC)
-        PHP_ME(PDO, pgsqlGetNotify, NULL, ZEND_ACC_PUBLIC)
-        PHP_ME(PDO, pgsqlGetPid, NULL, ZEND_ACC_PUBLIC)
+    PHP_ME(PDO, pgsqlGetNotify, NULL, ZEND_ACC_PUBLIC)
+    PHP_ME(PDO, pgsqlGetPid, NULL, ZEND_ACC_PUBLIC)
 	PHP_FE_END
 };
 
@@ -1113,13 +1113,16 @@ static int pdo_pgsql_set_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
 
 	switch (attr) {
 		case PDO_ATTR_EMULATE_PREPARES:
+			convert_to_long(val);
 			H->emulate_prepares = Z_LVAL_P(val);
 			return 1;
 		case PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT:
+			convert_to_long(val);
 			php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "PDO::PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT is deprecated, use PDO::ATTR_EMULATE_PREPARES instead");
 			H->disable_native_prepares = Z_LVAL_P(val);
 			return 1;
 		case PDO_PGSQL_ATTR_DISABLE_PREPARES:
+			convert_to_long(val);
 			H->disable_prepares = Z_LVAL_P(val);
 			return 1;
 		default:
diff --git a/ext/pdo_pgsql/pgsql_statement.c b/ext/pdo_pgsql/pgsql_statement.c
index d4cf99f9d1..10e775d899 100644
--- a/ext/pdo_pgsql/pgsql_statement.c
+++ b/ext/pdo_pgsql/pgsql_statement.c
@@ -259,11 +259,11 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
 						param->paramno = atoi(param->name->val + 1);
 					} else {
 						/* resolve parameter name to rewritten name */
-						zval *namevar;
+						char *namevar;
 
-						if (stmt->bound_param_map && (namevar = zend_hash_find(stmt->bound_param_map,
+						if (stmt->bound_param_map && (namevar = zend_hash_find_ptr(stmt->bound_param_map,
 								param->name)) != NULL) {
-							param->paramno = atoi(((zend_string*)Z_PTR_P(namevar))->val + 1) - 1;
+							param->paramno = atoi(namevar + 1) - 1;
 						} else {
 							pdo_raise_impl_error(stmt->dbh, stmt, "HY093", param->name->val TSRMLS_CC);
 							return 0;
@@ -298,15 +298,23 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
 							sizeof(Oid));
 				}
 				if (param->paramno >= 0) {
+					zval *parameter;
+
 					if (param->paramno > zend_hash_num_elements(stmt->bound_param_map)) {
 						pdo_pgsql_error_stmt(stmt, PGRES_FATAL_ERROR, "HY105");
 						return 0;
 					}
 
+					if (Z_ISREF(param->parameter)) {
+						parameter = Z_REFVAL(param->parameter);
+					} else {
+						parameter = &param->parameter;
+					}
+					
 					if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB &&
-							Z_TYPE(param->parameter) == IS_RESOURCE) {
+							Z_TYPE_P(parameter) == IS_RESOURCE) {
 						php_stream *stm;
-						php_stream_from_zval_no_verify(stm, &param->parameter);
+						php_stream_from_zval_no_verify(stm, parameter);
 						if (stm) {
 							if (php_stream_is(stm, &pdo_pgsql_lob_stream_ops)) {
 								struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stm->abstract;
@@ -325,10 +333,10 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
 							} else {
 								zend_string *str = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);
 								if (str != NULL) {
-									SEPARATE_ZVAL_IF_NOT_REF(&param->parameter);
-									ZVAL_STR(&param->parameter, str);
+									//??SEPARATE_ZVAL_IF_NOT_REF(&param->parameter);
+									ZVAL_STR(parameter, str);
 								} else {
-									ZVAL_EMPTY_STRING(&param->parameter);
+									ZVAL_EMPTY_STRING(parameter);
 								}
 							}
 						} else {
@@ -339,18 +347,18 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
 					}
 
 					if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL ||
-							Z_TYPE(param->parameter) == IS_NULL) {
+							Z_TYPE_P(parameter) == IS_NULL) {
 						S->param_values[param->paramno] = NULL;
 						S->param_lengths[param->paramno] = 0;
-					} else if (Z_TYPE(param->parameter) == IS_FALSE || Z_TYPE(param->parameter) == IS_TRUE) {
-						S->param_values[param->paramno] = Z_TYPE(param->parameter) == IS_TRUE ? "t" : "f";
+					} else if (Z_TYPE_P(parameter) == IS_FALSE || Z_TYPE_P(parameter) == IS_TRUE) {
+						S->param_values[param->paramno] = Z_TYPE_P(parameter) == IS_TRUE ? "t" : "f";
 						S->param_lengths[param->paramno] = 1;
 						S->param_formats[param->paramno] = 0;
 					} else {
-						SEPARATE_ZVAL_IF_NOT_REF(&param->parameter);
-						convert_to_string_ex(&param->parameter);
-						S->param_values[param->paramno] = Z_STRVAL(param->parameter);
-						S->param_lengths[param->paramno] = Z_STRLEN(param->parameter);
+						//SEPARATE_ZVAL_IF_NOT_REF(&param->parameter);
+						convert_to_string_ex(parameter);
+						S->param_values[param->paramno] = Z_STRVAL_P(parameter);
+						S->param_lengths[param->paramno] = Z_STRLEN_P(parameter);
 						S->param_formats[param->paramno] = 0;
 					}
 
@@ -367,9 +375,15 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
 		/* We need to manually convert to a pg native boolean value */
 		if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_BOOL &&
 			((param->param_type & PDO_PARAM_INPUT_OUTPUT) != PDO_PARAM_INPUT_OUTPUT)) {
+			zval *parameter;
+			if (Z_ISREF(param->parameter)) {
+				parameter = Z_REFVAL(param->parameter);
+			} else {
+				parameter = &param->parameter;
+			}
 			SEPARATE_ZVAL(&param->parameter);
 			param->param_type = PDO_PARAM_STR;
-			ZVAL_STRINGL(&param->parameter, Z_TYPE(param->parameter) == IS_TRUE ? "t" : "f", 1);
+			ZVAL_STRINGL(parameter, Z_TYPE_P(parameter) == IS_TRUE ? "t" : "f", 1);
 		}
 	}
 	return 1;
@@ -439,7 +453,7 @@ static int pgsql_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
 	cols[colno].precision = PQfmod(S->result, colno);
 	S->cols[colno].pgsql_type = PQftype(S->result, colno);
 
-	switch(S->cols[colno].pgsql_type) {
+	switch (S->cols[colno].pgsql_type) {
 
 		case BOOLOID:
 			cols[colno].param_type = PDO_PARAM_BOOL;
@@ -501,7 +515,7 @@ static int pgsql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned
 		*ptr = PQgetvalue(S->result, S->current_row - 1, colno);
 		*len = PQgetlength(S->result, S->current_row - 1, colno);
 
-		switch(cols[colno].param_type) {
+		switch (cols[colno].param_type) {
 
 			case PDO_PARAM_INT:
 				S->cols[colno].intval = atol(*ptr);
diff --git a/ext/soap/php_encoding.c b/ext/soap/php_encoding.c
index 8ea419dc1b..69dcbec517 100644
--- a/ext/soap/php_encoding.c
+++ b/ext/soap/php_encoding.c
@@ -2301,7 +2301,7 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod
 			}
 		}
 iterator_done:
-		iter->funcs->dtor(iter TSRMLS_CC);
+		OBJ_RELEASE(&iter->std);
 		if (EG(exception)) {
 			zval_ptr_dtor(&array_copy);
 			ZVAL_UNDEF(&array_copy);
diff --git a/ext/soap/php_http.c b/ext/soap/php_http.c
index a9eb2ae719..1fa386043d 100644
--- a/ext/soap/php_http.c
+++ b/ext/soap/php_http.c
@@ -378,26 +378,28 @@ int make_http_soap_request(zval  *this_ptr,
 			zval params[3];
 			int n;
 
-			//???ZVAL_STRINGL(params[0], buf, buf_size, 0);
 			ZVAL_STRINGL(&params[0], buf, buf_size);
 			ZVAL_LONG(&params[1], level);
-	    if (kind == SOAP_COMPRESSION_DEFLATE) {
-	    	n = 2;
-				//???ZVAL_STRING(&func, "gzcompress", 0);
+			if (kind == SOAP_COMPRESSION_DEFLATE) {
+				n = 2;
 				ZVAL_STRING(&func, "gzcompress");
 				smart_str_append_const(&soap_headers_z,"Content-Encoding: deflate\r\n");
-	    } else {
-	      n = 3;
-				//???ZVAL_STRING(&func, "gzencode", 0);
+			} else {
+				n = 3;
 				ZVAL_STRING(&func, "gzencode");
 				smart_str_append_const(&soap_headers_z,"Content-Encoding: gzip\r\n");
 				ZVAL_LONG(&params[2], 0x1f);
-	    }
+			}
 			if (call_user_function(CG(function_table), (zval*)NULL, &func, &retval, n, params TSRMLS_CC) == SUCCESS &&
 			    Z_TYPE(retval) == IS_STRING) {
+				zval_ptr_dtor(&params[0]);
+				zval_ptr_dtor(&func);
+// TODO: free retval ???
 				request = Z_STRVAL(retval);
 				request_size = Z_STRLEN(retval);
 			} else {
+				zval_ptr_dtor(&params[0]);
+				zval_ptr_dtor(&func);
 				if (request != buf) {efree(request);}
 				smart_str_free(&soap_headers_z);
 				return FALSE;
@@ -1234,14 +1236,10 @@ try_again:
 		if ((strcmp(content_encoding,"gzip") == 0 ||
 		     strcmp(content_encoding,"x-gzip") == 0) &&
 		     zend_hash_str_exists(EG(function_table), "gzinflate", sizeof("gzinflate")-1)) {
-			//???ZVAL_STRING(&func, "gzinflate", 0);
-			//???ZVAL_STRINGL(params[0], http_body+10, http_body_size-10, 0);
 			ZVAL_STRING(&func, "gzinflate");
 			ZVAL_STRINGL(&params[0], http_body+10, http_body_size-10);
 		} else if (strcmp(content_encoding,"deflate") == 0 &&
 		           zend_hash_str_exists(EG(function_table), "gzuncompress", sizeof("gzuncompress")-1)) {
-			//???ZVAL_STRING(&func, "gzuncompress", 0);
-			//???ZVAL_STRINGL(params[0], http_body, http_body_size, 0);
 			ZVAL_STRING(&func, "gzuncompress");
 			ZVAL_STRINGL(&params[0], http_body, http_body_size);
 		} else {
@@ -1256,9 +1254,13 @@ try_again:
 		}
 		if (call_user_function(CG(function_table), (zval*)NULL, &func, &retval, 1, params TSRMLS_CC) == SUCCESS &&
 		    Z_TYPE(retval) == IS_STRING) {
+			zval_ptr_dtor(&params[0]);
+			zval_ptr_dtor(&func);
 			efree(http_body);
 			ZVAL_COPY_VALUE(return_value, &retval);
 		} else {
+			zval_ptr_dtor(&params[0]);
+			zval_ptr_dtor(&func);
 			efree(content_encoding);
 			efree(http_headers);
 			efree(http_body);