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 static zend_object *dom_nodelist_objects_new(zend_class_entry *class_type);
96
97 typedef int (*dom_read_t)(dom_object *obj, zval *retval);
98 typedef int (*dom_write_t)(dom_object *obj, zval *newval);
99
100 typedef struct _dom_prop_handler {
101 dom_read_t read_func;
102 dom_write_t write_func;
103 } dom_prop_handler;
104
dom_get_obj_handlers(void)105 static zend_object_handlers* dom_get_obj_handlers(void) {
106 return &dom_object_handlers;
107 }
108
109 /* {{{ int dom_node_is_read_only(xmlNodePtr node) */
dom_node_is_read_only(xmlNodePtr node)110 int dom_node_is_read_only(xmlNodePtr node) {
111 switch (node->type) {
112 case XML_ENTITY_REF_NODE:
113 case XML_ENTITY_NODE:
114 case XML_DOCUMENT_TYPE_NODE:
115 case XML_NOTATION_NODE:
116 case XML_DTD_NODE:
117 case XML_ELEMENT_DECL:
118 case XML_ATTRIBUTE_DECL:
119 case XML_ENTITY_DECL:
120 case XML_NAMESPACE_DECL:
121 return SUCCESS;
122 break;
123 default:
124 if (node->doc == NULL) {
125 return SUCCESS;
126 } else {
127 return FAILURE;
128 }
129 }
130 }
131 /* }}} end dom_node_is_read_only */
132
133 /* {{{ int dom_node_children_valid(xmlNodePtr node) */
dom_node_children_valid(xmlNodePtr node)134 int dom_node_children_valid(xmlNodePtr node) {
135 switch (node->type) {
136 case XML_DOCUMENT_TYPE_NODE:
137 case XML_DTD_NODE:
138 case XML_PI_NODE:
139 case XML_COMMENT_NODE:
140 case XML_TEXT_NODE:
141 case XML_CDATA_SECTION_NODE:
142 case XML_NOTATION_NODE:
143 return FAILURE;
144 break;
145 default:
146 return SUCCESS;
147 }
148 }
149 /* }}} end dom_node_children_valid */
150
151 /* {{{ dom_get_doc_props() */
dom_get_doc_props(php_libxml_ref_obj * document)152 dom_doc_propsptr dom_get_doc_props(php_libxml_ref_obj *document)
153 {
154 dom_doc_propsptr doc_props;
155
156 if (document && document->doc_props) {
157 return document->doc_props;
158 } else {
159 doc_props = emalloc(sizeof(libxml_doc_props));
160 doc_props->formatoutput = 0;
161 doc_props->validateonparse = 0;
162 doc_props->resolveexternals = 0;
163 doc_props->preservewhitespace = 1;
164 doc_props->substituteentities = 0;
165 doc_props->stricterror = 1;
166 doc_props->recover = 0;
167 doc_props->classmap = NULL;
168 if (document) {
169 document->doc_props = doc_props;
170 }
171 return doc_props;
172 }
173 }
174
dom_copy_doc_props(php_libxml_ref_obj * source_doc,php_libxml_ref_obj * dest_doc)175 static void dom_copy_doc_props(php_libxml_ref_obj *source_doc, php_libxml_ref_obj *dest_doc)
176 {
177 dom_doc_propsptr source, dest;
178
179 if (source_doc && dest_doc) {
180
181 source = dom_get_doc_props(source_doc);
182 dest = dom_get_doc_props(dest_doc);
183
184 dest->formatoutput = source->formatoutput;
185 dest->validateonparse = source->validateonparse;
186 dest->resolveexternals = source->resolveexternals;
187 dest->preservewhitespace = source->preservewhitespace;
188 dest->substituteentities = source->substituteentities;
189 dest->stricterror = source->stricterror;
190 dest->recover = source->recover;
191 if (source->classmap) {
192 ALLOC_HASHTABLE(dest->classmap);
193 zend_hash_init(dest->classmap, 0, NULL, NULL, 0);
194 zend_hash_copy(dest->classmap, source->classmap, NULL);
195 }
196
197 }
198 }
199
dom_set_doc_classmap(php_libxml_ref_obj * document,zend_class_entry * basece,zend_class_entry * ce)200 void dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece, zend_class_entry *ce)
201 {
202 dom_doc_propsptr doc_props;
203
204 if (document) {
205 doc_props = dom_get_doc_props(document);
206 if (doc_props->classmap == NULL) {
207 if (ce == NULL) {
208 return;
209 }
210 ALLOC_HASHTABLE(doc_props->classmap);
211 zend_hash_init(doc_props->classmap, 0, NULL, NULL, 0);
212 }
213 if (ce) {
214 zend_hash_update_ptr(doc_props->classmap, basece->name, ce);
215 } else {
216 zend_hash_del(doc_props->classmap, basece->name);
217 }
218 }
219 }
220
dom_get_doc_classmap(php_libxml_ref_obj * document,zend_class_entry * basece)221 zend_class_entry *dom_get_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece)
222 {
223 dom_doc_propsptr doc_props;
224
225 if (document) {
226 doc_props = dom_get_doc_props(document);
227 if (doc_props->classmap) {
228 zend_class_entry *ce = zend_hash_find_ptr(doc_props->classmap, basece->name);
229 if (ce) {
230 return ce;
231 }
232 }
233 }
234
235 return basece;
236 }
237 /* }}} */
238
239 /* {{{ dom_get_strict_error() */
dom_get_strict_error(php_libxml_ref_obj * document)240 int dom_get_strict_error(php_libxml_ref_obj *document) {
241 int stricterror;
242 dom_doc_propsptr doc_props;
243
244 doc_props = dom_get_doc_props(document);
245 stricterror = doc_props->stricterror;
246 if (document == NULL) {
247 efree(doc_props);
248 }
249
250 return stricterror;
251 }
252 /* }}} */
253
254 /* {{{ xmlNodePtr dom_object_get_node(dom_object *obj) */
dom_object_get_node(dom_object * obj)255 PHP_DOM_EXPORT xmlNodePtr dom_object_get_node(dom_object *obj)
256 {
257 if (obj && obj->ptr != NULL) {
258 return ((php_libxml_node_ptr *)obj->ptr)->node;
259 } else {
260 return NULL;
261 }
262 }
263 /* }}} end dom_object_get_node */
264
265 /* {{{ dom_object *php_dom_object_get_data(xmlNodePtr obj) */
php_dom_object_get_data(xmlNodePtr obj)266 PHP_DOM_EXPORT dom_object *php_dom_object_get_data(xmlNodePtr obj)
267 {
268 if (obj && obj->_private != NULL) {
269 return (dom_object *) ((php_libxml_node_ptr *) obj->_private)->_private;
270 } else {
271 return NULL;
272 }
273 }
274 /* }}} end php_dom_object_get_data */
275
dom_register_prop_handler(HashTable * prop_handler,char * name,size_t name_len,dom_read_t read_func,dom_write_t write_func)276 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)
277 {
278 dom_prop_handler hnd;
279 zend_string *str;
280
281 hnd.read_func = read_func;
282 hnd.write_func = write_func;
283 str = zend_string_init_interned(name, name_len, 1);
284 zend_hash_add_mem(prop_handler, str, &hnd, sizeof(dom_prop_handler));
285 zend_string_release_ex(str, 1);
286 }
287
dom_override_prop_handler(HashTable * prop_handler,char * name,size_t name_len,dom_read_t read_func,dom_write_t write_func)288 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)
289 {
290 dom_prop_handler hnd;
291 hnd.read_func = read_func;
292 hnd.write_func = write_func;
293 zend_hash_str_update_mem(prop_handler, name, name_len, &hnd, sizeof(dom_prop_handler));
294 }
295
dom_get_property_ptr_ptr(zend_object * object,zend_string * name,int type,void ** cache_slot)296 static zval *dom_get_property_ptr_ptr(zend_object *object, zend_string *name, int type, void **cache_slot)
297 {
298 dom_object *obj = php_dom_obj_from_obj(object);
299
300 if (!obj->prop_handler || !zend_hash_exists(obj->prop_handler, name)) {
301 return zend_std_get_property_ptr_ptr(object, name, type, cache_slot);
302 }
303
304 return NULL;
305 }
306
307 /* {{{ dom_read_property */
dom_read_property(zend_object * object,zend_string * name,int type,void ** cache_slot,zval * rv)308 zval *dom_read_property(zend_object *object, zend_string *name, int type, void **cache_slot, zval *rv)
309 {
310 dom_object *obj = php_dom_obj_from_obj(object);
311 zval *retval;
312 dom_prop_handler *hnd = NULL;
313
314 if (obj->prop_handler != NULL) {
315 hnd = zend_hash_find_ptr(obj->prop_handler, name);
316 } else if (instanceof_function(obj->std.ce, dom_node_class_entry)) {
317 zend_throw_error(NULL, "Couldn't fetch %s. Node no longer exists", ZSTR_VAL(obj->std.ce->name));
318 retval = &EG(uninitialized_zval);
319 return retval;
320 }
321
322 if (hnd) {
323 int ret = hnd->read_func(obj, rv);
324 if (ret == SUCCESS) {
325 retval = rv;
326 } else {
327 retval = &EG(uninitialized_zval);
328 }
329 } else {
330 retval = zend_std_read_property(object, name, type, cache_slot, rv);
331 }
332
333 return retval;
334 }
335 /* }}} */
336
dom_write_property(zend_object * object,zend_string * name,zval * value,void ** cache_slot)337 zval *dom_write_property(zend_object *object, zend_string *name, zval *value, void **cache_slot)
338 {
339 dom_object *obj = php_dom_obj_from_obj(object);
340 dom_prop_handler *hnd = NULL;
341
342 if (obj->prop_handler != NULL) {
343 hnd = zend_hash_find_ptr(obj->prop_handler, name);
344 }
345
346 if (hnd) {
347 if (!hnd->write_func) {
348 zend_throw_error(NULL, "Cannot write read-only property %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name));
349 return &EG(error_zval);
350 }
351
352 zend_property_info *prop = zend_get_property_info(object->ce, name, /* silent */ true);
353 if (prop && ZEND_TYPE_IS_SET(prop->type)) {
354 zval tmp;
355 ZVAL_COPY(&tmp, value);
356 if (!zend_verify_property_type(prop, &tmp, ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data)))) {
357 zval_ptr_dtor(&tmp);
358 return &EG(error_zval);
359 }
360 hnd->write_func(obj, &tmp);
361 zval_ptr_dtor(&tmp);
362 } else {
363 hnd->write_func(obj, value);
364 }
365
366 return value;
367 }
368
369 return zend_std_write_property(object, name, value, cache_slot);
370 }
371
372 /* {{{ dom_property_exists */
dom_property_exists(zend_object * object,zend_string * name,int check_empty,void ** cache_slot)373 static int dom_property_exists(zend_object *object, zend_string *name, int check_empty, void **cache_slot)
374 {
375 dom_object *obj = php_dom_obj_from_obj(object);
376 dom_prop_handler *hnd = NULL;
377 int retval = 0;
378
379 if (obj->prop_handler != NULL) {
380 hnd = zend_hash_find_ptr(obj->prop_handler, name);
381 }
382 if (hnd) {
383 zval tmp;
384
385 if (check_empty == 2) {
386 retval = 1;
387 } else if (hnd->read_func(obj, &tmp) == SUCCESS) {
388 if (check_empty == 1) {
389 retval = zend_is_true(&tmp);
390 } else if (check_empty == 0) {
391 retval = (Z_TYPE(tmp) != IS_NULL);
392 }
393 zval_ptr_dtor(&tmp);
394 }
395 } else {
396 retval = zend_std_has_property(object, name, check_empty, cache_slot);
397 }
398
399 return retval;
400 }
401 /* }}} */
402
dom_get_debug_info_helper(zend_object * object,int * is_temp)403 static HashTable* dom_get_debug_info_helper(zend_object *object, int *is_temp) /* {{{ */
404 {
405 dom_object *obj = php_dom_obj_from_obj(object);
406 HashTable *debug_info,
407 *prop_handlers = obj->prop_handler,
408 *std_props;
409 zend_string *string_key;
410 dom_prop_handler *entry;
411 zend_string *object_str;
412
413 *is_temp = 1;
414
415 std_props = zend_std_get_properties(object);
416 debug_info = zend_array_dup(std_props);
417
418 if (!prop_handlers) {
419 return debug_info;
420 }
421
422 object_str = zend_string_init("(object value omitted)", sizeof("(object value omitted)")-1, 0);
423
424 ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(prop_handlers, string_key, entry) {
425 zval value;
426
427 if (entry->read_func(obj, &value) == FAILURE || !string_key) {
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, "childNodes", sizeof("childNodes")-1, dom_node_child_nodes_read, NULL);
645 dom_register_prop_handler(&dom_node_prop_handlers, "firstChild", sizeof("firstChild")-1, dom_node_first_child_read, NULL);
646 dom_register_prop_handler(&dom_node_prop_handlers, "lastChild", sizeof("lastChild")-1, dom_node_last_child_read, NULL);
647 dom_register_prop_handler(&dom_node_prop_handlers, "previousSibling", sizeof("previousSibling")-1, dom_node_previous_sibling_read, NULL);
648 dom_register_prop_handler(&dom_node_prop_handlers, "nextSibling", sizeof("nextSibling")-1, dom_node_next_sibling_read, NULL);
649 dom_register_prop_handler(&dom_node_prop_handlers, "attributes", sizeof("attributes")-1, dom_node_attributes_read, NULL);
650 dom_register_prop_handler(&dom_node_prop_handlers, "ownerDocument", sizeof("ownerDocument")-1, dom_node_owner_document_read, NULL);
651 dom_register_prop_handler(&dom_node_prop_handlers, "namespaceURI", sizeof("namespaceURI")-1, dom_node_namespace_uri_read, NULL);
652 dom_register_prop_handler(&dom_node_prop_handlers, "prefix", sizeof("prefix")-1, dom_node_prefix_read, dom_node_prefix_write);
653 dom_register_prop_handler(&dom_node_prop_handlers, "localName", sizeof("localName")-1, dom_node_local_name_read, NULL);
654 dom_register_prop_handler(&dom_node_prop_handlers, "baseURI", sizeof("baseURI")-1, dom_node_base_uri_read, NULL);
655 dom_register_prop_handler(&dom_node_prop_handlers, "textContent", sizeof("textContent")-1, dom_node_text_content_read, dom_node_text_content_write);
656 zend_hash_add_ptr(&classes, dom_node_class_entry->name, &dom_node_prop_handlers);
657
658 dom_namespace_node_class_entry = register_class_DOMNameSpaceNode();
659 dom_namespace_node_class_entry->create_object = dom_objects_namespace_node_new;
660
661 zend_hash_init(&dom_namespace_node_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
662 dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeName", sizeof("nodeName")-1, dom_node_node_name_read, NULL);
663 dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeValue", sizeof("nodeValue")-1, dom_node_node_value_read, NULL);
664 dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeType", sizeof("nodeType")-1, dom_node_node_type_read, NULL);
665 dom_register_prop_handler(&dom_namespace_node_prop_handlers, "prefix", sizeof("prefix")-1, dom_node_prefix_read, NULL);
666 dom_register_prop_handler(&dom_namespace_node_prop_handlers, "localName", sizeof("localName")-1, dom_node_local_name_read, NULL);
667 dom_register_prop_handler(&dom_namespace_node_prop_handlers, "namespaceURI", sizeof("namespaceURI")-1, dom_node_namespace_uri_read, NULL);
668 dom_register_prop_handler(&dom_namespace_node_prop_handlers, "ownerDocument", sizeof("ownerDocument")-1, dom_node_owner_document_read, NULL);
669 dom_register_prop_handler(&dom_namespace_node_prop_handlers, "parentNode", sizeof("parentNode")-1, dom_node_parent_node_read, NULL);
670 zend_hash_add_ptr(&classes, dom_namespace_node_class_entry->name, &dom_namespace_node_prop_handlers);
671
672 dom_documentfragment_class_entry = register_class_DOMDocumentFragment(dom_node_class_entry, dom_parentnode_class_entry);
673 dom_documentfragment_class_entry->create_object = dom_objects_new;
674 zend_hash_init(&dom_documentfragment_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
675
676 dom_register_prop_handler(&dom_documentfragment_prop_handlers, "firstElementChild", sizeof("firstElementChild")-1, dom_parent_node_first_element_child_read, NULL);
677 dom_register_prop_handler(&dom_documentfragment_prop_handlers, "lastElementChild", sizeof("lastElementChild")-1, dom_parent_node_last_element_child_read, NULL);
678 dom_register_prop_handler(&dom_documentfragment_prop_handlers, "childElementCount", sizeof("childElementCount")-1, dom_parent_node_child_element_count, NULL);
679
680 zend_hash_merge(&dom_documentfragment_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
681 zend_hash_add_ptr(&classes, dom_documentfragment_class_entry->name, &dom_documentfragment_prop_handlers);
682
683 dom_document_class_entry = register_class_DOMDocument(dom_node_class_entry, dom_parentnode_class_entry);
684 dom_document_class_entry->create_object = dom_objects_new;
685 zend_hash_init(&dom_document_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
686 dom_register_prop_handler(&dom_document_prop_handlers, "doctype", sizeof("doctype")-1, dom_document_doctype_read, NULL);
687 dom_register_prop_handler(&dom_document_prop_handlers, "implementation", sizeof("implementation")-1, dom_document_implementation_read, NULL);
688 dom_register_prop_handler(&dom_document_prop_handlers, "documentElement", sizeof("documentElement")-1, dom_document_document_element_read, NULL);
689 dom_register_prop_handler(&dom_document_prop_handlers, "actualEncoding", sizeof("actualEncoding")-1, dom_document_encoding_read, NULL);
690 dom_register_prop_handler(&dom_document_prop_handlers, "encoding", sizeof("encoding")-1, dom_document_encoding_read, dom_document_encoding_write);
691 dom_register_prop_handler(&dom_document_prop_handlers, "xmlEncoding", sizeof("xmlEncoding")-1, dom_document_encoding_read, NULL);
692 dom_register_prop_handler(&dom_document_prop_handlers, "standalone", sizeof("standalone")-1, dom_document_standalone_read, dom_document_standalone_write);
693 dom_register_prop_handler(&dom_document_prop_handlers, "xmlStandalone", sizeof("xmlStandalone")-1, dom_document_standalone_read, dom_document_standalone_write);
694 dom_register_prop_handler(&dom_document_prop_handlers, "version", sizeof("version")-1, dom_document_version_read, dom_document_version_write);
695 dom_register_prop_handler(&dom_document_prop_handlers, "xmlVersion", sizeof("xmlVersion")-1, dom_document_version_read, dom_document_version_write);
696 dom_register_prop_handler(&dom_document_prop_handlers, "strictErrorChecking", sizeof("strictErrorChecking")-1, dom_document_strict_error_checking_read, dom_document_strict_error_checking_write);
697 dom_register_prop_handler(&dom_document_prop_handlers, "documentURI", sizeof("documentURI")-1, dom_document_document_uri_read, dom_document_document_uri_write);
698 dom_register_prop_handler(&dom_document_prop_handlers, "config", sizeof("config")-1, dom_document_config_read, NULL);
699 dom_register_prop_handler(&dom_document_prop_handlers, "formatOutput", sizeof("formatOutput")-1, dom_document_format_output_read, dom_document_format_output_write);
700 dom_register_prop_handler(&dom_document_prop_handlers, "validateOnParse", sizeof("validateOnParse")-1, dom_document_validate_on_parse_read, dom_document_validate_on_parse_write);
701 dom_register_prop_handler(&dom_document_prop_handlers, "resolveExternals", sizeof("resolveExternals")-1, dom_document_resolve_externals_read, dom_document_resolve_externals_write);
702 dom_register_prop_handler(&dom_document_prop_handlers, "preserveWhiteSpace", sizeof("preserveWhitespace")-1, dom_document_preserve_whitespace_read, dom_document_preserve_whitespace_write);
703 dom_register_prop_handler(&dom_document_prop_handlers, "recover", sizeof("recover")-1, dom_document_recover_read, dom_document_recover_write);
704 dom_register_prop_handler(&dom_document_prop_handlers, "substituteEntities", sizeof("substituteEntities")-1, dom_document_substitue_entities_read, dom_document_substitue_entities_write);
705
706 dom_register_prop_handler(&dom_document_prop_handlers, "firstElementChild", sizeof("firstElementChild")-1, dom_parent_node_first_element_child_read, NULL);
707 dom_register_prop_handler(&dom_document_prop_handlers, "lastElementChild", sizeof("lastElementChild")-1, dom_parent_node_last_element_child_read, NULL);
708 dom_register_prop_handler(&dom_document_prop_handlers, "childElementCount", sizeof("childElementCount")-1, dom_parent_node_child_element_count, NULL);
709
710 zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
711 zend_hash_add_ptr(&classes, dom_document_class_entry->name, &dom_document_prop_handlers);
712
713 dom_nodelist_class_entry = register_class_DOMNodeList(zend_ce_aggregate, zend_ce_countable);
714 dom_nodelist_class_entry->create_object = dom_nodelist_objects_new;
715 dom_nodelist_class_entry->get_iterator = php_dom_get_iterator;
716
717 zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
718 dom_register_prop_handler(&dom_nodelist_prop_handlers, "length", sizeof("length")-1, dom_nodelist_length_read, NULL);
719 zend_hash_add_ptr(&classes, dom_nodelist_class_entry->name, &dom_nodelist_prop_handlers);
720
721 dom_namednodemap_class_entry = register_class_DOMNamedNodeMap(zend_ce_aggregate, zend_ce_countable);
722 dom_namednodemap_class_entry->create_object = dom_nnodemap_objects_new;
723 dom_namednodemap_class_entry->get_iterator = php_dom_get_iterator;
724
725 zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
726 dom_register_prop_handler(&dom_namednodemap_prop_handlers, "length", sizeof("length")-1, dom_namednodemap_length_read, NULL);
727 zend_hash_add_ptr(&classes, dom_namednodemap_class_entry->name, &dom_namednodemap_prop_handlers);
728
729 dom_characterdata_class_entry = register_class_DOMCharacterData(dom_node_class_entry, dom_childnode_class_entry);
730 dom_characterdata_class_entry->create_object = dom_objects_new;
731
732 zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
733 dom_register_prop_handler(&dom_characterdata_prop_handlers, "data", sizeof("data")-1, dom_characterdata_data_read, dom_characterdata_data_write);
734 dom_register_prop_handler(&dom_characterdata_prop_handlers, "length", sizeof("length")-1, dom_characterdata_length_read, NULL);
735 dom_register_prop_handler(&dom_characterdata_prop_handlers, "previousElementSibling", sizeof("previousElementSibling")-1, dom_node_previous_element_sibling_read, NULL);
736 dom_register_prop_handler(&dom_characterdata_prop_handlers, "nextElementSibling", sizeof("nextElementSibling")-1, dom_node_next_element_sibling_read, NULL);
737 zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
738 zend_hash_add_ptr(&classes, dom_characterdata_class_entry->name, &dom_characterdata_prop_handlers);
739
740 dom_attr_class_entry = register_class_DOMAttr(dom_node_class_entry);
741 dom_attr_class_entry->create_object = dom_objects_new;
742
743 zend_hash_init(&dom_attr_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
744 dom_register_prop_handler(&dom_attr_prop_handlers, "name", sizeof("name")-1, dom_attr_name_read, NULL);
745 dom_register_prop_handler(&dom_attr_prop_handlers, "specified", sizeof("specified")-1, dom_attr_specified_read, NULL);
746 dom_register_prop_handler(&dom_attr_prop_handlers, "value", sizeof("value")-1, dom_attr_value_read, dom_attr_value_write);
747 dom_register_prop_handler(&dom_attr_prop_handlers, "ownerElement", sizeof("ownerElement")-1, dom_attr_owner_element_read, NULL);
748 dom_register_prop_handler(&dom_attr_prop_handlers, "schemaTypeInfo", sizeof("schemaTypeInfo")-1, dom_attr_schema_type_info_read, NULL);
749 zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
750 zend_hash_add_ptr(&classes, dom_attr_class_entry->name, &dom_attr_prop_handlers);
751
752 dom_element_class_entry = register_class_DOMElement(dom_node_class_entry, dom_parentnode_class_entry, dom_childnode_class_entry);
753 dom_element_class_entry->create_object = dom_objects_new;
754
755 zend_hash_init(&dom_element_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
756 dom_register_prop_handler(&dom_element_prop_handlers, "tagName", sizeof("tagName")-1, dom_element_tag_name_read, NULL);
757 dom_register_prop_handler(&dom_element_prop_handlers, "schemaTypeInfo", sizeof("schemaTypeInfo")-1, dom_element_schema_type_info_read, NULL);
758 dom_register_prop_handler(&dom_element_prop_handlers, "firstElementChild", sizeof("firstElementChild")-1, dom_parent_node_first_element_child_read, NULL);
759 dom_register_prop_handler(&dom_element_prop_handlers, "lastElementChild", sizeof("lastElementChild")-1, dom_parent_node_last_element_child_read, NULL);
760 dom_register_prop_handler(&dom_element_prop_handlers, "childElementCount", sizeof("childElementCount")-1, dom_parent_node_child_element_count, NULL);
761 dom_register_prop_handler(&dom_element_prop_handlers, "previousElementSibling", sizeof("previousElementSibling")-1, dom_node_previous_element_sibling_read, NULL);
762 dom_register_prop_handler(&dom_element_prop_handlers, "nextElementSibling", sizeof("nextElementSibling")-1, dom_node_next_element_sibling_read, NULL);
763 zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
764 zend_hash_add_ptr(&classes, dom_element_class_entry->name, &dom_element_prop_handlers);
765
766 dom_text_class_entry = register_class_DOMText(dom_characterdata_class_entry);
767 dom_text_class_entry->create_object = dom_objects_new;
768
769 zend_hash_init(&dom_text_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
770 dom_register_prop_handler(&dom_text_prop_handlers, "wholeText", sizeof("wholeText")-1, dom_text_whole_text_read, NULL);
771 zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, dom_copy_prop_handler, 0);
772 zend_hash_add_ptr(&classes, dom_text_class_entry->name, &dom_text_prop_handlers);
773
774 dom_comment_class_entry = register_class_DOMComment(dom_characterdata_class_entry);
775 dom_comment_class_entry->create_object = dom_objects_new;
776 zend_hash_add_ptr(&classes, dom_comment_class_entry->name, &dom_characterdata_prop_handlers);
777
778 dom_cdatasection_class_entry = register_class_DOMCdataSection(dom_text_class_entry);
779 dom_cdatasection_class_entry->create_object = dom_objects_new;
780 zend_hash_add_ptr(&classes, dom_cdatasection_class_entry->name, &dom_text_prop_handlers);
781
782 dom_documenttype_class_entry = register_class_DOMDocumentType(dom_node_class_entry);
783 dom_documenttype_class_entry->create_object = dom_objects_new;
784
785 zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
786 dom_register_prop_handler(&dom_documenttype_prop_handlers, "name", sizeof("name")-1, dom_documenttype_name_read, NULL);
787 dom_register_prop_handler(&dom_documenttype_prop_handlers, "entities", sizeof("entities")-1, dom_documenttype_entities_read, NULL);
788 dom_register_prop_handler(&dom_documenttype_prop_handlers, "notations", sizeof("notations")-1, dom_documenttype_notations_read, NULL);
789 dom_register_prop_handler(&dom_documenttype_prop_handlers, "publicId", sizeof("publicId")-1, dom_documenttype_public_id_read, NULL);
790 dom_register_prop_handler(&dom_documenttype_prop_handlers, "systemId", sizeof("systemId")-1, dom_documenttype_system_id_read, NULL);
791 dom_register_prop_handler(&dom_documenttype_prop_handlers, "internalSubset", sizeof("internalSubset")-1, dom_documenttype_internal_subset_read, NULL);
792 zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
793 zend_hash_add_ptr(&classes, dom_documenttype_class_entry->name, &dom_documenttype_prop_handlers);
794
795 dom_notation_class_entry = register_class_DOMNotation(dom_node_class_entry);
796 dom_notation_class_entry->create_object = dom_objects_new;
797
798 zend_hash_init(&dom_notation_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
799 dom_register_prop_handler(&dom_notation_prop_handlers, "publicId", sizeof("publicId")-1, dom_notation_public_id_read, NULL);
800 dom_register_prop_handler(&dom_notation_prop_handlers, "systemId", sizeof("systemId")-1, dom_notation_system_id_read, NULL);
801 zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
802 zend_hash_add_ptr(&classes, dom_notation_class_entry->name, &dom_notation_prop_handlers);
803
804 dom_entity_class_entry = register_class_DOMEntity(dom_node_class_entry);
805 dom_entity_class_entry->create_object = dom_objects_new;
806
807 zend_hash_init(&dom_entity_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
808 dom_register_prop_handler(&dom_entity_prop_handlers, "publicId", sizeof("publicId")-1, dom_entity_public_id_read, NULL);
809 dom_register_prop_handler(&dom_entity_prop_handlers, "systemId", sizeof("systemId")-1, dom_entity_system_id_read, NULL);
810 dom_register_prop_handler(&dom_entity_prop_handlers, "notationName", sizeof("notationName")-1, dom_entity_notation_name_read, NULL);
811 dom_register_prop_handler(&dom_entity_prop_handlers, "actualEncoding", sizeof("actualEncoding")-1, dom_entity_actual_encoding_read, NULL);
812 dom_register_prop_handler(&dom_entity_prop_handlers, "encoding", sizeof("encoding")-1, dom_entity_encoding_read, NULL);
813 dom_register_prop_handler(&dom_entity_prop_handlers, "version", sizeof("version")-1, dom_entity_version_read, NULL);
814 zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
815 zend_hash_add_ptr(&classes, dom_entity_class_entry->name, &dom_entity_prop_handlers);
816
817 dom_entityreference_class_entry = register_class_DOMEntityReference(dom_node_class_entry);
818 dom_entityreference_class_entry->create_object = dom_objects_new;
819
820 zend_hash_init(&dom_entity_reference_prop_handlers, 0, NULL, dom_dtor_prop_handler, true);
821 zend_hash_merge(&dom_entity_reference_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, false);
822 dom_override_prop_handler(&dom_entity_reference_prop_handlers, "firstChild", sizeof("firstChild")-1, dom_entity_reference_child_read, NULL);
823 dom_override_prop_handler(&dom_entity_reference_prop_handlers, "lastChild", sizeof("lastChild")-1, dom_entity_reference_child_read, NULL);
824 dom_override_prop_handler(&dom_entity_reference_prop_handlers, "textContent", sizeof("textContent")-1, dom_entity_reference_text_content_read, NULL);
825 dom_override_prop_handler(&dom_entity_reference_prop_handlers, "childNodes", sizeof("childNodes")-1, dom_entity_reference_child_nodes_read, NULL);
826 zend_hash_add_ptr(&classes, dom_entityreference_class_entry->name, &dom_entity_reference_prop_handlers);
827
828 dom_processinginstruction_class_entry = register_class_DOMProcessingInstruction(dom_node_class_entry);
829 dom_processinginstruction_class_entry->create_object = dom_objects_new;
830
831 zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
832 dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "target", sizeof("target")-1, dom_processinginstruction_target_read, NULL);
833 dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "data", sizeof("data")-1, dom_processinginstruction_data_read, dom_processinginstruction_data_write);
834 zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
835 zend_hash_add_ptr(&classes, dom_processinginstruction_class_entry->name, &dom_processinginstruction_prop_handlers);
836
837 #ifdef LIBXML_XPATH_ENABLED
838 memcpy(&dom_xpath_object_handlers, &dom_object_handlers, sizeof(zend_object_handlers));
839 dom_xpath_object_handlers.offset = XtOffsetOf(dom_xpath_object, dom) + XtOffsetOf(dom_object, std);
840 dom_xpath_object_handlers.free_obj = dom_xpath_objects_free_storage;
841
842 dom_xpath_class_entry = register_class_DOMXPath();
843 dom_xpath_class_entry->create_object = dom_xpath_objects_new;
844
845 zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
846 dom_register_prop_handler(&dom_xpath_prop_handlers, "document", sizeof("document")-1, dom_xpath_document_read, NULL);
847 dom_register_prop_handler(&dom_xpath_prop_handlers, "registerNodeNamespaces", sizeof("registerNodeNamespaces")-1, dom_xpath_register_node_ns_read, dom_xpath_register_node_ns_write);
848 zend_hash_add_ptr(&classes, dom_xpath_class_entry->name, &dom_xpath_prop_handlers);
849 #endif
850
851 register_php_dom_symbols(module_number);
852
853 php_libxml_register_export(dom_node_class_entry, php_dom_export_node);
854
855 return SUCCESS;
856 }
857 /* }}} */
858
859 /* {{{ */
PHP_MINFO_FUNCTION(dom)860 PHP_MINFO_FUNCTION(dom)
861 {
862 php_info_print_table_start();
863 php_info_print_table_row(2, "DOM/XML", "enabled");
864 php_info_print_table_row(2, "DOM/XML API Version", DOM_API_VERSION);
865 php_info_print_table_row(2, "libxml Version", LIBXML_DOTTED_VERSION);
866 #ifdef LIBXML_HTML_ENABLED
867 php_info_print_table_row(2, "HTML Support", "enabled");
868 #endif
869 #ifdef LIBXML_XPATH_ENABLED
870 php_info_print_table_row(2, "XPath Support", "enabled");
871 #endif
872 #ifdef LIBXML_XPTR_ENABLED
873 php_info_print_table_row(2, "XPointer Support", "enabled");
874 #endif
875 #ifdef LIBXML_SCHEMAS_ENABLED
876 php_info_print_table_row(2, "Schema Support", "enabled");
877 php_info_print_table_row(2, "RelaxNG Support", "enabled");
878 #endif
879 php_info_print_table_end();
880 }
881 /* }}} */
882
PHP_MSHUTDOWN_FUNCTION(dom)883 PHP_MSHUTDOWN_FUNCTION(dom) /* {{{ */
884 {
885 zend_hash_destroy(&dom_document_prop_handlers);
886 zend_hash_destroy(&dom_documentfragment_prop_handlers);
887 zend_hash_destroy(&dom_node_prop_handlers);
888 zend_hash_destroy(&dom_entity_reference_prop_handlers);
889 zend_hash_destroy(&dom_namespace_node_prop_handlers);
890 zend_hash_destroy(&dom_nodelist_prop_handlers);
891 zend_hash_destroy(&dom_namednodemap_prop_handlers);
892 zend_hash_destroy(&dom_characterdata_prop_handlers);
893 zend_hash_destroy(&dom_attr_prop_handlers);
894 zend_hash_destroy(&dom_element_prop_handlers);
895 zend_hash_destroy(&dom_text_prop_handlers);
896 zend_hash_destroy(&dom_documenttype_prop_handlers);
897 zend_hash_destroy(&dom_notation_prop_handlers);
898 zend_hash_destroy(&dom_entity_prop_handlers);
899 zend_hash_destroy(&dom_processinginstruction_prop_handlers);
900 #ifdef LIBXML_XPATH_ENABLED
901 zend_hash_destroy(&dom_xpath_prop_handlers);
902 #endif
903 zend_hash_destroy(&classes);
904
905 /* If you want do find memleaks in this module, compile libxml2 with --with-mem-debug and
906 uncomment the following line, this will tell you the amount of not freed memory
907 and the total used memory into apaches error_log */
908 /* xmlMemoryDump();*/
909
910 return SUCCESS;
911 }
912 /* }}} */
913
914 /* {{{ node_list_unlink */
node_list_unlink(xmlNodePtr node)915 void node_list_unlink(xmlNodePtr node)
916 {
917 dom_object *wrapper;
918
919 while (node != NULL) {
920
921 wrapper = php_dom_object_get_data(node);
922
923 if (wrapper != NULL ) {
924 xmlUnlinkNode(node);
925 } else {
926 if (node->type == XML_ENTITY_REF_NODE)
927 break;
928 node_list_unlink(node->children);
929
930 switch (node->type) {
931 case XML_ATTRIBUTE_DECL:
932 case XML_DTD_NODE:
933 case XML_DOCUMENT_TYPE_NODE:
934 case XML_ENTITY_DECL:
935 case XML_ATTRIBUTE_NODE:
936 case XML_TEXT_NODE:
937 break;
938 default:
939 node_list_unlink((xmlNodePtr) node->properties);
940 }
941
942 }
943
944 node = node->next;
945 }
946 }
947 /* }}} end node_list_unlink */
948
949 #ifdef LIBXML_XPATH_ENABLED
950 /* {{{ dom_xpath_objects_free_storage */
dom_xpath_objects_free_storage(zend_object * object)951 void dom_xpath_objects_free_storage(zend_object *object)
952 {
953 dom_xpath_object *intern = php_xpath_obj_from_obj(object);
954
955 zend_object_std_dtor(&intern->dom.std);
956
957 if (intern->dom.ptr != NULL) {
958 xmlXPathFreeContext((xmlXPathContextPtr) intern->dom.ptr);
959 php_libxml_decrement_doc_ref((php_libxml_node_object *) &intern->dom);
960 }
961
962 if (intern->registered_phpfunctions) {
963 zend_hash_destroy(intern->registered_phpfunctions);
964 FREE_HASHTABLE(intern->registered_phpfunctions);
965 }
966
967 if (intern->node_list) {
968 zend_hash_destroy(intern->node_list);
969 FREE_HASHTABLE(intern->node_list);
970 }
971 }
972 /* }}} */
973 #endif
974
975 /* {{{ dom_objects_free_storage */
dom_objects_free_storage(zend_object * object)976 void dom_objects_free_storage(zend_object *object)
977 {
978 dom_object *intern = php_dom_obj_from_obj(object);
979 #if defined(__GNUC__) && __GNUC__ >= 3
980 int retcount __attribute__((unused)); /* keep compiler quiet */
981 #else
982 int retcount;
983 #endif
984
985 zend_object_std_dtor(&intern->std);
986
987 if (intern->ptr != NULL && ((php_libxml_node_ptr *)intern->ptr)->node != NULL) {
988 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) {
989 php_libxml_node_decrement_resource((php_libxml_node_object *) intern);
990 } else {
991 php_libxml_decrement_node_ptr((php_libxml_node_object *) intern);
992 retcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
993 }
994 intern->ptr = NULL;
995 }
996 }
997 /* }}} */
998
dom_namednode_iter(dom_object * basenode,int ntype,dom_object * intern,xmlHashTablePtr ht,xmlChar * local,xmlChar * ns)999 void dom_namednode_iter(dom_object *basenode, int ntype, dom_object *intern, xmlHashTablePtr ht, xmlChar *local, xmlChar *ns) /* {{{ */
1000 {
1001 dom_nnodemap_object *mapptr = (dom_nnodemap_object *) intern->ptr;
1002
1003 ZEND_ASSERT(basenode != NULL);
1004
1005 ZVAL_OBJ_COPY(&mapptr->baseobj_zv, &basenode->std);
1006
1007 mapptr->baseobj = basenode;
1008 mapptr->nodetype = ntype;
1009 mapptr->ht = ht;
1010 mapptr->local = local;
1011 mapptr->ns = ns;
1012 }
1013 /* }}} */
1014
dom_objects_set_class_ex(zend_class_entry * class_type,dom_object * intern)1015 static void dom_objects_set_class_ex(zend_class_entry *class_type, dom_object *intern)
1016 {
1017 zend_class_entry *base_class = class_type;
1018 while ((base_class->type != ZEND_INTERNAL_CLASS || base_class->info.internal.module->module_number != dom_module_entry.module_number) && base_class->parent != NULL) {
1019 base_class = base_class->parent;
1020 }
1021
1022 intern->prop_handler = zend_hash_find_ptr(&classes, base_class->name);
1023
1024 zend_object_std_init(&intern->std, class_type);
1025 object_properties_init(&intern->std, class_type);
1026 }
1027
dom_objects_set_class(zend_class_entry * class_type)1028 static dom_object* dom_objects_set_class(zend_class_entry *class_type)
1029 {
1030 dom_object *intern = zend_object_alloc(sizeof(dom_object), class_type);
1031 dom_objects_set_class_ex(class_type, intern);
1032 return intern;
1033 }
1034
1035 /* {{{ dom_objects_new */
dom_objects_new(zend_class_entry * class_type)1036 zend_object *dom_objects_new(zend_class_entry *class_type)
1037 {
1038 dom_object *intern = dom_objects_set_class(class_type);
1039 intern->std.handlers = dom_get_obj_handlers();
1040 return &intern->std;
1041 }
1042 /* }}} */
1043
dom_objects_namespace_node_new(zend_class_entry * class_type)1044 static zend_object *dom_objects_namespace_node_new(zend_class_entry *class_type)
1045 {
1046 dom_object_namespace_node *intern = zend_object_alloc(sizeof(dom_object_namespace_node), class_type);
1047 dom_objects_set_class_ex(class_type, &intern->dom);
1048 intern->dom.std.handlers = &dom_object_namespace_node_handlers;
1049 return &intern->dom.std;
1050 }
1051
dom_object_namespace_node_free_storage(zend_object * object)1052 static void dom_object_namespace_node_free_storage(zend_object *object)
1053 {
1054 dom_object_namespace_node *intern = php_dom_namespace_node_obj_from_obj(object);
1055 if (intern->parent_intern != NULL) {
1056 zval tmp;
1057 ZVAL_OBJ(&tmp, &intern->parent_intern->std);
1058 zval_ptr_dtor(&tmp);
1059 }
1060 dom_objects_free_storage(object);
1061 }
1062
1063 #ifdef LIBXML_XPATH_ENABLED
1064 /* {{{ zend_object dom_xpath_objects_new(zend_class_entry *class_type) */
dom_xpath_objects_new(zend_class_entry * class_type)1065 zend_object *dom_xpath_objects_new(zend_class_entry *class_type)
1066 {
1067 dom_xpath_object *intern = zend_object_alloc(sizeof(dom_xpath_object), class_type);
1068
1069 intern->registered_phpfunctions = zend_new_array(0);
1070 intern->register_node_ns = 1;
1071
1072 intern->dom.prop_handler = &dom_xpath_prop_handlers;
1073 intern->dom.std.handlers = &dom_xpath_object_handlers;
1074
1075 zend_object_std_init(&intern->dom.std, class_type);
1076 object_properties_init(&intern->dom.std, class_type);
1077
1078 return &intern->dom.std;
1079 }
1080 /* }}} */
1081 #endif
1082
dom_nnodemap_objects_free_storage(zend_object * object)1083 void dom_nnodemap_objects_free_storage(zend_object *object) /* {{{ */
1084 {
1085 dom_object *intern = php_dom_obj_from_obj(object);
1086 dom_nnodemap_object *objmap = (dom_nnodemap_object *)intern->ptr;
1087
1088 if (objmap) {
1089 if (objmap->local) {
1090 xmlFree(objmap->local);
1091 }
1092 if (objmap->ns) {
1093 xmlFree(objmap->ns);
1094 }
1095 if (!Z_ISUNDEF(objmap->baseobj_zv)) {
1096 zval_ptr_dtor(&objmap->baseobj_zv);
1097 }
1098 efree(objmap);
1099 intern->ptr = NULL;
1100 }
1101
1102 php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
1103
1104 zend_object_std_dtor(&intern->std);
1105 }
1106 /* }}} */
1107
dom_nodemap_or_nodelist_objects_new(zend_class_entry * class_type,const zend_object_handlers * handlers)1108 static zend_object *dom_nodemap_or_nodelist_objects_new(zend_class_entry *class_type, const zend_object_handlers *handlers)
1109 {
1110 dom_object *intern;
1111 dom_nnodemap_object *objmap;
1112
1113 intern = dom_objects_set_class(class_type);
1114 intern->ptr = emalloc(sizeof(dom_nnodemap_object));
1115 objmap = (dom_nnodemap_object *)intern->ptr;
1116 ZVAL_UNDEF(&objmap->baseobj_zv);
1117 objmap->baseobj = NULL;
1118 objmap->nodetype = 0;
1119 objmap->ht = NULL;
1120 objmap->local = NULL;
1121 objmap->ns = NULL;
1122
1123 intern->std.handlers = handlers;
1124
1125 return &intern->std;
1126 }
1127
dom_nnodemap_objects_new(zend_class_entry * class_type)1128 zend_object *dom_nnodemap_objects_new(zend_class_entry *class_type) /* {{{ */
1129 {
1130 return dom_nodemap_or_nodelist_objects_new(class_type, &dom_nnodemap_object_handlers);
1131 }
1132 /* }}} */
1133
dom_nodelist_objects_new(zend_class_entry * class_type)1134 zend_object *dom_nodelist_objects_new(zend_class_entry *class_type)
1135 {
1136 return dom_nodemap_or_nodelist_objects_new(class_type, &dom_nodelist_object_handlers);
1137 }
1138
php_dom_create_iterator(zval * return_value,int ce_type)1139 void php_dom_create_iterator(zval *return_value, int ce_type) /* {{{ */
1140 {
1141 zend_class_entry *ce;
1142
1143 if (ce_type == DOM_NAMEDNODEMAP) {
1144 ce = dom_namednodemap_class_entry;
1145 } else {
1146 ce = dom_nodelist_class_entry;
1147 }
1148
1149 object_init_ex(return_value, ce);
1150 }
1151 /* }}} */
1152
1153 /* {{{ php_dom_create_object */
php_dom_create_object(xmlNodePtr obj,zval * return_value,dom_object * domobj)1154 PHP_DOM_EXPORT bool php_dom_create_object(xmlNodePtr obj, zval *return_value, dom_object *domobj)
1155 {
1156 zend_class_entry *ce;
1157 dom_object *intern;
1158
1159 if (!obj) {
1160 ZVAL_NULL(return_value);
1161 return 0;
1162 }
1163
1164 if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
1165 ZVAL_OBJ_COPY(return_value, &intern->std);
1166 return 1;
1167 }
1168
1169 switch (obj->type) {
1170 case XML_DOCUMENT_NODE:
1171 case XML_HTML_DOCUMENT_NODE:
1172 {
1173 ce = dom_document_class_entry;
1174 break;
1175 }
1176 case XML_DTD_NODE:
1177 case XML_DOCUMENT_TYPE_NODE:
1178 {
1179 ce = dom_documenttype_class_entry;
1180 break;
1181 }
1182 case XML_ELEMENT_NODE:
1183 {
1184 ce = dom_element_class_entry;
1185 break;
1186 }
1187 case XML_ATTRIBUTE_NODE:
1188 {
1189 ce = dom_attr_class_entry;
1190 break;
1191 }
1192 case XML_TEXT_NODE:
1193 {
1194 ce = dom_text_class_entry;
1195 break;
1196 }
1197 case XML_COMMENT_NODE:
1198 {
1199 ce = dom_comment_class_entry;
1200 break;
1201 }
1202 case XML_PI_NODE:
1203 {
1204 ce = dom_processinginstruction_class_entry;
1205 break;
1206 }
1207 case XML_ENTITY_REF_NODE:
1208 {
1209 ce = dom_entityreference_class_entry;
1210 break;
1211 }
1212 case XML_ENTITY_DECL:
1213 case XML_ELEMENT_DECL:
1214 {
1215 ce = dom_entity_class_entry;
1216 break;
1217 }
1218 case XML_CDATA_SECTION_NODE:
1219 {
1220 ce = dom_cdatasection_class_entry;
1221 break;
1222 }
1223 case XML_DOCUMENT_FRAG_NODE:
1224 {
1225 ce = dom_documentfragment_class_entry;
1226 break;
1227 }
1228 case XML_NOTATION_NODE:
1229 {
1230 ce = dom_notation_class_entry;
1231 break;
1232 }
1233 case XML_NAMESPACE_DECL:
1234 {
1235 ce = dom_namespace_node_class_entry;
1236 break;
1237 }
1238 default:
1239 /* TODO Convert to a ZEND assertion? */
1240 zend_throw_error(NULL, "Unsupported node type: %d", obj->type);
1241 ZVAL_NULL(return_value);
1242 return 0;
1243 }
1244
1245 if (domobj && domobj->document) {
1246 ce = dom_get_doc_classmap(domobj->document, ce);
1247 }
1248 object_init_ex(return_value, ce);
1249
1250 intern = Z_DOMOBJ_P(return_value);
1251 if (obj->doc != NULL) {
1252 if (domobj != NULL) {
1253 intern->document = domobj->document;
1254 }
1255 php_libxml_increment_doc_ref((php_libxml_node_object *)intern, obj->doc);
1256 }
1257
1258 php_libxml_increment_node_ptr((php_libxml_node_object *)intern, obj, (void *)intern);
1259 return 0;
1260 }
1261 /* }}} end php_domobject_new */
1262
php_dom_create_implementation(zval * retval)1263 void php_dom_create_implementation(zval *retval) {
1264 object_init_ex(retval, dom_domimplementation_class_entry);
1265 }
1266
1267 /* {{{ int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) */
dom_hierarchy(xmlNodePtr parent,xmlNodePtr child)1268 int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child)
1269 {
1270 xmlNodePtr nodep;
1271
1272 if (parent == NULL || child == NULL || child->doc != parent->doc) {
1273 return SUCCESS;
1274 }
1275
1276 if (child->type == XML_DOCUMENT_NODE) {
1277 return FAILURE;
1278 }
1279
1280 nodep = parent;
1281
1282 while (nodep) {
1283 if (nodep == child) {
1284 return FAILURE;
1285 }
1286 nodep = nodep->parent;
1287 }
1288
1289 return SUCCESS;
1290 }
1291 /* }}} end dom_hierarchy */
1292
1293 /* {{{ */
dom_has_feature(zend_string * feature,zend_string * version)1294 bool dom_has_feature(zend_string *feature, zend_string *version)
1295 {
1296 if (zend_string_equals_literal(version, "1.0")
1297 || zend_string_equals_literal(version, "2.0")
1298 || zend_string_equals_literal(version, "")
1299 ) {
1300 if (zend_string_equals_literal_ci(feature, "XML")
1301 || (zend_string_equals_literal_ci(feature, "Core") && zend_string_equals_literal(version, "1.0"))
1302 ) {
1303 return true;
1304 }
1305 }
1306
1307 return false;
1308 }
1309 /* }}} end dom_has_feature */
1310
dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep,char * ns,char * local,int * cur,int index)1311 xmlNode *dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep, char *ns, char *local, int *cur, int index) /* {{{ */
1312 {
1313 xmlNodePtr ret = NULL;
1314
1315 /* Note: The spec says that ns == '' must be transformed to ns == NULL. In other words, they are equivalent.
1316 * PHP however does not do this and internally uses the empty string everywhere when the user provides ns == NULL.
1317 * This is because for PHP ns == NULL has another meaning: "match every namespace" instead of "match the empty namespace". */
1318 bool ns_match_any = ns == NULL || (ns[0] == '*' && ns[1] == '\0');
1319
1320 while (nodep != NULL && (*cur <= index || index == -1)) {
1321 if (nodep->type == XML_ELEMENT_NODE) {
1322 if (xmlStrEqual(nodep->name, (xmlChar *)local) || xmlStrEqual((xmlChar *)"*", (xmlChar *)local)) {
1323 if (ns_match_any || (!strcmp(ns, "") && nodep->ns == NULL) || (nodep->ns != NULL && xmlStrEqual(nodep->ns->href, (xmlChar *)ns))) {
1324 if (*cur == index) {
1325 ret = nodep;
1326 break;
1327 }
1328 (*cur)++;
1329 }
1330 }
1331 ret = dom_get_elements_by_tag_name_ns_raw(nodep->children, ns, local, cur, index);
1332 if (ret != NULL) {
1333 break;
1334 }
1335 }
1336 nodep = nodep->next;
1337 }
1338 return ret;
1339 }
1340 /* }}} */
1341 /* }}} end dom_element_get_elements_by_tag_name_ns_raw */
1342
is_empty_node(xmlNodePtr nodep)1343 static inline bool is_empty_node(xmlNodePtr nodep)
1344 {
1345 xmlChar *strContent = xmlNodeGetContent(nodep);
1346 bool ret = strContent == NULL || *strContent == '\0';
1347 xmlFree(strContent);
1348 return ret;
1349 }
1350
1351 /* {{{ void dom_normalize (xmlNodePtr nodep) */
dom_normalize(xmlNodePtr nodep)1352 void dom_normalize (xmlNodePtr nodep)
1353 {
1354 xmlNodePtr child, nextp, newnextp;
1355 xmlAttrPtr attr;
1356 xmlChar *strContent;
1357
1358 child = nodep->children;
1359 while(child != NULL) {
1360 switch (child->type) {
1361 case XML_TEXT_NODE:
1362 nextp = child->next;
1363 while (nextp != NULL) {
1364 if (nextp->type == XML_TEXT_NODE) {
1365 newnextp = nextp->next;
1366 strContent = xmlNodeGetContent(nextp);
1367 xmlNodeAddContent(child, strContent);
1368 xmlFree(strContent);
1369 xmlUnlinkNode(nextp);
1370 php_libxml_node_free_resource(nextp);
1371 nextp = newnextp;
1372 } else {
1373 break;
1374 }
1375 }
1376 if (is_empty_node(child)) {
1377 nextp = child->next;
1378 xmlUnlinkNode(child);
1379 php_libxml_node_free_resource(child);
1380 child = nextp;
1381 continue;
1382 }
1383 break;
1384 case XML_ELEMENT_NODE:
1385 dom_normalize (child);
1386 attr = child->properties;
1387 while (attr != NULL) {
1388 dom_normalize((xmlNodePtr) attr);
1389 attr = attr->next;
1390 }
1391 break;
1392 case XML_ATTRIBUTE_NODE:
1393 dom_normalize (child);
1394 break;
1395 default:
1396 break;
1397 }
1398 child = child->next;
1399 }
1400 }
1401 /* }}} end dom_normalize */
1402
1403
1404 /* {{{ void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) */
dom_set_old_ns(xmlDoc * doc,xmlNs * ns)1405 void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) {
1406 xmlNs *cur;
1407
1408 if (doc == NULL)
1409 return;
1410
1411 if (doc->oldNs == NULL) {
1412 doc->oldNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
1413 if (doc->oldNs == NULL) {
1414 return;
1415 }
1416 memset(doc->oldNs, 0, sizeof(xmlNs));
1417 doc->oldNs->type = XML_LOCAL_NAMESPACE;
1418 doc->oldNs->href = xmlStrdup(XML_XML_NAMESPACE);
1419 doc->oldNs->prefix = xmlStrdup((const xmlChar *)"xml");
1420 }
1421
1422 cur = doc->oldNs;
1423 while (cur->next != NULL) {
1424 cur = cur->next;
1425 }
1426 cur->next = ns;
1427 }
1428 /* }}} end dom_set_old_ns */
1429
dom_reconcile_ns_internal(xmlDocPtr doc,xmlNodePtr nodep,xmlNodePtr search_parent)1430 static void dom_reconcile_ns_internal(xmlDocPtr doc, xmlNodePtr nodep, xmlNodePtr search_parent)
1431 {
1432 xmlNsPtr nsptr, nsdftptr, curns, prevns = NULL;
1433
1434 /* Following if block primarily used for inserting nodes created via createElementNS */
1435 if (nodep->nsDef != NULL) {
1436 curns = nodep->nsDef;
1437 while (curns) {
1438 nsdftptr = curns->next;
1439 if (curns->href != NULL) {
1440 if((nsptr = xmlSearchNsByHref(doc, search_parent, curns->href)) &&
1441 (curns->prefix == NULL || xmlStrEqual(nsptr->prefix, curns->prefix))) {
1442 curns->next = NULL;
1443 if (prevns == NULL) {
1444 nodep->nsDef = nsdftptr;
1445 } else {
1446 prevns->next = nsdftptr;
1447 }
1448 dom_set_old_ns(doc, curns);
1449 curns = prevns;
1450 }
1451 }
1452 prevns = curns;
1453 curns = nsdftptr;
1454 }
1455 }
1456 }
1457
dom_libxml_reconcile_ensure_namespaces_are_declared(xmlNodePtr nodep)1458 static void dom_libxml_reconcile_ensure_namespaces_are_declared(xmlNodePtr nodep)
1459 {
1460 /* Ideally we'd use the DOM-wrapped version, but we cannot: https://github.com/php/php-src/pull/12308. */
1461 #if 0
1462 /* Put on stack to avoid allocation.
1463 * Although libxml2 currently does not use this for the reconciliation, it still
1464 * makes sense to do this just in case libxml2's internal change in the future. */
1465 xmlDOMWrapCtxt dummy_ctxt = {0};
1466 xmlDOMWrapReconcileNamespaces(&dummy_ctxt, nodep, /* options */ 0);
1467 #else
1468 xmlReconciliateNs(nodep->doc, nodep);
1469 #endif
1470 }
1471
dom_reconcile_ns(xmlDocPtr doc,xmlNodePtr nodep)1472 void dom_reconcile_ns(xmlDocPtr doc, xmlNodePtr nodep) /* {{{ */
1473 {
1474 /* Although the node type will be checked by the libxml2 API,
1475 * we still want to do the internal reconciliation conditionally. */
1476 if (nodep->type == XML_ELEMENT_NODE) {
1477 dom_reconcile_ns_internal(doc, nodep, nodep->parent);
1478 dom_libxml_reconcile_ensure_namespaces_are_declared(nodep);
1479 }
1480 }
1481 /* }}} */
1482
dom_reconcile_ns_list_internal(xmlDocPtr doc,xmlNodePtr nodep,xmlNodePtr last,xmlNodePtr search_parent)1483 static void dom_reconcile_ns_list_internal(xmlDocPtr doc, xmlNodePtr nodep, xmlNodePtr last, xmlNodePtr search_parent)
1484 {
1485 ZEND_ASSERT(nodep != NULL);
1486 while (true) {
1487 if (nodep->type == XML_ELEMENT_NODE) {
1488 dom_reconcile_ns_internal(doc, nodep, search_parent);
1489 if (nodep->children) {
1490 dom_reconcile_ns_list_internal(doc, nodep->children, nodep->last /* process the whole children list */, search_parent);
1491 }
1492 }
1493 if (nodep == last) {
1494 break;
1495 }
1496 nodep = nodep->next;
1497 }
1498 }
1499
dom_reconcile_ns_list(xmlDocPtr doc,xmlNodePtr nodep,xmlNodePtr last)1500 void dom_reconcile_ns_list(xmlDocPtr doc, xmlNodePtr nodep, xmlNodePtr last)
1501 {
1502 dom_reconcile_ns_list_internal(doc, nodep, last, nodep->parent);
1503 /* The loop is outside of the recursion in the above call because
1504 * dom_libxml_reconcile_ensure_namespaces_are_declared() performs its own recursion. */
1505 while (true) {
1506 /* The internal libxml2 call will already check the node type, no need for us to do it here. */
1507 dom_libxml_reconcile_ensure_namespaces_are_declared(nodep);
1508 if (nodep == last) {
1509 break;
1510 }
1511 nodep = nodep->next;
1512 }
1513 }
1514
1515 /*
1516 http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1517
1518 NAMESPACE_ERR: Raised if
1519
1520 1. the qualifiedName is a malformed qualified name
1521 2. the qualifiedName has a prefix and the namespaceURI is null
1522 */
1523
1524 /* {{{ 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)1525 int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) {
1526 if (name_len == 0) {
1527 return NAMESPACE_ERR;
1528 }
1529
1530 *localname = (char *)xmlSplitQName2((xmlChar *)qname, (xmlChar **) prefix);
1531 if (*localname == NULL) {
1532 *localname = (char *)xmlStrdup((xmlChar *)qname);
1533 if (*prefix == NULL && uri_len == 0) {
1534 return 0;
1535 }
1536 }
1537
1538 /* 1 */
1539 if (xmlValidateQName((xmlChar *) qname, 0) != 0) {
1540 return NAMESPACE_ERR;
1541 }
1542
1543 /* 2 */
1544 if (*prefix != NULL && uri_len == 0) {
1545 return NAMESPACE_ERR;
1546 }
1547
1548 return 0;
1549 }
1550 /* }}} */
1551
1552 /*
1553 http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1554
1555 NAMESPACE_ERR: Raised if
1556
1557 3. the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace" [XML Namespaces]
1558 4. the qualifiedName or its prefix is "xmlns" and the namespaceURI is different from "http://www.w3.org/2000/xmlns/"
1559 5. the namespaceURI is "http://www.w3.org/2000/xmlns/" and neither the qualifiedName nor its prefix is "xmlns".
1560 */
1561
1562 /* {{{ xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) */
dom_get_ns(xmlNodePtr nodep,char * uri,int * errorcode,char * prefix)1563 xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) {
1564 xmlNsPtr nsptr = NULL;
1565
1566 *errorcode = 0;
1567
1568 if (! ((prefix && !strcmp (prefix, "xml") && strcmp(uri, (char *)XML_XML_NAMESPACE)) ||
1569 (prefix && !strcmp (prefix, "xmlns") && strcmp(uri, (char *)DOM_XMLNS_NAMESPACE)) ||
1570 (prefix && !strcmp(uri, (char *)DOM_XMLNS_NAMESPACE) && strcmp (prefix, "xmlns")))) {
1571 nsptr = xmlNewNs(nodep, (xmlChar *)uri, (xmlChar *)prefix);
1572 }
1573
1574 if (nsptr == NULL) {
1575 *errorcode = NAMESPACE_ERR;
1576 }
1577
1578 return nsptr;
1579
1580 }
1581 /* }}} end dom_get_ns */
1582
1583 /* {{{ xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) */
dom_get_nsdecl(xmlNode * node,xmlChar * localName)1584 xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) {
1585 xmlNsPtr cur;
1586 xmlNs *ret = NULL;
1587 if (node == NULL)
1588 return NULL;
1589
1590 if (localName == NULL || xmlStrEqual(localName, (xmlChar *)"")) {
1591 cur = node->nsDef;
1592 while (cur != NULL) {
1593 if (cur->prefix == NULL && cur->href != NULL) {
1594 ret = cur;
1595 break;
1596 }
1597 cur = cur->next;
1598 }
1599 } else {
1600 cur = node->nsDef;
1601 while (cur != NULL) {
1602 if (cur->prefix != NULL && xmlStrEqual(localName, cur->prefix)) {
1603 ret = cur;
1604 break;
1605 }
1606 cur = cur->next;
1607 }
1608 }
1609 return ret;
1610 }
1611 /* }}} end dom_get_nsdecl */
1612
php_dom_create_fake_namespace_decl_node_ptr(xmlNodePtr nodep,xmlNsPtr original)1613 static xmlNodePtr php_dom_create_fake_namespace_decl_node_ptr(xmlNodePtr nodep, xmlNsPtr original)
1614 {
1615 xmlNodePtr attrp;
1616 xmlNsPtr curns = xmlNewNs(NULL, original->href, NULL);
1617 if (original->prefix) {
1618 curns->prefix = xmlStrdup(original->prefix);
1619 attrp = xmlNewDocNode(nodep->doc, NULL, (xmlChar *) original->prefix, original->href);
1620 } else {
1621 attrp = xmlNewDocNode(nodep->doc, NULL, (xmlChar *)"xmlns", original->href);
1622 }
1623 attrp->type = XML_NAMESPACE_DECL;
1624 attrp->parent = nodep;
1625 attrp->ns = curns;
1626 return attrp;
1627 }
1628
1629 /* 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)1630 xmlNodePtr php_dom_create_fake_namespace_decl(xmlNodePtr nodep, xmlNsPtr original, zval *return_value, dom_object *parent_intern)
1631 {
1632 xmlNodePtr attrp = php_dom_create_fake_namespace_decl_node_ptr(nodep, original);
1633 php_dom_create_object(attrp, return_value, parent_intern);
1634 /* This object must exist, because we just created an object for it via php_dom_create_object(). */
1635 php_dom_namespace_node_obj_from_obj(Z_OBJ_P(return_value))->parent_intern = parent_intern;
1636 return attrp;
1637 }
1638
dom_nodemap_or_nodelist_process_offset_as_named(zval * offset,zend_long * lval)1639 static bool dom_nodemap_or_nodelist_process_offset_as_named(zval *offset, zend_long *lval)
1640 {
1641 if (Z_TYPE_P(offset) == IS_STRING) {
1642 /* See zval_get_long_func() */
1643 double dval;
1644 zend_uchar is_numeric_string_type;
1645 if (0 == (is_numeric_string_type = is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), lval, &dval, true))) {
1646 return true;
1647 } else if (is_numeric_string_type == IS_DOUBLE) {
1648 *lval = zend_dval_to_lval_cap(dval);
1649 }
1650 } else {
1651 *lval = zval_get_long(offset);
1652 }
1653 return false;
1654 }
1655
dom_nodelist_read_dimension(zend_object * object,zval * offset,int type,zval * rv)1656 static zval *dom_nodelist_read_dimension(zend_object *object, zval *offset, int type, zval *rv) /* {{{ */
1657 {
1658 if (UNEXPECTED(!offset)) {
1659 zend_throw_error(NULL, "Cannot access DOMNodeList without offset");
1660 return NULL;
1661 }
1662
1663 ZVAL_DEREF(offset);
1664
1665 zend_long lval;
1666 if (dom_nodemap_or_nodelist_process_offset_as_named(offset, &lval)) {
1667 /* does not support named lookup */
1668 ZVAL_NULL(rv);
1669 return rv;
1670 }
1671
1672 php_dom_nodelist_get_item_into_zval(php_dom_obj_from_obj(object)->ptr, lval, rv);
1673 return rv;
1674 } /* }}} end dom_nodelist_read_dimension */
1675
dom_nodelist_has_dimension(zend_object * object,zval * member,int check_empty)1676 static int dom_nodelist_has_dimension(zend_object *object, zval *member, int check_empty)
1677 {
1678 ZVAL_DEREF(member);
1679
1680 zend_long offset;
1681 if (dom_nodemap_or_nodelist_process_offset_as_named(member, &offset)) {
1682 /* does not support named lookup */
1683 return 0;
1684 }
1685
1686 return offset >= 0 && offset < php_dom_get_nodelist_length(php_dom_obj_from_obj(object));
1687 } /* }}} end dom_nodelist_has_dimension */
1688
dom_nodemap_read_dimension(zend_object * object,zval * offset,int type,zval * rv)1689 static zval *dom_nodemap_read_dimension(zend_object *object, zval *offset, int type, zval *rv) /* {{{ */
1690 {
1691 if (UNEXPECTED(!offset)) {
1692 zend_throw_error(NULL, "Cannot access DOMNamedNodeMap without offset");
1693 return NULL;
1694 }
1695
1696 ZVAL_DEREF(offset);
1697
1698 zend_long lval;
1699 if (dom_nodemap_or_nodelist_process_offset_as_named(offset, &lval)) {
1700 /* exceptional case, switch to named lookup */
1701 php_dom_named_node_map_get_named_item_into_zval(php_dom_obj_from_obj(object)->ptr, Z_STRVAL_P(offset), rv);
1702 return rv;
1703 }
1704
1705 /* see PHP_METHOD(DOMNamedNodeMap, item) */
1706 if (UNEXPECTED(lval < 0 || ZEND_LONG_INT_OVFL(lval))) {
1707 zend_value_error("must be between 0 and %d", INT_MAX);
1708 return NULL;
1709 }
1710
1711 php_dom_named_node_map_get_item_into_zval(php_dom_obj_from_obj(object)->ptr, lval, rv);
1712 return rv;
1713 } /* }}} end dom_nodemap_read_dimension */
1714
dom_nodemap_has_dimension(zend_object * object,zval * member,int check_empty)1715 static int dom_nodemap_has_dimension(zend_object *object, zval *member, int check_empty)
1716 {
1717 ZVAL_DEREF(member);
1718
1719 zend_long offset;
1720 if (dom_nodemap_or_nodelist_process_offset_as_named(member, &offset)) {
1721 /* exceptional case, switch to named lookup */
1722 return php_dom_named_node_map_get_named_item(php_dom_obj_from_obj(object)->ptr, Z_STRVAL_P(member), false) != NULL;
1723 }
1724
1725 return offset >= 0 && offset < php_dom_get_namednodemap_length(php_dom_obj_from_obj(object));
1726 } /* }}} end dom_nodemap_has_dimension */
1727
1728 #endif /* HAVE_DOM */
1729
