MFH

7 files changed, 101 insertions, 77 deletions

diff --git a/ext/pdo_mysql/mysql_driver.c b/ext/pdo_mysql/mysql_driver.c
index 581766b38a..b39fdfaaa2 100644
--- a/ext/pdo_mysql/mysql_driver.c
+++ b/ext/pdo_mysql/mysql_driver.c
@@ -130,7 +130,7 @@ static int pdo_mysql_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *in
 
 	if (einfo->errcode) {
 		add_next_index_long(info, einfo->errcode);
-		add_next_index_string(info, einfo->errmsg, 1);
+		add_next_index_string(info, einfo->errmsg);
 	}
 
 	PDO_DBG_RETURN(1);
@@ -376,26 +376,31 @@ static int pdo_mysql_set_attribute(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_D
 	switch (attr) {
 		case PDO_ATTR_AUTOCOMMIT:		
 			convert_to_boolean(val);
-	
 			/* ignore if the new value equals the old one */			
-			if (dbh->auto_commit ^ Z_BVAL_P(val)) {
-				dbh->auto_commit = Z_BVAL_P(val);
+			if (dbh->auto_commit ^ (Z_TYPE_P(val) == IS_TRUE)) {
+				dbh->auto_commit = (Z_TYPE_P(val) == IS_TRUE);
 				mysql_handle_autocommit(dbh TSRMLS_CC);
 			}
 			PDO_DBG_RETURN(1);
 
 		case PDO_MYSQL_ATTR_USE_BUFFERED_QUERY:
-			((pdo_mysql_db_handle *)dbh->driver_data)->buffered = Z_BVAL_P(val);
+			convert_to_boolean(val);
+			/* ignore if the new value equals the old one */			
+			((pdo_mysql_db_handle *)dbh->driver_data)->buffered = (Z_TYPE_P(val) == IS_TRUE);
 			PDO_DBG_RETURN(1);
 		case PDO_MYSQL_ATTR_DIRECT_QUERY:
 		case PDO_ATTR_EMULATE_PREPARES:
-			((pdo_mysql_db_handle *)dbh->driver_data)->emulate_prepare = Z_BVAL_P(val);
+			convert_to_boolean(val);
+			/* ignore if the new value equals the old one */			
+			((pdo_mysql_db_handle *)dbh->driver_data)->emulate_prepare = (Z_TYPE_P(val) == IS_TRUE);
 			PDO_DBG_RETURN(1);
 		case PDO_ATTR_FETCH_TABLE_NAMES:
-			((pdo_mysql_db_handle *)dbh->driver_data)->fetch_table_names = Z_BVAL_P(val);
+			convert_to_boolean(val);
+			((pdo_mysql_db_handle *)dbh->driver_data)->fetch_table_names = (Z_TYPE_P(val) == IS_TRUE);
 			PDO_DBG_RETURN(1);
 #ifndef PDO_USE_MYSQLND
 		case PDO_MYSQL_ATTR_MAX_BUFFER_SIZE:
+			convert_to_long(val);
 			if (Z_LVAL_P(val) < 0) {
 				/* TODO: Johannes, can we throw a warning here? */
  				((pdo_mysql_db_handle *)dbh->driver_data)->max_buffer_size = 1024*1024;
@@ -423,26 +428,26 @@ static int pdo_mysql_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value
 	PDO_DBG_INF_FMT("attr=%l", attr);
 	switch (attr) {
 		case PDO_ATTR_CLIENT_VERSION:
-			ZVAL_STRING(return_value, (char *)mysql_get_client_info(), 1);
+			ZVAL_STRING(return_value, (char *)mysql_get_client_info());
 			break;
 
 		case PDO_ATTR_SERVER_VERSION:
-			ZVAL_STRING(return_value, (char *)mysql_get_server_info(H->server), 1);
+			ZVAL_STRING(return_value, (char *)mysql_get_server_info(H->server));
 			break;
 
 		case PDO_ATTR_CONNECTION_STATUS:
-			ZVAL_STRING(return_value, (char *)mysql_get_host_info(H->server), 1);
+			ZVAL_STRING(return_value, (char *)mysql_get_host_info(H->server));
 			break;
 		case PDO_ATTR_SERVER_INFO: {
-			char *tmp;
 #if defined(PDO_USE_MYSQLND)
-			unsigned int tmp_len;
+			zend_string *tmp;
 
-			if (mysqlnd_stat(H->server, &tmp, &tmp_len) == PASS) {
-				ZVAL_STRINGL(return_value, tmp, tmp_len, 0);
+			if (mysqlnd_stat(H->server, &tmp) == PASS) {
+				ZVAL_STR(return_value, tmp);
 #else
+			char *tmp;
 			if ((tmp = (char *)mysql_stat(H->server))) {
-				ZVAL_STRING(return_value, tmp, 1);
+				ZVAL_STRING(return_value, tmp);
 #endif
 			} else {
 				pdo_mysql_error(dbh);
diff --git a/ext/pdo_mysql/mysql_statement.c b/ext/pdo_mysql/mysql_statement.c
index 95501c22c7..30a2f04f98 100644
--- a/ext/pdo_mysql/mysql_statement.c
+++ b/ext/pdo_mysql/mysql_statement.c
@@ -342,7 +342,9 @@ static int pdo_mysql_stmt_next_rowset(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 {
 	pdo_mysql_stmt *S = (pdo_mysql_stmt*)stmt->driver_data;
 	pdo_mysql_db_handle *H = S->H;
+#if PDO_USE_MYSQLND
 	long row_count;
+#endif
 	PDO_DBG_ENTER("pdo_mysql_stmt_next_rowset");
 	PDO_DBG_INF_FMT("stmt=%p", S->stmt);
 
@@ -402,7 +404,9 @@ static int pdo_mysql_stmt_next_rowset(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 /* ensure that we free any previous unfetched results */
 #ifndef PDO_USE_MYSQLND
 	if (S->stmt) {
-		stmt->column_count = (int)mysql_num_fields(S->result);
+		if (S->result) {
+			stmt->column_count = (int)mysql_num_fields(S->result);
+		}
 		mysql_stmt_free_result(S->stmt);
 	}
 #endif
@@ -448,6 +452,7 @@ static const char * const pdo_param_event_names[] =
 
 static int pdo_mysql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, enum pdo_param_event event_type TSRMLS_DC) /* {{{ */
 {
+	zval *parameter;
 #ifndef PDO_USE_MYSQLND
 	PDO_MYSQL_PARAM_BIND *b;
 #endif
@@ -482,18 +487,22 @@ static int pdo_mysql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_da
 					strcpy(stmt->error_code, "HY093");
 					PDO_DBG_RETURN(0);
 				}
+ 
+				if (!Z_ISREF(param->parameter)) {
+					parameter = &param->parameter;
+				} else {
+					parameter = Z_REFVAL(param->parameter);
+				}
 
 #if PDO_USE_MYSQLND
-				if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL ||
-						Z_TYPE_P(param->parameter) == IS_NULL) {
-					mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, param->parameter, MYSQL_TYPE_NULL);
+				if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL || (Z_TYPE_P(parameter) == IS_NULL)) {
+					mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, parameter, MYSQL_TYPE_NULL);
 					PDO_DBG_RETURN(1);
 				}
 #else
 				b = (PDO_MYSQL_PARAM_BIND*)param->driver_data;
 				*b->is_null = 0;
-				if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL ||
-						Z_TYPE_P(param->parameter) == IS_NULL) {
+				if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL || Z_TYPE_P(parameter) == IS_NULL) {
 					*b->is_null = 1;
 					b->buffer_type = MYSQL_TYPE_STRING;
 					b->buffer = NULL;
@@ -508,14 +517,16 @@ static int pdo_mysql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_da
 						PDO_DBG_RETURN(0);
 					case PDO_PARAM_LOB:
 						PDO_DBG_INF("PDO_PARAM_LOB");
-						if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
+						if (!Z_ISREF(param->parameter)) {
+							parameter = &param->parameter;
+						} else {
+							parameter = Z_REFVAL(param->parameter);
+						}
+						if (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) {
-								SEPARATE_ZVAL_IF_NOT_REF(&param->parameter);
-								Z_TYPE_P(param->parameter) = IS_STRING;
-								Z_STRLEN_P(param->parameter) = php_stream_copy_to_mem(stm,
-									&Z_STRVAL_P(param->parameter), PHP_STREAM_COPY_ALL, 0);
+								ZVAL_STR(parameter, php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0));
 							} else {
 								pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource" TSRMLS_CC);
 								return 0;
@@ -529,20 +540,25 @@ static int pdo_mysql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_da
 
 #if PDO_USE_MYSQLND
 				/* Is it really correct to check the zval's type? - But well, that's what the old code below does, too */
-				PDO_DBG_INF_FMT("param->parameter->type=%d", Z_TYPE_P(param->parameter));
-				switch (Z_TYPE_P(param->parameter)) {
+				PDO_DBG_INF_FMT("param->parameter->type=%d", Z_TYPE(param->parameter));
+				if (!Z_ISREF(param->parameter)) {
+					parameter = &param->parameter;
+				} else {
+					parameter = Z_REFVAL(param->parameter);
+				}
+				switch (Z_TYPE_P(parameter)) {
 					case IS_STRING:
-						mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, param->parameter, MYSQL_TYPE_VAR_STRING);
+						mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, parameter, MYSQL_TYPE_VAR_STRING);
 						break;
 					case IS_LONG:
 #if SIZEOF_LONG==8
-						mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, param->parameter, MYSQL_TYPE_LONGLONG);
+						mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, parameter, MYSQL_TYPE_LONGLONG);
 #elif SIZEOF_LONG==4
-						mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, param->parameter, MYSQL_TYPE_LONG);
+						mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, parameter, MYSQL_TYPE_LONG);
 #endif /* SIZEOF_LONG */
 						break;
 					case IS_DOUBLE:
-						mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, param->parameter, MYSQL_TYPE_DOUBLE);
+						mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, parameter, MYSQL_TYPE_DOUBLE);
 						break;
 					default:
 						PDO_DBG_RETURN(0);
@@ -550,23 +566,28 @@ static int pdo_mysql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_da
 
 				PDO_DBG_RETURN(1);
 #else
-				PDO_DBG_INF_FMT("param->parameter->type=%d", Z_TYPE_P(param->parameter));
-				switch (Z_TYPE_P(param->parameter)) {
+				PDO_DBG_INF_FMT("param->parameter->type=%d", Z_TYPE(param->parameter));
+				if (!Z_ISREF(param->parameter)) {
+					parameter = &param->parameter;
+				} else {
+					parameter = Z_REFVAL(param->parameter);
+				}
+				switch (Z_TYPE_P(parameter)) {
 					case IS_STRING:
 						b->buffer_type = MYSQL_TYPE_STRING;
-						b->buffer = Z_STRVAL_P(param->parameter);
-						b->buffer_length = Z_STRLEN_P(param->parameter);
-						*b->length = Z_STRLEN_P(param->parameter);
+						b->buffer = Z_STRVAL_P(parameter);
+						b->buffer_length = Z_STRLEN_P(parameter);
+						*b->length = Z_STRLEN_P(parameter);
 						PDO_DBG_RETURN(1);
 
 					case IS_LONG:
 						b->buffer_type = MYSQL_TYPE_LONG;
-						b->buffer = &Z_LVAL_P(param->parameter);
+						b->buffer = &Z_LVAL_P(parameter);
 						PDO_DBG_RETURN(1);
 
 					case IS_DOUBLE:
 						b->buffer_type = MYSQL_TYPE_DOUBLE;
-						b->buffer = &Z_DVAL_P(param->parameter);
+						b->buffer = &Z_DVAL_P(parameter);
 						PDO_DBG_RETURN(1);
 
 					default:
@@ -681,9 +702,8 @@ static int pdo_mysql_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC) /* {{{
 			namelen = spprintf(&cols[i].name, 0, "%s.%s", S->fields[i].table, S->fields[i].name);
 			cols[i].namelen = namelen;
 		} else {
-			namelen = strlen(S->fields[i].name);
-			cols[i].namelen = namelen;
-			cols[i].name = estrndup(S->fields[i].name, namelen);
+			cols[i].namelen = S->fields[i].name_length;
+			cols[i].name = estrndup(S->fields[i].name, S->fields[i].name_length);
 		}
 
 		cols[i].precision = S->fields[i].decimals;
@@ -725,7 +745,7 @@ static int pdo_mysql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsig
 	}
 #if PDO_USE_MYSQLND
 	if (S->stmt) {
-		Z_ADDREF_P(S->stmt->data->result_bind[colno].zv);
+		Z_TRY_ADDREF(S->stmt->data->result_bind[colno].zv);
 		*ptr = (char*)&S->stmt->data->result_bind[colno].zv;
 		*len = sizeof(zval);
 		PDO_DBG_RETURN(1);
@@ -807,7 +827,7 @@ static int pdo_mysql_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_va
 {
 	pdo_mysql_stmt *S = (pdo_mysql_stmt*)stmt->driver_data;
 	const MYSQL_FIELD *F;
-	zval *flags;
+	zval flags;
 	char *str;
 
 	PDO_DBG_ENTER("pdo_mysql_stmt_col_meta");
@@ -821,32 +841,31 @@ static int pdo_mysql_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_va
 	}
 
 	array_init(return_value);
-	MAKE_STD_ZVAL(flags);
-	array_init(flags);
+	array_init(&flags);
 
 	F = S->fields + colno;
 
 	if (F->def) {
-		add_assoc_string(return_value, "mysql:def", F->def, 1);
+		add_assoc_string(return_value, "mysql:def", F->def);
 	}
 	if (IS_NOT_NULL(F->flags)) {
-		add_next_index_string(flags, "not_null", 1);
+		add_next_index_string(&flags, "not_null");
 	}
 	if (IS_PRI_KEY(F->flags)) {
-		add_next_index_string(flags, "primary_key", 1);
+		add_next_index_string(&flags, "primary_key");
 	}
 	if (F->flags & MULTIPLE_KEY_FLAG) {
-		add_next_index_string(flags, "multiple_key", 1);
+		add_next_index_string(&flags, "multiple_key");
 	}
 	if (F->flags & UNIQUE_KEY_FLAG) {
-		add_next_index_string(flags, "unique_key", 1);
+		add_next_index_string(&flags, "unique_key");
 	}
 	if (IS_BLOB(F->flags)) {
-		add_next_index_string(flags, "blob", 1);
+		add_next_index_string(&flags, "blob");
 	}
 	str = type_to_name_native(F->type);
 	if (str) {
-		add_assoc_string(return_value, "native_type", str, 1);
+		add_assoc_string(return_value, "native_type", str);
 	}
 
 #ifdef PDO_USE_MYSQLND
@@ -868,8 +887,9 @@ static int pdo_mysql_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_va
 	}
 #endif
 
-	add_assoc_zval(return_value, "flags", flags);
-	add_assoc_string(return_value, "table", (char *) (F->table?F->table:""), 1);
+	add_assoc_zval(return_value, "flags", &flags);
+	add_assoc_string(return_value, "table", (char *) (F->table?F->table : ""));
+
 	PDO_DBG_RETURN(SUCCESS);
 } /* }}} */
 
diff --git a/ext/pdo_mysql/pdo_mysql.c b/ext/pdo_mysql/pdo_mysql.c
index 6f4e9d5265..c3a90fedac 100644
--- a/ext/pdo_mysql/pdo_mysql.c
+++ b/ext/pdo_mysql/pdo_mysql.c
@@ -62,7 +62,7 @@ ZEND_DECLARE_MODULE_GLOBALS(pdo_mysql)
 static MYSQLND * pdo_mysql_convert_zv_to_mysqlnd(zval * zv TSRMLS_DC)
 {
 	if (Z_TYPE_P(zv) == IS_OBJECT && instanceof_function(Z_OBJCE_P(zv), php_pdo_get_dbh_ce() TSRMLS_CC)) {
-		pdo_dbh_t * dbh = zend_object_store_get_object(zv TSRMLS_CC);
+		pdo_dbh_t * dbh = Z_PDO_DBH_P(zv);
 
 		if (!dbh) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to retrieve handle from object store");
diff --git a/ext/pdo_mysql/php_pdo_mysql_int.h b/ext/pdo_mysql/php_pdo_mysql_int.h
index 26263222b9..4455dcbeb6 100644
--- a/ext/pdo_mysql/php_pdo_mysql_int.h
+++ b/ext/pdo_mysql/php_pdo_mysql_int.h
@@ -118,31 +118,31 @@ typedef struct {
 
 typedef struct {
 	pdo_mysql_db_handle 	*H;
-	MYSQL_RES		*result;
-	const MYSQL_FIELD	*fields;
-	MYSQL_ROW		current_data;
+	MYSQL_RES				*result;
+	const MYSQL_FIELD		*fields;
+	MYSQL_ROW				current_data;
 #if PDO_USE_MYSQLND
-	unsigned long		*current_lengths;
+	unsigned long			*current_lengths;
 #else
-	long			*current_lengths;
+	long					*current_lengths;
 #endif
-	pdo_mysql_error_info einfo;
+	pdo_mysql_error_info 	einfo;
 #if PDO_USE_MYSQLND
-	MYSQLND_STMT 		*stmt;
+	MYSQLND_STMT 			*stmt;
 #else
-	MYSQL_STMT		*stmt;
+	MYSQL_STMT				*stmt;
 #endif	
-	int num_params;
+	int 					num_params;
 	PDO_MYSQL_PARAM_BIND	*params;
 #ifndef PDO_USE_MYSQLND
-	my_bool			*in_null;
-	unsigned long		*in_length;
+	my_bool					*in_null;
+	unsigned long			*in_length;
 #endif
 	PDO_MYSQL_PARAM_BIND	*bound_result;
-	my_bool			*out_null;
-	unsigned long		*out_length;
-	unsigned int		params_given;
-	unsigned		max_length:1;
+	my_bool					*out_null;
+	unsigned long			*out_length;
+	unsigned int			params_given;
+	unsigned				max_length:1;
 } pdo_mysql_stmt;
 
 extern pdo_driver_t pdo_mysql_driver;
diff --git a/ext/pdo_mysql/tests/bug63176.phpt b/ext/pdo_mysql/tests/bug63176.phpt
index ee928c093d..c5be644450 100644
--- a/ext/pdo_mysql/tests/bug63176.phpt
+++ b/ext/pdo_mysql/tests/bug63176.phpt
@@ -47,8 +47,8 @@ object(ModelA)#%d (1) {
 }
 object(ModelA)#%d (1) {
   ["db"]=>
-  object(PDO2)#%d (1) {
-    ["transLevel":protected]=>
+  object(PDO3)#%d (1) {
+    ["tomato":protected]=>
     NULL
   }
 }
diff --git a/ext/pdo_mysql/tests/config.inc b/ext/pdo_mysql/tests/config.inc
index 2530442c0e..f5ea020b78 100644
--- a/ext/pdo_mysql/tests/config.inc
+++ b/ext/pdo_mysql/tests/config.inc
@@ -49,4 +49,4 @@ if (!function_exists('sys_get_temp_dir')) {
 		return FALSE;
 	}
 }
-?>
\ No newline at end of file
+?>
diff --git a/ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt b/ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt
index c992d3acf9..49bd5551ac 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt
@@ -102,5 +102,4 @@ require dirname(__FILE__) . '/mysql_pdo_test.inc';
 MySQLPDOTest::dropTestTable();
 ?>
 --EXPECTF--
-[001] Call to PDO::setAttribute(int attribute, mixed value) has changed the type of value from integer to boolean, test will not work properly
-done!
\ No newline at end of file
+done!