xref: /PHP-7.1/ext/dom/php_dom.c (revision a468752e)
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 7                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2018 The PHP Group                                |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 3.01 of the PHP license,      |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.php.net/license/3_01.txt                                  |
11    | If you did not receive a copy of the PHP license and are unable to   |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@php.net so we can mail you a copy immediately.               |
14    +----------------------------------------------------------------------+
15    | Authors: Christian Stocker <chregu@php.net>                          |
16    |          Rob Richards <rrichards@php.net>                            |
17    |          Marcus Borger <helly@php.net>                               |
18    +----------------------------------------------------------------------+
19 */
20 
21 /* $Id$ */
22 
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26 
27 #include "php.h"
28 #if HAVE_LIBXML && HAVE_DOM
29 #include "ext/standard/php_rand.h"
30 #include "php_dom.h"
31 #include "dom_properties.h"
32 #include "zend_interfaces.h"
33 
34 #include "ext/standard/info.h"
35 #define PHP_XPATH 1
36 #define PHP_XPTR 2
37 
38 /* {{{ class entries */
39 PHP_DOM_EXPORT zend_class_entry *dom_node_class_entry;
40 PHP_DOM_EXPORT zend_class_entry *dom_domexception_class_entry;
41 PHP_DOM_EXPORT zend_class_entry *dom_domstringlist_class_entry;
42 PHP_DOM_EXPORT zend_class_entry *dom_namelist_class_entry;
43 PHP_DOM_EXPORT zend_class_entry *dom_domimplementationlist_class_entry;
44 PHP_DOM_EXPORT zend_class_entry *dom_domimplementationsource_class_entry;
45 PHP_DOM_EXPORT zend_class_entry *dom_domimplementation_class_entry;
46 PHP_DOM_EXPORT zend_class_entry *dom_documentfragment_class_entry;
47 PHP_DOM_EXPORT zend_class_entry *dom_document_class_entry;
48 PHP_DOM_EXPORT zend_class_entry *dom_nodelist_class_entry;
49 PHP_DOM_EXPORT zend_class_entry *dom_namednodemap_class_entry;
50 PHP_DOM_EXPORT zend_class_entry *dom_characterdata_class_entry;
51 PHP_DOM_EXPORT zend_class_entry *dom_attr_class_entry;
52 PHP_DOM_EXPORT zend_class_entry *dom_element_class_entry;
53 PHP_DOM_EXPORT zend_class_entry *dom_text_class_entry;
54 PHP_DOM_EXPORT zend_class_entry *dom_comment_class_entry;
55 PHP_DOM_EXPORT zend_class_entry *dom_typeinfo_class_entry;
56 PHP_DOM_EXPORT zend_class_entry *dom_userdatahandler_class_entry;
57 PHP_DOM_EXPORT zend_class_entry *dom_domerror_class_entry;
58 PHP_DOM_EXPORT zend_class_entry *dom_domerrorhandler_class_entry;
59 PHP_DOM_EXPORT zend_class_entry *dom_domlocator_class_entry;
60 PHP_DOM_EXPORT zend_class_entry *dom_domconfiguration_class_entry;
61 PHP_DOM_EXPORT zend_class_entry *dom_cdatasection_class_entry;
62 PHP_DOM_EXPORT zend_class_entry *dom_documenttype_class_entry;
63 PHP_DOM_EXPORT zend_class_entry *dom_notation_class_entry;
64 PHP_DOM_EXPORT zend_class_entry *dom_entity_class_entry;
65 PHP_DOM_EXPORT zend_class_entry *dom_entityreference_class_entry;
66 PHP_DOM_EXPORT zend_class_entry *dom_processinginstruction_class_entry;
67 PHP_DOM_EXPORT zend_class_entry *dom_string_extend_class_entry;
68 #if defined(LIBXML_XPATH_ENABLED)
69 PHP_DOM_EXPORT zend_class_entry *dom_xpath_class_entry;
70 #endif
71 PHP_DOM_EXPORT zend_class_entry *dom_namespace_node_class_entry;
72 /* }}} */
73 
74 zend_object_handlers dom_object_handlers;
75 zend_object_handlers dom_nnodemap_object_handlers;
76 #if defined(LIBXML_XPATH_ENABLED)
77 zend_object_handlers dom_xpath_object_handlers;
78 #endif
79 
80 static HashTable classes;
81 /* {{{ prop handler tables */
82 static HashTable dom_domstringlist_prop_handlers;
83 static HashTable dom_namelist_prop_handlers;
84 static HashTable dom_domimplementationlist_prop_handlers;
85 static HashTable dom_document_prop_handlers;
86 static HashTable dom_node_prop_handlers;
87 static HashTable dom_nodelist_prop_handlers;
88 static HashTable dom_namednodemap_prop_handlers;
89 static HashTable dom_characterdata_prop_handlers;
90 static HashTable dom_attr_prop_handlers;
91 static HashTable dom_element_prop_handlers;
92 static HashTable dom_text_prop_handlers;
93 static HashTable dom_typeinfo_prop_handlers;
94 static HashTable dom_domerror_prop_handlers;
95 static HashTable dom_domlocator_prop_handlers;
96 static HashTable dom_documenttype_prop_handlers;
97 static HashTable dom_notation_prop_handlers;
98 static HashTable dom_entity_prop_handlers;
99 static HashTable dom_processinginstruction_prop_handlers;
100 static HashTable dom_namespace_node_prop_handlers;
101 #if defined(LIBXML_XPATH_ENABLED)
102 static HashTable dom_xpath_prop_handlers;
103 #endif
104 /* }}} */
105 
106 typedef int (*dom_read_t)(dom_object *obj, zval *retval);
107 typedef int (*dom_write_t)(dom_object *obj, zval *newval);
108 
109 typedef struct _dom_prop_handler {
110 	dom_read_t read_func;
111 	dom_write_t write_func;
112 } dom_prop_handler;
113 
dom_get_obj_handlers(void)114 static zend_object_handlers* dom_get_obj_handlers(void) {
115 	return &dom_object_handlers;
116 }
117 
118 /* {{{ int dom_node_is_read_only(xmlNodePtr node) */
dom_node_is_read_only(xmlNodePtr node)119 int dom_node_is_read_only(xmlNodePtr node) {
120 	switch (node->type) {
121 		case XML_ENTITY_REF_NODE:
122 		case XML_ENTITY_NODE:
123 		case XML_DOCUMENT_TYPE_NODE:
124 		case XML_NOTATION_NODE:
125 		case XML_DTD_NODE:
126 		case XML_ELEMENT_DECL:
127 		case XML_ATTRIBUTE_DECL:
128 		case XML_ENTITY_DECL:
129 		case XML_NAMESPACE_DECL:
130 			return SUCCESS;
131 			break;
132 		default:
133 			if (node->doc == NULL) {
134 				return SUCCESS;
135 			} else {
136 				return FAILURE;
137 			}
138 	}
139 }
140 /* }}} end dom_node_is_read_only */
141 
142 /* {{{ int dom_node_children_valid(xmlNodePtr node) */
dom_node_children_valid(xmlNodePtr node)143 int dom_node_children_valid(xmlNodePtr node) {
144 	switch (node->type) {
145 		case XML_DOCUMENT_TYPE_NODE:
146 		case XML_DTD_NODE:
147 		case XML_PI_NODE:
148 		case XML_COMMENT_NODE:
149 		case XML_TEXT_NODE:
150 		case XML_CDATA_SECTION_NODE:
151 		case XML_NOTATION_NODE:
152 			return FAILURE;
153 			break;
154 		default:
155 			return SUCCESS;
156 	}
157 }
158 /* }}} end dom_node_children_valid */
159 
160 /* {{{ dom_get_doc_props() */
dom_get_doc_props(php_libxml_ref_obj * document)161 dom_doc_propsptr dom_get_doc_props(php_libxml_ref_obj *document)
162 {
163 	dom_doc_propsptr doc_props;
164 
165 	if (document && document->doc_props) {
166 		return document->doc_props;
167 	} else {
168 		doc_props = emalloc(sizeof(libxml_doc_props));
169 		doc_props->formatoutput = 0;
170 		doc_props->validateonparse = 0;
171 		doc_props->resolveexternals = 0;
172 		doc_props->preservewhitespace = 1;
173 		doc_props->substituteentities = 0;
174 		doc_props->stricterror = 1;
175 		doc_props->recover = 0;
176 		doc_props->classmap = NULL;
177 		if (document) {
178 			document->doc_props = doc_props;
179 		}
180 		return doc_props;
181 	}
182 }
183 
dom_copy_doc_props(php_libxml_ref_obj * source_doc,php_libxml_ref_obj * dest_doc)184 static void dom_copy_doc_props(php_libxml_ref_obj *source_doc, php_libxml_ref_obj *dest_doc)
185 {
186 	dom_doc_propsptr source, dest;
187 
188 	if (source_doc && dest_doc) {
189 
190 		source = dom_get_doc_props(source_doc);
191 		dest = dom_get_doc_props(dest_doc);
192 
193 		dest->formatoutput = source->formatoutput;
194 		dest->validateonparse = source->validateonparse;
195 		dest->resolveexternals = source->resolveexternals;
196 		dest->preservewhitespace = source->preservewhitespace;
197 		dest->substituteentities = source->substituteentities;
198 		dest->stricterror = source->stricterror;
199 		dest->recover = source->recover;
200 		if (source->classmap) {
201 			ALLOC_HASHTABLE(dest->classmap);
202 			zend_hash_init(dest->classmap, 0, NULL, NULL, 0);
203 			zend_hash_copy(dest->classmap, source->classmap, NULL);
204 		}
205 
206 	}
207 }
208 
dom_set_doc_classmap(php_libxml_ref_obj * document,zend_class_entry * basece,zend_class_entry * ce)209 void dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece, zend_class_entry *ce)
210 {
211 	dom_doc_propsptr doc_props;
212 
213 	if (document) {
214 		doc_props = dom_get_doc_props(document);
215 		if (doc_props->classmap == NULL) {
216 			if (ce == NULL) {
217 				return;
218 			}
219 			ALLOC_HASHTABLE(doc_props->classmap);
220 			zend_hash_init(doc_props->classmap, 0, NULL, NULL, 0);
221 		}
222 		if (ce) {
223 			zend_hash_update_ptr(doc_props->classmap, basece->name, ce);
224 		} else {
225 			zend_hash_del(doc_props->classmap, basece->name);
226 		}
227 	}
228 }
229 
dom_get_doc_classmap(php_libxml_ref_obj * document,zend_class_entry * basece)230 zend_class_entry *dom_get_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece)
231 {
232 	dom_doc_propsptr doc_props;
233 
234 	if (document) {
235 		doc_props = dom_get_doc_props(document);
236 		if (doc_props->classmap) {
237 			zend_class_entry *ce = zend_hash_find_ptr(doc_props->classmap, basece->name);
238 			if (ce) {
239 				return ce;
240 			}
241 		}
242 	}
243 
244 	return basece;
245 }
246 /* }}} */
247 
248 /* {{{ dom_get_strict_error() */
dom_get_strict_error(php_libxml_ref_obj * document)249 int dom_get_strict_error(php_libxml_ref_obj *document) {
250 	int stricterror;
251 	dom_doc_propsptr doc_props;
252 
253 	doc_props = dom_get_doc_props(document);
254 	stricterror = doc_props->stricterror;
255 	if (document == NULL) {
256 		efree(doc_props);
257 	}
258 
259 	return stricterror;
260 }
261 /* }}} */
262 
263 /* {{{ xmlNodePtr dom_object_get_node(dom_object *obj) */
dom_object_get_node(dom_object * obj)264 PHP_DOM_EXPORT xmlNodePtr dom_object_get_node(dom_object *obj)
265 {
266 	if (obj && obj->ptr != NULL) {
267 		return ((php_libxml_node_ptr *)obj->ptr)->node;
268 	} else {
269 		return NULL;
270 	}
271 }
272 /* }}} end dom_object_get_node */
273 
274 /* {{{ dom_object *php_dom_object_get_data(xmlNodePtr obj) */
php_dom_object_get_data(xmlNodePtr obj)275 PHP_DOM_EXPORT dom_object *php_dom_object_get_data(xmlNodePtr obj)
276 {
277 	if (obj && obj->_private != NULL) {
278 		return (dom_object *) ((php_libxml_node_ptr *) obj->_private)->_private;
279 	} else {
280 		return NULL;
281 	}
282 }
283 /* }}} end php_dom_object_get_data */
284 
285 /* {{{ dom_read_na */
dom_read_na(dom_object * obj,zval * retval)286 static int dom_read_na(dom_object *obj, zval *retval)
287 {
288 	zend_throw_error(NULL, "Cannot read property");
289 	return FAILURE;
290 }
291 /* }}} */
292 
293 /* {{{ dom_write_na */
dom_write_na(dom_object * obj,zval * newval)294 static int dom_write_na(dom_object *obj, zval *newval)
295 {
296 	zend_throw_error(NULL, "Cannot write property");
297 	return FAILURE;
298 }
299 /* }}} */
300 
301 /* {{{ dom_register_prop_handler */
dom_register_prop_handler(HashTable * prop_handler,char * name,dom_read_t read_func,dom_write_t write_func)302 static void dom_register_prop_handler(HashTable *prop_handler, char *name, dom_read_t read_func, dom_write_t write_func)
303 {
304 	dom_prop_handler hnd;
305 
306 	hnd.read_func = read_func ? read_func : dom_read_na;
307 	hnd.write_func = write_func ? write_func : dom_write_na;
308 	zend_hash_str_add_mem(prop_handler, name, strlen(name), &hnd, sizeof(dom_prop_handler));
309 }
310 /* }}} */
311 
dom_get_property_ptr_ptr(zval * object,zval * member,int type,void ** cache_slot)312 static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
313 {
314 	dom_object *obj = Z_DOMOBJ_P(object);
315 	zend_string *member_str = zval_get_string(member);
316 	zval *retval = NULL;
317 
318 	if (!obj->prop_handler || !zend_hash_exists(obj->prop_handler, member_str)) {
319 		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
320 		retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot);
321 	}
322 
323 	zend_string_release(member_str);
324 	return retval;
325 }
326 /* }}} */
327 
328 /* {{{ dom_read_property */
dom_read_property(zval * object,zval * member,int type,void ** cache_slot,zval * rv)329 zval *dom_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
330 {
331 	dom_object *obj = Z_DOMOBJ_P(object);
332 	zend_string *member_str = zval_get_string(member);
333 	zval *retval;
334 	dom_prop_handler *hnd = NULL;
335 
336 	if (obj->prop_handler != NULL) {
337 		hnd = zend_hash_find_ptr(obj->prop_handler, member_str);
338 	} else if (instanceof_function(obj->std.ce, dom_node_class_entry)) {
339 		php_error(E_WARNING, "Couldn't fetch %s. Node no longer exists", ZSTR_VAL(obj->std.ce->name));
340 	}
341 
342 	if (hnd) {
343 		int ret = hnd->read_func(obj, rv);
344 		if (ret == SUCCESS) {
345 			retval = rv;
346 		} else {
347 			retval = &EG(uninitialized_zval);
348 		}
349 	} else {
350 		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
351 		retval = std_hnd->read_property(object, member, type, cache_slot, rv);
352 	}
353 
354 	zend_string_release(member_str);
355 	return retval;
356 }
357 /* }}} */
358 
359 /* {{{ dom_write_property */
dom_write_property(zval * object,zval * member,zval * value,void ** cache_slot)360 void dom_write_property(zval *object, zval *member, zval *value, void **cache_slot)
361 {
362 	dom_object *obj = Z_DOMOBJ_P(object);
363 	zend_string *member_str = zval_get_string(member);
364 	dom_prop_handler *hnd = NULL;
365 
366 	if (obj->prop_handler != NULL) {
367 		hnd = zend_hash_find_ptr(obj->prop_handler, member_str);
368 	}
369 	if (hnd) {
370 		hnd->write_func(obj, value);
371 	} else {
372 		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
373 		std_hnd->write_property(object, member, value, cache_slot);
374 	}
375 
376 	zend_string_release(member_str);
377 }
378 /* }}} */
379 
380 /* {{{ dom_property_exists */
dom_property_exists(zval * object,zval * member,int check_empty,void ** cache_slot)381 static int dom_property_exists(zval *object, zval *member, int check_empty, void **cache_slot)
382 {
383 	dom_object *obj = Z_DOMOBJ_P(object);
384 	zend_string *member_str = zval_get_string(member);
385 	dom_prop_handler *hnd = NULL;
386 	int retval = 0;
387 
388 	if (obj->prop_handler != NULL) {
389 		hnd = zend_hash_find_ptr(obj->prop_handler, member_str);
390 	}
391 	if (hnd) {
392 		zval tmp;
393 
394 		if (check_empty == 2) {
395 			retval = 1;
396 		} else if (hnd->read_func(obj, &tmp) == SUCCESS) {
397 			if (check_empty == 1) {
398 				retval = zend_is_true(&tmp);
399 			} else if (check_empty == 0) {
400 				retval = (Z_TYPE(tmp) != IS_NULL);
401 			}
402 			zval_dtor(&tmp);
403 		}
404 	} else {
405 		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
406 		retval = std_hnd->has_property(object, member, check_empty, cache_slot);
407 	}
408 
409 	zend_string_release(member_str);
410 	return retval;
411 }
412 /* }}} */
413 
dom_get_debug_info_helper(zval * object,int * is_temp)414 static HashTable* dom_get_debug_info_helper(zval *object, int *is_temp) /* {{{ */
415 {
416 	dom_object			*obj = Z_DOMOBJ_P(object);
417 	HashTable			*debug_info,
418 						*prop_handlers = obj->prop_handler,
419 						*std_props;
420 	zend_string			*string_key;
421 	dom_prop_handler	*entry;
422 	zend_string         *object_str;
423 
424 	*is_temp = 1;
425 
426 	std_props = zend_std_get_properties(object);
427 	debug_info = zend_array_dup(std_props);
428 
429 	if (!prop_handlers) {
430 		return debug_info;
431 	}
432 
433 	object_str = zend_string_init("(object value omitted)", sizeof("(object value omitted)")-1, 0);
434 
435 	ZEND_HASH_FOREACH_STR_KEY_PTR(prop_handlers, string_key, entry) {
436 		zval value;
437 
438 		if (entry->read_func(obj, &value) == FAILURE || !string_key) {
439 			continue;
440 		}
441 
442 		if (Z_TYPE(value) == IS_OBJECT) {
443 			zval_dtor(&value);
444 			ZVAL_NEW_STR(&value, object_str);
445 			zend_string_addref(object_str);
446 		}
447 
448 		zend_hash_add(debug_info, string_key, &value);
449 	} ZEND_HASH_FOREACH_END();
450 
451 	zend_string_release(object_str);
452 
453 	return debug_info;
454 }
455 /* }}} */
456 
dom_get_debug_info(zval * object,int * is_temp)457 static HashTable* dom_get_debug_info(zval *object, int *is_temp) /* {{{ */
458 {
459        return dom_get_debug_info_helper(object, is_temp);
460 }
461 /* }}} */
462 
php_dom_export_node(zval * object)463 void *php_dom_export_node(zval *object) /* {{{ */
464 {
465 	php_libxml_node_object *intern;
466 	xmlNodePtr nodep = NULL;
467 
468 	intern = (php_libxml_node_object *) Z_DOMOBJ_P(object);
469 	if (intern->node) {
470   		nodep = intern->node->node;
471 	}
472 
473 	return nodep;
474 }
475 /* }}} */
476 
477 /* {{{ proto somNode dom_import_simplexml(sxeobject node)
478    Get a simplexml_element object from dom to allow for processing */
PHP_FUNCTION(dom_import_simplexml)479 PHP_FUNCTION(dom_import_simplexml)
480 {
481 	zval *node;
482 	xmlNodePtr nodep = NULL;
483 	php_libxml_node_object *nodeobj;
484 	int ret;
485 
486 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &node) == FAILURE) {
487 		return;
488 	}
489 
490 	nodeobj = (php_libxml_node_object *) ((char *) Z_OBJ_P(node) - Z_OBJ_HT_P(node)->offset);
491 	nodep = php_libxml_import_node(node);
492 
493 	if (nodep && nodeobj && (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE)) {
494 		DOM_RET_OBJ((xmlNodePtr) nodep, &ret, (dom_object *)nodeobj);
495 	} else {
496 		php_error_docref(NULL, E_WARNING, "Invalid Nodetype to import");
497 		RETURN_NULL();
498 	}
499 }
500 /* }}} */
501 
502 static dom_object* dom_objects_set_class(zend_class_entry *class_type, zend_bool hash_copy);
503 
dom_objects_store_clone_obj(zval * zobject)504 static zend_object *dom_objects_store_clone_obj(zval *zobject) /* {{{ */
505 {
506 	dom_object *intern = Z_DOMOBJ_P(zobject);
507 	dom_object *clone = dom_objects_set_class(intern->std.ce, 0);
508 
509 	clone->std.handlers = dom_get_obj_handlers();
510 
511 	if (instanceof_function(intern->std.ce, dom_node_class_entry)) {
512 		xmlNodePtr node = (xmlNodePtr)dom_object_get_node(intern);
513 		if (node != NULL) {
514 			xmlNodePtr cloned_node = xmlDocCopyNode(node, node->doc, 1);
515 			if (cloned_node != NULL) {
516 				/* If we cloned a document then we must create new doc proxy */
517 				if (cloned_node->doc == node->doc) {
518 					clone->document = intern->document;
519 				}
520 				php_libxml_increment_doc_ref((php_libxml_node_object *)clone, cloned_node->doc);
521 				php_libxml_increment_node_ptr((php_libxml_node_object *)clone, cloned_node, (void *)clone);
522 				if (intern->document != clone->document) {
523 					dom_copy_doc_props(intern->document, clone->document);
524 				}
525 			}
526 
527 		}
528 	}
529 
530 	zend_objects_clone_members(&clone->std, &intern->std);
531 
532 	return &clone->std;
533 }
534 /* }}} */
535 
dom_copy_prop_handler(zval * zv)536 static void dom_copy_prop_handler(zval *zv) /* {{{ */
537 {
538 	dom_prop_handler *hnd = Z_PTR_P(zv);
539 	Z_PTR_P(zv) = malloc(sizeof(dom_prop_handler));
540 	memcpy(Z_PTR_P(zv), hnd, sizeof(dom_prop_handler));
541 }
542 /* }}} */
543 
dom_dtor_prop_handler(zval * zv)544 static void dom_dtor_prop_handler(zval *zv) /* {{{ */
545 {
546 	free(Z_PTR_P(zv));
547 }
548 
549 /* {{{ arginfo */
550 ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_import_simplexml, 0, 0, 1)
551 	ZEND_ARG_INFO(0, node)
552 ZEND_END_ARG_INFO()
553 /* }}} */
554 
555 static const zend_function_entry dom_functions[] = {
556 	PHP_FE(dom_import_simplexml, arginfo_dom_import_simplexml)
557 	PHP_FE_END
558 };
559 
560 static const zend_module_dep dom_deps[] = {
561 	ZEND_MOD_REQUIRED("libxml")
562 	ZEND_MOD_CONFLICTS("domxml")
563 	ZEND_MOD_END
564 };
565 
566 zend_module_entry dom_module_entry = { /* {{{ */
567 	STANDARD_MODULE_HEADER_EX, NULL,
568 	dom_deps,
569 	"dom",
570 	dom_functions,
571 	PHP_MINIT(dom),
572 	PHP_MSHUTDOWN(dom),
573 	NULL,
574 	NULL,
575 	PHP_MINFO(dom),
576 	DOM_API_VERSION, /* Extension versionnumber */
577 	STANDARD_MODULE_PROPERTIES
578 };
579 /* }}} */
580 
581 #ifdef COMPILE_DL_DOM
582 ZEND_GET_MODULE(dom)
583 #endif
584 
585 void dom_objects_free_storage(zend_object *object);
586 void dom_nnodemap_objects_free_storage(zend_object *object);
587 static zend_object *dom_objects_store_clone_obj(zval *zobject);
588 static void dom_nnodemap_object_dtor(zend_object *object);
589 #if defined(LIBXML_XPATH_ENABLED)
590 void dom_xpath_objects_free_storage(zend_object *object);
591 #endif
592 
593 /* {{{ PHP_MINIT_FUNCTION(dom) */
PHP_MINIT_FUNCTION(dom)594 PHP_MINIT_FUNCTION(dom)
595 {
596 	zend_class_entry ce;
597 
598 	memcpy(&dom_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
599 	dom_object_handlers.offset = XtOffsetOf(dom_object, std);
600 	dom_object_handlers.free_obj = dom_objects_free_storage;
601 	dom_object_handlers.read_property = dom_read_property;
602 	dom_object_handlers.write_property = dom_write_property;
603 	dom_object_handlers.get_property_ptr_ptr = dom_get_property_ptr_ptr;
604 	dom_object_handlers.clone_obj = dom_objects_store_clone_obj;
605 	dom_object_handlers.has_property = dom_property_exists;
606 	dom_object_handlers.get_debug_info = dom_get_debug_info;
607 
608 	memcpy(&dom_nnodemap_object_handlers, &dom_object_handlers, sizeof(zend_object_handlers));
609 	dom_nnodemap_object_handlers.free_obj = dom_nnodemap_objects_free_storage;
610 	dom_nnodemap_object_handlers.dtor_obj = dom_nnodemap_object_dtor;
611 	dom_nnodemap_object_handlers.read_dimension = dom_nodelist_read_dimension;
612 	dom_nnodemap_object_handlers.has_dimension = dom_nodelist_has_dimension;
613 
614 	zend_hash_init(&classes, 0, NULL, NULL, 1);
615 
616 	INIT_CLASS_ENTRY(ce, "DOMException", php_dom_domexception_class_functions);
617 	dom_domexception_class_entry = zend_register_internal_class_ex(&ce, zend_ce_exception);
618 	dom_domexception_class_entry->ce_flags |= ZEND_ACC_FINAL;
619 	zend_declare_property_long(dom_domexception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PUBLIC);
620 
621 	REGISTER_DOM_CLASS(ce, "DOMStringList", NULL, php_dom_domstringlist_class_functions, dom_domstringlist_class_entry);
622 
623 	zend_hash_init(&dom_domstringlist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
624 	dom_register_prop_handler(&dom_domstringlist_prop_handlers, "length", dom_domstringlist_length_read, NULL);
625 	zend_hash_add_ptr(&classes, ce.name, &dom_domstringlist_prop_handlers);
626 
627 	REGISTER_DOM_CLASS(ce, "DOMNameList", NULL, php_dom_namelist_class_functions, dom_namelist_class_entry);
628 
629 	zend_hash_init(&dom_namelist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
630 	dom_register_prop_handler(&dom_namelist_prop_handlers, "length", dom_namelist_length_read, NULL);
631 	zend_hash_add_ptr(&classes, ce.name, &dom_namelist_prop_handlers);
632 
633 	REGISTER_DOM_CLASS(ce, "DOMImplementationList", NULL, php_dom_domimplementationlist_class_functions, dom_domimplementationlist_class_entry);
634 
635 	zend_hash_init(&dom_domimplementationlist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
636 	dom_register_prop_handler(&dom_domimplementationlist_prop_handlers, "length", dom_domimplementationlist_length_read, NULL);
637 	zend_hash_add_ptr(&classes, ce.name, &dom_domimplementationlist_prop_handlers);
638 
639 	REGISTER_DOM_CLASS(ce, "DOMImplementationSource", NULL, php_dom_domimplementationsource_class_functions, dom_domimplementationsource_class_entry);
640 	REGISTER_DOM_CLASS(ce, "DOMImplementation", NULL, php_dom_domimplementation_class_functions, dom_domimplementation_class_entry);
641 
642 	REGISTER_DOM_CLASS(ce, "DOMNode", NULL, php_dom_node_class_functions, dom_node_class_entry);
643 
644 	zend_hash_init(&dom_node_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
645 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL);
646 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write);
647 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL);
648 	dom_register_prop_handler(&dom_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL);
649 	dom_register_prop_handler(&dom_node_prop_handlers, "childNodes", dom_node_child_nodes_read, NULL);
650 	dom_register_prop_handler(&dom_node_prop_handlers, "firstChild", dom_node_first_child_read, NULL);
651 	dom_register_prop_handler(&dom_node_prop_handlers, "lastChild", dom_node_last_child_read, NULL);
652 	dom_register_prop_handler(&dom_node_prop_handlers, "previousSibling", dom_node_previous_sibling_read, NULL);
653 	dom_register_prop_handler(&dom_node_prop_handlers, "nextSibling", dom_node_next_sibling_read, NULL);
654 	dom_register_prop_handler(&dom_node_prop_handlers, "attributes", dom_node_attributes_read, NULL);
655 	dom_register_prop_handler(&dom_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL);
656 	dom_register_prop_handler(&dom_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL);
657 	dom_register_prop_handler(&dom_node_prop_handlers, "prefix", dom_node_prefix_read, dom_node_prefix_write);
658 	dom_register_prop_handler(&dom_node_prop_handlers, "localName", dom_node_local_name_read, NULL);
659 	dom_register_prop_handler(&dom_node_prop_handlers, "baseURI", dom_node_base_uri_read, NULL);
660 	dom_register_prop_handler(&dom_node_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write);
661 	zend_hash_add_ptr(&classes, ce.name, &dom_node_prop_handlers);
662 
663 	REGISTER_DOM_CLASS(ce, "DOMNameSpaceNode", NULL, NULL, dom_namespace_node_class_entry);
664 
665 	zend_hash_init(&dom_namespace_node_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
666 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL);
667 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeValue", dom_node_node_value_read, NULL);
668 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL);
669 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "prefix", dom_node_prefix_read, NULL);
670 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "localName", dom_node_local_name_read, NULL);
671 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL);
672 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL);
673 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL);
674 	zend_hash_add_ptr(&classes, ce.name, &dom_namespace_node_prop_handlers);
675 
676 	REGISTER_DOM_CLASS(ce, "DOMDocumentFragment", dom_node_class_entry, php_dom_documentfragment_class_functions, dom_documentfragment_class_entry);
677 	zend_hash_add_ptr(&classes, ce.name, &dom_node_prop_handlers);
678 
679 	REGISTER_DOM_CLASS(ce, "DOMDocument", dom_node_class_entry, php_dom_document_class_functions, dom_document_class_entry);
680 	zend_hash_init(&dom_document_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
681 	dom_register_prop_handler(&dom_document_prop_handlers, "doctype", dom_document_doctype_read, NULL);
682 	dom_register_prop_handler(&dom_document_prop_handlers, "implementation", dom_document_implementation_read, NULL);
683 	dom_register_prop_handler(&dom_document_prop_handlers, "documentElement", dom_document_document_element_read, NULL);
684 	dom_register_prop_handler(&dom_document_prop_handlers, "actualEncoding", dom_document_encoding_read, NULL);
685 	dom_register_prop_handler(&dom_document_prop_handlers, "encoding", dom_document_encoding_read, dom_document_encoding_write);
686 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlEncoding", dom_document_encoding_read, NULL);
687 	dom_register_prop_handler(&dom_document_prop_handlers, "standalone", dom_document_standalone_read, dom_document_standalone_write);
688 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlStandalone", dom_document_standalone_read, dom_document_standalone_write);
689 	dom_register_prop_handler(&dom_document_prop_handlers, "version", dom_document_version_read, dom_document_version_write);
690 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlVersion", dom_document_version_read, dom_document_version_write);
691 	dom_register_prop_handler(&dom_document_prop_handlers, "strictErrorChecking", dom_document_strict_error_checking_read, dom_document_strict_error_checking_write);
692 	dom_register_prop_handler(&dom_document_prop_handlers, "documentURI", dom_document_document_uri_read, dom_document_document_uri_write);
693 	dom_register_prop_handler(&dom_document_prop_handlers, "config", dom_document_config_read, NULL);
694 	dom_register_prop_handler(&dom_document_prop_handlers, "formatOutput", dom_document_format_output_read, dom_document_format_output_write);
695 	dom_register_prop_handler(&dom_document_prop_handlers, "validateOnParse", dom_document_validate_on_parse_read, dom_document_validate_on_parse_write);
696 	dom_register_prop_handler(&dom_document_prop_handlers, "resolveExternals", dom_document_resolve_externals_read, dom_document_resolve_externals_write);
697 	dom_register_prop_handler(&dom_document_prop_handlers, "preserveWhiteSpace", dom_document_preserve_whitespace_read, dom_document_preserve_whitespace_write);
698 	dom_register_prop_handler(&dom_document_prop_handlers, "recover", dom_document_recover_read, dom_document_recover_write);
699 	dom_register_prop_handler(&dom_document_prop_handlers, "substituteEntities", dom_document_substitue_entities_read, dom_document_substitue_entities_write);
700 
701 	zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
702 	zend_hash_add_ptr(&classes, ce.name, &dom_document_prop_handlers);
703 
704 	INIT_CLASS_ENTRY(ce, "DOMNodeList", php_dom_nodelist_class_functions);
705 	ce.create_object = dom_nnodemap_objects_new;
706 	dom_nodelist_class_entry = zend_register_internal_class_ex(&ce, NULL);
707 	dom_nodelist_class_entry->get_iterator = php_dom_get_iterator;
708 	zend_class_implements(dom_nodelist_class_entry, 1, zend_ce_traversable);
709 
710 	zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
711 	dom_register_prop_handler(&dom_nodelist_prop_handlers, "length", dom_nodelist_length_read, NULL);
712 	zend_hash_add_ptr(&classes, ce.name, &dom_nodelist_prop_handlers);
713 
714 	INIT_CLASS_ENTRY(ce, "DOMNamedNodeMap", php_dom_namednodemap_class_functions);
715 	ce.create_object = dom_nnodemap_objects_new;
716 	dom_namednodemap_class_entry = zend_register_internal_class_ex(&ce, NULL);
717 	dom_namednodemap_class_entry->get_iterator = php_dom_get_iterator;
718 	zend_class_implements(dom_namednodemap_class_entry, 1, zend_ce_traversable);
719 
720 	zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
721 	dom_register_prop_handler(&dom_namednodemap_prop_handlers, "length", dom_namednodemap_length_read, NULL);
722 	zend_hash_add_ptr(&classes, ce.name, &dom_namednodemap_prop_handlers);
723 
724 	REGISTER_DOM_CLASS(ce, "DOMCharacterData", dom_node_class_entry, php_dom_characterdata_class_functions, dom_characterdata_class_entry);
725 
726 	zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
727 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "data", dom_characterdata_data_read, dom_characterdata_data_write);
728 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "length", dom_characterdata_length_read, NULL);
729 	zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
730 	zend_hash_add_ptr(&classes, ce.name, &dom_characterdata_prop_handlers);
731 
732 	REGISTER_DOM_CLASS(ce, "DOMAttr", dom_node_class_entry, php_dom_attr_class_functions, dom_attr_class_entry);
733 
734 	zend_hash_init(&dom_attr_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
735 	dom_register_prop_handler(&dom_attr_prop_handlers, "name", dom_attr_name_read, NULL);
736 	dom_register_prop_handler(&dom_attr_prop_handlers, "specified", dom_attr_specified_read, NULL);
737 	dom_register_prop_handler(&dom_attr_prop_handlers, "value", dom_attr_value_read, dom_attr_value_write);
738 	dom_register_prop_handler(&dom_attr_prop_handlers, "ownerElement", dom_attr_owner_element_read, NULL);
739 	dom_register_prop_handler(&dom_attr_prop_handlers, "schemaTypeInfo", dom_attr_schema_type_info_read, NULL);
740 	zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
741 	zend_hash_add_ptr(&classes, ce.name, &dom_attr_prop_handlers);
742 
743 	REGISTER_DOM_CLASS(ce, "DOMElement", dom_node_class_entry, php_dom_element_class_functions, dom_element_class_entry);
744 
745 	zend_hash_init(&dom_element_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
746 	dom_register_prop_handler(&dom_element_prop_handlers, "tagName", dom_element_tag_name_read, NULL);
747 	dom_register_prop_handler(&dom_element_prop_handlers, "schemaTypeInfo", dom_element_schema_type_info_read, NULL);
748 	zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
749 	zend_hash_add_ptr(&classes, ce.name, &dom_element_prop_handlers);
750 
751 	REGISTER_DOM_CLASS(ce, "DOMText", dom_characterdata_class_entry, php_dom_text_class_functions, dom_text_class_entry);
752 
753 	zend_hash_init(&dom_text_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
754 	dom_register_prop_handler(&dom_text_prop_handlers, "wholeText", dom_text_whole_text_read, NULL);
755 	zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, dom_copy_prop_handler, 0);
756 	zend_hash_add_ptr(&classes, ce.name, &dom_text_prop_handlers);
757 
758 	REGISTER_DOM_CLASS(ce, "DOMComment", dom_characterdata_class_entry, php_dom_comment_class_functions, dom_comment_class_entry);
759 	zend_hash_add_ptr(&classes, ce.name, &dom_characterdata_prop_handlers);
760 
761 	REGISTER_DOM_CLASS(ce, "DOMTypeinfo", NULL, php_dom_typeinfo_class_functions, dom_typeinfo_class_entry);
762 
763 	zend_hash_init(&dom_typeinfo_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
764 	dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeName", dom_typeinfo_type_name_read, NULL);
765 	dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeNamespace", dom_typeinfo_type_namespace_read, NULL);
766 	zend_hash_add_ptr(&classes, ce.name, &dom_typeinfo_prop_handlers);
767 
768 	REGISTER_DOM_CLASS(ce, "DOMUserDataHandler", NULL, php_dom_userdatahandler_class_functions, dom_userdatahandler_class_entry);
769 	REGISTER_DOM_CLASS(ce, "DOMDomError", NULL, php_dom_domerror_class_functions, dom_domerror_class_entry);
770 
771 	zend_hash_init(&dom_domerror_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
772 	dom_register_prop_handler(&dom_domerror_prop_handlers, "severity", dom_domerror_severity_read, NULL);
773 	dom_register_prop_handler(&dom_domerror_prop_handlers, "message", dom_domerror_message_read, NULL);
774 	dom_register_prop_handler(&dom_domerror_prop_handlers, "type", dom_domerror_type_read, NULL);
775 	dom_register_prop_handler(&dom_domerror_prop_handlers, "relatedException", dom_domerror_related_exception_read, NULL);
776 	dom_register_prop_handler(&dom_domerror_prop_handlers, "related_data", dom_domerror_related_data_read, NULL);
777 	dom_register_prop_handler(&dom_domerror_prop_handlers, "location", dom_domerror_location_read, NULL);
778 	zend_hash_add_ptr(&classes, ce.name, &dom_domerror_prop_handlers);
779 
780 	REGISTER_DOM_CLASS(ce, "DOMErrorHandler", NULL, php_dom_domerrorhandler_class_functions, dom_domerrorhandler_class_entry);
781 	REGISTER_DOM_CLASS(ce, "DOMLocator", NULL, php_dom_domlocator_class_functions, dom_domlocator_class_entry);
782 
783 	zend_hash_init(&dom_domlocator_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
784 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "lineNumber", dom_domlocator_line_number_read, NULL);
785 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "columnNumber", dom_domlocator_column_number_read, NULL);
786 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "offset", dom_domlocator_offset_read, NULL);
787 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "relatedNode", dom_domlocator_related_node_read, NULL);
788 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "uri", dom_domlocator_uri_read, NULL);
789 	zend_hash_add_ptr(&classes, ce.name, &dom_domlocator_prop_handlers);
790 
791 	REGISTER_DOM_CLASS(ce, "DOMConfiguration", NULL, php_dom_domconfiguration_class_functions, dom_domconfiguration_class_entry);
792 	REGISTER_DOM_CLASS(ce, "DOMCdataSection", dom_text_class_entry, php_dom_cdatasection_class_functions, dom_cdatasection_class_entry);
793 	zend_hash_add_ptr(&classes, ce.name, &dom_text_prop_handlers);
794 
795 	REGISTER_DOM_CLASS(ce, "DOMDocumentType", dom_node_class_entry, php_dom_documenttype_class_functions, dom_documenttype_class_entry);
796 
797 	zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
798 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "name", dom_documenttype_name_read, NULL);
799 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "entities", dom_documenttype_entities_read, NULL);
800 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "notations", dom_documenttype_notations_read, NULL);
801 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "publicId", dom_documenttype_public_id_read, NULL);
802 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "systemId", dom_documenttype_system_id_read, NULL);
803 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "internalSubset", dom_documenttype_internal_subset_read, NULL);
804 	zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
805 	zend_hash_add_ptr(&classes, ce.name, &dom_documenttype_prop_handlers);
806 
807 	REGISTER_DOM_CLASS(ce, "DOMNotation", dom_node_class_entry, php_dom_notation_class_functions, dom_notation_class_entry);
808 
809 	zend_hash_init(&dom_notation_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
810 	dom_register_prop_handler(&dom_notation_prop_handlers, "publicId", dom_notation_public_id_read, NULL);
811 	dom_register_prop_handler(&dom_notation_prop_handlers, "systemId", dom_notation_system_id_read, NULL);
812 	zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
813 	zend_hash_add_ptr(&classes, ce.name, &dom_notation_prop_handlers);
814 
815 	REGISTER_DOM_CLASS(ce, "DOMEntity", dom_node_class_entry, php_dom_entity_class_functions, dom_entity_class_entry);
816 
817 	zend_hash_init(&dom_entity_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
818 	dom_register_prop_handler(&dom_entity_prop_handlers, "publicId", dom_entity_public_id_read, NULL);
819 	dom_register_prop_handler(&dom_entity_prop_handlers, "systemId", dom_entity_system_id_read, NULL);
820 	dom_register_prop_handler(&dom_entity_prop_handlers, "notationName", dom_entity_notation_name_read, NULL);
821 	dom_register_prop_handler(&dom_entity_prop_handlers, "actualEncoding", dom_entity_actual_encoding_read, dom_entity_actual_encoding_write);
822 	dom_register_prop_handler(&dom_entity_prop_handlers, "encoding", dom_entity_encoding_read, dom_entity_encoding_write);
823 	dom_register_prop_handler(&dom_entity_prop_handlers, "version", dom_entity_version_read, dom_entity_version_write);
824 	zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
825 	zend_hash_add_ptr(&classes, ce.name, &dom_entity_prop_handlers);
826 
827 	REGISTER_DOM_CLASS(ce, "DOMEntityReference", dom_node_class_entry, php_dom_entityreference_class_functions, dom_entityreference_class_entry);
828 	zend_hash_add_ptr(&classes, ce.name, &dom_node_prop_handlers);
829 
830 	REGISTER_DOM_CLASS(ce, "DOMProcessingInstruction", dom_node_class_entry, php_dom_processinginstruction_class_functions, dom_processinginstruction_class_entry);
831 
832 	zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
833 	dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "target", dom_processinginstruction_target_read, NULL);
834 	dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "data", dom_processinginstruction_data_read, dom_processinginstruction_data_write);
835 	zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
836 	zend_hash_add_ptr(&classes, ce.name, &dom_processinginstruction_prop_handlers);
837 
838 	REGISTER_DOM_CLASS(ce, "DOMStringExtend", NULL, php_dom_string_extend_class_functions, dom_string_extend_class_entry);
839 
840 #if defined(LIBXML_XPATH_ENABLED)
841 	memcpy(&dom_xpath_object_handlers, &dom_object_handlers, sizeof(zend_object_handlers));
842 	dom_xpath_object_handlers.offset = XtOffsetOf(dom_xpath_object, dom) + XtOffsetOf(dom_object, std);
843 	dom_xpath_object_handlers.free_obj = dom_xpath_objects_free_storage;
844 
845 	INIT_CLASS_ENTRY(ce, "DOMXPath", php_dom_xpath_class_functions);
846 	ce.create_object = dom_xpath_objects_new;
847 	dom_xpath_class_entry = zend_register_internal_class_ex(&ce, NULL);
848 
849 	zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
850 	dom_register_prop_handler(&dom_xpath_prop_handlers, "document", dom_xpath_document_read, NULL);
851 	zend_hash_add_ptr(&classes, ce.name, &dom_xpath_prop_handlers);
852 #endif
853 
854 	REGISTER_LONG_CONSTANT("XML_ELEMENT_NODE",			XML_ELEMENT_NODE,			CONST_CS | CONST_PERSISTENT);
855 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NODE",		XML_ATTRIBUTE_NODE,			CONST_CS | CONST_PERSISTENT);
856 	REGISTER_LONG_CONSTANT("XML_TEXT_NODE",				XML_TEXT_NODE,				CONST_CS | CONST_PERSISTENT);
857 	REGISTER_LONG_CONSTANT("XML_CDATA_SECTION_NODE",	XML_CDATA_SECTION_NODE,		CONST_CS | CONST_PERSISTENT);
858 	REGISTER_LONG_CONSTANT("XML_ENTITY_REF_NODE",		XML_ENTITY_REF_NODE,		CONST_CS | CONST_PERSISTENT);
859 	REGISTER_LONG_CONSTANT("XML_ENTITY_NODE",			XML_ENTITY_NODE,			CONST_CS | CONST_PERSISTENT);
860 	REGISTER_LONG_CONSTANT("XML_PI_NODE",				XML_PI_NODE,				CONST_CS | CONST_PERSISTENT);
861 	REGISTER_LONG_CONSTANT("XML_COMMENT_NODE",			XML_COMMENT_NODE,			CONST_CS | CONST_PERSISTENT);
862 	REGISTER_LONG_CONSTANT("XML_DOCUMENT_NODE",			XML_DOCUMENT_NODE,			CONST_CS | CONST_PERSISTENT);
863 	REGISTER_LONG_CONSTANT("XML_DOCUMENT_TYPE_NODE",	XML_DOCUMENT_TYPE_NODE,		CONST_CS | CONST_PERSISTENT);
864 	REGISTER_LONG_CONSTANT("XML_DOCUMENT_FRAG_NODE",	XML_DOCUMENT_FRAG_NODE,		CONST_CS | CONST_PERSISTENT);
865 	REGISTER_LONG_CONSTANT("XML_NOTATION_NODE",			XML_NOTATION_NODE,			CONST_CS | CONST_PERSISTENT);
866 	REGISTER_LONG_CONSTANT("XML_HTML_DOCUMENT_NODE",	XML_HTML_DOCUMENT_NODE,		CONST_CS | CONST_PERSISTENT);
867 	REGISTER_LONG_CONSTANT("XML_DTD_NODE",				XML_DTD_NODE,				CONST_CS | CONST_PERSISTENT);
868 	REGISTER_LONG_CONSTANT("XML_ELEMENT_DECL_NODE", 	XML_ELEMENT_DECL,			CONST_CS | CONST_PERSISTENT);
869 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_DECL_NODE",	XML_ATTRIBUTE_DECL,			CONST_CS | CONST_PERSISTENT);
870 	REGISTER_LONG_CONSTANT("XML_ENTITY_DECL_NODE",		XML_ENTITY_DECL,			CONST_CS | CONST_PERSISTENT);
871 	REGISTER_LONG_CONSTANT("XML_NAMESPACE_DECL_NODE",	XML_NAMESPACE_DECL,			CONST_CS | CONST_PERSISTENT);
872 #ifdef XML_GLOBAL_NAMESPACE
873 	REGISTER_LONG_CONSTANT("XML_GLOBAL_NAMESPACE",		XML_GLOBAL_NAMESPACE,		CONST_CS | CONST_PERSISTENT);
874 #endif
875 	REGISTER_LONG_CONSTANT("XML_LOCAL_NAMESPACE",		XML_LOCAL_NAMESPACE,		CONST_CS | CONST_PERSISTENT);
876 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_CDATA",		XML_ATTRIBUTE_CDATA,		CONST_CS | CONST_PERSISTENT);
877 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ID",			XML_ATTRIBUTE_ID,			CONST_CS | CONST_PERSISTENT);
878 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREF",		XML_ATTRIBUTE_IDREF,		CONST_CS | CONST_PERSISTENT);
879 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREFS",		XML_ATTRIBUTE_IDREFS,		CONST_CS | CONST_PERSISTENT);
880 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENTITY",		XML_ATTRIBUTE_ENTITIES,		CONST_CS | CONST_PERSISTENT);
881 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKEN",		XML_ATTRIBUTE_NMTOKEN,		CONST_CS | CONST_PERSISTENT);
882 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKENS",	XML_ATTRIBUTE_NMTOKENS,		CONST_CS | CONST_PERSISTENT);
883 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENUMERATION",	XML_ATTRIBUTE_ENUMERATION,	CONST_CS | CONST_PERSISTENT);
884 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NOTATION",	XML_ATTRIBUTE_NOTATION,		CONST_CS | CONST_PERSISTENT);
885 
886 	/* DOMException Codes */
887 	REGISTER_LONG_CONSTANT("DOM_PHP_ERR",				PHP_ERR,				CONST_CS | CONST_PERSISTENT);
888 	REGISTER_LONG_CONSTANT("DOM_INDEX_SIZE_ERR",		INDEX_SIZE_ERR,			CONST_CS | CONST_PERSISTENT);
889 	REGISTER_LONG_CONSTANT("DOMSTRING_SIZE_ERR",		DOMSTRING_SIZE_ERR,		CONST_CS | CONST_PERSISTENT);
890 	REGISTER_LONG_CONSTANT("DOM_HIERARCHY_REQUEST_ERR",	HIERARCHY_REQUEST_ERR,	CONST_CS | CONST_PERSISTENT);
891 	REGISTER_LONG_CONSTANT("DOM_WRONG_DOCUMENT_ERR",	WRONG_DOCUMENT_ERR,		CONST_CS | CONST_PERSISTENT);
892 	REGISTER_LONG_CONSTANT("DOM_INVALID_CHARACTER_ERR",	INVALID_CHARACTER_ERR,	CONST_CS | CONST_PERSISTENT);
893 	REGISTER_LONG_CONSTANT("DOM_NO_DATA_ALLOWED_ERR",	NO_DATA_ALLOWED_ERR,	CONST_CS | CONST_PERSISTENT);
894 	REGISTER_LONG_CONSTANT("DOM_NO_MODIFICATION_ALLOWED_ERR", NO_MODIFICATION_ALLOWED_ERR, CONST_CS | CONST_PERSISTENT);
895 	REGISTER_LONG_CONSTANT("DOM_NOT_FOUND_ERR",			NOT_FOUND_ERR,			CONST_CS | CONST_PERSISTENT);
896 	REGISTER_LONG_CONSTANT("DOM_NOT_SUPPORTED_ERR",		NOT_SUPPORTED_ERR,		CONST_CS | CONST_PERSISTENT);
897 	REGISTER_LONG_CONSTANT("DOM_INUSE_ATTRIBUTE_ERR",	INUSE_ATTRIBUTE_ERR,	CONST_CS | CONST_PERSISTENT);
898 	REGISTER_LONG_CONSTANT("DOM_INVALID_STATE_ERR",		INVALID_STATE_ERR,		CONST_CS | CONST_PERSISTENT);
899 	REGISTER_LONG_CONSTANT("DOM_SYNTAX_ERR",			SYNTAX_ERR,				CONST_CS | CONST_PERSISTENT);
900 	REGISTER_LONG_CONSTANT("DOM_INVALID_MODIFICATION_ERR",	INVALID_MODIFICATION_ERR, CONST_CS | CONST_PERSISTENT);
901 	REGISTER_LONG_CONSTANT("DOM_NAMESPACE_ERR",			NAMESPACE_ERR,			CONST_CS | CONST_PERSISTENT);
902 	REGISTER_LONG_CONSTANT("DOM_INVALID_ACCESS_ERR",	INVALID_ACCESS_ERR,		CONST_CS | CONST_PERSISTENT);
903 	REGISTER_LONG_CONSTANT("DOM_VALIDATION_ERR",		VALIDATION_ERR,			CONST_CS | CONST_PERSISTENT);
904 
905 	php_libxml_register_export(dom_node_class_entry, php_dom_export_node);
906 
907 	return SUCCESS;
908 }
909 /* }}} */
910 
911 /* {{{ */
PHP_MINFO_FUNCTION(dom)912 PHP_MINFO_FUNCTION(dom)
913 {
914 	php_info_print_table_start();
915 	php_info_print_table_row(2, "DOM/XML", "enabled");
916 	php_info_print_table_row(2, "DOM/XML API Version", DOM_API_VERSION);
917 	php_info_print_table_row(2, "libxml Version", LIBXML_DOTTED_VERSION);
918 #if defined(LIBXML_HTML_ENABLED)
919 	php_info_print_table_row(2, "HTML Support", "enabled");
920 #endif
921 #if defined(LIBXML_XPATH_ENABLED)
922 	php_info_print_table_row(2, "XPath Support", "enabled");
923 #endif
924 #if defined(LIBXML_XPTR_ENABLED)
925 	php_info_print_table_row(2, "XPointer Support", "enabled");
926 #endif
927 #ifdef LIBXML_SCHEMAS_ENABLED
928 	php_info_print_table_row(2, "Schema Support", "enabled");
929 	php_info_print_table_row(2, "RelaxNG Support", "enabled");
930 #endif
931 	php_info_print_table_end();
932 }
933 /* }}} */
934 
PHP_MSHUTDOWN_FUNCTION(dom)935 PHP_MSHUTDOWN_FUNCTION(dom) /* {{{ */
936 {
937 	zend_hash_destroy(&dom_domstringlist_prop_handlers);
938 	zend_hash_destroy(&dom_namelist_prop_handlers);
939 	zend_hash_destroy(&dom_domimplementationlist_prop_handlers);
940 	zend_hash_destroy(&dom_document_prop_handlers);
941 	zend_hash_destroy(&dom_node_prop_handlers);
942 	zend_hash_destroy(&dom_namespace_node_prop_handlers);
943 	zend_hash_destroy(&dom_nodelist_prop_handlers);
944 	zend_hash_destroy(&dom_namednodemap_prop_handlers);
945 	zend_hash_destroy(&dom_characterdata_prop_handlers);
946 	zend_hash_destroy(&dom_attr_prop_handlers);
947 	zend_hash_destroy(&dom_element_prop_handlers);
948 	zend_hash_destroy(&dom_text_prop_handlers);
949 	zend_hash_destroy(&dom_typeinfo_prop_handlers);
950 	zend_hash_destroy(&dom_domerror_prop_handlers);
951 	zend_hash_destroy(&dom_domlocator_prop_handlers);
952 	zend_hash_destroy(&dom_documenttype_prop_handlers);
953 	zend_hash_destroy(&dom_notation_prop_handlers);
954 	zend_hash_destroy(&dom_entity_prop_handlers);
955 	zend_hash_destroy(&dom_processinginstruction_prop_handlers);
956 #if defined(LIBXML_XPATH_ENABLED)
957 	zend_hash_destroy(&dom_xpath_prop_handlers);
958 #endif
959 	zend_hash_destroy(&classes);
960 
961 /*	If you want do find memleaks in this module, compile libxml2 with --with-mem-debug and
962 	uncomment the following line, this will tell you the amount of not freed memory
963 	and the total used memory into apaches error_log  */
964 /*  xmlMemoryDump();*/
965 
966 	return SUCCESS;
967 }
968 /* }}} */
969 
970 /* {{{ node_list_unlink */
node_list_unlink(xmlNodePtr node)971 void node_list_unlink(xmlNodePtr node)
972 {
973 	dom_object *wrapper;
974 
975 	while (node != NULL) {
976 
977 		wrapper = php_dom_object_get_data(node);
978 
979 		if (wrapper != NULL ) {
980 			xmlUnlinkNode(node);
981 		} else {
982 			if (node->type == XML_ENTITY_REF_NODE)
983 				break;
984 			node_list_unlink(node->children);
985 
986 			switch (node->type) {
987 				case XML_ATTRIBUTE_DECL:
988 				case XML_DTD_NODE:
989 				case XML_DOCUMENT_TYPE_NODE:
990 				case XML_ENTITY_DECL:
991 				case XML_ATTRIBUTE_NODE:
992 				case XML_TEXT_NODE:
993 					break;
994 				default:
995 					node_list_unlink((xmlNodePtr) node->properties);
996 			}
997 
998 		}
999 
1000 		node = node->next;
1001 	}
1002 }
1003 /* }}} end node_list_unlink */
1004 
1005 #if defined(LIBXML_XPATH_ENABLED)
1006 /* {{{ dom_xpath_objects_free_storage */
dom_xpath_objects_free_storage(zend_object * object)1007 void dom_xpath_objects_free_storage(zend_object *object)
1008 {
1009 	dom_xpath_object *intern = php_xpath_obj_from_obj(object);
1010 
1011 	zend_object_std_dtor(&intern->dom.std);
1012 
1013 	if (intern->dom.ptr != NULL) {
1014 		xmlXPathFreeContext((xmlXPathContextPtr) intern->dom.ptr);
1015 		php_libxml_decrement_doc_ref((php_libxml_node_object *) &intern->dom);
1016 	}
1017 
1018 	if (intern->registered_phpfunctions) {
1019 		zend_hash_destroy(intern->registered_phpfunctions);
1020 		FREE_HASHTABLE(intern->registered_phpfunctions);
1021 	}
1022 
1023 	if (intern->node_list) {
1024 		zend_hash_destroy(intern->node_list);
1025 		FREE_HASHTABLE(intern->node_list);
1026 	}
1027 }
1028 /* }}} */
1029 #endif
1030 
1031 /* {{{ dom_objects_free_storage */
dom_objects_free_storage(zend_object * object)1032 void dom_objects_free_storage(zend_object *object)
1033 {
1034 	dom_object *intern = php_dom_obj_from_obj(object);
1035 #if defined(__GNUC__) && __GNUC__ >= 3
1036 	int retcount __attribute__((unused)); /* keep compiler quiet */
1037 #else
1038 	int retcount;
1039 #endif
1040 
1041 	zend_object_std_dtor(&intern->std);
1042 
1043 	if (intern->ptr != NULL && ((php_libxml_node_ptr *)intern->ptr)->node != NULL) {
1044 		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) {
1045 			php_libxml_node_decrement_resource((php_libxml_node_object *) intern);
1046 		} else {
1047 			php_libxml_decrement_node_ptr((php_libxml_node_object *) intern);
1048 			retcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
1049 		}
1050 		intern->ptr = NULL;
1051 	}
1052 }
1053 /* }}} */
1054 
dom_namednode_iter(dom_object * basenode,int ntype,dom_object * intern,xmlHashTablePtr ht,xmlChar * local,xmlChar * ns)1055 void dom_namednode_iter(dom_object *basenode, int ntype, dom_object *intern, xmlHashTablePtr ht, xmlChar *local, xmlChar *ns) /* {{{ */
1056 {
1057 	dom_nnodemap_object *mapptr = (dom_nnodemap_object *) intern->ptr;
1058 
1059 	ZEND_ASSERT(basenode != NULL);
1060 
1061 	ZVAL_OBJ(&mapptr->baseobj_zv, &basenode->std);
1062 	Z_ADDREF(mapptr->baseobj_zv);
1063 
1064 	mapptr->baseobj = basenode;
1065 	mapptr->nodetype = ntype;
1066 	mapptr->ht = ht;
1067 	mapptr->local = local;
1068 	mapptr->ns = ns;
1069 }
1070 /* }}} */
1071 
dom_objects_set_class(zend_class_entry * class_type,zend_bool hash_copy)1072 static dom_object* dom_objects_set_class(zend_class_entry *class_type, zend_bool hash_copy) /* {{{ */
1073 {
1074 	dom_object *intern = ecalloc(1, sizeof(dom_object) + zend_object_properties_size(class_type));
1075 
1076 	zend_class_entry *base_class = class_type;
1077 	while ((base_class->type != ZEND_INTERNAL_CLASS || base_class->info.internal.module->module_number != dom_module_entry.module_number) && base_class->parent != NULL) {
1078 		base_class = base_class->parent;
1079 	}
1080 
1081 	intern->prop_handler = zend_hash_find_ptr(&classes, base_class->name);
1082 
1083 	zend_object_std_init(&intern->std, class_type);
1084 	if (hash_copy) {
1085 		object_properties_init(&intern->std, class_type);
1086 	}
1087 
1088 	return intern;
1089 }
1090 /* }}} */
1091 
1092 /* {{{ dom_objects_new */
dom_objects_new(zend_class_entry * class_type)1093 zend_object *dom_objects_new(zend_class_entry *class_type)
1094 {
1095 	dom_object *intern = dom_objects_set_class(class_type, 1);
1096 	intern->std.handlers = dom_get_obj_handlers();
1097 	return &intern->std;
1098 }
1099 /* }}} */
1100 
1101 #if defined(LIBXML_XPATH_ENABLED)
1102 /* {{{ zend_object dom_xpath_objects_new(zend_class_entry *class_type) */
dom_xpath_objects_new(zend_class_entry * class_type)1103 zend_object *dom_xpath_objects_new(zend_class_entry *class_type)
1104 {
1105 	dom_xpath_object *intern = ecalloc(1, sizeof(dom_xpath_object) + zend_object_properties_size(class_type));
1106 
1107 	ALLOC_HASHTABLE(intern->registered_phpfunctions);
1108 	zend_hash_init(intern->registered_phpfunctions, 0, NULL, ZVAL_PTR_DTOR, 0);
1109 
1110 	intern->dom.prop_handler = &dom_xpath_prop_handlers;
1111 	intern->dom.std.handlers = &dom_xpath_object_handlers;
1112 
1113 	zend_object_std_init(&intern->dom.std, class_type);
1114 	object_properties_init(&intern->dom.std, class_type);
1115 
1116 	return &intern->dom.std;
1117 }
1118 /* }}} */
1119 #endif
1120 
dom_nnodemap_object_dtor(zend_object * object)1121 static void dom_nnodemap_object_dtor(zend_object *object) /* {{{ */
1122 {
1123 	dom_object *intern;
1124 	dom_nnodemap_object *objmap;
1125 
1126 	intern = php_dom_obj_from_obj(object);
1127 	objmap = (dom_nnodemap_object *)intern->ptr;
1128 
1129 	if (objmap) {
1130 		if (objmap->local) {
1131 			xmlFree(objmap->local);
1132 		}
1133 		if (objmap->ns) {
1134 			xmlFree(objmap->ns);
1135 		}
1136 		if (!Z_ISUNDEF(objmap->baseobj_zv)) {
1137 			zval_ptr_dtor(&objmap->baseobj_zv);
1138 		}
1139 		efree(objmap);
1140 		intern->ptr = NULL;
1141 	}
1142 }
1143 /* }}} */
1144 
dom_nnodemap_objects_free_storage(zend_object * object)1145 void dom_nnodemap_objects_free_storage(zend_object *object) /* {{{ */
1146 {
1147 	dom_object *intern = php_dom_obj_from_obj(object);
1148 
1149 	php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
1150 
1151 	zend_object_std_dtor(&intern->std);
1152 }
1153 /* }}} */
1154 
dom_nnodemap_objects_new(zend_class_entry * class_type)1155 zend_object *dom_nnodemap_objects_new(zend_class_entry *class_type) /* {{{ */
1156 {
1157 	dom_object *intern;
1158 	dom_nnodemap_object *objmap;
1159 
1160 	intern = dom_objects_set_class(class_type, 1);
1161 	intern->ptr = emalloc(sizeof(dom_nnodemap_object));
1162 	objmap = (dom_nnodemap_object *)intern->ptr;
1163 	ZVAL_UNDEF(&objmap->baseobj_zv);
1164 	objmap->baseobj = NULL;
1165 	objmap->nodetype = 0;
1166 	objmap->ht = NULL;
1167 	objmap->local = NULL;
1168 	objmap->ns = NULL;
1169 
1170 	intern->std.handlers = &dom_nnodemap_object_handlers;
1171 
1172 	return &intern->std;
1173 }
1174 /* }}} */
1175 
php_dom_create_interator(zval * return_value,int ce_type)1176 void php_dom_create_interator(zval *return_value, int ce_type) /* {{{ */
1177 {
1178 	zend_class_entry *ce;
1179 
1180 	if (ce_type == DOM_NAMEDNODEMAP) {
1181 		ce = dom_namednodemap_class_entry;
1182 	} else {
1183 		ce = dom_nodelist_class_entry;
1184 	}
1185 
1186 	object_init_ex(return_value, ce);
1187 }
1188 /* }}} */
1189 
1190 /* {{{ php_dom_create_object */
php_dom_create_object(xmlNodePtr obj,zval * return_value,dom_object * domobj)1191 PHP_DOM_EXPORT zend_bool php_dom_create_object(xmlNodePtr obj, zval *return_value, dom_object *domobj)
1192 {
1193 	zend_class_entry *ce;
1194 	dom_object *intern;
1195 
1196 	if (!obj) {
1197 		ZVAL_NULL(return_value);
1198 		return 0;
1199 	}
1200 
1201 	if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
1202 		GC_REFCOUNT(&intern->std)++;
1203 		ZVAL_OBJ(return_value, &intern->std);
1204 		return 1;
1205 	}
1206 
1207 	switch (obj->type) {
1208 		case XML_DOCUMENT_NODE:
1209 		case XML_HTML_DOCUMENT_NODE:
1210 		{
1211 			ce = dom_document_class_entry;
1212 			break;
1213 		}
1214 		case XML_DTD_NODE:
1215 		case XML_DOCUMENT_TYPE_NODE:
1216 		{
1217 			ce = dom_documenttype_class_entry;
1218 			break;
1219 		}
1220 		case XML_ELEMENT_NODE:
1221 		{
1222 			ce = dom_element_class_entry;
1223 			break;
1224 		}
1225 		case XML_ATTRIBUTE_NODE:
1226 		{
1227 			ce = dom_attr_class_entry;
1228 			break;
1229 		}
1230 		case XML_TEXT_NODE:
1231 		{
1232 			ce = dom_text_class_entry;
1233 			break;
1234 		}
1235 		case XML_COMMENT_NODE:
1236 		{
1237 			ce = dom_comment_class_entry;
1238 			break;
1239 		}
1240 		case XML_PI_NODE:
1241 		{
1242 			ce = dom_processinginstruction_class_entry;
1243 			break;
1244 		}
1245 		case XML_ENTITY_REF_NODE:
1246 		{
1247 			ce = dom_entityreference_class_entry;
1248 			break;
1249 		}
1250 		case XML_ENTITY_DECL:
1251 		case XML_ELEMENT_DECL:
1252 		{
1253 			ce = dom_entity_class_entry;
1254 			break;
1255 		}
1256 		case XML_CDATA_SECTION_NODE:
1257 		{
1258 			ce = dom_cdatasection_class_entry;
1259 			break;
1260 		}
1261 		case XML_DOCUMENT_FRAG_NODE:
1262 		{
1263 			ce = dom_documentfragment_class_entry;
1264 			break;
1265 		}
1266 		case XML_NOTATION_NODE:
1267 		{
1268 			ce = dom_notation_class_entry;
1269 			break;
1270 		}
1271 		case XML_NAMESPACE_DECL:
1272 		{
1273 			ce = dom_namespace_node_class_entry;
1274 			break;
1275 		}
1276 		default:
1277 			php_error_docref(NULL, E_WARNING, "Unsupported node type: %d", obj->type);
1278 			ZVAL_NULL(return_value);
1279 			return 0;
1280 	}
1281 
1282 	if (domobj && domobj->document) {
1283 		ce = dom_get_doc_classmap(domobj->document, ce);
1284 	}
1285 	object_init_ex(return_value, ce);
1286 
1287 	intern = Z_DOMOBJ_P(return_value);
1288 	if (obj->doc != NULL) {
1289 		if (domobj != NULL) {
1290 			intern->document = domobj->document;
1291 		}
1292 		php_libxml_increment_doc_ref((php_libxml_node_object *)intern, obj->doc);
1293 	}
1294 
1295 	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, obj, (void *)intern);
1296 	return 0;
1297 }
1298 /* }}} end php_domobject_new */
1299 
php_dom_create_implementation(zval * retval)1300 void php_dom_create_implementation(zval *retval) {
1301 	object_init_ex(retval, dom_domimplementation_class_entry);
1302 }
1303 
1304 /* {{{ int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) */
dom_hierarchy(xmlNodePtr parent,xmlNodePtr child)1305 int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child)
1306 {
1307 	xmlNodePtr nodep;
1308 
1309     if (parent == NULL || child == NULL || child->doc != parent->doc) {
1310         return SUCCESS;
1311     }
1312 
1313 	nodep = parent;
1314 
1315 	while (nodep) {
1316 		if (nodep == child) {
1317 			return FAILURE;
1318 		}
1319 		nodep = nodep->parent;
1320 	}
1321 
1322     return SUCCESS;
1323 }
1324 /* }}} end dom_hierarchy */
1325 
1326 /* {{{ dom_has_feature(char *feature, char *version) */
dom_has_feature(char * feature,char * version)1327 int dom_has_feature(char *feature, char *version)
1328 {
1329 	int retval = 0;
1330 
1331 	if (!(strcmp (version, "1.0") && strcmp (version,"2.0") && strcmp(version, ""))) {
1332 		if ((!strcasecmp(feature, "Core") && !strcmp (version, "1.0")) || !strcasecmp(feature, "XML"))
1333 			retval = 1;
1334 	}
1335 
1336 	return retval;
1337 }
1338 /* }}} end dom_has_feature */
1339 
dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep,char * ns,char * local,int * cur,int index)1340 xmlNode *dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep, char *ns, char *local, int *cur, int index) /* {{{ */
1341 {
1342 	xmlNodePtr ret = NULL;
1343 
1344 	while (nodep != NULL && (*cur <= index || index == -1)) {
1345 		if (nodep->type == XML_ELEMENT_NODE) {
1346 			if (xmlStrEqual(nodep->name, (xmlChar *)local) || xmlStrEqual((xmlChar *)"*", (xmlChar *)local)) {
1347 				if (ns == NULL || (!strcmp(ns, "") && nodep->ns == NULL) || (nodep->ns != NULL && (xmlStrEqual(nodep->ns->href, (xmlChar *)ns) || xmlStrEqual((xmlChar *)"*", (xmlChar *)ns)))) {
1348 					if (*cur == index) {
1349 						ret = nodep;
1350 						break;
1351 					}
1352 					(*cur)++;
1353 				}
1354 			}
1355 			ret = dom_get_elements_by_tag_name_ns_raw(nodep->children, ns, local, cur, index);
1356 			if (ret != NULL) {
1357 				break;
1358 			}
1359 		}
1360 		nodep = nodep->next;
1361 	}
1362 	return ret;
1363 }
1364 /* }}} */
1365 /* }}} end dom_element_get_elements_by_tag_name_ns_raw */
1366 
1367 /* {{{ void dom_normalize (xmlNodePtr nodep) */
dom_normalize(xmlNodePtr nodep)1368 void dom_normalize (xmlNodePtr nodep)
1369 {
1370 	xmlNodePtr child, nextp, newnextp;
1371 	xmlAttrPtr attr;
1372 	xmlChar	*strContent;
1373 
1374 	child = nodep->children;
1375 	while(child != NULL) {
1376 		switch (child->type) {
1377 			case XML_TEXT_NODE:
1378 				nextp = child->next;
1379 				while (nextp != NULL) {
1380 					if (nextp->type == XML_TEXT_NODE) {
1381 						newnextp = nextp->next;
1382 						strContent = xmlNodeGetContent(nextp);
1383 						xmlNodeAddContent(child, strContent);
1384 						xmlFree(strContent);
1385 						xmlUnlinkNode(nextp);
1386 						php_libxml_node_free_resource(nextp);
1387 						nextp = newnextp;
1388 					} else {
1389 						break;
1390 					}
1391 				}
1392 				break;
1393 			case XML_ELEMENT_NODE:
1394 				dom_normalize (child);
1395 				attr = child->properties;
1396 				while (attr != NULL) {
1397 					dom_normalize((xmlNodePtr) attr);
1398 					attr = attr->next;
1399 				}
1400 				break;
1401 			case XML_ATTRIBUTE_NODE:
1402 				dom_normalize (child);
1403 				break;
1404 			default:
1405 				break;
1406 		}
1407 		child = child->next;
1408 	}
1409 }
1410 /* }}} end dom_normalize */
1411 
1412 
1413 /* {{{ void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) */
dom_set_old_ns(xmlDoc * doc,xmlNs * ns)1414 void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) {
1415 	xmlNs *cur;
1416 
1417 	if (doc == NULL)
1418 		return;
1419 
1420 	if (doc->oldNs == NULL) {
1421 		doc->oldNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
1422 		if (doc->oldNs == NULL) {
1423 			return;
1424 		}
1425 		memset(doc->oldNs, 0, sizeof(xmlNs));
1426 		doc->oldNs->type = XML_LOCAL_NAMESPACE;
1427 		doc->oldNs->href = xmlStrdup(XML_XML_NAMESPACE);
1428 		doc->oldNs->prefix = xmlStrdup((const xmlChar *)"xml");
1429 	}
1430 
1431 	cur = doc->oldNs;
1432 	while (cur->next != NULL) {
1433 		cur = cur->next;
1434 	}
1435 	cur->next = ns;
1436 }
1437 /* }}} end dom_set_old_ns */
1438 
1439 /*
1440 http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1441 
1442 NAMESPACE_ERR: Raised if
1443 
1444 1. the qualifiedName is a malformed qualified name
1445 2. the qualifiedName has a prefix and the  namespaceURI is null
1446 */
1447 
1448 /* {{{ 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)1449 int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) {
1450 	if (name_len == 0) {
1451 		return NAMESPACE_ERR;
1452 	}
1453 
1454 	*localname = (char *)xmlSplitQName2((xmlChar *)qname, (xmlChar **) prefix);
1455 	if (*localname == NULL) {
1456 		*localname = (char *)xmlStrdup((xmlChar *)qname);
1457 		if (*prefix == NULL && uri_len == 0) {
1458 			return 0;
1459 		}
1460 	}
1461 
1462 	/* 1 */
1463 	if (xmlValidateQName((xmlChar *) qname, 0) != 0) {
1464 		return NAMESPACE_ERR;
1465 	}
1466 
1467 	/* 2 */
1468 	if (*prefix != NULL && uri_len == 0) {
1469 		return NAMESPACE_ERR;
1470 	}
1471 
1472 	return 0;
1473 }
1474 /* }}} */
1475 
1476 /*
1477 http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1478 
1479 NAMESPACE_ERR: Raised if
1480 
1481 3. the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace" [XML Namespaces]
1482 4. the qualifiedName or its prefix is "xmlns" and the namespaceURI is different from  "http://www.w3.org/2000/xmlns/"
1483 5. the namespaceURI is "http://www.w3.org/2000/xmlns/" and neither the	qualifiedName nor its prefix is "xmlns".
1484 */
1485 
1486 /* {{{ xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) */
dom_get_ns(xmlNodePtr nodep,char * uri,int * errorcode,char * prefix)1487 xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) {
1488 	xmlNsPtr nsptr = NULL;
1489 
1490 	*errorcode = 0;
1491 
1492 	if (! ((prefix && !strcmp (prefix, "xml") && strcmp(uri, (char *)XML_XML_NAMESPACE)) ||
1493 		   (prefix && !strcmp (prefix, "xmlns") && strcmp(uri, (char *)DOM_XMLNS_NAMESPACE)) ||
1494 		   (prefix && !strcmp(uri, (char *)DOM_XMLNS_NAMESPACE) && strcmp (prefix, "xmlns")))) {
1495 		nsptr = xmlNewNs(nodep, (xmlChar *)uri, (xmlChar *)prefix);
1496 	}
1497 
1498 	if (nsptr == NULL) {
1499 		*errorcode = NAMESPACE_ERR;
1500 	}
1501 
1502 	return nsptr;
1503 
1504 }
1505 /* }}} end dom_get_ns */
1506 
1507 /* {{{ xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) */
dom_get_nsdecl(xmlNode * node,xmlChar * localName)1508 xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) {
1509 	xmlNsPtr cur;
1510 	xmlNs *ret = NULL;
1511 	if (node == NULL)
1512 		return NULL;
1513 
1514 	if (localName == NULL || xmlStrEqual(localName, (xmlChar *)"")) {
1515 		cur = node->nsDef;
1516 		while (cur != NULL) {
1517 			if (cur->prefix == NULL  && cur->href != NULL) {
1518 				ret = cur;
1519 				break;
1520 			}
1521 			cur = cur->next;
1522 		}
1523 	} else {
1524 		cur = node->nsDef;
1525 		while (cur != NULL) {
1526 			if (cur->prefix != NULL && xmlStrEqual(localName, cur->prefix)) {
1527 				ret = cur;
1528 				break;
1529 			}
1530 			cur = cur->next;
1531 		}
1532 	}
1533 	return ret;
1534 }
1535 /* }}} end dom_get_nsdecl */
1536 
dom_nodelist_read_dimension(zval * object,zval * offset,int type,zval * rv)1537 zval *dom_nodelist_read_dimension(zval *object, zval *offset, int type, zval *rv) /* {{{ */
1538 {
1539 	zval offset_copy;
1540 
1541 	if (!offset) {
1542 		return NULL;
1543 	}
1544 
1545 	ZVAL_LONG(&offset_copy, zval_get_long(offset));
1546 
1547 	zend_call_method_with_1_params(object, Z_OBJCE_P(object), NULL, "item", rv, &offset_copy);
1548 
1549 	return rv;
1550 } /* }}} end dom_nodelist_read_dimension */
1551 
dom_nodelist_has_dimension(zval * object,zval * member,int check_empty)1552 int dom_nodelist_has_dimension(zval *object, zval *member, int check_empty)
1553 {
1554 	zend_long offset = zval_get_long(member);
1555 	zval rv;
1556 
1557 	if (offset < 0) {
1558 		return 0;
1559 	} else {
1560 		zval *length = zend_read_property(Z_OBJCE_P(object), object, "length", sizeof("length") - 1, 0, &rv);
1561 
1562 		return length && offset < Z_LVAL_P(length);
1563 	}
1564 } /* }}} end dom_nodelist_has_dimension */
1565 
1566 #endif /* HAVE_DOM */
1567 
1568 /*
1569  * Local variables:
1570  * tab-width: 4
1571  * c-basic-offset: 4
1572  * End:
1573  * vim600: noet sw=4 ts=4 fdm=marker
1574  * vim<600: noet sw=4 ts=4
1575  */
1576