xref: /PHP-8.3/ext/dom/php_dom.c (revision 9cb23a3d)
1 /*
2    +----------------------------------------------------------------------+
3    | Copyright (c) The PHP Group                                          |
4    +----------------------------------------------------------------------+
5    | This source file is subject to version 3.01 of the PHP license,      |
6    | that is bundled with this package in the file LICENSE, and is        |
7    | available through the world-wide-web at the following url:           |
8    | https://www.php.net/license/3_01.txt                                 |
9    | If you did not receive a copy of the PHP license and are unable to   |
10    | obtain it through the world-wide-web, please send a note to          |
11    | license@php.net so we can mail you a copy immediately.               |
12    +----------------------------------------------------------------------+
13    | Authors: Christian Stocker <chregu@php.net>                          |
14    |          Rob Richards <rrichards@php.net>                            |
15    |          Marcus Borger <helly@php.net>                               |
16    +----------------------------------------------------------------------+
17 */
18 
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22 
23 #include "php.h"
24 #if defined(HAVE_LIBXML) && defined(HAVE_DOM)
25 #include "ext/random/php_random.h"
26 #include "php_dom.h"
27 #include "php_dom_arginfo.h"
28 #include "dom_properties.h"
29 #include "zend_interfaces.h"
30 
31 #include "ext/standard/info.h"
32 #define PHP_XPATH 1
33 #define PHP_XPTR 2
34 
35 /* {{{ class entries */
36 PHP_DOM_EXPORT zend_class_entry *dom_node_class_entry;
37 PHP_DOM_EXPORT zend_class_entry *dom_domexception_class_entry;
38 PHP_DOM_EXPORT zend_class_entry *dom_parentnode_class_entry;
39 PHP_DOM_EXPORT zend_class_entry *dom_childnode_class_entry;
40 PHP_DOM_EXPORT zend_class_entry *dom_domimplementation_class_entry;
41 PHP_DOM_EXPORT zend_class_entry *dom_documentfragment_class_entry;
42 PHP_DOM_EXPORT zend_class_entry *dom_document_class_entry;
43 PHP_DOM_EXPORT zend_class_entry *dom_nodelist_class_entry;
44 PHP_DOM_EXPORT zend_class_entry *dom_namednodemap_class_entry;
45 PHP_DOM_EXPORT zend_class_entry *dom_characterdata_class_entry;
46 PHP_DOM_EXPORT zend_class_entry *dom_attr_class_entry;
47 PHP_DOM_EXPORT zend_class_entry *dom_element_class_entry;
48 PHP_DOM_EXPORT zend_class_entry *dom_text_class_entry;
49 PHP_DOM_EXPORT zend_class_entry *dom_comment_class_entry;
50 PHP_DOM_EXPORT zend_class_entry *dom_cdatasection_class_entry;
51 PHP_DOM_EXPORT zend_class_entry *dom_documenttype_class_entry;
52 PHP_DOM_EXPORT zend_class_entry *dom_notation_class_entry;
53 PHP_DOM_EXPORT zend_class_entry *dom_entity_class_entry;
54 PHP_DOM_EXPORT zend_class_entry *dom_entityreference_class_entry;
55 PHP_DOM_EXPORT zend_class_entry *dom_processinginstruction_class_entry;
56 #ifdef LIBXML_XPATH_ENABLED
57 PHP_DOM_EXPORT zend_class_entry *dom_xpath_class_entry;
58 #endif
59 PHP_DOM_EXPORT zend_class_entry *dom_namespace_node_class_entry;
60 /* }}} */
61 
62 zend_object_handlers dom_object_handlers;
63 zend_object_handlers dom_nnodemap_object_handlers;
64 zend_object_handlers dom_nodelist_object_handlers;
65 zend_object_handlers dom_object_namespace_node_handlers;
66 #ifdef LIBXML_XPATH_ENABLED
67 zend_object_handlers dom_xpath_object_handlers;
68 #endif
69 
70 static HashTable classes;
71 /* {{{ prop handler tables */
72 static HashTable dom_document_prop_handlers;
73 static HashTable dom_documentfragment_prop_handlers;
74 static HashTable dom_node_prop_handlers;
75 static HashTable dom_entity_reference_prop_handlers;
76 static HashTable dom_nodelist_prop_handlers;
77 static HashTable dom_namednodemap_prop_handlers;
78 static HashTable dom_characterdata_prop_handlers;
79 static HashTable dom_attr_prop_handlers;
80 static HashTable dom_element_prop_handlers;
81 static HashTable dom_text_prop_handlers;
82 static HashTable dom_documenttype_prop_handlers;
83 static HashTable dom_notation_prop_handlers;
84 static HashTable dom_entity_prop_handlers;
85 static HashTable dom_processinginstruction_prop_handlers;
86 static HashTable dom_namespace_node_prop_handlers;
87 #ifdef LIBXML_XPATH_ENABLED
88 static HashTable dom_xpath_prop_handlers;
89 #endif
90 /* }}} */
91 
92 static zend_object *dom_objects_namespace_node_new(zend_class_entry *class_type);
93 static void dom_object_namespace_node_free_storage(zend_object *object);
94 static xmlNodePtr php_dom_create_fake_namespace_decl_node_ptr(xmlNodePtr nodep, xmlNsPtr original);
95 
96 typedef int (*dom_read_t)(dom_object *obj, zval *retval);
97 typedef int (*dom_write_t)(dom_object *obj, zval *newval);
98 
99 typedef struct _dom_prop_handler {
100 	dom_read_t read_func;
101 	dom_write_t write_func;
102 } dom_prop_handler;
103 
dom_get_obj_handlers(void)104 static zend_object_handlers* dom_get_obj_handlers(void) {
105 	return &dom_object_handlers;
106 }
107 
108 /* {{{ int dom_node_is_read_only(xmlNodePtr node) */
dom_node_is_read_only(xmlNodePtr node)109 int dom_node_is_read_only(xmlNodePtr node) {
110 	switch (node->type) {
111 		case XML_ENTITY_REF_NODE:
112 		case XML_ENTITY_NODE:
113 		case XML_DOCUMENT_TYPE_NODE:
114 		case XML_NOTATION_NODE:
115 		case XML_DTD_NODE:
116 		case XML_ELEMENT_DECL:
117 		case XML_ATTRIBUTE_DECL:
118 		case XML_ENTITY_DECL:
119 		case XML_NAMESPACE_DECL:
120 			return SUCCESS;
121 			break;
122 		default:
123 			if (node->doc == NULL) {
124 				return SUCCESS;
125 			} else {
126 				return FAILURE;
127 			}
128 	}
129 }
130 /* }}} end dom_node_is_read_only */
131 
132 /* {{{ int dom_node_children_valid(xmlNodePtr node) */
dom_node_children_valid(xmlNodePtr node)133 int dom_node_children_valid(xmlNodePtr node) {
134 	switch (node->type) {
135 		case XML_DOCUMENT_TYPE_NODE:
136 		case XML_DTD_NODE:
137 		case XML_PI_NODE:
138 		case XML_COMMENT_NODE:
139 		case XML_TEXT_NODE:
140 		case XML_CDATA_SECTION_NODE:
141 		case XML_NOTATION_NODE:
142 			return FAILURE;
143 			break;
144 		default:
145 			return SUCCESS;
146 	}
147 }
148 /* }}} end dom_node_children_valid */
149 
150 static const libxml_doc_props default_doc_props = {
151 	.formatoutput = false,
152 	.validateonparse = false,
153 	.resolveexternals = false,
154 	.preservewhitespace = true,
155 	.substituteentities = false,
156 	.stricterror = true,
157 	.recover = false,
158 	.classmap = NULL,
159 };
160 
161 /* {{{ dom_get_doc_props() */
dom_get_doc_props(php_libxml_ref_obj * document)162 dom_doc_propsptr dom_get_doc_props(php_libxml_ref_obj *document)
163 {
164 	dom_doc_propsptr doc_props;
165 
166 	if (document && document->doc_props) {
167 		return document->doc_props;
168 	} else {
169 		doc_props = emalloc(sizeof(libxml_doc_props));
170 		memcpy(doc_props, &default_doc_props, sizeof(libxml_doc_props));
171 		if (document) {
172 			document->doc_props = doc_props;
173 		}
174 		return doc_props;
175 	}
176 }
177 /* }}} */
178 
dom_get_doc_props_read_only(const php_libxml_ref_obj * document)179 libxml_doc_props const* dom_get_doc_props_read_only(const php_libxml_ref_obj *document)
180 {
181 	if (document && document->doc_props) {
182 		return document->doc_props;
183 	} else {
184 		return &default_doc_props;
185 	}
186 }
187 
dom_copy_doc_props(php_libxml_ref_obj * source_doc,php_libxml_ref_obj * dest_doc)188 static void dom_copy_doc_props(php_libxml_ref_obj *source_doc, php_libxml_ref_obj *dest_doc)
189 {
190 	dom_doc_propsptr dest;
191 
192 	if (source_doc && dest_doc) {
193 
194 		libxml_doc_props const* source = dom_get_doc_props_read_only(source_doc);
195 		dest = dom_get_doc_props(dest_doc);
196 
197 		dest->formatoutput = source->formatoutput;
198 		dest->validateonparse = source->validateonparse;
199 		dest->resolveexternals = source->resolveexternals;
200 		dest->preservewhitespace = source->preservewhitespace;
201 		dest->substituteentities = source->substituteentities;
202 		dest->stricterror = source->stricterror;
203 		dest->recover = source->recover;
204 		if (source->classmap) {
205 			ALLOC_HASHTABLE(dest->classmap);
206 			zend_hash_init(dest->classmap, 0, NULL, NULL, 0);
207 			zend_hash_copy(dest->classmap, source->classmap, NULL);
208 		}
209 
210 	}
211 }
212 
dom_set_doc_classmap(php_libxml_ref_obj * document,zend_class_entry * basece,zend_class_entry * ce)213 void dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece, zend_class_entry *ce)
214 {
215 	dom_doc_propsptr doc_props;
216 
217 	if (document) {
218 		doc_props = dom_get_doc_props(document);
219 		if (doc_props->classmap == NULL) {
220 			if (ce == NULL) {
221 				return;
222 			}
223 			ALLOC_HASHTABLE(doc_props->classmap);
224 			zend_hash_init(doc_props->classmap, 0, NULL, NULL, 0);
225 		}
226 		if (ce) {
227 			zend_hash_update_ptr(doc_props->classmap, basece->name, ce);
228 		} else {
229 			zend_hash_del(doc_props->classmap, basece->name);
230 		}
231 	}
232 }
233 
dom_get_doc_classmap(php_libxml_ref_obj * document,zend_class_entry * basece)234 zend_class_entry *dom_get_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece)
235 {
236 	if (document) {
237 		libxml_doc_props const* doc_props = dom_get_doc_props_read_only(document);
238 		if (doc_props->classmap) {
239 			zend_class_entry *ce = zend_hash_find_ptr(doc_props->classmap, basece->name);
240 			if (ce) {
241 				return ce;
242 			}
243 		}
244 	}
245 
246 	return basece;
247 }
248 /* }}} */
249 
250 /* {{{ dom_get_strict_error() */
dom_get_strict_error(php_libxml_ref_obj * document)251 int dom_get_strict_error(php_libxml_ref_obj *document) {
252 	return dom_get_doc_props_read_only(document)->stricterror;
253 }
254 /* }}} */
255 
256 /* {{{ xmlNodePtr dom_object_get_node(dom_object *obj) */
dom_object_get_node(dom_object * obj)257 PHP_DOM_EXPORT xmlNodePtr dom_object_get_node(dom_object *obj)
258 {
259 	if (obj && obj->ptr != NULL) {
260 		return ((php_libxml_node_ptr *)obj->ptr)->node;
261 	} else {
262 		return NULL;
263 	}
264 }
265 /* }}} end dom_object_get_node */
266 
267 /* {{{ dom_object *php_dom_object_get_data(xmlNodePtr obj) */
php_dom_object_get_data(xmlNodePtr obj)268 PHP_DOM_EXPORT dom_object *php_dom_object_get_data(xmlNodePtr obj)
269 {
270 	if (obj && obj->_private != NULL) {
271 		return (dom_object *) ((php_libxml_node_ptr *) obj->_private)->_private;
272 	} else {
273 		return NULL;
274 	}
275 }
276 /* }}} end php_dom_object_get_data */
277 
dom_register_prop_handler(HashTable * prop_handler,char * name,size_t name_len,dom_read_t read_func,dom_write_t write_func)278 static void dom_register_prop_handler(HashTable *prop_handler, char *name, size_t name_len, dom_read_t read_func, dom_write_t write_func)
279 {
280 	dom_prop_handler hnd;
281 	zend_string *str;
282 
283 	hnd.read_func = read_func;
284 	hnd.write_func = write_func;
285 	str = zend_string_init_interned(name, name_len, 1);
286 	zend_hash_add_mem(prop_handler, str, &hnd, sizeof(dom_prop_handler));
287 	zend_string_release_ex(str, 1);
288 }
289 
dom_override_prop_handler(HashTable * prop_handler,char * name,size_t name_len,dom_read_t read_func,dom_write_t write_func)290 static void dom_override_prop_handler(HashTable *prop_handler, char *name, size_t name_len, dom_read_t read_func, dom_write_t write_func)
291 {
292 	dom_prop_handler hnd;
293 	hnd.read_func = read_func;
294 	hnd.write_func = write_func;
295 	zend_hash_str_update_mem(prop_handler, name, name_len, &hnd, sizeof(dom_prop_handler));
296 }
297 
dom_get_property_ptr_ptr(zend_object * object,zend_string * name,int type,void ** cache_slot)298 static zval *dom_get_property_ptr_ptr(zend_object *object, zend_string *name, int type, void **cache_slot)
299 {
300 	dom_object *obj = php_dom_obj_from_obj(object);
301 
302 	if (!obj->prop_handler || !zend_hash_exists(obj->prop_handler, name)) {
303 		return zend_std_get_property_ptr_ptr(object, name, type, cache_slot);
304 	}
305 
306 	return NULL;
307 }
308 
309 /* {{{ dom_read_property */
dom_read_property(zend_object * object,zend_string * name,int type,void ** cache_slot,zval * rv)310 zval *dom_read_property(zend_object *object, zend_string *name, int type, void **cache_slot, zval *rv)
311 {
312 	dom_object *obj = php_dom_obj_from_obj(object);
313 	zval *retval;
314 	dom_prop_handler *hnd = NULL;
315 
316 	if (obj->prop_handler != NULL) {
317 		hnd = zend_hash_find_ptr(obj->prop_handler, name);
318 	}
319 
320 	if (hnd) {
321 		int ret = hnd->read_func(obj, rv);
322 		if (ret == SUCCESS) {
323 			retval = rv;
324 		} else {
325 			retval = &EG(uninitialized_zval);
326 		}
327 	} else {
328 		retval = zend_std_read_property(object, name, type, cache_slot, rv);
329 	}
330 
331 	return retval;
332 }
333 /* }}} */
334 
dom_write_property(zend_object * object,zend_string * name,zval * value,void ** cache_slot)335 zval *dom_write_property(zend_object *object, zend_string *name, zval *value, void **cache_slot)
336 {
337 	dom_object *obj = php_dom_obj_from_obj(object);
338 	dom_prop_handler *hnd = NULL;
339 
340 	if (obj->prop_handler != NULL) {
341 		hnd = zend_hash_find_ptr(obj->prop_handler, name);
342 	}
343 
344 	if (hnd) {
345 		if (!hnd->write_func) {
346 			zend_throw_error(NULL, "Cannot write read-only property %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name));
347 			return &EG(error_zval);
348 		}
349 
350 		zend_property_info *prop = zend_get_property_info(object->ce, name, /* silent */ true);
351 		if (prop && ZEND_TYPE_IS_SET(prop->type)) {
352 			zval tmp;
353 			ZVAL_COPY(&tmp, value);
354 			if (!zend_verify_property_type(prop, &tmp, ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data)))) {
355 				zval_ptr_dtor(&tmp);
356 				return &EG(error_zval);
357 			}
358 			hnd->write_func(obj, &tmp);
359 			zval_ptr_dtor(&tmp);
360 		} else {
361 			hnd->write_func(obj, value);
362 		}
363 
364 		return value;
365 	}
366 
367 	return zend_std_write_property(object, name, value, cache_slot);
368 }
369 
370 /* {{{ dom_property_exists */
dom_property_exists(zend_object * object,zend_string * name,int check_empty,void ** cache_slot)371 static int dom_property_exists(zend_object *object, zend_string *name, int check_empty, void **cache_slot)
372 {
373 	dom_object *obj = php_dom_obj_from_obj(object);
374 	dom_prop_handler *hnd = NULL;
375 	int retval = 0;
376 
377 	if (obj->prop_handler != NULL) {
378 		hnd = zend_hash_find_ptr(obj->prop_handler, name);
379 	}
380 	if (hnd) {
381 		zval tmp;
382 
383 		if (check_empty == 2) {
384 			retval = 1;
385 		} else if (hnd->read_func(obj, &tmp) == SUCCESS) {
386 			if (check_empty == 1) {
387 				retval = zend_is_true(&tmp);
388 			} else if (check_empty == 0) {
389 				retval = (Z_TYPE(tmp) != IS_NULL);
390 			}
391 			zval_ptr_dtor(&tmp);
392 		}
393 	} else {
394 		retval = zend_std_has_property(object, name, check_empty, cache_slot);
395 	}
396 
397 	return retval;
398 }
399 /* }}} */
400 
dom_get_debug_info_helper(zend_object * object,int * is_temp)401 static HashTable* dom_get_debug_info_helper(zend_object *object, int *is_temp) /* {{{ */
402 {
403 	dom_object			*obj = php_dom_obj_from_obj(object);
404 	HashTable			*debug_info,
405 						*prop_handlers = obj->prop_handler,
406 						*std_props;
407 	zend_string			*string_key;
408 	dom_prop_handler	*entry;
409 	zend_string         *object_str;
410 
411 	*is_temp = 1;
412 
413 	std_props = zend_std_get_properties(object);
414 	debug_info = zend_array_dup(std_props);
415 
416 	if (!prop_handlers) {
417 		return debug_info;
418 	}
419 
420 	object_str = ZSTR_INIT_LITERAL("(object value omitted)", 0);
421 
422 	ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(prop_handlers, string_key, entry) {
423 		zval value;
424 
425 		ZEND_ASSERT(string_key != NULL);
426 
427 		if (entry->read_func(obj, &value) == FAILURE) {
428 			continue;
429 		}
430 
431 		if (Z_TYPE(value) == IS_OBJECT) {
432 			zval_ptr_dtor(&value);
433 			ZVAL_NEW_STR(&value, object_str);
434 			zend_string_addref(object_str);
435 		}
436 
437 		zend_hash_update(debug_info, string_key, &value);
438 	} ZEND_HASH_FOREACH_END();
439 
440 	zend_string_release_ex(object_str, 0);
441 
442 	return debug_info;
443 }
444 /* }}} */
445 
dom_get_debug_info(zend_object * object,int * is_temp)446 static HashTable* dom_get_debug_info(zend_object *object, int *is_temp) /* {{{ */
447 {
448 	return dom_get_debug_info_helper(object, is_temp);
449 }
450 /* }}} */
451 
php_dom_export_node(zval * object)452 void *php_dom_export_node(zval *object) /* {{{ */
453 {
454 	php_libxml_node_object *intern;
455 	xmlNodePtr nodep = NULL;
456 
457 	intern = (php_libxml_node_object *) Z_DOMOBJ_P(object);
458 	if (intern->node) {
459 		nodep = intern->node->node;
460 	}
461 
462 	return nodep;
463 }
464 /* }}} */
465 
466 /* {{{ Get a simplexml_element object from dom to allow for processing */
PHP_FUNCTION(dom_import_simplexml)467 PHP_FUNCTION(dom_import_simplexml)
468 {
469 	zval *node;
470 	xmlNodePtr nodep = NULL;
471 	php_libxml_node_object *nodeobj;
472 	int ret;
473 
474 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &node) == FAILURE) {
475 		RETURN_THROWS();
476 	}
477 
478 	nodeobj = (php_libxml_node_object *) ((char *) Z_OBJ_P(node) - Z_OBJ_HT_P(node)->offset);
479 	nodep = php_libxml_import_node(node);
480 
481 	if (nodep && nodeobj && (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE)) {
482 		DOM_RET_OBJ((xmlNodePtr) nodep, &ret, (dom_object *)nodeobj);
483 	} else {
484 		zend_argument_value_error(1, "is not a valid node type");
485 		RETURN_THROWS();
486 	}
487 }
488 /* }}} */
489 
490 static dom_object* dom_objects_set_class(zend_class_entry *class_type);
491 
dom_update_refcount_after_clone(dom_object * original,xmlNodePtr original_node,dom_object * clone,xmlNodePtr cloned_node)492 static void dom_update_refcount_after_clone(dom_object *original, xmlNodePtr original_node, dom_object *clone, xmlNodePtr cloned_node)
493 {
494 	/* If we cloned a document then we must create new doc proxy */
495 	if (cloned_node->doc == original_node->doc) {
496 		clone->document = original->document;
497 	}
498 	php_libxml_increment_doc_ref((php_libxml_node_object *)clone, cloned_node->doc);
499 	php_libxml_increment_node_ptr((php_libxml_node_object *)clone, cloned_node, (void *)clone);
500 	if (original->document != clone->document) {
501 		dom_copy_doc_props(original->document, clone->document);
502 	}
503 }
504 
dom_objects_store_clone_obj(zend_object * zobject)505 static zend_object *dom_objects_store_clone_obj(zend_object *zobject) /* {{{ */
506 {
507 	dom_object *intern = php_dom_obj_from_obj(zobject);
508 	dom_object *clone = dom_objects_set_class(intern->std.ce);
509 
510 	clone->std.handlers = dom_get_obj_handlers();
511 
512 	if (instanceof_function(intern->std.ce, dom_node_class_entry)) {
513 		xmlNodePtr node = (xmlNodePtr)dom_object_get_node(intern);
514 		if (node != NULL) {
515 			xmlNodePtr cloned_node = xmlDocCopyNode(node, node->doc, 1);
516 			if (cloned_node != NULL) {
517 				dom_update_refcount_after_clone(intern, node, clone, cloned_node);
518 			}
519 
520 		}
521 	}
522 
523 	zend_objects_clone_members(&clone->std, &intern->std);
524 
525 	return &clone->std;
526 }
527 /* }}} */
528 
dom_object_namespace_node_clone_obj(zend_object * zobject)529 static zend_object *dom_object_namespace_node_clone_obj(zend_object *zobject)
530 {
531 	dom_object_namespace_node *intern = php_dom_namespace_node_obj_from_obj(zobject);
532 	zend_object *clone = dom_objects_namespace_node_new(intern->dom.std.ce);
533 	dom_object_namespace_node *clone_intern = php_dom_namespace_node_obj_from_obj(clone);
534 
535 	xmlNodePtr original_node = dom_object_get_node(&intern->dom);
536 	ZEND_ASSERT(original_node->type == XML_NAMESPACE_DECL);
537 	xmlNodePtr cloned_node = php_dom_create_fake_namespace_decl_node_ptr(original_node->parent, original_node->ns);
538 
539 	if (intern->parent_intern) {
540 		clone_intern->parent_intern = intern->parent_intern;
541 		GC_ADDREF(&clone_intern->parent_intern->std);
542 	}
543 	dom_update_refcount_after_clone(&intern->dom, original_node, &clone_intern->dom, cloned_node);
544 
545 	zend_objects_clone_members(clone, &intern->dom.std);
546 	return clone;
547 }
548 
dom_copy_prop_handler(zval * zv)549 static void dom_copy_prop_handler(zval *zv) /* {{{ */
550 {
551 	dom_prop_handler *hnd = Z_PTR_P(zv);
552 	Z_PTR_P(zv) = malloc(sizeof(dom_prop_handler));
553 	memcpy(Z_PTR_P(zv), hnd, sizeof(dom_prop_handler));
554 }
555 /* }}} */
556 
dom_dtor_prop_handler(zval * zv)557 static void dom_dtor_prop_handler(zval *zv) /* {{{ */
558 {
559 	free(Z_PTR_P(zv));
560 }
561 
562 static const zend_module_dep dom_deps[] = {
563 	ZEND_MOD_REQUIRED("libxml")
564 	ZEND_MOD_CONFLICTS("domxml")
565 	ZEND_MOD_END
566 };
567 
568 zend_module_entry dom_module_entry = { /* {{{ */
569 	STANDARD_MODULE_HEADER_EX, NULL,
570 	dom_deps,
571 	"dom",
572 	ext_functions,
573 	PHP_MINIT(dom),
574 	PHP_MSHUTDOWN(dom),
575 	NULL,
576 	NULL,
577 	PHP_MINFO(dom),
578 	DOM_API_VERSION, /* Extension versionnumber */
579 	STANDARD_MODULE_PROPERTIES
580 };
581 /* }}} */
582 
583 #ifdef COMPILE_DL_DOM
584 ZEND_GET_MODULE(dom)
585 #endif
586 
587 void dom_objects_free_storage(zend_object *object);
588 void dom_nnodemap_objects_free_storage(zend_object *object);
589 static zval *dom_nodelist_read_dimension(zend_object *object, zval *offset, int type, zval *rv);
590 static int dom_nodelist_has_dimension(zend_object *object, zval *member, int check_empty);
591 static zval *dom_nodemap_read_dimension(zend_object *object, zval *offset, int type, zval *rv);
592 static int dom_nodemap_has_dimension(zend_object *object, zval *member, int check_empty);
593 static zend_object *dom_objects_store_clone_obj(zend_object *zobject);
594 #ifdef LIBXML_XPATH_ENABLED
595 void dom_xpath_objects_free_storage(zend_object *object);
596 #endif
597 
598 /* {{{ PHP_MINIT_FUNCTION(dom) */
PHP_MINIT_FUNCTION(dom)599 PHP_MINIT_FUNCTION(dom)
600 {
601 	memcpy(&dom_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
602 	dom_object_handlers.offset = XtOffsetOf(dom_object, std);
603 	dom_object_handlers.free_obj = dom_objects_free_storage;
604 	dom_object_handlers.read_property = dom_read_property;
605 	dom_object_handlers.write_property = dom_write_property;
606 	dom_object_handlers.get_property_ptr_ptr = dom_get_property_ptr_ptr;
607 	dom_object_handlers.clone_obj = dom_objects_store_clone_obj;
608 	dom_object_handlers.has_property = dom_property_exists;
609 	dom_object_handlers.get_debug_info = dom_get_debug_info;
610 
611 	memcpy(&dom_nnodemap_object_handlers, &dom_object_handlers, sizeof(zend_object_handlers));
612 	dom_nnodemap_object_handlers.free_obj = dom_nnodemap_objects_free_storage;
613 	dom_nnodemap_object_handlers.read_dimension = dom_nodemap_read_dimension;
614 	dom_nnodemap_object_handlers.has_dimension = dom_nodemap_has_dimension;
615 
616 	memcpy(&dom_nodelist_object_handlers, &dom_nnodemap_object_handlers, sizeof(zend_object_handlers));
617 	dom_nodelist_object_handlers.read_dimension = dom_nodelist_read_dimension;
618 	dom_nodelist_object_handlers.has_dimension = dom_nodelist_has_dimension;
619 
620 	memcpy(&dom_object_namespace_node_handlers, &dom_object_handlers, sizeof(zend_object_handlers));
621 	dom_object_namespace_node_handlers.offset = XtOffsetOf(dom_object_namespace_node, dom.std);
622 	dom_object_namespace_node_handlers.free_obj = dom_object_namespace_node_free_storage;
623 	dom_object_namespace_node_handlers.clone_obj = dom_object_namespace_node_clone_obj;
624 
625 	zend_hash_init(&classes, 0, NULL, NULL, 1);
626 
627 	dom_domexception_class_entry = register_class_DOMException(zend_ce_exception);
628 
629 	dom_parentnode_class_entry = register_class_DOMParentNode();
630 
631 	dom_childnode_class_entry = register_class_DOMChildNode();
632 
633 	dom_domimplementation_class_entry = register_class_DOMImplementation();
634 	dom_domimplementation_class_entry->create_object = dom_objects_new;
635 
636 	dom_node_class_entry = register_class_DOMNode();
637 	dom_node_class_entry->create_object = dom_objects_new;
638 
639 	zend_hash_init(&dom_node_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
640 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeName", sizeof("nodeName")-1, dom_node_node_name_read, NULL);
641 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeValue", sizeof("nodeValue")-1, dom_node_node_value_read, dom_node_node_value_write);
642 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeType", sizeof("nodeType")-1, dom_node_node_type_read, NULL);
643 	dom_register_prop_handler(&dom_node_prop_handlers, "parentNode", sizeof("parentNode")-1, dom_node_parent_node_read, NULL);
644 	dom_register_prop_handler(&dom_node_prop_handlers, "parentElement", sizeof("parentElement")-1, dom_node_parent_element_read, NULL);
645 	dom_register_prop_handler(&dom_node_prop_handlers, "childNodes", sizeof("childNodes")-1, dom_node_child_nodes_read, NULL);
646 	dom_register_prop_handler(&dom_node_prop_handlers, "firstChild", sizeof("firstChild")-1, dom_node_first_child_read, NULL);
647 	dom_register_prop_handler(&dom_node_prop_handlers, "lastChild", sizeof("lastChild")-1, dom_node_last_child_read, NULL);
648 	dom_register_prop_handler(&dom_node_prop_handlers, "previousSibling", sizeof("previousSibling")-1, dom_node_previous_sibling_read, NULL);
649 	dom_register_prop_handler(&dom_node_prop_handlers, "nextSibling", sizeof("nextSibling")-1, dom_node_next_sibling_read, NULL);
650 	dom_register_prop_handler(&dom_node_prop_handlers, "attributes", sizeof("attributes")-1, dom_node_attributes_read, NULL);
651 	dom_register_prop_handler(&dom_node_prop_handlers, "isConnected", sizeof("isConnected")-1, dom_node_is_connected_read, NULL);
652 	dom_register_prop_handler(&dom_node_prop_handlers, "ownerDocument", sizeof("ownerDocument")-1, dom_node_owner_document_read, NULL);
653 	dom_register_prop_handler(&dom_node_prop_handlers, "namespaceURI", sizeof("namespaceURI")-1, dom_node_namespace_uri_read, NULL);
654 	dom_register_prop_handler(&dom_node_prop_handlers, "prefix", sizeof("prefix")-1, dom_node_prefix_read, dom_node_prefix_write);
655 	dom_register_prop_handler(&dom_node_prop_handlers, "localName", sizeof("localName")-1, dom_node_local_name_read, NULL);
656 	dom_register_prop_handler(&dom_node_prop_handlers, "baseURI", sizeof("baseURI")-1, dom_node_base_uri_read, NULL);
657 	dom_register_prop_handler(&dom_node_prop_handlers, "textContent", sizeof("textContent")-1, dom_node_text_content_read, dom_node_text_content_write);
658 	zend_hash_add_ptr(&classes, dom_node_class_entry->name, &dom_node_prop_handlers);
659 
660 	dom_namespace_node_class_entry = register_class_DOMNameSpaceNode();
661 	dom_namespace_node_class_entry->create_object = dom_objects_namespace_node_new;
662 
663 	zend_hash_init(&dom_namespace_node_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
664 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeName", sizeof("nodeName")-1, dom_node_node_name_read, NULL);
665 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeValue", sizeof("nodeValue")-1, dom_node_node_value_read, NULL);
666 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeType", sizeof("nodeType")-1, dom_node_node_type_read, NULL);
667 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "prefix", sizeof("prefix")-1, dom_node_prefix_read, NULL);
668 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "localName", sizeof("localName")-1, dom_node_local_name_read, NULL);
669 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "namespaceURI", sizeof("namespaceURI")-1, dom_node_namespace_uri_read, NULL);
670 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "isConnected", sizeof("isConnected")-1, dom_node_is_connected_read, NULL);
671 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "ownerDocument", sizeof("ownerDocument")-1, dom_node_owner_document_read, NULL);
672 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "parentNode", sizeof("parentNode")-1, dom_node_parent_node_read, NULL);
673 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "parentElement", sizeof("parentElement")-1, dom_node_parent_element_read, NULL);
674 	zend_hash_add_ptr(&classes, dom_namespace_node_class_entry->name, &dom_namespace_node_prop_handlers);
675 
676 	dom_documentfragment_class_entry = register_class_DOMDocumentFragment(dom_node_class_entry, dom_parentnode_class_entry);
677 	dom_documentfragment_class_entry->create_object = dom_objects_new;
678 	zend_hash_init(&dom_documentfragment_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
679 
680 	dom_register_prop_handler(&dom_documentfragment_prop_handlers, "firstElementChild", sizeof("firstElementChild")-1, dom_parent_node_first_element_child_read, NULL);
681 	dom_register_prop_handler(&dom_documentfragment_prop_handlers, "lastElementChild", sizeof("lastElementChild")-1, dom_parent_node_last_element_child_read, NULL);
682 	dom_register_prop_handler(&dom_documentfragment_prop_handlers, "childElementCount", sizeof("childElementCount")-1, dom_parent_node_child_element_count, NULL);
683 
684 	zend_hash_merge(&dom_documentfragment_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
685 	zend_hash_add_ptr(&classes, dom_documentfragment_class_entry->name, &dom_documentfragment_prop_handlers);
686 
687 	dom_document_class_entry = register_class_DOMDocument(dom_node_class_entry, dom_parentnode_class_entry);
688 	dom_document_class_entry->create_object = dom_objects_new;
689 	zend_hash_init(&dom_document_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
690 	dom_register_prop_handler(&dom_document_prop_handlers, "doctype", sizeof("doctype")-1, dom_document_doctype_read, NULL);
691 	dom_register_prop_handler(&dom_document_prop_handlers, "implementation", sizeof("implementation")-1, dom_document_implementation_read, NULL);
692 	dom_register_prop_handler(&dom_document_prop_handlers, "documentElement", sizeof("documentElement")-1, dom_document_document_element_read, NULL);
693 	dom_register_prop_handler(&dom_document_prop_handlers, "actualEncoding", sizeof("actualEncoding")-1, dom_document_encoding_read, NULL);
694 	dom_register_prop_handler(&dom_document_prop_handlers, "encoding", sizeof("encoding")-1, dom_document_encoding_read, dom_document_encoding_write);
695 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlEncoding", sizeof("xmlEncoding")-1, dom_document_encoding_read, NULL);
696 	dom_register_prop_handler(&dom_document_prop_handlers, "standalone", sizeof("standalone")-1, dom_document_standalone_read, dom_document_standalone_write);
697 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlStandalone", sizeof("xmlStandalone")-1, dom_document_standalone_read, dom_document_standalone_write);
698 	dom_register_prop_handler(&dom_document_prop_handlers, "version", sizeof("version")-1, dom_document_version_read, dom_document_version_write);
699 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlVersion", sizeof("xmlVersion")-1, dom_document_version_read, dom_document_version_write);
700 	dom_register_prop_handler(&dom_document_prop_handlers, "strictErrorChecking", sizeof("strictErrorChecking")-1, dom_document_strict_error_checking_read, dom_document_strict_error_checking_write);
701 	dom_register_prop_handler(&dom_document_prop_handlers, "documentURI", sizeof("documentURI")-1, dom_document_document_uri_read, dom_document_document_uri_write);
702 	dom_register_prop_handler(&dom_document_prop_handlers, "config", sizeof("config")-1, dom_document_config_read, NULL);
703 	dom_register_prop_handler(&dom_document_prop_handlers, "formatOutput", sizeof("formatOutput")-1, dom_document_format_output_read, dom_document_format_output_write);
704 	dom_register_prop_handler(&dom_document_prop_handlers, "validateOnParse", sizeof("validateOnParse")-1, dom_document_validate_on_parse_read, dom_document_validate_on_parse_write);
705 	dom_register_prop_handler(&dom_document_prop_handlers, "resolveExternals", sizeof("resolveExternals")-1, dom_document_resolve_externals_read, dom_document_resolve_externals_write);
706 	dom_register_prop_handler(&dom_document_prop_handlers, "preserveWhiteSpace", sizeof("preserveWhitespace")-1, dom_document_preserve_whitespace_read, dom_document_preserve_whitespace_write);
707 	dom_register_prop_handler(&dom_document_prop_handlers, "recover", sizeof("recover")-1, dom_document_recover_read, dom_document_recover_write);
708 	dom_register_prop_handler(&dom_document_prop_handlers, "substituteEntities", sizeof("substituteEntities")-1, dom_document_substitue_entities_read, dom_document_substitue_entities_write);
709 
710 	dom_register_prop_handler(&dom_document_prop_handlers, "firstElementChild", sizeof("firstElementChild")-1, dom_parent_node_first_element_child_read, NULL);
711 	dom_register_prop_handler(&dom_document_prop_handlers, "lastElementChild", sizeof("lastElementChild")-1, dom_parent_node_last_element_child_read, NULL);
712 	dom_register_prop_handler(&dom_document_prop_handlers, "childElementCount", sizeof("childElementCount")-1, dom_parent_node_child_element_count, NULL);
713 
714 	zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
715 	zend_hash_add_ptr(&classes, dom_document_class_entry->name, &dom_document_prop_handlers);
716 
717 	dom_nodelist_class_entry = register_class_DOMNodeList(zend_ce_aggregate, zend_ce_countable);
718 	dom_nodelist_class_entry->create_object = dom_nnodemap_objects_new;
719 	dom_nodelist_class_entry->default_object_handlers = &dom_nodelist_object_handlers;
720 	dom_nodelist_class_entry->get_iterator = php_dom_get_iterator;
721 
722 	zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
723 	dom_register_prop_handler(&dom_nodelist_prop_handlers, "length", sizeof("length")-1, dom_nodelist_length_read, NULL);
724 	zend_hash_add_ptr(&classes, dom_nodelist_class_entry->name, &dom_nodelist_prop_handlers);
725 
726 	dom_namednodemap_class_entry = register_class_DOMNamedNodeMap(zend_ce_aggregate, zend_ce_countable);
727 	dom_namednodemap_class_entry->create_object = dom_nnodemap_objects_new;
728 	dom_namednodemap_class_entry->default_object_handlers = &dom_nnodemap_object_handlers;
729 	dom_namednodemap_class_entry->get_iterator = php_dom_get_iterator;
730 
731 	zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
732 	dom_register_prop_handler(&dom_namednodemap_prop_handlers, "length", sizeof("length")-1, dom_namednodemap_length_read, NULL);
733 	zend_hash_add_ptr(&classes, dom_namednodemap_class_entry->name, &dom_namednodemap_prop_handlers);
734 
735 	dom_characterdata_class_entry = register_class_DOMCharacterData(dom_node_class_entry, dom_childnode_class_entry);
736 	dom_characterdata_class_entry->create_object = dom_objects_new;
737 
738 	zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
739 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "data", sizeof("data")-1, dom_characterdata_data_read, dom_characterdata_data_write);
740 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "length", sizeof("length")-1, dom_characterdata_length_read, NULL);
741 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "previousElementSibling", sizeof("previousElementSibling")-1, dom_node_previous_element_sibling_read, NULL);
742 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "nextElementSibling", sizeof("nextElementSibling")-1, dom_node_next_element_sibling_read, NULL);
743 	zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
744 	zend_hash_add_ptr(&classes, dom_characterdata_class_entry->name, &dom_characterdata_prop_handlers);
745 
746 	dom_attr_class_entry = register_class_DOMAttr(dom_node_class_entry);
747 	dom_attr_class_entry->create_object = dom_objects_new;
748 
749 	zend_hash_init(&dom_attr_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
750 	dom_register_prop_handler(&dom_attr_prop_handlers, "name", sizeof("name")-1, dom_attr_name_read, NULL);
751 	dom_register_prop_handler(&dom_attr_prop_handlers, "specified", sizeof("specified")-1, dom_attr_specified_read, NULL);
752 	dom_register_prop_handler(&dom_attr_prop_handlers, "value", sizeof("value")-1, dom_attr_value_read, dom_attr_value_write);
753 	dom_register_prop_handler(&dom_attr_prop_handlers, "ownerElement", sizeof("ownerElement")-1, dom_attr_owner_element_read, NULL);
754 	dom_register_prop_handler(&dom_attr_prop_handlers, "schemaTypeInfo", sizeof("schemaTypeInfo")-1, dom_attr_schema_type_info_read, NULL);
755 	zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
756 	zend_hash_add_ptr(&classes, dom_attr_class_entry->name, &dom_attr_prop_handlers);
757 
758 	dom_element_class_entry = register_class_DOMElement(dom_node_class_entry, dom_parentnode_class_entry, dom_childnode_class_entry);
759 	dom_element_class_entry->create_object = dom_objects_new;
760 
761 	zend_hash_init(&dom_element_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
762 	dom_register_prop_handler(&dom_element_prop_handlers, "tagName", sizeof("tagName")-1, dom_element_tag_name_read, NULL);
763 	dom_register_prop_handler(&dom_element_prop_handlers, "className", sizeof("className")-1, dom_element_class_name_read, dom_element_class_name_write);
764 	dom_register_prop_handler(&dom_element_prop_handlers, "id", sizeof("id")-1, dom_element_id_read, dom_element_id_write);
765 	dom_register_prop_handler(&dom_element_prop_handlers, "schemaTypeInfo", sizeof("schemaTypeInfo")-1, dom_element_schema_type_info_read, NULL);
766 	dom_register_prop_handler(&dom_element_prop_handlers, "firstElementChild", sizeof("firstElementChild")-1, dom_parent_node_first_element_child_read, NULL);
767 	dom_register_prop_handler(&dom_element_prop_handlers, "lastElementChild", sizeof("lastElementChild")-1, dom_parent_node_last_element_child_read, NULL);
768 	dom_register_prop_handler(&dom_element_prop_handlers, "childElementCount", sizeof("childElementCount")-1, dom_parent_node_child_element_count, NULL);
769 	dom_register_prop_handler(&dom_element_prop_handlers, "previousElementSibling", sizeof("previousElementSibling")-1, dom_node_previous_element_sibling_read, NULL);
770 	dom_register_prop_handler(&dom_element_prop_handlers, "nextElementSibling", sizeof("nextElementSibling")-1, dom_node_next_element_sibling_read, NULL);
771 	zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
772 	zend_hash_add_ptr(&classes, dom_element_class_entry->name, &dom_element_prop_handlers);
773 
774 	dom_text_class_entry = register_class_DOMText(dom_characterdata_class_entry);
775 	dom_text_class_entry->create_object = dom_objects_new;
776 
777 	zend_hash_init(&dom_text_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
778 	dom_register_prop_handler(&dom_text_prop_handlers, "wholeText", sizeof("wholeText")-1, dom_text_whole_text_read, NULL);
779 	zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, dom_copy_prop_handler, 0);
780 	zend_hash_add_ptr(&classes, dom_text_class_entry->name, &dom_text_prop_handlers);
781 
782 	dom_comment_class_entry = register_class_DOMComment(dom_characterdata_class_entry);
783 	dom_comment_class_entry->create_object = dom_objects_new;
784 	zend_hash_add_ptr(&classes, dom_comment_class_entry->name, &dom_characterdata_prop_handlers);
785 
786 	dom_cdatasection_class_entry = register_class_DOMCdataSection(dom_text_class_entry);
787 	dom_cdatasection_class_entry->create_object = dom_objects_new;
788 	zend_hash_add_ptr(&classes, dom_cdatasection_class_entry->name, &dom_text_prop_handlers);
789 
790 	dom_documenttype_class_entry = register_class_DOMDocumentType(dom_node_class_entry);
791 	dom_documenttype_class_entry->create_object = dom_objects_new;
792 
793 	zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
794 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "name", sizeof("name")-1, dom_documenttype_name_read, NULL);
795 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "entities", sizeof("entities")-1, dom_documenttype_entities_read, NULL);
796 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "notations", sizeof("notations")-1, dom_documenttype_notations_read, NULL);
797 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "publicId", sizeof("publicId")-1, dom_documenttype_public_id_read, NULL);
798 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "systemId", sizeof("systemId")-1, dom_documenttype_system_id_read, NULL);
799 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "internalSubset", sizeof("internalSubset")-1, dom_documenttype_internal_subset_read, NULL);
800 	zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
801 	zend_hash_add_ptr(&classes, dom_documenttype_class_entry->name, &dom_documenttype_prop_handlers);
802 
803 	dom_notation_class_entry = register_class_DOMNotation(dom_node_class_entry);
804 	dom_notation_class_entry->create_object = dom_objects_new;
805 
806 	zend_hash_init(&dom_notation_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
807 	dom_register_prop_handler(&dom_notation_prop_handlers, "publicId", sizeof("publicId")-1, dom_notation_public_id_read, NULL);
808 	dom_register_prop_handler(&dom_notation_prop_handlers, "systemId", sizeof("systemId")-1, dom_notation_system_id_read, NULL);
809 	zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
810 	zend_hash_add_ptr(&classes, dom_notation_class_entry->name, &dom_notation_prop_handlers);
811 
812 	dom_entity_class_entry = register_class_DOMEntity(dom_node_class_entry);
813 	dom_entity_class_entry->create_object = dom_objects_new;
814 
815 	zend_hash_init(&dom_entity_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
816 	dom_register_prop_handler(&dom_entity_prop_handlers, "publicId", sizeof("publicId")-1, dom_entity_public_id_read, NULL);
817 	dom_register_prop_handler(&dom_entity_prop_handlers, "systemId", sizeof("systemId")-1, dom_entity_system_id_read, NULL);
818 	dom_register_prop_handler(&dom_entity_prop_handlers, "notationName", sizeof("notationName")-1, dom_entity_notation_name_read, NULL);
819 	dom_register_prop_handler(&dom_entity_prop_handlers, "actualEncoding", sizeof("actualEncoding")-1, dom_entity_actual_encoding_read, NULL);
820 	dom_register_prop_handler(&dom_entity_prop_handlers, "encoding", sizeof("encoding")-1, dom_entity_encoding_read, NULL);
821 	dom_register_prop_handler(&dom_entity_prop_handlers, "version", sizeof("version")-1, dom_entity_version_read, NULL);
822 	zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
823 	zend_hash_add_ptr(&classes, dom_entity_class_entry->name, &dom_entity_prop_handlers);
824 
825 	dom_entityreference_class_entry = register_class_DOMEntityReference(dom_node_class_entry);
826 	dom_entityreference_class_entry->create_object = dom_objects_new;
827 
828 	zend_hash_init(&dom_entity_reference_prop_handlers, 0, NULL, dom_dtor_prop_handler, true);
829 	zend_hash_merge(&dom_entity_reference_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, false);
830 	dom_override_prop_handler(&dom_entity_reference_prop_handlers, "firstChild", sizeof("firstChild")-1, dom_entity_reference_child_read, NULL);
831 	dom_override_prop_handler(&dom_entity_reference_prop_handlers, "lastChild", sizeof("lastChild")-1, dom_entity_reference_child_read, NULL);
832 	dom_override_prop_handler(&dom_entity_reference_prop_handlers, "textContent", sizeof("textContent")-1, dom_entity_reference_text_content_read, NULL);
833 	dom_override_prop_handler(&dom_entity_reference_prop_handlers, "childNodes", sizeof("childNodes")-1, dom_entity_reference_child_nodes_read, NULL);
834 	zend_hash_add_ptr(&classes, dom_entityreference_class_entry->name, &dom_entity_reference_prop_handlers);
835 
836 	dom_processinginstruction_class_entry = register_class_DOMProcessingInstruction(dom_node_class_entry);
837 	dom_processinginstruction_class_entry->create_object = dom_objects_new;
838 
839 	zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
840 	dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "target", sizeof("target")-1, dom_processinginstruction_target_read, NULL);
841 	dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "data", sizeof("data")-1, dom_processinginstruction_data_read, dom_processinginstruction_data_write);
842 	zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
843 	zend_hash_add_ptr(&classes, dom_processinginstruction_class_entry->name, &dom_processinginstruction_prop_handlers);
844 
845 #ifdef LIBXML_XPATH_ENABLED
846 	memcpy(&dom_xpath_object_handlers, &dom_object_handlers, sizeof(zend_object_handlers));
847 	dom_xpath_object_handlers.offset = XtOffsetOf(dom_xpath_object, dom) + XtOffsetOf(dom_object, std);
848 	dom_xpath_object_handlers.free_obj = dom_xpath_objects_free_storage;
849 
850 	dom_xpath_class_entry = register_class_DOMXPath();
851 	dom_xpath_class_entry->create_object = dom_xpath_objects_new;
852 	dom_xpath_class_entry->default_object_handlers = &dom_xpath_object_handlers;
853 
854 	zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
855 	dom_register_prop_handler(&dom_xpath_prop_handlers, "document", sizeof("document")-1, dom_xpath_document_read, NULL);
856 	dom_register_prop_handler(&dom_xpath_prop_handlers, "registerNodeNamespaces", sizeof("registerNodeNamespaces")-1, dom_xpath_register_node_ns_read, dom_xpath_register_node_ns_write);
857 	zend_hash_add_ptr(&classes, dom_xpath_class_entry->name, &dom_xpath_prop_handlers);
858 #endif
859 
860 	register_php_dom_symbols(module_number);
861 
862 	php_libxml_register_export(dom_node_class_entry, php_dom_export_node);
863 
864 	return SUCCESS;
865 }
866 /* }}} */
867 
868 /* {{{ */
PHP_MINFO_FUNCTION(dom)869 PHP_MINFO_FUNCTION(dom)
870 {
871 	php_info_print_table_start();
872 	php_info_print_table_row(2, "DOM/XML", "enabled");
873 	php_info_print_table_row(2, "DOM/XML API Version", DOM_API_VERSION);
874 	php_info_print_table_row(2, "libxml Version", LIBXML_DOTTED_VERSION);
875 #ifdef LIBXML_HTML_ENABLED
876 	php_info_print_table_row(2, "HTML Support", "enabled");
877 #endif
878 #ifdef LIBXML_XPATH_ENABLED
879 	php_info_print_table_row(2, "XPath Support", "enabled");
880 #endif
881 #ifdef LIBXML_XPTR_ENABLED
882 	php_info_print_table_row(2, "XPointer Support", "enabled");
883 #endif
884 #ifdef LIBXML_SCHEMAS_ENABLED
885 	php_info_print_table_row(2, "Schema Support", "enabled");
886 	php_info_print_table_row(2, "RelaxNG Support", "enabled");
887 #endif
888 	php_info_print_table_end();
889 }
890 /* }}} */
891 
PHP_MSHUTDOWN_FUNCTION(dom)892 PHP_MSHUTDOWN_FUNCTION(dom) /* {{{ */
893 {
894 	zend_hash_destroy(&dom_document_prop_handlers);
895 	zend_hash_destroy(&dom_documentfragment_prop_handlers);
896 	zend_hash_destroy(&dom_node_prop_handlers);
897 	zend_hash_destroy(&dom_entity_reference_prop_handlers);
898 	zend_hash_destroy(&dom_namespace_node_prop_handlers);
899 	zend_hash_destroy(&dom_nodelist_prop_handlers);
900 	zend_hash_destroy(&dom_namednodemap_prop_handlers);
901 	zend_hash_destroy(&dom_characterdata_prop_handlers);
902 	zend_hash_destroy(&dom_attr_prop_handlers);
903 	zend_hash_destroy(&dom_element_prop_handlers);
904 	zend_hash_destroy(&dom_text_prop_handlers);
905 	zend_hash_destroy(&dom_documenttype_prop_handlers);
906 	zend_hash_destroy(&dom_notation_prop_handlers);
907 	zend_hash_destroy(&dom_entity_prop_handlers);
908 	zend_hash_destroy(&dom_processinginstruction_prop_handlers);
909 #ifdef LIBXML_XPATH_ENABLED
910 	zend_hash_destroy(&dom_xpath_prop_handlers);
911 #endif
912 	zend_hash_destroy(&classes);
913 
914 /*	If you want do find memleaks in this module, compile libxml2 with --with-mem-debug and
915 	uncomment the following line, this will tell you the amount of not freed memory
916 	and the total used memory into apaches error_log  */
917 /*  xmlMemoryDump();*/
918 
919 	return SUCCESS;
920 }
921 /* }}} */
922 
923 /* {{{ node_list_unlink */
node_list_unlink(xmlNodePtr node)924 void node_list_unlink(xmlNodePtr node)
925 {
926 	dom_object *wrapper;
927 
928 	while (node != NULL) {
929 
930 		wrapper = php_dom_object_get_data(node);
931 
932 		if (wrapper != NULL ) {
933 			xmlUnlinkNode(node);
934 		} else {
935 			if (node->type == XML_ENTITY_REF_NODE)
936 				break;
937 			node_list_unlink(node->children);
938 
939 			switch (node->type) {
940 				case XML_ATTRIBUTE_DECL:
941 				case XML_DTD_NODE:
942 				case XML_DOCUMENT_TYPE_NODE:
943 				case XML_ENTITY_DECL:
944 				case XML_ATTRIBUTE_NODE:
945 				case XML_TEXT_NODE:
946 					break;
947 				default:
948 					node_list_unlink((xmlNodePtr) node->properties);
949 			}
950 
951 		}
952 
953 		node = node->next;
954 	}
955 }
956 /* }}} end node_list_unlink */
957 
958 #ifdef LIBXML_XPATH_ENABLED
959 /* {{{ dom_xpath_objects_free_storage */
dom_xpath_objects_free_storage(zend_object * object)960 void dom_xpath_objects_free_storage(zend_object *object)
961 {
962 	dom_xpath_object *intern = php_xpath_obj_from_obj(object);
963 
964 	zend_object_std_dtor(&intern->dom.std);
965 
966 	if (intern->dom.ptr != NULL) {
967 		xmlXPathFreeContext((xmlXPathContextPtr) intern->dom.ptr);
968 		php_libxml_decrement_doc_ref((php_libxml_node_object *) &intern->dom);
969 	}
970 
971 	if (intern->registered_phpfunctions) {
972 		zend_hash_destroy(intern->registered_phpfunctions);
973 		FREE_HASHTABLE(intern->registered_phpfunctions);
974 	}
975 
976 	if (intern->node_list) {
977 		zend_hash_destroy(intern->node_list);
978 		FREE_HASHTABLE(intern->node_list);
979 	}
980 }
981 /* }}} */
982 #endif
983 
984 /* {{{ dom_objects_free_storage */
dom_objects_free_storage(zend_object * object)985 void dom_objects_free_storage(zend_object *object)
986 {
987 	dom_object *intern = php_dom_obj_from_obj(object);
988 #if defined(__GNUC__) && __GNUC__ >= 3
989 	int retcount __attribute__((unused)); /* keep compiler quiet */
990 #else
991 	int retcount;
992 #endif
993 
994 	zend_object_std_dtor(&intern->std);
995 
996 	if (intern->ptr != NULL && ((php_libxml_node_ptr *)intern->ptr)->node != NULL) {
997 		if (((xmlNodePtr) ((php_libxml_node_ptr *)intern->ptr)->node)->type != XML_DOCUMENT_NODE && ((xmlNodePtr) ((php_libxml_node_ptr *)intern->ptr)->node)->type != XML_HTML_DOCUMENT_NODE) {
998 			php_libxml_node_decrement_resource((php_libxml_node_object *) intern);
999 		} else {
1000 			php_libxml_decrement_node_ptr((php_libxml_node_object *) intern);
1001 			retcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
1002 		}
1003 		intern->ptr = NULL;
1004 	}
1005 }
1006 /* }}} */
1007 
dom_namednode_iter(dom_object * basenode,int ntype,dom_object * intern,xmlHashTablePtr ht,const char * local,size_t local_len,const char * ns,size_t ns_len)1008 void dom_namednode_iter(dom_object *basenode, int ntype, dom_object *intern, xmlHashTablePtr ht, const char *local, size_t local_len, const char *ns, size_t ns_len) /* {{{ */
1009 {
1010 	dom_nnodemap_object *mapptr = (dom_nnodemap_object *) intern->ptr;
1011 
1012 	ZEND_ASSERT(basenode != NULL);
1013 
1014 	ZVAL_OBJ_COPY(&mapptr->baseobj_zv, &basenode->std);
1015 
1016 	xmlDocPtr doc = basenode->document ? basenode->document->ptr : NULL;
1017 
1018 	mapptr->baseobj = basenode;
1019 	mapptr->nodetype = ntype;
1020 	mapptr->ht = ht;
1021 
1022 	const xmlChar* tmp;
1023 
1024 	if (local) {
1025 		int len = local_len > INT_MAX ? -1 : (int) local_len;
1026 		if (doc != NULL && (tmp = xmlDictExists(doc->dict, (const xmlChar *)local, len)) != NULL) {
1027 			mapptr->local = (xmlChar*) tmp;
1028 		} else {
1029 			mapptr->local = xmlCharStrndup(local, len);
1030 			mapptr->free_local = true;
1031 		}
1032 	}
1033 
1034 	if (ns) {
1035 		int len = ns_len > INT_MAX ? -1 : (int) ns_len;
1036 		if (doc != NULL && (tmp = xmlDictExists(doc->dict, (const xmlChar *)ns, len)) != NULL) {
1037 			mapptr->ns = (xmlChar*) tmp;
1038 		} else {
1039 			mapptr->ns = xmlCharStrndup(ns, len);
1040 			mapptr->free_ns = true;
1041 		}
1042 	}
1043 }
1044 /* }}} */
1045 
dom_objects_set_class_ex(zend_class_entry * class_type,dom_object * intern)1046 static void dom_objects_set_class_ex(zend_class_entry *class_type, dom_object *intern)
1047 {
1048 	zend_class_entry *base_class = class_type;
1049 	while ((base_class->type != ZEND_INTERNAL_CLASS || base_class->info.internal.module->module_number != dom_module_entry.module_number) && base_class->parent != NULL) {
1050 		base_class = base_class->parent;
1051 	}
1052 
1053 	intern->prop_handler = zend_hash_find_ptr(&classes, base_class->name);
1054 
1055 	zend_object_std_init(&intern->std, class_type);
1056 	object_properties_init(&intern->std, class_type);
1057 }
1058 
dom_objects_set_class(zend_class_entry * class_type)1059 static dom_object* dom_objects_set_class(zend_class_entry *class_type)
1060 {
1061 	dom_object *intern = zend_object_alloc(sizeof(dom_object), class_type);
1062 	dom_objects_set_class_ex(class_type, intern);
1063 	return intern;
1064 }
1065 
1066 /* {{{ dom_objects_new */
dom_objects_new(zend_class_entry * class_type)1067 zend_object *dom_objects_new(zend_class_entry *class_type)
1068 {
1069 	dom_object *intern = dom_objects_set_class(class_type);
1070 	intern->std.handlers = dom_get_obj_handlers();
1071 	return &intern->std;
1072 }
1073 /* }}} */
1074 
dom_objects_namespace_node_new(zend_class_entry * class_type)1075 static zend_object *dom_objects_namespace_node_new(zend_class_entry *class_type)
1076 {
1077 	dom_object_namespace_node *intern = zend_object_alloc(sizeof(dom_object_namespace_node), class_type);
1078 	dom_objects_set_class_ex(class_type, &intern->dom);
1079 	intern->dom.std.handlers = &dom_object_namespace_node_handlers;
1080 	return &intern->dom.std;
1081 }
1082 
dom_object_namespace_node_free_storage(zend_object * object)1083 static void dom_object_namespace_node_free_storage(zend_object *object)
1084 {
1085 	dom_object_namespace_node *intern = php_dom_namespace_node_obj_from_obj(object);
1086 	if (intern->parent_intern != NULL) {
1087 		zval tmp;
1088 		ZVAL_OBJ(&tmp, &intern->parent_intern->std);
1089 		zval_ptr_dtor(&tmp);
1090 	}
1091 	dom_objects_free_storage(object);
1092 }
1093 
1094 #ifdef LIBXML_XPATH_ENABLED
1095 /* {{{ zend_object dom_xpath_objects_new(zend_class_entry *class_type) */
dom_xpath_objects_new(zend_class_entry * class_type)1096 zend_object *dom_xpath_objects_new(zend_class_entry *class_type)
1097 {
1098 	dom_xpath_object *intern = zend_object_alloc(sizeof(dom_xpath_object), class_type);
1099 
1100 	intern->registered_phpfunctions = zend_new_array(0);
1101 	intern->register_node_ns = 1;
1102 
1103 	intern->dom.prop_handler = &dom_xpath_prop_handlers;
1104 
1105 	zend_object_std_init(&intern->dom.std, class_type);
1106 	object_properties_init(&intern->dom.std, class_type);
1107 
1108 	return &intern->dom.std;
1109 }
1110 /* }}} */
1111 #endif
1112 
dom_nnodemap_objects_free_storage(zend_object * object)1113 void dom_nnodemap_objects_free_storage(zend_object *object) /* {{{ */
1114 {
1115 	dom_object *intern = php_dom_obj_from_obj(object);
1116 	dom_nnodemap_object *objmap = (dom_nnodemap_object *)intern->ptr;
1117 
1118 	if (objmap) {
1119 		if (objmap->cached_obj && GC_DELREF(&objmap->cached_obj->std) == 0) {
1120 			zend_objects_store_del(&objmap->cached_obj->std);
1121 		}
1122 		if (objmap->free_local) {
1123 			xmlFree(objmap->local);
1124 		}
1125 		if (objmap->free_ns) {
1126 			xmlFree(objmap->ns);
1127 		}
1128 		if (!Z_ISUNDEF(objmap->baseobj_zv)) {
1129 			zval_ptr_dtor(&objmap->baseobj_zv);
1130 		}
1131 		efree(objmap);
1132 		intern->ptr = NULL;
1133 	}
1134 
1135 	php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
1136 
1137 	zend_object_std_dtor(&intern->std);
1138 }
1139 /* }}} */
1140 
dom_nnodemap_objects_new(zend_class_entry * class_type)1141 zend_object *dom_nnodemap_objects_new(zend_class_entry *class_type)
1142 {
1143 	dom_object *intern;
1144 	dom_nnodemap_object *objmap;
1145 
1146 	intern = dom_objects_set_class(class_type);
1147 	intern->ptr = emalloc(sizeof(dom_nnodemap_object));
1148 	objmap = (dom_nnodemap_object *)intern->ptr;
1149 	ZVAL_UNDEF(&objmap->baseobj_zv);
1150 	objmap->baseobj = NULL;
1151 	objmap->nodetype = 0;
1152 	objmap->ht = NULL;
1153 	objmap->local = NULL;
1154 	objmap->free_local = false;
1155 	objmap->ns = NULL;
1156 	objmap->free_ns = false;
1157 	objmap->cache_tag.modification_nr = 0;
1158 	objmap->cached_length = -1;
1159 	objmap->cached_obj = NULL;
1160 	objmap->cached_obj_index = 0;
1161 
1162 	return &intern->std;
1163 }
1164 
php_dom_create_iterator(zval * return_value,int ce_type)1165 void php_dom_create_iterator(zval *return_value, int ce_type) /* {{{ */
1166 {
1167 	zend_class_entry *ce;
1168 
1169 	if (ce_type == DOM_NAMEDNODEMAP) {
1170 		ce = dom_namednodemap_class_entry;
1171 	} else {
1172 		ce = dom_nodelist_class_entry;
1173 	}
1174 
1175 	object_init_ex(return_value, ce);
1176 }
1177 /* }}} */
1178 
1179 /* {{{ php_dom_create_object */
php_dom_create_object(xmlNodePtr obj,zval * return_value,dom_object * domobj)1180 PHP_DOM_EXPORT bool php_dom_create_object(xmlNodePtr obj, zval *return_value, dom_object *domobj)
1181 {
1182 	zend_class_entry *ce;
1183 	dom_object *intern;
1184 
1185 	if (!obj) {
1186 		ZVAL_NULL(return_value);
1187 		return 0;
1188 	}
1189 
1190 	if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
1191 		ZVAL_OBJ_COPY(return_value, &intern->std);
1192 		return 1;
1193 	}
1194 
1195 	switch (obj->type) {
1196 		case XML_DOCUMENT_NODE:
1197 		case XML_HTML_DOCUMENT_NODE:
1198 		{
1199 			ce = dom_document_class_entry;
1200 			break;
1201 		}
1202 		case XML_DTD_NODE:
1203 		case XML_DOCUMENT_TYPE_NODE:
1204 		{
1205 			ce = dom_documenttype_class_entry;
1206 			break;
1207 		}
1208 		case XML_ELEMENT_NODE:
1209 		{
1210 			ce = dom_element_class_entry;
1211 			break;
1212 		}
1213 		case XML_ATTRIBUTE_NODE:
1214 		{
1215 			ce = dom_attr_class_entry;
1216 			break;
1217 		}
1218 		case XML_TEXT_NODE:
1219 		{
1220 			ce = dom_text_class_entry;
1221 			break;
1222 		}
1223 		case XML_COMMENT_NODE:
1224 		{
1225 			ce = dom_comment_class_entry;
1226 			break;
1227 		}
1228 		case XML_PI_NODE:
1229 		{
1230 			ce = dom_processinginstruction_class_entry;
1231 			break;
1232 		}
1233 		case XML_ENTITY_REF_NODE:
1234 		{
1235 			ce = dom_entityreference_class_entry;
1236 			break;
1237 		}
1238 		case XML_ENTITY_DECL:
1239 		case XML_ELEMENT_DECL:
1240 		{
1241 			ce = dom_entity_class_entry;
1242 			break;
1243 		}
1244 		case XML_CDATA_SECTION_NODE:
1245 		{
1246 			ce = dom_cdatasection_class_entry;
1247 			break;
1248 		}
1249 		case XML_DOCUMENT_FRAG_NODE:
1250 		{
1251 			ce = dom_documentfragment_class_entry;
1252 			break;
1253 		}
1254 		case XML_NOTATION_NODE:
1255 		{
1256 			ce = dom_notation_class_entry;
1257 			break;
1258 		}
1259 		case XML_NAMESPACE_DECL:
1260 		{
1261 			ce = dom_namespace_node_class_entry;
1262 			break;
1263 		}
1264 		default:
1265 			/* TODO Convert to a ZEND assertion? */
1266 			zend_throw_error(NULL, "Unsupported node type: %d", obj->type);
1267 			ZVAL_NULL(return_value);
1268 			return 0;
1269 	}
1270 
1271 	if (domobj && domobj->document) {
1272 		ce = dom_get_doc_classmap(domobj->document, ce);
1273 	}
1274 	object_init_ex(return_value, ce);
1275 
1276 	intern = Z_DOMOBJ_P(return_value);
1277 	if (obj->doc != NULL) {
1278 		if (domobj != NULL) {
1279 			intern->document = domobj->document;
1280 		}
1281 		php_libxml_increment_doc_ref((php_libxml_node_object *)intern, obj->doc);
1282 	}
1283 
1284 	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, obj, (void *)intern);
1285 	return 0;
1286 }
1287 /* }}} end php_domobject_new */
1288 
php_dom_create_implementation(zval * retval)1289 void php_dom_create_implementation(zval *retval) {
1290 	object_init_ex(retval, dom_domimplementation_class_entry);
1291 }
1292 
1293 /* {{{ int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) */
dom_hierarchy(xmlNodePtr parent,xmlNodePtr child)1294 int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child)
1295 {
1296 	xmlNodePtr nodep;
1297 
1298 	if (parent == NULL || child == NULL || child->doc != parent->doc) {
1299 		return SUCCESS;
1300 	}
1301 
1302 	if (child->type == XML_DOCUMENT_NODE) {
1303 		return FAILURE;
1304 	}
1305 
1306 	nodep = parent;
1307 
1308 	while (nodep) {
1309 		if (nodep == child) {
1310 			return FAILURE;
1311 		}
1312 		nodep = nodep->parent;
1313 	}
1314 
1315 	return SUCCESS;
1316 }
1317 /* }}} end dom_hierarchy */
1318 
1319 /* {{{ */
dom_has_feature(zend_string * feature,zend_string * version)1320 bool dom_has_feature(zend_string *feature, zend_string *version)
1321 {
1322 	if (zend_string_equals_literal(version, "1.0")
1323 		|| zend_string_equals_literal(version, "2.0")
1324 		|| zend_string_equals_literal(version, "")
1325 	) {
1326 		if (zend_string_equals_literal_ci(feature, "XML")
1327 			|| (zend_string_equals_literal_ci(feature, "Core") && zend_string_equals_literal(version, "1.0"))
1328 		) {
1329 			return true;
1330 		}
1331 	}
1332 
1333 	return false;
1334 }
1335 /* }}} end dom_has_feature */
1336 
dom_get_elements_by_tag_name_ns_raw(xmlNodePtr basep,xmlNodePtr nodep,char * ns,char * local,zend_long * cur,zend_long index)1337 xmlNode *dom_get_elements_by_tag_name_ns_raw(xmlNodePtr basep, xmlNodePtr nodep, char *ns, char *local, zend_long *cur, zend_long index) /* {{{ */
1338 {
1339 	/* Can happen with detached document */
1340 	if (UNEXPECTED(nodep == NULL)) {
1341 		return NULL;
1342 	}
1343 
1344 	xmlNodePtr ret = NULL;
1345 	bool local_match_any = local[0] == '*' && local[1] == '\0';
1346 
1347 	/* Note: The spec says that ns == '' must be transformed to ns == NULL. In other words, they are equivalent.
1348 	 *       PHP however does not do this and internally uses the empty string everywhere when the user provides ns == NULL.
1349 	 *       This is because for PHP ns == NULL has another meaning: "match every namespace" instead of "match the empty namespace". */
1350 	bool ns_match_any = ns == NULL || (ns[0] == '*' && ns[1] == '\0');
1351 
1352 	while (*cur <= index) {
1353 		if (nodep->type == XML_ELEMENT_NODE) {
1354 			if (local_match_any || xmlStrEqual(nodep->name, (xmlChar *)local)) {
1355 				if (ns_match_any || (ns[0] == '\0' && nodep->ns == NULL) || (nodep->ns != NULL && xmlStrEqual(nodep->ns->href, (xmlChar *)ns))) {
1356 					if (*cur == index) {
1357 						ret = nodep;
1358 						break;
1359 					}
1360 					(*cur)++;
1361 				}
1362 			}
1363 
1364 			if (nodep->children) {
1365 				nodep = nodep->children;
1366 				continue;
1367 			}
1368 		}
1369 
1370 		if (nodep->next) {
1371 			nodep = nodep->next;
1372 		} else {
1373 			/* Go upwards, until we find a parent node with a next sibling, or until we hit the base. */
1374 			do {
1375 				nodep = nodep->parent;
1376 				if (nodep == basep) {
1377 					return NULL;
1378 				}
1379 				/* This shouldn't happen, unless there's an invalidation bug somewhere. */
1380 				if (UNEXPECTED(nodep == NULL)) {
1381 					zend_throw_error(NULL, "Current node in traversal is not in the document. Please report this as a bug in php-src.");
1382 					return NULL;
1383 				}
1384 			} while (nodep->next == NULL);
1385 			nodep = nodep->next;
1386 		}
1387 	}
1388 	return ret;
1389 }
1390 /* }}} end dom_element_get_elements_by_tag_name_ns_raw */
1391 
is_empty_node(xmlNodePtr nodep)1392 static inline bool is_empty_node(xmlNodePtr nodep)
1393 {
1394 	xmlChar	*strContent = xmlNodeGetContent(nodep);
1395 	bool ret = strContent == NULL || *strContent == '\0';
1396 	xmlFree(strContent);
1397 	return ret;
1398 }
1399 
1400 /* {{{ void dom_normalize (xmlNodePtr nodep) */
dom_normalize(xmlNodePtr nodep)1401 void dom_normalize (xmlNodePtr nodep)
1402 {
1403 	xmlNodePtr child, nextp, newnextp;
1404 	xmlAttrPtr attr;
1405 	xmlChar	*strContent;
1406 
1407 	child = nodep->children;
1408 	while(child != NULL) {
1409 		switch (child->type) {
1410 			case XML_TEXT_NODE:
1411 				nextp = child->next;
1412 				while (nextp != NULL) {
1413 					if (nextp->type == XML_TEXT_NODE) {
1414 						newnextp = nextp->next;
1415 						strContent = xmlNodeGetContent(nextp);
1416 						xmlNodeAddContent(child, strContent);
1417 						xmlFree(strContent);
1418 						xmlUnlinkNode(nextp);
1419 						php_libxml_node_free_resource(nextp);
1420 						nextp = newnextp;
1421 					} else {
1422 						break;
1423 					}
1424 				}
1425 				if (is_empty_node(child)) {
1426 					nextp = child->next;
1427 					xmlUnlinkNode(child);
1428 					php_libxml_node_free_resource(child);
1429 					child = nextp;
1430 					continue;
1431 				}
1432 				break;
1433 			case XML_ELEMENT_NODE:
1434 				dom_normalize (child);
1435 				attr = child->properties;
1436 				while (attr != NULL) {
1437 					dom_normalize((xmlNodePtr) attr);
1438 					attr = attr->next;
1439 				}
1440 				break;
1441 			case XML_ATTRIBUTE_NODE:
1442 				dom_normalize (child);
1443 				break;
1444 			default:
1445 				break;
1446 		}
1447 		child = child->next;
1448 	}
1449 }
1450 /* }}} end dom_normalize */
1451 
dom_reconcile_ns_internal(xmlDocPtr doc,xmlNodePtr nodep,xmlNodePtr search_parent)1452 static void dom_reconcile_ns_internal(xmlDocPtr doc, xmlNodePtr nodep, xmlNodePtr search_parent)
1453 {
1454 	xmlNsPtr nsptr, nsdftptr, curns, prevns = NULL;
1455 
1456 	/* Following if block primarily used for inserting nodes created via createElementNS */
1457 	if (nodep->nsDef != NULL) {
1458 		curns = nodep->nsDef;
1459 		while (curns) {
1460 			nsdftptr = curns->next;
1461 			if (curns->href != NULL) {
1462 				if((nsptr = xmlSearchNsByHref(doc, search_parent, curns->href)) &&
1463 					(curns->prefix == NULL || xmlStrEqual(nsptr->prefix, curns->prefix))) {
1464 					curns->next = NULL;
1465 					if (prevns == NULL) {
1466 						nodep->nsDef = nsdftptr;
1467 					} else {
1468 						prevns->next = nsdftptr;
1469 					}
1470 					/* Note: we can't get here if the ns is already on the oldNs list.
1471 					 * This is because in that case the definition won't be on the node, and
1472 					 * therefore won't be in the nodep->nsDef list. */
1473 					php_libxml_set_old_ns(doc, curns);
1474 					curns = prevns;
1475 				}
1476 			}
1477 			prevns = curns;
1478 			curns = nsdftptr;
1479 		}
1480 	}
1481 }
1482 
dom_libxml_reconcile_ensure_namespaces_are_declared(xmlNodePtr nodep)1483 static void dom_libxml_reconcile_ensure_namespaces_are_declared(xmlNodePtr nodep)
1484 {
1485 	/* Ideally we'd use the DOM-wrapped version, but we cannot: https://github.com/php/php-src/pull/12308. */
1486 #if 0
1487 	/* Put on stack to avoid allocation.
1488 	 * Although libxml2 currently does not use this for the reconciliation, it still
1489 	 * makes sense to do this just in case libxml2's internal change in the future. */
1490 	xmlDOMWrapCtxt dummy_ctxt = {0};
1491 	xmlDOMWrapReconcileNamespaces(&dummy_ctxt, nodep, /* options */ 0);
1492 #else
1493 	xmlReconciliateNs(nodep->doc, nodep);
1494 #endif
1495 }
1496 
dom_reconcile_ns(xmlDocPtr doc,xmlNodePtr nodep)1497 void dom_reconcile_ns(xmlDocPtr doc, xmlNodePtr nodep) /* {{{ */
1498 {
1499 	/* Although the node type will be checked by the libxml2 API,
1500 	 * we still want to do the internal reconciliation conditionally. */
1501 	if (nodep->type == XML_ELEMENT_NODE) {
1502 		dom_reconcile_ns_internal(doc, nodep, nodep->parent);
1503 		dom_libxml_reconcile_ensure_namespaces_are_declared(nodep);
1504 	}
1505 }
1506 /* }}} */
1507 
dom_reconcile_ns_list_internal(xmlDocPtr doc,xmlNodePtr nodep,xmlNodePtr last,xmlNodePtr search_parent)1508 static void dom_reconcile_ns_list_internal(xmlDocPtr doc, xmlNodePtr nodep, xmlNodePtr last, xmlNodePtr search_parent)
1509 {
1510 	ZEND_ASSERT(nodep != NULL);
1511 	while (true) {
1512 		if (nodep->type == XML_ELEMENT_NODE) {
1513 			dom_reconcile_ns_internal(doc, nodep, search_parent);
1514 			if (nodep->children) {
1515 				dom_reconcile_ns_list_internal(doc, nodep->children, nodep->last /* process the whole children list */, search_parent);
1516 			}
1517 		}
1518 		if (nodep == last) {
1519 			break;
1520 		}
1521 		nodep = nodep->next;
1522 	}
1523 }
1524 
dom_reconcile_ns_list(xmlDocPtr doc,xmlNodePtr nodep,xmlNodePtr last)1525 void dom_reconcile_ns_list(xmlDocPtr doc, xmlNodePtr nodep, xmlNodePtr last)
1526 {
1527 	dom_reconcile_ns_list_internal(doc, nodep, last, nodep->parent);
1528 	/* The loop is outside of the recursion in the above call because
1529 	 * dom_libxml_reconcile_ensure_namespaces_are_declared() performs its own recursion. */
1530 	while (true) {
1531 		/* The internal libxml2 call will already check the node type, no need for us to do it here. */
1532 		dom_libxml_reconcile_ensure_namespaces_are_declared(nodep);
1533 		if (nodep == last) {
1534 			break;
1535 		}
1536 		nodep = nodep->next;
1537 	}
1538 }
1539 
1540 /*
1541 http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1542 
1543 NAMESPACE_ERR: Raised if
1544 
1545 1. the qualifiedName is a malformed qualified name
1546 2. the qualifiedName has a prefix and the  namespaceURI is null
1547 */
1548 
1549 /* {{{ int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) */
dom_check_qname(char * qname,char ** localname,char ** prefix,int uri_len,int name_len)1550 int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) {
1551 	if (name_len == 0) {
1552 		return NAMESPACE_ERR;
1553 	}
1554 
1555 	*localname = (char *)xmlSplitQName2((xmlChar *)qname, (xmlChar **) prefix);
1556 	if (*localname == NULL) {
1557 		*localname = (char *)xmlStrdup((xmlChar *)qname);
1558 		if (*prefix == NULL && uri_len == 0) {
1559 			return 0;
1560 		}
1561 	}
1562 
1563 	/* 1 */
1564 	if (xmlValidateQName((xmlChar *) qname, 0) != 0) {
1565 		return NAMESPACE_ERR;
1566 	}
1567 
1568 	/* 2 */
1569 	if (*prefix != NULL && uri_len == 0) {
1570 		return NAMESPACE_ERR;
1571 	}
1572 
1573 	return 0;
1574 }
1575 /* }}} */
1576 
1577 /* Creates a new namespace declaration with a random prefix with the given uri on the tree.
1578  * This is used to resolve a namespace prefix conflict in cases where spec does not want a
1579  * namespace error in case of conflicts, but demands a resolution. */
dom_get_ns_resolve_prefix_conflict(xmlNodePtr tree,const char * uri)1580 xmlNsPtr dom_get_ns_resolve_prefix_conflict(xmlNodePtr tree, const char *uri)
1581 {
1582 	ZEND_ASSERT(tree != NULL);
1583 	xmlDocPtr doc = tree->doc;
1584 
1585 	if (UNEXPECTED(doc == NULL)) {
1586 		return NULL;
1587 	}
1588 
1589 	/* Code adapted from libxml2 (2.10.4) */
1590 	char prefix[50];
1591 	int counter = 1;
1592 	snprintf(prefix, sizeof(prefix), "default");
1593 	xmlNsPtr nsptr = xmlSearchNs(doc, tree, (const xmlChar *) prefix);
1594 	while (nsptr != NULL) {
1595 		if (counter > 1000) {
1596 			return NULL;
1597 		}
1598 		snprintf(prefix, sizeof(prefix), "default%d", counter++);
1599 		nsptr = xmlSearchNs(doc, tree, (const xmlChar *) prefix);
1600 	}
1601 
1602 	/* Search yielded no conflict */
1603 	return xmlNewNs(tree, (const xmlChar *) uri, (const xmlChar *) prefix);
1604 }
1605 
1606 /*
1607 http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1608 
1609 NAMESPACE_ERR: Raised if
1610 
1611 3. the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace" [XML Namespaces]
1612 4. the qualifiedName or its prefix is "xmlns" and the namespaceURI is different from  "http://www.w3.org/2000/xmlns/"
1613 5. the namespaceURI is "http://www.w3.org/2000/xmlns/" and neither the	qualifiedName nor its prefix is "xmlns".
1614 */
1615 
dom_get_ns_unchecked(xmlNodePtr nodep,char * uri,char * prefix)1616 xmlNsPtr dom_get_ns_unchecked(xmlNodePtr nodep, char *uri, char *prefix)
1617 {
1618 	xmlNsPtr nsptr = xmlNewNs(nodep, (xmlChar *)uri, (xmlChar *)prefix);
1619 	if (UNEXPECTED(nsptr == NULL)) {
1620 		/* Either memory allocation failure, or it's because of a prefix conflict.
1621 		 * We'll assume a conflict and try again. If it was a memory allocation failure we'll just fail again, whatever.
1622 		 * This isn't needed for every caller (such as createElementNS & DOMElement::__construct), but isn't harmful and simplifies the mental model "when do I use which function?".
1623 		 * This branch will also be taken unlikely anyway as in those cases it'll be for allocation failure. */
1624 		return dom_get_ns_resolve_prefix_conflict(nodep, uri);
1625 	}
1626 
1627 	return nsptr;
1628 }
1629 
1630 /* {{{ xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) */
dom_get_ns(xmlNodePtr nodep,char * uri,int * errorcode,char * prefix)1631 xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) {
1632 	xmlNsPtr nsptr;
1633 
1634 	if (! ((prefix && !strcmp (prefix, "xml") && strcmp(uri, (char *)XML_XML_NAMESPACE)) ||
1635 		   (prefix && !strcmp (prefix, "xmlns") && strcmp(uri, (char *)DOM_XMLNS_NAMESPACE)) ||
1636 		   (prefix && !strcmp(uri, (char *)DOM_XMLNS_NAMESPACE) && strcmp (prefix, "xmlns")))) {
1637 		nsptr = dom_get_ns_unchecked(nodep, uri, prefix);
1638 		if (UNEXPECTED(nsptr == NULL)) {
1639 			goto err;
1640 		}
1641 	} else {
1642 		goto err;
1643 	}
1644 
1645 	*errorcode = 0;
1646 	return nsptr;
1647 err:
1648 	*errorcode = NAMESPACE_ERR;
1649 	return NULL;
1650 }
1651 /* }}} end dom_get_ns */
1652 
1653 /* {{{ xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) */
dom_get_nsdecl(xmlNode * node,xmlChar * localName)1654 xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) {
1655 	xmlNsPtr cur;
1656 	xmlNs *ret = NULL;
1657 	if (node == NULL)
1658 		return NULL;
1659 
1660 	if (localName == NULL || localName[0] == '\0') {
1661 		cur = node->nsDef;
1662 		while (cur != NULL) {
1663 			if (cur->prefix == NULL  && cur->href != NULL) {
1664 				ret = cur;
1665 				break;
1666 			}
1667 			cur = cur->next;
1668 		}
1669 	} else {
1670 		cur = node->nsDef;
1671 		while (cur != NULL) {
1672 			if (cur->prefix != NULL && xmlStrEqual(localName, cur->prefix)) {
1673 				ret = cur;
1674 				break;
1675 			}
1676 			cur = cur->next;
1677 		}
1678 	}
1679 	return ret;
1680 }
1681 /* }}} end dom_get_nsdecl */
1682 
php_dom_create_fake_namespace_decl_node_ptr(xmlNodePtr nodep,xmlNsPtr original)1683 static xmlNodePtr php_dom_create_fake_namespace_decl_node_ptr(xmlNodePtr nodep, xmlNsPtr original)
1684 {
1685 	xmlNodePtr attrp;
1686 	xmlNsPtr curns = xmlNewNs(NULL, original->href, NULL);
1687 	if (original->prefix) {
1688 		curns->prefix = xmlStrdup(original->prefix);
1689 		attrp = xmlNewDocNode(nodep->doc, NULL, (xmlChar *) original->prefix, original->href);
1690 	} else {
1691 		attrp = xmlNewDocNode(nodep->doc, NULL, (xmlChar *)"xmlns", original->href);
1692 	}
1693 	attrp->type = XML_NAMESPACE_DECL;
1694 	attrp->parent = nodep;
1695 	attrp->ns = curns;
1696 	return attrp;
1697 }
1698 
1699 /* Note: Assumes the additional lifetime was already added in the caller. */
php_dom_create_fake_namespace_decl(xmlNodePtr nodep,xmlNsPtr original,zval * return_value,dom_object * parent_intern)1700 xmlNodePtr php_dom_create_fake_namespace_decl(xmlNodePtr nodep, xmlNsPtr original, zval *return_value, dom_object *parent_intern)
1701 {
1702 	xmlNodePtr attrp = php_dom_create_fake_namespace_decl_node_ptr(nodep, original);
1703 	php_dom_create_object(attrp, return_value, parent_intern);
1704 	/* This object must exist, because we just created an object for it via php_dom_create_object(). */
1705 	php_dom_namespace_node_obj_from_obj(Z_OBJ_P(return_value))->parent_intern = parent_intern;
1706 	return attrp;
1707 }
1708 
dom_nodemap_or_nodelist_process_offset_as_named(zval * offset,zend_long * lval)1709 static bool dom_nodemap_or_nodelist_process_offset_as_named(zval *offset, zend_long *lval)
1710 {
1711 	if (Z_TYPE_P(offset) == IS_STRING) {
1712 		/* See zval_get_long_func() */
1713 		double dval;
1714 		zend_uchar is_numeric_string_type;
1715 		if (0 == (is_numeric_string_type = is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), lval, &dval, true))) {
1716 			return true;
1717 		} else if (is_numeric_string_type == IS_DOUBLE) {
1718 			*lval = zend_dval_to_lval_cap(dval);
1719 		}
1720 	} else {
1721 		*lval = zval_get_long(offset);
1722 	}
1723 	return false;
1724 }
1725 
dom_nodelist_read_dimension(zend_object * object,zval * offset,int type,zval * rv)1726 static zval *dom_nodelist_read_dimension(zend_object *object, zval *offset, int type, zval *rv) /* {{{ */
1727 {
1728 	if (UNEXPECTED(!offset)) {
1729 		zend_throw_error(NULL, "Cannot access DOMNodeList without offset");
1730 		return NULL;
1731 	}
1732 
1733 	ZVAL_DEREF(offset);
1734 
1735 	zend_long lval;
1736 	if (dom_nodemap_or_nodelist_process_offset_as_named(offset, &lval)) {
1737 		/* does not support named lookup */
1738 		ZVAL_NULL(rv);
1739 		return rv;
1740 	}
1741 
1742 	php_dom_nodelist_get_item_into_zval(php_dom_obj_from_obj(object)->ptr, lval, rv);
1743 	return rv;
1744 } /* }}} end dom_nodelist_read_dimension */
1745 
dom_nodelist_has_dimension(zend_object * object,zval * member,int check_empty)1746 static int dom_nodelist_has_dimension(zend_object *object, zval *member, int check_empty)
1747 {
1748 	ZVAL_DEREF(member);
1749 
1750 	zend_long offset;
1751 	if (dom_nodemap_or_nodelist_process_offset_as_named(member, &offset)) {
1752 		/* does not support named lookup */
1753 		return 0;
1754 	}
1755 
1756 	return offset >= 0 && offset < php_dom_get_nodelist_length(php_dom_obj_from_obj(object));
1757 } /* }}} end dom_nodelist_has_dimension */
1758 
dom_remove_all_children(xmlNodePtr nodep)1759 void dom_remove_all_children(xmlNodePtr nodep)
1760 {
1761 	if (nodep->children) {
1762 		node_list_unlink(nodep->children);
1763 		php_libxml_node_free_list((xmlNodePtr) nodep->children);
1764 		nodep->children = NULL;
1765 		nodep->last = NULL;
1766 	}
1767 }
1768 
php_dom_get_content_into_zval(const xmlNode * nodep,zval * retval,bool default_is_null)1769 void php_dom_get_content_into_zval(const xmlNode *nodep, zval *retval, bool default_is_null)
1770 {
1771 	ZEND_ASSERT(nodep != NULL);
1772 
1773 	if (nodep->type == XML_TEXT_NODE
1774 		|| nodep->type == XML_CDATA_SECTION_NODE
1775 		|| nodep->type == XML_PI_NODE
1776 		|| nodep->type == XML_COMMENT_NODE) {
1777 		char *str = (char * ) nodep->content;
1778 		if (str != NULL) {
1779 			ZVAL_STRING(retval, str);
1780 		} else {
1781 			goto failure;
1782 		}
1783 		return;
1784 	}
1785 
1786 	char *str = (char *) xmlNodeGetContent(nodep);
1787 
1788 	if (str != NULL) {
1789 		ZVAL_STRING(retval, str);
1790 		xmlFree(str);
1791 		return;
1792 	}
1793 
1794 failure:
1795 	if (default_is_null) {
1796 		ZVAL_NULL(retval);
1797 	} else {
1798 		ZVAL_EMPTY_STRING(retval);
1799 	}
1800 }
1801 
dom_nodemap_read_dimension(zend_object * object,zval * offset,int type,zval * rv)1802 static zval *dom_nodemap_read_dimension(zend_object *object, zval *offset, int type, zval *rv) /* {{{ */
1803 {
1804 	if (UNEXPECTED(!offset)) {
1805 		zend_throw_error(NULL, "Cannot access DOMNamedNodeMap without offset");
1806 		return NULL;
1807 	}
1808 
1809 	ZVAL_DEREF(offset);
1810 
1811 	zend_long lval;
1812 	if (dom_nodemap_or_nodelist_process_offset_as_named(offset, &lval)) {
1813 		/* exceptional case, switch to named lookup */
1814 		php_dom_named_node_map_get_named_item_into_zval(php_dom_obj_from_obj(object)->ptr, Z_STRVAL_P(offset), rv);
1815 		return rv;
1816 	}
1817 
1818 	/* see PHP_METHOD(DOMNamedNodeMap, item) */
1819 	if (UNEXPECTED(lval < 0 || ZEND_LONG_INT_OVFL(lval))) {
1820 		zend_value_error("must be between 0 and %d", INT_MAX);
1821 		return NULL;
1822 	}
1823 
1824 	php_dom_named_node_map_get_item_into_zval(php_dom_obj_from_obj(object)->ptr, lval, rv);
1825 	return rv;
1826 } /* }}} end dom_nodemap_read_dimension */
1827 
dom_nodemap_has_dimension(zend_object * object,zval * member,int check_empty)1828 static int dom_nodemap_has_dimension(zend_object *object, zval *member, int check_empty)
1829 {
1830 	ZVAL_DEREF(member);
1831 
1832 	zend_long offset;
1833 	if (dom_nodemap_or_nodelist_process_offset_as_named(member, &offset)) {
1834 		/* exceptional case, switch to named lookup */
1835 		return php_dom_named_node_map_get_named_item(php_dom_obj_from_obj(object)->ptr, Z_STRVAL_P(member), false) != NULL;
1836 	}
1837 
1838 	return offset >= 0 && offset < php_dom_get_namednodemap_length(php_dom_obj_from_obj(object));
1839 } /* }}} end dom_nodemap_has_dimension */
1840 
1841 #endif /* HAVE_DOM */
1842