PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/xml - compat.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 221 288 76.7 %
Date: 2014-09-02 Functions: 29 39 74.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 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 
      37        1020 : _qualify_namespace(XML_Parser parser, const xmlChar *name, const xmlChar *URI, xmlChar **qualified)
      38             : {
      39        1020 :         if (URI) {
      40             :                         /* Use libxml functions otherwise its memory deallocation is screwed up */
      41          18 :                         *qualified = xmlStrdup(URI);
      42          18 :                         *qualified = xmlStrncat(*qualified, parser->_ns_seperator, 1);
      43          18 :                         *qualified = xmlStrncat(*qualified, name, xmlStrlen(name));
      44             :         } else {
      45        1002 :                 *qualified = xmlStrdup(name);
      46             :         }
      47        1020 : }
      48             : 
      49             : static void
      50        2282 : _start_element_handler(void *user, const xmlChar *name, const xmlChar **attributes)
      51             : {
      52        2282 :         XML_Parser  parser = (XML_Parser) user;
      53        2282 :         xmlChar    *qualified_name = NULL;
      54             : 
      55        2282 :         if (parser->h_start_element == NULL) {
      56           1 :                 if (parser->h_default) {
      57           1 :                         int attno = 0;
      58             : 
      59           1 :                         qualified_name = xmlStrncatNew((xmlChar *)"<", name, xmlStrlen(name));
      60           1 :                         if (attributes) {
      61           0 :                                 while (attributes[attno] != NULL) {
      62             :                                         int att_len;
      63             :                                         char *att_string, *att_name, *att_value;
      64             : 
      65           0 :                                         att_name = (char *)attributes[attno++];
      66           0 :                                         att_value = (char *)attributes[attno++];
      67             : 
      68           0 :                                         att_len = spprintf(&att_string, 0, " %s=\"%s\"", att_name, att_value);
      69             : 
      70           0 :                                         qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_string, att_len);
      71           0 :                                         efree(att_string);
      72             :                                 }
      73             : 
      74             :                         }
      75           1 :                         qualified_name = xmlStrncat(qualified_name, (xmlChar *)">", 1);
      76           1 :                         parser->h_default(parser->user, (const XML_Char *) qualified_name, xmlStrlen(qualified_name));
      77           1 :                         xmlFree(qualified_name);
      78             :                 }
      79           1 :                 return;
      80             :         }
      81             : 
      82        2281 :         qualified_name = xmlStrdup(name);
      83             : 
      84        2281 :         parser->h_start_element(parser->user, (const XML_Char *) qualified_name, (const XML_Char **) attributes);
      85             : 
      86        2281 :         xmlFree(qualified_name);
      87             : }
      88             : 
      89             : static void
      90        1016 : _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        1016 :         XML_Parser  parser = (XML_Parser) user;
      93        1016 :         xmlChar    *qualified_name = NULL;
      94        1016 :         xmlChar **attrs = NULL;
      95             :         int i;
      96        1016 :         int z = 0;
      97        1016 :         int y = 0;
      98             :         
      99        1016 :         if (nb_namespaces > 0 && parser->h_start_ns != NULL) {
     100           3 :                 for (i = 0; i < nb_namespaces; i += 1) {
     101           2 :                         parser->h_start_ns(parser->user, (const XML_Char *) namespaces[y], (const XML_Char *) namespaces[y+1]);
     102           2 :                         y += 2;
     103             :                 }
     104           1 :                 y = 0;
     105             :         }
     106             :         
     107        1016 :         if (parser->h_start_element == NULL) {
     108           6 :                 if (parser->h_default) {
     109             : 
     110           3 :                         if (prefix) {
     111           2 :                                 qualified_name = xmlStrncatNew((xmlChar *)"<", prefix, xmlStrlen(prefix));
     112           2 :                                 qualified_name = xmlStrncat(qualified_name, (xmlChar *)":", 1);
     113           2 :                                 qualified_name = xmlStrncat(qualified_name, name, xmlStrlen(name));
     114             :                         } else {
     115           1 :                                 qualified_name = xmlStrncatNew((xmlChar *)"<", name, xmlStrlen(name));
     116             :                         }
     117             :                         
     118           3 :                         if (namespaces) {
     119             :                                 int i, j;
     120           3 :                                 for (i = 0,j = 0;j < nb_namespaces;j++) {
     121             :                                         int ns_len;
     122             :                                         char *ns_string, *ns_prefix, *ns_url;
     123             :                                         
     124           2 :                                         ns_prefix = (char *) namespaces[i++];
     125           2 :                                         ns_url = (char *) namespaces[i++];
     126             :                                         
     127           2 :                                         if (ns_prefix) {
     128           1 :                                                 ns_len = spprintf(&ns_string, 0, " xmlns:%s=\"%s\"", ns_prefix, ns_url);
     129             :                                         } else {
     130           1 :                                                 ns_len = spprintf(&ns_string, 0, " xmlns=\"%s\"", ns_url);
     131             :                                         }
     132           2 :                                         qualified_name = xmlStrncat(qualified_name, (xmlChar *)ns_string, ns_len);
     133             :                                         
     134           2 :                                         efree(ns_string);
     135             :                                 }
     136             :                         }
     137             :                         
     138           3 :                         if (attributes) {
     139           5 :                                 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           3 :                                         att_name = (char *) attributes[y++];
     144           3 :                                         att_prefix = (char *)attributes[y++];
     145           3 :                                         y++;
     146           3 :                                         att_value = (char *)attributes[y++];
     147           3 :                                         att_valueend = (char *)attributes[y++];
     148             : 
     149           3 :                                         if (att_prefix) {
     150           1 :                                                 att_len = spprintf(&att_string, 0, " %s:%s=\"", att_prefix, att_name);
     151             :                                         } else {
     152           2 :                                                 att_len = spprintf(&att_string, 0, " %s=\"", att_name);
     153             :                                         }
     154             : 
     155           3 :                                         qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_string, att_len);
     156           3 :                                         qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_value, att_valueend - att_value);
     157           3 :                                         qualified_name = xmlStrncat(qualified_name, (xmlChar *)"\"", 1);
     158             :                                         
     159           3 :                                         efree(att_string);
     160             :                                 }
     161             : 
     162             :                         }
     163           3 :                         qualified_name = xmlStrncat(qualified_name, (xmlChar *)">", 1);
     164           3 :                         parser->h_default(parser->user, (const XML_Char *) qualified_name, xmlStrlen(qualified_name));
     165           3 :                         xmlFree(qualified_name);
     166             :                 }
     167           6 :                 return;
     168             :         }
     169        1010 :         _qualify_namespace(parser, name, URI, &qualified_name);
     170             :         
     171        1010 :         if (attributes != NULL) {
     172           3 :                 xmlChar    *qualified_name_attr = NULL;
     173           3 :                 attrs = safe_emalloc((nb_attributes  * 2) + 1, sizeof(int *), 0);
     174             : 
     175           8 :                 for (i = 0; i < nb_attributes; i += 1) {
     176             : 
     177           5 :                         if (attributes[y+1] != NULL) {
     178           1 :                                 _qualify_namespace(parser, attributes[y] , attributes[y + 2], &qualified_name_attr);
     179             :                         } else {
     180           4 :                                 qualified_name_attr = xmlStrdup(attributes[y]);
     181             :                         }
     182           5 :                         attrs[z] = qualified_name_attr;
     183           5 :                         attrs[z + 1] = xmlStrndup(attributes[y + 3] , (int) (attributes[y + 4] - attributes[y + 3]));
     184           5 :                         z += 2;
     185           5 :                         y += 5;
     186             :                 }
     187             : 
     188           3 :                 attrs[z] = NULL;
     189             :         }
     190        1010 :         parser->h_start_element(parser->user, (const XML_Char *) qualified_name, (const XML_Char **) attrs);
     191        1010 :         if (attrs) {
     192          13 :                 for (i = 0; i < z; i++) {
     193          10 :                         xmlFree(attrs[i]);
     194             :                 }
     195           3 :                 efree(attrs);
     196             :         }
     197        1010 :         xmlFree(qualified_name);
     198             : }
     199             : 
     200             : static void
     201           0 : _namespace_handler(XML_Parser parser, xmlNsPtr nsptr)
     202             : {
     203           0 :         if (nsptr != NULL) {
     204           0 :                 _namespace_handler(parser, nsptr->next);
     205           0 :                 parser->h_end_ns(parser->user, nsptr->prefix);
     206             :         }
     207           0 : }
     208             : 
     209             : static void
     210        2278 : _end_element_handler(void *user, const xmlChar *name)
     211             : {
     212             :         xmlChar    *qualified_name;
     213        2278 :         XML_Parser  parser = (XML_Parser) user;
     214             : 
     215        2278 :         if (parser->h_end_element == NULL) {
     216           1 :                 if (parser->h_default) {
     217             :                         char *end_element;
     218             : 
     219           1 :                         spprintf(&end_element, 0, "</%s>", (char *)name);
     220           1 :                         parser->h_default(parser->user, (const XML_Char *) end_element, strlen(end_element));
     221           1 :                         efree(end_element);
     222             :                 }
     223           1 :                 return;
     224             :         }
     225             :         
     226        2277 :         qualified_name = xmlStrdup(name);
     227             : 
     228        2277 :         parser->h_end_element(parser->user, (const XML_Char *) qualified_name);
     229             : 
     230        2277 :         xmlFree(qualified_name);
     231             : }
     232             : 
     233             : static void
     234          15 : _end_element_handler_ns(void *user, const xmlChar *name, const xmlChar * prefix, const xmlChar *URI)
     235             : {
     236             :         xmlChar    *qualified_name;
     237          15 :         XML_Parser  parser = (XML_Parser) user;
     238             : 
     239          15 :         if (parser->h_end_element == NULL) {
     240           6 :                 if (parser->h_default) {
     241             :                         char *end_element;
     242             :                         int end_element_len;
     243             : 
     244           3 :                         if (prefix) {
     245           2 :                                 end_element_len = spprintf(&end_element, 0, "</%s:%s>", (char *) prefix, (char *)name);
     246             :                         } else {
     247           1 :                                 end_element_len = spprintf(&end_element, 0, "</%s>", (char *)name);
     248             :                         }
     249           3 :                         parser->h_default(parser->user, (const XML_Char *) end_element, end_element_len);
     250           3 :                         efree(end_element);
     251             :                 }
     252           6 :                 return;
     253             :         }
     254             : 
     255           9 :         _qualify_namespace(parser, name, URI,  &qualified_name);
     256             : 
     257           9 :         parser->h_end_element(parser->user, (const XML_Char *) qualified_name);
     258             : 
     259           9 :         xmlFree(qualified_name);
     260             : }
     261             : 
     262             : static void
     263        1083 : _cdata_handler(void *user, const xmlChar *cdata, int cdata_len)
     264             : {
     265        1083 :         XML_Parser parser = (XML_Parser) user;
     266             : 
     267        1083 :         if (parser->h_cdata == NULL) {
     268         139 :                 if (parser->h_default) {
     269           5 :                         parser->h_default(parser->user, (const XML_Char *) cdata, cdata_len);
     270             :                 }
     271         139 :                 return;
     272             :         }
     273             : 
     274         944 :         parser->h_cdata(parser->user, (const XML_Char *) cdata, cdata_len);
     275             : }
     276             : 
     277             : static void
     278           4 : _pi_handler(void *user, const xmlChar *target, const xmlChar *data)
     279             : {
     280           4 :         XML_Parser parser = (XML_Parser) user;
     281             : 
     282           4 :         if (parser->h_pi == NULL) {
     283           3 :                 if (parser->h_default) {
     284             :                         char    *full_pi;
     285           0 :                         spprintf(&full_pi, 0, "<?%s %s?>", (char *)target, (char *)data);
     286           0 :                         parser->h_default(parser->user, (const XML_Char *) full_pi, strlen(full_pi));
     287           0 :                         efree(full_pi);
     288             :                 }
     289           3 :                 return;
     290             :         }
     291             : 
     292           1 :         parser->h_pi(parser->user, (const XML_Char *) target, (const XML_Char *) data);
     293             : }
     294             : 
     295             : static void
     296           3 : _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           3 :         XML_Parser parser = (XML_Parser) user;
     303             : 
     304           3 :         if (parser->h_unparsed_entity_decl == NULL) {
     305           0 :                 return;
     306             :         }
     307             : 
     308           3 :         parser->h_unparsed_entity_decl(parser->user, name, NULL, sys_id, pub_id, notation);
     309             : }
     310             : 
     311             : static void
     312           3 : _notation_decl_handler(void *user, const xmlChar *notation, const xmlChar *pub_id, const xmlChar *sys_id)
     313             : {
     314           3 :         XML_Parser parser = (XML_Parser) user;
     315             : 
     316           3 :         if (parser->h_notation_decl == NULL) {
     317           0 :                 return;
     318             :         }
     319             : 
     320           3 :         parser->h_notation_decl(parser->user, notation, NULL, sys_id, pub_id);
     321             : }
     322             : 
     323             : static void
     324           0 : _build_comment(const xmlChar *data, int data_len, xmlChar **comment, int *comment_len)
     325             : {
     326           0 :         *comment_len = data_len + 7;
     327             :         
     328           0 :         *comment = xmlMalloc(*comment_len + 1);
     329           0 :         memcpy(*comment, "<!--", 4);
     330           0 :         memcpy(*comment + 4, data, data_len);
     331           0 :         memcpy(*comment + 4 + data_len, "-->", 3);
     332             : 
     333           0 :         (*comment)[*comment_len] = '\0';
     334           0 : }
     335             : 
     336             : static void
     337          16 : _comment_handler(void *user, const xmlChar *comment)
     338             : {
     339          16 :         XML_Parser parser = (XML_Parser) user;
     340             : 
     341          16 :         if (parser->h_default) {
     342             :                 xmlChar *d_comment;
     343             :                 int      d_comment_len;
     344             : 
     345           0 :                 _build_comment(comment, xmlStrlen(comment), &d_comment, &d_comment_len);
     346           0 :                 parser->h_default(parser->user, d_comment, d_comment_len);
     347           0 :                 xmlFree(d_comment);
     348             :         }
     349          16 : }
     350             : 
     351             : static void
     352           0 : _build_entity(const xmlChar *name, int len, xmlChar **entity, int *entity_len) 
     353             : {
     354           0 :         *entity_len = len + 2;
     355           0 :         *entity = xmlMalloc(*entity_len + 1);
     356           0 :         (*entity)[0] = '&';
     357           0 :         memcpy(*entity+1, name, len);
     358           0 :         (*entity)[len+1] = ';';
     359           0 :         (*entity)[*entity_len] = '\0';
     360           0 : }
     361             : 
     362             : static void
     363           0 : _external_entity_ref_handler(void *user, const xmlChar *names, int type, const xmlChar *sys_id, const xmlChar *pub_id, xmlChar *content)
     364             : {
     365           0 :         XML_Parser parser = (XML_Parser) user;
     366             : 
     367           0 :         if (parser->h_external_entity_ref == NULL) {
     368           0 :                 return;
     369             :         }
     370             : 
     371           0 :         parser->h_external_entity_ref(parser, names, "", sys_id, pub_id);
     372             : }
     373             : 
     374             : static xmlEntityPtr
     375          15 : _get_entity(void *user, const xmlChar *name)
     376             : {
     377          15 :         XML_Parser parser = (XML_Parser) user;
     378          15 :         xmlEntityPtr ret = NULL;
     379             : 
     380          15 :         if (parser->parser->inSubset == 0) {
     381          15 :                 ret = xmlGetPredefinedEntity(name);
     382          15 :                 if (ret == NULL)
     383           3 :                         ret = xmlGetDocEntity(parser->parser->myDoc, name);
     384             : 
     385          15 :                 if (ret == NULL || (parser->parser->instate != XML_PARSER_ENTITY_VALUE && parser->parser->instate != XML_PARSER_ATTRIBUTE_VALUE)) {
     386          20 :                         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          10 :                                 if (parser->h_default && ! (ret && ret->etype == XML_INTERNAL_PREDEFINED_ENTITY && parser->h_cdata)) {
     389             :                                         xmlChar *entity;
     390             :                                         int      len;
     391             :                                         
     392           0 :                                         _build_entity(name, xmlStrlen(name), &entity, &len);
     393           0 :                                         parser->h_default(parser->user, (const xmlChar *) entity, len);
     394           0 :                                         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          10 :                                         if (parser->h_cdata && ret) {
     399           6 :                                                 parser->h_cdata(parser->user, ret->content, xmlStrlen(ret->content));
     400             :                                         }
     401             :                                 }
     402             :                         } else {
     403           0 :                                 if (ret->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
     404           0 :                                         _external_entity_ref_handler(user, ret->name, ret->etype, ret->SystemID, ret->ExternalID, NULL);
     405             :                                 }
     406             :                         }
     407             :                 }
     408             :         }
     409             : 
     410          15 :         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 
     450         423 : XML_ParserCreate(const XML_Char *encoding)
     451             : {
     452         423 :         return XML_ParserCreate_MM(encoding, NULL, NULL);
     453             : }
     454             : 
     455             : PHPAPI XML_Parser
     456           0 : XML_ParserCreateNS(const XML_Char *encoding, const XML_Char sep)
     457             : {
     458             :         XML_Char tmp[2];
     459           0 :         tmp[0] = sep;
     460           0 :         tmp[1] = '\0';
     461           0 :         return XML_ParserCreate_MM(encoding, NULL, tmp);
     462             : }
     463             : 
     464             : PHPAPI XML_Parser
     465         583 : XML_ParserCreate_MM(const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite, const XML_Char *sep)
     466             : {
     467             :         XML_Parser parser;
     468             : 
     469         583 :         parser = (XML_Parser) emalloc(sizeof(struct _XML_Parser));
     470         583 :         memset(parser, 0, sizeof(struct _XML_Parser));
     471         583 :         parser->use_namespace = 0;
     472         583 :         parser->_ns_seperator = NULL;
     473             : 
     474         583 :         parser->parser = xmlCreatePushParserCtxt((xmlSAXHandlerPtr) &php_xml_compat_handlers, (void *) parser, NULL, 0, NULL);
     475         583 :         if (parser->parser == NULL) {
     476           0 :                 efree(parser);
     477           0 :                 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         583 :         xmlCtxtUseOptions(parser->parser, XML_PARSE_OLDSAX);
     487             : #endif
     488             : 
     489         583 :         parser->parser->replaceEntities = 1;
     490         583 :         parser->parser->wellFormed = 0;
     491         583 :         if (sep != NULL) {
     492          24 :                 parser->use_namespace = 1;
     493          24 :                 parser->parser->sax2 = 1;
     494          24 :                 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         559 :                 parser->parser->sax->initialized = 1;
     499             :         }
     500         583 :         return parser;
     501             : }
     502             : 
     503             : PHPAPI void
     504         583 : XML_SetUserData(XML_Parser parser, void *user)
     505             : {
     506         583 :         parser->user = user;
     507         583 : }
     508             : 
     509             : PHPAPI void *
     510           0 : XML_GetUserData(XML_Parser parser)
     511             : {
     512           0 :         return parser->user;
     513             : }
     514             : 
     515             : PHPAPI void
     516         462 : XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end)
     517             : {
     518         462 :         parser->h_start_element = start;
     519         462 :         parser->h_end_element = end;
     520         462 : }
     521             : 
     522             : PHPAPI void
     523         432 : XML_SetCharacterDataHandler(XML_Parser parser, XML_CharacterDataHandler cdata)
     524             : {
     525         432 :         parser->h_cdata = cdata;
     526         432 : }
     527             : 
     528             : PHPAPI void
     529           1 : XML_SetProcessingInstructionHandler(XML_Parser parser, XML_ProcessingInstructionHandler pi)
     530             : {
     531           1 :         parser->h_pi = pi;
     532           1 : }
     533             : 
     534             : PHPAPI void
     535           0 : XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler comment)
     536             : {
     537           0 :         parser->h_comment = comment;
     538           0 : }
     539             : 
     540             : PHPAPI void 
     541           8 : XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler d)
     542             : {
     543           8 :         parser->h_default = d;
     544           8 : }
     545             : 
     546             : PHPAPI void
     547           1 : XML_SetUnparsedEntityDeclHandler(XML_Parser parser, XML_UnparsedEntityDeclHandler unparsed_decl)
     548             : {
     549           1 :         parser->h_unparsed_entity_decl = unparsed_decl;
     550           1 : }
     551             : 
     552             : PHPAPI void
     553           1 : XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler notation_decl)
     554             : {
     555           1 :         parser->h_notation_decl = notation_decl;
     556           1 : }
     557             : 
     558             : PHPAPI void
     559           0 : XML_SetExternalEntityRefHandler(XML_Parser parser, XML_ExternalEntityRefHandler ext_entity)
     560             : {
     561           0 :         parser->h_external_entity_ref = ext_entity;
     562           0 : }
     563             : 
     564             : PHPAPI void
     565           1 : XML_SetStartNamespaceDeclHandler(XML_Parser parser, XML_StartNamespaceDeclHandler start_ns)
     566             : {
     567           1 :         parser->h_start_ns = start_ns;
     568           1 : }
     569             : 
     570             : PHPAPI void
     571           1 : XML_SetEndNamespaceDeclHandler(XML_Parser parser, XML_EndNamespaceDeclHandler end_ns)
     572             : {
     573           1 :         parser->h_end_ns = end_ns;
     574           1 : }
     575             : 
     576             : PHPAPI int
     577        3624 : 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        3624 :         error = xmlParseChunk(parser->parser, data, data_len, is_final);
     606        3624 :         if (!error) {
     607        3608 :                 return 1;
     608          16 :         } else if (parser->parser->lastError.level > XML_ERR_WARNING ){
     609          16 :                 return 0;
     610             :         } else {
     611           0 :                 return 1;
     612             :         }
     613             : }
     614             : 
     615             : PHPAPI int
     616           8 : XML_GetErrorCode(XML_Parser parser)
     617             : {
     618           8 :         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             : PHPAPI const XML_Char *
     728          21 : XML_ErrorString(int code)
     729             : {
     730          21 :         if (code < 0 || code >= (int)(sizeof(error_mapping) / sizeof(error_mapping[0]))) {
     731           2 :                 return "Unknown";
     732             :         }
     733          19 :         return error_mapping[code];
     734             : }
     735             : 
     736             : PHPAPI int
     737           8 : XML_GetCurrentLineNumber(XML_Parser parser)
     738             : {
     739           8 :         return parser->parser->input->line;
     740             : }
     741             : 
     742             : PHPAPI int
     743           8 : XML_GetCurrentColumnNumber(XML_Parser parser)
     744             : {
     745           8 :         return parser->parser->input->col;
     746             : }
     747             : 
     748             : PHPAPI int
     749           8 : XML_GetCurrentByteIndex(XML_Parser parser)
     750             : {
     751          24 :         return parser->parser->input->consumed +
     752          16 :                         (parser->parser->input->cur - parser->parser->input->base);
     753             : }
     754             : 
     755             : PHPAPI int
     756           0 : XML_GetCurrentByteCount(XML_Parser parser)
     757             : {
     758             :         /* WARNING: this is identical to ByteIndex; it should probably
     759             :          * be different */
     760           0 :         return parser->parser->input->consumed +
     761           0 :                         (parser->parser->input->cur - parser->parser->input->base);
     762             : }
     763             : 
     764           0 : PHPAPI const XML_Char *XML_ExpatVersion(void)
     765             : {
     766           0 :         return "1.0";
     767             : }
     768             : 
     769             : PHPAPI void
     770         583 : XML_ParserFree(XML_Parser parser)
     771             : {
     772         583 :         if (parser->use_namespace) {
     773          24 :                 if (parser->_ns_seperator) {
     774          24 :                         xmlFree(parser->_ns_seperator);
     775             :                 }
     776             :         }
     777         583 :         if (parser->parser->myDoc) {
     778           0 :                 xmlFreeDoc(parser->parser->myDoc);
     779           0 :                 parser->parser->myDoc = NULL;
     780             :         }
     781         583 :         xmlFreeParserCtxt(parser->parser);
     782         583 :         efree(parser);
     783         583 : }
     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             :  */

Generated by: LCOV version 1.10

Generated at Tue, 02 Sep 2014 09:43:06 +0000 (11 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.