1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 7 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2018 The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Sterling Hughes <sterling@php.net> |
16 +----------------------------------------------------------------------+
17 */
18
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include "php.h"
24 #if defined(HAVE_LIBXML) && (defined(HAVE_XML) || defined(HAVE_XMLRPC)) && !defined(HAVE_LIBEXPAT)
25 #include "expat_compat.h"
26
27 typedef struct _php_xml_ns {
28 xmlNsPtr nsptr;
29 int ref_count;
30 void *next;
31 void *prev;
32 } php_xml_ns;
33
34 #ifdef LIBXML_EXPAT_COMPAT
35
36 #define IS_NS_DECL(__ns) \
37 ((__ns) != NULL && strlen(__ns) == 5 && *(__ns) == 'x' && *((__ns)+1) == 'm' && \
38 *((__ns)+2) == 'l' && *((__ns)+3) == 'n' && *((__ns)+4) == 's')
39
40 static void
_qualify_namespace(XML_Parser parser,const xmlChar * name,const xmlChar * URI,xmlChar ** qualified)41 _qualify_namespace(XML_Parser parser, const xmlChar *name, const xmlChar *URI, xmlChar **qualified)
42 {
43 if (URI) {
44 /* Use libxml functions otherwise its memory deallocation is screwed up */
45 *qualified = xmlStrdup(URI);
46 *qualified = xmlStrncat(*qualified, parser->_ns_separator, 1);
47 *qualified = xmlStrncat(*qualified, name, xmlStrlen(name));
48 } else {
49 *qualified = xmlStrdup(name);
50 }
51 }
52
53 static void
_start_element_handler(void * user,const xmlChar * name,const xmlChar ** attributes)54 _start_element_handler(void *user, const xmlChar *name, const xmlChar **attributes)
55 {
56 XML_Parser parser = (XML_Parser) user;
57 xmlChar *qualified_name = NULL;
58
59 if (parser->h_start_element == NULL) {
60 if (parser->h_default) {
61 int attno = 0;
62
63 qualified_name = xmlStrncatNew((xmlChar *)"<", name, xmlStrlen(name));
64 if (attributes) {
65 while (attributes[attno] != NULL) {
66 int att_len;
67 char *att_string, *att_name, *att_value;
68
69 att_name = (char *)attributes[attno++];
70 att_value = (char *)attributes[attno++];
71
72 att_len = spprintf(&att_string, 0, " %s=\"%s\"", att_name, att_value);
73
74 qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_string, att_len);
75 efree(att_string);
76 }
77
78 }
79 qualified_name = xmlStrncat(qualified_name, (xmlChar *)">", 1);
80 parser->h_default(parser->user, (const XML_Char *) qualified_name, xmlStrlen(qualified_name));
81 xmlFree(qualified_name);
82 }
83 return;
84 }
85
86 qualified_name = xmlStrdup(name);
87
88 parser->h_start_element(parser->user, (const XML_Char *) qualified_name, (const XML_Char **) attributes);
89
90 xmlFree(qualified_name);
91 }
92
93 static void
_start_element_handler_ns(void * user,const xmlChar * name,const xmlChar * prefix,const xmlChar * URI,int nb_namespaces,const xmlChar ** namespaces,int nb_attributes,int nb_defaulted,const xmlChar ** attributes)94 _start_element_handler_ns(void *user, const xmlChar *name, const xmlChar *prefix, const xmlChar *URI, int nb_namespaces, const xmlChar ** namespaces, int nb_attributes, int nb_defaulted, const xmlChar ** attributes)
95 {
96 XML_Parser parser = (XML_Parser) user;
97 xmlChar *qualified_name = NULL;
98 xmlChar **attrs = NULL;
99 int i;
100 int z = 0;
101 int y = 0;
102
103 if (nb_namespaces > 0 && parser->h_start_ns != NULL) {
104 for (i = 0; i < nb_namespaces; i += 1) {
105 parser->h_start_ns(parser->user, (const XML_Char *) namespaces[y], (const XML_Char *) namespaces[y+1]);
106 y += 2;
107 }
108 y = 0;
109 }
110
111 if (parser->h_start_element == NULL) {
112 if (parser->h_default) {
113
114 if (prefix) {
115 qualified_name = xmlStrncatNew((xmlChar *)"<", prefix, xmlStrlen(prefix));
116 qualified_name = xmlStrncat(qualified_name, (xmlChar *)":", 1);
117 qualified_name = xmlStrncat(qualified_name, name, xmlStrlen(name));
118 } else {
119 qualified_name = xmlStrncatNew((xmlChar *)"<", name, xmlStrlen(name));
120 }
121
122 if (namespaces) {
123 int i, j;
124 for (i = 0,j = 0;j < nb_namespaces;j++) {
125 int ns_len;
126 char *ns_string, *ns_prefix, *ns_url;
127
128 ns_prefix = (char *) namespaces[i++];
129 ns_url = (char *) namespaces[i++];
130
131 if (ns_prefix) {
132 ns_len = spprintf(&ns_string, 0, " xmlns:%s=\"%s\"", ns_prefix, ns_url);
133 } else {
134 ns_len = spprintf(&ns_string, 0, " xmlns=\"%s\"", ns_url);
135 }
136 qualified_name = xmlStrncat(qualified_name, (xmlChar *)ns_string, ns_len);
137
138 efree(ns_string);
139 }
140 }
141
142 if (attributes) {
143 for (i = 0; i < nb_attributes; i += 1) {
144 int att_len;
145 char *att_string, *att_name, *att_value, *att_prefix, *att_valueend;
146
147 att_name = (char *) attributes[y++];
148 att_prefix = (char *)attributes[y++];
149 y++;
150 att_value = (char *)attributes[y++];
151 att_valueend = (char *)attributes[y++];
152
153 if (att_prefix) {
154 att_len = spprintf(&att_string, 0, " %s:%s=\"", att_prefix, att_name);
155 } else {
156 att_len = spprintf(&att_string, 0, " %s=\"", att_name);
157 }
158
159 qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_string, att_len);
160 qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_value, att_valueend - att_value);
161 qualified_name = xmlStrncat(qualified_name, (xmlChar *)"\"", 1);
162
163 efree(att_string);
164 }
165
166 }
167 qualified_name = xmlStrncat(qualified_name, (xmlChar *)">", 1);
168 parser->h_default(parser->user, (const XML_Char *) qualified_name, xmlStrlen(qualified_name));
169 xmlFree(qualified_name);
170 }
171 return;
172 }
173 _qualify_namespace(parser, name, URI, &qualified_name);
174
175 if (attributes != NULL) {
176 xmlChar *qualified_name_attr = NULL;
177 attrs = safe_emalloc((nb_attributes * 2) + 1, sizeof(int *), 0);
178
179 for (i = 0; i < nb_attributes; i += 1) {
180
181 if (attributes[y+1] != NULL) {
182 _qualify_namespace(parser, attributes[y] , attributes[y + 2], &qualified_name_attr);
183 } else {
184 qualified_name_attr = xmlStrdup(attributes[y]);
185 }
186 attrs[z] = qualified_name_attr;
187 attrs[z + 1] = xmlStrndup(attributes[y + 3] , (int) (attributes[y + 4] - attributes[y + 3]));
188 z += 2;
189 y += 5;
190 }
191
192 attrs[z] = NULL;
193 }
194 parser->h_start_element(parser->user, (const XML_Char *) qualified_name, (const XML_Char **) attrs);
195 if (attrs) {
196 for (i = 0; i < z; i++) {
197 xmlFree(attrs[i]);
198 }
199 efree(attrs);
200 }
201 xmlFree(qualified_name);
202 }
203
204 static void
_end_element_handler(void * user,const xmlChar * name)205 _end_element_handler(void *user, const xmlChar *name)
206 {
207 xmlChar *qualified_name;
208 XML_Parser parser = (XML_Parser) user;
209
210 if (parser->h_end_element == NULL) {
211 if (parser->h_default) {
212 char *end_element;
213
214 spprintf(&end_element, 0, "</%s>", (char *)name);
215 parser->h_default(parser->user, (const XML_Char *) end_element, strlen(end_element));
216 efree(end_element);
217 }
218 return;
219 }
220
221 qualified_name = xmlStrdup(name);
222
223 parser->h_end_element(parser->user, (const XML_Char *) qualified_name);
224
225 xmlFree(qualified_name);
226 }
227
228 static void
_end_element_handler_ns(void * user,const xmlChar * name,const xmlChar * prefix,const xmlChar * URI)229 _end_element_handler_ns(void *user, const xmlChar *name, const xmlChar * prefix, const xmlChar *URI)
230 {
231 xmlChar *qualified_name;
232 XML_Parser parser = (XML_Parser) user;
233
234 if (parser->h_end_element == NULL) {
235 if (parser->h_default) {
236 char *end_element;
237 int end_element_len;
238
239 if (prefix) {
240 end_element_len = spprintf(&end_element, 0, "</%s:%s>", (char *) prefix, (char *)name);
241 } else {
242 end_element_len = spprintf(&end_element, 0, "</%s>", (char *)name);
243 }
244 parser->h_default(parser->user, (const XML_Char *) end_element, end_element_len);
245 efree(end_element);
246 }
247 return;
248 }
249
250 _qualify_namespace(parser, name, URI, &qualified_name);
251
252 parser->h_end_element(parser->user, (const XML_Char *) qualified_name);
253
254 xmlFree(qualified_name);
255 }
256
257 static void
_cdata_handler(void * user,const xmlChar * cdata,int cdata_len)258 _cdata_handler(void *user, const xmlChar *cdata, int cdata_len)
259 {
260 XML_Parser parser = (XML_Parser) user;
261
262 if (parser->h_cdata == NULL) {
263 if (parser->h_default) {
264 parser->h_default(parser->user, (const XML_Char *) cdata, cdata_len);
265 }
266 return;
267 }
268
269 parser->h_cdata(parser->user, (const XML_Char *) cdata, cdata_len);
270 }
271
272 static void
_pi_handler(void * user,const xmlChar * target,const xmlChar * data)273 _pi_handler(void *user, const xmlChar *target, const xmlChar *data)
274 {
275 XML_Parser parser = (XML_Parser) user;
276
277 if (parser->h_pi == NULL) {
278 if (parser->h_default) {
279 char *full_pi;
280 spprintf(&full_pi, 0, "<?%s %s?>", (char *)target, (char *)data);
281 parser->h_default(parser->user, (const XML_Char *) full_pi, strlen(full_pi));
282 efree(full_pi);
283 }
284 return;
285 }
286
287 parser->h_pi(parser->user, (const XML_Char *) target, (const XML_Char *) data);
288 }
289
290 static void
_unparsed_entity_decl_handler(void * user,const xmlChar * name,const xmlChar * pub_id,const xmlChar * sys_id,const xmlChar * notation)291 _unparsed_entity_decl_handler(void *user,
292 const xmlChar *name,
293 const xmlChar *pub_id,
294 const xmlChar *sys_id,
295 const xmlChar *notation)
296 {
297 XML_Parser parser = (XML_Parser) user;
298
299 if (parser->h_unparsed_entity_decl == NULL) {
300 return;
301 }
302
303 parser->h_unparsed_entity_decl(parser->user, name, NULL, sys_id, pub_id, notation);
304 }
305
306 static void
_notation_decl_handler(void * user,const xmlChar * notation,const xmlChar * pub_id,const xmlChar * sys_id)307 _notation_decl_handler(void *user, const xmlChar *notation, const xmlChar *pub_id, const xmlChar *sys_id)
308 {
309 XML_Parser parser = (XML_Parser) user;
310
311 if (parser->h_notation_decl == NULL) {
312 return;
313 }
314
315 parser->h_notation_decl(parser->user, notation, NULL, sys_id, pub_id);
316 }
317
318 static void
_build_comment(const xmlChar * data,int data_len,xmlChar ** comment,int * comment_len)319 _build_comment(const xmlChar *data, int data_len, xmlChar **comment, int *comment_len)
320 {
321 *comment_len = data_len + 7;
322
323 *comment = xmlMalloc(*comment_len + 1);
324 memcpy(*comment, "<!--", 4);
325 memcpy(*comment + 4, data, data_len);
326 memcpy(*comment + 4 + data_len, "-->", 3);
327
328 (*comment)[*comment_len] = '\0';
329 }
330
331 static void
_comment_handler(void * user,const xmlChar * comment)332 _comment_handler(void *user, const xmlChar *comment)
333 {
334 XML_Parser parser = (XML_Parser) user;
335
336 if (parser->h_default) {
337 xmlChar *d_comment;
338 int d_comment_len;
339
340 _build_comment(comment, xmlStrlen(comment), &d_comment, &d_comment_len);
341 parser->h_default(parser->user, d_comment, d_comment_len);
342 xmlFree(d_comment);
343 }
344 }
345
346 static void
_build_entity(const xmlChar * name,int len,xmlChar ** entity,int * entity_len)347 _build_entity(const xmlChar *name, int len, xmlChar **entity, int *entity_len)
348 {
349 *entity_len = len + 2;
350 *entity = xmlMalloc(*entity_len + 1);
351 (*entity)[0] = '&';
352 memcpy(*entity+1, name, len);
353 (*entity)[len+1] = ';';
354 (*entity)[*entity_len] = '\0';
355 }
356
357 static void
_external_entity_ref_handler(void * user,const xmlChar * names,int type,const xmlChar * sys_id,const xmlChar * pub_id,xmlChar * content)358 _external_entity_ref_handler(void *user, const xmlChar *names, int type, const xmlChar *sys_id, const xmlChar *pub_id, xmlChar *content)
359 {
360 XML_Parser parser = (XML_Parser) user;
361
362 if (parser->h_external_entity_ref == NULL) {
363 return;
364 }
365
366 if (!parser->h_external_entity_ref(parser, names, (XML_Char *) "", sys_id, pub_id)) {
367 xmlStopParser(parser->parser);
368 parser->parser->errNo = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
369 };
370 }
371
372 static xmlEntityPtr
_get_entity(void * user,const xmlChar * name)373 _get_entity(void *user, const xmlChar *name)
374 {
375 XML_Parser parser = (XML_Parser) user;
376 xmlEntityPtr ret = NULL;
377
378 if (parser->parser->inSubset == 0) {
379 ret = xmlGetPredefinedEntity(name);
380 if (ret == NULL)
381 ret = xmlGetDocEntity(parser->parser->myDoc, name);
382
383 if (ret == NULL || (parser->parser->instate != XML_PARSER_ENTITY_VALUE && parser->parser->instate != XML_PARSER_ATTRIBUTE_VALUE)) {
384 if (ret == NULL || ret->etype == XML_INTERNAL_GENERAL_ENTITY || ret->etype == XML_INTERNAL_PARAMETER_ENTITY || ret->etype == XML_INTERNAL_PREDEFINED_ENTITY) {
385 /* Predefined entities will expand unless no cdata handler is present */
386 if (parser->h_default && ! (ret && ret->etype == XML_INTERNAL_PREDEFINED_ENTITY && parser->h_cdata)) {
387 xmlChar *entity;
388 int len;
389
390 _build_entity(name, xmlStrlen(name), &entity, &len);
391 parser->h_default(parser->user, (const xmlChar *) entity, len);
392 xmlFree(entity);
393 } else {
394 /* expat will not expand internal entities if default handler is present otherwise
395 it will expand and pass them to cdata handler */
396 if (parser->h_cdata && ret) {
397 parser->h_cdata(parser->user, ret->content, xmlStrlen(ret->content));
398 }
399 }
400 } else {
401 if (ret->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
402 _external_entity_ref_handler(user, ret->name, ret->etype, ret->SystemID, ret->ExternalID, NULL);
403 }
404 }
405 }
406 }
407
408 return ret;
409 }
410
411 static const xmlSAXHandler
412 php_xml_compat_handlers = {
413 NULL, /* internalSubset */
414 NULL, /* isStandalone */
415 NULL, /* hasInternalSubset */
416 NULL, /* hasExternalSubset */
417 NULL, /* resolveEntity */
418 _get_entity, /* getEntity */
419 NULL, /* entityDecl */
420 _notation_decl_handler,
421 NULL, /* attributeDecl */
422 NULL, /* elementDecl */
423 _unparsed_entity_decl_handler, /* unparsedEntity */
424 NULL, /* setDocumentLocator */
425 NULL, /* startDocument */
426 NULL, /* endDocument */
427 _start_element_handler, /* startElement */
428 _end_element_handler, /* endElement */
429 NULL, /* reference */
430 _cdata_handler,
431 NULL, /* ignorableWhitespace */
432 _pi_handler,
433 _comment_handler, /* comment */
434 NULL, /* warning */
435 NULL, /* error */
436 NULL, /* fatalError */
437 NULL, /* getParameterEntity */
438 _cdata_handler, /* cdataBlock */
439 NULL, /* externalSubset */
440 XML_SAX2_MAGIC,
441 NULL,
442 _start_element_handler_ns,
443 _end_element_handler_ns,
444 NULL
445 };
446
447 PHP_XML_API XML_Parser
XML_ParserCreate(const XML_Char * encoding)448 XML_ParserCreate(const XML_Char *encoding)
449 {
450 return XML_ParserCreate_MM(encoding, NULL, NULL);
451 }
452
453 PHP_XML_API XML_Parser
XML_ParserCreateNS(const XML_Char * encoding,const XML_Char sep)454 XML_ParserCreateNS(const XML_Char *encoding, const XML_Char sep)
455 {
456 XML_Char tmp[2];
457 tmp[0] = sep;
458 tmp[1] = '\0';
459 return XML_ParserCreate_MM(encoding, NULL, tmp);
460 }
461
462 PHP_XML_API XML_Parser
XML_ParserCreate_MM(const XML_Char * encoding,const XML_Memory_Handling_Suite * memsuite,const XML_Char * sep)463 XML_ParserCreate_MM(const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite, const XML_Char *sep)
464 {
465 XML_Parser parser;
466
467 parser = (XML_Parser) emalloc(sizeof(struct _XML_Parser));
468 memset(parser, 0, sizeof(struct _XML_Parser));
469 parser->use_namespace = 0;
470 parser->_ns_separator = NULL;
471
472 parser->parser = xmlCreatePushParserCtxt((xmlSAXHandlerPtr) &php_xml_compat_handlers, (void *) parser, NULL, 0, NULL);
473 if (parser->parser == NULL) {
474 efree(parser);
475 return NULL;
476 }
477 #if LIBXML_VERSION <= 20617
478 /* for older versions of libxml2, allow correct detection of
479 * charset in documents with a BOM: */
480 parser->parser->charset = XML_CHAR_ENCODING_NONE;
481 #endif
482
483 #if LIBXML_VERSION >= 20703
484 xmlCtxtUseOptions(parser->parser, XML_PARSE_OLDSAX);
485 #endif
486
487 parser->parser->replaceEntities = 1;
488 parser->parser->wellFormed = 0;
489 if (sep != NULL) {
490 parser->use_namespace = 1;
491 parser->parser->sax2 = 1;
492 parser->_ns_separator = xmlStrdup(sep);
493 } else {
494 /* Reset flag as XML_SAX2_MAGIC is needed for xmlCreatePushParserCtxt
495 so must be set in the handlers */
496 parser->parser->sax->initialized = 1;
497 }
498 return parser;
499 }
500
501 PHP_XML_API void
XML_SetUserData(XML_Parser parser,void * user)502 XML_SetUserData(XML_Parser parser, void *user)
503 {
504 parser->user = user;
505 }
506
507 PHP_XML_API void *
XML_GetUserData(XML_Parser parser)508 XML_GetUserData(XML_Parser parser)
509 {
510 return parser->user;
511 }
512
513 PHP_XML_API void
XML_SetElementHandler(XML_Parser parser,XML_StartElementHandler start,XML_EndElementHandler end)514 XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end)
515 {
516 parser->h_start_element = start;
517 parser->h_end_element = end;
518 }
519
520 PHP_XML_API void
XML_SetCharacterDataHandler(XML_Parser parser,XML_CharacterDataHandler cdata)521 XML_SetCharacterDataHandler(XML_Parser parser, XML_CharacterDataHandler cdata)
522 {
523 parser->h_cdata = cdata;
524 }
525
526 PHP_XML_API void
XML_SetProcessingInstructionHandler(XML_Parser parser,XML_ProcessingInstructionHandler pi)527 XML_SetProcessingInstructionHandler(XML_Parser parser, XML_ProcessingInstructionHandler pi)
528 {
529 parser->h_pi = pi;
530 }
531
532 PHP_XML_API void
XML_SetCommentHandler(XML_Parser parser,XML_CommentHandler comment)533 XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler comment)
534 {
535 parser->h_comment = comment;
536 }
537
538 PHP_XML_API void
XML_SetDefaultHandler(XML_Parser parser,XML_DefaultHandler d)539 XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler d)
540 {
541 parser->h_default = d;
542 }
543
544 PHP_XML_API void
XML_SetUnparsedEntityDeclHandler(XML_Parser parser,XML_UnparsedEntityDeclHandler unparsed_decl)545 XML_SetUnparsedEntityDeclHandler(XML_Parser parser, XML_UnparsedEntityDeclHandler unparsed_decl)
546 {
547 parser->h_unparsed_entity_decl = unparsed_decl;
548 }
549
550 PHP_XML_API void
XML_SetNotationDeclHandler(XML_Parser parser,XML_NotationDeclHandler notation_decl)551 XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler notation_decl)
552 {
553 parser->h_notation_decl = notation_decl;
554 }
555
556 PHP_XML_API void
XML_SetExternalEntityRefHandler(XML_Parser parser,XML_ExternalEntityRefHandler ext_entity)557 XML_SetExternalEntityRefHandler(XML_Parser parser, XML_ExternalEntityRefHandler ext_entity)
558 {
559 parser->h_external_entity_ref = ext_entity;
560 }
561
562 PHP_XML_API void
XML_SetStartNamespaceDeclHandler(XML_Parser parser,XML_StartNamespaceDeclHandler start_ns)563 XML_SetStartNamespaceDeclHandler(XML_Parser parser, XML_StartNamespaceDeclHandler start_ns)
564 {
565 parser->h_start_ns = start_ns;
566 }
567
568 PHP_XML_API void
XML_SetEndNamespaceDeclHandler(XML_Parser parser,XML_EndNamespaceDeclHandler end_ns)569 XML_SetEndNamespaceDeclHandler(XML_Parser parser, XML_EndNamespaceDeclHandler end_ns)
570 {
571 parser->h_end_ns = end_ns;
572 }
573
574 PHP_XML_API int
XML_Parse(XML_Parser parser,const XML_Char * data,int data_len,int is_final)575 XML_Parse(XML_Parser parser, const XML_Char *data, int data_len, int is_final)
576 {
577 int error;
578
579 /* The following is a hack to keep BC with PHP 4 while avoiding
580 the inifite loop in libxml <= 2.6.17 which occurs when no encoding
581 has been defined and none can be detected */
582 #if LIBXML_VERSION <= 20617
583 if (parser->parser->charset == XML_CHAR_ENCODING_NONE) {
584 if (data_len >= 4 || (parser->parser->input->buf->buffer->use + data_len >= 4)) {
585 xmlChar start[4];
586 int char_count;
587
588 char_count = parser->parser->input->buf->buffer->use;
589 if (char_count > 4) {
590 char_count = 4;
591 }
592
593 memcpy(start, parser->parser->input->buf->buffer->content, (size_t)char_count);
594 memcpy(start + char_count, data, (size_t)(4 - char_count));
595
596 if (xmlDetectCharEncoding(&start[0], 4) == XML_CHAR_ENCODING_NONE) {
597 parser->parser->charset = XML_CHAR_ENCODING_UTF8;
598 }
599 }
600 }
601 #endif
602
603 if (parser->parser->lastError.level >= XML_ERR_WARNING) {
604 return 0;
605 }
606
607 error = xmlParseChunk(parser->parser, (char *) data, data_len, is_final);
608 if (error) {
609 return 0;
610 } else {
611 return 1;
612 }
613 }
614
615 PHP_XML_API int
XML_GetErrorCode(XML_Parser parser)616 XML_GetErrorCode(XML_Parser parser)
617 {
618 return parser->parser->errNo;
619 }
620
621 static const XML_Char *const error_mapping[] = {
622 (const XML_Char *)"No error",
623 (const XML_Char *)"No memory",
624 (const XML_Char *)"Invalid document start",
625 (const XML_Char *)"Empty document",
626 (const XML_Char *)"Not well-formed (invalid token)",
627 (const XML_Char *)"Invalid document end",
628 (const XML_Char *)"Invalid hexadecimal character reference",
629 (const XML_Char *)"Invalid decimal character reference",
630 (const XML_Char *)"Invalid character reference",
631 (const XML_Char *)"Invalid character",
632 (const XML_Char *)"XML_ERR_CHARREF_AT_EOF",
633 (const XML_Char *)"XML_ERR_CHARREF_IN_PROLOG",
634 (const XML_Char *)"XML_ERR_CHARREF_IN_EPILOG",
635 (const XML_Char *)"XML_ERR_CHARREF_IN_DTD",
636 (const XML_Char *)"XML_ERR_ENTITYREF_AT_EOF",
637 (const XML_Char *)"XML_ERR_ENTITYREF_IN_PROLOG",
638 (const XML_Char *)"XML_ERR_ENTITYREF_IN_EPILOG",
639 (const XML_Char *)"XML_ERR_ENTITYREF_IN_DTD",
640 (const XML_Char *)"PEReference at end of document",
641 (const XML_Char *)"PEReference in prolog",
642 (const XML_Char *)"PEReference in epilog",
643 (const XML_Char *)"PEReference: forbidden within markup decl in internal subset",
644 (const XML_Char *)"XML_ERR_ENTITYREF_NO_NAME",
645 (const XML_Char *)"EntityRef: expecting ';'",
646 (const XML_Char *)"PEReference: no name",
647 (const XML_Char *)"PEReference: expecting ';'",
648 (const XML_Char *)"Undeclared entity error",
649 (const XML_Char *)"Undeclared entity warning",
650 (const XML_Char *)"Unparsed Entity",
651 (const XML_Char *)"XML_ERR_ENTITY_IS_EXTERNAL",
652 (const XML_Char *)"XML_ERR_ENTITY_IS_PARAMETER",
653 (const XML_Char *)"Unknown encoding",
654 (const XML_Char *)"Unsupported encoding",
655 (const XML_Char *)"String not started expecting ' or \"",
656 (const XML_Char *)"String not closed expecting \" or '",
657 (const XML_Char *)"Namespace declaration error",
658 (const XML_Char *)"EntityValue: \" or ' expected",
659 (const XML_Char *)"EntityValue: \" or ' expected",
660 (const XML_Char *)"< in attribute",
661 (const XML_Char *)"Attribute not started",
662 (const XML_Char *)"Attribute not finished",
663 (const XML_Char *)"Attribute without value",
664 (const XML_Char *)"Attribute redefined",
665 (const XML_Char *)"SystemLiteral \" or ' expected",
666 (const XML_Char *)"SystemLiteral \" or ' expected",
667 /* (const XML_Char *)"XML_ERR_COMMENT_NOT_STARTED", <= eliminated on purpose */
668 (const XML_Char *)"Comment not finished",
669 (const XML_Char *)"Processing Instruction not started",
670 (const XML_Char *)"Processing Instruction not finished",
671 (const XML_Char *)"NOTATION: Name expected here",
672 (const XML_Char *)"'>' required to close NOTATION declaration",
673 (const XML_Char *)"'(' required to start ATTLIST enumeration",
674 (const XML_Char *)"'(' required to start ATTLIST enumeration",
675 (const XML_Char *)"MixedContentDecl : '|' or ')*' expected",
676 (const XML_Char *)"XML_ERR_MIXED_NOT_FINISHED",
677 (const XML_Char *)"ELEMENT in DTD not started",
678 (const XML_Char *)"ELEMENT in DTD not finished",
679 (const XML_Char *)"XML declaration not started",
680 (const XML_Char *)"XML declaration not finished",
681 (const XML_Char *)"XML_ERR_CONDSEC_NOT_STARTED",
682 (const XML_Char *)"XML conditional section not closed",
683 (const XML_Char *)"Content error in the external subset",
684 (const XML_Char *)"DOCTYPE not finished",
685 (const XML_Char *)"Sequence ']]>' not allowed in content",
686 (const XML_Char *)"CDATA not finished",
687 (const XML_Char *)"Reserved XML Name",
688 (const XML_Char *)"Space required",
689 (const XML_Char *)"XML_ERR_SEPARATOR_REQUIRED",
690 (const XML_Char *)"NmToken expected in ATTLIST enumeration",
691 (const XML_Char *)"XML_ERR_NAME_REQUIRED",
692 (const XML_Char *)"MixedContentDecl : '#PCDATA' expected",
693 (const XML_Char *)"SYSTEM or PUBLIC, the URI is missing",
694 (const XML_Char *)"PUBLIC, the Public Identifier is missing",
695 (const XML_Char *)"< required",
696 (const XML_Char *)"> required",
697 (const XML_Char *)"</ required",
698 (const XML_Char *)"= required",
699 (const XML_Char *)"Mismatched tag",
700 (const XML_Char *)"Tag not finished",
701 (const XML_Char *)"standalone accepts only 'yes' or 'no'",
702 (const XML_Char *)"Invalid XML encoding name",
703 (const XML_Char *)"Comment must not contain '--' (double-hyphen)",
704 (const XML_Char *)"Invalid encoding",
705 (const XML_Char *)"external parsed entities cannot be standalone",
706 (const XML_Char *)"XML conditional section '[' expected",
707 (const XML_Char *)"Entity value required",
708 (const XML_Char *)"chunk is not well balanced",
709 (const XML_Char *)"extra content at the end of well balanced chunk",
710 (const XML_Char *)"XML_ERR_ENTITY_CHAR_ERROR",
711 (const XML_Char *)"PEReferences forbidden in internal subset",
712 (const XML_Char *)"Detected an entity reference loop",
713 (const XML_Char *)"XML_ERR_ENTITY_BOUNDARY",
714 (const XML_Char *)"Invalid URI",
715 (const XML_Char *)"Fragment not allowed",
716 (const XML_Char *)"XML_WAR_CATALOG_PI",
717 (const XML_Char *)"XML_ERR_NO_DTD",
718 (const XML_Char *)"conditional section INCLUDE or IGNORE keyword expected", /* 95 */
719 (const XML_Char *)"Version in XML Declaration missing", /* 96 */
720 (const XML_Char *)"XML_WAR_UNKNOWN_VERSION", /* 97 */
721 (const XML_Char *)"XML_WAR_LANG_VALUE", /* 98 */
722 (const XML_Char *)"XML_WAR_NS_URI", /* 99 */
723 (const XML_Char *)"XML_WAR_NS_URI_RELATIVE", /* 100 */
724 (const XML_Char *)"Missing encoding in text declaration" /* 101 */
725 };
726
727 PHP_XML_API const XML_Char *
XML_ErrorString(int code)728 XML_ErrorString(int code)
729 {
730 if (code < 0 || code >= (int)(sizeof(error_mapping) / sizeof(error_mapping[0]))) {
731 return (const XML_Char *) "Unknown";
732 }
733 return error_mapping[code];
734 }
735
736 PHP_XML_API int
XML_GetCurrentLineNumber(XML_Parser parser)737 XML_GetCurrentLineNumber(XML_Parser parser)
738 {
739 return parser->parser->input->line;
740 }
741
742 PHP_XML_API int
XML_GetCurrentColumnNumber(XML_Parser parser)743 XML_GetCurrentColumnNumber(XML_Parser parser)
744 {
745 return parser->parser->input->col;
746 }
747
748 PHP_XML_API int
XML_GetCurrentByteIndex(XML_Parser parser)749 XML_GetCurrentByteIndex(XML_Parser parser)
750 {
751 return parser->parser->input->consumed +
752 (parser->parser->input->cur - parser->parser->input->base);
753 }
754
755 PHP_XML_API int
XML_GetCurrentByteCount(XML_Parser parser)756 XML_GetCurrentByteCount(XML_Parser parser)
757 {
758 /* WARNING: this is identical to ByteIndex; it should probably
759 * be different */
760 return parser->parser->input->consumed +
761 (parser->parser->input->cur - parser->parser->input->base);
762 }
763
XML_ExpatVersion(void)764 PHP_XML_API const XML_Char *XML_ExpatVersion(void)
765 {
766 return (const XML_Char *) "1.0";
767 }
768
769 PHP_XML_API void
XML_ParserFree(XML_Parser parser)770 XML_ParserFree(XML_Parser parser)
771 {
772 if (parser->use_namespace) {
773 if (parser->_ns_separator) {
774 xmlFree(parser->_ns_separator);
775 }
776 }
777 if (parser->parser->myDoc) {
778 xmlFreeDoc(parser->parser->myDoc);
779 parser->parser->myDoc = NULL;
780 }
781 xmlFreeParserCtxt(parser->parser);
782 efree(parser);
783 }
784
785 #endif /* LIBXML_EXPAT_COMPAT */
786 #endif
787
788 /**
789 * Local Variables:
790 * tab-width: 4
791 * c-basic-offset: 4
792 * indent-tabs-mode: t
793 * End:
794 * vim600: fdm=marker
795 * vim: ts=4 noet sw=4
796 */
797