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