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
Files
81f6ba550325a6fd513217adb67d99479f224944
archived-php-src/ext/uri/uri_parser_whatwg.c
Tim Düsterhus 81f6ba5503 uri: Use the “includes credentials” rule for WhatWg user/password getters (#20303) 
* uri: Use the “includes credentials” rule for WhatWg user/password getters

The URL serializing algorithm from the WHATWG URL Standard uses an “includes
credentials” rule to decide whether or not to include the `@` in the output,
indicating the presence of a userinfo component in RFC 3986 terminology. Use
this rule to determine whether or not an empty username or password should be
returned as the empty string (present but empty) or NULL (not present).

* uri: Use ZVAL_STRINGL_FAST in `whatwg_(username|password)_read()`

This nicely sidesteps the undefined behavior with passing a `(NULL, 0)` pair
without needing manual logic.

* NEWS
2025-11-01 14:15:06 +01:00

647 lines
20 KiB
C
Raw Blame History

/*
+----------------------------------------------------------------------+
| Copyright (c) The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| https://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Máté Kocsis <kocsismate@php.net> |
+----------------------------------------------------------------------+
*/
#include "php.h"
#include "uri_parser_whatwg.h"
#include "php_uri_common.h"
#include "Zend/zend_enum.h"
#include "Zend/zend_smart_str.h"
#include "Zend/zend_exceptions.h"
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
ZEND_TLS lexbor_mraw_t lexbor_mraw = {0};
ZEND_TLS lxb_url_parser_t lexbor_parser = {0};
ZEND_TLS lxb_unicode_idna_t lexbor_idna = {0};
static const size_t lexbor_mraw_byte_size = 8192;
static zend_always_inline void zval_string_or_null_to_lexbor_str(zval *value, lexbor_str_t *lexbor_str)
{
if (Z_TYPE_P(value) == IS_STRING && Z_STRLEN_P(value) > 0) {
lexbor_str->data = (lxb_char_t *) Z_STRVAL_P(value);
lexbor_str->length = Z_STRLEN_P(value);
} else {
ZEND_ASSERT(Z_ISNULL_P(value) || (Z_TYPE_P(value) == IS_STRING && Z_STRLEN_P(value) == 0));
lexbor_str->data = (lxb_char_t *) "";
lexbor_str->length = 0;
}
}
static zend_always_inline void zval_long_or_null_to_lexbor_str(zval *value, lexbor_str_t *lexbor_str)
{
if (Z_TYPE_P(value) == IS_LONG) {
ZVAL_STR(value, zend_long_to_str(Z_LVAL_P(value)));
lexbor_str_init_append(lexbor_str, lexbor_parser.mraw, (const lxb_char_t *) Z_STRVAL_P(value), Z_STRLEN_P(value));
zval_ptr_dtor_str(value);
} else {
ZEND_ASSERT(Z_ISNULL_P(value));
lexbor_str->data = (lxb_char_t *) "";
lexbor_str->length = 0;
}
}
/**
* Creates a Uri\WhatWg\UrlValidationError class by mapping error codes listed in
* https://url.spec.whatwg.org/#writing to a Uri\WhatWg\UrlValidationErrorType enum.
* The result is passed by reference to the errors parameter.
*/
static const char *fill_errors(zval *errors)
{
if (lexbor_parser.log == NULL || lexbor_plog_length(lexbor_parser.log) == 0) {
ZVAL_EMPTY_ARRAY(errors);
return NULL;
}
array_init(errors);
const char *result = NULL;
lexbor_plog_entry_t *lxb_error;
while ((lxb_error = lexbor_array_obj_pop(&lexbor_parser.log->list)) != NULL) {
zval error;
object_init_ex(&error, php_uri_ce_whatwg_url_validation_error);
zend_update_property_string(php_uri_ce_whatwg_url_validation_error, Z_OBJ(error), ZEND_STRL("context"), (const char *) lxb_error->data);
const char *error_str;
zval failure;
switch (lxb_error->id) {
case LXB_URL_ERROR_TYPE_DOMAIN_TO_ASCII:
error_str = "DomainToAscii";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_DOMAIN_TO_UNICODE:
error_str = "DomainToUnicode";
ZVAL_FALSE(&failure);
break;
case LXB_URL_ERROR_TYPE_DOMAIN_INVALID_CODE_POINT:
error_str = "DomainInvalidCodePoint";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_HOST_INVALID_CODE_POINT:
error_str = "HostInvalidCodePoint";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_EMPTY_PART:
error_str = "Ipv4EmptyPart";
ZVAL_FALSE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_TOO_MANY_PARTS:
error_str = "Ipv4TooManyParts";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_NON_NUMERIC_PART:
error_str = "Ipv4NonNumericPart";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_NON_DECIMAL_PART:
error_str = "Ipv4NonDecimalPart";
ZVAL_FALSE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_OUT_OF_RANGE_PART:
error_str = "Ipv4OutOfRangePart";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV6_UNCLOSED:
error_str = "Ipv6Unclosed";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV6_INVALID_COMPRESSION:
error_str = "Ipv6InvalidCompression";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV6_TOO_MANY_PIECES:
error_str = "Ipv6TooManyPieces";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV6_MULTIPLE_COMPRESSION:
error_str = "Ipv6MultipleCompression";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV6_INVALID_CODE_POINT:
error_str = "Ipv6InvalidCodePoint";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV6_TOO_FEW_PIECES:
error_str = "Ipv6TooFewPieces";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_IN_IPV6_TOO_MANY_PIECES:
error_str = "Ipv4InIpv6TooManyPieces";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_IN_IPV6_INVALID_CODE_POINT:
error_str = "Ipv4InIpv6InvalidCodePoint";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_IN_IPV6_OUT_OF_RANGE_PART:
error_str = "Ipv4InIpv6OutOfRangePart";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_IPV4_IN_IPV6_TOO_FEW_PARTS:
error_str = "Ipv4InIpv6TooFewParts";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_INVALID_URL_UNIT:
error_str = "InvalidUrlUnit";
ZVAL_FALSE(&failure);
break;
case LXB_URL_ERROR_TYPE_SPECIAL_SCHEME_MISSING_FOLLOWING_SOLIDUS:
error_str = "SpecialSchemeMissingFollowingSolidus";
ZVAL_FALSE(&failure);
break;
case LXB_URL_ERROR_TYPE_MISSING_SCHEME_NON_RELATIVE_URL:
error_str = "MissingSchemeNonRelativeUrl";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_INVALID_REVERSE_SOLIDUS:
error_str = "InvalidReverseSoldius";
ZVAL_FALSE(&failure);
break;
case LXB_URL_ERROR_TYPE_INVALID_CREDENTIALS:
error_str = "InvalidCredentials";
ZVAL_FALSE(&failure);
break;
case LXB_URL_ERROR_TYPE_HOST_MISSING:
error_str = "HostMissing";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_PORT_OUT_OF_RANGE:
error_str = "PortOutOfRange";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_PORT_INVALID:
error_str = "PortInvalid";
ZVAL_TRUE(&failure);
break;
case LXB_URL_ERROR_TYPE_FILE_INVALID_WINDOWS_DRIVE_LETTER:
error_str = "FileInvalidWindowsDriveLetter";
ZVAL_FALSE(&failure);
break;
case LXB_URL_ERROR_TYPE_FILE_INVALID_WINDOWS_DRIVE_LETTER_HOST:
error_str = "FileInvalidWindowsDriveLetterHost";
ZVAL_FALSE(&failure);
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
zval error_type;
ZVAL_OBJ(&error_type, zend_enum_get_case_cstr(php_uri_ce_whatwg_url_validation_error_type, error_str));
zend_update_property_ex(php_uri_ce_whatwg_url_validation_error, Z_OBJ(error), ZSTR_KNOWN(ZEND_STR_TYPE), &error_type);
zend_update_property(php_uri_ce_whatwg_url_validation_error, Z_OBJ(error), ZEND_STRL("failure"), &failure);
if (Z_TYPE(failure) == IS_TRUE) {
result = error_str;
}
add_next_index_zval(errors, &error);
}
return result;
}
static void throw_invalid_url_exception_during_write(zval *errors, const char *component)
{
zval err;
const char *reason = fill_errors(&err);
zend_object *exception = zend_throw_exception_ex(
php_uri_ce_whatwg_invalid_url_exception,
0,
"The specified %s is malformed%s%s%s",
component,
reason ? " (" : "",
reason ? reason : "",
reason ? ")" : ""
);
zend_update_property(exception->ce, exception, ZEND_STRL("errors"), &err);
if (errors) {
zval_ptr_dtor(errors);
ZVAL_COPY_VALUE(errors, &err);
} else {
zval_ptr_dtor(&err);
}
}
static lxb_status_t serialize_to_smart_str_callback(const lxb_char_t *data, size_t length, void *ctx)
{
smart_str *uri_str = ctx;
if (data != NULL && length > 0) {
smart_str_appendl(uri_str, (const char *) data, length);
}
return LXB_STATUS_OK;
}
static zend_result php_uri_parser_whatwg_scheme_read(void *uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = uri;
ZEND_ASSERT(lexbor_uri->scheme.type != LXB_URL_SCHEMEL_TYPE__UNDEF);
ZVAL_STRINGL(retval, (const char *) lexbor_uri->scheme.name.data, lexbor_uri->scheme.name.length);
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_scheme_write(void *uri, zval *value, zval *errors)
{
lxb_url_t *lexbor_uri = uri;
lexbor_str_t str = {0};
zval_string_or_null_to_lexbor_str(value, &str);
if (lxb_url_api_protocol_set(lexbor_uri, &lexbor_parser, str.data, str.length) != LXB_STATUS_OK) {
throw_invalid_url_exception_during_write(errors, "scheme");
return FAILURE;
}
return SUCCESS;
}
/* 4.2. URL miscellaneous: A URL includes credentials if its username or password is not the empty string. */
static bool includes_credentials(const lxb_url_t *lexbor_uri)
{
return lexbor_uri->username.length > 0 || lexbor_uri->password.length > 0;
}
static zend_result php_uri_parser_whatwg_username_read(void *uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = uri;
if (includes_credentials(lexbor_uri)) {
ZVAL_STRINGL_FAST(retval, (const char *) lexbor_uri->username.data, lexbor_uri->username.length);
} else {
ZVAL_NULL(retval);
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_username_write(void *uri, zval *value, zval *errors)
{
lxb_url_t *lexbor_uri = uri;
lexbor_str_t str = {0};
zval_string_or_null_to_lexbor_str(value, &str);
if (lxb_url_api_username_set(lexbor_uri, str.data, str.length) != LXB_STATUS_OK) {
throw_invalid_url_exception_during_write(errors, "username");
return FAILURE;
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_password_read(void *uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = uri;
if (includes_credentials(lexbor_uri)) {
ZVAL_STRINGL_FAST(retval, (const char *) lexbor_uri->password.data, lexbor_uri->password.length);
} else {
ZVAL_NULL(retval);
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_password_write(void *uri, zval *value, zval *errors)
{
lxb_url_t *lexbor_uri = uri;
lexbor_str_t str = {0};
zval_string_or_null_to_lexbor_str(value, &str);
if (lxb_url_api_password_set(lexbor_uri, str.data, str.length) != LXB_STATUS_OK) {
throw_invalid_url_exception_during_write(errors, "password");
return FAILURE;
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_host_read(void *uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = uri;
if (lexbor_uri->host.type == LXB_URL_HOST_TYPE_IPV4) {
smart_str host_str = {0};
lxb_url_serialize_host_ipv4(lexbor_uri->host.u.ipv4, serialize_to_smart_str_callback, &host_str);
ZVAL_NEW_STR(retval, smart_str_extract(&host_str));
} else if (lexbor_uri->host.type == LXB_URL_HOST_TYPE_IPV6) {
smart_str host_str = {0};
smart_str_appendc(&host_str, '[');
lxb_url_serialize_host_ipv6(lexbor_uri->host.u.ipv6, serialize_to_smart_str_callback, &host_str);
smart_str_appendc(&host_str, ']');
ZVAL_NEW_STR(retval, smart_str_extract(&host_str));
} else if (lexbor_uri->host.type == LXB_URL_HOST_TYPE_EMPTY) {
ZVAL_EMPTY_STRING(retval);
} else if (lexbor_uri->host.type != LXB_URL_HOST_TYPE__UNDEF) {
switch (read_mode) {
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);
ZVAL_NEW_STR(retval, smart_str_extract(&host_str));
break;
}
case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII:
ZEND_FALLTHROUGH;
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()
}
} else {
ZVAL_NULL(retval);
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_host_write(void *uri, zval *value, zval *errors)
{
lxb_url_t *lexbor_uri = uri;
lexbor_str_t str = {0};
zval_string_or_null_to_lexbor_str(value, &str);
if (lxb_url_api_hostname_set(lexbor_uri, &lexbor_parser, str.data, str.length) != LXB_STATUS_OK) {
throw_invalid_url_exception_during_write(errors, "host");
return FAILURE;
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_port_read(void *uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = uri;
if (lexbor_uri->has_port) {
ZVAL_LONG(retval, lexbor_uri->port);
} else {
ZVAL_NULL(retval);
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_port_write(void *uri, zval *value, zval *errors)
{
lxb_url_t *lexbor_uri = uri;
lexbor_str_t str = {0};
zval_long_or_null_to_lexbor_str(value, &str);
if (lxb_url_api_port_set(lexbor_uri, &lexbor_parser, str.data, str.length) != LXB_STATUS_OK) {
throw_invalid_url_exception_during_write(errors, "port");
return FAILURE;
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_path_read(void *uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = uri;
if (lexbor_uri->path.str.length) {
ZVAL_STRINGL(retval, (const char *) lexbor_uri->path.str.data, lexbor_uri->path.str.length);
} else {
ZVAL_EMPTY_STRING(retval);
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_path_write(void *uri, zval *value, zval *errors)
{
lxb_url_t *lexbor_uri = uri;
lexbor_str_t str = {0};
zval_string_or_null_to_lexbor_str(value, &str);
if (lxb_url_api_pathname_set(lexbor_uri, &lexbor_parser, str.data, str.length) != LXB_STATUS_OK) {
throw_invalid_url_exception_during_write(errors, "path");
return FAILURE;
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_query_read(void *uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = uri;
if (lexbor_uri->query.length) {
ZVAL_STRINGL(retval, (const char *) lexbor_uri->query.data, lexbor_uri->query.length);
} else {
ZVAL_NULL(retval);
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_query_write(void *uri, zval *value, zval *errors)
{
lxb_url_t *lexbor_uri = uri;
lexbor_str_t str = {0};
zval_string_or_null_to_lexbor_str(value, &str);
if (lxb_url_api_search_set(lexbor_uri, &lexbor_parser, str.data, str.length) != LXB_STATUS_OK) {
throw_invalid_url_exception_during_write(errors, "query string");
return FAILURE;
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_fragment_read(void *uri, php_uri_component_read_mode read_mode, zval *retval)
{
const lxb_url_t *lexbor_uri = uri;
if (lexbor_uri->fragment.length) {
ZVAL_STRINGL(retval, (const char *) lexbor_uri->fragment.data, lexbor_uri->fragment.length);
} else {
ZVAL_NULL(retval);
}
return SUCCESS;
}
static zend_result php_uri_parser_whatwg_fragment_write(void *uri, zval *value, zval *errors)
{
lxb_url_t *lexbor_uri = uri;
lexbor_str_t str = {0};
zval_string_or_null_to_lexbor_str(value, &str);
if (lxb_url_api_hash_set(lexbor_uri, &lexbor_parser, str.data, str.length) != LXB_STATUS_OK) {
throw_invalid_url_exception_during_write(errors, "fragment");
return FAILURE;
}
return SUCCESS;
}
PHP_RINIT_FUNCTION(uri_parser_whatwg)
{
lxb_status_t status;
status = lexbor_mraw_init(&lexbor_mraw, lexbor_mraw_byte_size);
if (status != LXB_STATUS_OK) {
goto fail;
}
status = lxb_url_parser_init(&lexbor_parser, &lexbor_mraw);
if (status != LXB_STATUS_OK) {
goto fail;
}
status = lxb_unicode_idna_init(&lexbor_idna);
if (status != LXB_STATUS_OK) {
goto fail;
}
return SUCCESS;
fail:
/* Unconditionally calling the _destroy() functions is
* safe on a zeroed structure. */
lxb_unicode_idna_destroy(&lexbor_idna, false);
memset(&lexbor_idna, 0, sizeof(lexbor_idna));
lxb_url_parser_destroy(&lexbor_parser, false);
memset(&lexbor_parser, 0, sizeof(lexbor_parser));
lexbor_mraw_destroy(&lexbor_mraw, false);
memset(&lexbor_mraw, 0, sizeof(lexbor_mraw));
return FAILURE;
}
ZEND_MODULE_POST_ZEND_DEACTIVATE_D(uri_parser_whatwg)
{
lxb_unicode_idna_destroy(&lexbor_idna, false);
memset(&lexbor_idna, 0, sizeof(lexbor_idna));
lxb_url_parser_destroy(&lexbor_parser, false);
memset(&lexbor_parser, 0, sizeof(lexbor_parser));
lexbor_mraw_destroy(&lexbor_mraw, false);
memset(&lexbor_mraw, 0, sizeof(lexbor_mraw));
return SUCCESS;
}
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)
{
lxb_url_parser_clean(&lexbor_parser);
lxb_url_t *url = lxb_url_parse(&lexbor_parser, lexbor_base_url, (unsigned char *) uri_str, uri_str_len);
if ((url == NULL && !silent) || errors != NULL) {
zval err;
const char *reason = fill_errors(&err);
if (url == NULL && !silent) {
zend_object *exception = zend_throw_exception_ex(php_uri_ce_whatwg_invalid_url_exception, 0, "The specified URI is malformed%s%s%s", reason ? " (" : "", reason ? reason : "", reason ? ")" : "");
zend_update_property(exception->ce, exception, ZEND_STRL("errors"), &err);
}
if (errors != NULL) {
zval_ptr_dtor(errors);
ZVAL_COPY_VALUE(errors, &err);
} else {
zval_ptr_dtor(&err);
}
}
return url;
}
static void *php_uri_parser_whatwg_parse(const char *uri_str, size_t uri_str_len, const void *base_url, zval *errors, bool silent)
{
return php_uri_parser_whatwg_parse_ex(uri_str, uri_str_len, base_url, errors, silent);
}
static void *php_uri_parser_whatwg_clone(void *uri)
{
const lxb_url_t *lexbor_uri = uri;
return lxb_url_clone(lexbor_parser.mraw, lexbor_uri);
}
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 PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE:
ZEND_FALLTHROUGH;
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 PHP_URI_RECOMPOSITION_MODE_RAW_ASCII:
ZEND_FALLTHROUGH;
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()
}
return smart_str_extract(&uri_str);
}
static void php_uri_parser_whatwg_destroy(void *uri)
{
lxb_url_t *lexbor_uri = uri;
lxb_url_destroy(lexbor_uri);
}
PHPAPI const php_uri_parser php_uri_parser_whatwg = {
.name = PHP_URI_PARSER_WHATWG,
.parse = php_uri_parser_whatwg_parse,
.clone = php_uri_parser_whatwg_clone,
.to_string = php_uri_parser_whatwg_to_string,
.destroy = php_uri_parser_whatwg_destroy,
{
.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},
}
};
Reference in New Issue View Git Blame Copy Permalink