1 /*

     2  * libxml2_parser.c : an XML 1.0 parser, namespaces and validity support are mostly

     3  *                    implemented on top of the SAX interfaces

     4  *

     5  * References:

     6  *   The XML specification:

     7  *     http://www.w3.org/TR/REC-xml

     8  *   Original 1.0 version:

     9  *     http://www.w3.org/TR/1998/REC-xml-19980210

    10  *   XML second edition workingdraft

    11  *     http://www.w3.org/TR/2000/WD-xml-2e-20000814

    12  *

    13  * Okay this is a big file, the parser core is around 7000 lines, then it

    14  * is followed by the progressive parser top routines, then the various

    15  * high level APIs to call the parser and a few miscellaneous functions.

    16  * A number of helper functions and deprecated ones have been moved to

    17  * parserInternals.c to reduce this file size.

    18  * As much as possible the functions are associated with their relative

    19  * production in the XML specification. A few productions defining the

    20  * different ranges of character are actually implanted either in

    21  * parserInternals.h or parserInternals.c

    22  * The DOM tree build is realized from the default SAX callbacks in

    23  * the module SAX.c.

    24  * The routines doing the validation checks are in valid.c and called either

    25  * from the SAX callbacks or as standalone functions using a preparsed

    26  * document.

    27  *

    28  * See Copyright for the status of this software.

    29  *

    30  * daniel@veillard.com

    31  * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

    32  */

    33 

    34 #pragma warning(disable: 4127 4132)

    35 

    36 #define IN_LIBXML

    37 #include "xmlenglibxml.h"

    38 

    39 #if (defined(WIN32) || defined(__SYMBIAN32__)) && !defined (__CYGWIN__)

    40 #define XML_DIR_SEP '\\'

    41 #else

    42 #define XML_DIR_SEP '/'

    43 #endif

    44 

    45 #include <stdlib.h>

    46 #include <string.h>

    47 #include <stdarg.h>

    48 

    49 #include <stdapis/libxml2/libxml2_globals.h>

    50 #include <stdapis/libxml2/libxml2_parserinternals.h>

    51 #include "libxml2_errencoding.h"

    52 #include "libxml2_xmlerror2.h"

    53 #include <stdapis/libxml2/libxml2_uri.h>

    54 

    55 #ifdef LIBXML_CATALOG_ENABLED

    56 #include "libxml2_catalog.h"

    57 #endif

    58 

    59 #ifdef HAVE_CTYPE_H

    60 #include <ctype.h>

    61 #endif

    62 #ifdef HAVE_STDLIB_H

    63 #include <stdlib.h>

    64 #endif

    65 #ifdef HAVE_SYS_STAT_H

    66 #include <sys/stat.h>

    67 #endif

    68 #ifdef HAVE_FCNTL_H

    69 #include <fcntl.h>

    70 #endif

    71 #ifdef HAVE_UNISTD_H

    72 #include <unistd.h>

    73 #endif

    74 #ifdef HAVE_ZLIB_H

    75 #include <zlib.h>

    76 #endif

    77 

    78 #define SAX2 1

    79 

    80 #define XML_PARSER_BIG_BUFFER_SIZE 300

    81 #define XML_PARSER_BUFFER_SIZE 100

    82 

    83 

    84 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */

    85 xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,

    86                                        const xmlChar **str);

    87 

    88 static xmlParserErrors

    89 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,

    90                   xmlSAXHandlerPtr sax,

    91               void *user_data, int depth, const xmlChar *URL,

    92               const xmlChar *ID, xmlNodePtr *list);

    93 

    94 #ifdef LIBXML_LEGACY_ENABLED

    95 static void

    96 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,

    97                       xmlNodePtr lastNode);

    98 #endif /* LIBXML_LEGACY_ENABLED */

    99 

   100 static xmlParserErrors

   101 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,

   102               const xmlChar *string, void *user_data, xmlNodePtr *lst);

   103 

   104 /************************************************************************

   105  *                                                                      *

   106  *      Some factorized error routines                                  *

   107  *                                                                      *

   108  ************************************************************************/

   109 

   110 /**

   111  * xmlErrAttributeDup:

   112  * @param ctxt an XML parser context

   113  * @param prefix the attribute prefix

   114  * @param localname the attribute localname

   115  *

   116  * Handle a redefinition of attribute error

   117  */

   118 static void

   119 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,

   120                    const xmlChar * localname)

   121 {

   122     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   123         (ctxt->instate == XML_PARSER_EOF))

   124         return;

   125     ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;

   126     if (prefix == NULL) 

   127         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,

   128                         ctxt->errNo, XML_ERR_FATAL, NULL, 0,

   129                         (const char *) localname, NULL, NULL, 0, 0,

   130                         EMBED_ERRTXT("Attribute %s redefined\n"), localname);

   131     else

   132         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,

   133                         ctxt->errNo, XML_ERR_FATAL, NULL, 0,

   134                         (const char *) prefix, (const char *) localname,

   135                         NULL, 0, 0, EMBED_ERRTXT("Attribute %s:%s redefined\n"), prefix,

   136                         localname);

   137     ctxt->wellFormed = 0;

   138     if (ctxt->recovery == 0)

   139         ctxt->disableSAX = 1;

   140 }

   141 

   142 /**

   143  * xmlFatalErr:

   144  * @param ctxt an XML parser context

   145  * @param error the error number

   146  * @param extra extra information string

   147  *

   148  * Handle a fatal parser error, i.e. violating Well-Formedness constraints

   149  */

   150 static void

   151 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)

   152 {

   153     const char *errmsg;

   154 

   155     if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF))

   156         return;

   157 

   158 #ifdef XMLENGINE_EXCLUDE_EMBED_MSG

   159     errmsg = "Error message is not availabe\n";

   160 #else

   161     switch (error) { // DONE: Disable this SWITCH if EMBED_ERRTXT returns NULL

   162         case XML_ERR_INVALID_HEX_CHARREF:

   163             errmsg = EMBED_ERRTXT("CharRef: invalid hexadecimal value\n");

   164             break;

   165         case XML_ERR_INVALID_DEC_CHARREF:

   166             errmsg = EMBED_ERRTXT("CharRef: invalid decimal value\n");

   167             break;

   168         case XML_ERR_INVALID_CHARREF:

   169             errmsg = EMBED_ERRTXT("CharRef: invalid value\n");

   170             break;

   171         case XML_ERR_INTERNAL_ERROR:

   172             errmsg = EMBED_ERRTXT("internal error");

   173             break;

   174         case XML_ERR_PEREF_AT_EOF:

   175             errmsg = EMBED_ERRTXT("PEReference at end of document\n");

   176             break;

   177         case XML_ERR_PEREF_IN_PROLOG:

   178             errmsg = EMBED_ERRTXT("PEReference in prolog\n");

   179             break;

   180         case XML_ERR_PEREF_IN_EPILOG:

   181             errmsg = EMBED_ERRTXT("PEReference in epilog\n");

   182             break;

   183         case XML_ERR_PEREF_NO_NAME:

   184             errmsg = EMBED_ERRTXT("PEReference: no name\n");

   185             break;

   186         case XML_ERR_PEREF_SEMICOL_MISSING:

   187             errmsg = EMBED_ERRTXT("PEReference: expecting ';'\n");

   188             break;

   189         case XML_ERR_ENTITY_LOOP:

   190             errmsg = EMBED_ERRTXT("Detected an entity reference loop\n");

   191             break;

   192         case XML_ERR_ENTITY_NOT_STARTED:

   193             errmsg = EMBED_ERRTXT("EntityValue: \" or ' expected\n");

   194             break;

   195         case XML_ERR_ENTITY_PE_INTERNAL:

   196             errmsg = EMBED_ERRTXT("PEReferences forbidden in internal subset\n");

   197             break;

   198         case XML_ERR_ENTITY_NOT_FINISHED:

   199             errmsg = EMBED_ERRTXT("EntityValue: \" or ' expected\n");

   200             break;

   201         case XML_ERR_ATTRIBUTE_NOT_STARTED:

   202             errmsg = EMBED_ERRTXT("AttValue: \" or ' expected\n");

   203             break;

   204         case XML_ERR_LT_IN_ATTRIBUTE:

   205             errmsg = EMBED_ERRTXT("Unescaped '<' not allowed in attributes values\n");

   206             break;

   207         case XML_ERR_LITERAL_NOT_STARTED:

   208             errmsg = EMBED_ERRTXT("SystemLiteral \" or ' expected\n");

   209             break;

   210         case XML_ERR_LITERAL_NOT_FINISHED:

   211             errmsg = EMBED_ERRTXT("UnfinishedSystem or Public ID \" or ' expected\n");

   212             break;

   213         case XML_ERR_MISPLACED_CDATA_END:

   214             errmsg = EMBED_ERRTXT("Sequence ']]>' not allowed in content\n");

   215             break;

   216         case XML_ERR_URI_REQUIRED:

   217             errmsg = EMBED_ERRTXT("SYSTEM or PUBLIC, the URI is missing\n");

   218             break;

   219         case XML_ERR_PUBID_REQUIRED:

   220             errmsg = EMBED_ERRTXT("PUBLIC, the Public Identifier is missing\n");

   221             break;

   222         case XML_ERR_HYPHEN_IN_COMMENT:

   223             errmsg = EMBED_ERRTXT("Comment must not contain '--' (double-hyphen)\n");

   224             break;

   225         case XML_ERR_PI_NOT_STARTED:

   226             errmsg = EMBED_ERRTXT("xmlParsePI : no target name\n");

   227             break;

   228         case XML_ERR_RESERVED_XML_NAME:

   229             errmsg = EMBED_ERRTXT("Invalid PI name\n");

   230             break;

   231         case XML_ERR_NOTATION_NOT_STARTED:

   232             errmsg = EMBED_ERRTXT("NOTATION: Name expected here\n");

   233             break;

   234         case XML_ERR_NOTATION_NOT_FINISHED:

   235             errmsg = EMBED_ERRTXT("'>' required to close NOTATION declaration\n");

   236             break;

   237         case XML_ERR_VALUE_REQUIRED:

   238             errmsg = EMBED_ERRTXT("Entity value required\n");

   239             break;

   240         case XML_ERR_URI_FRAGMENT:

   241             errmsg = EMBED_ERRTXT("Fragment not allowed");

   242             break;

   243         case XML_ERR_ATTLIST_NOT_STARTED:

   244             errmsg = EMBED_ERRTXT("'(' required to start ATTLIST enumeration\n");

   245             break;

   246         case XML_ERR_NMTOKEN_REQUIRED:

   247             errmsg = EMBED_ERRTXT("NmToken expected in ATTLIST enumeration\n");

   248             break;

   249         case XML_ERR_ATTLIST_NOT_FINISHED:

   250             errmsg = EMBED_ERRTXT("')' required to finish ATTLIST enumeration\n");

   251             break;

   252         case XML_ERR_MIXED_NOT_STARTED:

   253             errmsg = EMBED_ERRTXT("MixedContentDecl : '|' or ')*' expected\n");

   254             break;

   255         case XML_ERR_PCDATA_REQUIRED:

   256             errmsg = EMBED_ERRTXT("MixedContentDecl : '#PCDATA' expected\n");

   257             break;

   258         case XML_ERR_ELEMCONTENT_NOT_STARTED:

   259             errmsg = EMBED_ERRTXT("ContentDecl : Name or '(' expected\n");

   260             break;

   261         case XML_ERR_ELEMCONTENT_NOT_FINISHED:

   262             errmsg = EMBED_ERRTXT("ContentDecl : ',' '|' or ')' expected\n");

   263             break;

   264         case XML_ERR_PEREF_IN_INT_SUBSET:

   265             errmsg =

   266                 EMBED_ERRTXT("PEReference: forbidden within markup decl in internal subset\n");

   267             break;

   268         case XML_ERR_GT_REQUIRED:

   269             errmsg =EMBED_ERRTXT("expected '>'\n");

   270             break;

   271         case XML_ERR_CONDSEC_INVALID:

   272             errmsg = EMBED_ERRTXT("XML conditional section '[' expected\n");

   273             break;

   274         case XML_ERR_EXT_SUBSET_NOT_FINISHED:

   275             errmsg = EMBED_ERRTXT("Content error in the external subset\n");

   276             break;

   277         case XML_ERR_CONDSEC_INVALID_KEYWORD:

   278             errmsg =

   279                 EMBED_ERRTXT("conditional section INCLUDE or IGNORE keyword expected\n");

   280             break;

   281         case XML_ERR_CONDSEC_NOT_FINISHED:

   282             errmsg = EMBED_ERRTXT("XML conditional section not closed\n");

   283             break;

   284         case XML_ERR_XMLDECL_NOT_STARTED:

   285             errmsg = EMBED_ERRTXT("Text declaration '<?xml' required\n");

   286             break;

   287         case XML_ERR_XMLDECL_NOT_FINISHED:

   288             errmsg = EMBED_ERRTXT("parsing XML declaration: '?>' expected\n");

   289             break;

   290         case XML_ERR_EXT_ENTITY_STANDALONE:

   291             errmsg = EMBED_ERRTXT("external parsed entities cannot be standalone\n");

   292             break;

   293         case XML_ERR_ENTITYREF_SEMICOL_MISSING:

   294             errmsg = EMBED_ERRTXT("EntityRef: expecting ';'\n");

   295             break;

   296         case XML_ERR_DOCTYPE_NOT_FINISHED:

   297             errmsg = EMBED_ERRTXT("DOCTYPE improperly terminated\n");

   298             break;

   299         case XML_ERR_LTSLASH_REQUIRED:

   300             errmsg = EMBED_ERRTXT("EndTag: '</' not found\n");

   301             break;

   302         case XML_ERR_EQUAL_REQUIRED:

   303             errmsg = EMBED_ERRTXT("expected '='\n");

   304             break;

   305         case XML_ERR_STRING_NOT_CLOSED:

   306             errmsg = EMBED_ERRTXT("String not closed expecting \" or '\n");

   307             break;

   308         case XML_ERR_STRING_NOT_STARTED:

   309             errmsg = EMBED_ERRTXT("String not started expecting ' or \"\n");

   310             break;

   311         case XML_ERR_ENCODING_NAME:

   312             errmsg = EMBED_ERRTXT("Invalid XML encoding name\n");

   313             break;

   314         case XML_ERR_STANDALONE_VALUE:

   315             errmsg = EMBED_ERRTXT("standalone accepts only 'yes' or 'no'\n");

   316             break;

   317         case XML_ERR_DOCUMENT_EMPTY:

   318             errmsg = EMBED_ERRTXT("Document is empty\n");

   319             break;

   320         case XML_ERR_DOCUMENT_END:

   321             errmsg = EMBED_ERRTXT("Extra content at the end of the document\n");

   322             break;

   323         case XML_ERR_NOT_WELL_BALANCED:

   324             errmsg = EMBED_ERRTXT("chunk is not well balanced\n");

   325             break;

   326         case XML_ERR_EXTRA_CONTENT:

   327             errmsg = EMBED_ERRTXT("extra content at the end of well balanced chunk\n");

   328             break;

   329         case XML_ERR_VERSION_MISSING:

   330             errmsg = EMBED_ERRTXT("Malformed declaration expecting version\n");

   331             break;

   332         case XML_ERR_STACK_LOW:

   333             errmsg = EMBED_ERRTXT("Thread's stack has reached critical level\n");

   334             break;            

   335 #if 0

   336         case:

   337             errmsg = "\n";

   338             break;

   339 #endif

   340         default:

   341             errmsg = EMBED_ERRTXT("Unregistered error message\n");

   342     }

   343 #endif /* !XMLENGINE_EXCLUDE_EMBED_MSG */

   344 

   345     ctxt->errNo = error;

   346     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,

   347                     XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, errmsg,

   348                     info);

   349     ctxt->wellFormed = 0;

   350     if (ctxt->recovery == 0)

   351         ctxt->disableSAX = 1;

   352 }

   353 

   354 /**

   355  * xmlFatalErrMsg:

   356  * @param ctxt an XML parser context

   357  * @param error the error number

   358  * @param msg the error message

   359  *

   360  * Handle a fatal parser error, i.e. violating Well-Formedness constraints

   361  */

   362 static void

   363 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,

   364                const char *msg)

   365 {

   366     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   367         (ctxt->instate == XML_PARSER_EOF))

   368     return;

   369     ctxt->errNo = error;

   370     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,

   371                     XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, msg);

   372     ctxt->wellFormed = 0;

   373     if (ctxt->recovery == 0)

   374         ctxt->disableSAX = 1;

   375 }

   376 

   377 /**

   378  * xmlWarningMsg:

   379  * @param ctxt an XML parser context

   380  * @param error the error number

   381  * @param msg the error message

   382  * @param str1 extra data

   383  * @param str2 extra data

   384  *

   385  * Handle a warning.

   386  */

   387 static void

   388 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,

   389               const char *msg, const xmlChar *str1, const xmlChar *str2)

   390 {

   391     xmlStructuredErrorFunc schannel = NULL;

   392 

   393     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   394         (ctxt->instate == XML_PARSER_EOF))

   395     return;

   396     ctxt->errNo = error;

   397     if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))

   398         schannel = ctxt->sax->serror;

   399     __xmlRaiseError(schannel,

   400                     (ctxt->sax) ? ctxt->sax->warning : NULL,

   401                     ctxt->userData,

   402                     ctxt, NULL, XML_FROM_PARSER, error,

   403                     XML_ERR_WARNING, NULL, 0,

   404             (const char *) str1, (const char *) str2, NULL, 0, 0,

   405             msg, (const char *) str1, (const char *) str2);

   406 }

   407 

   408 /**

   409  * xmlValidityError:

   410  * @param ctxt an XML parser context

   411  * @param error the error number

   412  * @param msg the error message

   413  * @param str1 extra data

   414  *

   415  * Handle a validity error.

   416  */

   417 static void

   418 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,

   419               const char *msg, const xmlChar *str1)

   420 {

   421     xmlStructuredErrorFunc schannel = NULL;

   422 

   423     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   424         (ctxt->instate == XML_PARSER_EOF))

   425     return;

   426     ctxt->errNo = error;

   427     if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))

   428         schannel = ctxt->sax->serror;

   429     __xmlRaiseError(schannel,

   430                     ctxt->vctxt.error, ctxt->vctxt.userData,

   431                     ctxt, NULL, XML_FROM_DTD, error,

   432                     XML_ERR_ERROR, NULL, 0, (const char *) str1,

   433             NULL, NULL, 0, 0,

   434             msg, (const char *) str1);

   435     ctxt->valid = 0;

   436 }

   437 

   438 /**

   439  * xmlFatalErrMsgInt:

   440  * @param ctxt an XML parser context

   441  * @param error the error number

   442  * @param msg the error message

   443  * @param val an integer value

   444  *

   445  * Handle a fatal parser error, i.e. violating Well-Formedness constraints

   446  */

   447 static void

   448 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,

   449                   const char *msg, int val)

   450 {

   451     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   452         (ctxt->instate == XML_PARSER_EOF))

   453     return;

   454     ctxt->errNo = error;

   455     __xmlRaiseError(NULL, NULL, NULL,

   456                     ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,

   457                     NULL, 0, NULL, NULL, NULL, val, 0, msg, val);

   458     ctxt->wellFormed = 0;

   459     if (ctxt->recovery == 0)

   460         ctxt->disableSAX = 1;

   461 }

   462 

   463 /**

   464  * xmlFatalErrMsgStrIntStr:

   465  * @param ctxt an XML parser context

   466  * @param error the error number

   467  * @param msg the error message

   468  * @param str1 an string info

   469  * @param val an integer value

   470  * @param str2 an string info

   471  *

   472  * Handle a fatal parser error, i.e. violating Well-Formedness constraints

   473  */

   474 static void

   475 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,

   476                   const char *msg, const xmlChar *str1, int val,

   477           const xmlChar *str2)

   478 {

   479     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   480         (ctxt->instate == XML_PARSER_EOF))

   481     return;

   482     ctxt->errNo = error;

   483     __xmlRaiseError(NULL, NULL, NULL,

   484                     ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,

   485                     NULL, 0, (const char *) str1, (const char *) str2,

   486             NULL, val, 0, msg, str1, val, str2);

   487     ctxt->wellFormed = 0;

   488     if (ctxt->recovery == 0)

   489         ctxt->disableSAX = 1;

   490 }

   491 

   492 /**

   493  * xmlFatalErrMsgStr:

   494  * @param ctxt an XML parser context

   495  * @param error the error number

   496  * @param msg the error message

   497  * @param val a string value

   498  *

   499  * Handle a fatal parser error, i.e. violating Well-Formedness constraints

   500  */

   501 static void

   502 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,

   503                   const char *msg, const xmlChar * val)

   504 {

   505     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   506         (ctxt->instate == XML_PARSER_EOF))

   507     return;

   508     ctxt->errNo = error;

   509     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,

   510                     XML_FROM_PARSER, error, XML_ERR_FATAL,

   511                     NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,

   512                     val);

   513     ctxt->wellFormed = 0;

   514     if (ctxt->recovery == 0)

   515         ctxt->disableSAX = 1;

   516 }

   517 

   518 /**

   519  * xmlErrMsgStr:

   520  * @param ctxt an XML parser context

   521  * @param error the error number

   522  * @param msg the error message

   523  * @param val a string value

   524  *

   525  * Handle a non fatal parser error

   526  */

   527 static void

   528 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,

   529                   const char *msg, const xmlChar * val)

   530 {

   531     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   532         (ctxt->instate == XML_PARSER_EOF))

   533     return;

   534     ctxt->errNo = error;

   535     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,

   536                     XML_FROM_PARSER, error, XML_ERR_ERROR,

   537                     NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,

   538                     val);

   539 }

   540 

   541 /**

   542  * xmlNsErr:

   543  * @param ctxt an XML parser context

   544  * @param error the error number

   545  * @param msg the message

   546  * @param info1 extra information string

   547  * @param info2 extra information string

   548  *

   549  * Handle a fatal parser error, i.e. violating Well-Formedness constraints

   550  */

   551 static void

   552 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,

   553          const char *msg,

   554          const xmlChar * info1, const xmlChar * info2,

   555          const xmlChar * info3)

   556 {

   557     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

   558         (ctxt->instate == XML_PARSER_EOF))

   559     return;

   560     ctxt->errNo = error;

   561     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,

   562                     XML_ERR_ERROR, NULL, 0, (const char *) info1,

   563                     (const char *) info2, (const char *) info3, 0, 0, msg,

   564                     info1, info2, info3);

   565     ctxt->nsWellFormed = 0;

   566 }

   567 

   568 // XMLENGINE: New code

   569 /**

   570  * xmlParserOOMErr:

   571  * @param ctxt an XML parser context

   572  *

   573  * Handle a OOM error during parsing XML;

   574  * parser is set into state that prevents further processing

   575  */

   576 static void

   577 xmlParserOOMErr(xmlParserCtxtPtr ctxt)

   578 {

   579     // Note: this function is mere a simpler (smaller) form to use

   580     // it should not change

   581     xmlErrMemory(ctxt, NULL);

   582 }

   583 //

   584 

   585 /**

   586  * xmlCheckCdataPush:

   587  * @param cur pointer to the bock of characters

   588  * @param len length of the block in bytes

   589  *

   590  * Check that the block of characters is okay as SCdata content [20]

   591  *

   592  * Returns the number of bytes to pass if okay, a negative index where an

   593  *         UTF-8 error occured otherwise

   594  */

   595 static int

   596 xmlCheckCdataPush(const xmlChar *utf, int len) {

   597     int ix;

   598     unsigned char c;

   599     int codepoint;

   600 

   601     if ((utf == NULL) || (len <= 0))

   602         return(0);

   603 

   604     for (ix = 0; ix < len;) {      /* string is 0-terminated */

   605         c = utf[ix];

   606         if ((c & 0x80) == 0x00) {   /* 1-byte code, starts with 10 */

   607         if (c >= 0x20)

   608         ix++;

   609         else if ((c == 0xA) || (c == 0xD) || (c == 0x9))

   610             ix++;

   611         else

   612             return(-ix);

   613     } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */

   614         if (ix + 2 > len) return(ix);

   615         if ((utf[ix+1] & 0xc0 ) != 0x80)

   616             return(-ix);

   617         codepoint = (utf[ix] & 0x1f) << 6;

   618         codepoint |= utf[ix+1] & 0x3f;

   619         if (!xmlIsCharQ(codepoint))

   620             return(-ix);

   621         ix += 2;

   622     } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */

   623         if (ix + 3 > len) return(ix);

   624         if (((utf[ix+1] & 0xc0) != 0x80) ||

   625             ((utf[ix+2] & 0xc0) != 0x80))

   626             return(-ix);

   627         codepoint = (utf[ix] & 0xf) << 12;

   628         codepoint |= (utf[ix+1] & 0x3f) << 6;

   629         codepoint |= utf[ix+2] & 0x3f;

   630         if (!xmlIsCharQ(codepoint))

   631             return(-ix);

   632         ix += 3;

   633     } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */

   634         if (ix + 4 > len) return(ix);

   635         if (((utf[ix+1] & 0xc0) != 0x80) ||

   636             ((utf[ix+2] & 0xc0) != 0x80) ||

   637         ((utf[ix+3] & 0xc0) != 0x80))

   638             return(-ix);

   639         codepoint = (utf[ix] & 0x7) << 18;

   640         codepoint |= (utf[ix+1] & 0x3f) << 12;

   641         codepoint |= (utf[ix+2] & 0x3f) << 6;

   642         codepoint |= utf[ix+3] & 0x3f;

   643         if (!xmlIsCharQ(codepoint))

   644             return(-ix);

   645         ix += 4;

   646     } else              /* unknown encoding */

   647         return(-ix);

   648       }

   649       return(ix);

   650 }

   651 

   652 /************************************************************************

   653  *                                                                      *

   654  *      SAX2 defaulted attributes handling                              *

   655  *                                                                      *

   656  ************************************************************************/

   657 

   658 /**

   659  * xmlDetectSAX2:

   660  * @param ctxt an XML parser context

   661  *

   662  * Do the SAX2 detection and specific intialization

   663  *

   664  * OOM: possible --> OOM flag is set

   665  */

   666 static void

   667 xmlDetectSAX2(xmlParserCtxtPtr ctxt)

   668 {

   669     if (!ctxt)

   670         return;

   671 #ifdef LIBXML_SAX1_ENABLED

   672     if ((ctxt->sax) &&  (ctxt->sax->initialized == XML_SAX2_MAGIC) &&

   673         ((ctxt->sax->startElementNs != NULL) ||

   674          (ctxt->sax->endElementNs != NULL)))

   675     {

   676         ctxt->sax2 = 1;

   677     }

   678 #else

   679     ctxt->sax2 = 1;

   680 #endif /* LIBXML_SAX1_ENABLED */

   681     // Each of these can end with OOM condition

   682     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);

   683     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);

   684     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);

   685     if(ctxt->sax && ctxt->sax->startElementNs == xmlSAX2StartElementNs)

   686 		{

   687 		ctxt->stackLowThreshold = MIN_STACK_THRESHOLD;

   688 		}

   689 	else

   690 		{

   691 		ctxt->stackLowThreshold = MAX_STACK_THRESHOLD;

   692 		}

   693 }

   694 

   695 typedef struct _xmlDefAttrs xmlDefAttrs;

   696 typedef xmlDefAttrs *xmlDefAttrsPtr;

   697 struct _xmlDefAttrs {

   698     int nbAttrs;    /* number of defaulted attributes on that element */

   699     int maxAttrs;       /* the size of the array */

   700     const xmlChar *values[4]; /* array of localname/prefix/values */

   701 };

   702 

   703 /**

   704  * xmlAddDefAttrs:

   705  * @param ctxt an XML parser context

   706  * @param fullname the element fullname

   707  * @param fullattr the attribute fullname

   708  * @param value the attribute value

   709  *

   710  * Add a defaulted attribute for an element

   711  */

   712 static void

   713 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,

   714                const xmlChar *fullname,

   715                const xmlChar *fullattr,

   716                const xmlChar *value)

   717 {

   718     xmlDefAttrsPtr defaults;

   719     int len;

   720     const xmlChar* name;

   721     const xmlChar* prefix;

   722     LOAD_GS_SAFE_CTXT(ctxt)

   723 

   724     if (ctxt->attsDefault == NULL) {

   725         ctxt->attsDefault = xmlHashCreate(10);

   726         if (ctxt->attsDefault == NULL)

   727             goto mem_error;

   728     }

   729 

   730     /*

   731      * split the element name into prefix:localname , the string found

   732      * are within the DTD and then not associated to namespace names.

   733      */

   734     name = xmlSplitQName3(fullname, &len);

   735     if (name == NULL) {

   736         name = xmlDictLookup(ctxt->dict, fullname, -1);

   737         prefix = NULL;

   738     } else {

   739         name = xmlDictLookup(ctxt->dict, name, -1);

   740         prefix = xmlDictLookup(ctxt->dict, fullname, len);

   741     }

   742 

   743     /*

   744      * make sure there is some storage

   745      */

   746     defaults = (xmlDefAttrsPtr)xmlHashLookup2(ctxt->attsDefault, name, prefix);

   747     if (defaults == NULL)

   748     {

   749         defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +

   750                                    12 * sizeof(const xmlChar *));

   751         if (defaults == NULL)

   752             goto mem_error;

   753         defaults->maxAttrs = 4;

   754         defaults->nbAttrs = 0;

   755         if ( xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL) == -1 ) 

   756             {

   757             xmlFree( defaults );

   758             return ;   

   759             }

   760         if ( OOM_FLAG )

   761             return ;

   762     }

   763     else if (defaults->nbAttrs >= defaults->maxAttrs)

   764     {

   765         // DONE: Fix xmlRealloc

   766         // NOTE: nothing to fix since 'defaults' is stored in hash table

   767         defaults = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +

   768                    (2 * defaults->maxAttrs * 4) * sizeof(const xmlChar*));

   769         if (defaults == NULL)

   770             goto mem_error;

   771         defaults->maxAttrs *= 2;

   772         if ( xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL) == -1 ) 

   773             {

   774             xmlFree( defaults );

   775             return ;   

   776             }

   777         if ( OOM_FLAG )

   778             return ;

   779     }

   780 

   781     /*

   782      * split the element name into prefix:localname , the string found

   783      * are within the DTD and then not associated to namespace names.

   784      */

   785     name = xmlSplitQName3(fullattr, &len);

   786     if (name == NULL) {

   787         name = xmlDictLookup(ctxt->dict, fullattr, -1);

   788         prefix = NULL;

   789     } else {

   790         name = xmlDictLookup(ctxt->dict, name, -1);

   791         prefix = xmlDictLookup(ctxt->dict, fullattr, len);

   792     }

   793 

   794     defaults->values[4 * defaults->nbAttrs] = name;

   795     defaults->values[4 * defaults->nbAttrs + 1] = prefix;

   796     /* intern the string and precompute the end */

   797     len = xmlStrlen(value);

   798     value = xmlDictLookup(ctxt->dict, value, len);

   799     defaults->values[4 * defaults->nbAttrs + 2] = value;

   800     defaults->values[4 * defaults->nbAttrs + 3] = value + len;

   801     defaults->nbAttrs++;

   802 

   803     return;

   804 

   805 mem_error:

   806     xmlErrMemory(ctxt, NULL);

   807     return;

   808 }

   809 

   810 /**

   811  * xmlAddSpecialAttr:

   812  * @param ctxt an XML parser context

   813  * @param fullname the element fullname

   814  * @param fullattr the attribute fullname

   815  * @param type the attribute type

   816  *

   817  * Register that this attribute is not CDATA

   818  */

   819 static void

   820 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,

   821           const xmlChar *fullname,

   822           const xmlChar *fullattr,

   823           int type)

   824 {

   825     if (ctxt->attsSpecial == NULL) {

   826         ctxt->attsSpecial = xmlHashCreate(10);

   827     if (ctxt->attsSpecial == NULL)

   828         goto mem_error;

   829     }

   830 

   831     xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,

   832                      (void *) (long) type);

   833     return;

   834 

   835 mem_error:

   836     xmlParserOOMErr(ctxt);

   837     return;

   838 }

   839 

   840 /**

   841  * xmlCheckLanguageID:

   842  * @param lang pointer to the string value

   843  *

   844  * Checks that the value conforms to the LanguageID production:

   845  *

   846  * NOTE: this is somewhat deprecated, those productions were removed from

   847  *       the XML Second edition.

   848  *

   849  * [33] LanguageID ::= Langcode ('-' Subcode)*

   850  * [34] Langcode ::= ISO639Code |  IanaCode |  UserCode

   851  * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z])

   852  * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+

   853  * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+

   854  * [38] Subcode ::= ([a-z] | [A-Z])+

   855  *

   856  * Returns 1 if correct 0 otherwise

   857  **/

   858 XMLPUBFUNEXPORT int

   859 xmlCheckLanguageID(const xmlChar * lang)

   860 {

   861     const xmlChar *cur = lang;

   862 

   863     if (cur == NULL)

   864         return (0);

   865     if (((cur[0] == 'i') && (cur[1] == '-')) ||

   866         ((cur[0] == 'I') && (cur[1] == '-'))) {

   867         /*

   868          * IANA code

   869          */

   870         cur += 2;

   871         while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||  /* non input consuming */

   872                ((cur[0] >= 'a') && (cur[0] <= 'z')))

   873             cur++;

   874     } else if (((cur[0] == 'x') && (cur[1] == '-')) ||

   875                ((cur[0] == 'X') && (cur[1] == '-'))) {

   876         /*

   877          * User code

   878          */

   879         cur += 2;

   880         while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||  /* non input consuming */

   881                ((cur[0] >= 'a') && (cur[0] <= 'z')))

   882             cur++;

   883     } else if (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||

   884                ((cur[0] >= 'a') && (cur[0] <= 'z'))) {

   885         /*

   886          * ISO639

   887          */

   888         cur++;

   889         if (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||

   890             ((cur[0] >= 'a') && (cur[0] <= 'z')))

   891             cur++;

   892         else

   893             return (0);

   894     } else

   895         return (0);

   896     while (cur[0] != 0) {       /* non input consuming */

   897         if (cur[0] != '-')

   898             return (0);

   899         cur++;

   900         if (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||

   901             ((cur[0] >= 'a') && (cur[0] <= 'z')))

   902             cur++;

   903         else

   904             return (0);

   905         while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||  /* non input consuming */

   906                ((cur[0] >= 'a') && (cur[0] <= 'z')))

   907             cur++;

   908     }

   909     return (1);

   910 }

   911 

   912 /************************************************************************

   913  *                                                                      *

   914  *      Parser stacks related functions and macros                      *

   915  *                                                                      *

   916  ************************************************************************/

   917 

   918 xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,

   919                                      const xmlChar** str);

   920 

   921 #ifdef SAX2

   922 /**

   923  * nsPush:

   924  * @param ctxt an XML parser context

   925  * @param prefix the namespace prefix or NULL

   926  * @param URL the namespace name

   927  *

   928  * Pushes a new parser namespace on top of the ns stack

   929  *

   930  * Returns -1 in case of error, -2 if the namespace should be discarded

   931  *     and the index in the stack otherwise.

   932  */

   933 static int

   934 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)

   935 {

   936     if (ctxt->options & XML_PARSE_NSCLEAN)

   937     {

   938         int i;

   939         for (i = 0; i < ctxt->nsNr; i += 2)

   940         {

   941             if (ctxt->nsTab[i] == prefix)

   942             {

   943                 /* in scope */

   944                 if (ctxt->nsTab[i + 1] == URL)

   945                     return(-2);

   946                 /* out of scope keep it */

   947                 break;

   948             }

   949         }

   950     }

   951     if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {

   952     ctxt->nsMax = 10; 

   953     ctxt->nsNr = 0;

   954     

   955     ctxt->nsTab = (const xmlChar **)

   956                   xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));

   957     if (ctxt->nsTab == NULL) {

   958         xmlParserOOMErr(ctxt);

   959         ctxt->nsMax = 0;

   960             return (-1);

   961     }

   962     } else if (ctxt->nsNr >= ctxt->nsMax) {

   963         const xmlChar** largerTab;

   964 

   965         ctxt->nsMax *= 2;

   966         // DONE: Fix memory leak here (when realloc returns NULL)

   967         largerTab = (const xmlChar **)

   968                   xmlRealloc((char *) ctxt->nsTab,

   969                  ctxt->nsMax * sizeof(ctxt->nsTab[0]));

   970         if (!largerTab) {

   971             xmlParserOOMErr(ctxt);

   972             ctxt->nsMax /= 2;

   973             return (-1);

   974         }

   975         ctxt->nsTab = largerTab;

   976     }

   977     ctxt->nsTab[ctxt->nsNr++] = prefix;

   978     ctxt->nsTab[ctxt->nsNr++] = URL;

   979 // XE: BEGIN NEW CODE

   980     /*

   981     * SAX: prefix mapping !

   982     */

   983     if ((ctxt->sax != NULL) &&

   984         (ctxt->sax->startPrefixMapping != NULL) &&

   985         (!ctxt->disableSAX))

   986     {

   987         ctxt->sax->startPrefixMapping(ctxt->userData, prefix, URL);

   988     }

   989 // XE: END NEW CODE

   990     return (ctxt->nsNr);

   991 }

   992 /**

   993  * nsPop:

   994  * @param ctxt an XML parser context

   995  * @param nr the number to pop

   996  *

   997  * Pops the top nr parser prefix/namespace from the ns stack

   998  *

   999  * Returns the number of namespaces removed

  1000  */

  1001 static int

  1002 nsPop(xmlParserCtxtPtr ctxt, int nr)

  1003 {

  1004     int i;

  1005 	

  1006     if (ctxt->nsTab == NULL) return(0);

  1007     if (ctxt->nsNr < nr) {

  1008         xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("Pbm popping %d NS\n"), nr);

  1009         nr = ctxt->nsNr;

  1010     }

  1011     if (ctxt->nsNr <= 0)

  1012         return (0);

  1013 

  1014 // XE: REPLACED CODE

  1015     //for (i = 0;i < nr;i++) {

  1016     // nr is even number, because pairs of (URL,prefix) are removed from ctxt->nsTab[] array

  1017     // by this moment ctxt->nsNr points to the next free cell after  ...{prefix}{URL}{..}...

  1018     //                                                  ctxt->nsTab[ctxt->nsNr]-------^

  1019 // XE: REPLACED WITH

  1020     for (i = nr/2; i > 0; i--) {

  1021          ctxt->nsNr--;

  1022          ctxt->nsTab[ctxt->nsNr] = NULL; // clean up URL

  1023          ctxt->nsNr--;

  1024 // XE: BEGIN NEW CODE

  1025         

  1026         /*

  1027         * SAX: end of prefix mapping !

  1028         */

  1029         if ((ctxt->sax != NULL) &&

  1030             (ctxt->sax->endPrefixMapping != NULL) &&

  1031             (!ctxt->disableSAX))

  1032         {

  1033             ctxt->sax->endPrefixMapping(ctxt->userData, ctxt->nsTab[ctxt->nsNr]);

  1034         }

  1035 // XE: END NEW CODE

  1036          ctxt->nsTab[ctxt->nsNr] = NULL; // clean up prefix name

  1037 

  1038          

  1039     }

  1040     return(nr);

  1041 }

  1042 #endif

  1043 

  1044 static int

  1045 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {

  1046     const xmlChar **atts;

  1047     int *attallocs;

  1048     int maxatts;

  1049 

  1050     if (ctxt->atts == NULL) {

  1051     maxatts = 55; /* allow for 10 attrs by default */

  1052     atts = (const xmlChar **)

  1053            xmlMalloc(maxatts * sizeof(xmlChar *));

  1054     if (atts == NULL) goto mem_error;

  1055     ctxt->atts = atts;

  1056     attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int));

  1057     if (attallocs == NULL) goto mem_error;

  1058     ctxt->attallocs = attallocs;

  1059     ctxt->maxatts = maxatts;

  1060     } else if (nr + 5 > ctxt->maxatts) {

  1061     maxatts = (nr + 5) * 2;

  1062     atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,

  1063                      maxatts * sizeof(const xmlChar *));

  1064     if (atts == NULL) goto mem_error;

  1065     ctxt->atts = atts;

  1066     attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,

  1067                                  (maxatts / 5) * sizeof(int));

  1068     if (attallocs == NULL) goto mem_error;

  1069     ctxt->attallocs = attallocs;

  1070     ctxt->maxatts = maxatts;

  1071     }

  1072     return(ctxt->maxatts);

  1073 mem_error:

  1074     xmlParserOOMErr(ctxt);

  1075     return(-1);

  1076 }

  1077 

  1078 /**

  1079  * inputPush:

  1080  * @param ctxt an XML parser context

  1081  * @param value the parser input

  1082  *

  1083  * Pushes a new parser input on top of the input stack

  1084  *

  1085  * Returns -1 in case of error, the index in the stack otherwise

  1086  *

  1087  * OOM: possible --> returns -1 and OOM flag is set

  1088  */

  1089 XMLPUBFUNEXPORT int

  1090 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)

  1091 {

  1092     if (ctxt->inputNr >= ctxt->inputMax)

  1093     {

  1094         // DONE: Fix xmlRealloc

  1095         void* tmp;

  1096         ctxt->inputMax *= 2;

  1097         tmp = xmlRealloc(ctxt->inputTab,

  1098                          ctxt->inputMax * sizeof(ctxt->inputTab[0]));

  1099         if (!tmp) {

  1100             ctxt->inputMax /= 2;

  1101             xmlParserOOMErr(ctxt);

  1102             return (-1);

  1103         }

  1104         ctxt->inputTab = (xmlParserInputPtr*) tmp;

  1105     }

  1106     ctxt->inputTab[ctxt->inputNr] = value;

  1107     ctxt->input = value;

  1108     return (ctxt->inputNr++);

  1109 }

  1110 

  1111 /**

  1112  * inputPop:

  1113  * @param ctxt an XML parser context

  1114  *

  1115  * Pops the top parser input from the input stack

  1116  *

  1117  * Returns the input just removed

  1118  */

  1119 XMLPUBFUNEXPORT xmlParserInputPtr

  1120 inputPop(xmlParserCtxtPtr ctxt)

  1121 {

  1122     xmlParserInputPtr ret;

  1123 

  1124     if (ctxt->inputNr <= 0)

  1125         return (0);

  1126     ctxt->inputNr--;

  1127     if (ctxt->inputNr > 0)

  1128         ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];

  1129     else

  1130         ctxt->input = NULL;

  1131     ret = ctxt->inputTab[ctxt->inputNr];

  1132     ctxt->inputTab[ctxt->inputNr] = 0;

  1133     return (ret);

  1134 }

  1135 /**