Try to address comments

kocsismate · kocsismate · commit 12ea97b5cfe6 · 2025-08-06T22:53:53.000+02:00
diff --git a/ext/standard/http_fopen_wrapper.c b/ext/standard/http_fopen_wrapper.c
@@ -753,33 +753,32 @@ static php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 
 	/* auth header if it was specified */
 	if (((have_header & HTTP_HEADER_AUTH) == 0) && resource->user) {
-		/* make scratch large enough to hold the whole URL (over-estimate) */
-		size_t scratch_len = strlen(path) + 1;
-		char *scratch = emalloc(scratch_len);
+		smart_str scratch = {0};
 		zend_string *stmp;
 
 		/* decode the strings first */
 		php_url_decode(ZSTR_VAL(resource->user), ZSTR_LEN(resource->user));
 
-		strcpy(scratch, ZSTR_VAL(resource->user));
-		strcat(scratch, ":");
+		smart_str_appendl(&scratch, ZSTR_VAL(resource->user), ZSTR_LEN(resource->user));
+		smart_str_appendc(&scratch, ':');
 
 		/* Note: password is optional! */
 		if (resource->password) {
 			php_url_decode(ZSTR_VAL(resource->password), ZSTR_LEN(resource->password));
-			strcat(scratch, ZSTR_VAL(resource->password));
+			smart_str_appendl(&scratch, ZSTR_VAL(resource->password), ZSTR_LEN(resource->password));
 		}
 
-		stmp = php_base64_encode((unsigned char*)scratch, strlen(scratch));
+		zend_string *scratch_str = smart_str_extract(&scratch);
+		stmp = php_base64_encode((unsigned char*)ZSTR_VAL(scratch_str), ZSTR_LEN(scratch_str));
 
 		smart_str_appends(&req_buf, "Authorization: Basic ");
-		smart_str_appends(&req_buf, ZSTR_VAL(stmp));
+		smart_str_appendl(&req_buf, ZSTR_VAL(stmp), ZSTR_LEN(stmp));
 		smart_str_appends(&req_buf, "\r\n");
 
 		php_stream_notify_info(context, PHP_STREAM_NOTIFY_AUTH_REQUIRED, NULL, 0);
 
 		zend_string_free(stmp);
-		efree(scratch);
+		smart_str_free(&scratch);
 	}
 
 	/* if the user has configured who they are, send a From: line */
diff --git a/ext/standard/url.c b/ext/standard/url.c
@@ -321,12 +321,20 @@ PHPAPI php_url *php_url_parse_ex2(char const *str, size_t length, bool *has_port
 	return ret;
 }
 
+static void parse_url_decode_component(zval *zv, uri_component_read_mode_t read_mode)
+{
+	if (read_mode == URI_COMPONENT_READ_NORMALIZED_ASCII || read_mode == URI_COMPONENT_READ_NORMALIZED_UNICODE) {
+		php_url_decode(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
+	}
+}
+
 static zend_result parse_url_read_scheme(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
 {
 	php_url *parse_url_uri = internal_uri->uri;
 
 	if (parse_url_uri->scheme) {
 		ZVAL_STR_COPY(retval, parse_url_uri->scheme);
+		parse_url_decode_component(retval, read_mode);
 	} else {
 		ZVAL_NULL(retval);
 	}
@@ -340,6 +348,7 @@ static zend_result parse_url_read_username(const uri_internal_t *internal_uri, u
 
 	if (parse_url_uri->user) {
 		ZVAL_STR_COPY(retval, parse_url_uri->user);
+		parse_url_decode_component(retval, read_mode);
 	} else {
 		ZVAL_NULL(retval);
 	}
@@ -353,6 +362,7 @@ static zend_result parse_url_read_password(const uri_internal_t *internal_uri, u
 
 	if (parse_url_uri->pass) {
 		ZVAL_STR_COPY(retval, parse_url_uri->pass);
+		parse_url_decode_component(retval, read_mode);
 	} else {
 		ZVAL_NULL(retval);
 	}
@@ -366,6 +376,7 @@ static zend_result parse_url_read_host(const uri_internal_t *internal_uri, uri_c
 
 	if (parse_url_uri->host) {
 		ZVAL_STR_COPY(retval, parse_url_uri->host);
+		parse_url_decode_component(retval, read_mode);
 	} else {
 		ZVAL_NULL(retval);
 	}
@@ -379,6 +390,7 @@ static zend_result parse_url_read_port(const uri_internal_t *internal_uri, uri_c
 
 	if (parse_url_uri->port) {
 		ZVAL_LONG(retval, parse_url_uri->port);
+		parse_url_decode_component(retval, read_mode);
 	} else {
 		ZVAL_NULL(retval);
 	}
@@ -392,6 +404,7 @@ static zend_result parse_url_read_path(const uri_internal_t *internal_uri, uri_c
 
 	if (parse_url_uri->path) {
 		ZVAL_STR_COPY(retval, parse_url_uri->path);
+		parse_url_decode_component(retval, read_mode);
 	} else {
 		ZVAL_NULL(retval);
 	}
@@ -405,6 +418,7 @@ static zend_result parse_url_read_query(const uri_internal_t *internal_uri, uri_
 
 	if (parse_url_uri->query) {
 		ZVAL_STR_COPY(retval, parse_url_uri->query);
+		parse_url_decode_component(retval, read_mode);
 	} else {
 		ZVAL_NULL(retval);
 	}
@@ -418,18 +432,14 @@ static zend_result parse_url_read_fragment(const uri_internal_t *internal_uri, u
 
 	if (parse_url_uri->fragment) {
 		ZVAL_STR_COPY(retval, parse_url_uri->fragment);
+		parse_url_decode_component(retval, read_mode);
 	} else {
 		ZVAL_NULL(retval);
 	}
 
 	return SUCCESS;
 }
 
-static void *parse_url_clone_uri(void *uri)
-{
-	ZEND_UNREACHABLE();
-}
-
 static void throw_invalid_uri_exception(void)
 {
 	zend_throw_exception(uri_invalid_uri_exception_ce, "The specified URI is malformed", 0);
@@ -447,16 +457,11 @@ static void *parse_url_parse_uri(const char *uri_str, size_t uri_str_len, const
 	return url;
 }
 
-static zend_string *parse_url_uri_to_string(void *uri, uri_recomposition_mode_t recomposition_mode, bool exclude_fragment)
-{
-	ZEND_UNREACHABLE();
-}
-
 const uri_handler_t parse_url_uri_handler = {
 	.name = URI_PARSER_PHP,
 	.parse_uri = parse_url_parse_uri,
-	.clone_uri = parse_url_clone_uri,
-	.uri_to_string = parse_url_uri_to_string,
+	.clone_uri = NULL,
+	.uri_to_string = NULL,
 	.free_uri = parse_url_free_uri,
 	{
 		.scheme = {.read_func = parse_url_read_scheme, .write_func = NULL},
diff --git a/ext/uri/php_uri.c b/ext/uri/php_uri.c
@@ -136,7 +136,11 @@ ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_get_property(const uri_interna
 		return FAILURE;
 	}
 
-	return property_handler->read_func(internal_uri, read_mode, zv);
+	zend_result result = property_handler->read_func(internal_uri, read_mode, zv);
+
+	ZEND_ASSERT((Z_TYPE_P(zv) == IS_STRING && GC_REFCOUNT(Z_STR_P(zv)) == 2) || Z_TYPE_P(zv) == IS_NULL || Z_TYPE_P(zv) == IS_LONG);
+
+	return result;
 }
 
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_scheme(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
@@ -1015,10 +1019,10 @@ zend_result uri_handler_register(const uri_handler_t *uri_handler)
 {
 	zend_string *key = zend_string_init_interned(uri_handler->name, strlen(uri_handler->name), 1);
 
-	ZEND_ASSERT(uri_handler->name != NULL);
+	ZEND_ASSERT(uri_handler->name != NULL && (strlen(uri_handler->name) > 0 || strcmp(uri_handler->name, URI_PARSER_PHP) == 0));
 	ZEND_ASSERT(uri_handler->parse_uri != NULL);
-	ZEND_ASSERT(uri_handler->clone_uri != NULL);
-	ZEND_ASSERT(uri_handler->uri_to_string != NULL);
+	ZEND_ASSERT(uri_handler->clone_uri != NULL || strcmp(uri_handler->name, URI_PARSER_PHP) == 0);
+	ZEND_ASSERT(uri_handler->uri_to_string != NULL || strcmp(uri_handler->name, URI_PARSER_PHP) == 0);
 	ZEND_ASSERT(uri_handler->free_uri != NULL);
 
 	zend_result result = zend_hash_add_ptr(&uri_handlers, key, (void *) uri_handler) != NULL ? SUCCESS : FAILURE;
diff --git a/ext/uri/php_uri.h b/ext/uri/php_uri.h
@@ -35,15 +35,84 @@ typedef struct php_uri {
 
 PHPAPI uri_handler_t *php_uri_get_handler(const zend_string *uri_handler_name);
 ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const uri_handler_t *uri_handler, const char *uri_str, size_t uri_str_len, bool silent);
+/**
+ * Passes the scheme component as a new string or null to the zv zval in case of success.
+ *
+ * @param internal_uri The input struct
+ * @param read_mode
+ * @param zv The output parameter
+ * @return SUCCESS in case of success, FAILURE otherwise.
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_scheme(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+/**
+ * Passes the username component as a new string or null to the zv zval in case of success.
+ *
+ * @param internal_uri The input struct
+ * @param read_mode
+ * @param zv The output parameter
+ * @return SUCCESS in case of success, FAILURE otherwise.
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_username(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+/**
+ * Passes the password component as a new string or null to the zv zval in case of success.
+ *
+ * @param internal_uri The input struct
+ * @param read_mode
+ * @param zv The output parameter
+ * @return SUCCESS in case of success, FAILURE otherwise.
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_password(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+/**
+ * Passes the host component as a new string or null to the zv zval in case of success.
+ *
+ * @param internal_uri The input struct
+ * @param read_mode
+ * @param zv The output parameter
+ * @return SUCCESS in case of success, FAILURE otherwise.
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_host(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+/**
+ * Passes the port component as a long or null to the zv zval in case of success.
+ *
+ * @param internal_uri The input struct
+ * @param read_mode
+ * @param zv The output parameter
+ * @return SUCCESS in case of success, FAILURE otherwise.
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_port(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+/**
+ * Passes the path component as a new string to the zv zval in case of success.
+ *
+ * @param internal_uri The input struct
+ * @param read_mode
+ * @param zv The output parameter
+ * @return SUCCESS in case of success, FAILURE otherwise.
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_path(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+/**
+ * Passes the query component as a new string to the zv zval in case of success.
+ *
+ * @param internal_uri The input struct
+ * @param read_mode
+ * @param zv The output parameter
+ * @return SUCCESS in case of success, FAILURE otherwise.
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_query(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+/**
+ * Passes the fragment component as a new string to the zv zval in case of success.
+ *
+ * @param internal_uri The input struct
+ * @param read_mode
+ * @param zv The output parameter
+ * @return SUCCESS in case of success, FAILURE otherwise.
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_fragment(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
 ZEND_ATTRIBUTE_NONNULL PHPAPI void php_uri_free(uri_internal_t *internal_uri);
+/**
+ * Returns a new php_uri containing the URI fields.
+ *
+ * @return the php_uri in case of success, NULL otherwise
+ */
 ZEND_ATTRIBUTE_NONNULL PHPAPI php_uri *php_uri_parse_to_struct(
 	const uri_handler_t *uri_handler, const char *uri_str, size_t uri_str_len, uri_component_read_mode_t read_mode, bool silent
 );
diff --git a/ext/uri/php_uri_common.h b/ext/uri/php_uri_common.h
@@ -76,6 +76,9 @@ typedef struct uri_property_handlers_t {
 } uri_property_handlers_t;
 
 typedef struct uri_handler_t {
+	/**
+	 * Name (usually the FQCN) of the URI handler.
+	 */
 	const char *name;
 
 	/**
@@ -93,10 +96,43 @@ typedef struct uri_handler_t {
 	 *
 	 * If the silent parameter is true, a Uri\InvalidUriException instance must be thrown.
 	 * If the parameter is false, the possible errors should be handled by the caller.
+	 *
+	 * @param uri_str The input string
+	 * @param uri_str_len Length of the input string
+	 * @param base_url The base URI if reference resolution should be performed, otherwise NULL
+	 * @param errors An out parameter that stores additional error information
+	 * @param silent Whether to throw a Uri\InvalidUriException in case of failure
 	 */
 	void *(*parse_uri)(const char *uri_str, size_t uri_str_len, const void *base_url, zval *errors, bool silent);
+	/**
+	 * Clone a URI to a new URI.
+	 *
+	 * A deep-clone must be performed that copies all pointer members to a new memory address.
+	 * @param uri The input URI
+	 * @return The copied URI
+	 */
 	void *(*clone_uri)(void *uri);
+	/**
+	 * Recomposes a URI as a string according to the recomposition_mode and exclude_fragment parameters.
+	 * The return value must not be persistent.
+	 *
+	 * Recomposition_mode can be one of the following:
+	 * - URI_RECOMPOSITION_RAW_ASCII: Recomposes the raw, non-normalized variant of the URI as a string that may contain only ASCII characters
+	 * - URI_RECOMPOSITION_RAW_UNICODE: Recomposes the raw, non-normalized variant of the URI as a string that may contain UNICODE codepoints
+	 * - URI_RECOMPOSITION_NORMALIZED_ASCII: Recomposes the normalized variant of the URI as a string that may contain only ASCII characters
+	 * - URI_RECOMPOSITION_NORMALIZED_UNICODE: Recomposes the normalized variant of the URI as a string that may contain UNICODE codepoints
+	 *
+	 * @param uri The input URI
+	 * @param recomposition_mode The type of recomposition
+	 * @param exclude_fragment Whether the fragment component should be part of the recomposed URI
+	 * @return The recomposed URI as a non-persistent zend_string
+	 */
 	zend_string *(*uri_to_string)(void *uri, uri_recomposition_mode_t recomposition_mode, bool exclude_fragment);
+	/**
+	 * Frees the provided URI.
+	 *
+	 * @param uri The input URI
+	 */
 	void (*free_uri)(void *uri);
 
 	const uri_property_handlers_t property_handlers;
@@ -125,7 +161,7 @@ static inline uri_internal_t *uri_internal_from_obj(const zend_object *object) {
 
 #define URI_PARSER_RFC3986 "Uri\\Rfc3986\\Uri"
 #define URI_PARSER_WHATWG "Uri\\WhatWg\\Url"
-#define URI_PARSER_PHP "parse_url"
+#define URI_PARSER_PHP ""
 #define URI_SERIALIZED_PROPERTY_NAME "uri"
 
 zend_result uri_handler_register(const uri_handler_t *uri_handler);
diff --git a/ext/uri/php_uriparser.c b/ext/uri/php_uriparser.c
@@ -352,8 +352,7 @@ void *uriparser_parse_uri(const char *uri_str, size_t uri_str_len, const void *b
 	return uriparser_parse_uri_ex(uri_str, uri_str_len, base_url, silent);
 }
 
-/* TODO make the clone handler accept a flag to distinguish between clone() calls and withers.
- * When calling a wither successfully, the normalized URI is surely invalidated, therefore
+/* When calling a wither successfully, the normalized URI is surely invalidated, therefore
  * it doesn't make sense to copy it. In case of failure, an exception is thrown, and the URI object
  * is discarded altogether. */
 ZEND_ATTRIBUTE_NONNULL static void *uriparser_clone_uri(void *uri)

Original file line number	Diff line number	Diff line change
`@@ -352,8 +352,7 @@ void uriparser_parse_uri(const char uri_str, size_t uri_str_len, const void *b`
`352`	`352`	`return uriparser_parse_uri_ex(uri_str, uri_str_len, base_url, silent);`
`353`	`353`	`}`
`354`	`354`
`355`		`-/* TODO make the clone handler accept a flag to distinguish between clone() calls and withers.`
`356`		`- * When calling a wither successfully, the normalized URI is surely invalidated, therefore`
	`355`	`+/* When calling a wither successfully, the normalized URI is surely invalidated, therefore`
`357`	`356`	`* it doesn't make sense to copy it. In case of failure, an exception is thrown, and the URI object`
`358`	`357`	`* is discarded altogether. */`
`359`	`358`	`ZEND_ATTRIBUTE_NONNULL static void uriparser_clone_uri(void uri)`