Promote warnings to Errors in sockets's extension.

Author: Girgias

ext/sockets/conversions.c

@@ -241,26 +241,26 @@ static void from_zval_write_aggregation(const zval *container,
 	zval					*elem;
 
 	if (Z_TYPE_P(container) != IS_ARRAY) {
-		do_from_zval_err(ctx, "%s", "expected an array here");
+		zend_type_error("Expected array");
+		return;
 	}
 
 	for (descr = descriptors; descr->name != NULL && !ctx->err.has_error; descr++) {
 		if ((elem = zend_hash_str_find(Z_ARRVAL_P(container),
 				descr->name, descr->name_size - 1)) != NULL) {
 
 			if (descr->from_zval == NULL) {
-				do_from_zval_err(ctx, "No information on how to convert value "
-						"of key '%s'", descr->name);
-				break;
+				zend_value_error("Impossible to convert value of key '%s'", descr->name);
+				return;
 			}
 
 			zend_llist_add_element(&ctx->keys, (void*)&descr->name);
 			descr->from_zval(elem, ((char*)structure) + descr->field_offset, ctx);
 			zend_llist_remove_tail(&ctx->keys);
 
 		} else if (descr->required) {
-			do_from_zval_err(ctx, "The key '%s' is required", descr->name);
-			break;
+			zend_value_error("The key '%s' is required", descr->name);
+			return;
 		}
 	}
 }
@@ -339,15 +339,13 @@ static zend_long from_zval_integer_common(const zval *arr_value, ser_context *ct
 		}
 
 		/* if we get here, we don't have a numeric string */
-		do_from_zval_err(ctx, "expected an integer, but got a non numeric "
-				"string (possibly from a converted object): '%s'", Z_STRVAL_P(arr_value));
-		break;
+		zend_type_error("Expected an integer, received a non numeric string: '%s'", Z_STRVAL_P(arr_value));
+		return ret;
 	}
 
 	default:
-		do_from_zval_err(ctx, "%s", "expected an integer, either of a PHP "
-				"integer type or of a convertible type");
-		break;
+		zend_type_error("Expected an integer");
+		return ret;
 	}
 
 	zval_ptr_dtor(&lzval);
@@ -365,8 +363,7 @@ void from_zval_write_int(const zval *arr_value, char *field, ser_context *ctx)
 	}
 
 	if (lval > INT_MAX || lval < INT_MIN) {
-		do_from_zval_err(ctx, "%s", "given PHP integer is out of bounds "
-				"for a native int");
+		zend_value_error("Provided PHP integer is out of bounds for a native int");
 		return;
 	}
 
@@ -384,8 +381,7 @@ static void from_zval_write_uint32(const zval *arr_value, char *field, ser_conte
 	}
 
 	if (sizeof(zend_long) > sizeof(uint32_t) && (lval < 0 || lval > 0xFFFFFFFF)) {
-		do_from_zval_err(ctx, "%s", "given PHP integer is out of bounds "
-				"for an unsigned 32-bit integer");
+		zend_value_error("Provided PHP integer is out of bounds for an unsigned 32-bit integer");
 		return;
 	}
 
@@ -403,8 +399,7 @@ static void from_zval_write_net_uint16(const zval *arr_value, char *field, ser_c
 	}
 
 	if (lval < 0 || lval > 0xFFFF) {
-		do_from_zval_err(ctx, "%s", "given PHP integer is out of bounds "
-				"for an unsigned 16-bit integer");
+		zend_value_error("Provided PHP integer is out of bounds for an unsigned 16-bit integer");
 		return;
 	}
 
@@ -422,8 +417,7 @@ static void from_zval_write_sa_family(const zval *arr_value, char *field, ser_co
 	}
 
 	if (lval < 0 || lval > (sa_family_t)-1) { /* sa_family_t is unsigned */
-		do_from_zval_err(ctx, "%s", "given PHP integer is out of bounds "
-				"for a sa_family_t value");
+		zend_value_error("Provided PHP integer is out of bounds for a sa_family_t value");
 		return;
 	}
 
@@ -443,8 +437,7 @@ static void from_zval_write_pid_t(const zval *arr_value, char *field, ser_contex
 	}
 
 	if (lval < 0 || (pid_t)lval != lval) { /* pid_t is signed */
-		do_from_zval_err(ctx, "%s", "given PHP integer is out of bounds "
-				"for a pid_t value");
+		zend_value_error("Provided PHP integer is out of bounds for a pid_t value");
 		return;
 	}
 
@@ -464,14 +457,12 @@ static void from_zval_write_uid_t(const zval *arr_value, char *field, ser_contex
 	/* uid_t can be signed or unsigned (generally unsigned) */
 	if ((uid_t)-1 > (uid_t)0) {
 		if (sizeof(zend_long) > sizeof(uid_t) && (lval < 0 || (uid_t)lval != lval)) {
-			do_from_zval_err(ctx, "%s", "given PHP integer is out of bounds "
-					"for a uid_t value");
+			zend_value_error("Provided PHP integer is out of bounds for a uid_t value");
 			return;
 		}
 	} else {
 		if (sizeof(zend_long) > sizeof(uid_t) && (uid_t)lval != lval) {
-			do_from_zval_err(ctx, "%s", "given PHP integer is out of bounds "
-					"for a uid_t value");
+			zend_value_error("Provided PHP integer is out of bounds for a uid_t value");
 			return;
 		}
 	}
@@ -546,6 +537,7 @@ static void from_zval_write_sin_addr(const zval *zaddr_str, char *inaddr, ser_co
 		memcpy(inaddr, &saddr.sin_addr, sizeof saddr.sin_addr);
 	} else {
 		/* error already emitted, but let's emit another more relevant */
+		/* TODO Convert to ValueError? */
 		do_from_zval_err(ctx, "could not resolve address '%s' to get an AF_INET "
 				"address", ZSTR_VAL(addr_str));
 	}
@@ -562,8 +554,7 @@ static void to_zval_read_sin_addr(const char *data, zval *zv, res_context *ctx)
 	ZVAL_NEW_STR(zv, str);
 
 	if (inet_ntop(AF_INET, addr, Z_STRVAL_P(zv), size) == NULL) {
-		do_to_zval_err(ctx, "could not convert IPv4 address to string "
-				"(errno %d)", errno);
+		zend_value_error("Could not convert IPv4 address to string (errno %d)", errno);
 		return;
 	}
 
@@ -596,6 +587,7 @@ static void from_zval_write_sin6_addr(const zval *zaddr_str, char *addr6, ser_co
 		memcpy(addr6, &saddr6.sin6_addr, sizeof saddr6.sin6_addr);
 	} else {
 		/* error already emitted, but let's emit another more relevant */
+		/* TODO Convert to ValueError? */
 		do_from_zval_err(ctx, "could not resolve address '%s' to get an AF_INET6 "
 				"address", Z_STRVAL_P(zaddr_str));
 	}
@@ -613,8 +605,7 @@ static void to_zval_read_sin6_addr(const char *data, zval *zv, res_context *ctx)
 	ZVAL_NEW_STR(zv, str);
 
 	if (inet_ntop(AF_INET6, addr, Z_STRVAL_P(zv), size) == NULL) {
-		do_to_zval_err(ctx, "could not convert IPv6 address to string "
-				"(errno %d)", errno);
+		zend_value_error("Could not convert IPv6 address to string (errno %d)", errno);
 		return;
 	}
 
@@ -648,13 +639,12 @@ static void from_zval_write_sun_path(const zval *path, char *sockaddr_un_c, ser_
 	 * this is not required, at least on linux for abstract paths. It also
 	 * assumes that the path is not empty */
 	if (ZSTR_LEN(path_str) == 0) {
-		do_from_zval_err(ctx, "%s", "the path is cannot be empty");
+		zend_value_error("The path cannot be empty");
 		zend_tmp_string_release(tmp_path_str);
 		return;
 	}
 	if (ZSTR_LEN(path_str) >= sizeof(saddr->sun_path)) {
-		do_from_zval_err(ctx, "the path is too long, the maximum permitted "
-				"length is %zd", sizeof(saddr->sun_path) - 1);
+		zend_value_error("The path is too long, maximum permitted length is %zd", sizeof(saddr->sun_path) - 1);
 		zend_tmp_string_release(tmp_path_str);
 		return;
 	}
@@ -670,7 +660,7 @@ static void to_zval_read_sun_path(const char *data, zval *zv, res_context *ctx)
 
 	nul_pos = memchr(&saddr->sun_path, '\0', sizeof(saddr->sun_path));
 	if (nul_pos == NULL) {
-		do_to_zval_err(ctx, "could not find a NUL in the path");
+		zend_value_error("Could not find a NUL in the path");
 		return;
 	}
 
@@ -702,7 +692,8 @@ static void from_zval_write_sockaddr_aux(const zval *container,
 	*sockaddr_len = 0;
 
 	if (Z_TYPE_P(container) != IS_ARRAY) {
-		do_from_zval_err(ctx, "%s", "expected an array here");
+		/* TODO improve error message? */
+		zend_type_error("Expected array");
 		return;
 	}
 
@@ -865,16 +856,15 @@ static void from_zval_write_control(const zval			*arr,
 
 	entry = get_ancillary_reg_entry(level, type);
 	if (entry == NULL) {
-		do_from_zval_err(ctx, "cmsghdr with level %d and type %d not supported",
-				level, type);
+		zend_value_error("cmsghdr with level %d and type %d not supported", level, type);
 		return;
 	}
 
 	if (entry->calc_space) {
 		zval *data_elem;
 		/* arr must be an array at this point */
 		if ((data_elem = zend_hash_str_find(Z_ARRVAL_P(arr), "data", sizeof("data") - 1)) == NULL) {
-			do_from_zval_err(ctx, "cmsghdr should have a 'data' element here");
+			zend_value_error("cmsghdr should have a 'data' element here");
 			return;
 		}
 		data_len = entry->calc_space(data_elem, ctx);
@@ -919,7 +909,8 @@ static void from_zval_write_control_array(const zval *arr, char *msghdr_c, ser_c
 	struct msghdr		*msg = (struct msghdr*)msghdr_c;
 
 	if (Z_TYPE_P(arr) != IS_ARRAY) {
-		do_from_zval_err(ctx, "%s", "expected an array here");
+		/* TODO Improve error message */
+		zend_type_error("Expected array");
 		return;
 	}
 
@@ -961,11 +952,11 @@ static void to_zval_read_cmsg_data(const char *cmsghdr_c, zval *zv, res_context
 
 	entry = get_ancillary_reg_entry(cmsg->cmsg_level, cmsg->cmsg_type);
 	if (entry == NULL) {
-		do_to_zval_err(ctx, "cmsghdr with level %d and type %d not supported",
-				cmsg->cmsg_level, cmsg->cmsg_type);
+		zend_value_error("cmsghdr with level %d and type %d not supported", cmsg->cmsg_level, cmsg->cmsg_type);
 		return;
 	}
 	if (CMSG_LEN(entry->size) > cmsg->cmsg_len) {
+		/* TODO Convert? */
 		do_to_zval_err(ctx, "the cmsghdr structure is unexpectedly small; "
 				"expected a length of at least " ZEND_LONG_FMT ", but got " ZEND_LONG_FMT,
 				(zend_long)CMSG_LEN(entry->size), (zend_long)cmsg->cmsg_len);
@@ -1057,8 +1048,8 @@ static void from_zval_write_msghdr_buffer_size(const zval *elem, char *msghdr_c,
 	}
 
 	if (lval < 0 || (zend_ulong)lval > MAX_USER_BUFF_SIZE) {
-		do_from_zval_err(ctx, "the buffer size must be between 1 and " ZEND_LONG_FMT "; "
-				"given " ZEND_LONG_FMT, (zend_long)MAX_USER_BUFF_SIZE, lval);
+		zend_value_error("The buffer size must be between 1 and " ZEND_LONG_FMT ";  given " ZEND_LONG_FMT,
+				(zend_long) MAX_USER_BUFF_SIZE, lval);
 		return;
 	}
 
@@ -1086,7 +1077,8 @@ static void from_zval_write_iov_array(const zval *arr, char *msghdr_c, ser_conte
 	struct msghdr	*msg = (struct msghdr*)msghdr_c;
 
 	if (Z_TYPE_P(arr) != IS_ARRAY) {
-		do_from_zval_err(ctx, "%s", "expected an array here");
+		/* TODO Improve error */
+		zend_type_error("Expected array");
 		return;
 	}
 
@@ -1110,7 +1102,7 @@ static void from_zval_write_controllen(const zval *elem, char *msghdr_c, ser_con
 	 */
 	from_zval_write_uint32(elem, (char*)&len, ctx);
 	if (!ctx->err.has_error && len == 0) {
-		do_from_zval_err(ctx, "controllen cannot be 0");
+		zend_value_error("controllen cannot be 0");
 		return;
 	}
 	msghdr->msg_control = accounted_emalloc(len, ctx);
@@ -1154,6 +1146,7 @@ void from_zval_write_msghdr_recv(const zval *container, char *msghdr_c, ser_cont
 					*falsevp = &falsev;
 
 	if (zend_hash_str_add_ptr(&ctx->params, KEY_FILL_SOCKADDR, sizeof(KEY_FILL_SOCKADDR) - 1, (void *)falsevp) == NULL) {
+		/* Should throw? */
 		do_from_zval_err(ctx, "could not add fill_sockaddr; this is a bug");
 		return;
 	}
@@ -1182,12 +1175,12 @@ static void to_zval_read_iov(const char *msghdr_c, zval *zv, res_context *ctx)
 	uint32_t			i;
 
 	if (iovlen > UINT_MAX) {
-		do_to_zval_err(ctx, "unexpectedly large value for iov_len: %lu",
-				(unsigned long)iovlen);
+		zend_value_error("Unexpectedly large value for iov_len: %lu", (unsigned long) iovlen);
 	}
 	array_init_size(zv, (uint32_t)iovlen);
 
 	if ((recvmsg_ret = zend_hash_str_find_ptr(&ctx->params, KEY_RECVMSG_RET, sizeof(KEY_RECVMSG_RET) - 1)) == NULL) {
+		/* Should throw? */
 		do_to_zval_err(ctx, "recvmsg_ret not found in params. This is a bug");
 		return;
 	}
@@ -1228,8 +1221,8 @@ static void from_zval_write_ifindex(const zval *zv, char *uinteger, ser_context
 
 	if (Z_TYPE_P(zv) == IS_LONG) {
 		if (Z_LVAL_P(zv) < 0 || (zend_ulong)Z_LVAL_P(zv) > UINT_MAX) { /* allow 0 (unspecified interface) */
-			do_from_zval_err(ctx, "the interface index cannot be negative or "
-					"larger than %u; given " ZEND_LONG_FMT, UINT_MAX, Z_LVAL_P(zv));
+			zend_value_error("The interface index cannot be negative or  larger than %u; given " ZEND_LONG_FMT,
+					UINT_MAX, Z_LVAL_P(zv));
 		} else {
 			ret = (unsigned)Z_LVAL_P(zv);
 		}
@@ -1323,13 +1316,14 @@ size_t calculate_scm_rights_space(const zval *arr, ser_context *ctx)
 	int num_elems;
 
 	if (Z_TYPE_P(arr) != IS_ARRAY) {
-		do_from_zval_err(ctx, "%s", "expected an array here");
+		/* TODO Improve error */
+		zend_type_error("Expected array");
 		return (size_t)-1;
 	}
 
 	num_elems = zend_hash_num_elements(Z_ARRVAL_P(arr));
 	if (num_elems == 0) {
-		do_from_zval_err(ctx, "%s", "expected at least one element in this array");
+		zend_value_error("Expected at least one element in this array");
 		return (size_t)-1;
 	}
 
@@ -1351,23 +1345,25 @@ static void from_zval_write_fd_array_aux(zval *elem, unsigned i, void **args, se
 
 		stream = (php_stream *)zend_fetch_resource2_ex(elem, NULL, php_file_le_stream(), php_file_le_pstream());
 		if (stream == NULL) {
-			do_from_zval_err(ctx, "resource is not a stream or a socket");
+			zend_type_error("Resource is not a stream nor a scoket");
 			return;
 		}
 
 		if (php_stream_cast(stream, PHP_STREAM_AS_FD, (void **)&iarr[i - 1],
 				REPORT_ERRORS) == FAILURE) {
+			/* Throw? */
 			do_from_zval_err(ctx, "cast stream to file descriptor failed");
 			return;
 		}
 	} else {
-		do_from_zval_err(ctx, "expected a resource variable");
+		zend_type_error("Expected a resource");
 	}
 }
 void from_zval_write_fd_array(const zval *arr, char *int_arr, ser_context *ctx)
 {
 	if (Z_TYPE_P(arr) != IS_ARRAY) {
-		do_from_zval_err(ctx, "%s", "expected an array here");
+		/* TODO Improve error */
+		zend_type_error("Expected array");
 		return;
 	}
 
@@ -1390,8 +1386,8 @@ void to_zval_read_fd_array(const char *data, zval *zv, res_context *ctx)
 	}
 
 	if (*cmsg_len < data_offset) {
-		do_to_zval_err(ctx, "length of cmsg is smaller than its data member "
-				"offset (" ZEND_LONG_FMT " vs " ZEND_LONG_FMT ")", (zend_long)*cmsg_len, (zend_long)data_offset);
+		zend_value_error("Length of cmsg is smaller than its data member offset (" ZEND_LONG_FMT
+			" vs " ZEND_LONG_FMT ")", (zend_long)*cmsg_len, (zend_long)data_offset);
 		return;
 	}
 	num_elems = (*cmsg_len - data_offset) / sizeof(int);

ext/sockets/tests/socket_set_option_in6_pktinfo.phpt

@@ -21,7 +21,11 @@ if (!defined('IPV6_PKTINFO')) {
 <?php
 
 $s = socket_create(AF_INET6, SOCK_DGRAM, SOL_UDP) or die("err");
-var_dump(socket_set_option($s, IPPROTO_IPV6, IPV6_PKTINFO, []));
+try {
+    var_dump(socket_set_option($s, IPPROTO_IPV6, IPV6_PKTINFO, []));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . \PHP_EOL;
+}
 var_dump(socket_set_option($s, IPPROTO_IPV6, IPV6_PKTINFO, [
     "addr" => '::1',
     "ifindex" => 0
@@ -31,7 +35,6 @@ var_dump(socket_set_option($s, IPPROTO_IPV6, IPV6_PKTINFO, [
 //A work-around with is sort-of possible (with IPV6_2292PKTOPTIONS),
 //but not worth it
 //var_dump(socket_get_option($s, IPPROTO_IPV6, IPV6_PKTINFO));
---EXPECTF--
-Warning: socket_set_option(): error converting user data (path: in6_pktinfo): The key 'addr' is required in %s on line %d
-bool(false)
+--EXPECT--
+The key 'addr' is required
 bool(true)