Hugging Face's logo

Datasets:
meddyrat
/
dis-bench

Modalities:
Tabular
Text
Formats:
parquet
Size:
1K - 10K
Libraries:
Datasets
pandas
Polars
Dataset card Data Studio Files
xet
 Community
1
dis-bench / src /php /php-src /ext /dom /html_document.c
meddyrat's picture
meddyrat
Replace repository contents with the original corrected artifact
1e94262
Raw History Blame Contribute Delete
61.8 kB
/*
+----------------------------------------------------------------------+
| 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: Niels Dossche <nielsdos@php.net> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "php.h"
#if defined(HAVE_LIBXML) && defined(HAVE_DOM)
#include "php_dom.h"
#include "infra.h"
#include "html5_parser.h"
#include "html5_serializer.h"
#include "namespace_compat.h"
#include "private_data.h"
#include "dom_properties.h"
#include <Zend/zend_smart_string.h>
#include <lexbor/html/encoding.h>
#include <lexbor/encoding/encoding.h>
#include <lexbor/core/swar.h>
/* Implementation defined, but as HTML5 defaults in all other cases to UTF-8, we'll do the same. */
#define DOM_FALLBACK_ENCODING_ID LXB_ENCODING_UTF_8
typedef struct dom_line_column_cache {
size_t last_line;
size_t last_column;
size_t last_offset;
} dom_line_column_cache;
typedef struct dom_lexbor_libxml2_bridge_application_data {
const char *input_name;
const lxb_codepoint_t *current_input_codepoints;
const char *current_input_characters;
size_t current_input_length;
size_t current_total_offset;
dom_line_column_cache cache_tokenizer;
bool html_no_implied;
} dom_lexbor_libxml2_bridge_application_data;
typedef struct dom_character_encoding_data {
const lxb_encoding_data_t *encoding_data;
size_t bom_shift;
} dom_character_encoding_data;
typedef zend_result (*dom_write_output)(void*, const char *, size_t);
typedef struct dom_output_ctx {
const lxb_encoding_data_t *encoding_data;
const lxb_encoding_data_t *decoding_data;
lxb_encoding_encode_t *encode;
lxb_encoding_decode_t *decode;
lxb_codepoint_t *codepoints;
lxb_char_t *encoding_output;
void *output_data;
dom_write_output write_output;
} dom_output_ctx;
typedef struct dom_decoding_encoding_ctx {
/* We can skip some conversion if the input and output encoding are both UTF-8,
* we only have to validate and substitute replacement characters */
bool fast_path; /* Put first, near the encode & decode structures, for cache locality */
lxb_encoding_encode_t encode;
lxb_encoding_decode_t decode;
const lxb_encoding_data_t *encode_data;
const lxb_encoding_data_t *decode_data;
lxb_char_t encoding_output[4096];
lxb_codepoint_t codepoints[4096];
} dom_decoding_encoding_ctx;
/* https://dom.spec.whatwg.org/#dom-document-implementation */
zend_result dom_modern_document_implementation_read(dom_object *obj, zval *retval)
{
const uint32_t PROP_INDEX = 0;
#if ZEND_DEBUG
zend_string *implementation_str = ZSTR_INIT_LITERAL("implementation", false);
const zend_property_info *prop_info = zend_get_property_info(dom_abstract_base_document_class_entry, implementation_str, 0);
zend_string_release_ex(implementation_str, false);
ZEND_ASSERT(OBJ_PROP_TO_NUM(prop_info->offset) == PROP_INDEX);
#endif
zval *cached_implementation = OBJ_PROP_NUM(&obj->std, PROP_INDEX);
if (Z_ISUNDEF_P(cached_implementation)) {
php_dom_create_implementation(cached_implementation, true);
}
ZVAL_OBJ_COPY(retval, Z_OBJ_P(cached_implementation));
return SUCCESS;
}
static void dom_decoding_encoding_ctx_init(dom_decoding_encoding_ctx *ctx)
{
ctx->decode_data = ctx->encode_data = lxb_encoding_data(LXB_ENCODING_UTF_8);
ctx->fast_path = true;
(void) lxb_encoding_encode_init(
&ctx->encode,
ctx->encode_data,
ctx->encoding_output,
sizeof(ctx->encoding_output) / sizeof(*ctx->encoding_output)
);
(void) lxb_encoding_encode_replace_set(&ctx->encode, LXB_ENCODING_REPLACEMENT_BYTES, LXB_ENCODING_REPLACEMENT_SIZE);
(void) lxb_encoding_decode_init(
&ctx->decode,
ctx->decode_data,
ctx->codepoints,
sizeof(ctx->codepoints) / sizeof(*ctx->codepoints)
);
(void) lxb_encoding_decode_replace_set(&ctx->decode, LXB_ENCODING_REPLACEMENT_BUFFER, LXB_ENCODING_REPLACEMENT_BUFFER_LEN);
}
static const char *dom_lexbor_tokenizer_error_code_to_string(lxb_html_tokenizer_error_id_t id)
{
switch (id) {
case LXB_HTML_TOKENIZER_ERROR_ABCLOFEMCO: return "abrupt-closing-of-empty-comment";
case LXB_HTML_TOKENIZER_ERROR_ABDOPUID: return "abrupt-doctype-public-identifier";
case LXB_HTML_TOKENIZER_ERROR_ABDOSYID: return "abrupt-doctype-system-identifier";
case LXB_HTML_TOKENIZER_ERROR_ABOFDIINNUCHRE: return "absence-of-digits-in-numeric-character-reference";
case LXB_HTML_TOKENIZER_ERROR_CDINHTCO: return "cdata-in-html-content";
case LXB_HTML_TOKENIZER_ERROR_CHREOUUNRA: return "character-reference-outside-unicode-range";
case LXB_HTML_TOKENIZER_ERROR_COCHININST: return "control-character-in-input-stream";
case LXB_HTML_TOKENIZER_ERROR_COCHRE: return "control-character-reference";
case LXB_HTML_TOKENIZER_ERROR_ENTAWIAT: return "end-tag-with-attributes";
case LXB_HTML_TOKENIZER_ERROR_DUAT: return "duplicate-attribute";
case LXB_HTML_TOKENIZER_ERROR_ENTAWITRSO: return "end-tag-with-trailing-solidus";
case LXB_HTML_TOKENIZER_ERROR_EOBETANA: return "eof-before-tag-name";
case LXB_HTML_TOKENIZER_ERROR_EOINCD: return "eof-in-cdata";
case LXB_HTML_TOKENIZER_ERROR_EOINCO: return "eof-in-comment";
case LXB_HTML_TOKENIZER_ERROR_EOINDO: return "eof-in-doctype";
case LXB_HTML_TOKENIZER_ERROR_EOINSCHTCOLITE: return "eof-in-script-html-comment-like-text";
case LXB_HTML_TOKENIZER_ERROR_EOINTA: return "eof-in-tag";
case LXB_HTML_TOKENIZER_ERROR_INCLCO: return "incorrectly-closed-comment";
case LXB_HTML_TOKENIZER_ERROR_INOPCO: return "incorrectly-opened-comment";
case LXB_HTML_TOKENIZER_ERROR_INCHSEAFDONA: return "invalid-character-sequence-after-doctype-name";
case LXB_HTML_TOKENIZER_ERROR_INFICHOFTANA: return "invalid-first-character-of-tag-name";
case LXB_HTML_TOKENIZER_ERROR_MIATVA: return "missing-attribute-value";
case LXB_HTML_TOKENIZER_ERROR_MIDONA: return "missing-doctype-name";
case LXB_HTML_TOKENIZER_ERROR_MIDOPUID: return "missing-doctype-public-identifier";
case LXB_HTML_TOKENIZER_ERROR_MIDOSYID: return "missing-doctype-system-identifier";
case LXB_HTML_TOKENIZER_ERROR_MIENTANA: return "missing-end-tag-name";
case LXB_HTML_TOKENIZER_ERROR_MIQUBEDOPUID: return "missing-quote-before-doctype-public-identifier";
case LXB_HTML_TOKENIZER_ERROR_MIQUBEDOSYID: return "missing-quote-before-doctype-system-identifier";
case LXB_HTML_TOKENIZER_ERROR_MISEAFCHRE: return "missing-semicolon-after-character-reference";
case LXB_HTML_TOKENIZER_ERROR_MIWHAFDOPUKE: return "missing-whitespace-after-doctype-public-keyword";
case LXB_HTML_TOKENIZER_ERROR_MIWHAFDOSYKE: return "missing-whitespace-after-doctype-system-keyword";
case LXB_HTML_TOKENIZER_ERROR_MIWHBEDONA: return "missing-whitespace-before-doctype-name";
case LXB_HTML_TOKENIZER_ERROR_MIWHBEAT: return "missing-whitespace-between-attributes";
case LXB_HTML_TOKENIZER_ERROR_MIWHBEDOPUANSYID: return "missing-whitespace-between-doctype-public-and-system-identifiers";
case LXB_HTML_TOKENIZER_ERROR_NECO: return "nested-comment";
case LXB_HTML_TOKENIZER_ERROR_NOCHRE: return "noncharacter-character-reference";
case LXB_HTML_TOKENIZER_ERROR_NOININST: return "noncharacter-in-input-stream";
case LXB_HTML_TOKENIZER_ERROR_NOVOHTELSTTAWITRSO: return "non-void-html-element-start-tag-with-trailing-solidus";
case LXB_HTML_TOKENIZER_ERROR_NUCHRE: return "null-character-reference";
case LXB_HTML_TOKENIZER_ERROR_SUCHRE: return "surrogate-character-reference";
case LXB_HTML_TOKENIZER_ERROR_SUININST: return "surrogate-in-input-stream";
case LXB_HTML_TOKENIZER_ERROR_UNCHAFDOSYID: return "unexpected-character-after-doctype-system-identifier";
case LXB_HTML_TOKENIZER_ERROR_UNCHINATNA: return "unexpected-character-in-attribute-name";
case LXB_HTML_TOKENIZER_ERROR_UNCHINUNATVA: return "unexpected-character-in-unquoted-attribute-value";
case LXB_HTML_TOKENIZER_ERROR_UNEQSIBEATNA: return "unexpected-equals-sign-before-attribute-name";
case LXB_HTML_TOKENIZER_ERROR_UNNUCH: return "unexpected-null-character";
case LXB_HTML_TOKENIZER_ERROR_UNQUMAINOFTANA: return "unexpected-question-mark-instead-of-tag-name";
case LXB_HTML_TOKENIZER_ERROR_UNSOINTA: return "unexpected-solidus-in-tag";
case LXB_HTML_TOKENIZER_ERROR_UNNACHRE: return "unknown-named-character-reference";
default: return "unknown error";
}
}
static const char *dom_lexbor_tree_error_code_to_string(lxb_html_tree_error_id_t id)
{
switch (id) {
case LXB_HTML_RULES_ERROR_UNTO: return "unexpected-token";
case LXB_HTML_RULES_ERROR_UNCLTO: return "unexpected-closed-token";
case LXB_HTML_RULES_ERROR_NUCH: return "null-character";
case LXB_HTML_RULES_ERROR_UNCHTO: return "unexpected-character-token";
case LXB_HTML_RULES_ERROR_UNTOININMO: return "unexpected-token-in-initial-mode";
case LXB_HTML_RULES_ERROR_BADOTOININMO: return "bad-doctype-token-in-initial-mode";
case LXB_HTML_RULES_ERROR_DOTOINBEHTMO: return "doctype-token-in-before-html-mode";
case LXB_HTML_RULES_ERROR_UNCLTOINBEHTMO: return "unexpected-closed-token-in-before-html-mode";
case LXB_HTML_RULES_ERROR_DOTOINBEHEMO: return "doctype-token-in-before-head-mode";
case LXB_HTML_RULES_ERROR_UNCLTOINBEHEMO: return "unexpected-closed_token-in-before-head-mode";
case LXB_HTML_RULES_ERROR_DOTOINHEMO: return "doctype-token-in-head-mode";
case LXB_HTML_RULES_ERROR_NOVOHTELSTTAWITRSO: return "non-void-html-element-start-tag-with-trailing-solidus";
case LXB_HTML_RULES_ERROR_HETOINHEMO: return "head-token-in-head-mode";
case LXB_HTML_RULES_ERROR_UNCLTOINHEMO: return "unexpected-closed-token-in-head-mode";
case LXB_HTML_RULES_ERROR_TECLTOWIOPINHEMO: return "template-closed-token-without-opening-in-head-mode";
case LXB_HTML_RULES_ERROR_TEELISNOCUINHEMO: return "template-element-is-not-current-in-head-mode";
case LXB_HTML_RULES_ERROR_DOTOINHENOMO: return "doctype-token-in-head-noscript-mode";
case LXB_HTML_RULES_ERROR_DOTOAFHEMO: return "doctype-token-after-head-mode";
case LXB_HTML_RULES_ERROR_HETOAFHEMO: return "head-token-after-head-mode";
case LXB_HTML_RULES_ERROR_DOTOINBOMO: return "doctype-token-in-body-mode";
case LXB_HTML_RULES_ERROR_BAENOPELISWR: return "bad-ending-open-elements-is-wrong";
case LXB_HTML_RULES_ERROR_OPELISWR: return "open-elements-is-wrong";
case LXB_HTML_RULES_ERROR_UNELINOPELST: return "unexpected-element-in-open-elements-stack";
case LXB_HTML_RULES_ERROR_MIELINOPELST: return "missing-element-in-open-elements-stack";
case LXB_HTML_RULES_ERROR_NOBOELINSC: return "no-body-element-in-scope";
case LXB_HTML_RULES_ERROR_MIELINSC: return "missing-element-in-scope";
case LXB_HTML_RULES_ERROR_UNELINSC: return "unexpected-element-in-scope";
case LXB_HTML_RULES_ERROR_UNELINACFOST: return "unexpected-element-in-active-formatting-stack";
case LXB_HTML_RULES_ERROR_UNENOFFI: return "unexpected-end-of-file";
case LXB_HTML_RULES_ERROR_CHINTATE: return "characters-in-table-text";
case LXB_HTML_RULES_ERROR_DOTOINTAMO: return "doctype-token-in-table-mode";
case LXB_HTML_RULES_ERROR_DOTOINSEMO: return "doctype-token-in-select-mode";
case LXB_HTML_RULES_ERROR_DOTOAFBOMO: return "doctype-token-after-body-mode";
case LXB_HTML_RULES_ERROR_DOTOINFRMO: return "doctype-token-in-frameset-mode";
case LXB_HTML_RULES_ERROR_DOTOAFFRMO: return "doctype-token-after-frameset-mode";
case LXB_HTML_RULES_ERROR_DOTOFOCOMO: return "doctype-token-foreign-content-mode";
default: return "unknown error";
}
}
static const char *dom_lexbor_libxml2_bridge_status_code_to_string(lexbor_libxml2_bridge_status status)
{
switch (status) {
case LEXBOR_LIBXML2_BRIDGE_STATUS_CANNOT_INIT: return "cannot initialize data structures";
case LEXBOR_LIBXML2_BRIDGE_STATUS_FATAL_PARSE: return "fatal error in parsing";
case LEXBOR_LIBXML2_BRIDGE_STATUS_OVERFLOW: return "string length overflow";
case LEXBOR_LIBXML2_BRIDGE_STATUS_OOM: return "out of memory";
default: return "unknown error";
}
}
static void dom_reset_line_column_cache(dom_line_column_cache *cache)
{
cache->last_line = 1;
cache->last_column = 1;
cache->last_offset = 0;
}
static void dom_find_line_and_column_using_cache(
const dom_lexbor_libxml2_bridge_application_data *application_data,
dom_line_column_cache *cache,
size_t offset
)
{
offset -= application_data->current_total_offset;
if (offset > application_data->current_input_length) {
/* Possible with empty input, also just good for general safety */
offset = application_data->current_input_length;
}
size_t last_column = cache->last_column;
size_t last_line = cache->last_line;
size_t last_offset = cache->last_offset;
/* Either unicode or UTF-8 data */
if (application_data->current_input_codepoints != NULL) {
while (last_offset < offset) {
if (application_data->current_input_codepoints[last_offset] == 0x000A /* Unicode codepoint for line feed */) {
last_line++;
last_column = 1;
} else {
last_column++;
}
last_offset++;
}
} else {
while (last_offset < offset) {
const lxb_char_t current = application_data->current_input_characters[last_offset];
if (current == '\n') {
last_line++;
last_column = 1;
last_offset++;
} else {
/* See Lexbor tokenizer patch
* Note for future self: branchlessly computing the length and jumping by the length would be nice,
* however it takes so many instructions to do so that it is slower than this naive method. */
if ((current & 0b11000000) != 0b10000000) {
last_column++;
}
last_offset++;
}
}
}
cache->last_column = last_column;
cache->last_line = last_line;
cache->last_offset = last_offset;
}
static void dom_lexbor_libxml2_bridge_tokenizer_error_reporter(
void *application_data_voidptr,
lxb_html_tokenizer_error_t *error,
size_t offset
)
{
dom_lexbor_libxml2_bridge_application_data *application_data = application_data_voidptr;
dom_find_line_and_column_using_cache(application_data, &application_data->cache_tokenizer, offset);
php_libxml_pretend_ctx_error_ex(application_data->input_name, application_data->cache_tokenizer.last_line, application_data->cache_tokenizer.last_column, "tokenizer error %s in %s, line: %zu, column: %zu\n", dom_lexbor_tokenizer_error_code_to_string(error->id), application_data->input_name, application_data->cache_tokenizer.last_line, application_data->cache_tokenizer.last_column);
}
static void dom_lexbor_libxml2_bridge_tree_error_reporter(
void *application_data_voidptr,
lxb_html_tree_error_t *error,
size_t line,
size_t column,
size_t len
)
{
dom_lexbor_libxml2_bridge_application_data *application_data = application_data_voidptr;
if (line == 1 && application_data->html_no_implied && error->id == LXB_HTML_RULES_ERROR_UNTOININMO) {
/* For no implied mode, we want to mimick libxml's behaviour of not reporting an error for a lacking doctype. */
return;
}
if (len <= 1) {
/* Possible with EOF, or single-character tokens, don't use a range in the error display in this case */
php_libxml_pretend_ctx_error_ex(
application_data->input_name,
line,
column,
"tree error %s in %s, line: %zu, column: %zu\n",
dom_lexbor_tree_error_code_to_string(error->id),
application_data->input_name,
line,
column
);
} else {
php_libxml_pretend_ctx_error_ex(
application_data->input_name,
line,
column,
"tree error %s in %s, line: %zu, column: %zu-%zu\n",
dom_lexbor_tree_error_code_to_string(error->id),
application_data->input_name,
line,
column,
column + len - 1
);
}
}
static xmlNodePtr dom_search_child(xmlNodePtr parent, const char *searching_for)
{
xmlNodePtr node = parent->children;
while (node != NULL) {
if (node->type == XML_ELEMENT_NODE && strcmp((const char *) node->name, searching_for) == 0) {
return node;
}
node = node->next;
}
return NULL;
}
static void dom_place_remove_element_and_hoist_children(xmlNodePtr parent, const char *searching_for)
{
xmlNodePtr node = dom_search_child(parent, searching_for);
if (node != NULL) {
xmlUnlinkNode(node);
xmlNodePtr child = node->children;
while (child != NULL) {
xmlUnlinkNode(child);
xmlAddChild(parent, child);
child = node->children;
}
xmlFreeNode(node);
}
}
static void dom_post_process_html5_loading(
xmlDocPtr lxml_doc,
zend_long options,
const lexbor_libxml2_bridge_extracted_observations *observations
)
{
if (options & HTML_PARSE_NOIMPLIED) {
xmlNodePtr html_node = dom_search_child((xmlNodePtr) lxml_doc, "html");
if (!observations->has_explicit_head_tag) {
dom_place_remove_element_and_hoist_children(html_node, "head");
}
if (!observations->has_explicit_body_tag) {
dom_place_remove_element_and_hoist_children(html_node, "body");
}
if (!observations->has_explicit_html_tag) {
dom_place_remove_element_and_hoist_children((xmlNodePtr) lxml_doc, "html");
}
}
}
/* https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding */
static dom_character_encoding_data dom_determine_encoding(const char *source, size_t source_len)
{
dom_character_encoding_data result;
/* BOM sniffing */
if (source_len >= 3 && source[0] == '\xEF' && source[1] == '\xBB' && source[2] == '\xBF') {
result.encoding_data = lxb_encoding_data(LXB_ENCODING_UTF_8);
result.bom_shift = 3;
return result;
} else if (source_len >= 2) {
if (source[0] == '\xFE' && source[1] == '\xFF') {
result.encoding_data = lxb_encoding_data(LXB_ENCODING_UTF_16BE);
result.bom_shift = 2;
return result;
} else if (source[0] == '\xFF' && source[1] == '\xFE') {
result.encoding_data = lxb_encoding_data(LXB_ENCODING_UTF_16LE);
result.bom_shift = 2;
return result;
}
}
/* Perform prescan */
lxb_html_encoding_t encoding;
lxb_status_t status = lxb_html_encoding_init(&encoding);
if (status != LXB_STATUS_OK) {
goto fallback_uninit;
}
/* This is the "wait either for 1024 bytes or 500ms" part */
if (source_len > 1024) {
source_len = 1024;
}
status = lxb_html_encoding_determine(&encoding, (const lxb_char_t *) source, (const lxb_char_t *) source + source_len);
if (status != LXB_STATUS_OK) {
goto fallback;
}
lxb_html_encoding_entry_t *entry = lxb_html_encoding_meta_entry(&encoding, 0);
if (entry == NULL) {
goto fallback;
}
result.encoding_data = lxb_encoding_data_by_pre_name(entry->name, entry->end - entry->name);
if (!result.encoding_data) {
goto fallback;
}
result.bom_shift = 0;
lxb_html_encoding_destroy(&encoding, false);
return result;
fallback:
lxb_html_encoding_destroy(&encoding, false);
fallback_uninit:
result.encoding_data = lxb_encoding_data(DOM_FALLBACK_ENCODING_ID);
result.bom_shift = 0;
return result;
}
static void dom_setup_parser_encoding_manually(const lxb_char_t *buf_start, const lxb_encoding_data_t *encoding_data, dom_decoding_encoding_ctx *decoding_encoding_ctx, dom_lexbor_libxml2_bridge_application_data *application_data)
{
static const lxb_codepoint_t replacement_codepoint = LXB_ENCODING_REPLACEMENT_CODEPOINT;
decoding_encoding_ctx->decode_data = encoding_data;
(void) lxb_encoding_decode_init(
&decoding_encoding_ctx->decode,
decoding_encoding_ctx->decode_data,
decoding_encoding_ctx->codepoints,
sizeof(decoding_encoding_ctx->codepoints) / sizeof(*decoding_encoding_ctx->codepoints)
);
(void) lxb_encoding_decode_replace_set(
&decoding_encoding_ctx->decode,
&replacement_codepoint,
LXB_ENCODING_REPLACEMENT_BUFFER_LEN
);
/* Note: encode_data is for UTF-8 */
decoding_encoding_ctx->fast_path = decoding_encoding_ctx->decode_data == decoding_encoding_ctx->encode_data;
if (decoding_encoding_ctx->fast_path) {
application_data->current_input_codepoints = NULL;
application_data->current_input_characters = (const char *) buf_start;
} else {
application_data->current_input_codepoints = decoding_encoding_ctx->codepoints;
application_data->current_input_characters = NULL;
}
}
static void dom_setup_parser_encoding_implicitly(
const lxb_char_t **buf_ref,
size_t *read,
dom_decoding_encoding_ctx *decoding_encoding_ctx,
dom_lexbor_libxml2_bridge_application_data *application_data
)
{
const char *buf_start = (const char *) *buf_ref;
dom_character_encoding_data dom_encoding_data = dom_determine_encoding(buf_start, *read);
*buf_ref += dom_encoding_data.bom_shift;
*read -= dom_encoding_data.bom_shift;
dom_setup_parser_encoding_manually((const lxb_char_t *) buf_start, dom_encoding_data.encoding_data, decoding_encoding_ctx, application_data);
}
static bool dom_process_parse_chunk(
lexbor_libxml2_bridge_parse_context *ctx,
lxb_html_document_t *document,
lxb_html_parser_t *parser,
size_t encoded_length,
const lxb_char_t *encoding_output,
size_t input_buffer_length,
size_t *tokenizer_error_offset,
size_t *tree_error_offset
)
{
dom_lexbor_libxml2_bridge_application_data *application_data = ctx->application_data;
application_data->current_input_length = input_buffer_length;
lexbor_status_t lexbor_status = lxb_html_document_parse_chunk(document, encoding_output, encoded_length);
if (UNEXPECTED(lexbor_status != LXB_STATUS_OK)) {
return false;
}
if (ctx->tokenizer_error_reporter || ctx->tree_error_reporter) {
lexbor_libxml2_bridge_report_errors(ctx, parser, encoding_output, application_data->current_total_offset, tokenizer_error_offset, tree_error_offset);
dom_find_line_and_column_using_cache(application_data, &application_data->cache_tokenizer, application_data->current_total_offset + input_buffer_length);
}
application_data->current_total_offset += input_buffer_length;
application_data->cache_tokenizer.last_offset = 0;
return true;
}
/* This seeks, using SWAR techniques, to the first non-ASCII byte in a UTF-8 input.
* Returns true if the entire input was consumed without encountering non-ASCII, false otherwise. */
static zend_always_inline bool dom_seek_utf8_non_ascii(const lxb_char_t **data, const lxb_char_t *end)
{
while (*data + sizeof(size_t) <= end) {
size_t bytes;
memcpy(&bytes, *data, sizeof(bytes));
/* If the top bit is set, it's not ASCII. */
if ((bytes & LEXBOR_SWAR_REPEAT(0x80)) != 0) {
return false;
}
*data += sizeof(size_t);
}
while (*data < end) {
if (**data & 0x80) {
return false;
}
(*data)++;
}
return true;
}
static bool dom_decode_encode_fast_path(
lexbor_libxml2_bridge_parse_context *ctx,
lxb_html_document_t *document,
lxb_html_parser_t *parser,
const lxb_char_t **buf_ref_ref,
const lxb_char_t *buf_end,
dom_decoding_encoding_ctx *decoding_encoding_ctx,
size_t *tokenizer_error_offset,
size_t *tree_error_offset
)
{
const lxb_char_t *buf_ref = *buf_ref_ref;
/* If we returned for needing more bytes, we need to finish up the buffer for the old codepoint. */
if (decoding_encoding_ctx->decode.status == LXB_STATUS_CONTINUE) {
lxb_char_t buf[4];
lxb_char_t *buf_ptr = buf;
lxb_codepoint_t codepoint = lxb_encoding_decode_utf_8_single(&decoding_encoding_ctx->decode, &buf_ref, buf_end);
if (lxb_encoding_encode_utf_8_single(&decoding_encoding_ctx->encode, &buf_ptr, buf + sizeof(buf), codepoint) > sizeof(buf)) {
buf_ptr = zend_mempcpy(buf, LXB_ENCODING_REPLACEMENT_BYTES, LXB_ENCODING_REPLACEMENT_SIZE);
}
decoding_encoding_ctx->decode.status = LXB_STATUS_OK;
if (!dom_process_parse_chunk(
ctx,
document,
parser,
buf_ptr - buf,
buf,
buf_ref - *buf_ref_ref,
tokenizer_error_offset,
tree_error_offset
)) {
goto fail_oom;
}
}
const lxb_char_t *last_output = buf_ref;
while (buf_ref != buf_end) {
/* Fast path converts non-validated UTF-8 -> validated UTF-8 */
if (decoding_encoding_ctx->decode.u.utf_8.need == 0) {
/* Fast path within the fast path: try to skip non-mb bytes in bulk if we are not in a state where we
* need more UTF-8 bytes to complete a sequence. */
if (dom_seek_utf8_non_ascii(&buf_ref, buf_end)) {
ZEND_ASSERT(buf_ref == buf_end);
break;
}
}
const lxb_char_t *buf_ref_backup = buf_ref;
lxb_codepoint_t codepoint = lxb_encoding_decode_utf_8_single(&decoding_encoding_ctx->decode, &buf_ref, buf_end);
if (UNEXPECTED(codepoint > LXB_ENCODING_MAX_CODEPOINT)) {
if (!dom_process_parse_chunk(
ctx,
document,
parser,
buf_ref_backup - last_output,
last_output,
buf_ref - last_output,
tokenizer_error_offset,
tree_error_offset
)) {
goto fail_oom;
}
if (codepoint == LXB_ENCODING_DECODE_CONTINUE) {
ZEND_ASSERT(buf_ref == buf_end);
/* The decoder needs more data but the entire buffer is consumed.
* All valid data is outputted, and if the remaining data for the code point
* is invalid, the next call will output the replacement bytes. */
*buf_ref_ref = buf_ref;
decoding_encoding_ctx->decode.status = LXB_STATUS_CONTINUE;
return true;
}
if (!dom_process_parse_chunk(
ctx,
document,
parser,
LXB_ENCODING_REPLACEMENT_SIZE,
LXB_ENCODING_REPLACEMENT_BYTES,
0,
tokenizer_error_offset,
tree_error_offset
)) {
goto fail_oom;
}
last_output = buf_ref;
}
}
if (buf_ref != last_output
&& !dom_process_parse_chunk(
ctx,
document,
parser,
buf_ref - last_output,
last_output,
buf_ref - last_output,
tokenizer_error_offset,
tree_error_offset
)) {
goto fail_oom;
}
*buf_ref_ref = buf_ref;
return true;
fail_oom:
*buf_ref_ref = buf_ref;
return false;
}
static bool dom_decode_encode_slow_path(
lexbor_libxml2_bridge_parse_context *ctx,
lxb_html_document_t *document,
lxb_html_parser_t *parser,
const lxb_char_t **buf_ref_ref,
const lxb_char_t *buf_end,
dom_decoding_encoding_ctx *decoding_encoding_ctx,
size_t *tokenizer_error_offset,
size_t *tree_error_offset
)
{
const lxb_char_t *buf_ref = *buf_ref_ref;
lexbor_status_t decode_status, encode_status;
do {
decode_status = decoding_encoding_ctx->decode_data->decode(&decoding_encoding_ctx->decode, &buf_ref, buf_end);
const lxb_codepoint_t *codepoints_ref = (const lxb_codepoint_t *) decoding_encoding_ctx->codepoints;
size_t decoding_buffer_used = lxb_encoding_decode_buf_used(&decoding_encoding_ctx->decode);
const lxb_codepoint_t *codepoints_end = decoding_encoding_ctx->codepoints + decoding_buffer_used;
do {
encode_status = decoding_encoding_ctx->encode_data->encode(&decoding_encoding_ctx->encode, &codepoints_ref, codepoints_end);
ZEND_ASSERT(encode_status != LXB_STATUS_ERROR && "parameters and replacements should be valid");
if (!dom_process_parse_chunk(
ctx,
document,
parser,
lxb_encoding_encode_buf_used(&decoding_encoding_ctx->encode),
decoding_encoding_ctx->encoding_output,
decoding_buffer_used,
tokenizer_error_offset,
tree_error_offset
)) {
goto fail_oom;
}
lxb_encoding_encode_buf_used_set(&decoding_encoding_ctx->encode, 0);
} while (encode_status == LXB_STATUS_SMALL_BUFFER);
lxb_encoding_decode_buf_used_set(&decoding_encoding_ctx->decode, 0);
} while (decode_status == LXB_STATUS_SMALL_BUFFER);
*buf_ref_ref = buf_ref;
return true;
fail_oom:
*buf_ref_ref = buf_ref;
return false;
}
static bool dom_parse_decode_encode_step(
lexbor_libxml2_bridge_parse_context *ctx,
lxb_html_document_t *document,
lxb_html_parser_t *parser,
const lxb_char_t **buf_ref_ref,
const lxb_char_t *buf_end,
dom_decoding_encoding_ctx *decoding_encoding_ctx,
size_t *tokenizer_error_offset,
size_t *tree_error_offset
)
{
if (decoding_encoding_ctx->fast_path) {
return dom_decode_encode_fast_path(
ctx,
document,
parser,
buf_ref_ref,
buf_end,
decoding_encoding_ctx,
tokenizer_error_offset,
tree_error_offset
);
} else {
return dom_decode_encode_slow_path(
ctx,
document,
parser,
buf_ref_ref,
buf_end,
decoding_encoding_ctx,
tokenizer_error_offset,
tree_error_offset
);
}
}
static bool dom_parse_decode_encode_finish(
lexbor_libxml2_bridge_parse_context *ctx,
lxb_html_document_t *document,
lxb_html_parser_t *parser,
dom_decoding_encoding_ctx *decoding_encoding_ctx,
size_t *tokenizer_error_offset,
size_t *tree_error_offset
)
{
lxb_status_t status;
status = lxb_encoding_decode_finish(&decoding_encoding_ctx->decode);
ZEND_ASSERT(status == LXB_STATUS_OK);
size_t decoding_buffer_size = lxb_encoding_decode_buf_used(&decoding_encoding_ctx->decode);
if (decoding_buffer_size > 0) {
const lxb_codepoint_t *codepoints_ref = (const lxb_codepoint_t *) decoding_encoding_ctx->codepoints;
const lxb_codepoint_t *codepoints_end = codepoints_ref + decoding_buffer_size;
status = decoding_encoding_ctx->encode_data->encode(&decoding_encoding_ctx->encode, &codepoints_ref, codepoints_end);
ZEND_ASSERT(status == LXB_STATUS_OK);
/* No need to produce output here, as we finish the encoder below and pass the chunk. */
}
status = lxb_encoding_encode_finish(&decoding_encoding_ctx->encode);
ZEND_ASSERT(status == LXB_STATUS_OK);
if (lxb_encoding_encode_buf_used(&decoding_encoding_ctx->encode)
&& !dom_process_parse_chunk(
ctx,
document,
parser,
lxb_encoding_encode_buf_used(&decoding_encoding_ctx->encode),
decoding_encoding_ctx->encoding_output,
lxb_encoding_decode_buf_used(&decoding_encoding_ctx->decode),
tokenizer_error_offset,
tree_error_offset
)) {
return false;
}
return true;
}
static bool check_options_validity(uint32_t arg_num, zend_long options)
{
const zend_long VALID_OPTIONS = XML_PARSE_NOERROR | XML_PARSE_COMPACT | HTML_PARSE_NOIMPLIED | DOM_HTML_NO_DEFAULT_NS;
if ((options & ~VALID_OPTIONS) != 0) {
zend_argument_value_error(arg_num, "contains invalid flags (allowed flags: "
"LIBXML_NOERROR, "
"LIBXML_COMPACT, "
"LIBXML_HTML_NOIMPLIED, "
"Dom\\HTML_NO_DEFAULT_NS)");
return false;
}
return true;
}
PHP_METHOD(Dom_HTMLDocument, createEmpty)
{
const char *encoding = "UTF-8";
size_t encoding_len = strlen("UTF-8");
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|p", &encoding, &encoding_len) == FAILURE) {
RETURN_THROWS();
}
const lxb_encoding_data_t *encoding_data = lxb_encoding_data_by_name((const lxb_char_t *) encoding, encoding_len);
if (encoding_data == NULL) {
zend_argument_value_error(1, "must be a valid document encoding");
RETURN_THROWS();
}
xmlDocPtr lxml_doc = php_dom_create_html_doc();
if (UNEXPECTED(lxml_doc == NULL)) {
goto oom;
}
lxml_doc->encoding = xmlStrdup((const xmlChar *) encoding);
dom_object *intern = php_dom_instantiate_object_helper(
return_value,
dom_html_document_class_entry,
(xmlNodePtr) lxml_doc,
NULL
);
dom_set_xml_class(intern->document);
intern->document->private_data = php_dom_libxml_private_data_header(php_dom_private_data_create());
return;
oom:
php_dom_throw_error(INVALID_STATE_ERR, true);
RETURN_THROWS();
}
/* Only bother to register error handling when the error reports can become observable. */
static bool dom_should_register_error_handlers(zend_long options)
{
if (options & XML_PARSE_NOERROR) {
return false;
}
return php_libxml_uses_internal_errors() || ((EG(error_reporting) | EG(user_error_handler_error_reporting)) & E_WARNING);
}
PHP_METHOD(Dom_HTMLDocument, createFromString)
{
const char *source, *override_encoding = NULL;
size_t source_len, override_encoding_len;
zend_long options = 0;
if (zend_parse_parameters(
ZEND_NUM_ARGS(),
"s|lp!",
&source,
&source_len,
&options,
&override_encoding,
&override_encoding_len
) == FAILURE) {
RETURN_THROWS();
}
if (!check_options_validity(2, options)) {
RETURN_THROWS();
}
dom_lexbor_libxml2_bridge_application_data application_data;
application_data.input_name = "Entity";
application_data.current_total_offset = 0;
application_data.html_no_implied = options & HTML_PARSE_NOIMPLIED;
dom_reset_line_column_cache(&application_data.cache_tokenizer);
lexbor_libxml2_bridge_parse_context ctx;
lexbor_libxml2_bridge_parse_context_init(&ctx);
if (dom_should_register_error_handlers(options)) {
lexbor_libxml2_bridge_parse_set_error_callbacks(
&ctx,
dom_lexbor_libxml2_bridge_tokenizer_error_reporter,
dom_lexbor_libxml2_bridge_tree_error_reporter
);
}
ctx.application_data = &application_data;
size_t tokenizer_error_offset = 0;
size_t tree_error_offset = 0;
/* Setup everything encoding & decoding related */
const lxb_char_t *buf_ref = (const lxb_char_t *) source;
dom_decoding_encoding_ctx decoding_encoding_ctx;
dom_decoding_encoding_ctx_init(&decoding_encoding_ctx);
if (override_encoding != NULL) {
const lxb_encoding_data_t *encoding_data = lxb_encoding_data_by_name(
(const lxb_char_t *) override_encoding,
override_encoding_len
);
if (!encoding_data) {
zend_argument_value_error(3, "must be a valid document encoding");
RETURN_THROWS();
}
dom_setup_parser_encoding_manually(buf_ref, encoding_data, &decoding_encoding_ctx, &application_data);
} else {
dom_setup_parser_encoding_implicitly(&buf_ref, &source_len, &decoding_encoding_ctx, &application_data);
}
lxb_html_document_t *document = lxb_html_document_create();
if (UNEXPECTED(document == NULL)) {
goto fail_oom;
}
lxb_status_t lexbor_status = lxb_html_document_parse_chunk_begin(document);
if (UNEXPECTED(lexbor_status != LXB_STATUS_OK)) {
goto fail_oom;
}
lxb_html_parser_t *parser = document->dom_document.parser;
while (source_len > 0) {
size_t chunk_size = source_len;
const size_t MAX_CHUNK_SIZE = sizeof(decoding_encoding_ctx.encoding_output) / sizeof(*decoding_encoding_ctx.encoding_output);
if (chunk_size > MAX_CHUNK_SIZE) {
chunk_size = MAX_CHUNK_SIZE;
}
source_len -= chunk_size;
const lxb_char_t *buf_end = buf_ref + chunk_size;
bool result = dom_parse_decode_encode_step(
&ctx,
document,
parser,
&buf_ref,
buf_end,
&decoding_encoding_ctx,
&tokenizer_error_offset,
&tree_error_offset
);
if (!result) {
goto fail_oom;
}
/* In the string case we have a single buffer that acts as a sliding window.
* The `current_input_characters` field starts pointing at the start of the buffer, but needs to slide along the
* sliding window as well. */
if (application_data.current_input_characters) {
application_data.current_input_characters += chunk_size;
}
}
if (!dom_parse_decode_encode_finish(&ctx, document, parser, &decoding_encoding_ctx, &tokenizer_error_offset, &tree_error_offset)) {
goto fail_oom;
}
lexbor_status = lxb_html_document_parse_chunk_end(document);
if (lexbor_status != LXB_STATUS_OK) {
goto fail_oom;
}
php_dom_private_data *private_data = php_dom_private_data_create();
xmlDocPtr lxml_doc;
lexbor_libxml2_bridge_status bridge_status = lexbor_libxml2_bridge_convert_document(
document,
&lxml_doc,
options & XML_PARSE_COMPACT,
!(options & DOM_HTML_NO_DEFAULT_NS),
private_data
);
lexbor_libxml2_bridge_copy_observations(parser->tree, &ctx.observations);
if (UNEXPECTED(bridge_status != LEXBOR_LIBXML2_BRIDGE_STATUS_OK)) {
php_dom_private_data_destroy(private_data);
php_libxml_ctx_error(
NULL,
"%s in %s",
dom_lexbor_libxml2_bridge_status_code_to_string(bridge_status),
application_data.input_name
);
lxb_html_document_destroy(document);
RETURN_FALSE;
}
lxb_html_document_destroy(document);
dom_post_process_html5_loading(lxml_doc, options, &ctx.observations);
if (decoding_encoding_ctx.decode_data) {
lxml_doc->encoding = xmlStrdup((const xmlChar *) decoding_encoding_ctx.decode_data->name);
} else {
lxml_doc->encoding = xmlStrdup((const xmlChar *) "UTF-8");
}
dom_object *intern = php_dom_instantiate_object_helper(
return_value,
dom_html_document_class_entry,
(xmlNodePtr) lxml_doc,
NULL
);
dom_set_xml_class(intern->document);
intern->document->quirks_mode = ctx.observations.quirks_mode;
intern->document->private_data = php_dom_libxml_private_data_header(private_data);
return;
fail_oom:
lxb_html_document_destroy(document);
php_dom_throw_error(INVALID_STATE_ERR, true);
RETURN_THROWS();
}
PHP_METHOD(Dom_HTMLDocument, createFromFile)
{
const char *filename, *override_encoding = NULL;
php_dom_private_data *private_data = NULL;
size_t filename_len, override_encoding_len;
zend_long options = 0;
php_stream *stream = NULL;
if (zend_parse_parameters(
ZEND_NUM_ARGS(),
"p|lp!",
&filename,
&filename_len,
&options,
&override_encoding,
&override_encoding_len
) == FAILURE) {
RETURN_THROWS();
}
/* See php_libxml_streams_IO_open_wrapper(), apparently this caused issues in the past. */
if (strstr(filename, "%00")) {
zend_argument_value_error(1, "must not contain percent-encoded NUL bytes");
RETURN_THROWS();
}
if (!check_options_validity(2, options)) {
RETURN_THROWS();
}
dom_lexbor_libxml2_bridge_application_data application_data;
application_data.input_name = filename;
application_data.current_total_offset = 0;
application_data.html_no_implied = options & HTML_PARSE_NOIMPLIED;
dom_reset_line_column_cache(&application_data.cache_tokenizer);
lexbor_libxml2_bridge_parse_context ctx;
lexbor_libxml2_bridge_parse_context_init(&ctx);
if (dom_should_register_error_handlers(options)) {
lexbor_libxml2_bridge_parse_set_error_callbacks(
&ctx,
dom_lexbor_libxml2_bridge_tokenizer_error_reporter,
dom_lexbor_libxml2_bridge_tree_error_reporter
);
}
ctx.application_data = &application_data;
char buf[4096];
/* Setup everything encoding & decoding related */
dom_decoding_encoding_ctx decoding_encoding_ctx;
dom_decoding_encoding_ctx_init(&decoding_encoding_ctx);
bool should_determine_encoding_implicitly = true; /* First read => determine encoding implicitly */
if (override_encoding != NULL) {
const lxb_encoding_data_t *encoding_data = lxb_encoding_data_by_name(
(const lxb_char_t *) override_encoding,
override_encoding_len
);
if (!encoding_data) {
zend_argument_value_error(3, "must be a valid document encoding");
RETURN_THROWS();
}
should_determine_encoding_implicitly = false;
dom_setup_parser_encoding_manually((const lxb_char_t *) buf, encoding_data, &decoding_encoding_ctx, &application_data);
}
zend_string *opened_path = NULL;
stream = php_stream_open_wrapper_ex(filename, "rb", REPORT_ERRORS, &opened_path, php_libxml_get_stream_context());
if (!stream) {
if (!EG(exception)) {
zend_throw_exception_ex(NULL, 0, "Cannot open file '%s'", filename);
}
RETURN_THROWS();
}
/* MIME sniff */
if (should_determine_encoding_implicitly) {
zend_string *charset = php_libxml_sniff_charset_from_stream(stream);
if (charset != NULL) {
const lxb_encoding_data_t *encoding_data = lxb_encoding_data_by_name(
(const lxb_char_t *) ZSTR_VAL(charset),
ZSTR_LEN(charset)
);
if (encoding_data != NULL) {
should_determine_encoding_implicitly = false;
dom_setup_parser_encoding_manually(
(const lxb_char_t *) buf,
encoding_data,
&decoding_encoding_ctx,
&application_data
);
}
zend_string_release_ex(charset, false);
}
}
lxb_html_document_t *document = lxb_html_document_create();
if (UNEXPECTED(document == NULL)) {
goto fail_oom;
}
lxb_status_t lexbor_status = lxb_html_document_parse_chunk_begin(document);
if (UNEXPECTED(lexbor_status != LXB_STATUS_OK)) {
goto fail_oom;
}
size_t tokenizer_error_offset = 0;
size_t tree_error_offset = 0;
ssize_t read;
lxb_html_parser_t *parser = document->dom_document.parser;
while ((read = php_stream_read(stream, buf, sizeof(buf))) > 0) {
const lxb_char_t *buf_ref = (const lxb_char_t *) buf;
if (should_determine_encoding_implicitly) {
should_determine_encoding_implicitly = false;
dom_setup_parser_encoding_implicitly(&buf_ref, (size_t *) &read, &decoding_encoding_ctx, &application_data);
}
const lxb_char_t *buf_end = buf_ref + read;
bool result = dom_parse_decode_encode_step(
&ctx,
document,
parser,
&buf_ref,
buf_end,
&decoding_encoding_ctx,
&tokenizer_error_offset,
&tree_error_offset
);
if (!result) {
goto fail_oom;
}
}
if (!dom_parse_decode_encode_finish(&ctx, document, parser, &decoding_encoding_ctx, &tokenizer_error_offset, &tree_error_offset)) {
goto fail_oom;
}
lexbor_status = lxb_html_document_parse_chunk_end(document);
if (lexbor_status != LXB_STATUS_OK) {
goto fail_oom;
}
private_data = php_dom_private_data_create();
xmlDocPtr lxml_doc;
lexbor_libxml2_bridge_status bridge_status = lexbor_libxml2_bridge_convert_document(
document,
&lxml_doc,
options & XML_PARSE_COMPACT,
!(options & DOM_HTML_NO_DEFAULT_NS),
private_data
);
lexbor_libxml2_bridge_copy_observations(parser->tree, &ctx.observations);
if (UNEXPECTED(bridge_status != LEXBOR_LIBXML2_BRIDGE_STATUS_OK)) {
php_libxml_ctx_error(NULL, "%s in %s", dom_lexbor_libxml2_bridge_status_code_to_string(bridge_status), filename);
RETVAL_FALSE;
goto fail_general;
}
lxb_html_document_destroy(document);
dom_post_process_html5_loading(lxml_doc, options, &ctx.observations);
if (decoding_encoding_ctx.decode_data) {
lxml_doc->encoding = xmlStrdup((const xmlChar *) decoding_encoding_ctx.decode_data->name);
} else {
lxml_doc->encoding = xmlStrdup((const xmlChar *) "UTF-8");
}
if (stream->wrapper == &php_plain_files_wrapper && opened_path != NULL) {
xmlChar *converted = xmlPathToURI((const xmlChar *) ZSTR_VAL(opened_path));
if (UNEXPECTED(!converted)) {
goto fail_oom;
}
/* Check for "file:/" instead of "file://" because of libxml2 quirk */
if (strncmp((const char *) converted, "file:/", sizeof("file:/") - 1) != 0) {
xmlChar *buffer = xmlStrdup((const xmlChar *) "file://");
if (UNEXPECTED(!buffer)) {
xmlFree(converted);
goto fail_oom;
}
xmlChar *new_buffer = xmlStrcat(buffer, converted);
if (UNEXPECTED(!new_buffer)) {
xmlFree(buffer);
xmlFree(converted);
goto fail_oom;
}
xmlFree(converted);
lxml_doc->URL = new_buffer;
} else {
#ifdef PHP_WIN32
converted = php_dom_libxml_fix_file_path(converted);
#endif
lxml_doc->URL = converted;
}
} else {
lxml_doc->URL = xmlStrdup((const xmlChar *) filename);
}
if (opened_path != NULL) {
zend_string_release_ex(opened_path, false);
}
php_stream_close(stream);
stream = NULL;
dom_object *intern = php_dom_instantiate_object_helper(
return_value,
dom_html_document_class_entry,
(xmlNodePtr) lxml_doc,
NULL
);
dom_set_xml_class(intern->document);
intern->document->quirks_mode = ctx.observations.quirks_mode;
intern->document->private_data = php_dom_libxml_private_data_header(private_data);
return;
fail_oom:
php_dom_throw_error(INVALID_STATE_ERR, true);
fail_general:
if (private_data != NULL) {
php_dom_private_data_destroy(private_data);
}
lxb_html_document_destroy(document);
php_stream_close(stream);
if (opened_path != NULL) {
zend_string_release_ex(opened_path, false);
}
}
static zend_result dom_write_output_smart_str(void *ctx, const char *buf, size_t size)
{
smart_str_appendl((smart_str *) ctx, buf, size);
return SUCCESS;
}
static zend_result dom_write_output_stream(void *application_data, const char *buf, size_t len)
{
php_stream *stream = (php_stream *) application_data;
if (UNEXPECTED(php_stream_write(stream, buf, len) < 0)) {
return FAILURE;
}
return SUCCESS;
}
/* Fast path when the output encoding is UTF-8 */
static zend_result dom_saveHTML_write_string_len_utf8_output(void *application_data, const char *buf, size_t len)
{
dom_output_ctx *output = (dom_output_ctx *) application_data;
output->decode->status = LXB_STATUS_OK;
const lxb_char_t *buf_ref = (const lxb_char_t *) buf;
const lxb_char_t *last_output = buf_ref;
const lxb_char_t *buf_end = buf_ref + len;
while (buf_ref != buf_end) {
const lxb_char_t *buf_ref_backup = buf_ref;
lxb_codepoint_t codepoint = lxb_encoding_decode_utf_8_single(output->decode, &buf_ref, buf_end);
if (UNEXPECTED(codepoint > LXB_ENCODING_MAX_CODEPOINT)) {
if (UNEXPECTED(output->write_output(
output->output_data,
(const char *) last_output,
buf_ref_backup - last_output
) != SUCCESS)) {
return FAILURE;
}
if (codepoint == LXB_ENCODING_DECODE_CONTINUE) {
ZEND_ASSERT(buf_ref == buf_end);
/* The decoder needs more data but the entire buffer is consumed.
* All valid data is outputted, and if the remaining data for the code point
* is invalid, the next call will output the replacement bytes. */
output->decode->status = LXB_STATUS_CONTINUE;
return SUCCESS;
}
if (UNEXPECTED(output->write_output(
output->output_data,
(const char *) LXB_ENCODING_REPLACEMENT_BYTES,
LXB_ENCODING_REPLACEMENT_SIZE
) != SUCCESS)) {
return FAILURE;
}
last_output = buf_ref;
}
}
if (buf_ref != last_output) {
if (UNEXPECTED(output->write_output(
output->output_data,
(const char *) last_output,
buf_ref - last_output
) != SUCCESS)) {
return FAILURE;
}
}
return SUCCESS;
}
static zend_result dom_saveHTML_write_string_utf8_output(void *application_data, const char *buf)
{
return dom_saveHTML_write_string_len_utf8_output(application_data, buf, strlen(buf));
}
static zend_result dom_saveHTML_write_string_len(void *application_data, const char *buf, size_t len)
{
dom_output_ctx *output = (dom_output_ctx *) application_data;
lxb_status_t decode_status, encode_status;
const lxb_char_t *buf_ref = (const lxb_char_t *) buf;
const lxb_char_t *buf_end = buf_ref + len;
do {
decode_status = lxb_encoding_decode_utf_8(output->decode, &buf_ref, buf_end);
const lxb_codepoint_t *codepoints_ref = output->codepoints;
const lxb_codepoint_t *codepoints_end = codepoints_ref + lxb_encoding_decode_buf_used(output->decode);
do {
encode_status = output->encoding_data->encode(output->encode, &codepoints_ref, codepoints_end);
if (UNEXPECTED(output->write_output(
output->output_data,
(const char *) output->encoding_output,
lxb_encoding_encode_buf_used(output->encode)
) != SUCCESS)) {
return FAILURE;
}
lxb_encoding_encode_buf_used_set(output->encode, 0);
} while (encode_status == LXB_STATUS_SMALL_BUFFER);
lxb_encoding_decode_buf_used_set(output->decode, 0);
} while (decode_status == LXB_STATUS_SMALL_BUFFER);
return SUCCESS;
}
static zend_result dom_saveHTML_write_string(void *application_data, const char *buf)
{
return dom_saveHTML_write_string_len(application_data, buf, strlen(buf));
}
static zend_result dom_common_save(dom_output_ctx *output_ctx, dom_object *intern, const xmlDoc *docp, const xmlNode *node)
{
/* Initialize everything related to encoding & decoding */
const lxb_encoding_data_t *decoding_data = lxb_encoding_data(LXB_ENCODING_UTF_8);
const lxb_encoding_data_t *encoding_data = lxb_encoding_data_by_name(
(const lxb_char_t *) docp->encoding,
strlen((const char *) docp->encoding)
);
lxb_encoding_encode_t encode;
lxb_encoding_decode_t decode;
lxb_char_t encoding_output[4096];
lxb_codepoint_t codepoints[4096];
(void) lxb_encoding_encode_init(&encode, encoding_data, encoding_output, sizeof(encoding_output) / sizeof(*encoding_output));
(void) lxb_encoding_decode_init(&decode, decoding_data, codepoints, sizeof(codepoints) / sizeof(*codepoints));
if (encoding_data->encoding == LXB_ENCODING_UTF_8) {
lxb_encoding_encode_replace_set(&encode, LXB_ENCODING_REPLACEMENT_BYTES, LXB_ENCODING_REPLACEMENT_SIZE);
} else {
/* Fallback if there is no replacement by default */
lxb_encoding_encode_replace_set(&encode, (const lxb_char_t *) "?", 1);
}
lxb_encoding_decode_replace_set(&decode, LXB_ENCODING_REPLACEMENT_BUFFER, LXB_ENCODING_REPLACEMENT_BUFFER_LEN);
output_ctx->encoding_data = encoding_data;
output_ctx->decoding_data = decoding_data;
output_ctx->encode = &encode;
output_ctx->decode = &decode;
output_ctx->codepoints = codepoints;
output_ctx->encoding_output = encoding_output;
dom_html5_serialize_context ctx;
if (encoding_data->encoding == LXB_ENCODING_UTF_8) {
/* Fast path */
ctx.write_string_len = dom_saveHTML_write_string_len_utf8_output;
ctx.write_string = dom_saveHTML_write_string_utf8_output;
} else {
/* Slow path */
ctx.write_string_len = dom_saveHTML_write_string_len;
ctx.write_string = dom_saveHTML_write_string;
}
ctx.application_data = output_ctx;
ctx.private_data = php_dom_get_private_data(intern);
if (UNEXPECTED(dom_html5_serialize_outer(&ctx, node) != SUCCESS)) {
return FAILURE;
}
(void) lxb_encoding_decode_finish(&decode);
if (lxb_encoding_decode_buf_used(&decode)) {
const lxb_codepoint_t *codepoints_ref = (const lxb_codepoint_t *) codepoints;
(void) encoding_data->encode(&encode, &codepoints_ref, codepoints_ref + lxb_encoding_decode_buf_used(&decode));
if (UNEXPECTED(output_ctx->write_output(
output_ctx->output_data,
(const char *) encoding_output,
lxb_encoding_encode_buf_used(&encode)) != SUCCESS
)) {
return FAILURE;
}
}
(void) lxb_encoding_encode_finish(&encode);
if (lxb_encoding_encode_buf_used(&encode)) {
if (UNEXPECTED(output_ctx->write_output(
output_ctx->output_data,
(const char *) encoding_output,
lxb_encoding_encode_buf_used(&encode)) != SUCCESS
)) {
return FAILURE;
}
}
return SUCCESS;
}
PHP_METHOD(Dom_HTMLDocument, saveHtmlFile)
{
zval *id;
xmlDoc *docp;
size_t file_len;
dom_object *intern;
char *file;
id = ZEND_THIS;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "p", &file, &file_len) == FAILURE) {
RETURN_THROWS();
}
if (file_len == 0) {
zend_argument_must_not_be_empty_error(1);
RETURN_THROWS();
}
php_stream *stream = php_stream_open_wrapper_ex(file, "wb", REPORT_ERRORS, /* opened_path */ NULL, php_libxml_get_stream_context());
if (!stream) {
RETURN_FALSE;
}
DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
dom_output_ctx output_ctx;
output_ctx.output_data = stream;
output_ctx.write_output = dom_write_output_stream;
if (UNEXPECTED(dom_common_save(&output_ctx, intern, docp, (const xmlNode *) docp) != SUCCESS)) {
php_stream_close(stream);
RETURN_FALSE;
}
zend_long bytes = php_stream_tell(stream);
php_stream_close(stream);
RETURN_LONG(bytes);
}
PHP_METHOD(Dom_HTMLDocument, saveHtml)
{
zval *nodep = NULL;
const xmlDoc *docp;
const xmlNode *node;
dom_object *intern, *nodeobj;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|O!", &nodep, dom_modern_node_class_entry) == FAILURE) {
RETURN_THROWS();
}
DOM_GET_OBJ(docp, ZEND_THIS, xmlDocPtr, intern);
if (nodep != NULL) {
DOM_GET_OBJ(node, nodep, xmlNodePtr, nodeobj);
if (node->doc != docp) {
php_dom_throw_error(WRONG_DOCUMENT_ERR, true);
RETURN_THROWS();
}
} else {
node = (const xmlNode *) docp;
}
smart_str buf = {0};
dom_output_ctx output_ctx;
output_ctx.output_data = &buf;
output_ctx.write_output = dom_write_output_smart_str;
/* Can't fail because dom_write_output_smart_str() can't fail. */
zend_result result = dom_common_save(&output_ctx, intern, docp, node);
ZEND_ASSERT(result == SUCCESS);
RETURN_STR(smart_str_extract(&buf));
}
zend_result dom_html_document_encoding_write(dom_object *obj, zval *newval)
{
DOM_PROP_NODE(xmlDocPtr, docp, obj);
/* Typed property, can only be IS_STRING. */
ZEND_ASSERT(Z_TYPE_P(newval) == IS_STRING);
zend_string *str = Z_STR_P(newval);
const lxb_encoding_data_t *encoding_data = lxb_encoding_data_by_name((const lxb_char_t *) ZSTR_VAL(str), ZSTR_LEN(str));
if (encoding_data != NULL) {
xmlFree(BAD_CAST docp->encoding);
docp->encoding = xmlStrdup((const xmlChar *) encoding_data->name);
} else {
zend_value_error("Invalid document encoding");
return FAILURE;
}
return SUCCESS;
}
static xmlNodePtr dom_html_document_element_read_raw(const xmlDoc *docp, bool (*accept)(const xmlChar *))
{
const xmlNode *root = xmlDocGetRootElement(docp);
if (root == NULL || !(php_dom_ns_is_fast(root, php_dom_ns_is_html_magic_token) && xmlStrEqual(root->name, BAD_CAST "html"))) {
return NULL;
}
xmlNodePtr cur = root->children;
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE && php_dom_ns_is_fast(cur, php_dom_ns_is_html_magic_token) && accept(cur->name)) {
return cur;
}
cur = cur->next;
}
return NULL;
}
zend_result dom_html_document_element_read_helper(dom_object *obj, zval *retval, bool (*accept)(const xmlChar *))
{
DOM_PROP_NODE(const xmlDoc *, docp, obj);
const xmlNode *element = dom_html_document_element_read_raw(docp, accept);
php_dom_create_nullable_object((xmlNodePtr) element, retval, obj);
return SUCCESS;
}
static bool dom_accept_body_name(const xmlChar *name)
{
return xmlStrEqual(name, BAD_CAST "body") || xmlStrEqual(name, BAD_CAST "frameset");
}
static bool dom_accept_head_name(const xmlChar *name)
{
return xmlStrEqual(name, BAD_CAST "head");
}
/* https://html.spec.whatwg.org/#dom-document-body */
zend_result dom_html_document_body_read(dom_object *obj, zval *retval)
{
return dom_html_document_element_read_helper(obj, retval, dom_accept_body_name);
}
/* https://html.spec.whatwg.org/#dom-document-head */
zend_result dom_html_document_head_read(dom_object *obj, zval *retval)
{
return dom_html_document_element_read_helper(obj, retval, dom_accept_head_name);
}
/* https://html.spec.whatwg.org/#dom-document-body */
zend_result dom_html_document_body_write(dom_object *obj, zval *newval)
{
DOM_PROP_NODE(xmlDocPtr, docp, obj);
/* 1. If the new value is not a body or frameset element, then throw a "HierarchyRequestError" DOMException. */
if (Z_TYPE_P(newval) != IS_NULL) {
dom_object *newval_intern = Z_DOMOBJ_P(newval);
if (newval_intern->ptr != NULL) {
xmlNodePtr newval_node = ((php_libxml_node_ptr *) newval_intern->ptr)->node;
/* Note: because this property has type HTMLElement, we know the namespace is correct. */
if (dom_accept_body_name(newval_node->name)) {
/* 2. If the new value is the same as the body element, return. */
const xmlNode *current_body_element = dom_html_document_element_read_raw(docp, dom_accept_body_name);
if (current_body_element == newval_node) {
return SUCCESS;
}
/* 3. If the body element is not null, then replace the body element with the new value within the body element's parent and return. */
if (current_body_element != NULL) {
php_dom_adopt_node(newval_node, obj, docp);
xmlNodePtr old = xmlReplaceNode((xmlNodePtr) current_body_element, newval_node);
if (old != NULL && old->_private == NULL) {
php_libxml_node_free_resource(old);
}
return SUCCESS;
}
/* 4. If there is no document element, throw a "HierarchyRequestError" DOMException. */
xmlNodePtr root = xmlDocGetRootElement(docp);
if (root == NULL) {
php_dom_throw_error_with_message(HIERARCHY_REQUEST_ERR, "A body can only be set if there is a document element", true);
return FAILURE;
}
/* 5. Append the new value to the document element. */
php_dom_adopt_node(newval_node, obj, docp);
xmlAddChild(root, newval_node);
return SUCCESS;
}
}
}
php_dom_throw_error_with_message(HIERARCHY_REQUEST_ERR, "The new body must either be a body or a frameset tag", true);
return FAILURE;
}
/* https://dom.spec.whatwg.org/#concept-child-text-content */
static zend_string *dom_get_child_text_content(const xmlNode *node)
{
smart_str content = {0};
const xmlNode *text = node->children;
while (text != NULL) {
if ((text->type == XML_TEXT_NODE || text->type == XML_CDATA_SECTION_NODE) && text->content != NULL) {
smart_str_appends(&content, (const char *) text->content);
}
text = text->next;
}
return smart_str_extract(&content);
}
/* https://html.spec.whatwg.org/#the-title-element-2 */
static xmlNodePtr dom_get_title_element(const xmlDoc *doc)
{
xmlNodePtr node = doc->children;
while (node != NULL) {
if (node->type == XML_ELEMENT_NODE) {
if (php_dom_ns_is_fast(node, php_dom_ns_is_html_magic_token) && xmlStrEqual(node->name, BAD_CAST "title")) {
break;
}
}
node = php_dom_next_in_tree_order(node, NULL);
}
return node;
}
/* The subtle difference is that this is about the direct title descendant of the svg element,
* whereas the html variant of this function is about the first in-tree title element. */
static xmlNodePtr dom_get_svg_title_element(xmlNodePtr svg)
{
xmlNodePtr cur = svg->children;
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE
&& php_dom_ns_is_fast(cur, php_dom_ns_is_svg_magic_token) && xmlStrEqual(cur->name, BAD_CAST "title")) {
break;
}
cur = cur->next;
}
return cur;
}
/* https://html.spec.whatwg.org/#document.title */
zend_result dom_html_document_title_read(dom_object *obj, zval *retval)
{
DOM_PROP_NODE(const xmlDoc *, docp, obj);
xmlNodePtr root = xmlDocGetRootElement(docp);
if (root == NULL) {
ZVAL_EMPTY_STRING(retval);
return SUCCESS;
}
zend_string *value = zend_empty_string;
/* 1. If the document element is an SVG svg element,
* then let value be the child text content of the first SVG title element that is a child of the document element. */
if (php_dom_ns_is_fast(root, php_dom_ns_is_svg_magic_token) && xmlStrEqual(root->name, BAD_CAST "svg")) {
const xmlNode *title = dom_get_svg_title_element(root);
if (title != NULL) {
value = dom_get_child_text_content(title);
}
} else {
/* 2. Otherwise, let value be the child text content of the title element,
* or the empty string if the title element is null. */
const xmlNode *title = dom_get_title_element(docp);
if (title != NULL) {
value = dom_get_child_text_content(title);
}
}
/* 3. Strip and collapse ASCII whitespace in value. */
value = dom_strip_and_collapse_ascii_whitespace(value);
/* 4. Return value. */
ZVAL_STR(retval, value);
return SUCCESS;
}
static void dom_string_replace_all(xmlDocPtr docp, xmlNodePtr element, zval *zv)
{
dom_remove_all_children(element);
xmlNode *text = xmlNewDocText(docp, BAD_CAST Z_STRVAL_P(zv));
xmlAddChild(element, text);
}
/* https://html.spec.whatwg.org/#document.title */
zend_result dom_html_document_title_write(dom_object *obj, zval *newval)
{
DOM_PROP_NODE(xmlDocPtr, docp, obj);
xmlNodePtr root = xmlDocGetRootElement(docp);
if (root == NULL) {
return SUCCESS;
}
/* If the document element is an SVG svg element */
if (php_dom_ns_is_fast(root, php_dom_ns_is_svg_magic_token) && xmlStrEqual(root->name, BAD_CAST "svg")) {
/* 1. If there is an SVG title element that is a child of the document element, let element be the first such element. */
xmlNodePtr element = dom_get_svg_title_element(root);
/* 2. Otherwise: */
if (element == NULL) {
/* 2.1. Let element be the result of creating an element given the document element's node document,
* title, and the SVG namespace. */
/* Annoyingly, we must create it in the svg namespace _without_ prefix... */
xmlNsPtr ns = root->ns;
if (ns->prefix != NULL) {
/* Slow path... */
php_dom_libxml_ns_mapper *ns_mapper = php_dom_get_ns_mapper(obj);
zend_string *href = ZSTR_INIT_LITERAL(DOM_SVG_NS_URI, false);
ns = php_dom_libxml_ns_mapper_get_ns(ns_mapper, zend_empty_string, href);
zend_string_release_ex(href, false);
}
element = xmlNewDocNode(docp, ns, BAD_CAST "title", NULL);
if (UNEXPECTED(element == NULL)) {
php_dom_throw_error(INVALID_STATE_ERR, true);
return FAILURE;
}
/* 2.2. Insert element as the first child of the document element. */
if (root->children == NULL) {
root->last = element;
} else {
element->next = root->children;
root->children->prev = element;
}
root->children = element;
element->parent = root;
}
/* 3. String replace all with the given value within element. */
dom_string_replace_all(docp, element, newval);
}
/* If the document element is in the HTML namespace */
else if (php_dom_ns_is_fast(root, php_dom_ns_is_html_magic_token)) {
/* 1. If the title element is null and the head element is null, then return. */
xmlNodePtr title = dom_get_title_element(docp);
xmlNodePtr head = dom_html_document_element_read_raw(docp, dom_accept_head_name);
if (title == NULL && head == NULL) {
return SUCCESS;
}
/* 2. If the title element is non-null, let element be the title element. */
xmlNodePtr element = title;
/* 3. Otherwise: */
if (element == NULL) {
/* 3.1. Let element be the result of creating an element given the document element's node document, title,
* and the HTML namespace. */
php_dom_libxml_ns_mapper *ns_mapper = php_dom_get_ns_mapper(obj);
element = xmlNewDocNode(docp, php_dom_libxml_ns_mapper_ensure_html_ns(ns_mapper), BAD_CAST "title", NULL);
if (UNEXPECTED(element == NULL)) {
php_dom_throw_error(INVALID_STATE_ERR, true);
return FAILURE;
}
/* 3.2. Append element to the head element. */
xmlAddChild(head, element);
}
/* 4. String replace all with the given value within element. */
dom_string_replace_all(docp, element, newval);
}
return SUCCESS;
}
#if ZEND_DEBUG
PHP_METHOD(Dom_HTMLDocument, debugGetTemplateCount)
{
xmlDocPtr doc;
dom_object *intern;
ZEND_PARSE_PARAMETERS_NONE();
DOM_GET_OBJ(doc, ZEND_THIS, xmlDocPtr, intern);
ZEND_IGNORE_VALUE(doc);
RETURN_LONG((zend_long) php_dom_get_template_count((const php_dom_private_data *) intern->document->private_data));
}
#endif
#endif /* HAVE_LIBXML && HAVE_DOM */