/src/php-src/ext/uri/uri_parser_whatwg.c

Source
/*
   +----------------------------------------------------------------------+
   | Copyright © The PHP Group and Contributors.                          |
   +----------------------------------------------------------------------+
   | This source file is subject to the Modified BSD License that is      |
   | bundled with this package in the file LICENSE, and is available      |
   | through the World Wide Web at <https://www.php.net/license/>.        |
   |                                                                      |
   | SPDX-License-Identifier: BSD-3-Clause                                |
   +----------------------------------------------------------------------+
   | 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};
ZEND_TLS uint8_t lexbor_custom_url_map[256] = {0};

static const size_t lexbor_mraw_byte_size = 8192;

ZEND_ATTRIBUTE_NONNULL static zend_always_inline void zval_string_or_null_to_lexbor_str(const 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 bool zval_long_or_null_to_lexbor_str(const zval *value, lexbor_str_t *lexbor_str)
{
  if (Z_TYPE_P(value) == IS_LONG) {
    char buf[MAX_LENGTH_OF_LONG + 1];
    const char *res = zend_print_long_to_buf(buf + sizeof(buf) - 1, Z_LVAL_P(value));
    const lxb_char_t *appended = lexbor_str_init_append(lexbor_str, lexbor_parser.mraw, (const lxb_char_t *) res, strlen(res));
    if (UNEXPECTED(appended == NULL)) {
      return false;
    }
  } else {
    ZEND_ASSERT(Z_ISNULL_P(value));
    lexbor_str->data = (lxb_char_t *) "";
    lexbor_str->length = 0;
  }

  return true;
}

ZEND_ATTRIBUTE_NONNULL static bool get_reason_from_error_type(const lxb_url_error_type_t error_type, const char **error_str)
{
  switch (error_type) {
    case LXB_URL_ERROR_TYPE_DOMAIN_TO_ASCII:
      *error_str = "DomainToAscii";
      return true;
    case LXB_URL_ERROR_TYPE_DOMAIN_TO_UNICODE:
      *error_str = "DomainToUnicode";
      return false;
    case LXB_URL_ERROR_TYPE_DOMAIN_INVALID_CODE_POINT:
      *error_str = "DomainInvalidCodePoint";
      return true;
    case LXB_URL_ERROR_TYPE_HOST_INVALID_CODE_POINT:
      *error_str = "HostInvalidCodePoint";
      return true;
    case LXB_URL_ERROR_TYPE_IPV4_EMPTY_PART:
      *error_str = "Ipv4EmptyPart";
      return false;
    case LXB_URL_ERROR_TYPE_IPV4_TOO_MANY_PARTS:
      *error_str = "Ipv4TooManyParts";
      return true;
    case LXB_URL_ERROR_TYPE_IPV4_NON_NUMERIC_PART:
      *error_str = "Ipv4NonNumericPart";
      return true;
    case LXB_URL_ERROR_TYPE_IPV4_NON_DECIMAL_PART:
      *error_str = "Ipv4NonDecimalPart";
      return false;
    case LXB_URL_ERROR_TYPE_IPV4_OUT_OF_RANGE_PART:
      *error_str = "Ipv4OutOfRangePart";
      return true;
    case LXB_URL_ERROR_TYPE_IPV6_UNCLOSED:
      *error_str = "Ipv6Unclosed";
      return true;
    case LXB_URL_ERROR_TYPE_IPV6_INVALID_COMPRESSION:
      *error_str = "Ipv6InvalidCompression";
      return true;
    case LXB_URL_ERROR_TYPE_IPV6_TOO_MANY_PIECES:
      *error_str = "Ipv6TooManyPieces";
      return true;
    case LXB_URL_ERROR_TYPE_IPV6_MULTIPLE_COMPRESSION:
      *error_str = "Ipv6MultipleCompression";
      return true;
    case LXB_URL_ERROR_TYPE_IPV6_INVALID_CODE_POINT:
      *error_str = "Ipv6InvalidCodePoint";
      return true;
    case LXB_URL_ERROR_TYPE_IPV6_TOO_FEW_PIECES:
      *error_str = "Ipv6TooFewPieces";
      return true;
    case LXB_URL_ERROR_TYPE_IPV4_IN_IPV6_TOO_MANY_PIECES:
      *error_str = "Ipv4InIpv6TooManyPieces";
      return true;
    case LXB_URL_ERROR_TYPE_IPV4_IN_IPV6_INVALID_CODE_POINT:
      *error_str = "Ipv4InIpv6InvalidCodePoint";
      return true;
    case LXB_URL_ERROR_TYPE_IPV4_IN_IPV6_OUT_OF_RANGE_PART:
      *error_str = "Ipv4InIpv6OutOfRangePart";
      return true;
    case LXB_URL_ERROR_TYPE_IPV4_IN_IPV6_TOO_FEW_PARTS:
      *error_str = "Ipv4InIpv6TooFewParts";
      return true;
    case LXB_URL_ERROR_TYPE_INVALID_URL_UNIT:
      *error_str = "InvalidUrlUnit";
      return false;
    case LXB_URL_ERROR_TYPE_SPECIAL_SCHEME_MISSING_FOLLOWING_SOLIDUS:
      *error_str = "SpecialSchemeMissingFollowingSolidus";
      return false;
    case LXB_URL_ERROR_TYPE_MISSING_SCHEME_NON_RELATIVE_URL:
      *error_str = "MissingSchemeNonRelativeUrl";
      return true;
    case LXB_URL_ERROR_TYPE_INVALID_REVERSE_SOLIDUS:
      *error_str = "InvalidReverseSoldius";
      return false;
    case LXB_URL_ERROR_TYPE_INVALID_CREDENTIALS:
      *error_str = "InvalidCredentials";
      return false;
    case LXB_URL_ERROR_TYPE_HOST_MISSING:
      *error_str = "HostMissing";
      return true;
    case LXB_URL_ERROR_TYPE_PORT_OUT_OF_RANGE:
      *error_str = "PortOutOfRange";
      return true;
    case LXB_URL_ERROR_TYPE_PORT_INVALID:
      *error_str = "PortInvalid";
      return true;
    case LXB_URL_ERROR_TYPE_FILE_INVALID_WINDOWS_DRIVE_LETTER:
      *error_str = "FileInvalidWindowsDriveLetter";
      return false;
    case LXB_URL_ERROR_TYPE_FILE_INVALID_WINDOWS_DRIVE_LETTER_HOST:
      *error_str = "FileInvalidWindowsDriveLetterHost";
      return false;
    default: ZEND_UNREACHABLE();
  }
}

ZEND_ATTRIBUTE_NONNULL static bool append_validation_error(
  HashTable *errors, lxb_url_error_type_t error_type, const char *context, const char **reason
) {
  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"), context);

  bool failure = get_reason_from_error_type(error_type, reason);
  zval type;
  ZVAL_OBJ(&type, zend_enum_get_case_cstr(php_uri_ce_whatwg_url_validation_error_type, *reason));
  zend_update_property_ex(php_uri_ce_whatwg_url_validation_error, Z_OBJ(error), ZSTR_KNOWN(ZEND_STR_TYPE), &type);
  zend_update_property_bool(php_uri_ce_whatwg_url_validation_error, Z_OBJ(error), ZEND_STRL("failure"), failure);
  zend_hash_next_index_insert(errors, &error);

  return failure;
}

/**
 * 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.
 */
ZEND_ATTRIBUTE_NONNULL static const char *fill_errors_inner(HashTable *errors)
{
  const char *result = NULL;
  lexbor_plog_t *log = lexbor_parser.log;
  const size_t length = lexbor_plog_length(log);

  for (size_t i = 0; i < length; i++) {
    const lexbor_plog_entry_t *lxb_error = lexbor_array_obj_get(&log->list, i);
    const char *reason;
    if (append_validation_error(errors, lxb_error->id, (const char *) lxb_error->data, &reason) && result == NULL) {
      result = reason;
    }

    if (ZEND_HAS_OOM()) {
      break;
    }
  }
  lexbor_plog_clean(log);

  return result;
}

/**
 * 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.
 */
ZEND_ATTRIBUTE_NONNULL static const char *fill_errors(zval *errors)
{
  size_t log_len;
  if (lexbor_parser.log == NULL || (log_len = lexbor_plog_length(lexbor_parser.log)) == 0) {
    ZVAL_EMPTY_ARRAY(errors);
    return NULL;
  }

  array_init_size(errors, log_len);

  return fill_errors_inner(Z_ARRVAL_P(errors));
}

static void throw_invalid_url_exception_with_reason(zval *errors, const char *component, const char *reason, zval *err)
{
  if (ZEND_HAS_OOM()) {
    zend_handle_delayed_oom();
    return;
  }

  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 void throw_invalid_url_exception_during_write(zval *errors, const char *component)
{
  zval err;
  const char *reason = fill_errors(&err);

  throw_invalid_url_exception_with_reason(errors, component, reason, &err);
}

static lxb_status_t serialize_to_smart_str_callback(const lxb_char_t *data, const 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, const 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, const zval *value, zval *errors)
{
  lxb_url_t *lexbor_uri = uri;
  lexbor_str_t str = {0};

  zval_string_or_null_to_lexbor_str(value, &str);

  lxb_url_parser_clean(&lexbor_parser);

  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;
}

ZEND_ATTRIBUTE_NONNULL bool php_uri_parser_whatwg_is_special(const lxb_url_t *lexbor_uri)
{
  return lxb_url_is_special(lexbor_uri);
}

/* 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, const zval *value, zval *errors)
{
  lxb_url_t *lexbor_uri = uri;
  lexbor_str_t str = {0};

  zval_string_or_null_to_lexbor_str(value, &str);

  lxb_url_parser_clean(&lexbor_parser);

  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, const zval *value, zval *errors)
{
  lxb_url_t *lexbor_uri = uri;
  lexbor_str_t str = {0};

  zval_string_or_null_to_lexbor_str(value, &str);

  lxb_url_parser_clean(&lexbor_parser);

  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, const 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);
    if (ZEND_HAS_OOM()) {
      smart_str_free(&host_str);
      return FAILURE;
    }

    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, ']');
    if (ZEND_HAS_OOM()) {
      smart_str_free(&host_str);
      return FAILURE;
    }

    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);
        if (ZEND_HAS_OOM()) {
          smart_str_free(&host_str);
          return FAILURE;
        }

        ZVAL_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;
      default: ZEND_UNREACHABLE();
    }
  } else {
    ZVAL_NULL(retval);
  }

  return SUCCESS;
}

ZEND_ATTRIBUTE_NONNULL void php_uri_parser_whatwg_host_type_read(const lxb_url_t *lexbor_uri, zval *retval)
{
  switch (lexbor_uri->host.type) {
    case LXB_URL_HOST_TYPE_IPV4:
      ZVAL_OBJ_COPY(retval, zend_enum_get_case_cstr(php_uri_ce_whatwg_url_host_type, "IpV4"));
      return;
    case LXB_URL_HOST_TYPE_IPV6:
      ZVAL_OBJ_COPY(retval, zend_enum_get_case_cstr(php_uri_ce_whatwg_url_host_type, "IpV6"));
      return;
    case LXB_URL_HOST_TYPE_DOMAIN:
      ZVAL_OBJ_COPY(retval, zend_enum_get_case_cstr(php_uri_ce_whatwg_url_host_type, "Domain"));
      return;
    case LXB_URL_HOST_TYPE_EMPTY:
      ZVAL_OBJ_COPY(retval, zend_enum_get_case_cstr(php_uri_ce_whatwg_url_host_type, "Empty"));
      return;
    case LXB_URL_HOST_TYPE_OPAQUE:
      ZVAL_OBJ_COPY(retval, zend_enum_get_case_cstr(php_uri_ce_whatwg_url_host_type, "Opaque"));
      return;
    case LXB_URL_HOST_TYPE__UNDEF:
      ZVAL_NULL(retval);
      return;
    default: ZEND_UNREACHABLE();
  }
}

static zend_result php_uri_parser_whatwg_host_write(void *uri, const zval *value, zval *errors)
{
  lxb_url_t *lexbor_uri = uri;
  lexbor_str_t str = {0};

  zval_string_or_null_to_lexbor_str(value, &str);

  lxb_url_parser_clean(&lexbor_parser);

  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, const 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, const zval *value, zval *errors)
{
  lxb_url_t *lexbor_uri = uri;
  lexbor_str_t str = {0};

  if (UNEXPECTED(!zval_long_or_null_to_lexbor_str(value, &str))) {
    ZEND_ASSERT(ZEND_HAS_OOM());
    zend_handle_delayed_oom();
    return FAILURE;
  }

  lxb_url_parser_clean(&lexbor_parser);

  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, const php_uri_component_read_mode read_mode, zval *retval)
{
  const lxb_url_t *lexbor_uri = uri;

  if (lexbor_uri->path.str.length > 0) {
    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, const zval *value, zval *errors)
{
  lxb_url_t *lexbor_uri = uri;
  lexbor_str_t str = {0};

  zval_string_or_null_to_lexbor_str(value, &str);

  lxb_url_parser_clean(&lexbor_parser);

  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, const php_uri_component_read_mode read_mode, zval *retval)
{
  const lxb_url_t *lexbor_uri = uri;

  if (lexbor_uri->query.data != NULL) {
    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, const zval *value, zval *errors)
{
  lxb_url_t *lexbor_uri = uri;
  lexbor_str_t str = {0};

  zval_string_or_null_to_lexbor_str(value, &str);

  lxb_url_parser_clean(&lexbor_parser);

  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, const php_uri_component_read_mode read_mode, zval *retval)
{
  const lxb_url_t *lexbor_uri = uri;

  if (lexbor_uri->fragment.data != NULL) {
    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, const zval *value, zval *errors)
{
  lxb_url_t *lexbor_uri = uri;
  lexbor_str_t str = {0};

  zval_string_or_null_to_lexbor_str(value, &str);

  lxb_url_parser_clean(&lexbor_parser);

  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 = 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;
  }

  memcpy(lexbor_custom_url_map, lxb_url_get_percent_encoding_map(), sizeof(lexbor_custom_url_map));
  lexbor_custom_url_map['%'] = -1; /* % is percent-encoded */

  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, const size_t uri_str_len, const lxb_url_t *lexbor_base_url, zval *errors, const 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 (ZEND_HAS_OOM()) {
    zend_handle_delayed_oom();
    return url;
  }

  if ((url == NULL && !silent) || errors != NULL) {
    zval err;
    const char *reason = fill_errors(&err);
    if (ZEND_HAS_OOM()) {
      zval_ptr_dtor(&err);
      zend_handle_delayed_oom();

      return url;
    }

    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, const size_t uri_str_len, const void *base_url, zval *errors, const 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, const php_uri_recomposition_mode recomposition_mode, const 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;
    default: ZEND_UNREACHABLE();
  }

  if (ZEND_HAS_OOM()) {
    smart_str_free(&uri_str);
    return NULL;
  }

  return smart_str_extract(&uri_str);
}

static zend_string *php_uri_parser_whatwg_percent_encode_component(const char *str, const size_t str_length, const lxb_url_map_type_t map, const bool space_as_plus)
{
  lexbor_str_t lexbor_str = {0};

  const lexbor_status_t status = lxb_url_percent_encode_utf_8(
    (lxb_char_t *) str, str_length, &lexbor_str, lexbor_parser.mraw, lexbor_custom_url_map, map, space_as_plus
  );

  if (status != LXB_STATUS_OK) {
    lexbor_str_destroy(&lexbor_str, lexbor_parser.mraw, false);
    return NULL;
  }

  zend_string *result = zend_string_init((const char *) lexbor_str.data, lexbor_str.length, false);

  lexbor_str_destroy(&lexbor_str, lexbor_parser.mraw, false);

  return result;
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_userinfo_percent_encode(const char *str, const size_t str_length)
{
  return php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_USERINFO, false);
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_opaque_host_percent_encode(const char *str, const size_t str_length)
{
  return php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_C0, false);
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_path_percent_encode(const char *str, const size_t str_length)
{
  return php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_PATH, false);
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_opaque_path_percent_encode(const char *str, const size_t str_length)
{
  return php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_C0, false);
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_path_segment_percent_encode(const char *str, const size_t str_length)
{
  ZEND_ASSERT((lexbor_custom_url_map['/'] & LXB_URL_MAP_PATH) == 0);

  lexbor_custom_url_map['/'] |= LXB_URL_MAP_PATH;

  zend_string *result = php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_PATH, false);

  lexbor_custom_url_map['/'] &= ~LXB_URL_MAP_PATH;

  return result;
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_query_percent_encode(const char *str, const size_t str_length)
{
  return php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_QUERY, false);
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_special_query_percent_encode(const char *str, const size_t str_length)
{
  return php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_SPECIAL_QUERY, false);
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_form_query_percent_encode(const char *str, const size_t str_length)
{
  return php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_X_WWW_FORM, true);
}

ZEND_ATTRIBUTE_NONNULL zend_string *php_uri_parser_whatwg_fragment_percent_encode(const char *str, const size_t str_length)
{
  return php_uri_parser_whatwg_percent_encode_component(str, str_length, LXB_URL_MAP_FRAGMENT, false);
}

static void php_uri_parser_whatwg_destroy(void *uri)
{
  lxb_url_t *lexbor_uri = uri;

  lxb_url_destroy(lexbor_uri);
}

ZEND_ATTRIBUTE_NONNULL static void php_uri_parser_whatwg_throw_exception(const char *message)
{
  zend_object *exception = zend_throw_exception(php_uri_ce_whatwg_invalid_url_exception, message, 0);
  zval errors;
  ZVAL_EMPTY_ARRAY(&errors);
  zend_update_property(exception->ce, exception, ZEND_STRL("errors"), &errors);
}

ZEND_ATTRIBUTE_NONNULL static zend_always_inline zend_result php_uri_parser_whatwg_component_error(
  const char *component_name, const lxb_url_error_type_t error_type
) {
  zval errors;
  array_init(&errors);

  const char *reason = NULL;
  if (error_type != LXB_URL_ERROR_TYPE__LAST_ENTRY) {
    append_validation_error(Z_ARRVAL(errors), error_type, "", &reason);
  }

  zend_object *exception = zend_throw_exception_ex(php_uri_ce_whatwg_invalid_url_exception,
    0, "The specified %s is malformed%s%s%s", component_name,
    reason ? " (" : "", reason ? reason : "", reason ? ")" : "");

  zend_update_property(exception->ce, exception, ZEND_STRL("errors"), &errors);
  zval_ptr_dtor(&errors);

  return FAILURE;
}

ZEND_ATTRIBUTE_NONNULL zend_result php_uri_parser_whatwg_none_validate(const zend_string *component)
{
  return SUCCESS;
}

static zend_always_inline bool php_uri_whatwg_is_ascii_tab_or_newline(const unsigned char c)
{
  return c == '\t' || c == '\n' || c == '\r';
}

static zend_always_inline bool php_uri_parser_whatwg_is_alpha(const unsigned char c)
{
  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}

static zend_always_inline bool php_uri_parser_whatwg_is_digit(const unsigned char c)
{
  return c >= '0' && c <= '9';
}

static zend_always_inline unsigned char php_uri_ascii_to_lowercase(const unsigned char c)
{
  return c >= 'A' && c <= 'Z' ? (unsigned char) (c + ('a' - 'A')) : c;
}

ZEND_ATTRIBUTE_NONNULL zend_result php_uri_parser_whatwg_scheme_validate(const zend_string *scheme)
{
  const char *p = ZSTR_VAL(scheme);
  const char *end = p + ZSTR_LEN(scheme);
  bool seen_first = false;

  for (const char *c = p; c < end; c++) {
    const unsigned char uc = (unsigned char) *c;

    if (php_uri_whatwg_is_ascii_tab_or_newline(uc)) {
      continue;
    }

    if (!seen_first) {
      if (!php_uri_parser_whatwg_is_alpha(uc)) {
        return php_uri_parser_whatwg_component_error("scheme", LXB_URL_ERROR_TYPE_MISSING_SCHEME_NON_RELATIVE_URL);
      }
      seen_first = true;
    } else {
      if (!php_uri_parser_whatwg_is_alpha(uc) && !php_uri_parser_whatwg_is_digit(uc) && uc != '+' && uc != '-' && uc != '.') {
        return php_uri_parser_whatwg_component_error("scheme", LXB_URL_ERROR_TYPE_MISSING_SCHEME_NON_RELATIVE_URL);
      }
    }
  }

  if (!seen_first) {
    return php_uri_parser_whatwg_component_error("scheme", LXB_URL_ERROR_TYPE_MISSING_SCHEME_NON_RELATIVE_URL);
  }

  return SUCCESS;
}

ZEND_ATTRIBUTE_NONNULL zend_result php_uri_parser_whatwg_host_validate(const zend_string *host)
{
  if (ZSTR_LEN(host) == 0) {
    /* Skip validation - an empty string may or may not be a valid host depending on whether the URL is special */
    return SUCCESS;
  }

  const char *first = ZSTR_VAL(host);
  const char *last = ZSTR_VAL(host) + ZSTR_LEN(host);

  while (first < last && php_uri_whatwg_is_ascii_tab_or_newline((unsigned char) *first)) {
    first++;
  }

  /* Validate the entire host before the hostname setter can stop at a URL delimiter.
   * Backslash is a delimiter only for special URLs, but is also forbidden in opaque hosts.
   * https://url.spec.whatwg.org/#hostname-state
   * https://url.spec.whatwg.org/#opaque-host-parser */
  for (const char *p = first; p < last; p++) {
    if (*p == '/' || *p == '?' || *p == '#' || *p == '\\') {
      return php_uri_parser_whatwg_component_error("host", LXB_URL_ERROR_TYPE_HOST_INVALID_CODE_POINT);
    }
  }

  if (*first != '[') {
    /* Skip further validation - The host is not an IPv6 address */
    return SUCCESS;
  }

  while (first < last && php_uri_whatwg_is_ascii_tab_or_newline((unsigned char) *last)) {
    last--;
  }

  lxb_char_t *stripped_host = emalloc(last - first + 1);
  size_t stripped_host_len = 0;

  for (const char *i = first; i < last; i++) {
    const unsigned char uc = (unsigned char) *i;

    if (!php_uri_whatwg_is_ascii_tab_or_newline(uc)) {
      stripped_host[stripped_host_len++] = (lxb_char_t) uc;
    }
  }
  stripped_host[stripped_host_len] = '\0';

  uint16_t ipv6[8];
  const lxb_status_t result = lxb_url_parse_host_ipv6(
    &lexbor_parser,
    stripped_host,
    stripped_host_len,
    ipv6
  );

  efree(stripped_host);

  if (result != LXB_STATUS_OK) {
    lexbor_plog_entry_t *lxb_error;

    if (lexbor_parser.log != NULL && (lxb_error = lexbor_array_obj_pop(&lexbor_parser.log->list)) != NULL) {
      return php_uri_parser_whatwg_component_error("host", lxb_error->id);
    } else {
      return php_uri_parser_whatwg_component_error("host", LXB_URL_ERROR_TYPE__LAST_ENTRY);
    }
  }

  return SUCCESS;
}

ZEND_ATTRIBUTE_NONNULL zend_result php_uri_parser_whatwg_port_validate(const zend_long port)
{
  if (port  < 0) {
    return php_uri_parser_whatwg_component_error("port", LXB_URL_ERROR_TYPE_PORT_INVALID);
  }

  if (port > 65535) {
    return php_uri_parser_whatwg_component_error("port", LXB_URL_ERROR_TYPE_PORT_OUT_OF_RANGE);
  }

  return SUCCESS;
}

ZEND_ATTRIBUTE_NONNULL static lxb_url_scheme_type_t php_uri_parser_whatwg_get_special_scheme(const zend_string *scheme)
{
    const char *p = ZSTR_VAL(scheme);
    const char *end = p + ZSTR_LEN(scheme);

    /*
     * Create a normalized buffer from the scheme by leaving out tab and newline characters.
     * The longest special scheme "https" is 5 characters, therefore 6 bytes is enough to store.
     */
    char buf[6];
    size_t buf_len = 0;

    for (const char *c = p; c < end; c++) {
        const unsigned char uc = (unsigned char) *c;

        if (php_uri_whatwg_is_ascii_tab_or_newline(uc)) {
            continue;
        }

        if (buf_len == sizeof(buf) - 1) {
          /* Longer than any special scheme */
            return false;
        }

        buf[buf_len++] = (char) php_uri_ascii_to_lowercase(uc);
    }

    switch (buf_len) {
      case 2:
        if (memcmp(buf, "ws", 2) == 0) {
          return LXB_URL_SCHEMEL_TYPE_WS;
        }

        break;
        case 3:
        if (memcmp(buf, "ftp", 3) == 0) {
          return LXB_URL_SCHEMEL_TYPE_FTP;
        }

        if (memcmp(buf, "wss", 3) == 0) {
          return LXB_URL_SCHEMEL_TYPE_WSS;
        }

        break;
      case 4:
        if (memcmp(buf, "http", 4) == 0) {
          return LXB_URL_SCHEMEL_TYPE_HTTP;
        }

        if (memcmp(buf, "file", 4) == 0) {
          return LXB_URL_SCHEMEL_TYPE_FILE;
        }

            break;
        case 5:
        if (memcmp(buf, "https", 5) == 0) {
          return LXB_URL_SCHEMEL_TYPE_HTTPS;
        }

        break;
  }

  return LXB_URL_SCHEMEL_TYPE__UNDEF;
}

ZEND_ATTRIBUTE_NONNULL static const char *php_uri_parser_whatwg_build_errors(HashTable *errors)
{
  if (lexbor_parser.log == NULL || lexbor_plog_length(lexbor_parser.log) == 0) {
    return NULL;
  }

  return fill_errors_inner(errors);
}

ZEND_ATTRIBUTE_NONNULL static void php_uri_parser_whatwg_build_errors_into_exception(HashTable *errors)
{
  /* Include errors from earlier components in the exception raised by a later component. */
  if (zend_hash_num_elements(errors) > 0 && EG(exception)
    && instanceof_function(EG(exception)->ce, php_uri_ce_whatwg_invalid_url_exception)) {
    zval rv;
    zval *exception_errors = zend_read_property(php_uri_ce_whatwg_invalid_url_exception,
      EG(exception), ZEND_STRL("errors"), true, &rv);
    ZEND_ASSERT(Z_TYPE_P(exception_errors) == IS_ARRAY);

    zval *error;
    ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(exception_errors), error) {
      Z_TRY_ADDREF_P(error);
      zend_hash_next_index_insert(errors, error);
    } ZEND_HASH_FOREACH_END();

    zval_ptr_dtor(exception_errors);
    GC_ADDREF(errors);
    ZVAL_ARR(exception_errors, errors);
  }
}

ZEND_ATTRIBUTE_NONNULL static void php_uri_parser_whatwg_build_errors_and_throw(const lxb_status_t status, const char *component, HashTable *errors)
{
  if (status != LXB_STATUS_OK) {
    throw_invalid_url_exception_during_write(NULL, component);
  } else {
    php_uri_parser_whatwg_build_errors(errors);
  }
}

ZEND_ATTRIBUTE_NONNULL_ARGS(1, 2, 3, 4, 5, 6, 7, 8, 9) lxb_url_t *php_uri_parser_whatwg_resolve_reference_from_zval(
  lxb_url_t *lexbor_base_url, const zval *scheme, const zval *username, const zval *password,
  const zval *host, const zval *port, const zval *path, const zval *query, const zval *fragment,
  zval *soft_errors_zv
) {
  if (Z_TYPE_P(host) == IS_STRING) {
    if (lexbor_base_url->path.opaque) {
      php_uri_parser_whatwg_component_error("host", LXB_URL_ERROR_TYPE_MISSING_SCHEME_NON_RELATIVE_URL);
      return NULL;
    }

    /* A new authority inherits only the scheme, not the base URL's other components. */
    zval base_scheme;
    php_uri_parser_whatwg_scheme_read(lexbor_base_url, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &base_scheme);
    lxb_url_t *url = php_uri_parser_whatwg_build_from_zval(NULL, &base_scheme,
      username, password, host, port, path, query, fragment, soft_errors_zv);
    zval_ptr_dtor(&base_scheme);
    return url;
  }

  /* Credentials and ports require an authority in the reference itself. */
  if (Z_TYPE_P(username) == IS_STRING && Z_STRLEN_P(username) > 0) {
    php_uri_parser_whatwg_throw_exception("The specified URL cannot have username");
    return NULL;
  }

  if (Z_TYPE_P(password) == IS_STRING && Z_STRLEN_P(password) > 0) {
    php_uri_parser_whatwg_throw_exception("The specified URL cannot have password");
    return NULL;
  }

  if (Z_TYPE_P(port) == IS_LONG) {
    php_uri_parser_whatwg_throw_exception("The specified URL cannot have port");
    return NULL;
  }

  const char *first = Z_STRVAL_P(path);
  const char *end = first + Z_STRLEN_P(path);
  while (first < end && php_uri_whatwg_is_ascii_tab_or_newline(*first)) {
    first++;
  }

  lxb_status_t status;
  zval errors;
  array_init(&errors);

  lxb_url_t *lexbor_url = php_uri_parser_whatwg_clone(lexbor_base_url);
  if (lexbor_url == NULL) {
    zend_throw_exception(php_uri_ce_error, "Memory allocation error", 0);
    goto failure;
  }
  if (lexbor_base_url->path.opaque && first == end
    && (Z_TYPE_P(query) == IS_STRING || Z_TYPE_P(fragment) == IS_NULL)) {
    php_uri_parser_whatwg_component_error(Z_TYPE_P(query) == IS_STRING ? "query" : "path",
      LXB_URL_ERROR_TYPE_MISSING_SCHEME_NON_RELATIVE_URL);
    goto failure;
  }

  /* Discard the base fragment; the reference fragment is applied below. */
  lxb_url_fragment_set_null(lexbor_url);

  if (Z_STRLEN_P(path) > 0) {
    /* Resolve relative paths against the base directory. Absolute paths use
     * a path state so leading slashes cannot introduce a new authority. */
    lxb_url_state_t state = LXB_URL_STATE_NO_SCHEME_STATE;
    if (!lexbor_base_url->path.opaque && first < end
      && (*first == '/' || (lxb_url_is_special(lexbor_base_url) && *first == '\\'))) {
      /* A path beginning with // must not replace the authority. */
      state = LXB_URL_STATE_PATH_START_STATE;
      if (lexbor_base_url->scheme.type == LXB_URL_SCHEMEL_TYPE_FILE) {
        const char *second = first + 1;
        while (second < end && php_uri_whatwg_is_ascii_tab_or_newline(*second)) {
          second++;
        }
        if (second == end || (*second != '/' && *second != '\\')) {
          state = LXB_URL_STATE_FILE_STATE;
        }
      }
    }

    /* Keep delimiters inside the path when entering the reference parser. */
    smart_str reference = {0};
    for (const char *p = Z_STRVAL_P(path); p < end; p++) {
      if (*p == '?') {
        smart_str_appends(&reference, "%3F");
      } else if (*p == '#') {
        smart_str_appends(&reference, "%23");
        const char *reason;
        append_validation_error(
          Z_ARRVAL(errors), LXB_URL_ERROR_TYPE_INVALID_URL_UNIT, p, &reason
        );
      } else {
        smart_str_appendc(&reference, *p);
      }
    }

    /* After removing tabs and newlines, the parser must see a fragment
     * reference to accept an opaque base. Its actual value is applied below. */
    if (lexbor_base_url->path.opaque && first == end
      && Z_TYPE_P(query) == IS_NULL && Z_TYPE_P(fragment) != IS_NULL) {
      smart_str_appendc(&reference, '#');
    }

    zend_string *input = smart_str_extract(&reference);
    lxb_url_path_set_null(lexbor_url);
    lxb_url_parser_clean(&lexbor_parser);
    status = lxb_url_parse_basic(&lexbor_parser, lexbor_url, lexbor_base_url,
      (const lxb_char_t *) ZSTR_VAL(input), ZSTR_LEN(input), state, LXB_ENCODING_UTF_8);
    php_uri_parser_whatwg_build_errors_and_throw(status, "path", Z_ARRVAL(errors));
    zend_string_release(input);
    if (status != LXB_STATUS_OK) {
      goto failure;
    }
    if (first < end) {
      lxb_url_query_set_null(lexbor_url);
    }
  }

  if (Z_TYPE_P(query) == IS_STRING) {
    zend_result result = php_uri_parser_whatwg_query_write(lexbor_url, query, NULL);
    php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
    if (result == FAILURE) {
      goto failure;
    }
  }

  if (Z_TYPE_P(fragment) == IS_STRING) {
    zend_result result = php_uri_parser_whatwg_fragment_write(lexbor_url, fragment, NULL);
    php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
    if (result == FAILURE) {
      goto failure;
    }
  }

  if (php_uri_pass_errors_by_ref_and_free(soft_errors_zv, Z_ARRVAL(errors)) == FAILURE) {
    /* The errors array was already consumed; goto failure would destroy it again. */
    lxb_url_destroy(lexbor_url);
    return NULL;
  }

  return lexbor_url;

failure:
  php_uri_parser_whatwg_build_errors_into_exception(Z_ARRVAL(errors));
  zval_ptr_dtor(&errors);
  lxb_url_destroy(lexbor_url);
  return NULL;
}

ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_whatwg_build_path(
  lxb_url_t *lexbor_url, const zval *path, const zval *query, const zval *fragment, HashTable *errors
) {
  zend_result result;
  const char *path_start = Z_STRVAL_P(path);
  const char *path_end = path_start + Z_STRLEN_P(path);
  while (path_start < path_end && php_uri_whatwg_is_ascii_tab_or_newline(*path_start)) {
    path_start++;
  }

  if (lexbor_url->host.type == LXB_URL_HOST_TYPE__UNDEF && (path_start == path_end || *path_start != '/')) {
    /* A pathname setter cannot parse an opaque path. Parse it directly,
     * rejecting delimiters that would start a query or fragment. */
    for (const char *p = Z_STRVAL_P(path); p < path_end; p++) {
      if (*p == '?' || *p == '#') {
        throw_invalid_url_exception_during_write(NULL, "path");

        return FAILURE;
      }
    }

    smart_str opaque_path = {0};
    smart_str_append(&opaque_path, Z_STR_P(path));

    /* The opaque path parser needs the following delimiter to encode the
     * immediately preceding space, while still reporting all space errors. */
    if (Z_TYPE_P(query) == IS_STRING && Z_STRLEN_P(query) > 0) {
      smart_str_appendc(&opaque_path, '?');
    } else if (Z_TYPE_P(fragment) == IS_STRING && Z_STRLEN_P(fragment) > 0) {
      smart_str_appendc(&opaque_path, '#');
    }

    zend_string *input = smart_str_extract(&opaque_path);
    lxb_url_parser_clean(&lexbor_parser);
    const lxb_status_t status = lxb_url_parse_basic(&lexbor_parser, lexbor_url, NULL,
      (const lxb_char_t *) ZSTR_VAL(input), ZSTR_LEN(input),
      LXB_URL_STATE_OPAQUE_PATH_STATE, LXB_ENCODING_UTF_8);
    result = status == LXB_STATUS_OK ? SUCCESS : FAILURE;
    if (result == FAILURE) {
      throw_invalid_url_exception_during_write(NULL, "path");
    }
    php_uri_parser_whatwg_build_errors(errors);
    zend_string_release(input);
  } else {
    result = php_uri_parser_whatwg_path_write(lexbor_url, path, NULL);
  }

  return result;
}

ZEND_ATTRIBUTE_NONNULL_ARGS(2, 3, 4, 5, 6, 7, 8, 9) lxb_url_t *php_uri_parser_whatwg_build_from_zval(
  lxb_url_t *lexbor_base_url, const zval *scheme, const zval *username, const zval *password,
  const zval *host, const zval *port, const zval *path, const zval *query, const zval *fragment,
  zval *soft_errors_zv
) {
  lxb_url_parser_clean(&lexbor_parser);

  if (lexbor_base_url != NULL && Z_TYPE_P(scheme) == IS_STRING && Z_STRLEN_P(scheme) == 0) {
    return php_uri_parser_whatwg_resolve_reference_from_zval(
      lexbor_base_url, scheme, username, password, host, port, path, query, fragment, soft_errors_zv
    );
  }

  lxb_url_t *lexbor_url = lexbor_mraw_calloc(lexbor_parser.mraw, sizeof(*lexbor_url));
  if (lexbor_url == NULL) {
    zend_throw_exception(php_uri_ce_error, "Memory allocation error", 0);
    return NULL;
  }

  lexbor_url->mraw = lexbor_parser.mraw;

  /*
   * The URL is initialized as LXB_URL_SCHEMEL_TYPE__UNDEF but this would prevent the scheme to be updated
   * in case of non-special schemes due to https://github.com/php/php-src/blob/27d7b799c0a13578ee0506b428b8ddc209ffb010/ext/lexbor/lexbor/url/url.c#L1402
   */
  if (php_uri_parser_whatwg_get_special_scheme(Z_STR_P(scheme)) == LXB_URL_SCHEMEL_TYPE__UNDEF) {
    lexbor_url->scheme.type = LXB_URL_SCHEMEL_TYPE__UNKNOWN;
  }

  zval errors;
  array_init(&errors);

  zend_result result = php_uri_parser_whatwg_scheme_write(lexbor_url, scheme, NULL);
  php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
  if (result == FAILURE) {
    goto failure;
  }

  /* Set the host when provided or required by a special scheme (file allows an empty host).
   * Otherwise, preserve the absent host so the path can be opaque. */
  if (Z_TYPE_P(host) == IS_STRING || lxb_url_is_special(lexbor_url)) {
    result = php_uri_parser_whatwg_host_write(lexbor_url, host, NULL);
    php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
    if (result == FAILURE) {
      goto failure;
    }
  }

  if (lexbor_url->host.type == LXB_URL_HOST_TYPE__UNDEF
    || lexbor_url->host.type == LXB_URL_HOST_TYPE_EMPTY
    || lexbor_url->scheme.type == LXB_URL_SCHEMEL_TYPE_FILE) {
    if (Z_TYPE_P(username) == IS_STRING && Z_STRLEN_P(username) > 0) {
      php_uri_parser_whatwg_throw_exception("The specified URL cannot have username");
      goto failure;
    }

    if (Z_TYPE_P(password) == IS_STRING && Z_STRLEN_P(password) > 0) {
      php_uri_parser_whatwg_throw_exception("The specified URL cannot have password");
      goto failure;
    }

    if (Z_TYPE_P(port) != IS_NULL) {
      php_uri_parser_whatwg_throw_exception("The specified URL cannot have port");
      goto failure;
    }
  }

  /* Intentionally writing username after host to avoid error when the username is set but the host is missing */
  result = php_uri_parser_whatwg_username_write(lexbor_url, username, NULL);
  php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
  if (result == FAILURE) {
    goto failure;
  }

  /* Intentionally writing password after host to avoid error when the password is set but the password is missing */
  result = php_uri_parser_whatwg_password_write(lexbor_url, password, NULL);
  php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
  if (result == FAILURE) {
    goto failure;
  }

  /* Intentionally writing port after host to avoid error when the port is set but the host is missing */
  result = php_uri_parser_whatwg_port_write(lexbor_url, port, NULL);
  php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
  if (result == FAILURE) {
    goto failure;
  }

  result = php_uri_parser_whatwg_build_path(lexbor_url, path, query, fragment, Z_ARRVAL(errors));
  php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
  if (result == FAILURE) {
    goto failure;
  }

  result = php_uri_parser_whatwg_query_write(lexbor_url, query, NULL);
  php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
  if (result == FAILURE) {
    goto failure;
  }

  result = php_uri_parser_whatwg_fragment_write(lexbor_url, fragment, NULL);
  php_uri_parser_whatwg_build_errors(Z_ARRVAL(errors));
  if (result == FAILURE) {
    goto failure;
  }

  if (php_uri_pass_errors_by_ref_and_free(soft_errors_zv, Z_ARRVAL(errors)) == FAILURE) {
    /* The errors array was already consumed; goto failure would destroy it again. */
    lxb_url_destroy(lexbor_url);
    return NULL;
  }

  return lexbor_url;
failure:
  ZEND_ASSERT(EG(exception));
  php_uri_parser_whatwg_build_errors_into_exception(Z_ARRVAL(errors));
  zval_ptr_dtor(&errors);
  lxb_url_destroy(lexbor_url);
  return NULL;
}

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},
  }
};

Coverage Report

Created: 2026-10-28 06:20