1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2016 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: Stig Sæther Bakken <ssb@php.net> |
16 | Thies C. Arntzen <thies@thieso.net> |
17 | Sterling Hughes <sterling@php.net> |
18 +----------------------------------------------------------------------+
19 */
20
21 /* $Id$ */
22
23 #define IS_EXT_MODULE
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include "php.h"
30
31 #define PHP_XML_INTERNAL
32 #include "zend_variables.h"
33 #include "ext/standard/php_string.h"
34 #include "ext/standard/info.h"
35 #include "ext/standard/html.h"
36
37 #if HAVE_XML
38
39 #include "php_xml.h"
40 # include "ext/standard/head.h"
41 #ifdef LIBXML_EXPAT_COMPAT
42 #include "ext/libxml/php_libxml.h"
43 #endif
44
45 /* Short-term TODO list:
46 * - Implement XML_ExternalEntityParserCreate()
47 * - XML_SetCommentHandler
48 * - XML_SetCdataSectionHandler
49 * - XML_SetParamEntityParsing
50 */
51
52 /* Long-term TODO list:
53 * - Fix the expat library so you can install your own memory manager
54 * functions
55 */
56
57 /* Known bugs:
58 * - Weird things happen with <![CDATA[]]> sections.
59 */
60
61 ZEND_DECLARE_MODULE_GLOBALS(xml)
62
63 /* {{{ dynamically loadable module stuff */
64 #ifdef COMPILE_DL_XML
65 ZEND_GET_MODULE(xml)
66 #endif /* COMPILE_DL_XML */
67 /* }}} */
68
69
70 #define SKIP_TAGSTART(str) ((str) + (parser->toffset > strlen(str) ? strlen(str) : parser->toffset))
71
72
73 /* {{{ function prototypes */
74 PHP_MINIT_FUNCTION(xml);
75 PHP_MINFO_FUNCTION(xml);
76 static PHP_GINIT_FUNCTION(xml);
77
78 static void xml_parser_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC);
79 static void xml_set_handler(zval **, zval **);
80 inline static unsigned short xml_encode_iso_8859_1(unsigned char);
81 inline static char xml_decode_iso_8859_1(unsigned short);
82 inline static unsigned short xml_encode_us_ascii(unsigned char);
83 inline static char xml_decode_us_ascii(unsigned short);
84 static zval *xml_call_handler(xml_parser *, zval *, zend_function *, int, zval **);
85 static zval *_xml_xmlchar_zval(const XML_Char *, int, const XML_Char *);
86 static int _xml_xmlcharlen(const XML_Char *);
87 static void _xml_add_to_info(xml_parser *parser,char *name);
88 inline static char *_xml_decode_tag(xml_parser *parser, const char *tag);
89
90 void _xml_startElementHandler(void *, const XML_Char *, const XML_Char **);
91 void _xml_endElementHandler(void *, const XML_Char *);
92 void _xml_characterDataHandler(void *, const XML_Char *, int);
93 void _xml_processingInstructionHandler(void *, const XML_Char *, const XML_Char *);
94 void _xml_defaultHandler(void *, const XML_Char *, int);
95 void _xml_unparsedEntityDeclHandler(void *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
96 void _xml_notationDeclHandler(void *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
97 int _xml_externalEntityRefHandler(XML_Parser, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
98
99 void _xml_startNamespaceDeclHandler(void *, const XML_Char *, const XML_Char *);
100 void _xml_endNamespaceDeclHandler(void *, const XML_Char *);
101 /* }}} */
102
103 /* {{{ extension definition structures */
104 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_create, 0, 0, 0)
105 ZEND_ARG_INFO(0, encoding)
106 ZEND_END_ARG_INFO()
107
108 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_create_ns, 0, 0, 0)
109 ZEND_ARG_INFO(0, encoding)
110 ZEND_ARG_INFO(0, sep)
111 ZEND_END_ARG_INFO()
112
113 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_object, 0, 0, 2)
114 ZEND_ARG_INFO(0, parser)
115 ZEND_ARG_INFO(1, obj)
116 ZEND_END_ARG_INFO()
117
118 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_element_handler, 0, 0, 3)
119 ZEND_ARG_INFO(0, parser)
120 ZEND_ARG_INFO(0, shdl)
121 ZEND_ARG_INFO(0, ehdl)
122 ZEND_END_ARG_INFO()
123
124 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_character_data_handler, 0, 0, 2)
125 ZEND_ARG_INFO(0, parser)
126 ZEND_ARG_INFO(0, hdl)
127 ZEND_END_ARG_INFO()
128
129 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_processing_instruction_handler, 0, 0, 2)
130 ZEND_ARG_INFO(0, parser)
131 ZEND_ARG_INFO(0, hdl)
132 ZEND_END_ARG_INFO()
133
134 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_default_handler, 0, 0, 2)
135 ZEND_ARG_INFO(0, parser)
136 ZEND_ARG_INFO(0, hdl)
137 ZEND_END_ARG_INFO()
138
139 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_unparsed_entity_decl_handler, 0, 0, 2)
140 ZEND_ARG_INFO(0, parser)
141 ZEND_ARG_INFO(0, hdl)
142 ZEND_END_ARG_INFO()
143
144 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_notation_decl_handler, 0, 0, 2)
145 ZEND_ARG_INFO(0, parser)
146 ZEND_ARG_INFO(0, hdl)
147 ZEND_END_ARG_INFO()
148
149 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_external_entity_ref_handler, 0, 0, 2)
150 ZEND_ARG_INFO(0, parser)
151 ZEND_ARG_INFO(0, hdl)
152 ZEND_END_ARG_INFO()
153
154 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_start_namespace_decl_handler, 0, 0, 2)
155 ZEND_ARG_INFO(0, parser)
156 ZEND_ARG_INFO(0, hdl)
157 ZEND_END_ARG_INFO()
158
159 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_end_namespace_decl_handler, 0, 0, 2)
160 ZEND_ARG_INFO(0, parser)
161 ZEND_ARG_INFO(0, hdl)
162 ZEND_END_ARG_INFO()
163
164 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parse, 0, 0, 2)
165 ZEND_ARG_INFO(0, parser)
166 ZEND_ARG_INFO(0, data)
167 ZEND_ARG_INFO(0, isfinal)
168 ZEND_END_ARG_INFO()
169
170 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parse_into_struct, 0, 0, 3)
171 ZEND_ARG_INFO(0, parser)
172 ZEND_ARG_INFO(0, data)
173 ZEND_ARG_INFO(1, values)
174 ZEND_ARG_INFO(1, index)
175 ZEND_END_ARG_INFO()
176
177 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_get_error_code, 0, 0, 1)
178 ZEND_ARG_INFO(0, parser)
179 ZEND_END_ARG_INFO()
180
181 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_error_string, 0, 0, 1)
182 ZEND_ARG_INFO(0, code)
183 ZEND_END_ARG_INFO()
184
185 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_get_current_line_number, 0, 0, 1)
186 ZEND_ARG_INFO(0, parser)
187 ZEND_END_ARG_INFO()
188
189 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_get_current_column_number, 0, 0, 1)
190 ZEND_ARG_INFO(0, parser)
191 ZEND_END_ARG_INFO()
192
193 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_get_current_byte_index, 0, 0, 1)
194 ZEND_ARG_INFO(0, parser)
195 ZEND_END_ARG_INFO()
196
197 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_free, 0, 0, 1)
198 ZEND_ARG_INFO(0, parser)
199 ZEND_END_ARG_INFO()
200
201 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_set_option, 0, 0, 3)
202 ZEND_ARG_INFO(0, parser)
203 ZEND_ARG_INFO(0, option)
204 ZEND_ARG_INFO(0, value)
205 ZEND_END_ARG_INFO()
206
207 ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_get_option, 0, 0, 2)
208 ZEND_ARG_INFO(0, parser)
209 ZEND_ARG_INFO(0, option)
210 ZEND_END_ARG_INFO()
211
212 ZEND_BEGIN_ARG_INFO_EX(arginfo_utf8_encode, 0, 0, 1)
213 ZEND_ARG_INFO(0, data)
214 ZEND_END_ARG_INFO()
215
216 ZEND_BEGIN_ARG_INFO_EX(arginfo_utf8_decode, 0, 0, 1)
217 ZEND_ARG_INFO(0, data)
218 ZEND_END_ARG_INFO()
219
220 const zend_function_entry xml_functions[] = {
221 PHP_FE(xml_parser_create, arginfo_xml_parser_create)
222 PHP_FE(xml_parser_create_ns, arginfo_xml_parser_create_ns)
223 PHP_FE(xml_set_object, arginfo_xml_set_object)
224 PHP_FE(xml_set_element_handler, arginfo_xml_set_element_handler)
225 PHP_FE(xml_set_character_data_handler, arginfo_xml_set_character_data_handler)
226 PHP_FE(xml_set_processing_instruction_handler, arginfo_xml_set_processing_instruction_handler)
227 PHP_FE(xml_set_default_handler, arginfo_xml_set_default_handler)
228 PHP_FE(xml_set_unparsed_entity_decl_handler,arginfo_xml_set_unparsed_entity_decl_handler)
229 PHP_FE(xml_set_notation_decl_handler, arginfo_xml_set_notation_decl_handler)
230 PHP_FE(xml_set_external_entity_ref_handler, arginfo_xml_set_external_entity_ref_handler)
231 PHP_FE(xml_set_start_namespace_decl_handler,arginfo_xml_set_start_namespace_decl_handler)
232 PHP_FE(xml_set_end_namespace_decl_handler, arginfo_xml_set_end_namespace_decl_handler)
233 PHP_FE(xml_parse, arginfo_xml_parse)
234 PHP_FE(xml_parse_into_struct, arginfo_xml_parse_into_struct)
235 PHP_FE(xml_get_error_code, arginfo_xml_get_error_code)
236 PHP_FE(xml_error_string, arginfo_xml_error_string)
237 PHP_FE(xml_get_current_line_number, arginfo_xml_get_current_line_number)
238 PHP_FE(xml_get_current_column_number, arginfo_xml_get_current_column_number)
239 PHP_FE(xml_get_current_byte_index, arginfo_xml_get_current_byte_index)
240 PHP_FE(xml_parser_free, arginfo_xml_parser_free)
241 PHP_FE(xml_parser_set_option, arginfo_xml_parser_set_option)
242 PHP_FE(xml_parser_get_option, arginfo_xml_parser_get_option)
243 PHP_FE(utf8_encode, arginfo_utf8_encode)
244 PHP_FE(utf8_decode, arginfo_utf8_decode)
245 PHP_FE_END
246 };
247
248 #ifdef LIBXML_EXPAT_COMPAT
249 static const zend_module_dep xml_deps[] = {
250 ZEND_MOD_REQUIRED("libxml")
251 ZEND_MOD_END
252 };
253 #endif
254
255 zend_module_entry xml_module_entry = {
256 #ifdef LIBXML_EXPAT_COMPAT
257 STANDARD_MODULE_HEADER_EX, NULL,
258 xml_deps,
259 #else
260 STANDARD_MODULE_HEADER,
261 #endif
262 "xml", /* extension name */
263 xml_functions, /* extension function list */
264 PHP_MINIT(xml), /* extension-wide startup function */
265 NULL, /* extension-wide shutdown function */
266 NULL, /* per-request startup function */
267 NULL, /* per-request shutdown function */
268 PHP_MINFO(xml), /* information function */
269 NO_VERSION_YET,
270 PHP_MODULE_GLOBALS(xml), /* globals descriptor */
271 PHP_GINIT(xml), /* globals ctor */
272 NULL, /* globals dtor */
273 NULL, /* post deactivate */
274 STANDARD_MODULE_PROPERTIES_EX
275 };
276
277 /* All the encoding functions are set to NULL right now, since all
278 * the encoding is currently done internally by expat/xmltok.
279 */
280 xml_encoding xml_encodings[] = {
281 { (XML_Char *)"ISO-8859-1", xml_decode_iso_8859_1, xml_encode_iso_8859_1 },
282 { (XML_Char *)"US-ASCII", xml_decode_us_ascii, xml_encode_us_ascii },
283 { (XML_Char *)"UTF-8", NULL, NULL },
284 { (XML_Char *)NULL, NULL, NULL }
285 };
286
287 static XML_Memory_Handling_Suite php_xml_mem_hdlrs;
288
289 /* True globals, no need for thread safety */
290 static int le_xml_parser;
291
292 /* }}} */
293
294 /* {{{ startup, shutdown and info functions */
PHP_GINIT_FUNCTION(xml)295 static PHP_GINIT_FUNCTION(xml)
296 {
297 xml_globals->default_encoding = "UTF-8";
298 }
299
php_xml_malloc_wrapper(size_t sz)300 static void *php_xml_malloc_wrapper(size_t sz)
301 {
302 return emalloc(sz);
303 }
304
php_xml_realloc_wrapper(void * ptr,size_t sz)305 static void *php_xml_realloc_wrapper(void *ptr, size_t sz)
306 {
307 return erealloc(ptr, sz);
308 }
309
php_xml_free_wrapper(void * ptr)310 static void php_xml_free_wrapper(void *ptr)
311 {
312 if (ptr != NULL) {
313 efree(ptr);
314 }
315 }
316
PHP_MINIT_FUNCTION(xml)317 PHP_MINIT_FUNCTION(xml)
318 {
319 le_xml_parser = zend_register_list_destructors_ex(xml_parser_dtor, NULL, "xml", module_number);
320
321 REGISTER_LONG_CONSTANT("XML_ERROR_NONE", XML_ERROR_NONE, CONST_CS|CONST_PERSISTENT);
322 REGISTER_LONG_CONSTANT("XML_ERROR_NO_MEMORY", XML_ERROR_NO_MEMORY, CONST_CS|CONST_PERSISTENT);
323 REGISTER_LONG_CONSTANT("XML_ERROR_SYNTAX", XML_ERROR_SYNTAX, CONST_CS|CONST_PERSISTENT);
324 REGISTER_LONG_CONSTANT("XML_ERROR_NO_ELEMENTS", XML_ERROR_NO_ELEMENTS, CONST_CS|CONST_PERSISTENT);
325 REGISTER_LONG_CONSTANT("XML_ERROR_INVALID_TOKEN", XML_ERROR_INVALID_TOKEN, CONST_CS|CONST_PERSISTENT);
326 REGISTER_LONG_CONSTANT("XML_ERROR_UNCLOSED_TOKEN", XML_ERROR_UNCLOSED_TOKEN, CONST_CS|CONST_PERSISTENT);
327 REGISTER_LONG_CONSTANT("XML_ERROR_PARTIAL_CHAR", XML_ERROR_PARTIAL_CHAR, CONST_CS|CONST_PERSISTENT);
328 REGISTER_LONG_CONSTANT("XML_ERROR_TAG_MISMATCH", XML_ERROR_TAG_MISMATCH, CONST_CS|CONST_PERSISTENT);
329 REGISTER_LONG_CONSTANT("XML_ERROR_DUPLICATE_ATTRIBUTE", XML_ERROR_DUPLICATE_ATTRIBUTE, CONST_CS|CONST_PERSISTENT);
330 REGISTER_LONG_CONSTANT("XML_ERROR_JUNK_AFTER_DOC_ELEMENT", XML_ERROR_JUNK_AFTER_DOC_ELEMENT, CONST_CS|CONST_PERSISTENT);
331 REGISTER_LONG_CONSTANT("XML_ERROR_PARAM_ENTITY_REF", XML_ERROR_PARAM_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
332 REGISTER_LONG_CONSTANT("XML_ERROR_UNDEFINED_ENTITY", XML_ERROR_UNDEFINED_ENTITY, CONST_CS|CONST_PERSISTENT);
333 REGISTER_LONG_CONSTANT("XML_ERROR_RECURSIVE_ENTITY_REF", XML_ERROR_RECURSIVE_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
334 REGISTER_LONG_CONSTANT("XML_ERROR_ASYNC_ENTITY", XML_ERROR_ASYNC_ENTITY, CONST_CS|CONST_PERSISTENT);
335 REGISTER_LONG_CONSTANT("XML_ERROR_BAD_CHAR_REF", XML_ERROR_BAD_CHAR_REF, CONST_CS|CONST_PERSISTENT);
336 REGISTER_LONG_CONSTANT("XML_ERROR_BINARY_ENTITY_REF", XML_ERROR_BINARY_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
337 REGISTER_LONG_CONSTANT("XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF", XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
338 REGISTER_LONG_CONSTANT("XML_ERROR_MISPLACED_XML_PI", XML_ERROR_MISPLACED_XML_PI, CONST_CS|CONST_PERSISTENT);
339 REGISTER_LONG_CONSTANT("XML_ERROR_UNKNOWN_ENCODING", XML_ERROR_UNKNOWN_ENCODING, CONST_CS|CONST_PERSISTENT);
340 REGISTER_LONG_CONSTANT("XML_ERROR_INCORRECT_ENCODING", XML_ERROR_INCORRECT_ENCODING, CONST_CS|CONST_PERSISTENT);
341 REGISTER_LONG_CONSTANT("XML_ERROR_UNCLOSED_CDATA_SECTION", XML_ERROR_UNCLOSED_CDATA_SECTION, CONST_CS|CONST_PERSISTENT);
342 REGISTER_LONG_CONSTANT("XML_ERROR_EXTERNAL_ENTITY_HANDLING", XML_ERROR_EXTERNAL_ENTITY_HANDLING, CONST_CS|CONST_PERSISTENT);
343
344 REGISTER_LONG_CONSTANT("XML_OPTION_CASE_FOLDING", PHP_XML_OPTION_CASE_FOLDING, CONST_CS|CONST_PERSISTENT);
345 REGISTER_LONG_CONSTANT("XML_OPTION_TARGET_ENCODING", PHP_XML_OPTION_TARGET_ENCODING, CONST_CS|CONST_PERSISTENT);
346 REGISTER_LONG_CONSTANT("XML_OPTION_SKIP_TAGSTART", PHP_XML_OPTION_SKIP_TAGSTART, CONST_CS|CONST_PERSISTENT);
347 REGISTER_LONG_CONSTANT("XML_OPTION_SKIP_WHITE", PHP_XML_OPTION_SKIP_WHITE, CONST_CS|CONST_PERSISTENT);
348
349 /* this object should not be pre-initialised at compile time,
350 as the order of members may vary */
351
352 php_xml_mem_hdlrs.malloc_fcn = php_xml_malloc_wrapper;
353 php_xml_mem_hdlrs.realloc_fcn = php_xml_realloc_wrapper;
354 php_xml_mem_hdlrs.free_fcn = php_xml_free_wrapper;
355
356 #ifdef LIBXML_EXPAT_COMPAT
357 REGISTER_STRING_CONSTANT("XML_SAX_IMPL", "libxml", CONST_CS|CONST_PERSISTENT);
358 #else
359 REGISTER_STRING_CONSTANT("XML_SAX_IMPL", "expat", CONST_CS|CONST_PERSISTENT);
360 #endif
361
362 return SUCCESS;
363 }
364
PHP_MINFO_FUNCTION(xml)365 PHP_MINFO_FUNCTION(xml)
366 {
367 php_info_print_table_start();
368 php_info_print_table_row(2, "XML Support", "active");
369 php_info_print_table_row(2, "XML Namespace Support", "active");
370 #if defined(LIBXML_DOTTED_VERSION) && defined(LIBXML_EXPAT_COMPAT)
371 php_info_print_table_row(2, "libxml2 Version", LIBXML_DOTTED_VERSION);
372 #else
373 php_info_print_table_row(2, "EXPAT Version", XML_ExpatVersion());
374 #endif
375 php_info_print_table_end();
376 }
377 /* }}} */
378
379 /* {{{ extension-internal functions */
_xml_resource_zval(long value)380 static zval *_xml_resource_zval(long value)
381 {
382 zval *ret;
383 TSRMLS_FETCH();
384
385 MAKE_STD_ZVAL(ret);
386
387 Z_TYPE_P(ret) = IS_RESOURCE;
388 Z_LVAL_P(ret) = value;
389
390 zend_list_addref(value);
391
392 return ret;
393 }
394
_xml_string_zval(const char * str)395 static zval *_xml_string_zval(const char *str)
396 {
397 zval *ret;
398 int len = strlen(str);
399 MAKE_STD_ZVAL(ret);
400
401 Z_TYPE_P(ret) = IS_STRING;
402 Z_STRLEN_P(ret) = len;
403 Z_STRVAL_P(ret) = estrndup(str, len);
404 return ret;
405 }
406
_xml_xmlchar_zval(const XML_Char * s,int len,const XML_Char * encoding)407 static zval *_xml_xmlchar_zval(const XML_Char *s, int len, const XML_Char *encoding)
408 {
409 zval *ret;
410 MAKE_STD_ZVAL(ret);
411
412 if (s == NULL) {
413 ZVAL_FALSE(ret);
414 return ret;
415 }
416 if (len == 0) {
417 len = _xml_xmlcharlen(s);
418 }
419 Z_TYPE_P(ret) = IS_STRING;
420 Z_STRVAL_P(ret) = xml_utf8_decode(s, len, &Z_STRLEN_P(ret), encoding);
421 return ret;
422 }
423 /* }}} */
424
425 /* {{{ xml_parser_dtor() */
xml_parser_dtor(zend_rsrc_list_entry * rsrc TSRMLS_DC)426 static void xml_parser_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
427 {
428 xml_parser *parser = (xml_parser *)rsrc->ptr;
429
430 if (parser->parser) {
431 XML_ParserFree(parser->parser);
432 }
433 if (parser->ltags) {
434 int inx;
435 for (inx = 0; ((inx < parser->level) && (inx < XML_MAXLEVEL)); inx++)
436 efree(parser->ltags[ inx ]);
437 efree(parser->ltags);
438 }
439 if (parser->startElementHandler) {
440 zval_ptr_dtor(&parser->startElementHandler);
441 }
442 if (parser->endElementHandler) {
443 zval_ptr_dtor(&parser->endElementHandler);
444 }
445 if (parser->characterDataHandler) {
446 zval_ptr_dtor(&parser->characterDataHandler);
447 }
448 if (parser->processingInstructionHandler) {
449 zval_ptr_dtor(&parser->processingInstructionHandler);
450 }
451 if (parser->defaultHandler) {
452 zval_ptr_dtor(&parser->defaultHandler);
453 }
454 if (parser->unparsedEntityDeclHandler) {
455 zval_ptr_dtor(&parser->unparsedEntityDeclHandler);
456 }
457 if (parser->notationDeclHandler) {
458 zval_ptr_dtor(&parser->notationDeclHandler);
459 }
460 if (parser->externalEntityRefHandler) {
461 zval_ptr_dtor(&parser->externalEntityRefHandler);
462 }
463 if (parser->unknownEncodingHandler) {
464 zval_ptr_dtor(&parser->unknownEncodingHandler);
465 }
466 if (parser->startNamespaceDeclHandler) {
467 zval_ptr_dtor(&parser->startNamespaceDeclHandler);
468 }
469 if (parser->endNamespaceDeclHandler) {
470 zval_ptr_dtor(&parser->endNamespaceDeclHandler);
471 }
472 if (parser->baseURI) {
473 efree(parser->baseURI);
474 }
475 if (parser->object) {
476 zval_ptr_dtor(&parser->object);
477 }
478
479 efree(parser);
480 }
481 /* }}} */
482
483 /* {{{ xml_set_handler() */
xml_set_handler(zval ** handler,zval ** data)484 static void xml_set_handler(zval **handler, zval **data)
485 {
486 /* If we have already a handler, release it */
487 if (*handler) {
488 zval_ptr_dtor(handler);
489 }
490
491 /* IS_ARRAY might indicate that we're using array($obj, 'method') syntax */
492 if (Z_TYPE_PP(data) != IS_ARRAY && Z_TYPE_PP(data) != IS_OBJECT) {
493
494 convert_to_string_ex(data);
495 if (Z_STRLEN_PP(data) == 0) {
496 *handler = NULL;
497 return;
498 }
499 }
500
501 zval_add_ref(data);
502
503 *handler = *data;
504 }
505 /* }}} */
506
507 /* {{{ xml_call_handler() */
xml_call_handler(xml_parser * parser,zval * handler,zend_function * function_ptr,int argc,zval ** argv)508 static zval *xml_call_handler(xml_parser *parser, zval *handler, zend_function *function_ptr, int argc, zval **argv)
509 {
510 int i;
511 TSRMLS_FETCH();
512
513 if (parser && handler && !EG(exception)) {
514 zval ***args;
515 zval *retval;
516 int result;
517 zend_fcall_info fci;
518
519 args = safe_emalloc(sizeof(zval **), argc, 0);
520 for (i = 0; i < argc; i++) {
521 args[i] = &argv[i];
522 }
523
524 fci.size = sizeof(fci);
525 fci.function_table = EG(function_table);
526 fci.function_name = handler;
527 fci.symbol_table = NULL;
528 fci.object_ptr = parser->object;
529 fci.retval_ptr_ptr = &retval;
530 fci.param_count = argc;
531 fci.params = args;
532 fci.no_separation = 0;
533 /*fci.function_handler_cache = &function_ptr;*/
534
535 result = zend_call_function(&fci, NULL TSRMLS_CC);
536 if (result == FAILURE) {
537 zval **method;
538 zval **obj;
539
540 if (Z_TYPE_P(handler) == IS_STRING) {
541 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", Z_STRVAL_P(handler));
542 } else if (Z_TYPE_P(handler) == IS_ARRAY &&
543 zend_hash_index_find(Z_ARRVAL_P(handler), 0, (void **) &obj) == SUCCESS &&
544 zend_hash_index_find(Z_ARRVAL_P(handler), 1, (void **) &method) == SUCCESS &&
545 Z_TYPE_PP(obj) == IS_OBJECT &&
546 Z_TYPE_PP(method) == IS_STRING) {
547 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s::%s()", Z_OBJCE_PP(obj)->name, Z_STRVAL_PP(method));
548 } else
549 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler");
550 }
551
552 for (i = 0; i < argc; i++) {
553 zval_ptr_dtor(args[i]);
554 }
555 efree(args);
556
557 if (result == FAILURE) {
558 return NULL;
559 } else {
560 return EG(exception) ? NULL : retval;
561 }
562 } else {
563 for (i = 0; i < argc; i++) {
564 zval_ptr_dtor(&argv[i]);
565 }
566 return NULL;
567 }
568 }
569 /* }}} */
570
571 /* {{{ xml_encode_iso_8859_1() */
xml_encode_iso_8859_1(unsigned char c)572 inline static unsigned short xml_encode_iso_8859_1(unsigned char c)
573 {
574 return (unsigned short)c;
575 }
576 /* }}} */
577
578 /* {{{ xml_decode_iso_8859_1() */
xml_decode_iso_8859_1(unsigned short c)579 inline static char xml_decode_iso_8859_1(unsigned short c)
580 {
581 return (char)(c > 0xff ? '?' : c);
582 }
583 /* }}} */
584
585 /* {{{ xml_encode_us_ascii() */
xml_encode_us_ascii(unsigned char c)586 inline static unsigned short xml_encode_us_ascii(unsigned char c)
587 {
588 return (unsigned short)c;
589 }
590 /* }}} */
591
592 /* {{{ xml_decode_us_ascii() */
xml_decode_us_ascii(unsigned short c)593 inline static char xml_decode_us_ascii(unsigned short c)
594 {
595 return (char)(c > 0x7f ? '?' : c);
596 }
597 /* }}} */
598
599 /* {{{ xml_get_encoding() */
xml_get_encoding(const XML_Char * name)600 static xml_encoding *xml_get_encoding(const XML_Char *name)
601 {
602 xml_encoding *enc = &xml_encodings[0];
603
604 while (enc && enc->name) {
605 if (strcasecmp(name, enc->name) == 0) {
606 return enc;
607 }
608 enc++;
609 }
610 return NULL;
611 }
612 /* }}} */
613
614 /* {{{ xml_utf8_encode */
xml_utf8_encode(const char * s,int len,int * newlen,const XML_Char * encoding)615 PHPAPI char *xml_utf8_encode(const char *s, int len, int *newlen, const XML_Char *encoding)
616 {
617 int pos = len;
618 char *newbuf;
619 unsigned int c;
620 unsigned short (*encoder)(unsigned char) = NULL;
621 xml_encoding *enc = xml_get_encoding(encoding);
622
623 *newlen = 0;
624 if (enc) {
625 encoder = enc->encoding_function;
626 } else {
627 /* If the target encoding was unknown, fail */
628 return NULL;
629 }
630 if (encoder == NULL) {
631 /* If no encoder function was specified, return the data as-is.
632 */
633 newbuf = emalloc(len + 1);
634 memcpy(newbuf, s, len);
635 *newlen = len;
636 newbuf[*newlen] = '\0';
637 return newbuf;
638 }
639 /* This is the theoretical max (will never get beyond len * 2 as long
640 * as we are converting from single-byte characters, though) */
641 newbuf = safe_emalloc_string(len, 4, 1);
642 while (pos > 0) {
643 c = encoder ? encoder((unsigned char)(*s)) : (unsigned short)(*s);
644 if (c < 0x80) {
645 newbuf[(*newlen)++] = (char) c;
646 } else if (c < 0x800) {
647 newbuf[(*newlen)++] = (0xc0 | (c >> 6));
648 newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
649 } else if (c < 0x10000) {
650 newbuf[(*newlen)++] = (0xe0 | (c >> 12));
651 newbuf[(*newlen)++] = (0xc0 | ((c >> 6) & 0x3f));
652 newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
653 } else if (c < 0x200000) {
654 newbuf[(*newlen)++] = (0xf0 | (c >> 18));
655 newbuf[(*newlen)++] = (0xe0 | ((c >> 12) & 0x3f));
656 newbuf[(*newlen)++] = (0xc0 | ((c >> 6) & 0x3f));
657 newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
658 }
659 pos--;
660 s++;
661 }
662 newbuf[*newlen] = 0;
663 newbuf = erealloc(newbuf, (*newlen)+1);
664 return newbuf;
665 }
666 /* }}} */
667
668 /* {{{ xml_utf8_decode */
xml_utf8_decode(const XML_Char * s,int len,int * newlen,const XML_Char * encoding)669 PHPAPI char *xml_utf8_decode(const XML_Char *s, int len, int *newlen, const XML_Char *encoding)
670 {
671 size_t pos = 0;
672 char *newbuf = emalloc(len + 1);
673 unsigned int c;
674 char (*decoder)(unsigned short) = NULL;
675 xml_encoding *enc = xml_get_encoding(encoding);
676
677 *newlen = 0;
678 if (enc) {
679 decoder = enc->decoding_function;
680 }
681 if (decoder == NULL) {
682 /* If the target encoding was unknown, or no decoder function
683 * was specified, return the UTF-8-encoded data as-is.
684 */
685 memcpy(newbuf, s, len);
686 *newlen = len;
687 newbuf[*newlen] = '\0';
688 return newbuf;
689 }
690
691 while (pos < (size_t)len) {
692 int status = FAILURE;
693 c = php_next_utf8_char((const unsigned char*)s, (size_t) len, &pos, &status);
694
695 if (status == FAILURE || c > 0xFFU) {
696 c = '?';
697 }
698
699 newbuf[*newlen] = decoder ? decoder(c) : c;
700 ++*newlen;
701 }
702 if (*newlen < len) {
703 newbuf = erealloc(newbuf, *newlen + 1);
704 }
705 newbuf[*newlen] = '\0';
706 return newbuf;
707 }
708 /* }}} */
709
710 /* {{{ _xml_xmlcharlen() */
_xml_xmlcharlen(const XML_Char * s)711 static int _xml_xmlcharlen(const XML_Char *s)
712 {
713 int len = 0;
714
715 while (*s) {
716 len++;
717 s++;
718 }
719 return len;
720 }
721 /* }}} */
722
723 /* {{{ _xml_zval_strdup() */
_xml_zval_strdup(zval * val)724 PHPAPI char *_xml_zval_strdup(zval *val)
725 {
726 if (Z_TYPE_P(val) == IS_STRING) {
727 char *buf = emalloc(Z_STRLEN_P(val) + 1);
728 memcpy(buf, Z_STRVAL_P(val), Z_STRLEN_P(val));
729 buf[Z_STRLEN_P(val)] = '\0';
730 return buf;
731 }
732 return NULL;
733 }
734 /* }}} */
735
736 /* {{{ _xml_add_to_info */
_xml_add_to_info(xml_parser * parser,char * name)737 static void _xml_add_to_info(xml_parser *parser,char *name)
738 {
739 zval **element, *values;
740
741 if (! parser->info) {
742 return;
743 }
744
745 if (zend_hash_find(Z_ARRVAL_P(parser->info),name,strlen(name) + 1,(void **) &element) == FAILURE) {
746 MAKE_STD_ZVAL(values);
747
748 array_init(values);
749
750 zend_hash_update(Z_ARRVAL_P(parser->info), name, strlen(name)+1, (void *) &values, sizeof(zval*), (void **) &element);
751 }
752
753 add_next_index_long(*element,parser->curtag);
754
755 parser->curtag++;
756 }
757 /* }}} */
758
759 /* {{{ _xml_decode_tag() */
_xml_decode_tag(xml_parser * parser,const char * tag)760 static char *_xml_decode_tag(xml_parser *parser, const char *tag)
761 {
762 char *newstr;
763 int out_len;
764
765 newstr = xml_utf8_decode(tag, strlen(tag), &out_len, parser->target_encoding);
766
767 if (parser->case_folding) {
768 php_strtoupper(newstr, out_len);
769 }
770
771 return newstr;
772 }
773 /* }}} */
774
775 /* {{{ _xml_startElementHandler() */
_xml_startElementHandler(void * userData,const XML_Char * name,const XML_Char ** attributes)776 void _xml_startElementHandler(void *userData, const XML_Char *name, const XML_Char **attributes)
777 {
778 xml_parser *parser = (xml_parser *)userData;
779 const char **attrs = (const char **) attributes;
780 char *tag_name;
781 char *att, *val;
782 int val_len;
783 zval *retval, *args[3];
784
785 if (parser) {
786 parser->level++;
787
788 tag_name = _xml_decode_tag(parser, name);
789
790 if (parser->startElementHandler) {
791 args[0] = _xml_resource_zval(parser->index);
792 args[1] = _xml_string_zval(SKIP_TAGSTART((char *) tag_name));
793 MAKE_STD_ZVAL(args[2]);
794 array_init(args[2]);
795
796 while (attributes && *attributes) {
797 att = _xml_decode_tag(parser, attributes[0]);
798 val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
799
800 add_assoc_stringl(args[2], att, val, val_len, 0);
801
802 attributes += 2;
803
804 efree(att);
805 }
806
807 if ((retval = xml_call_handler(parser, parser->startElementHandler, parser->startElementPtr, 3, args))) {
808 zval_ptr_dtor(&retval);
809 }
810 }
811
812 if (parser->data) {
813 if (parser->level <= XML_MAXLEVEL) {
814 zval *tag, *atr;
815 int atcnt = 0;
816
817 MAKE_STD_ZVAL(tag);
818 MAKE_STD_ZVAL(atr);
819
820 array_init(tag);
821 array_init(atr);
822
823 _xml_add_to_info(parser,SKIP_TAGSTART((char *) tag_name));
824
825 add_assoc_string(tag,"tag",SKIP_TAGSTART((char *) tag_name),1);
826 add_assoc_string(tag,"type","open",1);
827 add_assoc_long(tag,"level",parser->level);
828
829 parser->ltags[parser->level-1] = estrdup(tag_name);
830 parser->lastwasopen = 1;
831
832 attributes = (const XML_Char **) attrs;
833
834 while (attributes && *attributes) {
835 att = _xml_decode_tag(parser, attributes[0]);
836 val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
837
838 add_assoc_stringl(atr,att,val,val_len,0);
839
840 atcnt++;
841 attributes += 2;
842
843 efree(att);
844 }
845
846 if (atcnt) {
847 zend_hash_add(Z_ARRVAL_P(tag),"attributes",sizeof("attributes"),&atr,sizeof(zval*),NULL);
848 } else {
849 zval_ptr_dtor(&atr);
850 }
851
852 zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),(void *) &parser->ctag);
853 } else if (parser->level == (XML_MAXLEVEL + 1)) {
854 TSRMLS_FETCH();
855 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Maximum depth exceeded - Results truncated");
856 }
857 }
858
859 efree(tag_name);
860 }
861 }
862 /* }}} */
863
864 /* {{{ _xml_endElementHandler() */
_xml_endElementHandler(void * userData,const XML_Char * name)865 void _xml_endElementHandler(void *userData, const XML_Char *name)
866 {
867 xml_parser *parser = (xml_parser *)userData;
868 char *tag_name;
869
870 if (parser) {
871 zval *retval, *args[2];
872
873 tag_name = _xml_decode_tag(parser, name);
874
875 if (parser->endElementHandler) {
876 args[0] = _xml_resource_zval(parser->index);
877 args[1] = _xml_string_zval(SKIP_TAGSTART((char *) tag_name));
878
879 if ((retval = xml_call_handler(parser, parser->endElementHandler, parser->endElementPtr, 2, args))) {
880 zval_ptr_dtor(&retval);
881 }
882 }
883
884 if (parser->data) {
885 zval *tag;
886
887 if (parser->lastwasopen) {
888 add_assoc_string(*(parser->ctag),"type","complete",1);
889 } else {
890 MAKE_STD_ZVAL(tag);
891
892 array_init(tag);
893
894 _xml_add_to_info(parser,SKIP_TAGSTART((char *) tag_name));
895
896 add_assoc_string(tag,"tag",SKIP_TAGSTART((char *) tag_name),1);
897 add_assoc_string(tag,"type","close",1);
898 add_assoc_long(tag,"level",parser->level);
899
900 zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
901 }
902
903 parser->lastwasopen = 0;
904 }
905
906 efree(tag_name);
907
908 if ((parser->ltags) && (parser->level <= XML_MAXLEVEL)) {
909 efree(parser->ltags[parser->level-1]);
910 }
911
912 parser->level--;
913 }
914 }
915 /* }}} */
916
917 /* {{{ _xml_characterDataHandler() */
_xml_characterDataHandler(void * userData,const XML_Char * s,int len)918 void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
919 {
920 xml_parser *parser = (xml_parser *)userData;
921
922 if (parser) {
923 zval *retval, *args[2];
924
925 if (parser->characterDataHandler) {
926 args[0] = _xml_resource_zval(parser->index);
927 args[1] = _xml_xmlchar_zval(s, len, parser->target_encoding);
928 if ((retval = xml_call_handler(parser, parser->characterDataHandler, parser->characterDataPtr, 2, args))) {
929 zval_ptr_dtor(&retval);
930 }
931 }
932
933 if (parser->data) {
934 int i;
935 int doprint = 0;
936
937 char *decoded_value;
938 int decoded_len;
939
940 decoded_value = xml_utf8_decode(s,len,&decoded_len,parser->target_encoding);
941 for (i = 0; i < decoded_len; i++) {
942 switch (decoded_value[i]) {
943 case ' ':
944 case '\t':
945 case '\n':
946 continue;
947 default:
948 doprint = 1;
949 break;
950 }
951 if (doprint) {
952 break;
953 }
954 }
955 if (doprint || (! parser->skipwhite)) {
956 if (parser->lastwasopen) {
957 zval **myval;
958
959 /* check if the current tag already has a value - if yes append to that! */
960 if (zend_hash_find(Z_ARRVAL_PP(parser->ctag),"value",sizeof("value"),(void **) &myval) == SUCCESS) {
961 int newlen = Z_STRLEN_PP(myval) + decoded_len;
962 Z_STRVAL_PP(myval) = erealloc(Z_STRVAL_PP(myval),newlen+1);
963 strncpy(Z_STRVAL_PP(myval) + Z_STRLEN_PP(myval), decoded_value, decoded_len + 1);
964 Z_STRLEN_PP(myval) += decoded_len;
965 efree(decoded_value);
966 } else {
967 add_assoc_string(*(parser->ctag),"value",decoded_value,0);
968 }
969
970 } else {
971 zval *tag;
972 zval **curtag, **mytype, **myval;
973 HashPosition hpos=NULL;
974
975 zend_hash_internal_pointer_end_ex(Z_ARRVAL_P(parser->data), &hpos);
976
977 if (hpos && (zend_hash_get_current_data_ex(Z_ARRVAL_P(parser->data), (void **) &curtag, &hpos) == SUCCESS)) {
978 if (zend_hash_find(Z_ARRVAL_PP(curtag),"type",sizeof("type"),(void **) &mytype) == SUCCESS) {
979 if (!strcmp(Z_STRVAL_PP(mytype), "cdata")) {
980 if (zend_hash_find(Z_ARRVAL_PP(curtag),"value",sizeof("value"),(void **) &myval) == SUCCESS) {
981 int newlen = Z_STRLEN_PP(myval) + decoded_len;
982 Z_STRVAL_PP(myval) = erealloc(Z_STRVAL_PP(myval),newlen+1);
983 strncpy(Z_STRVAL_PP(myval) + Z_STRLEN_PP(myval), decoded_value, decoded_len + 1);
984 Z_STRLEN_PP(myval) += decoded_len;
985 efree(decoded_value);
986 return;
987 }
988 }
989 }
990 }
991
992 if (parser->level <= XML_MAXLEVEL && parser->level > 0) {
993 MAKE_STD_ZVAL(tag);
994
995 array_init(tag);
996
997 _xml_add_to_info(parser,SKIP_TAGSTART(parser->ltags[parser->level-1]));
998
999 add_assoc_string(tag,"tag",SKIP_TAGSTART(parser->ltags[parser->level-1]),1);
1000 add_assoc_string(tag,"value",decoded_value,0);
1001 add_assoc_string(tag,"type","cdata",1);
1002 add_assoc_long(tag,"level",parser->level);
1003
1004 zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
1005 } else if (parser->level == (XML_MAXLEVEL + 1)) {
1006 TSRMLS_FETCH();
1007 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Maximum depth exceeded - Results truncated");
1008 }
1009 }
1010 } else {
1011 efree(decoded_value);
1012 }
1013 }
1014 }
1015 }
1016 /* }}} */
1017
1018 /* {{{ _xml_processingInstructionHandler() */
_xml_processingInstructionHandler(void * userData,const XML_Char * target,const XML_Char * data)1019 void _xml_processingInstructionHandler(void *userData, const XML_Char *target, const XML_Char *data)
1020 {
1021 xml_parser *parser = (xml_parser *)userData;
1022
1023 if (parser && parser->processingInstructionHandler) {
1024 zval *retval, *args[3];
1025
1026 args[0] = _xml_resource_zval(parser->index);
1027 args[1] = _xml_xmlchar_zval(target, 0, parser->target_encoding);
1028 args[2] = _xml_xmlchar_zval(data, 0, parser->target_encoding);
1029 if ((retval = xml_call_handler(parser, parser->processingInstructionHandler, parser->processingInstructionPtr, 3, args))) {
1030 zval_ptr_dtor(&retval);
1031 }
1032 }
1033 }
1034 /* }}} */
1035
1036 /* {{{ _xml_defaultHandler() */
_xml_defaultHandler(void * userData,const XML_Char * s,int len)1037 void _xml_defaultHandler(void *userData, const XML_Char *s, int len)
1038 {
1039 xml_parser *parser = (xml_parser *)userData;
1040
1041 if (parser && parser->defaultHandler) {
1042 zval *retval, *args[2];
1043
1044 args[0] = _xml_resource_zval(parser->index);
1045 args[1] = _xml_xmlchar_zval(s, len, parser->target_encoding);
1046 if ((retval = xml_call_handler(parser, parser->defaultHandler, parser->defaultPtr, 2, args))) {
1047 zval_ptr_dtor(&retval);
1048 }
1049 }
1050 }
1051 /* }}} */
1052
1053 /* {{{ _xml_unparsedEntityDeclHandler() */
_xml_unparsedEntityDeclHandler(void * userData,const XML_Char * entityName,const XML_Char * base,const XML_Char * systemId,const XML_Char * publicId,const XML_Char * notationName)1054 void _xml_unparsedEntityDeclHandler(void *userData,
1055 const XML_Char *entityName,
1056 const XML_Char *base,
1057 const XML_Char *systemId,
1058 const XML_Char *publicId,
1059 const XML_Char *notationName)
1060 {
1061 xml_parser *parser = (xml_parser *)userData;
1062
1063 if (parser && parser->unparsedEntityDeclHandler) {
1064 zval *retval, *args[6];
1065
1066 args[0] = _xml_resource_zval(parser->index);
1067 args[1] = _xml_xmlchar_zval(entityName, 0, parser->target_encoding);
1068 args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
1069 args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
1070 args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
1071 args[5] = _xml_xmlchar_zval(notationName, 0, parser->target_encoding);
1072 if ((retval = xml_call_handler(parser, parser->unparsedEntityDeclHandler, parser->unparsedEntityDeclPtr, 6, args))) {
1073 zval_ptr_dtor(&retval);
1074 }
1075 }
1076 }
1077 /* }}} */
1078
1079 /* {{{ _xml_notationDeclHandler() */
_xml_notationDeclHandler(void * userData,const XML_Char * notationName,const XML_Char * base,const XML_Char * systemId,const XML_Char * publicId)1080 void _xml_notationDeclHandler(void *userData,
1081 const XML_Char *notationName,
1082 const XML_Char *base,
1083 const XML_Char *systemId,
1084 const XML_Char *publicId)
1085 {
1086 xml_parser *parser = (xml_parser *)userData;
1087
1088 if (parser && parser->notationDeclHandler) {
1089 zval *retval, *args[5];
1090
1091 args[0] = _xml_resource_zval(parser->index);
1092 args[1] = _xml_xmlchar_zval(notationName, 0, parser->target_encoding);
1093 args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
1094 args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
1095 args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
1096 if ((retval = xml_call_handler(parser, parser->notationDeclHandler, parser->notationDeclPtr, 5, args))) {
1097 zval_ptr_dtor(&retval);
1098 }
1099 }
1100 }
1101 /* }}} */
1102
1103 /* {{{ _xml_externalEntityRefHandler() */
_xml_externalEntityRefHandler(XML_Parser parserPtr,const XML_Char * openEntityNames,const XML_Char * base,const XML_Char * systemId,const XML_Char * publicId)1104 int _xml_externalEntityRefHandler(XML_Parser parserPtr,
1105 const XML_Char *openEntityNames,
1106 const XML_Char *base,
1107 const XML_Char *systemId,
1108 const XML_Char *publicId)
1109 {
1110 xml_parser *parser = XML_GetUserData(parserPtr);
1111 int ret = 0; /* abort if no handler is set (should be configurable?) */
1112
1113 if (parser && parser->externalEntityRefHandler) {
1114 zval *retval, *args[5];
1115
1116 args[0] = _xml_resource_zval(parser->index);
1117 args[1] = _xml_xmlchar_zval(openEntityNames, 0, parser->target_encoding);
1118 args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
1119 args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
1120 args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
1121 if ((retval = xml_call_handler(parser, parser->externalEntityRefHandler, parser->externalEntityRefPtr, 5, args))) {
1122 convert_to_long(retval);
1123 ret = Z_LVAL_P(retval);
1124 efree(retval);
1125 } else {
1126 ret = 0;
1127 }
1128 }
1129 return ret;
1130 }
1131 /* }}} */
1132
1133 /* {{{ _xml_startNamespaceDeclHandler() */
_xml_startNamespaceDeclHandler(void * userData,const XML_Char * prefix,const XML_Char * uri)1134 void _xml_startNamespaceDeclHandler(void *userData,const XML_Char *prefix, const XML_Char *uri)
1135 {
1136 xml_parser *parser = (xml_parser *)userData;
1137
1138 if (parser && parser->startNamespaceDeclHandler) {
1139 zval *retval, *args[3];
1140
1141 args[0] = _xml_resource_zval(parser->index);
1142 args[1] = _xml_xmlchar_zval(prefix, 0, parser->target_encoding);
1143 args[2] = _xml_xmlchar_zval(uri, 0, parser->target_encoding);
1144 if ((retval = xml_call_handler(parser, parser->startNamespaceDeclHandler, parser->startNamespaceDeclPtr, 3, args))) {
1145 zval_ptr_dtor(&retval);
1146 }
1147 }
1148 }
1149 /* }}} */
1150
1151 /* {{{ _xml_endNamespaceDeclHandler() */
_xml_endNamespaceDeclHandler(void * userData,const XML_Char * prefix)1152 void _xml_endNamespaceDeclHandler(void *userData, const XML_Char *prefix)
1153 {
1154 xml_parser *parser = (xml_parser *)userData;
1155
1156 if (parser && parser->endNamespaceDeclHandler) {
1157 zval *retval, *args[2];
1158
1159 args[0] = _xml_resource_zval(parser->index);
1160 args[1] = _xml_xmlchar_zval(prefix, 0, parser->target_encoding);
1161 if ((retval = xml_call_handler(parser, parser->endNamespaceDeclHandler, parser->endNamespaceDeclPtr, 2, args))) {
1162 zval_ptr_dtor(&retval);
1163 }
1164 }
1165 }
1166 /* }}} */
1167
1168 /************************* EXTENSION FUNCTIONS *************************/
1169
php_xml_parser_create_impl(INTERNAL_FUNCTION_PARAMETERS,int ns_support)1170 static void php_xml_parser_create_impl(INTERNAL_FUNCTION_PARAMETERS, int ns_support) /* {{{ */
1171 {
1172 xml_parser *parser;
1173 int auto_detect = 0;
1174
1175 char *encoding_param = NULL;
1176 int encoding_param_len = 0;
1177
1178 char *ns_param = NULL;
1179 int ns_param_len = 0;
1180
1181 XML_Char *encoding;
1182
1183 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, (ns_support ? "|ss": "|s"), &encoding_param, &encoding_param_len, &ns_param, &ns_param_len) == FAILURE) {
1184 RETURN_FALSE;
1185 }
1186
1187 if (encoding_param != NULL) {
1188 /* The supported encoding types are hardcoded here because
1189 * we are limited to the encodings supported by expat/xmltok.
1190 */
1191 if (encoding_param_len == 0) {
1192 encoding = XML(default_encoding);
1193 auto_detect = 1;
1194 } else if (strcasecmp(encoding_param, "ISO-8859-1") == 0) {
1195 encoding = "ISO-8859-1";
1196 } else if (strcasecmp(encoding_param, "UTF-8") == 0) {
1197 encoding = "UTF-8";
1198 } else if (strcasecmp(encoding_param, "US-ASCII") == 0) {
1199 encoding = "US-ASCII";
1200 } else {
1201 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unsupported source encoding \"%s\"", encoding_param);
1202 RETURN_FALSE;
1203 }
1204 } else {
1205 encoding = XML(default_encoding);
1206 }
1207
1208 if (ns_support && ns_param == NULL){
1209 ns_param = ":";
1210 }
1211
1212 parser = ecalloc(1, sizeof(xml_parser));
1213 parser->parser = XML_ParserCreate_MM((auto_detect ? NULL : encoding),
1214 &php_xml_mem_hdlrs, ns_param);
1215
1216 parser->target_encoding = encoding;
1217 parser->case_folding = 1;
1218 parser->object = NULL;
1219 parser->isparsing = 0;
1220
1221 XML_SetUserData(parser->parser, parser);
1222
1223 ZEND_REGISTER_RESOURCE(return_value, parser,le_xml_parser);
1224 parser->index = Z_LVAL_P(return_value);
1225 }
1226 /* }}} */
1227
1228 /* {{{ proto resource xml_parser_create([string encoding])
1229 Create an XML parser */
PHP_FUNCTION(xml_parser_create)1230 PHP_FUNCTION(xml_parser_create)
1231 {
1232 php_xml_parser_create_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1233 }
1234 /* }}} */
1235
1236 /* {{{ proto resource xml_parser_create_ns([string encoding [, string sep]])
1237 Create an XML parser */
PHP_FUNCTION(xml_parser_create_ns)1238 PHP_FUNCTION(xml_parser_create_ns)
1239 {
1240 php_xml_parser_create_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
1241 }
1242 /* }}} */
1243
1244 /* {{{ proto int xml_set_object(resource parser, object &obj)
1245 Set up object which should be used for callbacks */
PHP_FUNCTION(xml_set_object)1246 PHP_FUNCTION(xml_set_object)
1247 {
1248 xml_parser *parser;
1249 zval *pind, *mythis;
1250
1251 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ro", &pind, &mythis) == FAILURE) {
1252 return;
1253 }
1254
1255 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1256
1257 /* please leave this commented - or ask thies@thieso.net before doing it (again) */
1258 if (parser->object) {
1259 zval_ptr_dtor(&parser->object);
1260 }
1261
1262 /* please leave this commented - or ask thies@thieso.net before doing it (again) */
1263 /* #ifdef ZEND_ENGINE_2
1264 zval_add_ref(&parser->object);
1265 #endif */
1266
1267 ALLOC_ZVAL(parser->object);
1268 MAKE_COPY_ZVAL(&mythis, parser->object);
1269
1270 RETVAL_TRUE;
1271 }
1272 /* }}} */
1273
1274 /* {{{ proto int xml_set_element_handler(resource parser, string shdl, string ehdl)
1275 Set up start and end element handlers */
PHP_FUNCTION(xml_set_element_handler)1276 PHP_FUNCTION(xml_set_element_handler)
1277 {
1278 xml_parser *parser;
1279 zval *pind, **shdl, **ehdl;
1280
1281 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZZ", &pind, &shdl, &ehdl) == FAILURE) {
1282 return;
1283 }
1284
1285 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1286
1287 xml_set_handler(&parser->startElementHandler, shdl);
1288 xml_set_handler(&parser->endElementHandler, ehdl);
1289 XML_SetElementHandler(parser->parser, _xml_startElementHandler, _xml_endElementHandler);
1290 RETVAL_TRUE;
1291 }
1292 /* }}} */
1293
1294 /* {{{ proto int xml_set_character_data_handler(resource parser, string hdl)
1295 Set up character data handler */
PHP_FUNCTION(xml_set_character_data_handler)1296 PHP_FUNCTION(xml_set_character_data_handler)
1297 {
1298 xml_parser *parser;
1299 zval *pind, **hdl;
1300
1301 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1302 return;
1303 }
1304
1305 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1306
1307 xml_set_handler(&parser->characterDataHandler, hdl);
1308 XML_SetCharacterDataHandler(parser->parser, _xml_characterDataHandler);
1309 RETVAL_TRUE;
1310 }
1311 /* }}} */
1312
1313 /* {{{ proto int xml_set_processing_instruction_handler(resource parser, string hdl)
1314 Set up processing instruction (PI) handler */
PHP_FUNCTION(xml_set_processing_instruction_handler)1315 PHP_FUNCTION(xml_set_processing_instruction_handler)
1316 {
1317 xml_parser *parser;
1318 zval *pind, **hdl;
1319
1320 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1321 return;
1322 }
1323
1324 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1325
1326 xml_set_handler(&parser->processingInstructionHandler, hdl);
1327 XML_SetProcessingInstructionHandler(parser->parser, _xml_processingInstructionHandler);
1328 RETVAL_TRUE;
1329 }
1330 /* }}} */
1331
1332 /* {{{ proto int xml_set_default_handler(resource parser, string hdl)
1333 Set up default handler */
PHP_FUNCTION(xml_set_default_handler)1334 PHP_FUNCTION(xml_set_default_handler)
1335 {
1336 xml_parser *parser;
1337 zval *pind, **hdl;
1338
1339 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1340 return;
1341 }
1342 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1343
1344 xml_set_handler(&parser->defaultHandler, hdl);
1345 XML_SetDefaultHandler(parser->parser, _xml_defaultHandler);
1346 RETVAL_TRUE;
1347 }
1348 /* }}} */
1349
1350 /* {{{ proto int xml_set_unparsed_entity_decl_handler(resource parser, string hdl)
1351 Set up unparsed entity declaration handler */
PHP_FUNCTION(xml_set_unparsed_entity_decl_handler)1352 PHP_FUNCTION(xml_set_unparsed_entity_decl_handler)
1353 {
1354 xml_parser *parser;
1355 zval *pind, **hdl;
1356
1357 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1358 return;
1359 }
1360
1361 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1362
1363 xml_set_handler(&parser->unparsedEntityDeclHandler, hdl);
1364 XML_SetUnparsedEntityDeclHandler(parser->parser, _xml_unparsedEntityDeclHandler);
1365 RETVAL_TRUE;
1366 }
1367 /* }}} */
1368
1369 /* {{{ proto int xml_set_notation_decl_handler(resource parser, string hdl)
1370 Set up notation declaration handler */
PHP_FUNCTION(xml_set_notation_decl_handler)1371 PHP_FUNCTION(xml_set_notation_decl_handler)
1372 {
1373 xml_parser *parser;
1374 zval *pind, **hdl;
1375
1376 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1377 return;
1378 }
1379 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1380
1381 xml_set_handler(&parser->notationDeclHandler, hdl);
1382 XML_SetNotationDeclHandler(parser->parser, _xml_notationDeclHandler);
1383 RETVAL_TRUE;
1384 }
1385 /* }}} */
1386
1387 /* {{{ proto int xml_set_external_entity_ref_handler(resource parser, string hdl)
1388 Set up external entity reference handler */
PHP_FUNCTION(xml_set_external_entity_ref_handler)1389 PHP_FUNCTION(xml_set_external_entity_ref_handler)
1390 {
1391 xml_parser *parser;
1392 zval *pind, **hdl;
1393
1394 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1395 return;
1396 }
1397 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1398
1399 xml_set_handler(&parser->externalEntityRefHandler, hdl);
1400 XML_SetExternalEntityRefHandler(parser->parser, (void *) _xml_externalEntityRefHandler);
1401 RETVAL_TRUE;
1402 }
1403 /* }}} */
1404
1405 /* {{{ proto int xml_set_start_namespace_decl_handler(resource parser, string hdl)
1406 Set up character data handler */
PHP_FUNCTION(xml_set_start_namespace_decl_handler)1407 PHP_FUNCTION(xml_set_start_namespace_decl_handler)
1408 {
1409 xml_parser *parser;
1410 zval *pind, **hdl;
1411
1412 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1413 return;
1414 }
1415
1416 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1417
1418 xml_set_handler(&parser->startNamespaceDeclHandler, hdl);
1419 XML_SetStartNamespaceDeclHandler(parser->parser, _xml_startNamespaceDeclHandler);
1420 RETVAL_TRUE;
1421 }
1422 /* }}} */
1423
1424 /* {{{ proto int xml_set_end_namespace_decl_handler(resource parser, string hdl)
1425 Set up character data handler */
PHP_FUNCTION(xml_set_end_namespace_decl_handler)1426 PHP_FUNCTION(xml_set_end_namespace_decl_handler)
1427 {
1428 xml_parser *parser;
1429 zval *pind, **hdl;
1430
1431 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1432 return;
1433 }
1434
1435 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1436
1437 xml_set_handler(&parser->endNamespaceDeclHandler, hdl);
1438 XML_SetEndNamespaceDeclHandler(parser->parser, _xml_endNamespaceDeclHandler);
1439 RETVAL_TRUE;
1440 }
1441 /* }}} */
1442
1443 /* {{{ proto int xml_parse(resource parser, string data [, int isFinal])
1444 Start parsing an XML document */
PHP_FUNCTION(xml_parse)1445 PHP_FUNCTION(xml_parse)
1446 {
1447 xml_parser *parser;
1448 zval *pind;
1449 char *data;
1450 int data_len, ret;
1451 long isFinal = 0;
1452
1453 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &pind, &data, &data_len, &isFinal) == FAILURE) {
1454 return;
1455 }
1456 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1457
1458 parser->isparsing = 1;
1459 ret = XML_Parse(parser->parser, data, data_len, isFinal);
1460 parser->isparsing = 0;
1461 RETVAL_LONG(ret);
1462 }
1463
1464 /* }}} */
1465
1466 /* {{{ proto int xml_parse_into_struct(resource parser, string data, array &values [, array &index ])
1467 Parsing a XML document */
1468
PHP_FUNCTION(xml_parse_into_struct)1469 PHP_FUNCTION(xml_parse_into_struct)
1470 {
1471 xml_parser *parser;
1472 zval *pind, **xdata, **info = NULL;
1473 char *data;
1474 int data_len, ret;
1475
1476 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ|Z", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
1477 return;
1478 }
1479
1480 if (info) {
1481 zval_dtor(*info);
1482 array_init(*info);
1483 }
1484
1485 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1486
1487 zval_dtor(*xdata);
1488 array_init(*xdata);
1489
1490 parser->data = *xdata;
1491
1492 if (info) {
1493 parser->info = *info;
1494 }
1495
1496 parser->level = 0;
1497 parser->ltags = safe_emalloc(XML_MAXLEVEL, sizeof(char *), 0);
1498
1499 XML_SetDefaultHandler(parser->parser, _xml_defaultHandler);
1500 XML_SetElementHandler(parser->parser, _xml_startElementHandler, _xml_endElementHandler);
1501 XML_SetCharacterDataHandler(parser->parser, _xml_characterDataHandler);
1502
1503 parser->isparsing = 1;
1504 ret = XML_Parse(parser->parser, data, data_len, 1);
1505 parser->isparsing = 0;
1506
1507 RETVAL_LONG(ret);
1508 }
1509 /* }}} */
1510
1511 /* {{{ proto int xml_get_error_code(resource parser)
1512 Get XML parser error code */
PHP_FUNCTION(xml_get_error_code)1513 PHP_FUNCTION(xml_get_error_code)
1514 {
1515 xml_parser *parser;
1516 zval *pind;
1517
1518 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1519 return;
1520 }
1521 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1522
1523 RETVAL_LONG((long)XML_GetErrorCode(parser->parser));
1524 }
1525 /* }}} */
1526
1527 /* {{{ proto string xml_error_string(int code)
1528 Get XML parser error string */
PHP_FUNCTION(xml_error_string)1529 PHP_FUNCTION(xml_error_string)
1530 {
1531 long code;
1532 char *str;
1533
1534 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code) == FAILURE) {
1535 return;
1536 }
1537
1538 str = (char *)XML_ErrorString((int)code);
1539 if (str) {
1540 RETVAL_STRING(str, 1);
1541 }
1542 }
1543 /* }}} */
1544
1545 /* {{{ proto int xml_get_current_line_number(resource parser)
1546 Get current line number for an XML parser */
PHP_FUNCTION(xml_get_current_line_number)1547 PHP_FUNCTION(xml_get_current_line_number)
1548 {
1549 xml_parser *parser;
1550 zval *pind;
1551
1552 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1553 return;
1554 }
1555 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1556
1557 RETVAL_LONG(XML_GetCurrentLineNumber(parser->parser));
1558 }
1559 /* }}} */
1560
1561 /* {{{ proto int xml_get_current_column_number(resource parser)
1562 Get current column number for an XML parser */
PHP_FUNCTION(xml_get_current_column_number)1563 PHP_FUNCTION(xml_get_current_column_number)
1564 {
1565 xml_parser *parser;
1566 zval *pind;
1567
1568 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1569 return;
1570 }
1571 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1572
1573 RETVAL_LONG(XML_GetCurrentColumnNumber(parser->parser));
1574 }
1575 /* }}} */
1576
1577 /* {{{ proto int xml_get_current_byte_index(resource parser)
1578 Get current byte index for an XML parser */
PHP_FUNCTION(xml_get_current_byte_index)1579 PHP_FUNCTION(xml_get_current_byte_index)
1580 {
1581 xml_parser *parser;
1582 zval *pind;
1583
1584 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1585 return;
1586 }
1587 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1588
1589 RETVAL_LONG(XML_GetCurrentByteIndex(parser->parser));
1590 }
1591 /* }}} */
1592
1593 /* {{{ proto int xml_parser_free(resource parser)
1594 Free an XML parser */
PHP_FUNCTION(xml_parser_free)1595 PHP_FUNCTION(xml_parser_free)
1596 {
1597 zval *pind;
1598 xml_parser *parser;
1599
1600 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1601 return;
1602 }
1603
1604 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1605
1606 if (parser->isparsing == 1) {
1607 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Parser cannot be freed while it is parsing.");
1608 RETURN_FALSE;
1609 }
1610
1611 if (zend_list_delete(parser->index) == FAILURE) {
1612 RETURN_FALSE;
1613 }
1614
1615 RETVAL_TRUE;
1616 }
1617 /* }}} */
1618
1619 /* {{{ proto int xml_parser_set_option(resource parser, int option, mixed value)
1620 Set options in an XML parser */
PHP_FUNCTION(xml_parser_set_option)1621 PHP_FUNCTION(xml_parser_set_option)
1622 {
1623 xml_parser *parser;
1624 zval *pind, **val;
1625 long opt;
1626
1627 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlZ", &pind, &opt, &val) == FAILURE) {
1628 return;
1629 }
1630 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1631
1632 switch (opt) {
1633 case PHP_XML_OPTION_CASE_FOLDING:
1634 convert_to_long_ex(val);
1635 parser->case_folding = Z_LVAL_PP(val);
1636 break;
1637 case PHP_XML_OPTION_SKIP_TAGSTART:
1638 convert_to_long_ex(val);
1639 parser->toffset = Z_LVAL_PP(val);
1640 if (parser->toffset < 0) {
1641 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "tagstart ignored, because it is out of range");
1642 parser->toffset = 0;
1643 }
1644 break;
1645 case PHP_XML_OPTION_SKIP_WHITE:
1646 convert_to_long_ex(val);
1647 parser->skipwhite = Z_LVAL_PP(val);
1648 break;
1649 case PHP_XML_OPTION_TARGET_ENCODING: {
1650 xml_encoding *enc;
1651 convert_to_string_ex(val);
1652 enc = xml_get_encoding(Z_STRVAL_PP(val));
1653 if (enc == NULL) {
1654 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported target encoding \"%s\"", Z_STRVAL_PP(val));
1655 RETURN_FALSE;
1656 }
1657 parser->target_encoding = enc->name;
1658 break;
1659 }
1660 default:
1661 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option");
1662 RETURN_FALSE;
1663 break;
1664 }
1665 RETVAL_TRUE;
1666 }
1667 /* }}} */
1668
1669 /* {{{ proto int xml_parser_get_option(resource parser, int option)
1670 Get options from an XML parser */
PHP_FUNCTION(xml_parser_get_option)1671 PHP_FUNCTION(xml_parser_get_option)
1672 {
1673 xml_parser *parser;
1674 zval *pind;
1675 long opt;
1676
1677 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pind, &opt) == FAILURE) {
1678 return;
1679 }
1680 ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1681
1682 switch (opt) {
1683 case PHP_XML_OPTION_CASE_FOLDING:
1684 RETURN_LONG(parser->case_folding);
1685 break;
1686 case PHP_XML_OPTION_TARGET_ENCODING:
1687 RETURN_STRING(parser->target_encoding, 1);
1688 break;
1689 default:
1690 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option");
1691 RETURN_FALSE;
1692 break;
1693 }
1694
1695 RETVAL_FALSE; /* never reached */
1696 }
1697 /* }}} */
1698
1699 /* {{{ proto string utf8_encode(string data)
1700 Encodes an ISO-8859-1 string to UTF-8 */
PHP_FUNCTION(utf8_encode)1701 PHP_FUNCTION(utf8_encode)
1702 {
1703 char *arg;
1704 XML_Char *encoded;
1705 int arg_len, len;
1706
1707 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
1708 return;
1709 }
1710
1711 encoded = xml_utf8_encode(arg, arg_len, &len, "ISO-8859-1");
1712 if (encoded == NULL) {
1713 RETURN_FALSE;
1714 }
1715 RETVAL_STRINGL(encoded, len, 0);
1716 }
1717 /* }}} */
1718
1719 /* {{{ proto string utf8_decode(string data)
1720 Converts a UTF-8 encoded string to ISO-8859-1 */
PHP_FUNCTION(utf8_decode)1721 PHP_FUNCTION(utf8_decode)
1722 {
1723 char *arg;
1724 XML_Char *decoded;
1725 int arg_len, len;
1726
1727 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
1728 return;
1729 }
1730
1731 decoded = xml_utf8_decode(arg, arg_len, &len, "ISO-8859-1");
1732 if (decoded == NULL) {
1733 RETURN_FALSE;
1734 }
1735 RETVAL_STRINGL(decoded, len, 0);
1736 }
1737 /* }}} */
1738
1739 #endif
1740
1741 /*
1742 * Local variables:
1743 * tab-width: 4
1744 * c-basic-offset: 4
1745 * End:
1746 * vim600: sw=4 ts=4 fdm=marker
1747 * vim<600: sw=4 ts=4
1748 */
1749
