1 /*
2   +----------------------------------------------------------------------+
3   | PHP Version 7                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 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: Sterling Hughes <sterling@php.net>                          |
16   |          Marcus Boerger <helly@php.net>                              |
17   |          Rob Richards <rrichards@php.net>                            |
18   +----------------------------------------------------------------------+
19 */
20 
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24 
25 #include "php.h"
26 #if HAVE_LIBXML && HAVE_SIMPLEXML
27 
28 #include "php_ini.h"
29 #include "ext/standard/info.h"
30 #include "ext/standard/php_string.h"
31 #include "php_simplexml.h"
32 #include "php_simplexml_exports.h"
33 #include "zend_exceptions.h"
34 #include "zend_interfaces.h"
35 #include "sxe.h"
36 
37 zend_class_entry *sxe_class_entry = NULL;
38 
sxe_get_element_class_entrynull39 PHP_SXE_API zend_class_entry *sxe_get_element_class_entry() /* {{{ */
40 {
41 	return sxe_class_entry;
42 }
43 /* }}} */
44 
45 #define SXE_ME(func, arg_info, flags) PHP_ME(simplexml_element, func, arg_info, flags)
46 #define SXE_MALIAS(func, alias, arg_info, flags) PHP_MALIAS(simplexml_element, func, alias, arg_info, flags)
47 
48 #define SXE_METHOD(func) PHP_METHOD(simplexml_element, func)
49 
50 static php_sxe_object* php_sxe_object_new(zend_class_entry *ce, zend_function *fptr_count);
51 static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data);
52 static xmlNodePtr php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data);
53 static zval *sxe_get_value(zval *z, zval *rv);
54 static void php_sxe_iterator_dtor(zend_object_iterator *iter);
55 static int php_sxe_iterator_valid(zend_object_iterator *iter);
56 static zval *php_sxe_iterator_current_data(zend_object_iterator *iter);
57 static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key);
58 static void php_sxe_iterator_move_forward(zend_object_iterator *iter);
59 static void php_sxe_iterator_rewind(zend_object_iterator *iter);
60 
61 /* {{{ _node_as_zval()
62  */
_node_as_zval(php_sxe_object *sxe, xmlNodePtr node, zval *value, SXE_ITER itertype, char *name, const xmlChar *nsprefix, int isprefix)63 static void _node_as_zval(php_sxe_object *sxe, xmlNodePtr node, zval *value, SXE_ITER itertype, char *name, const xmlChar *nsprefix, int isprefix)
64 {
65 	php_sxe_object *subnode;
66 
67 	subnode = php_sxe_object_new(sxe->zo.ce, sxe->fptr_count);
68 	subnode->document = sxe->document;
69 	subnode->document->refcount++;
70 	subnode->iter.type = itertype;
71 	if (name) {
72 		subnode->iter.name = (xmlChar*)estrdup(name);
73 	}
74 	if (nsprefix && *nsprefix) {
75 		subnode->iter.nsprefix = (xmlChar*)estrdup((char*)nsprefix);
76 		subnode->iter.isprefix = isprefix;
77 	}
78 
79 	php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL);
80 
81 	ZVAL_OBJ(value, &subnode->zo);
82 }
83 /* }}} */
84 
85 #define GET_NODE(__s, __n) { \
86 	if ((__s)->node && (__s)->node->node) { \
87 		__n = (__s)->node->node; \
88 	} else { \
89 		__n = NULL; \
90 		php_error_docref(NULL, E_WARNING, "Node no longer exists"); \
91 	} \
92 }
93 
php_sxe_get_first_node(php_sxe_object *sxe, xmlNodePtr node)94 static xmlNodePtr php_sxe_get_first_node(php_sxe_object *sxe, xmlNodePtr node) /* {{{ */
95 {
96 	php_sxe_object *intern;
97 	xmlNodePtr retnode = NULL;
98 
99 	if (sxe && sxe->iter.type != SXE_ITER_NONE) {
100 		php_sxe_reset_iterator(sxe, 1);
101 		if (!Z_ISUNDEF(sxe->iter.data)) {
102 			intern = Z_SXEOBJ_P(&sxe->iter.data);
103 			GET_NODE(intern, retnode)
104 		}
105 		return retnode;
106 	} else {
107 		return node;
108 	}
109 }
110 /* }}} */
111 
match_ns(php_sxe_object *sxe, xmlNodePtr node, xmlChar *name, int prefix)112 static inline int match_ns(php_sxe_object *sxe, xmlNodePtr node, xmlChar *name, int prefix) /* {{{ */
113 {
114 	if (name == NULL && (node->ns == NULL || node->ns->prefix == NULL)) {
115 		return 1;
116 	}
117 
118 	if (node->ns && !xmlStrcmp(prefix ? node->ns->prefix : node->ns->href, name)) {
119 		return 1;
120 	}
121 
122 	return 0;
123 }
124 /* }}} */
125 
sxe_get_element_by_offset(php_sxe_object *sxe, zend_long offset, xmlNodePtr node, zend_long *cnt)126 static xmlNodePtr sxe_get_element_by_offset(php_sxe_object *sxe, zend_long offset, xmlNodePtr node, zend_long *cnt) /* {{{ */
127 {
128 	zend_long nodendx = 0;
129 
130 	if (sxe->iter.type == SXE_ITER_NONE) {
131 		if (offset == 0) {
132 			if (cnt) {
133 				*cnt = 0;
134 			}
135 			return node;
136 		} else {
137 			return NULL;
138 		}
139 	}
140 	while (node && nodendx <= offset) {
141 		SKIP_TEXT(node)
142 		if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
143 			if (sxe->iter.type == SXE_ITER_CHILD || (
144 				sxe->iter.type == SXE_ITER_ELEMENT && !xmlStrcmp(node->name, sxe->iter.name))) {
145 				if (nodendx == offset) {
146 					break;
147 				}
148 				nodendx++;
149 			}
150 		}
151 next_iter:
152 		node = node->next;
153 	}
154 
155 	if (cnt) {
156 		*cnt = nodendx;
157 	}
158 
159 	return node;
160 }
161 /* }}} */
162 
sxe_find_element_by_name(php_sxe_object *sxe, xmlNodePtr node, xmlChar *name)163 static xmlNodePtr sxe_find_element_by_name(php_sxe_object *sxe, xmlNodePtr node, xmlChar *name) /* {{{ */
164 {
165 	while (node) {
166 		SKIP_TEXT(node)
167 		if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
168 			if (!xmlStrcmp(node->name, name)) {
169 				return node;
170 			}
171 		}
172 next_iter:
173 		node = node->next;
174 	}
175 	return NULL;
176 } /* }}} */
177 
sxe_get_element_by_name(php_sxe_object *sxe, xmlNodePtr node, char **name, SXE_ITER *type)178 static xmlNodePtr sxe_get_element_by_name(php_sxe_object *sxe, xmlNodePtr node, char **name, SXE_ITER *type) /* {{{ */
179 {
180 	int         orgtype;
181 	xmlNodePtr  orgnode = node;
182 	xmlNodePtr  retnode = NULL;
183 
184 	if (sxe->iter.type != SXE_ITER_ATTRLIST)
185 	{
186 		orgtype = sxe->iter.type;
187 		if (sxe->iter.type == SXE_ITER_NONE) {
188 			sxe->iter.type = SXE_ITER_CHILD;
189 		}
190 		node = php_sxe_get_first_node(sxe, node);
191 		sxe->iter.type = orgtype;
192 	}
193 
194 	if (sxe->iter.type == SXE_ITER_ELEMENT) {
195 		orgnode = sxe_find_element_by_name(sxe, node, sxe->iter.name);
196 		if (!orgnode) {
197 			return NULL;
198 		}
199 		node = orgnode->children;
200 	}
201 
202 	while (node) {
203 		SKIP_TEXT(node)
204 		if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
205 			if (!xmlStrcmp(node->name, (xmlChar *)*name)) {
206 				if (1||retnode)
207 				{
208 					*type = SXE_ITER_ELEMENT;
209 					return orgnode;
210 				}
211 				retnode = node;
212 			}
213 		}
214 next_iter:
215 		node = node->next;
216 	}
217 
218 	if (retnode)
219 	{
220 		*type = SXE_ITER_NONE;
221 		*name = NULL;
222 		return retnode;
223 	}
224 
225 	return NULL;
226 }
227 /* }}} */
228 
229 /* {{{ sxe_prop_dim_read()
230  */
sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type, zval *rv)231 static zval *sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type, zval *rv)
232 {
233 	php_sxe_object *sxe;
234 	char           *name;
235 	xmlNodePtr      node;
236 	xmlAttrPtr      attr = NULL;
237 	zval            tmp_zv;
238 	int             nodendx = 0;
239 	int             test = 0;
240 
241 	sxe = Z_SXEOBJ_P(object);
242 
243 	if (!member) {
244 		if (sxe->iter.type == SXE_ITER_ATTRLIST) {
245 			/* This happens when the user did: $sxe[]->foo = $value */
246 			zend_throw_error(NULL, "Cannot create unnamed attribute");
247 			return &EG(uninitialized_zval);
248 		}
249 		goto long_dim;
250 	} else {
251 		ZVAL_DEREF(member);
252 		if (Z_TYPE_P(member) == IS_LONG) {
253 			if (sxe->iter.type != SXE_ITER_ATTRLIST) {
254 long_dim:
255 				attribs = 0;
256 				elements = 1;
257 			}
258 			name = NULL;
259 		} else {
260 			if (Z_TYPE_P(member) != IS_STRING) {
261 				zend_string *str = zval_try_get_string_func(member);
262 				if (UNEXPECTED(!str)) {
263 					return &EG(uninitialized_zval);
264 				}
265 				ZVAL_STR(&tmp_zv, str);
266 				member = &tmp_zv;
267 			}
268 			name = Z_STRVAL_P(member);
269 		}
270 	}
271 
272 	GET_NODE(sxe, node);
273 
274 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
275 		attribs = 1;
276 		elements = 0;
277 		node = php_sxe_get_first_node(sxe, node);
278 		attr = (xmlAttrPtr)node;
279 		test = sxe->iter.name != NULL;
280 	} else if (sxe->iter.type != SXE_ITER_CHILD) {
281 		node = php_sxe_get_first_node(sxe, node);
282 		attr = node ? node->properties : NULL;
283 		test = 0;
284 		if (!member && node && node->parent &&
285 		    node->parent->type == XML_DOCUMENT_NODE) {
286 			/* This happens when the user did: $sxe[]->foo = $value */
287 			zend_throw_error(NULL, "Cannot create unnamed attribute");
288 			return &EG(uninitialized_zval);
289 		}
290 	}
291 
292 	ZVAL_UNDEF(rv);
293 
294 	if (node) {
295 		if (attribs) {
296 			if (Z_TYPE_P(member) != IS_LONG || sxe->iter.type == SXE_ITER_ATTRLIST) {
297 				if (Z_TYPE_P(member) == IS_LONG) {
298 					while (attr && nodendx <= Z_LVAL_P(member)) {
299 						if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
300 							if (nodendx == Z_LVAL_P(member)) {
301 								_node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix);
302 								break;
303 							}
304 							nodendx++;
305 						}
306 						attr = attr->next;
307 					}
308 				} else {
309 					while (attr) {
310 						if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)name) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
311 							_node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix);
312 							break;
313 						}
314 						attr = attr->next;
315 					}
316 				}
317 			}
318 		}
319 
320 		if (elements) {
321 			if (!sxe->node) {
322 				php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, node, NULL);
323 			}
324 			if (!member || Z_TYPE_P(member) == IS_LONG) {
325 				zend_long cnt = 0;
326 				xmlNodePtr mynode = node;
327 
328 				if (sxe->iter.type == SXE_ITER_CHILD) {
329 					node = php_sxe_get_first_node(sxe, node);
330 				}
331 				if (sxe->iter.type == SXE_ITER_NONE) {
332 					if (member && Z_LVAL_P(member) > 0) {
333 						php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only 0 such elements exist", mynode->name, Z_LVAL_P(member));
334 					}
335 				} else if (member) {
336 					node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, &cnt);
337 				} else {
338 					node = NULL;
339 				}
340 				if (node) {
341 					_node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix);
342 				} else if (type == BP_VAR_W || type == BP_VAR_RW) {
343 					if (member && cnt < Z_LVAL_P(member)) {
344 						php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only " ZEND_LONG_FMT " such elements exist", mynode->name, Z_LVAL_P(member), cnt);
345 					}
346 					node = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, NULL);
347 					_node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix);
348 				}
349 			} else {
350 				/* In BP_VAR_IS mode only return a proper node if it actually exists. */
351 				if (type != BP_VAR_IS || sxe_find_element_by_name(sxe, node->children, (xmlChar *) name)) {
352 					_node_as_zval(sxe, node, rv, SXE_ITER_ELEMENT, name, sxe->iter.nsprefix, sxe->iter.isprefix);
353 				}
354 			}
355 		}
356 	}
357 
358 	if (member == &tmp_zv) {
359 		zval_ptr_dtor_str(&tmp_zv);
360 	}
361 
362 	if (Z_ISUNDEF_P(rv)) {
363 		ZVAL_NULL(rv);
364 	}
365 
366 	return rv;
367 }
368 /* }}} */
369 
370 /* {{{ sxe_property_read()
371  */
sxe_property_read(zval *object, zval *member, int type, void **cache_slot, zval *rv)372 static zval *sxe_property_read(zval *object, zval *member, int type, void **cache_slot, zval *rv)
373 {
374 	return sxe_prop_dim_read(object, member, 1, 0, type, rv);
375 }
376 /* }}} */
377 
378 /* {{{ sxe_dimension_read()
379  */
sxe_dimension_read(zval *object, zval *offset, int type, zval *rv)380 static zval *sxe_dimension_read(zval *object, zval *offset, int type, zval *rv)
381 {
382 	return sxe_prop_dim_read(object, offset, 0, 1, type, rv);
383 }
384 /* }}} */
385 
386 /* {{{ change_node_zval()
387  */
change_node_zval(xmlNodePtr node, zval *value)388 static void change_node_zval(xmlNodePtr node, zval *value)
389 {
390 	xmlChar *buffer;
391 
392 	if (!value)
393 	{
394 		xmlNodeSetContentLen(node, (xmlChar *)"", 0);
395 		return;
396 	}
397 	switch (Z_TYPE_P(value)) {
398 		case IS_LONG:
399 		case IS_FALSE:
400 		case IS_TRUE:
401 		case IS_DOUBLE:
402 		case IS_NULL:
403 			convert_to_string(value);
404 			/* break missing intentionally */
405 		case IS_STRING:
406 			buffer = xmlEncodeEntitiesReentrant(node->doc, (xmlChar *)Z_STRVAL_P(value));
407 			/* check for NULL buffer in case of memory error in xmlEncodeEntitiesReentrant */
408 			if (buffer) {
409 				xmlNodeSetContent(node, buffer);
410 				xmlFree(buffer);
411 			}
412 			break;
413 		default:
414 			php_error_docref(NULL, E_WARNING, "It is not possible to assign complex types to nodes");
415 			break;
416 	}
417 }
418 /* }}} */
419 
420 /* {{{ sxe_property_write()
421  */
sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool elements, zend_bool attribs, xmlNodePtr *pnewnode)422 static zval *sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool elements, zend_bool attribs, xmlNodePtr *pnewnode)
423 {
424 	php_sxe_object *sxe;
425 	xmlNodePtr      node;
426 	xmlNodePtr      newnode = NULL;
427 	xmlNodePtr      mynode;
428 	xmlNodePtr		tempnode;
429 	xmlAttrPtr      attr = NULL;
430 	int             counter = 0;
431 	int             is_attr = 0;
432 	int				nodendx = 0;
433 	int             test = 0;
434 	int				new_value = 0;
435 	zend_long            cnt = 0;
436 	zval            tmp_zv, zval_copy;
437 	zend_string    *trim_str;
438 
439 	sxe = Z_SXEOBJ_P(object);
440 
441 	if (!member) {
442 		if (sxe->iter.type == SXE_ITER_ATTRLIST) {
443 			/* This happens when the user did: $sxe[] = $value
444 			 * and could also be E_PARSE, but we use this only during parsing
445 			 * and this is during runtime.
446 			 */
447 			zend_throw_error(NULL, "Cannot create unnamed attribute");
448 			return &EG(error_zval);
449 		}
450 		goto long_dim;
451 	} else {
452 		ZVAL_DEREF(member);
453 		if (Z_TYPE_P(member) == IS_LONG) {
454 			if (sxe->iter.type != SXE_ITER_ATTRLIST) {
455 long_dim:
456 				attribs = 0;
457 				elements = 1;
458 			}
459 		} else {
460 			if (Z_TYPE_P(member) != IS_STRING) {
461 				trim_str = zval_try_get_string_func(member);
462 				if (UNEXPECTED(!trim_str)) {
463 					return &EG(error_zval);
464 				}
465 
466 				ZVAL_STR(&tmp_zv, php_trim(trim_str, NULL, 0, 3));
467 				zend_string_release_ex(trim_str, 0);
468 				member = &tmp_zv;
469 			}
470 
471 			if (!Z_STRLEN_P(member)) {
472 				php_error_docref(NULL, E_WARNING, "Cannot write or create unnamed %s", attribs ? "attribute" : "element");
473 				if (member == &tmp_zv) {
474 					zval_ptr_dtor_str(&tmp_zv);
475 				}
476 				return &EG(error_zval);
477 			}
478 		}
479 	}
480 
481 	GET_NODE(sxe, node);
482 
483 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
484 		attribs = 1;
485 		elements = 0;
486 		node = php_sxe_get_first_node(sxe, node);
487 		attr = (xmlAttrPtr)node;
488 		test = sxe->iter.name != NULL;
489 	} else if (sxe->iter.type != SXE_ITER_CHILD) {
490 		mynode = node;
491 		node = php_sxe_get_first_node(sxe, node);
492 		attr = node ? node->properties : NULL;
493 		test = 0;
494 		if (!member && node && node->parent &&
495 		    node->parent->type == XML_DOCUMENT_NODE) {
496 			/* This happens when the user did: $sxe[] = $value
497 			 * and could also be E_PARSE, but we use this only during parsing
498 			 * and this is during runtime.
499 			 */
500 			zend_throw_error(NULL, "Cannot create unnamed attribute");
501 			return &EG(error_zval);
502 		}
503 		if (attribs && !node && sxe->iter.type == SXE_ITER_ELEMENT) {
504 			node = xmlNewChild(mynode, mynode->ns, sxe->iter.name, NULL);
505 			attr = node->properties;
506 		}
507 	}
508 
509 	mynode = node;
510 
511 	if (value) {
512 		switch (Z_TYPE_P(value)) {
513 			case IS_LONG:
514 			case IS_FALSE:
515 			case IS_TRUE:
516 			case IS_DOUBLE:
517 			case IS_NULL:
518 				if (Z_TYPE_P(value) != IS_STRING) {
519 					ZVAL_STR(&zval_copy, zval_get_string_func(value));
520 					value = &zval_copy;
521 					new_value = 1;
522 				}
523 				break;
524 			case IS_STRING:
525 				break;
526 			case IS_OBJECT:
527 				if (Z_OBJCE_P(value) == sxe_class_entry) {
528 					value = sxe_get_value(value, &zval_copy);
529 					new_value = 1;
530 					break;
531 				}
532 				/* break is missing intentionally */
533 			default:
534 				if (member == &tmp_zv) {
535 					zval_ptr_dtor_str(&tmp_zv);
536 				}
537 				zend_error(E_WARNING, "It is not yet possible to assign complex types to %s", attribs ? "attributes" : "properties");
538 				return &EG(error_zval);
539 		}
540 	}
541 
542 	if (node) {
543 		if (attribs) {
544 			if (Z_TYPE_P(member) == IS_LONG) {
545 				while (attr && nodendx <= Z_LVAL_P(member)) {
546 					if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
547 						if (nodendx == Z_LVAL_P(member)) {
548 							is_attr = 1;
549 							++counter;
550 							break;
551 						}
552 						nodendx++;
553 					}
554 					attr = attr->next;
555 				}
556 			} else {
557 				while (attr) {
558 					if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)Z_STRVAL_P(member)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
559 						is_attr = 1;
560 						++counter;
561 						break;
562 					}
563 					attr = attr->next;
564 				}
565 			}
566 
567 		}
568 
569 		if (elements) {
570 			if (!member || Z_TYPE_P(member) == IS_LONG) {
571 				if (node->type == XML_ATTRIBUTE_NODE) {
572 					zend_throw_error(NULL, "Cannot create duplicate attribute");
573 					if (new_value) {
574 						zval_ptr_dtor(value);
575 					}
576 					return &EG(error_zval);
577 				}
578 
579 				if (sxe->iter.type == SXE_ITER_NONE) {
580 					newnode = node;
581 					++counter;
582 					if (member && Z_LVAL_P(member) > 0) {
583 						php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only 0 such elements exist", mynode->name, Z_LVAL_P(member));
584 						value = &EG(error_zval);
585 					}
586 				} else if (member) {
587 					newnode = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, &cnt);
588 					if (newnode) {
589 						++counter;
590 					}
591 				}
592 			} else {
593 				node = node->children;
594 				while (node) {
595 					SKIP_TEXT(node);
596 
597 					if (!xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member)) && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
598 						newnode = node;
599 						++counter;
600 					}
601 
602 next_iter:
603 					node = node->next;
604 				}
605 			}
606 		}
607 
608 		if (counter == 1) {
609 			if (is_attr) {
610 				newnode = (xmlNodePtr) attr;
611 			}
612 			if (value) {
613 				while ((tempnode = (xmlNodePtr) newnode->children)) {
614 					xmlUnlinkNode(tempnode);
615 					php_libxml_node_free_resource((xmlNodePtr) tempnode);
616 				}
617 				change_node_zval(newnode, value);
618 			}
619 		} else if (counter > 1) {
620 			php_error_docref(NULL, E_WARNING, "Cannot assign to an array of nodes (duplicate subnodes or attr detected)");
621 			value = &EG(error_zval);
622 		} else if (elements) {
623 			if (!node) {
624 				if (!member || Z_TYPE_P(member) == IS_LONG) {
625 					newnode = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
626 				} else {
627 					newnode = xmlNewTextChild(mynode, mynode->ns, (xmlChar *)Z_STRVAL_P(member), value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
628 				}
629 			} else if (!member || Z_TYPE_P(member) == IS_LONG) {
630 				if (member && cnt < Z_LVAL_P(member)) {
631 					php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only " ZEND_LONG_FMT " such elements exist", mynode->name, Z_LVAL_P(member), cnt);
632 				}
633 				newnode = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
634 			}
635 		} else if (attribs) {
636 			if (Z_TYPE_P(member) == IS_LONG) {
637 				php_error_docref(NULL, E_WARNING, "Cannot change attribute number " ZEND_LONG_FMT " when only %d attributes exist", Z_LVAL_P(member), nodendx);
638 			} else {
639 				newnode = (xmlNodePtr)xmlNewProp(node, (xmlChar *)Z_STRVAL_P(member), value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
640 			}
641 		}
642 	}
643 
644 	if (member == &tmp_zv) {
645 		zval_ptr_dtor_str(&tmp_zv);
646 	}
647 	if (pnewnode) {
648 		*pnewnode = newnode;
649 	}
650 	if (new_value) {
651 		zval_ptr_dtor(value);
652 	}
653 	return value;
654 }
655 /* }}} */
656 
657 /* {{{ sxe_property_write()
658  */
sxe_property_write(zval *object, zval *member, zval *value, void **cache_slot)659 static zval *sxe_property_write(zval *object, zval *member, zval *value, void **cache_slot)
660 {
661 	zval *retval = sxe_prop_dim_write(object, member, value, 1, 0, NULL);
662 
663 	return retval == &EG(error_zval) ? &EG(uninitialized_zval) : retval;
664 }
665 /* }}} */
666 
667 /* {{{ sxe_dimension_write()
668  */
sxe_dimension_write(zval *object, zval *offset, zval *value)669 static void sxe_dimension_write(zval *object, zval *offset, zval *value)
670 {
671 	sxe_prop_dim_write(object, offset, value, 0, 1, NULL);
672 }
673 /* }}} */
674 
sxe_property_get_adr(zval *object, zval *member, int fetch_type, void **cache_slot)675 static zval *sxe_property_get_adr(zval *object, zval *member, int fetch_type, void **cache_slot) /* {{{ */
676 {
677 	php_sxe_object *sxe;
678 	xmlNodePtr      node;
679 	zval            ret;
680 	char           *name;
681 	SXE_ITER        type;
682 
683 	if (!try_convert_to_string(member)) {
684 		return NULL;
685 	}
686 
687 	sxe = Z_SXEOBJ_P(object);
688 	GET_NODE(sxe, node);
689 	name = Z_STRVAL_P(member);
690 	node = sxe_get_element_by_name(sxe, node, &name, &type);
691 	if (node) {
692 		return NULL;
693 	}
694 	if (sxe_prop_dim_write(object, member, NULL, 1, 0, &node) == &EG(error_zval)) {
695 		return NULL;
696 	}
697 	type = SXE_ITER_NONE;
698 	name = NULL;
699 
700 	_node_as_zval(sxe, node, &ret, type, name, sxe->iter.nsprefix, sxe->iter.isprefix);
701 
702 	if (!Z_ISUNDEF(sxe->tmp)) {
703 		zval_ptr_dtor(&sxe->tmp);
704 	}
705 
706 	ZVAL_COPY_VALUE(&sxe->tmp, &ret);
707 
708 	return &sxe->tmp;
709 }
710 /* }}} */
711 
712 /* {{{ sxe_prop_dim_exists()
713  */
sxe_prop_dim_exists(zval *object, zval *member, int check_empty, zend_bool elements, zend_bool attribs)714 static int sxe_prop_dim_exists(zval *object, zval *member, int check_empty, zend_bool elements, zend_bool attribs)
715 {
716 	php_sxe_object *sxe;
717 	xmlNodePtr      node;
718 	xmlAttrPtr      attr = NULL;
719 	int				exists = 0;
720 	int             test = 0;
721 	zval            tmp_zv;
722 
723 	if (Z_TYPE_P(member) != IS_STRING && Z_TYPE_P(member) != IS_LONG) {
724 		zend_string *str = zval_try_get_string_func(member);
725 		if (UNEXPECTED(!str)) {
726 			return 0;
727 		}
728 		ZVAL_STR(&tmp_zv, str);
729 		member = &tmp_zv;
730 	}
731 
732 	sxe = Z_SXEOBJ_P(object);
733 
734 	GET_NODE(sxe, node);
735 
736 	if (Z_TYPE_P(member) == IS_LONG) {
737 		if (sxe->iter.type != SXE_ITER_ATTRLIST) {
738 			attribs = 0;
739 			elements = 1;
740 			if (sxe->iter.type == SXE_ITER_CHILD) {
741 				node = php_sxe_get_first_node(sxe, node);
742 			}
743 		}
744 	}
745 
746 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
747 		attribs = 1;
748 		elements = 0;
749 		node = php_sxe_get_first_node(sxe, node);
750 		attr = (xmlAttrPtr)node;
751 		test = sxe->iter.name != NULL;
752 	} else if (sxe->iter.type != SXE_ITER_CHILD) {
753 		node = php_sxe_get_first_node(sxe, node);
754 		attr = node ? node->properties : NULL;
755 		test = 0;
756 	}
757 
758 	if (node) {
759 		if (attribs) {
760 			if (Z_TYPE_P(member) == IS_LONG) {
761 				int	nodendx = 0;
762 
763 				while (attr && nodendx <= Z_LVAL_P(member)) {
764 					if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
765 						if (nodendx == Z_LVAL_P(member)) {
766 							exists = 1;
767 							break;
768 						}
769 						nodendx++;
770 					}
771 					attr = attr->next;
772 				}
773 			} else {
774 				while (attr) {
775 					if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)Z_STRVAL_P(member)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
776 						exists = 1;
777 						break;
778 					}
779 
780 					attr = attr->next;
781 				}
782 			}
783 			if (exists && check_empty == 1 &&
784 				(!attr->children || !attr->children->content || !attr->children->content[0] || !xmlStrcmp(attr->children->content, (const xmlChar *) "0")) ) {
785 				/* Attribute with no content in it's text node */
786 				exists = 0;
787 			}
788 		}
789 
790 		if (elements) {
791 			if (Z_TYPE_P(member) == IS_LONG) {
792 				if (sxe->iter.type == SXE_ITER_CHILD) {
793 					node = php_sxe_get_first_node(sxe, node);
794 				}
795 				node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, NULL);
796 			} else {
797 				node = sxe_find_element_by_name(sxe, node->children, (xmlChar *)Z_STRVAL_P(member));
798 			}
799 			if (node) {
800 				exists = 1;
801 				if (check_empty == 1 &&
802 					(!node->children || (node->children->type == XML_TEXT_NODE && !node->children->next &&
803 					 (!node->children->content || !node->children->content[0] || !xmlStrcmp(node->children->content, (const xmlChar *) "0")))) ) {
804 					exists = 0;
805 				}
806 			}
807 		}
808 	}
809 
810 	if (member == &tmp_zv) {
811 		zval_ptr_dtor_str(&tmp_zv);
812 	}
813 
814 	return exists;
815 }
816 /* }}} */
817 
818 /* {{{ sxe_property_exists()
819  */
sxe_property_exists(zval *object, zval *member, int check_empty, void **cache_slot)820 static int sxe_property_exists(zval *object, zval *member, int check_empty, void **cache_slot)
821 {
822 	return sxe_prop_dim_exists(object, member, check_empty, 1, 0);
823 }
824 /* }}} */
825 
826 /* {{{ sxe_dimension_exists()
827  */
sxe_dimension_exists(zval *object, zval *member, int check_empty)828 static int sxe_dimension_exists(zval *object, zval *member, int check_empty)
829 {
830 	return sxe_prop_dim_exists(object, member, check_empty, 0, 1);
831 }
832 /* }}} */
833 
834 /* {{{ sxe_prop_dim_delete()
835  */
sxe_prop_dim_delete(zval *object, zval *member, zend_bool elements, zend_bool attribs)836 static void sxe_prop_dim_delete(zval *object, zval *member, zend_bool elements, zend_bool attribs)
837 {
838 	php_sxe_object *sxe;
839 	xmlNodePtr      node;
840 	xmlNodePtr      nnext;
841 	xmlAttrPtr      attr = NULL;
842 	xmlAttrPtr      anext;
843 	zval            tmp_zv;
844 	int             test = 0;
845 
846 	if (Z_TYPE_P(member) != IS_STRING && Z_TYPE_P(member) != IS_LONG) {
847 		zend_string *str = zval_try_get_string_func(member);
848 		if (UNEXPECTED(!str)) {
849 			return;
850 		}
851 		ZVAL_STR(&tmp_zv, str);
852 		member = &tmp_zv;
853 	}
854 
855 	sxe = Z_SXEOBJ_P(object);
856 
857 	GET_NODE(sxe, node);
858 
859 	if (Z_TYPE_P(member) == IS_LONG) {
860 		if (sxe->iter.type != SXE_ITER_ATTRLIST) {
861 			attribs = 0;
862 			elements = 1;
863 			if (sxe->iter.type == SXE_ITER_CHILD) {
864 				node = php_sxe_get_first_node(sxe, node);
865 			}
866 		}
867 	}
868 
869 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
870 		attribs = 1;
871 		elements = 0;
872 		node = php_sxe_get_first_node(sxe, node);
873 		attr = (xmlAttrPtr)node;
874 		test = sxe->iter.name != NULL;
875 	} else if (sxe->iter.type != SXE_ITER_CHILD) {
876 		node = php_sxe_get_first_node(sxe, node);
877 		attr = node ? node->properties : NULL;
878 		test = 0;
879 	}
880 
881 	if (node) {
882 		if (attribs) {
883 			if (Z_TYPE_P(member) == IS_LONG) {
884 				int	nodendx = 0;
885 
886 				while (attr && nodendx <= Z_LVAL_P(member)) {
887 					if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
888 						if (nodendx == Z_LVAL_P(member)) {
889 							xmlUnlinkNode((xmlNodePtr) attr);
890 							php_libxml_node_free_resource((xmlNodePtr) attr);
891 							break;
892 						}
893 						nodendx++;
894 					}
895 					attr = attr->next;
896 				}
897 			} else {
898 				while (attr) {
899 					anext = attr->next;
900 					if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)Z_STRVAL_P(member)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
901 						xmlUnlinkNode((xmlNodePtr) attr);
902 						php_libxml_node_free_resource((xmlNodePtr) attr);
903 						break;
904 					}
905 					attr = anext;
906 				}
907 			}
908 		}
909 
910 		if (elements) {
911 			if (Z_TYPE_P(member) == IS_LONG) {
912 				if (sxe->iter.type == SXE_ITER_CHILD) {
913 					node = php_sxe_get_first_node(sxe, node);
914 				}
915 				node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, NULL);
916 				if (node) {
917 					xmlUnlinkNode(node);
918 					php_libxml_node_free_resource(node);
919 				}
920 			} else {
921 				node = node->children;
922 				while (node) {
923 					nnext = node->next;
924 
925 					SKIP_TEXT(node);
926 
927 					if (!xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member)) && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
928 						xmlUnlinkNode(node);
929 						php_libxml_node_free_resource(node);
930 					}
931 
932 next_iter:
933 					node = nnext;
934 				}
935 			}
936 		}
937 	}
938 
939 	if (member == &tmp_zv) {
940 		zval_ptr_dtor_str(&tmp_zv);
941 	}
942 }
943 /* }}} */
944 
945 /* {{{ sxe_property_delete()
946  */
sxe_property_delete(zval *object, zval *member, void **cache_slot)947 static void sxe_property_delete(zval *object, zval *member, void **cache_slot)
948 {
949 	sxe_prop_dim_delete(object, member, 1, 0);
950 }
951 /* }}} */
952 
953 /* {{{ sxe_dimension_unset()
954  */
sxe_dimension_delete(zval *object, zval *offset)955 static void sxe_dimension_delete(zval *object, zval *offset)
956 {
957 	sxe_prop_dim_delete(object, offset, 0, 1);
958 }
959 /* }}} */
960 
sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine)961 static inline zend_string *sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine) /* {{{ */
962 {
963 	xmlChar *tmp = xmlNodeListGetString(doc, list, inLine);
964 	zend_string *res;
965 
966 	if (tmp) {
967 		res = zend_string_init((char*)tmp, strlen((char *)tmp), 0);
968 		xmlFree(tmp);
969 	} else {
970 		res = ZSTR_EMPTY_ALLOC();
971 	}
972 
973 	return res;
974 }
975 /* }}} */
976 
977 /* {{{ _get_base_node_value()
978  */
_get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval *value, xmlChar *nsprefix, int isprefix)979 static void _get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval *value, xmlChar *nsprefix, int isprefix)
980 {
981 	php_sxe_object *subnode;
982 	xmlChar        *contents;
983 
984 	if (node->children && node->children->type == XML_TEXT_NODE && !xmlIsBlankNode(node->children)) {
985 		contents = xmlNodeListGetString(node->doc, node->children, 1);
986 		if (contents) {
987 			ZVAL_STRING(value, (char *)contents);
988 			xmlFree(contents);
989 		}
990 	} else {
991 		subnode = php_sxe_object_new(sxe_ref->zo.ce, sxe_ref->fptr_count);
992 		subnode->document = sxe_ref->document;
993 		subnode->document->refcount++;
994 		if (nsprefix && *nsprefix) {
995 			subnode->iter.nsprefix = (xmlChar*)estrdup((char *)nsprefix);
996 			subnode->iter.isprefix = isprefix;
997 		}
998 		php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL);
999 
1000 		ZVAL_OBJ(value, &subnode->zo);
1001 		/*zval_add_ref(value);*/
1002 	}
1003 }
1004 /* }}} */
1005 
sxe_properties_add(HashTable *rv, char *name, int namelen, zval *value)1006 static void sxe_properties_add(HashTable *rv, char *name, int namelen, zval *value) /* {{{ */
1007 {
1008 	zend_string *key;
1009 	zval  *data_ptr;
1010 	zval  newptr;
1011 
1012 	key = zend_string_init(name, namelen, 0);
1013 	if ((data_ptr = zend_hash_find(rv, key)) != NULL) {
1014 		if (Z_TYPE_P(data_ptr) == IS_ARRAY) {
1015 			zend_hash_next_index_insert_new(Z_ARRVAL_P(data_ptr), value);
1016 		} else {
1017 			array_init(&newptr);
1018 			zend_hash_next_index_insert_new(Z_ARRVAL(newptr), data_ptr);
1019 			zend_hash_next_index_insert_new(Z_ARRVAL(newptr), value);
1020 			ZVAL_ARR(data_ptr, Z_ARR(newptr));
1021 		}
1022 	} else {
1023 		zend_hash_add_new(rv, key, value);
1024 	}
1025 	zend_string_release_ex(key, 0);
1026 }
1027 /* }}} */
1028 
sxe_prop_is_empty(zval *object)1029 static int sxe_prop_is_empty(zval *object) /* {{{ */
1030 {
1031 	php_sxe_object  *sxe;
1032 	xmlNodePtr       node;
1033 	xmlAttrPtr       attr;
1034 	zval             iter_data;
1035 	int              test;
1036 	int              is_empty;
1037 	int              use_iter = 0;
1038 
1039 	sxe = Z_SXEOBJ_P(object);
1040 
1041 	GET_NODE(sxe, node);
1042 	if (!node) {
1043 		return 1;
1044 	}
1045 
1046 	if (sxe->iter.type == SXE_ITER_ELEMENT) {
1047 		node = php_sxe_get_first_node(sxe, node);
1048 	}
1049 	if (!node || node->type != XML_ENTITY_DECL) {
1050 		attr = node ? (xmlAttrPtr)node->properties : NULL;
1051 		test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
1052 		while (attr) {
1053 			if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr)attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
1054 				return 0;
1055 			}
1056 			attr = attr->next;
1057 		}
1058 	}
1059 
1060 	GET_NODE(sxe, node);
1061 	node = php_sxe_get_first_node(sxe, node);
1062 	is_empty = 1;
1063 	ZVAL_UNDEF(&iter_data);
1064 	if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
1065 		if (node->type == XML_ATTRIBUTE_NODE) {
1066 			return 0;
1067 		} else if (sxe->iter.type != SXE_ITER_CHILD) {
1068 			if (sxe->iter.type == SXE_ITER_NONE || !node->children || !node->parent || node->children->next || node->children->children || node->parent->children == node->parent->last) {
1069 				node = node->children;
1070 			} else {
1071 				ZVAL_COPY_VALUE(&iter_data, &sxe->iter.data);
1072 				ZVAL_UNDEF(&sxe->iter.data);
1073 				node = php_sxe_reset_iterator(sxe, 0);
1074 				use_iter = 1;
1075 			}
1076 		}
1077 
1078 		while (node) {
1079 			if (node->children != NULL || node->prev != NULL || node->next != NULL) {
1080 				SKIP_TEXT(node);
1081 			} else {
1082 				if (node->type == XML_TEXT_NODE) {
1083 					const xmlChar *cur = node->content;
1084 					if (*cur != 0) {
1085 						is_empty = 0;
1086 						break;
1087 					}
1088 					goto next_iter;
1089 				}
1090 			}
1091 
1092 			if (node->type == XML_ELEMENT_NODE && (! match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix))) {
1093 				goto next_iter;
1094 			}
1095 
1096 			if (!node->name) {
1097 				goto next_iter;
1098 			}
1099 
1100 			is_empty = 0;
1101 			break;
1102 next_iter:
1103 			if (use_iter) {
1104 				node = php_sxe_iterator_fetch(sxe, node->next, 0);
1105 			} else {
1106 				node = node->next;
1107 			}
1108 		}
1109 	}
1110 
1111 	if (use_iter) {
1112 		if (!Z_ISUNDEF(sxe->iter.data)) {
1113 			zval_ptr_dtor(&sxe->iter.data);
1114 		}
1115 		ZVAL_COPY_VALUE(&sxe->iter.data, &iter_data);
1116 	}
1117 
1118 	return is_empty;
1119 }
1120 /* }}} */
1121 
sxe_get_prop_hash(zval *object, int is_debug)1122 static HashTable *sxe_get_prop_hash(zval *object, int is_debug) /* {{{ */
1123 {
1124 	zval            value;
1125 	zval            zattr;
1126 	HashTable       *rv;
1127 	php_sxe_object  *sxe;
1128 	char            *name;
1129 	xmlNodePtr       node;
1130 	xmlAttrPtr       attr;
1131 	int              namelen;
1132 	int              test;
1133 	char 		 	 use_iter;
1134 	zval             iter_data;
1135 
1136 	use_iter = 0;
1137 
1138 	sxe = Z_SXEOBJ_P(object);
1139 
1140 	if (is_debug) {
1141 		rv = zend_new_array(0);
1142 	} else if (sxe->properties) {
1143 		zend_hash_clean(sxe->properties);
1144 		rv = sxe->properties;
1145 	} else {
1146 		rv = zend_new_array(0);
1147 		sxe->properties = rv;
1148 	}
1149 
1150 	GET_NODE(sxe, node);
1151 	if (!node) {
1152 		return rv;
1153 	}
1154 	if (is_debug || sxe->iter.type != SXE_ITER_CHILD) {
1155 		if (sxe->iter.type == SXE_ITER_ELEMENT) {
1156 			node = php_sxe_get_first_node(sxe, node);
1157 		}
1158 		if (!node || node->type != XML_ENTITY_DECL) {
1159 			attr = node ? (xmlAttrPtr)node->properties : NULL;
1160 			ZVAL_UNDEF(&zattr);
1161 			test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
1162 			while (attr) {
1163 				if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr)attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
1164 					ZVAL_STR(&value, sxe_xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, attr->children, 1));
1165 					namelen = xmlStrlen(attr->name);
1166 					if (Z_ISUNDEF(zattr)) {
1167 						array_init(&zattr);
1168 						sxe_properties_add(rv, "@attributes", sizeof("@attributes") - 1, &zattr);
1169 					}
1170 					add_assoc_zval_ex(&zattr, (char*)attr->name, namelen, &value);
1171 				}
1172 				attr = attr->next;
1173 			}
1174 		}
1175 	}
1176 
1177 	GET_NODE(sxe, node);
1178 	node = php_sxe_get_first_node(sxe, node);
1179 
1180 	if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
1181 		if (node->type == XML_ATTRIBUTE_NODE) {
1182 			ZVAL_STR(&value, sxe_xmlNodeListGetString(node->doc, node->children, 1));
1183 			zend_hash_next_index_insert(rv, &value);
1184 			node = NULL;
1185 		} else if (sxe->iter.type != SXE_ITER_CHILD) {
1186 
1187 			if ( sxe->iter.type == SXE_ITER_NONE || !node->children || !node->parent || !node->next || node->children->next || node->children->children || node->parent->children == node->parent->last ) {
1188 				node = node->children;
1189 			} else {
1190 				ZVAL_COPY_VALUE(&iter_data, &sxe->iter.data);
1191 				ZVAL_UNDEF(&sxe->iter.data);
1192 
1193 				node = php_sxe_reset_iterator(sxe, 0);
1194 
1195 				use_iter = 1;
1196 			}
1197 		}
1198 
1199 		while (node) {
1200 			if (node->children != NULL || node->prev != NULL || node->next != NULL || xmlIsBlankNode(node)) {
1201 				SKIP_TEXT(node);
1202 			} else {
1203 				if (node->type == XML_TEXT_NODE) {
1204 					const xmlChar *cur = node->content;
1205 
1206 					if (*cur != 0) {
1207 						ZVAL_STR(&value, sxe_xmlNodeListGetString(node->doc, node, 1));
1208 						zend_hash_next_index_insert(rv, &value);
1209 					}
1210 					goto next_iter;
1211 				}
1212 			}
1213 
1214 			if (node->type == XML_ELEMENT_NODE && (! match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix))) {
1215 				goto next_iter;
1216 			}
1217 
1218 			name = (char *) node->name;
1219 			if (!name) {
1220 				goto next_iter;
1221 			} else {
1222 				namelen = xmlStrlen(node->name);
1223 			}
1224 
1225 			_get_base_node_value(sxe, node, &value, sxe->iter.nsprefix, sxe->iter.isprefix);
1226 
1227 			if ( use_iter ) {
1228 				zend_hash_next_index_insert(rv, &value);
1229 			} else {
1230 				sxe_properties_add(rv, name, namelen, &value);
1231 			}
1232 next_iter:
1233 			if (use_iter) {
1234 				node = php_sxe_iterator_fetch(sxe, node->next, 0);
1235 			} else {
1236 				node = node->next;
1237 			}
1238 		}
1239 	}
1240 
1241 	if (use_iter) {
1242 		if (!Z_ISUNDEF(sxe->iter.data)) {
1243 			zval_ptr_dtor(&sxe->iter.data);
1244 		}
1245 		ZVAL_COPY_VALUE(&sxe->iter.data, &iter_data);
1246 	}
1247 
1248 	return rv;
1249 }
1250 /* }}} */
1251 
sxe_get_gc(zval *object, zval **table, int *n)1252 static HashTable *sxe_get_gc(zval *object, zval **table, int *n) /* {{{ */ {
1253 	php_sxe_object *sxe;
1254 	sxe = Z_SXEOBJ_P(object);
1255 
1256 	*table = NULL;
1257 	*n = 0;
1258 	return sxe->properties;
1259 }
1260 /* }}} */
1261 
sxe_get_properties(zval *object)1262 static HashTable *sxe_get_properties(zval *object) /* {{{ */
1263 {
1264 	return sxe_get_prop_hash(object, 0);
1265 }
1266 /* }}} */
1267 
sxe_get_debug_info(zval *object, int *is_temp)1268 static HashTable * sxe_get_debug_info(zval *object, int *is_temp) /* {{{ */
1269 {
1270 	*is_temp = 1;
1271 	return sxe_get_prop_hash(object, 1);
1272 }
1273 /* }}} */
1274 
sxe_objects_compare(zval *object1, zval *object2)1275 static int sxe_objects_compare(zval *object1, zval *object2) /* {{{ */
1276 {
1277 	php_sxe_object *sxe1;
1278 	php_sxe_object *sxe2;
1279 
1280 	sxe1 = Z_SXEOBJ_P(object1);
1281 	sxe2 = Z_SXEOBJ_P(object2);
1282 
1283 	if (sxe1->node == NULL) {
1284 		if (sxe2->node) {
1285 			return 1;
1286 		} else if (sxe1->document->ptr == sxe2->document->ptr) {
1287 			return 0;
1288 		}
1289 	} else {
1290 		return !(sxe1->node == sxe2->node);
1291 	}
1292 	return 1;
1293 }
1294 /* }}} */
1295 
1296 /* {{{ proto array SimpleXMLElement::xpath(string path)
1297    Runs XPath query on the XML data */
SXE_METHODnull1298 SXE_METHOD(xpath)
1299 {
1300 	php_sxe_object    *sxe;
1301 	zval               value;
1302 	char              *query;
1303 	size_t                query_len;
1304 	int                i;
1305 	int                nsnbr = 0;
1306 	xmlNsPtr          *ns = NULL;
1307 	xmlXPathObjectPtr  retval;
1308 	xmlNodeSetPtr      result;
1309 	xmlNodePtr		   nodeptr;
1310 
1311 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &query, &query_len) == FAILURE) {
1312 		return;
1313 	}
1314 
1315 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1316 
1317 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
1318 		return; /* attributes don't have attributes */
1319 	}
1320 
1321 	if (!sxe->xpath) {
1322 		sxe->xpath = xmlXPathNewContext((xmlDocPtr) sxe->document->ptr);
1323 	}
1324 	if (!sxe->node) {
1325 		php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement((xmlDocPtr) sxe->document->ptr), NULL);
1326 		if (!sxe->node) {
1327 			RETURN_FALSE;
1328 		}
1329 	}
1330 
1331 	nodeptr = php_sxe_get_first_node(sxe, sxe->node->node);
1332 
1333 	sxe->xpath->node = nodeptr;
1334 
1335  	ns = xmlGetNsList((xmlDocPtr) sxe->document->ptr, nodeptr);
1336 	if (ns != NULL) {
1337 		while (ns[nsnbr] != NULL) {
1338 			nsnbr++;
1339 		}
1340 	}
1341 
1342 	sxe->xpath->namespaces = ns;
1343 	sxe->xpath->nsNr = nsnbr;
1344 
1345 	retval = xmlXPathEval((xmlChar *)query, sxe->xpath);
1346 	if (ns != NULL) {
1347 		xmlFree(ns);
1348 		sxe->xpath->namespaces = NULL;
1349 		sxe->xpath->nsNr = 0;
1350 	}
1351 
1352 	if (!retval) {
1353 		RETURN_FALSE;
1354 	}
1355 
1356 	result = retval->nodesetval;
1357 
1358 	if (result != NULL) {
1359 		array_init(return_value);
1360 
1361 		for (i = 0; i < result->nodeNr; ++i) {
1362 			nodeptr = result->nodeTab[i];
1363 			if (nodeptr->type == XML_TEXT_NODE || nodeptr->type == XML_ELEMENT_NODE || nodeptr->type == XML_ATTRIBUTE_NODE) {
1364 				/**
1365 				 * Detect the case where the last selector is text(), simplexml
1366 				 * always accesses the text() child by default, therefore we assign
1367 				 * to the parent node.
1368 				 */
1369 				if (nodeptr->type == XML_TEXT_NODE) {
1370 					_node_as_zval(sxe, nodeptr->parent, &value, SXE_ITER_NONE, NULL, NULL, 0);
1371 				} else if (nodeptr->type == XML_ATTRIBUTE_NODE) {
1372 					_node_as_zval(sxe, nodeptr->parent, &value, SXE_ITER_ATTRLIST, (char*)nodeptr->name, nodeptr->ns ? (xmlChar *)nodeptr->ns->href : NULL, 0);
1373 				} else {
1374 					_node_as_zval(sxe, nodeptr, &value, SXE_ITER_NONE, NULL, NULL, 0);
1375 				}
1376 
1377 				add_next_index_zval(return_value, &value);
1378 			}
1379 		}
1380 	} else {
1381 		RETVAL_EMPTY_ARRAY();
1382 	}
1383 
1384 	xmlXPathFreeObject(retval);
1385 }
1386 /* }}} */
1387 
1388 /* {{{ proto bool SimpleXMLElement::registerXPathNamespace(string prefix, string ns)
1389    Creates a prefix/ns context for the next XPath query */
SXE_METHODnull1390 SXE_METHOD(registerXPathNamespace)
1391 {
1392 	php_sxe_object    *sxe;
1393 	size_t prefix_len, ns_uri_len;
1394 	char *prefix, *ns_uri;
1395 
1396 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &prefix, &prefix_len, &ns_uri, &ns_uri_len) == FAILURE) {
1397 		return;
1398 	}
1399 
1400 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1401 	if (!sxe->xpath) {
1402 		sxe->xpath = xmlXPathNewContext((xmlDocPtr) sxe->document->ptr);
1403 	}
1404 
1405 	if (xmlXPathRegisterNs(sxe->xpath, (xmlChar *)prefix, (xmlChar *)ns_uri) != 0) {
1406 		RETURN_FALSE
1407 	}
1408 	RETURN_TRUE;
1409 }
1410 
1411 /* }}} */
1412 
1413 /* {{{ proto string SimpleXMLElement::asXML([string filename])
1414    Return a well-formed XML string based on SimpleXML element */
SXE_METHODnull1415 SXE_METHOD(asXML)
1416 {
1417 	php_sxe_object     *sxe;
1418 	xmlNodePtr          node;
1419 	xmlOutputBufferPtr  outbuf;
1420 	xmlChar            *strval;
1421 	int                 strval_len;
1422 	char               *filename;
1423 	size_t                 filename_len;
1424 
1425 	if (ZEND_NUM_ARGS() > 1) {
1426 		RETURN_FALSE;
1427 	}
1428 
1429 	if (ZEND_NUM_ARGS() == 1) {
1430 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "p", &filename, &filename_len) == FAILURE) {
1431 			RETURN_FALSE;
1432 		}
1433 
1434 		sxe = Z_SXEOBJ_P(ZEND_THIS);
1435 		GET_NODE(sxe, node);
1436 		node = php_sxe_get_first_node(sxe, node);
1437 
1438 		if (node) {
1439 			if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
1440 				int bytes;
1441 				bytes = xmlSaveFile(filename, (xmlDocPtr) sxe->document->ptr);
1442 				if (bytes == -1) {
1443 					RETURN_FALSE;
1444 				} else {
1445 					RETURN_TRUE;
1446 				}
1447 			} else {
1448 				outbuf = xmlOutputBufferCreateFilename(filename, NULL, 0);
1449 
1450 				if (outbuf == NULL) {
1451 					RETURN_FALSE;
1452 				}
1453 
1454 				xmlNodeDumpOutput(outbuf, (xmlDocPtr) sxe->document->ptr, node, 0, 0, NULL);
1455 				xmlOutputBufferClose(outbuf);
1456 				RETURN_TRUE;
1457 			}
1458 		} else {
1459 			RETURN_FALSE;
1460 		}
1461 	}
1462 
1463 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1464 	GET_NODE(sxe, node);
1465 	node = php_sxe_get_first_node(sxe, node);
1466 
1467 	if (node) {
1468 		if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
1469 			xmlDocDumpMemoryEnc((xmlDocPtr) sxe->document->ptr, &strval, &strval_len, (const char *) ((xmlDocPtr) sxe->document->ptr)->encoding);
1470 			if (!strval) {
1471 				RETVAL_FALSE;
1472 			} else {
1473 				RETVAL_STRINGL((char *)strval, strval_len);
1474 			}
1475 			xmlFree(strval);
1476 		} else {
1477 			char *return_content;
1478 			size_t return_len;
1479 			/* Should we be passing encoding information instead of NULL? */
1480 			outbuf = xmlAllocOutputBuffer(NULL);
1481 
1482 			if (outbuf == NULL) {
1483 				RETURN_FALSE;
1484 			}
1485 
1486 			xmlNodeDumpOutput(outbuf, (xmlDocPtr) sxe->document->ptr, node, 0, 0, (const char *) ((xmlDocPtr) sxe->document->ptr)->encoding);
1487 			xmlOutputBufferFlush(outbuf);
1488 #ifdef LIBXML2_NEW_BUFFER
1489 			return_content = (char *)xmlOutputBufferGetContent(outbuf);
1490 			return_len = xmlOutputBufferGetSize(outbuf);
1491 #else
1492 			return_content = (char *)outbuf->buffer->content;
1493 			return_len = outbuf->buffer->use;
1494 #endif
1495 			if (!return_content) {
1496 				RETVAL_FALSE;
1497 			} else {
1498 				RETVAL_STRINGL(return_content, return_len);
1499 			}
1500 			xmlOutputBufferClose(outbuf);
1501 		}
1502 	} else {
1503 		RETVAL_FALSE;
1504 	}
1505 }
1506 /* }}} */
1507 
1508 #define SXE_NS_PREFIX(ns) (ns->prefix ? (char*)ns->prefix : "")
1509 
sxe_add_namespace_name(zval *return_value, xmlNsPtr ns)1510 static inline void sxe_add_namespace_name(zval *return_value, xmlNsPtr ns) /* {{{ */
1511 {
1512 	char *prefix = SXE_NS_PREFIX(ns);
1513 	zend_string *key = zend_string_init(prefix, strlen(prefix), 0);
1514 	zval zv;
1515 
1516 	if (!zend_hash_exists(Z_ARRVAL_P(return_value), key)) {
1517 		ZVAL_STRING(&zv, (char*)ns->href);
1518 		zend_hash_add_new(Z_ARRVAL_P(return_value), key, &zv);
1519 	}
1520 	zend_string_release_ex(key, 0);
1521 }
1522 /* }}} */
1523 
sxe_add_namespaces(php_sxe_object *sxe, xmlNodePtr node, zend_bool recursive, zval *return_value)1524 static void sxe_add_namespaces(php_sxe_object *sxe, xmlNodePtr node, zend_bool recursive, zval *return_value) /* {{{ */
1525 {
1526 	xmlAttrPtr  attr;
1527 
1528 	if (node->ns) {
1529 		sxe_add_namespace_name(return_value, node->ns);
1530 	}
1531 
1532 	attr = node->properties;
1533 	while (attr) {
1534 		if (attr->ns) {
1535 			sxe_add_namespace_name(return_value, attr->ns);
1536 		}
1537 		attr = attr->next;
1538 	}
1539 
1540 	if (recursive) {
1541 		node = node->children;
1542 		while (node) {
1543 			if (node->type == XML_ELEMENT_NODE) {
1544 				sxe_add_namespaces(sxe, node, recursive, return_value);
1545 			}
1546 			node = node->next;
1547 		}
1548 	}
1549 } /* }}} */
1550 
1551 /* {{{ proto string SimpleXMLElement::getNamespaces([bool recursve])
1552    Return all namespaces in use */
SXE_METHODnull1553 SXE_METHOD(getNamespaces)
1554 {
1555 	zend_bool           recursive = 0;
1556 	php_sxe_object     *sxe;
1557 	xmlNodePtr          node;
1558 
1559 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &recursive) == FAILURE) {
1560 		return;
1561 	}
1562 
1563 	array_init(return_value);
1564 
1565 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1566 	GET_NODE(sxe, node);
1567 	node = php_sxe_get_first_node(sxe, node);
1568 
1569 	if (node) {
1570 		if (node->type == XML_ELEMENT_NODE) {
1571 			sxe_add_namespaces(sxe, node, recursive, return_value);
1572 		} else if (node->type == XML_ATTRIBUTE_NODE && node->ns) {
1573 			sxe_add_namespace_name(return_value, node->ns);
1574 		}
1575 	}
1576 }
1577 /* }}} */
1578 
sxe_add_registered_namespaces(php_sxe_object *sxe, xmlNodePtr node, zend_bool recursive, zval *return_value)1579 static void sxe_add_registered_namespaces(php_sxe_object *sxe, xmlNodePtr node, zend_bool recursive, zval *return_value) /* {{{ */
1580 {
1581 	xmlNsPtr ns;
1582 
1583 	if (node->type == XML_ELEMENT_NODE) {
1584 		ns = node->nsDef;
1585 		while (ns != NULL) {
1586 			sxe_add_namespace_name(return_value, ns);
1587 			ns = ns->next;
1588 		}
1589 		if (recursive) {
1590 			node = node->children;
1591 			while (node) {
1592 				sxe_add_registered_namespaces(sxe, node, recursive, return_value);
1593 				node = node->next;
1594 			}
1595 		}
1596 	}
1597 }
1598 /* }}} */
1599 
1600 /* {{{ proto string SimpleXMLElement::getDocNamespaces([bool recursive [, bool from_root])
1601    Return all namespaces registered with document */
SXE_METHODnull1602 SXE_METHOD(getDocNamespaces)
1603 {
1604 	zend_bool           recursive = 0, from_root = 1;
1605 	php_sxe_object     *sxe;
1606 	xmlNodePtr          node;
1607 
1608 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|bb", &recursive, &from_root) == FAILURE) {
1609 		return;
1610 	}
1611 
1612 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1613 	if(from_root){
1614 		node = xmlDocGetRootElement((xmlDocPtr)sxe->document->ptr);
1615 	}else{
1616 		GET_NODE(sxe, node);
1617 	}
1618 
1619 	if (node == NULL) {
1620 		RETURN_FALSE;
1621 	}
1622 
1623 	array_init(return_value);
1624 	sxe_add_registered_namespaces(sxe, node, recursive, return_value);
1625 }
1626 /* }}} */
1627 
1628 /* {{{ proto object SimpleXMLElement::children([string ns [, bool is_prefix]])
1629    Finds children of given node */
SXE_METHODnull1630 SXE_METHOD(children)
1631 {
1632 	php_sxe_object *sxe;
1633 	char           *nsprefix = NULL;
1634 	size_t             nsprefix_len = 0;
1635 	xmlNodePtr      node;
1636 	zend_bool       isprefix = 0;
1637 
1638 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s!b", &nsprefix, &nsprefix_len, &isprefix) == FAILURE) {
1639 		return;
1640 	}
1641 
1642 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1643 
1644 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
1645 		return; /* attributes don't have attributes */
1646 	}
1647 
1648 	GET_NODE(sxe, node);
1649 	node = php_sxe_get_first_node(sxe, node);
1650 
1651 	_node_as_zval(sxe, node, return_value, SXE_ITER_CHILD, NULL, (xmlChar *)nsprefix, isprefix);
1652 
1653 }
1654 /* }}} */
1655 
1656 /* {{{ proto object SimpleXMLElement::getName()
1657    Finds children of given node */
SXE_METHODnull1658 SXE_METHOD(getName)
1659 {
1660 	php_sxe_object *sxe;
1661 	xmlNodePtr      node;
1662 	int             namelen;
1663 
1664 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1665 
1666 	GET_NODE(sxe, node);
1667 	node = php_sxe_get_first_node(sxe, node);
1668 	if (node) {
1669 		namelen = xmlStrlen(node->name);
1670 		RETURN_STRINGL((char*)node->name, namelen);
1671 	} else {
1672 		RETURN_EMPTY_STRING();
1673 	}
1674 }
1675 /* }}} */
1676 
1677 /* {{{ proto array SimpleXMLElement::attributes([string ns [, bool is_prefix]])
1678    Identifies an element's attributes */
SXE_METHODnull1679 SXE_METHOD(attributes)
1680 {
1681 	php_sxe_object *sxe;
1682 	char           *nsprefix = NULL;
1683 	size_t             nsprefix_len = 0;
1684 	xmlNodePtr      node;
1685 	zend_bool       isprefix = 0;
1686 
1687 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s!b", &nsprefix, &nsprefix_len, &isprefix) == FAILURE) {
1688 		return;
1689 	}
1690 
1691 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1692 	GET_NODE(sxe, node);
1693 
1694 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
1695 		return; /* attributes don't have attributes */
1696 	}
1697 
1698 	node = php_sxe_get_first_node(sxe, node);
1699 
1700 	_node_as_zval(sxe, node, return_value, SXE_ITER_ATTRLIST, NULL, (xmlChar *)nsprefix, isprefix);
1701 }
1702 /* }}} */
1703 
1704 /* {{{ proto void SimpleXMLElement::addChild(string qName [, string value [, string ns]])
1705    Add Element with optional namespace information */
SXE_METHODnull1706 SXE_METHOD(addChild)
1707 {
1708 	php_sxe_object *sxe;
1709 	char           *qname, *value = NULL, *nsuri = NULL;
1710 	size_t             qname_len, value_len = 0, nsuri_len = 0;
1711 	xmlNodePtr      node, newnode;
1712 	xmlNsPtr        nsptr = NULL;
1713 	xmlChar        *localname, *prefix = NULL;
1714 
1715 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!s!",
1716 		&qname, &qname_len, &value, &value_len, &nsuri, &nsuri_len) == FAILURE) {
1717 		return;
1718 	}
1719 
1720 	if (qname_len == 0) {
1721 		php_error_docref(NULL, E_WARNING, "Element name is required");
1722 		return;
1723 	}
1724 
1725 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1726 	GET_NODE(sxe, node);
1727 
1728 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
1729 		php_error_docref(NULL, E_WARNING, "Cannot add element to attributes");
1730 		return;
1731 	}
1732 
1733 	node = php_sxe_get_first_node(sxe, node);
1734 
1735 	if (node == NULL) {
1736 		php_error_docref(NULL, E_WARNING, "Cannot add child. Parent is not a permanent member of the XML tree");
1737 		return;
1738 	}
1739 
1740 	localname = xmlSplitQName2((xmlChar *)qname, &prefix);
1741 	if (localname == NULL) {
1742 		localname = xmlStrdup((xmlChar *)qname);
1743 	}
1744 
1745 	newnode = xmlNewChild(node, NULL, localname, (xmlChar *)value);
1746 
1747 	if (nsuri != NULL) {
1748 		if (nsuri_len == 0) {
1749 			newnode->ns = NULL;
1750 			nsptr = xmlNewNs(newnode, (xmlChar *)nsuri, prefix);
1751 		} else {
1752 			nsptr = xmlSearchNsByHref(node->doc, node, (xmlChar *)nsuri);
1753 			if (nsptr == NULL) {
1754 				nsptr = xmlNewNs(newnode, (xmlChar *)nsuri, prefix);
1755 			}
1756 			newnode->ns = nsptr;
1757 		}
1758 	}
1759 
1760 	_node_as_zval(sxe, newnode, return_value, SXE_ITER_NONE, (char *)localname, prefix, 0);
1761 
1762 	xmlFree(localname);
1763 	if (prefix != NULL) {
1764 		xmlFree(prefix);
1765 	}
1766 }
1767 /* }}} */
1768 
1769 /* {{{ proto void SimpleXMLElement::addAttribute(string qName, string value [,string ns])
1770    Add Attribute with optional namespace information */
SXE_METHODnull1771 SXE_METHOD(addAttribute)
1772 {
1773 	php_sxe_object *sxe;
1774 	char           *qname, *value = NULL, *nsuri = NULL;
1775 	size_t             qname_len, value_len = 0, nsuri_len = 0;
1776 	xmlNodePtr      node;
1777 	xmlAttrPtr      attrp = NULL;
1778 	xmlNsPtr        nsptr = NULL;
1779 	xmlChar        *localname, *prefix = NULL;
1780 
1781 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|s!",
1782 		&qname, &qname_len, &value, &value_len, &nsuri, &nsuri_len) == FAILURE) {
1783 		return;
1784 	}
1785 
1786 	if (qname_len == 0) {
1787 		php_error_docref(NULL, E_WARNING, "Attribute name is required");
1788 		return;
1789 	}
1790 
1791 	sxe = Z_SXEOBJ_P(ZEND_THIS);
1792 	GET_NODE(sxe, node);
1793 
1794 	node = php_sxe_get_first_node(sxe, node);
1795 
1796 	if (node && node->type != XML_ELEMENT_NODE) {
1797 		node = node->parent;
1798 	}
1799 
1800 	if (node == NULL) {
1801 		php_error_docref(NULL, E_WARNING, "Unable to locate parent Element");
1802 		return;
1803 	}
1804 
1805 	localname = xmlSplitQName2((xmlChar *)qname, &prefix);
1806 	if (localname == NULL) {
1807 		if (nsuri_len > 0) {
1808 			if (prefix != NULL) {
1809 				xmlFree(prefix);
1810 			}
1811 			php_error_docref(NULL, E_WARNING, "Attribute requires prefix for namespace");
1812 			return;
1813 		}
1814 		localname = xmlStrdup((xmlChar *)qname);
1815 	}
1816 
1817 	attrp = xmlHasNsProp(node, localname, (xmlChar *)nsuri);
1818 	if (attrp != NULL && attrp->type != XML_ATTRIBUTE_DECL) {
1819 		xmlFree(localname);
1820 		if (prefix != NULL) {
1821 			xmlFree(prefix);
1822 		}
1823 		php_error_docref(NULL, E_WARNING, "Attribute already exists");
1824 		return;
1825 	}
1826 
1827 	if (nsuri != NULL) {
1828 		nsptr = xmlSearchNsByHref(node->doc, node, (xmlChar *)nsuri);
1829 		if (nsptr == NULL) {
1830 			nsptr = xmlNewNs(node, (xmlChar *)nsuri, prefix);
1831 		}
1832 	}
1833 
1834 	attrp = xmlNewNsProp(node, nsptr, localname, (xmlChar *)value);
1835 
1836 	xmlFree(localname);
1837 	if (prefix != NULL) {
1838 		xmlFree(prefix);
1839 	}
1840 }
1841 /* }}} */
1842 
1843 /* {{{ cast_object()
1844  */
cast_object(zval *object, int type, char *contents)1845 static int cast_object(zval *object, int type, char *contents)
1846 {
1847 	if (contents) {
1848 		ZVAL_STRINGL(object, contents, strlen(contents));
1849 	} else {
1850 		ZVAL_NULL(object);
1851 	}
1852 
1853 	switch (type) {
1854 		case IS_STRING:
1855 			convert_to_string(object);
1856 			break;
1857 		case _IS_BOOL:
1858 			convert_to_boolean(object);
1859 			break;
1860 		case IS_LONG:
1861 			convert_to_long(object);
1862 			break;
1863 		case IS_DOUBLE:
1864 			convert_to_double(object);
1865 			break;
1866 		case _IS_NUMBER:
1867 			convert_scalar_to_number(object);
1868 			break;
1869 		default:
1870 			return FAILURE;
1871 	}
1872 	return SUCCESS;
1873 }
1874 /* }}} */
1875 
1876 /* {{{ sxe_object_cast()
1877  */
sxe_object_cast_ex(zval *readobj, zval *writeobj, int type)1878 static int sxe_object_cast_ex(zval *readobj, zval *writeobj, int type)
1879 {
1880 	php_sxe_object *sxe;
1881 	xmlChar        *contents = NULL;
1882 	xmlNodePtr	    node;
1883 	int rv;
1884 
1885 	sxe = Z_SXEOBJ_P(readobj);
1886 
1887 	if (type == _IS_BOOL) {
1888 		node = php_sxe_get_first_node(sxe, NULL);
1889 		if (node) {
1890 			ZVAL_TRUE(writeobj);
1891 		} else {
1892 			ZVAL_BOOL(writeobj, !sxe_prop_is_empty(readobj));
1893 		}
1894 		return SUCCESS;
1895 	}
1896 
1897 	if (sxe->iter.type != SXE_ITER_NONE) {
1898 		node = php_sxe_get_first_node(sxe, NULL);
1899 		if (node) {
1900 			contents = xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, node->children, 1);
1901 		}
1902 	} else {
1903 		if (!sxe->node) {
1904 			if (sxe->document) {
1905 				php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement((xmlDocPtr) sxe->document->ptr), NULL);
1906 			}
1907 		}
1908 
1909 		if (sxe->node && sxe->node->node) {
1910 			if (sxe->node->node->children) {
1911 				contents = xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, sxe->node->node->children, 1);
1912 			}
1913 		}
1914 	}
1915 
1916 	rv = cast_object(writeobj, type, (char *)contents);
1917 
1918 	if (contents) {
1919 		xmlFree(contents);
1920 	}
1921 
1922 	return rv;
1923 }
1924 /* }}} */
1925 
1926 /*  {{{ Variant of sxe_object_cast_ex that handles overwritten __toString() method */
sxe_object_cast(zval *readobj, zval *writeobj, int type)1927 static int sxe_object_cast(zval *readobj, zval *writeobj, int type)
1928 {
1929 	if (type == IS_STRING
1930 		&& zend_std_cast_object_tostring(readobj, writeobj, IS_STRING) == SUCCESS
1931 	) {
1932 		return SUCCESS;
1933 	}
1934 
1935 	return sxe_object_cast_ex(readobj, writeobj, type);
1936 }
1937 /* }}} */
1938 
1939 /* {{{ proto object SimpleXMLElement::__toString()
1940    Returns the string content */
SXE_METHODnull1941 SXE_METHOD(__toString)
1942 {
1943 	if (sxe_object_cast_ex(ZEND_THIS, return_value, IS_STRING) != SUCCESS) {
1944 		zval_ptr_dtor(return_value);
1945 		RETURN_EMPTY_STRING();
1946 	}
1947 }
1948 /* }}} */
1949 
php_sxe_count_elements_helper(php_sxe_object *sxe, zend_long *count)1950 static int php_sxe_count_elements_helper(php_sxe_object *sxe, zend_long *count) /* {{{ */
1951 {
1952 	xmlNodePtr      node;
1953 	zval            data;
1954 
1955 	*count = 0;
1956 
1957 	ZVAL_COPY_VALUE(&data, &sxe->iter.data);
1958 	ZVAL_UNDEF(&sxe->iter.data);
1959 
1960 	node = php_sxe_reset_iterator(sxe, 0);
1961 
1962 	while (node)
1963 	{
1964 		(*count)++;
1965 		node = php_sxe_iterator_fetch(sxe, node->next, 0);
1966 	}
1967 
1968 	if (!Z_ISUNDEF(sxe->iter.data)) {
1969 		zval_ptr_dtor(&sxe->iter.data);
1970 	}
1971 	ZVAL_COPY_VALUE(&sxe->iter.data, &data);
1972 
1973 	return SUCCESS;
1974 }
1975 /* }}} */
1976 
sxe_count_elements(zval *object, zend_long *count)1977 static int sxe_count_elements(zval *object, zend_long *count) /* {{{ */
1978 {
1979 	php_sxe_object  *intern;
1980 	intern = Z_SXEOBJ_P(object);
1981 	if (intern->fptr_count) {
1982 		zval rv;
1983 		zend_call_method_with_0_params(object, intern->zo.ce, &intern->fptr_count, "count", &rv);
1984 		if (!Z_ISUNDEF(rv)) {
1985 			*count = zval_get_long(&rv);
1986 			zval_ptr_dtor(&rv);
1987 			return SUCCESS;
1988 		}
1989 		return FAILURE;
1990 	}
1991 	return php_sxe_count_elements_helper(intern, count);
1992 }
1993 /* }}} */
1994 
1995 /* {{{ proto int SimpleXMLElement::count()
1996  Get number of child elements */
SXE_METHODnull1997 SXE_METHOD(count)
1998 {
1999 	zend_long count = 0;
2000 	php_sxe_object *sxe = Z_SXEOBJ_P(ZEND_THIS);
2001 
2002 	if (zend_parse_parameters_none() == FAILURE) {
2003 		return;
2004 	}
2005 
2006 	php_sxe_count_elements_helper(sxe, &count);
2007 
2008 	RETURN_LONG(count);
2009 }
2010 /* }}} */
2011 
sxe_get_value(zval *z, zval *rv)2012 static zval *sxe_get_value(zval *z, zval *rv) /* {{{ */
2013 {
2014 	if (sxe_object_cast_ex(z, rv, IS_STRING) == FAILURE) {
2015 		zend_error(E_ERROR, "Unable to cast node to string");
2016 		/* FIXME: Should not be fatal */
2017 	}
2018 
2019 	return rv;
2020 }
2021 /* }}} */
2022 
2023 static zend_object_handlers sxe_object_handlers;
2024 
2025 /* {{{ sxe_object_clone()
2026  */
2027 static zend_object *
sxe_object_clone(zval *object)2028 sxe_object_clone(zval *object)
2029 {
2030 	php_sxe_object *sxe = Z_SXEOBJ_P(object);
2031 	php_sxe_object *clone;
2032 	xmlNodePtr nodep = NULL;
2033 	xmlDocPtr docp = NULL;
2034 
2035 	clone = php_sxe_object_new(sxe->zo.ce, sxe->fptr_count);
2036 	clone->document = sxe->document;
2037 	if (clone->document) {
2038 		clone->document->refcount++;
2039 		docp = clone->document->ptr;
2040 	}
2041 
2042 	clone->iter.isprefix = sxe->iter.isprefix;
2043 	if (sxe->iter.name != NULL) {
2044 		clone->iter.name = (xmlChar*)estrdup((char*)sxe->iter.name);
2045 	}
2046 	if (sxe->iter.nsprefix != NULL) {
2047 		clone->iter.nsprefix = (xmlChar*)estrdup((char*)sxe->iter.nsprefix);
2048 	}
2049 	clone->iter.type = sxe->iter.type;
2050 
2051 	if (sxe->node) {
2052 		nodep = xmlDocCopyNode(sxe->node->node, docp, 1);
2053 	}
2054 
2055 	php_libxml_increment_node_ptr((php_libxml_node_object *)clone, nodep, NULL);
2056 
2057 	return &clone->zo;
2058 }
2059 /* }}} */
2060 
2061 /* {{{ sxe_object_dtor()
2062  */
sxe_object_dtor(zend_object *object)2063 static void sxe_object_dtor(zend_object *object)
2064 {
2065 	/* dtor required to cleanup iterator related data properly */
2066 	php_sxe_object *sxe;
2067 
2068 	sxe = php_sxe_fetch_object(object);
2069 
2070 	if (!Z_ISUNDEF(sxe->iter.data)) {
2071 		zval_ptr_dtor(&sxe->iter.data);
2072 		ZVAL_UNDEF(&sxe->iter.data);
2073 	}
2074 
2075 	if (sxe->iter.name) {
2076 		efree(sxe->iter.name);
2077 		sxe->iter.name = NULL;
2078 	}
2079 	if (sxe->iter.nsprefix) {
2080 		efree(sxe->iter.nsprefix);
2081 		sxe->iter.nsprefix = NULL;
2082 	}
2083 	if (!Z_ISUNDEF(sxe->tmp)) {
2084 		zval_ptr_dtor(&sxe->tmp);
2085 		ZVAL_UNDEF(&sxe->tmp);
2086 	}
2087 }
2088 /* }}} */
2089 
2090 /* {{{ sxe_object_free_storage()
2091  */
sxe_object_free_storage(zend_object *object)2092 static void sxe_object_free_storage(zend_object *object)
2093 {
2094 	php_sxe_object *sxe;
2095 
2096 	sxe = php_sxe_fetch_object(object);
2097 
2098 	zend_object_std_dtor(&sxe->zo);
2099 
2100 	php_libxml_node_decrement_resource((php_libxml_node_object *)sxe);
2101 
2102 	if (sxe->xpath) {
2103 		xmlXPathFreeContext(sxe->xpath);
2104 	}
2105 
2106 	if (sxe->properties) {
2107 		zend_hash_destroy(sxe->properties);
2108 		FREE_HASHTABLE(sxe->properties);
2109 	}
2110 }
2111 /* }}} */
2112 
2113 /* {{{ php_sxe_find_fptr_count()
2114  */
php_sxe_find_fptr_count(zend_class_entry *ce)2115 static zend_function* php_sxe_find_fptr_count(zend_class_entry *ce)
2116 {
2117 	zend_function *fptr_count = NULL;
2118 	zend_class_entry *parent = ce;
2119 	int inherited = 0;
2120 
2121 	while (parent) {
2122 		if (parent == sxe_class_entry) {
2123 			break;
2124 		}
2125 		parent = parent->parent;
2126 		inherited = 1;
2127 	}
2128 
2129 	if (inherited) {
2130 		fptr_count = zend_hash_str_find_ptr(&ce->function_table, "count", sizeof("count") - 1);
2131 		if (fptr_count->common.scope == parent) {
2132 			fptr_count = NULL;
2133 		}
2134 	}
2135 
2136 	return fptr_count;
2137 }
2138 /* }}} */
2139 
2140 /* {{{ php_sxe_object_new()
2141  */
php_sxe_object_new(zend_class_entry *ce, zend_function *fptr_count)2142 static php_sxe_object* php_sxe_object_new(zend_class_entry *ce, zend_function *fptr_count)
2143 {
2144 	php_sxe_object *intern;
2145 
2146 	intern = zend_object_alloc(sizeof(php_sxe_object), ce);
2147 
2148 	intern->iter.type = SXE_ITER_NONE;
2149 	intern->iter.nsprefix = NULL;
2150 	intern->iter.name = NULL;
2151 	intern->fptr_count = fptr_count;
2152 
2153 	zend_object_std_init(&intern->zo, ce);
2154 	object_properties_init(&intern->zo, ce);
2155 	intern->zo.handlers = &sxe_object_handlers;
2156 
2157 	return intern;
2158 }
2159 /* }}} */
2160 
2161 /* {{{ sxe_object_new()
2162  */
2163 PHP_SXE_API zend_object *
sxe_object_new(zend_class_entry *ce)2164 sxe_object_new(zend_class_entry *ce)
2165 {
2166 	php_sxe_object    *intern;
2167 
2168 	intern = php_sxe_object_new(ce, php_sxe_find_fptr_count(ce));
2169 	return &intern->zo;
2170 }
2171 /* }}} */
2172 
2173 /* {{{ proto simplemxml_element simplexml_load_file(string filename [, string class_name [, int options [, string ns [, bool is_prefix]]]])
2174    Load a filename and return a simplexml_element object to allow for processing */
PHP_FUNCTIONnull2175 PHP_FUNCTION(simplexml_load_file)
2176 {
2177 	php_sxe_object *sxe;
2178 	char           *filename;
2179 	size_t             filename_len;
2180 	xmlDocPtr       docp;
2181 	char           *ns = NULL;
2182 	size_t             ns_len = 0;
2183 	zend_long            options = 0;
2184 	zend_class_entry *ce= sxe_class_entry;
2185 	zend_function    *fptr_count;
2186 	zend_bool       isprefix = 0;
2187 
2188 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "p|C!lsb", &filename, &filename_len, &ce, &options, &ns, &ns_len, &isprefix) == FAILURE) {
2189 		return;
2190 	}
2191 
2192 	if (ZEND_LONG_EXCEEDS_INT(options)) {
2193 		php_error_docref(NULL, E_WARNING, "Invalid options");
2194 		RETURN_FALSE;
2195 	}
2196 
2197 	docp = xmlReadFile(filename, NULL, (int)options);
2198 
2199 	if (!docp) {
2200 		RETURN_FALSE;
2201 	}
2202 
2203 	if (!ce) {
2204 		ce = sxe_class_entry;
2205 		fptr_count = NULL;
2206 	} else {
2207 		fptr_count = php_sxe_find_fptr_count(ce);
2208 	}
2209 	sxe = php_sxe_object_new(ce, fptr_count);
2210 	sxe->iter.nsprefix = ns_len ? (xmlChar*)estrdup(ns) : NULL;
2211 	sxe->iter.isprefix = isprefix;
2212 	php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp);
2213 	php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL);
2214 
2215 	ZVAL_OBJ(return_value, &sxe->zo);
2216 }
2217 /* }}} */
2218 
2219 /* {{{ proto simplemxml_element simplexml_load_string(string data [, string class_name [, int options [, string ns [, bool is_prefix]]]])
2220    Load a string and return a simplexml_element object to allow for processing */
PHP_FUNCTIONnull2221 PHP_FUNCTION(simplexml_load_string)
2222 {
2223 	php_sxe_object *sxe;
2224 	char           *data;
2225 	size_t             data_len;
2226 	xmlDocPtr       docp;
2227 	char           *ns = NULL;
2228 	size_t             ns_len = 0;
2229 	zend_long            options = 0;
2230 	zend_class_entry *ce= sxe_class_entry;
2231 	zend_function    *fptr_count;
2232 	zend_bool       isprefix = 0;
2233 
2234 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|C!lsb", &data, &data_len, &ce, &options, &ns, &ns_len, &isprefix) == FAILURE) {
2235 		return;
2236 	}
2237 
2238 	if (ZEND_SIZE_T_INT_OVFL(data_len)) {
2239 		php_error_docref(NULL, E_WARNING, "Data is too long");
2240 		RETURN_FALSE;
2241 	}
2242 	if (ZEND_SIZE_T_INT_OVFL(ns_len)) {
2243 		php_error_docref(NULL, E_WARNING, "Namespace is too long");
2244 		RETURN_FALSE;
2245 	}
2246 	if (ZEND_LONG_EXCEEDS_INT(options)) {
2247 		php_error_docref(NULL, E_WARNING, "Invalid options");
2248 		RETURN_FALSE;
2249 	}
2250 
2251 	docp = xmlReadMemory(data, (int)data_len, NULL, NULL, (int)options);
2252 
2253 	if (!docp) {
2254 		RETURN_FALSE;
2255 	}
2256 
2257 	if (!ce) {
2258 		ce = sxe_class_entry;
2259 		fptr_count = NULL;
2260 	} else {
2261 		fptr_count = php_sxe_find_fptr_count(ce);
2262 	}
2263 	sxe = php_sxe_object_new(ce, fptr_count);
2264 	sxe->iter.nsprefix = ns_len ? (xmlChar*)estrdup(ns) : NULL;
2265 	sxe->iter.isprefix = isprefix;
2266 	php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp);
2267 	php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL);
2268 
2269 	ZVAL_OBJ(return_value, &sxe->zo);
2270 }
2271 /* }}} */
2272 
2273 /* {{{ proto SimpleXMLElement::__construct(string data [, int options [, bool data_is_url [, string ns [, bool is_prefix]]]])
2274    SimpleXMLElement constructor */
SXE_METHODnull2275 SXE_METHOD(__construct)
2276 {
2277 	php_sxe_object *sxe = Z_SXEOBJ_P(ZEND_THIS);
2278 	char           *data, *ns = NULL;
2279 	size_t             data_len, ns_len = 0;
2280 	xmlDocPtr       docp;
2281 	zend_long            options = 0;
2282 	zend_bool       is_url = 0, isprefix = 0;
2283 
2284 	if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s|lbsb", &data, &data_len, &options, &is_url, &ns, &ns_len, &isprefix) == FAILURE) {
2285 		return;
2286 	}
2287 
2288 	if (ZEND_SIZE_T_INT_OVFL(data_len)) {
2289 		zend_throw_exception(zend_ce_exception, "Data is too long", 0);
2290 		return;
2291 	}
2292 	if (ZEND_SIZE_T_INT_OVFL(ns_len)) {
2293 		zend_throw_exception(zend_ce_exception, "Namespace is too long", 0);
2294 		return;
2295 	}
2296 	if (ZEND_LONG_EXCEEDS_INT(options)) {
2297 		zend_throw_exception(zend_ce_exception, "Invalid options", 0);
2298 		return;
2299 	}
2300 
2301 	docp = is_url ? xmlReadFile(data, NULL, (int)options) : xmlReadMemory(data, (int)data_len, NULL, NULL, (int)options);
2302 
2303 	if (!docp) {
2304 		((php_libxml_node_object *)sxe)->document = NULL;
2305 		zend_throw_exception(zend_ce_exception, "String could not be parsed as XML", 0);
2306 		return;
2307 	}
2308 
2309 	sxe->iter.nsprefix = ns_len ? (xmlChar*)estrdup(ns) : NULL;
2310 	sxe->iter.isprefix = isprefix;
2311 	php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp);
2312 	php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL);
2313 }
2314 /* }}} */
2315 
2316 static const zend_object_iterator_funcs php_sxe_iterator_funcs = { /* {{{ */
2317 	php_sxe_iterator_dtor,
2318 	php_sxe_iterator_valid,
2319 	php_sxe_iterator_current_data,
2320 	php_sxe_iterator_current_key,
2321 	php_sxe_iterator_move_forward,
2322 	php_sxe_iterator_rewind,
2323 	NULL
2324 };
2325 /* }}} */
2326 
php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data)2327 static xmlNodePtr php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data) /* {{{ */
2328 {
2329 	xmlChar *prefix  = sxe->iter.nsprefix;
2330 	int isprefix  = sxe->iter.isprefix;
2331 
2332 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
2333 		if (sxe->iter.name) {
2334 			while (node) {
2335 				if (node->type == XML_ATTRIBUTE_NODE) {
2336 					if (!xmlStrcmp(node->name, sxe->iter.name) && match_ns(sxe, node, prefix, isprefix)) {
2337 						break;
2338 					}
2339 				}
2340 				node = node->next;
2341 			}
2342 		} else {
2343 			while (node) {
2344 				if (node->type == XML_ATTRIBUTE_NODE) {
2345 					if (match_ns(sxe, node, prefix, isprefix)) {
2346 						break;
2347 					}
2348 				}
2349 				node = node->next;
2350 			}
2351 		}
2352 	} else if (sxe->iter.type == SXE_ITER_ELEMENT && sxe->iter.name) {
2353 		while (node) {
2354 			if (node->type == XML_ELEMENT_NODE) {
2355 				if (!xmlStrcmp(node->name, sxe->iter.name) && match_ns(sxe, node, prefix, isprefix)) {
2356 					break;
2357 				}
2358 			}
2359 			node = node->next;
2360 		}
2361 	} else {
2362 		while (node) {
2363 			if (node->type == XML_ELEMENT_NODE) {
2364 				if (match_ns(sxe, node, prefix, isprefix)) {
2365 					break;
2366 				}
2367 			}
2368 			node = node->next;
2369 		}
2370 	}
2371 
2372 	if (node && use_data) {
2373 		_node_as_zval(sxe, node, &sxe->iter.data, SXE_ITER_NONE, NULL, prefix, isprefix);
2374 	}
2375 
2376 	return node;
2377 }
2378 /* }}} */
2379 
php_sxe_reset_iterator(php_sxe_object *sxe, int use_data)2380 static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data) /* {{{ */
2381 {
2382 	xmlNodePtr node;
2383 
2384 	if (!Z_ISUNDEF(sxe->iter.data)) {
2385 		zval_ptr_dtor(&sxe->iter.data);
2386 		ZVAL_UNDEF(&sxe->iter.data);
2387 	}
2388 
2389 	GET_NODE(sxe, node)
2390 
2391 	if (node) {
2392 		switch (sxe->iter.type) {
2393 			case SXE_ITER_ELEMENT:
2394 			case SXE_ITER_CHILD:
2395 			case SXE_ITER_NONE:
2396 				node = node->children;
2397 				break;
2398 			case SXE_ITER_ATTRLIST:
2399 				node = (xmlNodePtr) node->properties;
2400 		}
2401 		return php_sxe_iterator_fetch(sxe, node, use_data);
2402 	}
2403 	return NULL;
2404 }
2405 /* }}} */
2406 
php_sxe_get_iterator(zend_class_entry *ce, zval *object, int by_ref)2407 zend_object_iterator *php_sxe_get_iterator(zend_class_entry *ce, zval *object, int by_ref) /* {{{ */
2408 {
2409 	php_sxe_iterator *iterator;
2410 
2411 	if (by_ref) {
2412 		zend_throw_error(NULL, "An iterator cannot be used with foreach by reference");
2413 		return NULL;
2414 	}
2415 	iterator = emalloc(sizeof(php_sxe_iterator));
2416 	zend_iterator_init(&iterator->intern);
2417 
2418 	Z_ADDREF_P(object);
2419 	ZVAL_OBJ(&iterator->intern.data, Z_OBJ_P(object));
2420 	iterator->intern.funcs = &php_sxe_iterator_funcs;
2421 	iterator->sxe = Z_SXEOBJ_P(object);
2422 
2423 	return (zend_object_iterator*)iterator;
2424 }
2425 /* }}} */
2426 
php_sxe_iterator_dtor(zend_object_iterator *iter)2427 static void php_sxe_iterator_dtor(zend_object_iterator *iter) /* {{{ */
2428 {
2429 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2430 
2431 	/* cleanup handled in sxe_object_dtor as we don't always have an iterator wrapper */
2432 	if (!Z_ISUNDEF(iterator->intern.data)) {
2433 		zval_ptr_dtor(&iterator->intern.data);
2434 	}
2435 }
2436 /* }}} */
2437 
php_sxe_iterator_valid(zend_object_iterator *iter)2438 static int php_sxe_iterator_valid(zend_object_iterator *iter) /* {{{ */
2439 {
2440 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2441 
2442 	return Z_ISUNDEF(iterator->sxe->iter.data) ? FAILURE : SUCCESS;
2443 }
2444 /* }}} */
2445 
php_sxe_iterator_current_data(zend_object_iterator *iter)2446 static zval *php_sxe_iterator_current_data(zend_object_iterator *iter) /* {{{ */
2447 {
2448 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2449 
2450 	return &iterator->sxe->iter.data;
2451 }
2452 /* }}} */
2453 
php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key)2454 static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key) /* {{{ */
2455 {
2456 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2457 	zval *curobj = &iterator->sxe->iter.data;
2458 	php_sxe_object *intern = Z_SXEOBJ_P(curobj);
2459 
2460 	xmlNodePtr curnode = NULL;
2461 	if (intern != NULL && intern->node != NULL) {
2462 		curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->node)->node;
2463 	}
2464 
2465 	if (curnode) {
2466 		ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name));
2467 	} else {
2468 		ZVAL_NULL(key);
2469 	}
2470 }
2471 /* }}} */
2472 
php_sxe_move_forward_iterator(php_sxe_object *sxe)2473 PHP_SXE_API void php_sxe_move_forward_iterator(php_sxe_object *sxe) /* {{{ */
2474 {
2475 	xmlNodePtr      node = NULL;
2476 	php_sxe_object  *intern;
2477 
2478 	if (!Z_ISUNDEF(sxe->iter.data)) {
2479 		intern = Z_SXEOBJ_P(&sxe->iter.data);
2480 		GET_NODE(intern, node)
2481 		zval_ptr_dtor(&sxe->iter.data);
2482 		ZVAL_UNDEF(&sxe->iter.data);
2483 	}
2484 
2485 	if (node) {
2486 		php_sxe_iterator_fetch(sxe, node->next, 1);
2487 	}
2488 }
2489 /* }}} */
2490 
php_sxe_iterator_move_forward(zend_object_iterator *iter)2491 static void php_sxe_iterator_move_forward(zend_object_iterator *iter) /* {{{ */
2492 {
2493 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2494 	php_sxe_move_forward_iterator(iterator->sxe);
2495 }
2496 /* }}} */
2497 
php_sxe_rewind_iterator(php_sxe_object *sxe)2498 PHP_SXE_API void php_sxe_rewind_iterator(php_sxe_object *sxe) /* {{{ */
2499 {
2500 	php_sxe_reset_iterator(sxe, 1);
2501 }
2502 /* }}} */
2503 
php_sxe_iterator_rewind(zend_object_iterator *iter)2504 static void php_sxe_iterator_rewind(zend_object_iterator *iter) /* {{{ */
2505 {
2506 	php_sxe_object	*sxe;
2507 
2508 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2509 	sxe = iterator->sxe;
2510 
2511 	php_sxe_reset_iterator(sxe, 1);
2512 }
2513 /* }}} */
2514 
simplexml_export_node(zval *object)2515 void *simplexml_export_node(zval *object) /* {{{ */
2516 {
2517 	php_sxe_object *sxe;
2518 	xmlNodePtr node;
2519 
2520 	sxe = Z_SXEOBJ_P(object);
2521 	GET_NODE(sxe, node);
2522 	return php_sxe_get_first_node(sxe, node);
2523 }
2524 /* }}} */
2525 
2526 /* {{{ proto simplemxml_element simplexml_import_dom(domNode node [, string class_name])
2527    Get a simplexml_element object from dom to allow for processing */
PHP_FUNCTIONnull2528 PHP_FUNCTION(simplexml_import_dom)
2529 {
2530 	php_sxe_object *sxe;
2531 	zval *node;
2532 	php_libxml_node_object *object;
2533 	xmlNodePtr		nodep = NULL;
2534 	zend_class_entry *ce = sxe_class_entry;
2535 	zend_function    *fptr_count;
2536 
2537 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|C!", &node, &ce) == FAILURE) {
2538 		return;
2539 	}
2540 
2541 	object = Z_LIBXML_NODE_P(node);
2542 
2543 	nodep = php_libxml_import_node(node);
2544 
2545 	if (nodep) {
2546 		if (nodep->doc == NULL) {
2547 			php_error_docref(NULL, E_WARNING, "Imported Node must have associated Document");
2548 			RETURN_NULL();
2549 		}
2550 		if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
2551 			nodep = xmlDocGetRootElement((xmlDocPtr) nodep);
2552 		}
2553 	}
2554 
2555 	if (nodep && nodep->type == XML_ELEMENT_NODE) {
2556 		if (!ce) {
2557 			ce = sxe_class_entry;
2558 			fptr_count = NULL;
2559 		} else {
2560 			fptr_count = php_sxe_find_fptr_count(ce);
2561 		}
2562 		sxe = php_sxe_object_new(ce, fptr_count);
2563 		sxe->document = object->document;
2564 		php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, nodep->doc);
2565 		php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, nodep, NULL);
2566 
2567 		ZVAL_OBJ(return_value, &sxe->zo);
2568 	} else {
2569 		php_error_docref(NULL, E_WARNING, "Invalid Nodetype to import");
2570 		RETVAL_NULL();
2571 	}
2572 }
2573 /* }}} */
2574 
2575 /* {{{ arginfo */
2576 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_load_file, 0, 0, 1)
2577 	ZEND_ARG_INFO(0, filename)
2578 	ZEND_ARG_INFO(0, class_name)
2579 	ZEND_ARG_INFO(0, options)
2580 	ZEND_ARG_INFO(0, ns)
2581 	ZEND_ARG_INFO(0, is_prefix)
2582 ZEND_END_ARG_INFO()
2583 
2584 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_load_string, 0, 0, 1)
2585 	ZEND_ARG_INFO(0, data)
2586 	ZEND_ARG_INFO(0, class_name)
2587 	ZEND_ARG_INFO(0, options)
2588 	ZEND_ARG_INFO(0, ns)
2589 	ZEND_ARG_INFO(0, is_prefix)
2590 ZEND_END_ARG_INFO()
2591 
2592 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_import_dom, 0, 0, 1)
2593 	ZEND_ARG_INFO(0, node)
2594 	ZEND_ARG_INFO(0, class_name)
2595 ZEND_END_ARG_INFO()
2596 
2597 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_xpath, 0, 0, 1)
2598 	ZEND_ARG_INFO(0, path)
2599 ZEND_END_ARG_INFO()
2600 
2601 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_registerxpathnamespace, 0, 0, 2)
2602 	ZEND_ARG_INFO(0, prefix)
2603 	ZEND_ARG_INFO(0, ns)
2604 ZEND_END_ARG_INFO()
2605 
2606 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_asxml, 0, 0, 0)
2607 	ZEND_ARG_INFO(0, filename)
2608 ZEND_END_ARG_INFO()
2609 
2610 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_getnamespaces, 0, 0, 0)
2611 	ZEND_ARG_INFO(0, recursve)
2612 ZEND_END_ARG_INFO()
2613 
2614 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_getdocnamespaces, 0, 0, 0)
2615 	ZEND_ARG_INFO(0, recursve)
2616 	ZEND_ARG_INFO(0, from_root)
2617 ZEND_END_ARG_INFO()
2618 
2619 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_children, 0, 0, 0)
2620 	ZEND_ARG_INFO(0, ns)
2621 	ZEND_ARG_INFO(0, is_prefix)
2622 ZEND_END_ARG_INFO()
2623 
2624 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement__construct, 0, 0, 1)
2625 	ZEND_ARG_INFO(0, data)
2626 	ZEND_ARG_INFO(0, options)
2627 	ZEND_ARG_INFO(0, data_is_url)
2628 	ZEND_ARG_INFO(0, ns)
2629 	ZEND_ARG_INFO(0, is_prefix)
2630 ZEND_END_ARG_INFO()
2631 
2632 ZEND_BEGIN_ARG_INFO(arginfo_simplexmlelement__void, 0)
2633 ZEND_END_ARG_INFO()
2634 
2635 ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_addchild, 0, 0, 1)
2636 	ZEND_ARG_INFO(0, name)
2637 	ZEND_ARG_INFO(0, value)
2638 	ZEND_ARG_INFO(0, ns)
2639 ZEND_END_ARG_INFO()
2640 /* }}} */
2641 
2642 static const zend_function_entry simplexml_functions[] = { /* {{{ */
2643 	PHP_FE(simplexml_load_file, 	arginfo_simplexml_load_file)
2644 	PHP_FE(simplexml_load_string,	arginfo_simplexml_load_string)
2645 	PHP_FE(simplexml_import_dom,	arginfo_simplexml_import_dom)
2646 	PHP_FE_END
2647 };
2648 /* }}} */
2649 
2650 static const zend_module_dep simplexml_deps[] = { /* {{{ */
2651 	ZEND_MOD_REQUIRED("libxml")
2652 	ZEND_MOD_REQUIRED("spl")
2653 	ZEND_MOD_END
2654 };
2655 /* }}} */
2656 
2657 zend_module_entry simplexml_module_entry = { /* {{{ */
2658 	STANDARD_MODULE_HEADER_EX, NULL,
2659 	simplexml_deps,
2660 	"SimpleXML",
2661 	simplexml_functions,
2662 	PHP_MINIT(simplexml),
2663 	PHP_MSHUTDOWN(simplexml),
2664 	NULL,
2665 	NULL,
2666 	PHP_MINFO(simplexml),
2667 	PHP_SIMPLEXML_VERSION,
2668 	STANDARD_MODULE_PROPERTIES
2669 };
2670 /* }}} */
2671 
2672 #ifdef COMPILE_DL_SIMPLEXML
2673 ZEND_GET_MODULE(simplexml)
2674 #endif
2675 
2676 /* the method table */
2677 /* each method can have its own parameters and visibility */
2678 static const zend_function_entry sxe_functions[] = { /* {{{ */
2679 	SXE_ME(__construct,            arginfo_simplexmlelement__construct, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) /* must be called */
2680 	SXE_ME(asXML,                  arginfo_simplexmlelement_asxml, ZEND_ACC_PUBLIC)
2681 	SXE_MALIAS(saveXML, asXML,	   arginfo_simplexmlelement_asxml, ZEND_ACC_PUBLIC)
2682 	SXE_ME(xpath,                  arginfo_simplexmlelement_xpath, ZEND_ACC_PUBLIC)
2683 	SXE_ME(registerXPathNamespace, arginfo_simplexmlelement_registerxpathnamespace, ZEND_ACC_PUBLIC)
2684 	SXE_ME(attributes,             arginfo_simplexmlelement_children, ZEND_ACC_PUBLIC)
2685 	SXE_ME(children,               arginfo_simplexmlelement_children, ZEND_ACC_PUBLIC)
2686 	SXE_ME(getNamespaces,          arginfo_simplexmlelement_getnamespaces, ZEND_ACC_PUBLIC)
2687 	SXE_ME(getDocNamespaces,       arginfo_simplexmlelement_getdocnamespaces, ZEND_ACC_PUBLIC)
2688 	SXE_ME(getName,                arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
2689 	SXE_ME(addChild,               arginfo_simplexmlelement_addchild, ZEND_ACC_PUBLIC)
2690 	SXE_ME(addAttribute,           arginfo_simplexmlelement_addchild, ZEND_ACC_PUBLIC)
2691 	SXE_ME(__toString,             arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
2692 	SXE_ME(count,                  arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
2693 	PHP_FE_END
2694 };
2695 /* }}} */
2696 
2697 /* {{{ PHP_MINIT_FUNCTION(simplexml)
2698  */
PHP_MINIT_FUNCTIONnull2699 PHP_MINIT_FUNCTION(simplexml)
2700 {
2701 	zend_class_entry sxe;
2702 
2703 	INIT_CLASS_ENTRY(sxe, "SimpleXMLElement", sxe_functions);
2704 	sxe.create_object = sxe_object_new;
2705 	sxe_class_entry = zend_register_internal_class(&sxe);
2706 	sxe_class_entry->get_iterator = php_sxe_get_iterator;
2707 	zend_class_implements(sxe_class_entry, 2, zend_ce_traversable, zend_ce_countable);
2708 
2709 	memcpy(&sxe_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
2710 	sxe_object_handlers.offset = XtOffsetOf(php_sxe_object, zo);
2711 	sxe_object_handlers.dtor_obj = sxe_object_dtor;
2712 	sxe_object_handlers.free_obj = sxe_object_free_storage;
2713 	sxe_object_handlers.clone_obj = sxe_object_clone;
2714 	sxe_object_handlers.read_property = sxe_property_read;
2715 	sxe_object_handlers.write_property = sxe_property_write;
2716 	sxe_object_handlers.read_dimension = sxe_dimension_read;
2717 	sxe_object_handlers.write_dimension = sxe_dimension_write;
2718 	sxe_object_handlers.get_property_ptr_ptr = sxe_property_get_adr;
2719 	sxe_object_handlers.get = sxe_get_value;
2720 	sxe_object_handlers.has_property = sxe_property_exists;
2721 	sxe_object_handlers.unset_property = sxe_property_delete;
2722 	sxe_object_handlers.has_dimension = sxe_dimension_exists;
2723 	sxe_object_handlers.unset_dimension = sxe_dimension_delete;
2724 	sxe_object_handlers.get_properties = sxe_get_properties;
2725 	sxe_object_handlers.compare_objects = sxe_objects_compare;
2726 	sxe_object_handlers.cast_object = sxe_object_cast;
2727 	sxe_object_handlers.count_elements = sxe_count_elements;
2728 	sxe_object_handlers.get_debug_info = sxe_get_debug_info;
2729 	sxe_object_handlers.get_closure = NULL;
2730 	sxe_object_handlers.get_gc = sxe_get_gc;
2731 
2732 	sxe_class_entry->serialize = zend_class_serialize_deny;
2733 	sxe_class_entry->unserialize = zend_class_unserialize_deny;
2734 
2735 	php_libxml_register_export(sxe_class_entry, simplexml_export_node);
2736 
2737 	PHP_MINIT(sxe)(INIT_FUNC_ARGS_PASSTHRU);
2738 
2739 	return SUCCESS;
2740 }
2741 /* }}} */
2742 
2743 /* {{{ PHP_MSHUTDOWN_FUNCTION(simplexml)
2744  */
PHP_MSHUTDOWN_FUNCTIONnull2745 PHP_MSHUTDOWN_FUNCTION(simplexml)
2746 {
2747 	sxe_class_entry = NULL;
2748 	return SUCCESS;
2749 }
2750 /* }}} */
2751 
2752 /* {{{ PHP_MINFO_FUNCTION(simplexml)
2753  */
PHP_MINFO_FUNCTIONnull2754 PHP_MINFO_FUNCTION(simplexml)
2755 {
2756 	php_info_print_table_start();
2757 	php_info_print_table_row(2, "SimpleXML support", "enabled");
2758 	php_info_print_table_row(2, "Schema support",
2759 #ifdef LIBXML_SCHEMAS_ENABLED
2760 		"enabled");
2761 #else
2762 		"not available");
2763 #endif
2764 	php_info_print_table_end();
2765 }
2766 /* }}} */
2767 
2768 #endif
2769