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