php/archived-php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2026-03-24 00:02:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

uri: Clean up naming of public symbols (#19794)

Browse Source 
* uri: Rename `uri_recomposition_mode_t` to `php_uri_recomposition_mode`

* uri: Align the names of the `php_uri_recomposition_mode` values

* uri: Rename `uri_component_read_mode_t` to `php_uri_component_read_mode`

* uri: Align the names of the `php_uri_component_read_mode` values

* uri: Rename `uri_property_name_t` to `php_uri_property_name`

* uri: Align the names of the `php_uri_property_name` values

* uri: Rename `uri_property_handler_t` to `php_uri_property_handler`

* uri: Rename `uri_(read|write)_t` to `php_uri_property_handler_(read|write)`

* uri: Rename `php_uri_property_handler`’s `(read|write)_func` to `read|write`

The `_func` is implied by the data type and the name of the struct.

* uri: Rename `uri_parser_t` to `php_uri_parser`

* uri: Shorten the names of `php_uri_parser` fields

The `_uri` suffix is implied, because this is an URI parser.
This commit is contained in:
Tim Düsterhus
2025-09-11 12:10:41 +02:00
committed by GitHub
parent 9659f3e53f
commit 26eac7de17
18 changed files with 338 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ext/filter/logical_filters.c
View File

@@ -612,14 +612,14 @@ zend_result php_filter_validate_url(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
int parser_name_set;
FETCH_STR_OPTION(parser_name, URL_OPTION_URI_PARSER_CLASS);
const uri_parser_t *uri_parser = php_uri_get_parser(parser_name_set ? parser_name : NULL);
const php_uri_parser *uri_parser = php_uri_get_parser(parser_name_set ? parser_name : NULL);
if (uri_parser == NULL) {
zend_value_error("%s(): \"uri_parser_class\" option has invalid value", get_active_function_name());
RETURN_VALIDATION_FAILED
}
/* Parse the URI - if it fails, we return NULL */
php_uri *uri = php_uri_parse_to_struct(uri_parser, Z_STRVAL_P(value), Z_STRLEN_P(value), URI_COMPONENT_READ_RAW, true);
php_uri *uri = php_uri_parse_to_struct(uri_parser, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_URI_COMPONENT_READ_MODE_RAW, true);
if (uri == NULL) {
RETURN_VALIDATION_FAILED
}

4
ext/openssl/xp_ssl.c
View File

@@ -2634,7 +2634,7 @@ static char *php_openssl_get_url_name(const char *resourcename,
return NULL;
}
const uri_parser_t *uri_parser = php_stream_context_get_uri_parser("ssl", context);
const php_uri_parser *uri_parser = php_stream_context_get_uri_parser("ssl", context);
if (uri_parser == NULL) {
zend_value_error("%s(): Provided stream context has invalid value for the \"uri_parser_class\" option", get_active_function_name());
return NULL;
@@ -2647,7 +2647,7 @@ static char *php_openssl_get_url_name(const char *resourcename,
char * url_name = NULL;
zval host_zv;
zend_result result = php_uri_get_host(internal_uri, URI_COMPONENT_READ_RAW, &host_zv);
zend_result result = php_uri_get_host(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &host_zv);
if (result == SUCCESS && Z_TYPE(host_zv) == IS_STRING) {
const char * host = Z_STRVAL(host_zv);
size_t len = Z_STRLEN(host_zv);

8
ext/soap/php_http.c
View File

@@ -431,12 +431,12 @@ int make_http_soap_request(
}
if (location != NULL && ZSTR_VAL(location)[0] != '\000') {
const uri_parser_t *uri_parser = php_uri_get_parser(uri_parser_class);
const php_uri_parser *uri_parser = php_uri_get_parser(uri_parser_class);
if (uri_parser == NULL) {
zend_argument_value_error(6, "must be a valid URI parser name");
return FALSE;
}
uri = php_uri_parse_to_struct(uri_parser, ZSTR_VAL(location), ZSTR_LEN(location), URI_COMPONENT_READ_RAW, true);
uri = php_uri_parse_to_struct(uri_parser, ZSTR_VAL(location), ZSTR_LEN(location), PHP_URI_COMPONENT_READ_MODE_RAW, true);
}
tmp = Z_CLIENT_STREAM_CONTEXT_P(this_ptr);
@@ -1148,14 +1148,14 @@ try_again:
char *loc;
if ((loc = get_http_header_value(ZSTR_VAL(http_headers), "Location:")) != NULL) {
const uri_parser_t *uri_parser = php_uri_get_parser(uri_parser_class);
const php_uri_parser *uri_parser = php_uri_get_parser(uri_parser_class);
if (uri_parser == NULL) {
efree(loc);
zend_argument_value_error(6, "must be a valid URI parser name");
return FALSE;
}
php_uri *new_uri = php_uri_parse_to_struct(uri_parser, loc, strlen(loc), URI_COMPONENT_READ_RAW, true);
php_uri *new_uri = php_uri_parse_to_struct(uri_parser, loc, strlen(loc), PHP_URI_COMPONENT_READ_MODE_RAW, true);
efree(loc);
if (new_uri != NULL) {

10
ext/standard/ftp_fopen_wrapper.c
View File

@@ -135,13 +135,13 @@ static php_stream *php_ftp_fopen_connect(php_stream_wrapper *wrapper, const char
char *transport;
int transport_len;
const uri_parser_t *uri_parser = php_stream_context_get_uri_parser("ftp", context);
const php_uri_parser *uri_parser = php_stream_context_get_uri_parser("ftp", context);
if (uri_parser == NULL) {
zend_value_error("%s(): Provided stream context has invalid value for the \"uri_parser_class\" option", get_active_function_name());
return NULL;
}
resource = php_uri_parse_to_struct(uri_parser, path, strlen(path), URI_COMPONENT_READ_RAW, true);
resource = php_uri_parse_to_struct(uri_parser, path, strlen(path), PHP_URI_COMPONENT_READ_MODE_RAW, true);
if (resource == NULL || resource->path == NULL) {
if (resource && presource) {
*presource = resource;
@@ -956,18 +956,18 @@ static int php_stream_ftp_rename(php_stream_wrapper *wrapper, const char *url_fr
int result;
char tmp_line[512];
const uri_parser_t *uri_parser = php_stream_context_get_uri_parser("ftp", context);
const php_uri_parser *uri_parser = php_stream_context_get_uri_parser("ftp", context);
if (uri_parser == NULL) {
zend_value_error("%s(): Provided stream context has invalid value for the \"uri_parser_class\" option", get_active_function_name());
return 0;
}
resource_from = php_uri_parse_to_struct(uri_parser, url_from, strlen(url_from), URI_COMPONENT_READ_RAW, true);
resource_from = php_uri_parse_to_struct(uri_parser, url_from, strlen(url_from), PHP_URI_COMPONENT_READ_MODE_RAW, true);
if (!resource_from) {
return 0;
}
resource_to = php_uri_parse_to_struct(uri_parser, url_to, strlen(url_to), URI_COMPONENT_READ_RAW, true);
resource_to = php_uri_parse_to_struct(uri_parser, url_to, strlen(url_to), PHP_URI_COMPONENT_READ_MODE_RAW, true);
if (!resource_to) {
goto rename_errexit;
}

6
ext/standard/http_fopen_wrapper.c
View File

@@ -393,12 +393,12 @@ static php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
return NULL;
}
const uri_parser_t *uri_parser = php_stream_context_get_uri_parser("http", context);
const php_uri_parser *uri_parser = php_stream_context_get_uri_parser("http", context);
if (uri_parser == NULL) {
zend_value_error("%s(): Provided stream context has invalid value for the \"uri_parser_class\" option", get_active_function_name());
return NULL;
}
resource = php_uri_parse_to_struct(uri_parser, path, strlen(path), URI_COMPONENT_READ_RAW, true);
resource = php_uri_parse_to_struct(uri_parser, path, strlen(path), PHP_URI_COMPONENT_READ_MODE_RAW, true);
if (resource == NULL) {
return NULL;
}
@@ -1097,7 +1097,7 @@ finish:
php_uri_struct_free(resource);
/* check for invalid redirection URLs */
if ((resource = php_uri_parse_to_struct(uri_parser, new_path, strlen(new_path), URI_COMPONENT_READ_RAW, true)) == NULL) {
if ((resource = php_uri_parse_to_struct(uri_parser, new_path, strlen(new_path), PHP_URI_COMPONENT_READ_MODE_RAW, true)) == NULL) {
php_stream_wrapper_log_error(wrapper, options, "Invalid redirect URL! %s", new_path);
efree(new_path);
goto out;

174
ext/uri/php_uri.c
View File

@@ -62,45 +62,45 @@ static HashTable *uri_get_debug_properties(zend_object *object)
return result;
}
const uri_parser_t *parser = internal_uri->parser;
const php_uri_parser *parser = internal_uri->parser;
zval tmp;
if (parser->property_handlers.scheme.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
if (parser->property_handler.scheme.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_SCHEME), &tmp);
}
if (parser->property_handlers.username.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
if (parser->property_handler.username.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_USERNAME), &tmp);
}
if (parser->property_handlers.password.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
if (parser->property_handler.password.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_PASSWORD), &tmp);
}
if (parser->property_handlers.host.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
if (parser->property_handler.host.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_HOST), &tmp);
}
if (parser->property_handlers.port.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
if (parser->property_handler.port.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_PORT), &tmp);
}
if (parser->property_handlers.path.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
if (parser->property_handler.path.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_PATH), &tmp);
}
if (parser->property_handlers.query.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
if (parser->property_handler.query.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_QUERY), &tmp);
}
if (parser->property_handlers.fragment.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
if (parser->property_handler.fragment.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_FRAGMENT), &tmp);
}
return result;
}
PHPAPI const uri_parser_t *php_uri_get_parser(zend_string *uri_parser_name)
PHPAPI const php_uri_parser *php_uri_get_parser(zend_string *uri_parser_name)
{
if (uri_parser_name == NULL) {
return zend_hash_str_find_ptr(&uri_parsers, PHP_URI_PARSER_PHP_PARSE_URL, sizeof(PHP_URI_PARSER_PHP_PARSE_URL) - 1);
@@ -109,11 +109,11 @@ PHPAPI const uri_parser_t *php_uri_get_parser(zend_string *uri_parser_name)
return zend_hash_find_ptr(&uri_parsers, uri_parser_name);
}
ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const uri_parser_t *uri_parser, const char *uri_str, size_t uri_str_len, bool silent)
ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const php_uri_parser *uri_parser, const char *uri_str, size_t uri_str_len, bool silent)
{
uri_internal_t *internal_uri = emalloc(sizeof(*internal_uri));
internal_uri->parser = uri_parser;
internal_uri->uri = uri_parser->parse_uri(uri_str, uri_str_len, NULL, NULL, silent);
internal_uri->uri = uri_parser->parse(uri_str, uri_str_len, NULL, NULL, silent);
if (UNEXPECTED(internal_uri->uri == NULL)) {
efree(internal_uri);
@@ -123,66 +123,66 @@ ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const uri_parser_t *
return internal_uri;
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_get_property(const uri_internal_t *internal_uri, uri_property_name_t property_name, uri_component_read_mode_t read_mode, zval *zv)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_get_property(const uri_internal_t *internal_uri, php_uri_property_name property_name, php_uri_component_read_mode read_mode, zval *zv)
{
const uri_property_handler_t *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
const php_uri_property_handler *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
if (property_handler == NULL) {
return FAILURE;
}
return property_handler->read_func(internal_uri, read_mode, zv);
return property_handler->read(internal_uri, read_mode, zv);
}
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)
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_scheme(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
{
return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_SCHEME, read_mode, zv);
return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_SCHEME, read_mode, zv);
}
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)
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_username(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
{
return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_USERNAME, read_mode, zv);
return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_USERNAME, read_mode, zv);
}
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)
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_password(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
{
return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_PASSWORD, read_mode, zv);
return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_PASSWORD, read_mode, zv);
}
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)
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_host(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
{
return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_HOST, read_mode, zv);
return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_HOST, read_mode, zv);
}
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)
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_port(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
{
return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_PORT, read_mode, zv);
return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_PORT, read_mode, zv);
}
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)
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_path(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
{
return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_PATH, read_mode, zv);
return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_PATH, read_mode, zv);
}
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)
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_query(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
{
return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_QUERY, read_mode, zv);
return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_QUERY, read_mode, zv);
}
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 zend_result php_uri_get_fragment(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
{
return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_FRAGMENT, read_mode, zv);
return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_FRAGMENT, read_mode, zv);
}
ZEND_ATTRIBUTE_NONNULL PHPAPI void php_uri_free(uri_internal_t *internal_uri)
{
internal_uri->parser->free_uri(internal_uri->uri);
internal_uri->parser->free(internal_uri->uri);
internal_uri->uri = NULL;
internal_uri->parser = NULL;
efree(internal_uri);
}
ZEND_ATTRIBUTE_NONNULL PHPAPI php_uri *php_uri_parse_to_struct(
const uri_parser_t *uri_parser, const char *uri_str, size_t uri_str_len, uri_component_read_mode_t read_mode, bool silent
const php_uri_parser *uri_parser, const char *uri_str, size_t uri_str_len, php_uri_component_read_mode read_mode, bool silent
) {
uri_internal_t *uri_internal = php_uri_parse(uri_parser, uri_str, uri_str_len, silent);
if (uri_internal == NULL) {
@@ -341,7 +341,7 @@ ZEND_ATTRIBUTE_NONNULL_ARGS(1, 2) PHPAPI void php_uri_instantiate_uri(
uri_object = Z_URI_OBJECT_P(return_value);
}
const uri_parser_t *uri_parser = uri_object->internal.parser;
const php_uri_parser *uri_parser = uri_object->internal.parser;
zval errors;
ZVAL_UNDEF(&errors);
@@ -355,7 +355,7 @@ ZEND_ATTRIBUTE_NONNULL_ARGS(1, 2) PHPAPI void php_uri_instantiate_uri(
base_url = internal_base_url->uri;
}
void *uri = uri_parser->parse_uri(ZSTR_VAL(uri_str), ZSTR_LEN(uri_str), base_url, errors_zv != NULL ? &errors : NULL, !should_throw);
void *uri = uri_parser->parse(ZSTR_VAL(uri_str), ZSTR_LEN(uri_str), base_url, errors_zv != NULL ? &errors : NULL, !should_throw);
if (UNEXPECTED(uri == NULL)) {
if (should_throw) {
zval_ptr_dtor(&errors);
@@ -370,7 +370,7 @@ ZEND_ATTRIBUTE_NONNULL_ARGS(1, 2) PHPAPI void php_uri_instantiate_uri(
}
if (pass_errors_by_ref_and_free(errors_zv, &errors) == FAILURE) {
uri_parser->free_uri(uri);
uri_parser->free(uri);
RETURN_THROWS();
}
@@ -516,20 +516,20 @@ PHP_METHOD(Uri_WhatWg_Url, __construct)
PHP_METHOD(Uri_Rfc3986_Uri, getScheme)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_Rfc3986_Uri, getRawScheme)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME, URI_COMPONENT_READ_RAW);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, withScheme)
{
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME);
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME);
}
static void rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAMETERS, uri_component_read_mode_t read_mode)
static void rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAMETERS, php_uri_component_read_mode read_mode)
{
ZEND_PARSE_PARAMETERS_NONE();
@@ -544,12 +544,12 @@ static void rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAMETERS, uri_component_re
PHP_METHOD(Uri_Rfc3986_Uri, getUserInfo)
{
rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_COMPONENT_READ_NORMALIZED_ASCII);
rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_Rfc3986_Uri, getRawUserInfo)
{
rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_COMPONENT_READ_RAW);
rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, withUserInfo)
@@ -590,92 +590,92 @@ PHP_METHOD(Uri_Rfc3986_Uri, withUserInfo)
PHP_METHOD(Uri_Rfc3986_Uri, getUsername)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_USERNAME, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_USERNAME, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_Rfc3986_Uri, getRawUsername)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_USERNAME, URI_COMPONENT_READ_RAW);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_USERNAME, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, getPassword)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PASSWORD, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PASSWORD, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_Rfc3986_Uri, getRawPassword)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PASSWORD, URI_COMPONENT_READ_RAW);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PASSWORD, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, getHost)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_Rfc3986_Uri, getRawHost)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST, URI_COMPONENT_READ_RAW);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, withHost)
{
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST);
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST);
}
PHP_METHOD(Uri_Rfc3986_Uri, getPort)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PORT, URI_COMPONENT_READ_RAW);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PORT, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, withPort)
{
uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PORT);
uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PORT);
}
PHP_METHOD(Uri_Rfc3986_Uri, getPath)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PATH, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PATH, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_Rfc3986_Uri, getRawPath)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PATH, URI_COMPONENT_READ_RAW);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PATH, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, withPath)
{
uri_write_component_str(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PATH);
uri_write_component_str(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PATH);
}
PHP_METHOD(Uri_Rfc3986_Uri, getQuery)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_QUERY, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_QUERY, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_Rfc3986_Uri, getRawQuery)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_QUERY, URI_COMPONENT_READ_RAW);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_QUERY, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, withQuery)
{
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_QUERY);
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_QUERY);
}
PHP_METHOD(Uri_Rfc3986_Uri, getFragment)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_FRAGMENT, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_FRAGMENT, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_Rfc3986_Uri, getRawFragment)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_FRAGMENT, URI_COMPONENT_READ_RAW);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_FRAGMENT, PHP_URI_COMPONENT_READ_MODE_RAW);
}
PHP_METHOD(Uri_Rfc3986_Uri, withFragment)
{
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_FRAGMENT);
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_FRAGMENT);
}
static void throw_cannot_recompose_uri_to_string(zend_object *object)
@@ -705,15 +705,15 @@ static void uri_equals(INTERNAL_FUNCTION_PARAMETERS, zend_object *that_object, z
exclude_fragment = zend_string_equals_literal(Z_STR_P(case_name), "ExcludeFragment");
}
zend_string *this_str = this_internal_uri->parser->uri_to_string(
this_internal_uri->uri, URI_RECOMPOSITION_NORMALIZED_ASCII, exclude_fragment);
zend_string *this_str = this_internal_uri->parser->to_string(
this_internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII, exclude_fragment);
if (this_str == NULL) {
throw_cannot_recompose_uri_to_string(this_object);
RETURN_THROWS();
}
zend_string *that_str = that_internal_uri->parser->uri_to_string(
that_internal_uri->uri, URI_RECOMPOSITION_NORMALIZED_ASCII, exclude_fragment);
zend_string *that_str = that_internal_uri->parser->to_string(
that_internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII, exclude_fragment);
if (that_str == NULL) {
zend_string_release(this_str);
throw_cannot_recompose_uri_to_string(that_object);
@@ -748,7 +748,7 @@ PHP_METHOD(Uri_Rfc3986_Uri, toRawString)
uri_internal_t *internal_uri = uri_internal_from_obj(this_object);
URI_ASSERT_INITIALIZATION(internal_uri);
zend_string *uri_str = internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_ASCII, false);
zend_string *uri_str = internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_ASCII, false);
if (uri_str == NULL) {
throw_cannot_recompose_uri_to_string(this_object);
RETURN_THROWS();
@@ -765,7 +765,7 @@ PHP_METHOD(Uri_Rfc3986_Uri, toString)
uri_internal_t *internal_uri = uri_internal_from_obj(this_object);
URI_ASSERT_INITIALIZATION(internal_uri);
zend_string *uri_str = internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_NORMALIZED_ASCII, false);
zend_string *uri_str = internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII, false);
if (uri_str == NULL) {
throw_cannot_recompose_uri_to_string(this_object);
RETURN_THROWS();
@@ -794,7 +794,7 @@ PHP_METHOD(Uri_Rfc3986_Uri, __serialize)
URI_ASSERT_INITIALIZATION(internal_uri);
/* Serialize state: "uri" key in the first array */
zend_string *uri_str = internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_ASCII, false);
zend_string *uri_str = internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_ASCII, false);
if (uri_str == NULL) {
throw_cannot_recompose_uri_to_string(this_object);
RETURN_THROWS();
@@ -851,8 +851,8 @@ static void uri_unserialize(INTERNAL_FUNCTION_PARAMETERS)
}
uri_internal_t *internal_uri = uri_internal_from_obj(object);
internal_uri->parser->free_uri(internal_uri->uri);
internal_uri->uri = internal_uri->parser->parse_uri(Z_STRVAL_P(uri_zv), Z_STRLEN_P(uri_zv), NULL, NULL, true);
internal_uri->parser->free(internal_uri->uri);
internal_uri->uri = internal_uri->parser->parse(Z_STRVAL_P(uri_zv), Z_STRLEN_P(uri_zv), NULL, NULL, true);
if (internal_uri->uri == NULL) {
zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(object->ce->name));
RETURN_THROWS();
@@ -888,37 +888,37 @@ PHP_METHOD(Uri_Rfc3986_Uri, __debugInfo)
PHP_METHOD(Uri_WhatWg_Url, getScheme)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_WhatWg_Url, withScheme)
{
uri_write_component_str(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME);
uri_write_component_str(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME);
}
PHP_METHOD(Uri_WhatWg_Url, withUsername)
{
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_USERNAME);
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_USERNAME);
}
PHP_METHOD(Uri_WhatWg_Url, withPassword)
{
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PASSWORD);
uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PASSWORD);
}
PHP_METHOD(Uri_WhatWg_Url, getAsciiHost)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST, URI_COMPONENT_READ_NORMALIZED_ASCII);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
}
PHP_METHOD(Uri_WhatWg_Url, getUnicodeHost)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST, URI_COMPONENT_READ_NORMALIZED_UNICODE);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE);
}
PHP_METHOD(Uri_WhatWg_Url, getFragment)
{
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_FRAGMENT, URI_COMPONENT_READ_NORMALIZED_UNICODE);
uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_FRAGMENT, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE);
}
PHP_METHOD(Uri_WhatWg_Url, equals)
@@ -943,7 +943,7 @@ PHP_METHOD(Uri_WhatWg_Url, toUnicodeString)
uri_internal_t *internal_uri = uri_internal_from_obj(this_object);
URI_ASSERT_INITIALIZATION(internal_uri);
RETURN_STR(internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_UNICODE, false));
RETURN_STR(internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE, false));
}
PHP_METHOD(Uri_WhatWg_Url, toAsciiString)
@@ -954,7 +954,7 @@ PHP_METHOD(Uri_WhatWg_Url, toAsciiString)
uri_internal_t *internal_uri = uri_internal_from_obj(this_object);
URI_ASSERT_INITIALIZATION(internal_uri);
RETURN_STR(internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_ASCII, false));
RETURN_STR(internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_ASCII, false));
}
PHP_METHOD(Uri_WhatWg_Url, resolve)
@@ -980,7 +980,7 @@ PHP_METHOD(Uri_WhatWg_Url, __serialize)
URI_ASSERT_INITIALIZATION(internal_uri);
/* Serialize state: "uri" key in the first array */
zend_string *uri_str = internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_ASCII, false);
zend_string *uri_str = internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_ASCII, false);
if (uri_str == NULL) {
throw_cannot_recompose_uri_to_string(this_object);
RETURN_THROWS();
@@ -1015,7 +1015,7 @@ PHP_METHOD(Uri_WhatWg_Url, __debugInfo)
RETURN_ARR(uri_get_debug_properties(object));
}
PHPAPI uri_object_t *php_uri_object_create(zend_class_entry *class_type, const uri_parser_t *parser)
PHPAPI uri_object_t *php_uri_object_create(zend_class_entry *class_type, const php_uri_parser *parser)
{
uri_object_t *uri_object = zend_object_alloc(sizeof(*uri_object), class_type);
@@ -1044,7 +1044,7 @@ PHPAPI void php_uri_object_handler_free(zend_object *object)
{
uri_object_t *uri_object = uri_object_from_obj(object);
uri_object->internal.parser->free_uri(uri_object->internal.uri);
uri_object->internal.parser->free(uri_object->internal.uri);
zend_object_std_dtor(&uri_object->std);
}
@@ -1058,7 +1058,7 @@ PHPAPI zend_object *php_uri_object_handler_clone(zend_object *object)
uri_object_t *new_uri_object = uri_object_from_obj(object->ce->create_object(object->ce));
ZEND_ASSERT(new_uri_object->internal.parser == internal_uri->parser);
void *uri = internal_uri->parser->clone_uri(internal_uri->uri);
void *uri = internal_uri->parser->clone(internal_uri->uri);
ZEND_ASSERT(uri != NULL);
new_uri_object->internal.uri = uri;
@@ -1068,15 +1068,15 @@ PHPAPI zend_object *php_uri_object_handler_clone(zend_object *object)
return &new_uri_object->std;
}
PHPAPI zend_result php_uri_parser_register(const uri_parser_t *uri_parser)
PHPAPI zend_result php_uri_parser_register(const php_uri_parser *uri_parser)
{
zend_string *key = zend_string_init_interned(uri_parser->name, strlen(uri_parser->name), true);
ZEND_ASSERT(uri_parser->name != NULL);
ZEND_ASSERT(uri_parser->parse_uri != NULL);
ZEND_ASSERT(uri_parser->clone_uri != NULL || strcmp(uri_parser->name, PHP_URI_PARSER_PHP_PARSE_URL) == 0);
ZEND_ASSERT(uri_parser->uri_to_string != NULL || strcmp(uri_parser->name, PHP_URI_PARSER_PHP_PARSE_URL) == 0);
ZEND_ASSERT(uri_parser->free_uri != NULL);
ZEND_ASSERT(uri_parser->parse != NULL);
ZEND_ASSERT(uri_parser->clone != NULL || strcmp(uri_parser->name, PHP_URI_PARSER_PHP_PARSE_URL) == 0);
ZEND_ASSERT(uri_parser->to_string != NULL || strcmp(uri_parser->name, PHP_URI_PARSER_PHP_PARSE_URL) == 0);
ZEND_ASSERT(uri_parser->free != NULL);
zend_result result = zend_hash_add_ptr(&uri_parsers, key, (void *) uri_parser) != NULL ? SUCCESS : FAILURE;

80
ext/uri/php_uri.h
View File

@@ -39,7 +39,7 @@ typedef struct php_uri {
* @param uri_parser The URI parser
* @return SUCCESS in case of success, FAILURE otherwise
*/
PHPAPI zend_result php_uri_parser_register(const uri_parser_t *uri_parser);
PHPAPI zend_result php_uri_parser_register(const php_uri_parser *uri_parser);
/**
* Returns the registered URI parser based on uri_parser_name.
@@ -47,129 +47,129 @@ PHPAPI zend_result php_uri_parser_register(const uri_parser_t *uri_parser);
* @param uri_parser_name The URI parser name
* @return The URI parser
*/
PHPAPI const uri_parser_t *php_uri_get_parser(zend_string *uri_parser_name);
PHPAPI const php_uri_parser *php_uri_get_parser(zend_string *uri_parser_name);
ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const uri_parser_t *uri_parser, const char *uri_str, size_t uri_str_len, bool silent);
ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const php_uri_parser *uri_parser, const char *uri_str, size_t uri_str_len, bool silent);
/**
* Retrieves the scheme component based on the read_mode and passes it to the zv ZVAL in case of success.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param internal_uri The internal URI whose uri member is used to retrieve the component
* @param read_mode The read mode
* @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
* @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);
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_scheme(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
/**
* Retrieves the username component based on the read_mode and passes it to the zv ZVAL in case of success.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param internal_uri The internal URI whose uri member is used to retrieve the component
* @param read_mode The read mode
* @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
* @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);
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_username(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
/**
* Retrieves the password component based on the read_mode and passes it to the zv ZVAL in case of success.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param internal_uri The internal URI whose uri member is used to retrieve the component
* @param read_mode The read mode
* @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
* @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);
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_password(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
/**
* Retrieves the host component based on the read_mode and passes it to the zv ZVAL in case of success.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param internal_uri The internal URI whose uri member is used to retrieve the component
* @param read_mode The read mode
* @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
* @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);
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_host(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
/**
* Retrieves the port component based on the read_mode and passes it to the zv ZVAL in case of success.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param internal_uri The internal URI whose uri member is used to retrieve the component
* @param read_mode The read mode
* @param zv The output parameter containing the retrieved component as a ZVAL (either IS_LONG or IS_NULL).
* @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);
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_port(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
/**
* Retrieves the path component based on the read_mode and passes it to the zv ZVAL in case of success.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param internal_uri The internal URI whose uri member is used to retrieve the component
* @param read_mode The read mode
* @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
* @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);
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_path(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
/**
* Retrieves the query component based on the read_mode and passes it to the zv ZVAL in case of success.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param internal_uri The internal URI whose uri member is used to retrieve the component
* @param read_mode The read mode
* @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
* @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);
ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_query(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
/**
* Retrieves the fragment component based on the read_mode and passes it to the zv ZVAL in case of success.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param internal_uri The internal URI whose uri member is used to retrieve the component
* @param read_mode The read mode
* @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
* @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 zend_result php_uri_get_fragment(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
/**
* Frees the uri member within the provided internal URI.
@@ -182,11 +182,11 @@ ZEND_ATTRIBUTE_NONNULL PHPAPI void php_uri_free(uri_internal_t *internal_uri);
* Creates a new php_uri struct containing all the URI components. The components are retrieved based on the read_mode parameter.
*
* Read_mode can be one of the following:
* - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
* - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
* - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
* - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
*
* @param uri_parser The URI parser whose parse_uri() handler is called
* @param uri_parser The URI parser whose parse() handler is called
* @param uri_str The input string that is going to be parsed
* @param uri_str_len Length of the input string
* @param read_mode The read mode based on which components are retrieved
@@ -194,7 +194,7 @@ ZEND_ATTRIBUTE_NONNULL PHPAPI void php_uri_free(uri_internal_t *internal_uri);
* @return The created php_uri struct in case of success, NULL otherwise
*/
ZEND_ATTRIBUTE_NONNULL PHPAPI php_uri *php_uri_parse_to_struct(
const uri_parser_t *uri_parser, const char *uri_str, size_t uri_str_len, uri_component_read_mode_t read_mode, bool silent
const php_uri_parser *uri_parser, const char *uri_str, size_t uri_str_len, php_uri_component_read_mode read_mode, bool silent
);
/**

72
ext/uri/php_uri_common.c
View File

@@ -19,69 +19,69 @@
#include "Zend/zend_exceptions.h"
#include "php_uri_common.h"
const uri_property_handler_t *uri_property_handler_from_internal_uri(const uri_internal_t *internal_uri, uri_property_name_t property_name)
const php_uri_property_handler *uri_property_handler_from_internal_uri(const uri_internal_t *internal_uri, php_uri_property_name property_name)
{
switch (property_name) {
case URI_PROPERTY_NAME_SCHEME:
return &internal_uri->parser->property_handlers.scheme;
case URI_PROPERTY_NAME_USERNAME:
return &internal_uri->parser->property_handlers.username;
case URI_PROPERTY_NAME_PASSWORD:
return &internal_uri->parser->property_handlers.password;
case URI_PROPERTY_NAME_HOST:
return &internal_uri->parser->property_handlers.host;
case URI_PROPERTY_NAME_PORT:
return &internal_uri->parser->property_handlers.port;
case URI_PROPERTY_NAME_PATH:
return &internal_uri->parser->property_handlers.path;
case URI_PROPERTY_NAME_QUERY:
return &internal_uri->parser->property_handlers.query;
case URI_PROPERTY_NAME_FRAGMENT:
return &internal_uri->parser->property_handlers.fragment;
case PHP_URI_PROPERTY_NAME_SCHEME:
return &internal_uri->parser->property_handler.scheme;
case PHP_URI_PROPERTY_NAME_USERNAME:
return &internal_uri->parser->property_handler.username;
case PHP_URI_PROPERTY_NAME_PASSWORD:
return &internal_uri->parser->property_handler.password;
case PHP_URI_PROPERTY_NAME_HOST:
return &internal_uri->parser->property_handler.host;
case PHP_URI_PROPERTY_NAME_PORT:
return &internal_uri->parser->property_handler.port;
case PHP_URI_PROPERTY_NAME_PATH:
return &internal_uri->parser->property_handler.path;
case PHP_URI_PROPERTY_NAME_QUERY:
return &internal_uri->parser->property_handler.query;
case PHP_URI_PROPERTY_NAME_FRAGMENT:
return &internal_uri->parser->property_handler.fragment;
EMPTY_SWITCH_DEFAULT_CASE()
}
}
static zend_string *get_known_string_by_property_name(uri_property_name_t property_name)
static zend_string *get_known_string_by_property_name(php_uri_property_name property_name)
{
switch (property_name) {
case URI_PROPERTY_NAME_SCHEME:
case PHP_URI_PROPERTY_NAME_SCHEME:
return ZSTR_KNOWN(ZEND_STR_SCHEME);
case URI_PROPERTY_NAME_USERNAME:
case PHP_URI_PROPERTY_NAME_USERNAME:
return ZSTR_KNOWN(ZEND_STR_USERNAME);
case URI_PROPERTY_NAME_PASSWORD:
case PHP_URI_PROPERTY_NAME_PASSWORD:
return ZSTR_KNOWN(ZEND_STR_PASSWORD);
case URI_PROPERTY_NAME_HOST:
case PHP_URI_PROPERTY_NAME_HOST:
return ZSTR_KNOWN(ZEND_STR_HOST);
case URI_PROPERTY_NAME_PORT:
case PHP_URI_PROPERTY_NAME_PORT:
return ZSTR_KNOWN(ZEND_STR_PORT);
case URI_PROPERTY_NAME_PATH:
case PHP_URI_PROPERTY_NAME_PATH:
return ZSTR_KNOWN(ZEND_STR_PATH);
case URI_PROPERTY_NAME_QUERY:
case PHP_URI_PROPERTY_NAME_QUERY:
return ZSTR_KNOWN(ZEND_STR_QUERY);
case URI_PROPERTY_NAME_FRAGMENT:
case PHP_URI_PROPERTY_NAME_FRAGMENT:
return ZSTR_KNOWN(ZEND_STR_FRAGMENT);
EMPTY_SWITCH_DEFAULT_CASE()
}
}
void uri_read_component(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name, uri_component_read_mode_t component_read_mode)
void uri_read_component(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name, php_uri_component_read_mode component_read_mode)
{
ZEND_PARSE_PARAMETERS_NONE();
uri_internal_t *internal_uri = Z_URI_INTERNAL_P(ZEND_THIS);
URI_ASSERT_INITIALIZATION(internal_uri);
const uri_property_handler_t *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
const php_uri_property_handler *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
ZEND_ASSERT(property_handler != NULL);
if (UNEXPECTED(property_handler->read_func(internal_uri, component_read_mode, return_value) == FAILURE)) {
if (UNEXPECTED(property_handler->read(internal_uri, component_read_mode, return_value) == FAILURE)) {
zend_throw_error(NULL, "The %s component cannot be retrieved", ZSTR_VAL(get_known_string_by_property_name(property_name)));
RETURN_THROWS();
}
}
static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name, zval *property_zv)
static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name, zval *property_zv)
{
zend_object *old_object = Z_OBJ_P(ZEND_THIS);
uri_internal_t *internal_uri = Z_URI_INTERNAL_P(ZEND_THIS);
@@ -96,12 +96,12 @@ static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, uri_property_na
* case of an exception being thrown. */
RETVAL_OBJ(new_object);
const uri_property_handler_t *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
const php_uri_property_handler *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
ZEND_ASSERT(property_handler != NULL);
uri_internal_t *new_internal_uri = uri_internal_from_obj(new_object);
URI_ASSERT_INITIALIZATION(new_internal_uri);
if (UNEXPECTED(property_handler->write_func == NULL)) {
if (UNEXPECTED(property_handler->write == NULL)) {
zend_readonly_property_modification_error_ex(ZSTR_VAL(old_object->ce->name),
ZSTR_VAL(get_known_string_by_property_name(property_name)));
RETURN_THROWS();
@@ -109,7 +109,7 @@ static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, uri_property_na
zval errors;
ZVAL_UNDEF(&errors);
if (UNEXPECTED(property_handler->write_func(new_internal_uri, property_zv, &errors) == FAILURE)) {
if (UNEXPECTED(property_handler->write(new_internal_uri, property_zv, &errors) == FAILURE)) {
zval_ptr_dtor(&errors);
RETURN_THROWS();
}
@@ -117,7 +117,7 @@ static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, uri_property_na
ZEND_ASSERT(Z_ISUNDEF(errors));
}
void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name)
void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name)
{
zend_string *value;
@@ -131,7 +131,7 @@ void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t p
uri_write_component_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, property_name, &zv);
}
void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name)
void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name)
{
zend_string *value;
@@ -149,7 +149,7 @@ void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_
uri_write_component_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, property_name, &zv);
}
void uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name)
void uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name)
{
zend_long value;
bool value_is_null;

106
ext/uri/php_uri_common.h
View File

@@ -28,42 +28,42 @@ extern zend_class_entry *uri_whatwg_invalid_url_exception_ce;
extern zend_class_entry *uri_whatwg_url_validation_error_type_ce;
extern zend_class_entry *uri_whatwg_url_validation_error_ce;
typedef enum {
URI_RECOMPOSITION_RAW_ASCII,
URI_RECOMPOSITION_RAW_UNICODE,
URI_RECOMPOSITION_NORMALIZED_ASCII,
URI_RECOMPOSITION_NORMALIZED_UNICODE,
} uri_recomposition_mode_t;
typedef enum php_uri_recomposition_mode {
PHP_URI_RECOMPOSITION_MODE_RAW_ASCII,
PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE,
PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII,
PHP_URI_RECOMPOSITION_MODE_NORMALIZED_UNICODE,
} php_uri_recomposition_mode;
typedef enum {
URI_COMPONENT_READ_RAW,
URI_COMPONENT_READ_NORMALIZED_ASCII,
URI_COMPONENT_READ_NORMALIZED_UNICODE,
} uri_component_read_mode_t;
typedef enum php_uri_component_read_mode {
PHP_URI_COMPONENT_READ_MODE_RAW,
PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII,
PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE,
} php_uri_component_read_mode;
struct uri_internal_t;
typedef zend_result (*uri_read_t)(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval);
typedef zend_result (*php_uri_property_handler_read)(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval);
typedef zend_result (*uri_write_t)(struct uri_internal_t *internal_uri, zval *value, zval *errors);
typedef zend_result (*php_uri_property_handler_write)(struct uri_internal_t *internal_uri, zval *value, zval *errors);
typedef enum {
URI_PROPERTY_NAME_SCHEME,
URI_PROPERTY_NAME_USERNAME,
URI_PROPERTY_NAME_PASSWORD,
URI_PROPERTY_NAME_HOST,
URI_PROPERTY_NAME_PORT,
URI_PROPERTY_NAME_PATH,
URI_PROPERTY_NAME_QUERY,
URI_PROPERTY_NAME_FRAGMENT,
} uri_property_name_t;
typedef enum php_uri_property_name {
PHP_URI_PROPERTY_NAME_SCHEME,
PHP_URI_PROPERTY_NAME_USERNAME,
PHP_URI_PROPERTY_NAME_PASSWORD,
PHP_URI_PROPERTY_NAME_HOST,
PHP_URI_PROPERTY_NAME_PORT,
PHP_URI_PROPERTY_NAME_PATH,
PHP_URI_PROPERTY_NAME_QUERY,
PHP_URI_PROPERTY_NAME_FRAGMENT,
} php_uri_property_name;
typedef struct uri_property_handler_t {
uri_read_t read_func;
uri_write_t write_func;
} uri_property_handler_t;
typedef struct php_uri_property_handler {
php_uri_property_handler_read read;
php_uri_property_handler_write write;
} php_uri_property_handler;
typedef struct uri_parser_t {
typedef struct php_uri_parser {
/**
* Name (the FQCN) of the URI parser. The "" name is reserved for the handler of the legacy parse_url().
*/
@@ -91,7 +91,7 @@ typedef struct uri_parser_t {
* @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);
void *(*parse)(const char *uri_str, size_t uri_str_len, const void *base_url, zval *errors, bool silent);
/**
* Clones a URI to a new URI.
@@ -100,46 +100,46 @@ typedef struct uri_parser_t {
* @param uri The input URI
* @return The cloned URI
*/
void *(*clone_uri)(void *uri);
void *(*clone)(void *uri);
/**
* Recomposes a URI as a string according to the recomposition_mode and exclude_fragment parameters.
* The returned zend_string 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 must only contain 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 must only contain ASCII characters
* - URI_RECOMPOSITION_NORMALIZED_UNICODE: Recomposes the normalized variant of the URI as a string that may contain Unicode codepoints
* - PHP_URI_RECOMPOSITION_MODE_RAW_ASCII: Recomposes the raw, non-normalized variant of the URI as a string that must only contain ASCII characters
* - PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE: Recomposes the raw, non-normalized variant of the URI as a string that may contain Unicode codepoints
* - PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII: Recomposes the normalized variant of the URI as a string that must only contain ASCII characters
* - PHP_URI_RECOMPOSITION_MODE_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);
zend_string *(*to_string)(void *uri, php_uri_recomposition_mode recomposition_mode, bool exclude_fragment);
/**
* Frees the provided URI.
*
* @param uri The URI to free. Must do nothing if NULL.
*/
void (*free_uri)(void *uri);
void (*free)(void *uri);
struct {
uri_property_handler_t scheme;
uri_property_handler_t username;
uri_property_handler_t password;
uri_property_handler_t host;
uri_property_handler_t port;
uri_property_handler_t path;
uri_property_handler_t query;
uri_property_handler_t fragment;
} property_handlers;
} uri_parser_t;
php_uri_property_handler scheme;
php_uri_property_handler username;
php_uri_property_handler password;
php_uri_property_handler host;
php_uri_property_handler port;
php_uri_property_handler path;
php_uri_property_handler query;
php_uri_property_handler fragment;
} property_handler;
} php_uri_parser;
typedef struct uri_internal_t {
const uri_parser_t *parser;
const php_uri_parser *parser;
void *uri;
} uri_internal_t;
@@ -159,7 +159,7 @@ static inline uri_internal_t *uri_internal_from_obj(const zend_object *object) {
#define Z_URI_OBJECT_P(zv) uri_object_from_obj(Z_OBJ_P((zv)))
#define Z_URI_INTERNAL_P(zv) uri_internal_from_obj(Z_OBJ_P((zv)))
PHPAPI uri_object_t *php_uri_object_create(zend_class_entry *class_type, const uri_parser_t *parser);
PHPAPI uri_object_t *php_uri_object_create(zend_class_entry *class_type, const php_uri_parser *parser);
PHPAPI void php_uri_object_handler_free(zend_object *object);
PHPAPI zend_object *php_uri_object_handler_clone(zend_object *object);
@@ -168,11 +168,11 @@ PHPAPI zend_object *php_uri_object_handler_clone(zend_object *object);
#define PHP_URI_PARSER_PHP_PARSE_URL "parse_url"
#define URI_SERIALIZED_PROPERTY_NAME "uri"
const uri_property_handler_t *uri_property_handler_from_internal_uri(const uri_internal_t *internal_uri, uri_property_name_t property_name);
void uri_read_component(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name, uri_component_read_mode_t component_read_mode);
void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name);
void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name);
void uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name);
const php_uri_property_handler *uri_property_handler_from_internal_uri(const uri_internal_t *internal_uri, php_uri_property_name property_name);
void uri_read_component(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name, php_uri_component_read_mode component_read_mode);
void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name);
void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name);
void uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name);
#define URI_ASSERT_INITIALIZATION(internal_uri) do { \
ZEND_ASSERT(internal_uri != NULL && internal_uri->uri != NULL); \

50
ext/uri/uri_parser_php_parse_url.c
View File

@@ -21,13 +21,13 @@
#include "Zend/zend_exceptions.h"
#include "ext/standard/url.h"
static zend_string *decode_component(zend_string *in, uri_component_read_mode_t read_mode)
static zend_string *decode_component(zend_string *in, php_uri_component_read_mode read_mode)
{
switch (read_mode) {
case URI_COMPONENT_READ_RAW:
case PHP_URI_COMPONENT_READ_MODE_RAW:
return zend_string_copy(in);
case URI_COMPONENT_READ_NORMALIZED_ASCII:
case URI_COMPONENT_READ_NORMALIZED_UNICODE: {
case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII:
case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: {
zend_string *out = zend_string_alloc(ZSTR_LEN(in), false);
ZSTR_LEN(out) = php_raw_url_decode_ex(ZSTR_VAL(out), ZSTR_VAL(in), ZSTR_LEN(in));
@@ -38,7 +38,7 @@ static zend_string *decode_component(zend_string *in, uri_component_read_mode_t
}
}
static zend_result uri_parser_php_parse_url_scheme_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result uri_parser_php_parse_url_scheme_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const php_url *parse_url_uri = internal_uri->uri;
@@ -51,7 +51,7 @@ static zend_result uri_parser_php_parse_url_scheme_read(const uri_internal_t *in
return SUCCESS;
}
static zend_result uri_parser_php_parse_url_username_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result uri_parser_php_parse_url_username_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const php_url *parse_url_uri = internal_uri->uri;
@@ -64,7 +64,7 @@ static zend_result uri_parser_php_parse_url_username_read(const uri_internal_t *
return SUCCESS;
}
static zend_result uri_parser_php_parse_url_password_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result uri_parser_php_parse_url_password_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const php_url *parse_url_uri = internal_uri->uri;
@@ -77,7 +77,7 @@ static zend_result uri_parser_php_parse_url_password_read(const uri_internal_t *
return SUCCESS;
}
static zend_result uri_parser_php_parse_url_host_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result uri_parser_php_parse_url_host_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const php_url *parse_url_uri = internal_uri->uri;
@@ -90,7 +90,7 @@ static zend_result uri_parser_php_parse_url_host_read(const uri_internal_t *inte
return SUCCESS;
}
static zend_result uri_parser_php_parse_url_port_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result uri_parser_php_parse_url_port_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const php_url *parse_url_uri = internal_uri->uri;
@@ -103,7 +103,7 @@ static zend_result uri_parser_php_parse_url_port_read(const uri_internal_t *inte
return SUCCESS;
}
static zend_result uri_parser_php_parse_url_path_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result uri_parser_php_parse_url_path_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const php_url *parse_url_uri = internal_uri->uri;
@@ -116,7 +116,7 @@ static zend_result uri_parser_php_parse_url_path_read(const uri_internal_t *inte
return SUCCESS;
}
static zend_result uri_parser_php_parse_url_query_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result uri_parser_php_parse_url_query_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const php_url *parse_url_uri = internal_uri->uri;
@@ -129,7 +129,7 @@ static zend_result uri_parser_php_parse_url_query_read(const uri_internal_t *int
return SUCCESS;
}
static zend_result uri_parser_php_parse_url_fragment_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result uri_parser_php_parse_url_fragment_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const php_url *parse_url_uri = internal_uri->uri;
@@ -165,20 +165,20 @@ static void uri_parser_php_parse_url_free(void *uri)
php_url_free(parse_url_uri);
}
const uri_parser_t php_uri_parser_php_parse_url = {
const php_uri_parser php_uri_parser_php_parse_url = {
.name = PHP_URI_PARSER_PHP_PARSE_URL,
.parse_uri = uri_parser_php_parse_url_parse,
.clone_uri = NULL,
.uri_to_string = NULL,
.free_uri = uri_parser_php_parse_url_free,
.parse = uri_parser_php_parse_url_parse,
.clone = NULL,
.to_string = NULL,
.free = uri_parser_php_parse_url_free,
{
.scheme = {.read_func = uri_parser_php_parse_url_scheme_read, .write_func = NULL},
.username = {.read_func = uri_parser_php_parse_url_username_read, .write_func = NULL},
.password = {.read_func = uri_parser_php_parse_url_password_read, .write_func = NULL},
.host = {.read_func = uri_parser_php_parse_url_host_read, .write_func = NULL},
.port = {.read_func = uri_parser_php_parse_url_port_read, .write_func = NULL},
.path = {.read_func = uri_parser_php_parse_url_path_read, .write_func = NULL},
.query = {.read_func = uri_parser_php_parse_url_query_read, .write_func = NULL},
.fragment = {.read_func = uri_parser_php_parse_url_fragment_read, .write_func = NULL},
.scheme = {.read = uri_parser_php_parse_url_scheme_read, .write = NULL},
.username = {.read = uri_parser_php_parse_url_username_read, .write = NULL},
.password = {.read = uri_parser_php_parse_url_password_read, .write = NULL},
.host = {.read = uri_parser_php_parse_url_host_read, .write = NULL},
.port = {.read = uri_parser_php_parse_url_port_read, .write = NULL},
.path = {.read = uri_parser_php_parse_url_path_read, .write = NULL},
.query = {.read = uri_parser_php_parse_url_query_read, .write = NULL},
.fragment = {.read = uri_parser_php_parse_url_fragment_read, .write = NULL},
}
};

2
ext/uri/uri_parser_php_parse_url.h
View File

@@ -20,6 +20,6 @@
#include "php_uri_common.h"
extern const uri_parser_t php_uri_parser_php_parse_url;
extern const php_uri_parser php_uri_parser_php_parse_url;
#endif

56
ext/uri/uri_parser_rfc3986.c
View File

@@ -86,14 +86,14 @@ ZEND_ATTRIBUTE_NONNULL static UriUriA *get_normalized_uri(php_uri_parser_rfc3986
return &uriparser_uris->normalized_uri;
}
ZEND_ATTRIBUTE_NONNULL static UriUriA *get_uri_for_reading(php_uri_parser_rfc3986_uris *uriparser_uris, uri_component_read_mode_t read_mode)
ZEND_ATTRIBUTE_NONNULL static UriUriA *get_uri_for_reading(php_uri_parser_rfc3986_uris *uriparser_uris, php_uri_component_read_mode read_mode)
{
switch (read_mode) {
case URI_COMPONENT_READ_RAW:
case PHP_URI_COMPONENT_READ_MODE_RAW:
return &uriparser_uris->uri;
case URI_COMPONENT_READ_NORMALIZED_ASCII:
case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII:
ZEND_FALLTHROUGH;
case URI_COMPONENT_READ_NORMALIZED_UNICODE:
case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE:
return get_normalized_uri(uriparser_uris);
EMPTY_SWITCH_DEFAULT_CASE()
}
@@ -106,7 +106,7 @@ ZEND_ATTRIBUTE_NONNULL static UriUriA *get_uri_for_writing(uri_internal_t *inter
return &uriparser_uris->uri;
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_scheme_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_scheme_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -143,7 +143,7 @@ static zend_result php_uri_parser_rfc3986_scheme_write(struct uri_internal_t *in
}
}
ZEND_ATTRIBUTE_NONNULL zend_result php_uri_parser_rfc3986_userinfo_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL zend_result php_uri_parser_rfc3986_userinfo_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -183,7 +183,7 @@ zend_result php_uri_parser_rfc3986_userinfo_write(struct uri_internal_t *interna
}
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_username_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_username_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -205,7 +205,7 @@ ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_username_read(c
return SUCCESS;
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_password_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_password_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -224,7 +224,7 @@ ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_password_read(c
return SUCCESS;
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_host_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_host_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -296,7 +296,7 @@ ZEND_ATTRIBUTE_NONNULL static zend_long port_str_to_zend_long_checked(const char
return (zend_long)result;
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_port_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_port_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -338,7 +338,7 @@ static zend_result php_uri_parser_rfc3986_port_write(struct uri_internal_t *inte
}
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_path_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_path_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -390,7 +390,7 @@ static zend_result php_uri_parser_rfc3986_path_write(struct uri_internal_t *inte
}
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_query_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_query_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -427,7 +427,7 @@ static zend_result php_uri_parser_rfc3986_query_write(struct uri_internal_t *int
}
}
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_fragment_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_fragment_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
@@ -564,12 +564,12 @@ ZEND_ATTRIBUTE_NONNULL static void *php_uri_parser_rfc3986_clone(void *uri)
return new_uriparser_uris;
}
ZEND_ATTRIBUTE_NONNULL static zend_string *php_uri_parser_rfc3986_to_string(void *uri, uri_recomposition_mode_t recomposition_mode, bool exclude_fragment)
ZEND_ATTRIBUTE_NONNULL static zend_string *php_uri_parser_rfc3986_to_string(void *uri, php_uri_recomposition_mode recomposition_mode, bool exclude_fragment)
{
php_uri_parser_rfc3986_uris *uriparser_uris = uri;
const UriUriA *uriparser_uri;
if (recomposition_mode == URI_RECOMPOSITION_RAW_ASCII || recomposition_mode == URI_RECOMPOSITION_RAW_UNICODE) {
if (recomposition_mode == PHP_URI_RECOMPOSITION_MODE_RAW_ASCII || recomposition_mode == PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE) {
uriparser_uri = &uriparser_uris->uri;
} else {
uriparser_uri = get_normalized_uri(uriparser_uris);
@@ -609,20 +609,20 @@ static void php_uri_parser_rfc3986_free(void *uri)
efree(uriparser_uris);
}
const uri_parser_t php_uri_parser_rfc3986 = {
const php_uri_parser php_uri_parser_rfc3986 = {
.name = PHP_URI_PARSER_RFC3986,
.parse_uri = php_uri_parser_rfc3986_parse,
.clone_uri = php_uri_parser_rfc3986_clone,
.uri_to_string = php_uri_parser_rfc3986_to_string,
.free_uri = php_uri_parser_rfc3986_free,
.parse = php_uri_parser_rfc3986_parse,
.clone = php_uri_parser_rfc3986_clone,
.to_string = php_uri_parser_rfc3986_to_string,
.free = php_uri_parser_rfc3986_free,
{
.scheme = {.read_func = php_uri_parser_rfc3986_scheme_read, .write_func = php_uri_parser_rfc3986_scheme_write},
.username = {.read_func = php_uri_parser_rfc3986_username_read, .write_func = NULL},
.password = {.read_func = php_uri_parser_rfc3986_password_read, .write_func = NULL},
.host = {.read_func = php_uri_parser_rfc3986_host_read, .write_func = php_uri_parser_rfc3986_host_write},
.port = {.read_func = php_uri_parser_rfc3986_port_read, .write_func = php_uri_parser_rfc3986_port_write},
.path = {.read_func = php_uri_parser_rfc3986_path_read, .write_func = php_uri_parser_rfc3986_path_write},
.query = {.read_func = php_uri_parser_rfc3986_query_read, .write_func = php_uri_parser_rfc3986_query_write},
.fragment = {.read_func = php_uri_parser_rfc3986_fragment_read, .write_func = php_uri_parser_rfc3986_fragment_write},
.scheme = {.read = php_uri_parser_rfc3986_scheme_read, .write = php_uri_parser_rfc3986_scheme_write},
.username = {.read = php_uri_parser_rfc3986_username_read, .write = NULL},
.password = {.read = php_uri_parser_rfc3986_password_read, .write = NULL},
.host = {.read = php_uri_parser_rfc3986_host_read, .write = php_uri_parser_rfc3986_host_write},
.port = {.read = php_uri_parser_rfc3986_port_read, .write = php_uri_parser_rfc3986_port_write},
.path = {.read = php_uri_parser_rfc3986_path_read, .write = php_uri_parser_rfc3986_path_write},
.query = {.read = php_uri_parser_rfc3986_query_read, .write = php_uri_parser_rfc3986_query_write},
.fragment = {.read = php_uri_parser_rfc3986_fragment_read, .write = php_uri_parser_rfc3986_fragment_write},
}
};

4
ext/uri/uri_parser_rfc3986.h
View File

@@ -20,7 +20,7 @@
#include <uriparser/Uri.h>
#include "php_uri_common.h"
extern const uri_parser_t php_uri_parser_rfc3986;
extern const php_uri_parser php_uri_parser_rfc3986;
typedef struct php_uri_parser_rfc3986_uris {
UriUriA uri;
@@ -28,7 +28,7 @@ typedef struct php_uri_parser_rfc3986_uris {
bool normalized_uri_initialized;
} php_uri_parser_rfc3986_uris;
zend_result php_uri_parser_rfc3986_userinfo_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval);
zend_result php_uri_parser_rfc3986_userinfo_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval);
zend_result php_uri_parser_rfc3986_userinfo_write(struct uri_internal_t *internal_uri, zval *value, zval *errors);
php_uri_parser_rfc3986_uris *php_uri_parser_rfc3986_parse_ex(const char *uri_str, size_t uri_str_len, const php_uri_parser_rfc3986_uris *uriparser_base_url, bool silent);

58
ext/uri/uri_parser_whatwg.c
View File

@@ -250,7 +250,7 @@ static lxb_status_t serialize_to_smart_str_callback(const lxb_char_t *data, size
return LXB_STATUS_OK;
}
static zend_result php_uri_parser_whatwg_scheme_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result php_uri_parser_whatwg_scheme_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = internal_uri->uri;
@@ -277,7 +277,7 @@ static zend_result php_uri_parser_whatwg_scheme_write(struct uri_internal_t *int
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_username_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result php_uri_parser_whatwg_username_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = internal_uri->uri;
@@ -306,7 +306,7 @@ static zend_result php_uri_parser_whatwg_username_write(uri_internal_t *internal
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_password_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result php_uri_parser_whatwg_password_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = internal_uri->uri;
@@ -335,7 +335,7 @@ static zend_result php_uri_parser_whatwg_password_write(struct uri_internal_t *i
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_host_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result php_uri_parser_whatwg_host_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = internal_uri->uri;
@@ -357,7 +357,7 @@ static zend_result php_uri_parser_whatwg_host_read(const struct uri_internal_t *
ZVAL_EMPTY_STRING(retval);
} else if (lexbor_uri->host.type != LXB_URL_HOST_TYPE__UNDEF) {
switch (read_mode) {
case URI_COMPONENT_READ_NORMALIZED_UNICODE: {
case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: {
smart_str host_str = {0};
lxb_url_serialize_host_unicode(&lexbor_idna, &lexbor_uri->host, serialize_to_smart_str_callback, &host_str);
lxb_unicode_idna_clean(&lexbor_idna);
@@ -365,9 +365,9 @@ static zend_result php_uri_parser_whatwg_host_read(const struct uri_internal_t *
ZVAL_NEW_STR(retval, smart_str_extract(&host_str));
break;
}
case URI_COMPONENT_READ_NORMALIZED_ASCII:
case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII:
ZEND_FALLTHROUGH;
case URI_COMPONENT_READ_RAW:
case PHP_URI_COMPONENT_READ_MODE_RAW:
ZVAL_STRINGL(retval, (const char *) lexbor_uri->host.u.domain.data, lexbor_uri->host.u.domain.length);
break;
EMPTY_SWITCH_DEFAULT_CASE()
@@ -395,7 +395,7 @@ static zend_result php_uri_parser_whatwg_host_write(struct uri_internal_t *inter
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_port_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result php_uri_parser_whatwg_port_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = internal_uri->uri;
@@ -424,7 +424,7 @@ static zend_result php_uri_parser_whatwg_port_write(struct uri_internal_t *inter
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_path_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result php_uri_parser_whatwg_path_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = internal_uri->uri;
@@ -453,7 +453,7 @@ static zend_result php_uri_parser_whatwg_path_write(struct uri_internal_t *inter
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_query_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result php_uri_parser_whatwg_query_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = internal_uri->uri;
@@ -482,7 +482,7 @@ static zend_result php_uri_parser_whatwg_query_write(struct uri_internal_t *inte
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_fragment_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
static zend_result php_uri_parser_whatwg_fragment_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = internal_uri->uri;
@@ -594,21 +594,21 @@ static void *php_uri_parser_whatwg_clone(void *uri)
return lxb_url_clone(lexbor_parser.mraw, lexbor_uri);
}
static zend_string *php_uri_parser_whatwg_to_string(void *uri, uri_recomposition_mode_t recomposition_mode, bool exclude_fragment)
static zend_string *php_uri_parser_whatwg_to_string(void *uri, php_uri_recomposition_mode recomposition_mode, bool exclude_fragment)
{
const lxb_url_t *lexbor_uri = uri;
smart_str uri_str = {0};
switch (recomposition_mode) {
case URI_RECOMPOSITION_RAW_UNICODE:
case PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE:
ZEND_FALLTHROUGH;
case URI_RECOMPOSITION_NORMALIZED_UNICODE:
case PHP_URI_RECOMPOSITION_MODE_NORMALIZED_UNICODE:
lxb_url_serialize_idna(&lexbor_idna, lexbor_uri, serialize_to_smart_str_callback, &uri_str, exclude_fragment);
lxb_unicode_idna_clean(&lexbor_idna);
break;
case URI_RECOMPOSITION_RAW_ASCII:
case PHP_URI_RECOMPOSITION_MODE_RAW_ASCII:
ZEND_FALLTHROUGH;
case URI_RECOMPOSITION_NORMALIZED_ASCII:
case PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII:
lxb_url_serialize(lexbor_uri, serialize_to_smart_str_callback, &uri_str, exclude_fragment);
break;
EMPTY_SWITCH_DEFAULT_CASE()
@@ -624,20 +624,20 @@ static void php_uri_parser_whatwg_free(void *uri)
lxb_url_destroy(lexbor_uri);
}
const uri_parser_t php_uri_parser_whatwg = {
const php_uri_parser php_uri_parser_whatwg = {
.name = PHP_URI_PARSER_WHATWG,
.parse_uri = php_uri_parser_whatwg_parse,
.clone_uri = php_uri_parser_whatwg_clone,
.uri_to_string = php_uri_parser_whatwg_to_string,
.free_uri = php_uri_parser_whatwg_free,
.parse = php_uri_parser_whatwg_parse,
.clone = php_uri_parser_whatwg_clone,
.to_string = php_uri_parser_whatwg_to_string,
.free = php_uri_parser_whatwg_free,
{
.scheme = {.read_func = php_uri_parser_whatwg_scheme_read, .write_func = php_uri_parser_whatwg_scheme_write},
.username = {.read_func = php_uri_parser_whatwg_username_read, .write_func = php_uri_parser_whatwg_username_write},
.password = {.read_func = php_uri_parser_whatwg_password_read, .write_func = php_uri_parser_whatwg_password_write},
.host = {.read_func = php_uri_parser_whatwg_host_read, .write_func = php_uri_parser_whatwg_host_write},
.port = {.read_func = php_uri_parser_whatwg_port_read, .write_func = php_uri_parser_whatwg_port_write},
.path = {.read_func = php_uri_parser_whatwg_path_read, .write_func = php_uri_parser_whatwg_path_write},
.query = {.read_func = php_uri_parser_whatwg_query_read, .write_func = php_uri_parser_whatwg_query_write},
.fragment = {.read_func = php_uri_parser_whatwg_fragment_read, .write_func = php_uri_parser_whatwg_fragment_write},
.scheme = {.read = php_uri_parser_whatwg_scheme_read, .write = php_uri_parser_whatwg_scheme_write},
.username = {.read = php_uri_parser_whatwg_username_read, .write = php_uri_parser_whatwg_username_write},
.password = {.read = php_uri_parser_whatwg_password_read, .write = php_uri_parser_whatwg_password_write},
.host = {.read = php_uri_parser_whatwg_host_read, .write = php_uri_parser_whatwg_host_write},
.port = {.read = php_uri_parser_whatwg_port_read, .write = php_uri_parser_whatwg_port_write},
.path = {.read = php_uri_parser_whatwg_path_read, .write = php_uri_parser_whatwg_path_write},
.query = {.read = php_uri_parser_whatwg_query_read, .write = php_uri_parser_whatwg_query_write},
.fragment = {.read = php_uri_parser_whatwg_fragment_read, .write = php_uri_parser_whatwg_fragment_write},
}
};

2
ext/uri/uri_parser_whatwg.h
View File

@@ -20,7 +20,7 @@
#include "php_uri_common.h"
#include "lexbor/url/url.h"
extern const uri_parser_t php_uri_parser_whatwg;
extern const php_uri_parser php_uri_parser_whatwg;
lxb_url_t *php_uri_parser_whatwg_parse_ex(const char *uri_str, size_t uri_str_len, const lxb_url_t *lexbor_base_url, zval *errors, bool silent);

34
ext/zend_test/test.c
View File

@@ -735,7 +735,7 @@ static ZEND_FUNCTION(zend_test_uri_parser)
Z_PARAM_STR(parser_name)
ZEND_PARSE_PARAMETERS_END();
const uri_parser_t *parser = php_uri_get_parser(parser_name);
const php_uri_parser *parser = php_uri_get_parser(parser_name);
if (parser == NULL) {
zend_argument_value_error(1, "Unknown parser");
RETURN_THROWS();
@@ -751,40 +751,40 @@ static ZEND_FUNCTION(zend_test_uri_parser)
array_init(return_value);
zval normalized;
array_init(&normalized);
php_uri_get_scheme(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
php_uri_get_scheme(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_SCHEME), &value);
php_uri_get_username(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
php_uri_get_username(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_USERNAME), &value);
php_uri_get_password(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
php_uri_get_password(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_PASSWORD), &value);
php_uri_get_host(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
php_uri_get_host(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_HOST), &value);
php_uri_get_port(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
php_uri_get_port(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_PORT), &value);
php_uri_get_path(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
php_uri_get_path(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_PATH), &value);
php_uri_get_query(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
php_uri_get_query(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_QUERY), &value);
php_uri_get_fragment(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
php_uri_get_fragment(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_FRAGMENT), &value);
zend_hash_str_add(Z_ARR_P(return_value), "normalized", strlen("normalized"), &normalized);
zval raw;
array_init(&raw);
php_uri_get_scheme(uri, URI_COMPONENT_READ_RAW, &value);
php_uri_get_scheme(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_SCHEME), &value);
php_uri_get_username(uri, URI_COMPONENT_READ_RAW, &value);
php_uri_get_username(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_USERNAME), &value);
php_uri_get_password(uri, URI_COMPONENT_READ_RAW, &value);
php_uri_get_password(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_PASSWORD), &value);
php_uri_get_host(uri, URI_COMPONENT_READ_RAW, &value);
php_uri_get_host(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_HOST), &value);
php_uri_get_port(uri, URI_COMPONENT_READ_RAW, &value);
php_uri_get_port(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_PORT), &value);
php_uri_get_path(uri, URI_COMPONENT_READ_RAW, &value);
php_uri_get_path(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_PATH), &value);
php_uri_get_query(uri, URI_COMPONENT_READ_RAW, &value);
php_uri_get_query(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_QUERY), &value);
php_uri_get_fragment(uri, URI_COMPONENT_READ_RAW, &value);
php_uri_get_fragment(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_FRAGMENT), &value);
zend_hash_str_add(Z_ARR_P(return_value), "raw", strlen("raw"), &raw);

4
main/streams/php_stream_context.h
View File

@@ -66,9 +66,9 @@ PHPAPI void php_stream_context_set_option(php_stream_context *context,
void php_stream_context_unset_option(php_stream_context *context,
const char *wrappername, const char *optionname);
struct uri_parser_t;
struct php_uri_parser;
PHPAPI const struct uri_parser_t *php_stream_context_get_uri_parser(const char *wrappername, php_stream_context *context);
PHPAPI const struct php_uri_parser *php_stream_context_get_uri_parser(const char *wrappername, php_stream_context *context);
PHPAPI php_stream_notifier *php_stream_notification_alloc(void);
PHPAPI void php_stream_notification_free(php_stream_notifier *notifier);
END_EXTERN_C()

2
main/streams/streams.c
View File

@@ -2472,7 +2472,7 @@ void php_stream_context_unset_option(php_stream_context *context,
}
/* }}} */
PHPAPI const struct uri_parser_t *php_stream_context_get_uri_parser(const char *wrappername, php_stream_context *context)
PHPAPI const struct php_uri_parser *php_stream_context_get_uri_parser(const char *wrappername, php_stream_context *context)
{
if (context == NULL) {
return php_uri_get_parser(NULL);