contrib/expat/lib/xmlparse.c

   1 /* 5ab094ffadd6edfc94c3eee53af44a86951f9f1f0933ada3114bbce2bfb02c99 (2.5.0+)
   2                             __  __            _
   3                          ___\ \/ /_ __   __ _| |_
   4                         / _ \\  /| '_ \ / _` | __|
   5                        |  __//  \| |_) | (_| | |_
   6                         \___/_/\_\ .__/ \__,_|\__|
   7                                  |_| XML parser
   8
   9    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
  10    Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
  11    Copyright (c) 2000-2006 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
  12    Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
  13    Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
  14    Copyright (c) 2005-2009 Steven Solie <steven@solie.ca>
  15    Copyright (c) 2016      Eric Rahm <erahm@mozilla.com>
  16    Copyright (c) 2016-2022 Sebastian Pipping <sebastian@pipping.org>
  17    Copyright (c) 2016      Gaurav <g.gupta@samsung.com>
  18    Copyright (c) 2016      Thomas Beutlich <tc@tbeu.de>
  19    Copyright (c) 2016      Gustavo Grieco <gustavo.grieco@imag.fr>
  20    Copyright (c) 2016      Pascal Cuoq <cuoq@trust-in-soft.com>
  21    Copyright (c) 2016      Ed Schouten <ed@nuxi.nl>
  22    Copyright (c) 2017-2022 Rhodri James <rhodri@wildebeest.org.uk>
  23    Copyright (c) 2017      Václav Slavík <vaclav@slavik.io>
  24    Copyright (c) 2017      Viktor Szakats <commit@vsz.me>
  25    Copyright (c) 2017      Chanho Park <chanho61.park@samsung.com>
  26    Copyright (c) 2017      Rolf Eike Beer <eike@sf-mail.de>
  27    Copyright (c) 2017      Hans Wennborg <hans@chromium.org>
  28    Copyright (c) 2018      Anton Maklakov <antmak.pub@gmail.com>
  29    Copyright (c) 2018      Benjamin Peterson <benjamin@python.org>
  30    Copyright (c) 2018      Marco Maggi <marco.maggi-ipsu@poste.it>
  31    Copyright (c) 2018      Mariusz Zaborski <oshogbo@vexillium.org>
  32    Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
  33    Copyright (c) 2019-2020 Ben Wagner <bungeman@chromium.org>
  34    Copyright (c) 2019      Vadim Zeitlin <vadim@zeitlins.org>
  35    Copyright (c) 2021      Dong-hee Na <donghee.na@python.org>
  36    Copyright (c) 2022      Samanta Navarro <ferivoz@riseup.net>
  37    Copyright (c) 2022      Jeffrey Walton <noloader@gmail.com>
  38    Copyright (c) 2022      Jann Horn <jannh@google.com>
  39    Licensed under the MIT license:
  40
  41    Permission is  hereby granted,  free of charge,  to any  person obtaining
  42    a  copy  of  this  software   and  associated  documentation  files  (the
  43    "Software"),  to  deal in  the  Software  without restriction,  including
  44    without  limitation the  rights  to use,  copy,  modify, merge,  publish,
  45    distribute, sublicense, and/or sell copies of the Software, and to permit
  46    persons  to whom  the Software  is  furnished to  do so,  subject to  the
  47    following conditions:
  48
  49    The above copyright  notice and this permission notice  shall be included
  50    in all copies or substantial portions of the Software.
  51
  52    THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
  53    EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
  54    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  55    NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  56    DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
  57    OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  58    USE OR OTHER DEALINGS IN THE SOFTWARE.
  59 */
  60
  61 #define XML_BUILDING_EXPAT 1
  62
  63 #include <expat_config.h>
  64
  65 #if ! defined(_GNU_SOURCE)
  66 #  define _GNU_SOURCE 1 /* syscall prototype */
  67 #endif
  68
  69 #ifdef _WIN32
  70 /* force stdlib to define rand_s() */
  71 #  if ! defined(_CRT_RAND_S)
  72 #    define _CRT_RAND_S
  73 #  endif
  74 #endif
  75
  76 #include <stddef.h>
  77 #include <string.h> /* memset(), memcpy() */
  78 #include <assert.h>
  79 #include <limits.h> /* UINT_MAX */
  80 #include <stdio.h>  /* fprintf */
  81 #include <stdlib.h> /* getenv, rand_s */
  82 #include <stdint.h> /* uintptr_t */
  83 #include <math.h>   /* isnan */
  84
  85 #ifdef _WIN32
  86 #  define getpid GetCurrentProcessId
  87 #else
  88 #  include <sys/time.h>  /* gettimeofday() */
  89 #  include <sys/types.h> /* getpid() */
  90 #  include <unistd.h>    /* getpid() */
  91 #  include <fcntl.h>     /* O_RDONLY */
  92 #  include <errno.h>
  93 #endif
  94
  95 #ifdef _WIN32
  96 #  include "winconfig.h"
  97 #endif
  98
  99 #include "ascii.h"
 100 #include "expat.h"
 101 #include "siphash.h"
 102
 103 #if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
 104 #  if defined(HAVE_GETRANDOM)
 105 #    include <sys/random.h> /* getrandom */
 106 #  else
 107 #    include <unistd.h>      /* syscall */
 108 #    include <sys/syscall.h> /* SYS_getrandom */
 109 #  endif
 110 #  if ! defined(GRND_NONBLOCK)
 111 #    define GRND_NONBLOCK 0x0001
 112 #  endif /* defined(GRND_NONBLOCK) */
 113 #endif   /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
 114
 115 #if defined(HAVE_LIBBSD)                                                       \
 116     && (defined(HAVE_ARC4RANDOM_BUF) || defined(HAVE_ARC4RANDOM))
 117 #  include <bsd/stdlib.h>
 118 #endif
 119
 120 #if defined(_WIN32) && ! defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
 121 #  define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
 122 #endif
 123
 124 #if ! defined(HAVE_GETRANDOM) && ! defined(HAVE_SYSCALL_GETRANDOM)             \
 125     && ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)            \
 126     && ! defined(XML_DEV_URANDOM) && ! defined(_WIN32)                         \
 127     && ! defined(XML_POOR_ENTROPY)
 128 #  error You do not have support for any sources of high quality entropy \
 129     enabled.  For end user security, that is probably not what you want. \
 130     \
 131     Your options include: \
 132       * Linux >=3.17 + glibc >=2.25 (getrandom): HAVE_GETRANDOM, \
 133       * Linux >=3.17 + glibc (including <2.25) (syscall SYS_getrandom): HAVE_SYSCALL_GETRANDOM, \
 134       * BSD / macOS >=10.7 (arc4random_buf): HAVE_ARC4RANDOM_BUF, \
 135       * BSD / macOS (including <10.7) (arc4random): HAVE_ARC4RANDOM, \
 136       * libbsd (arc4random_buf): HAVE_ARC4RANDOM_BUF + HAVE_LIBBSD, \
 137       * libbsd (arc4random): HAVE_ARC4RANDOM + HAVE_LIBBSD, \
 138       * Linux (including <3.17) / BSD / macOS (including <10.7) / Solaris >=8 (/dev/urandom): XML_DEV_URANDOM, \
 139       * Windows >=Vista (rand_s): _WIN32. \
 140     \
 141     If insist on not using any of these, bypass this error by defining \
 142     XML_POOR_ENTROPY; you have been warned. \
 143     \
 144     If you have reasons to patch this detection code away or need changes \
 145     to the build system, please open a bug.  Thank you!
 146 #endif
 147
 148 #ifdef XML_UNICODE
 149 #  define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
 150 #  define XmlConvert XmlUtf16Convert
 151 #  define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
 152 #  define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
 153 #  define XmlEncode XmlUtf16Encode
 154 #  define MUST_CONVERT(enc, s) (! (enc)->isUtf16 || (((uintptr_t)(s)) & 1))
 155 typedef unsigned short ICHAR;
 156 #else
 157 #  define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
 158 #  define XmlConvert XmlUtf8Convert
 159 #  define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
 160 #  define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
 161 #  define XmlEncode XmlUtf8Encode
 162 #  define MUST_CONVERT(enc, s) (! (enc)->isUtf8)
 163 typedef char ICHAR;
 164 #endif
 165
 166 #ifndef XML_NS
 167
 168 #  define XmlInitEncodingNS XmlInitEncoding
 169 #  define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
 170 #  undef XmlGetInternalEncodingNS
 171 #  define XmlGetInternalEncodingNS XmlGetInternalEncoding
 172 #  define XmlParseXmlDeclNS XmlParseXmlDecl
 173
 174 #endif
 175
 176 #ifdef XML_UNICODE
 177
 178 #  ifdef XML_UNICODE_WCHAR_T
 179 #    define XML_T(x) (const wchar_t) x
 180 #    define XML_L(x) L##x
 181 #  else
 182 #    define XML_T(x) (const unsigned short)x
 183 #    define XML_L(x) x
 184 #  endif
 185
 186 #else
 187
 188 #  define XML_T(x) x
 189 #  define XML_L(x) x
 190
 191 #endif
 192
 193 /* Round up n to be a multiple of sz, where sz is a power of 2. */
 194 #define ROUND_UP(n, sz) (((n) + ((sz)-1)) & ~((sz)-1))
 195
 196 /* Do safe (NULL-aware) pointer arithmetic */
 197 #define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0)
 198
 199 #include "internal.h"
 200 #include "xmltok.h"
 201 #include "xmlrole.h"
 202
 203 typedef const XML_Char *KEY;
 204
 205 typedef struct {
 206   KEY name;
 207 } NAMED;
 208
 209 typedef struct {
 210   NAMED **v;
 211   unsigned char power;
 212   size_t size;
 213   size_t used;
 214   const XML_Memory_Handling_Suite *mem;
 215 } HASH_TABLE;
 216
 217 static size_t keylen(KEY s);
 218
 219 static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);
 220
 221 /* For probing (after a collision) we need a step size relative prime
 222    to the hash table size, which is a power of 2. We use double-hashing,
 223    since we can calculate a second hash value cheaply by taking those bits
 224    of the first hash value that were discarded (masked out) when the table
 225    index was calculated: index = hash & mask, where mask = table->size - 1.
 226    We limit the maximum step size to table->size / 4 (mask >> 2) and make
 227    it odd, since odd numbers are always relative prime to a power of 2.
 228 */
 229 #define SECOND_HASH(hash, mask, power)                                         \
 230   ((((hash) & ~(mask)) >> ((power)-1)) & ((mask) >> 2))
 231 #define PROBE_STEP(hash, mask, power)                                          \
 232   ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
 233
 234 typedef struct {
 235   NAMED **p;
 236   NAMED **end;
 237 } HASH_TABLE_ITER;
 238
 239 #define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */
 240 #define INIT_DATA_BUF_SIZE 1024
 241 #define INIT_ATTS_SIZE 16
 242 #define INIT_ATTS_VERSION 0xFFFFFFFF
 243 #define INIT_BLOCK_SIZE 1024
 244 #define INIT_BUFFER_SIZE 1024
 245
 246 #define EXPAND_SPARE 24
 247
 248 typedef struct binding {
 249   struct prefix *prefix;
 250   struct binding *nextTagBinding;
 251   struct binding *prevPrefixBinding;
 252   const struct attribute_id *attId;
 253   XML_Char *uri;
 254   int uriLen;
 255   int uriAlloc;
 256 } BINDING;
 257
 258 typedef struct prefix {
 259   const XML_Char *name;
 260   BINDING *binding;
 261 } PREFIX;
 262
 263 typedef struct {
 264   const XML_Char *str;
 265   const XML_Char *localPart;
 266   const XML_Char *prefix;
 267   int strLen;
 268   int uriLen;
 269   int prefixLen;
 270 } TAG_NAME;
 271
 272 /* TAG represents an open element.
 273    The name of the element is stored in both the document and API
 274    encodings.  The memory buffer 'buf' is a separately-allocated
 275    memory area which stores the name.  During the XML_Parse()/
 276    XMLParseBuffer() when the element is open, the memory for the 'raw'
 277    version of the name (in the document encoding) is shared with the
 278    document buffer.  If the element is open across calls to
 279    XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to
 280    contain the 'raw' name as well.
 281
 282    A parser re-uses these structures, maintaining a list of allocated
 283    TAG objects in a free list.
 284 */
 285 typedef struct tag {
 286   struct tag *parent;  /* parent of this element */
 287   const char *rawName; /* tagName in the original encoding */
 288   int rawNameLength;
 289   TAG_NAME name; /* tagName in the API encoding */
 290   char *buf;     /* buffer for name components */
 291   char *bufEnd;  /* end of the buffer */
 292   BINDING *bindings;
 293 } TAG;
 294
 295 typedef struct {
 296   const XML_Char *name;
 297   const XML_Char *textPtr;
 298   int textLen;   /* length in XML_Chars */
 299   int processed; /* # of processed bytes - when suspended */
 300   const XML_Char *systemId;
 301   const XML_Char *base;
 302   const XML_Char *publicId;
 303   const XML_Char *notation;
 304   XML_Bool open;
 305   XML_Bool is_param;
 306   XML_Bool is_internal; /* true if declared in internal subset outside PE */
 307 } ENTITY;
 308
 309 typedef struct {
 310   enum XML_Content_Type type;
 311   enum XML_Content_Quant quant;
 312   const XML_Char *name;
 313   int firstchild;
 314   int lastchild;
 315   int childcnt;
 316   int nextsib;
 317 } CONTENT_SCAFFOLD;
 318
 319 #define INIT_SCAFFOLD_ELEMENTS 32
 320
 321 typedef struct block {
 322   struct block *next;
 323   int size;
 324   XML_Char s[1];
 325 } BLOCK;
 326
 327 typedef struct {
 328   BLOCK *blocks;
 329   BLOCK *freeBlocks;
 330   const XML_Char *end;
 331   XML_Char *ptr;
 332   XML_Char *start;
 333   const XML_Memory_Handling_Suite *mem;
 334 } STRING_POOL;
 335
 336 /* The XML_Char before the name is used to determine whether
 337    an attribute has been specified. */
 338 typedef struct attribute_id {
 339   XML_Char *name;
 340   PREFIX *prefix;
 341   XML_Bool maybeTokenized;
 342   XML_Bool xmlns;
 343 } ATTRIBUTE_ID;
 344
 345 typedef struct {
 346   const ATTRIBUTE_ID *id;
 347   XML_Bool isCdata;
 348   const XML_Char *value;
 349 } DEFAULT_ATTRIBUTE;
 350
 351 typedef struct {
 352   unsigned long version;
 353   unsigned long hash;
 354   const XML_Char *uriName;
 355 } NS_ATT;
 356
 357 typedef struct {
 358   const XML_Char *name;
 359   PREFIX *prefix;
 360   const ATTRIBUTE_ID *idAtt;
 361   int nDefaultAtts;
 362   int allocDefaultAtts;
 363   DEFAULT_ATTRIBUTE *defaultAtts;
 364 } ELEMENT_TYPE;
 365
 366 typedef struct {
 367   HASH_TABLE generalEntities;
 368   HASH_TABLE elementTypes;
 369   HASH_TABLE attributeIds;
 370   HASH_TABLE prefixes;
 371   STRING_POOL pool;
 372   STRING_POOL entityValuePool;
 373   /* false once a parameter entity reference has been skipped */
 374   XML_Bool keepProcessing;
 375   /* true once an internal or external PE reference has been encountered;
 376      this includes the reference to an external subset */
 377   XML_Bool hasParamEntityRefs;
 378   XML_Bool standalone;
 379 #ifdef XML_DTD
 380   /* indicates if external PE has been read */
 381   XML_Bool paramEntityRead;
 382   HASH_TABLE paramEntities;
 383 #endif /* XML_DTD */
 384   PREFIX defaultPrefix;
 385   /* === scaffolding for building content model === */
 386   XML_Bool in_eldecl;
 387   CONTENT_SCAFFOLD *scaffold;
 388   unsigned contentStringLen;
 389   unsigned scaffSize;
 390   unsigned scaffCount;
 391   int scaffLevel;
 392   int *scaffIndex;
 393 } DTD;
 394
 395 typedef struct open_internal_entity {
 396   const char *internalEventPtr;
 397   const char *internalEventEndPtr;
 398   struct open_internal_entity *next;
 399   ENTITY *entity;
 400   int startTagLevel;
 401   XML_Bool betweenDecl; /* WFC: PE Between Declarations */
 402 } OPEN_INTERNAL_ENTITY;
 403
 404 enum XML_Account {
 405   XML_ACCOUNT_DIRECT,           /* bytes directly passed to the Expat parser */
 406   XML_ACCOUNT_ENTITY_EXPANSION, /* intermediate bytes produced during entity
 407                                    expansion */
 408   XML_ACCOUNT_NONE              /* i.e. do not account, was accounted already */
 409 };
 410
 411 #ifdef XML_DTD
 412 typedef unsigned long long XmlBigCount;
 413 typedef struct accounting {
 414   XmlBigCount countBytesDirect;
 415   XmlBigCount countBytesIndirect;
 416   int debugLevel;
 417   float maximumAmplificationFactor; // >=1.0
 418   unsigned long long activationThresholdBytes;
 419 } ACCOUNTING;
 420
 421 typedef struct entity_stats {
 422   unsigned int countEverOpened;
 423   unsigned int currentDepth;
 424   unsigned int maximumDepthSeen;
 425   int debugLevel;
 426 } ENTITY_STATS;
 427 #endif /* XML_DTD */
 428
 429 typedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,
 430                                          const char *end, const char **endPtr);
 431
 432 static Processor prologProcessor;
 433 static Processor prologInitProcessor;
 434 static Processor contentProcessor;
 435 static Processor cdataSectionProcessor;
 436 #ifdef XML_DTD
 437 static Processor ignoreSectionProcessor;
 438 static Processor externalParEntProcessor;
 439 static Processor externalParEntInitProcessor;
 440 static Processor entityValueProcessor;
 441 static Processor entityValueInitProcessor;
 442 #endif /* XML_DTD */
 443 static Processor epilogProcessor;
 444 static Processor errorProcessor;
 445 static Processor externalEntityInitProcessor;
 446 static Processor externalEntityInitProcessor2;
 447 static Processor externalEntityInitProcessor3;
 448 static Processor externalEntityContentProcessor;
 449 static Processor internalEntityProcessor;
 450
 451 static enum XML_Error handleUnknownEncoding(XML_Parser parser,
 452                                             const XML_Char *encodingName);
 453 static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
 454                                      const char *s, const char *next);
 455 static enum XML_Error initializeEncoding(XML_Parser parser);
 456 static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
 457                                const char *s, const char *end, int tok,
 458                                const char *next, const char **nextPtr,
 459                                XML_Bool haveMore, XML_Bool allowClosingDoctype,
 460                                enum XML_Account account);
 461 static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
 462                                             XML_Bool betweenDecl);
 463 static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
 464                                 const ENCODING *enc, const char *start,
 465                                 const char *end, const char **endPtr,
 466                                 XML_Bool haveMore, enum XML_Account account);
 467 static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *,
 468                                      const char **startPtr, const char *end,
 469                                      const char **nextPtr, XML_Bool haveMore,
 470                                      enum XML_Account account);
 471 #ifdef XML_DTD
 472 static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *,
 473                                       const char **startPtr, const char *end,
 474                                       const char **nextPtr, XML_Bool haveMore);
 475 #endif /* XML_DTD */
 476
 477 static void freeBindings(XML_Parser parser, BINDING *bindings);
 478 static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *,
 479                                 const char *s, TAG_NAME *tagNamePtr,
 480                                 BINDING **bindingsPtr,
 481                                 enum XML_Account account);
 482 static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
 483                                  const ATTRIBUTE_ID *attId, const XML_Char *uri,
 484                                  BINDING **bindingsPtr);
 485 static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
 486                            XML_Bool isId, const XML_Char *dfltValue,
 487                            XML_Parser parser);
 488 static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *,
 489                                           XML_Bool isCdata, const char *,
 490                                           const char *, STRING_POOL *,
 491                                           enum XML_Account account);
 492 static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *,
 493                                            XML_Bool isCdata, const char *,
 494                                            const char *, STRING_POOL *,
 495                                            enum XML_Account account);
 496 static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
 497                                     const char *start, const char *end);
 498 static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
 499 static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
 500                                        const char *start, const char *end,
 501                                        enum XML_Account account);
 502 static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
 503                                        const char *start, const char *end);
 504 static int reportComment(XML_Parser parser, const ENCODING *enc,
 505                          const char *start, const char *end);
 506 static void reportDefault(XML_Parser parser, const ENCODING *enc,
 507                           const char *start, const char *end);
 508
 509 static const XML_Char *getContext(XML_Parser parser);
 510 static XML_Bool setContext(XML_Parser parser, const XML_Char *context);
 511
 512 static void FASTCALL normalizePublicId(XML_Char *s);
 513
 514 static DTD *dtdCreate(const XML_Memory_Handling_Suite *ms);
 515 /* do not call if m_parentParser != NULL */
 516 static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
 517 static void dtdDestroy(DTD *p, XML_Bool isDocEntity,
 518                        const XML_Memory_Handling_Suite *ms);
 519 static int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
 520                    const XML_Memory_Handling_Suite *ms);
 521 static int copyEntityTable(XML_Parser oldParser, HASH_TABLE *, STRING_POOL *,
 522                            const HASH_TABLE *);
 523 static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
 524                      size_t createSize);
 525 static void FASTCALL hashTableInit(HASH_TABLE *,
 526                                    const XML_Memory_Handling_Suite *ms);
 527 static void FASTCALL hashTableClear(HASH_TABLE *);
 528 static void FASTCALL hashTableDestroy(HASH_TABLE *);
 529 static void FASTCALL hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
 530 static NAMED *FASTCALL hashTableIterNext(HASH_TABLE_ITER *);
 531
 532 static void FASTCALL poolInit(STRING_POOL *,
 533                               const XML_Memory_Handling_Suite *ms);
 534 static void FASTCALL poolClear(STRING_POOL *);
 535 static void FASTCALL poolDestroy(STRING_POOL *);
 536 static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
 537                             const char *ptr, const char *end);
 538 static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
 539                                  const char *ptr, const char *end);
 540 static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);
 541 static const XML_Char *FASTCALL poolCopyString(STRING_POOL *pool,
 542                                                const XML_Char *s);
 543 static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,
 544                                        int n);
 545 static const XML_Char *FASTCALL poolAppendString(STRING_POOL *pool,
 546                                                  const XML_Char *s);
 547
 548 static int FASTCALL nextScaffoldPart(XML_Parser parser);
 549 static XML_Content *build_model(XML_Parser parser);
 550 static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
 551                                     const char *ptr, const char *end);
 552
 553 static XML_Char *copyString(const XML_Char *s,
 554                             const XML_Memory_Handling_Suite *memsuite);
 555
 556 static unsigned long generate_hash_secret_salt(XML_Parser parser);
 557 static XML_Bool startParsing(XML_Parser parser);
 558
 559 static XML_Parser parserCreate(const XML_Char *encodingName,
 560                                const XML_Memory_Handling_Suite *memsuite,
 561                                const XML_Char *nameSep, DTD *dtd);
 562
 563 static void parserInit(XML_Parser parser, const XML_Char *encodingName);
 564
 565 #ifdef XML_DTD
 566 static float accountingGetCurrentAmplification(XML_Parser rootParser);
 567 static void accountingReportStats(XML_Parser originParser, const char *epilog);
 568 static void accountingOnAbort(XML_Parser originParser);
 569 static void accountingReportDiff(XML_Parser rootParser,
 570                                  unsigned int levelsAwayFromRootParser,
 571                                  const char *before, const char *after,
 572                                  ptrdiff_t bytesMore, int source_line,
 573                                  enum XML_Account account);
 574 static XML_Bool accountingDiffTolerated(XML_Parser originParser, int tok,
 575                                         const char *before, const char *after,
 576                                         int source_line,
 577                                         enum XML_Account account);
 578
 579 static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,
 580                                       const char *action, int sourceLine);
 581 static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,
 582                                  int sourceLine);
 583 static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,
 584                                   int sourceLine);
 585
 586 static XML_Parser getRootParserOf(XML_Parser parser,
 587                                   unsigned int *outLevelDiff);
 588 #endif /* XML_DTD */
 589
 590 static unsigned long getDebugLevel(const char *variableName,
 591                                    unsigned long defaultDebugLevel);
 592
 593 #define poolStart(pool) ((pool)->start)
 594 #define poolEnd(pool) ((pool)->ptr)
 595 #define poolLength(pool) ((pool)->ptr - (pool)->start)
 596 #define poolChop(pool) ((void)--(pool->ptr))
 597 #define poolLastChar(pool) (((pool)->ptr)[-1])
 598 #define poolDiscard(pool) ((pool)->ptr = (pool)->start)
 599 #define poolFinish(pool) ((pool)->start = (pool)->ptr)
 600 #define poolAppendChar(pool, c)                                                \
 601   (((pool)->ptr == (pool)->end && ! poolGrow(pool))                            \
 602        ? 0                                                                     \
 603        : ((*((pool)->ptr)++ = c), 1))
 604
 605 struct XML_ParserStruct {
 606   /* The first member must be m_userData so that the XML_GetUserData
 607      macro works. */
 608   void *m_userData;
 609   void *m_handlerArg;
 610   char *m_buffer;
 611   const XML_Memory_Handling_Suite m_mem;
 612   /* first character to be parsed */
 613   const char *m_bufferPtr;
 614   /* past last character to be parsed */
 615   char *m_bufferEnd;
 616   /* allocated end of m_buffer */
 617   const char *m_bufferLim;
 618   XML_Index m_parseEndByteIndex;
 619   const char *m_parseEndPtr;
 620   XML_Char *m_dataBuf;
 621   XML_Char *m_dataBufEnd;
 622   XML_StartElementHandler m_startElementHandler;
 623   XML_EndElementHandler m_endElementHandler;
 624   XML_CharacterDataHandler m_characterDataHandler;
 625   XML_ProcessingInstructionHandler m_processingInstructionHandler;
 626   XML_CommentHandler m_commentHandler;
 627   XML_StartCdataSectionHandler m_startCdataSectionHandler;
 628   XML_EndCdataSectionHandler m_endCdataSectionHandler;
 629   XML_DefaultHandler m_defaultHandler;
 630   XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
 631   XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
 632   XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
 633   XML_NotationDeclHandler m_notationDeclHandler;
 634   XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
 635   XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
 636   XML_NotStandaloneHandler m_notStandaloneHandler;
 637   XML_ExternalEntityRefHandler m_externalEntityRefHandler;
 638   XML_Parser m_externalEntityRefHandlerArg;
 639   XML_SkippedEntityHandler m_skippedEntityHandler;
 640   XML_UnknownEncodingHandler m_unknownEncodingHandler;
 641   XML_ElementDeclHandler m_elementDeclHandler;
 642   XML_AttlistDeclHandler m_attlistDeclHandler;
 643   XML_EntityDeclHandler m_entityDeclHandler;
 644   XML_XmlDeclHandler m_xmlDeclHandler;
 645   const ENCODING *m_encoding;
 646   INIT_ENCODING m_initEncoding;
 647   const ENCODING *m_internalEncoding;
 648   const XML_Char *m_protocolEncodingName;
 649   XML_Bool m_ns;
 650   XML_Bool m_ns_triplets;
 651   void *m_unknownEncodingMem;
 652   void *m_unknownEncodingData;
 653   void *m_unknownEncodingHandlerData;
 654   void(XMLCALL *m_unknownEncodingRelease)(void *);
 655   PROLOG_STATE m_prologState;
 656   Processor *m_processor;
 657   enum XML_Error m_errorCode;
 658   const char *m_eventPtr;
 659   const char *m_eventEndPtr;
 660   const char *m_positionPtr;
 661   OPEN_INTERNAL_ENTITY *m_openInternalEntities;
 662   OPEN_INTERNAL_ENTITY *m_freeInternalEntities;
 663   XML_Bool m_defaultExpandInternalEntities;
 664   int m_tagLevel;
 665   ENTITY *m_declEntity;
 666   const XML_Char *m_doctypeName;
 667   const XML_Char *m_doctypeSysid;
 668   const XML_Char *m_doctypePubid;
 669   const XML_Char *m_declAttributeType;
 670   const XML_Char *m_declNotationName;
 671   const XML_Char *m_declNotationPublicId;
 672   ELEMENT_TYPE *m_declElementType;
 673   ATTRIBUTE_ID *m_declAttributeId;
 674   XML_Bool m_declAttributeIsCdata;
 675   XML_Bool m_declAttributeIsId;
 676   DTD *m_dtd;
 677   const XML_Char *m_curBase;
 678   TAG *m_tagStack;
 679   TAG *m_freeTagList;
 680   BINDING *m_inheritedBindings;
 681   BINDING *m_freeBindingList;
 682   int m_attsSize;
 683   int m_nSpecifiedAtts;
 684   int m_idAttIndex;
 685   ATTRIBUTE *m_atts;
 686   NS_ATT *m_nsAtts;
 687   unsigned long m_nsAttsVersion;
 688   unsigned char m_nsAttsPower;
 689 #ifdef XML_ATTR_INFO
 690   XML_AttrInfo *m_attInfo;
 691 #endif
 692   POSITION m_position;
 693   STRING_POOL m_tempPool;
 694   STRING_POOL m_temp2Pool;
 695   char *m_groupConnector;
 696   unsigned int m_groupSize;
 697   XML_Char m_namespaceSeparator;
 698   XML_Parser m_parentParser;
 699   XML_ParsingStatus m_parsingStatus;
 700 #ifdef XML_DTD
 701   XML_Bool m_isParamEntity;
 702   XML_Bool m_useForeignDTD;
 703   enum XML_ParamEntityParsing m_paramEntityParsing;
 704 #endif
 705   unsigned long m_hash_secret_salt;
 706 #ifdef XML_DTD
 707   ACCOUNTING m_accounting;
 708   ENTITY_STATS m_entity_stats;
 709 #endif
 710 };
 711
 712 #define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))
 713 #define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))
 714 #define FREE(parser, p) (parser->m_mem.free_fcn((p)))
 715
 716 XML_Parser XMLCALL
 717 XML_ParserCreate(const XML_Char *encodingName) {
 718   return XML_ParserCreate_MM(encodingName, NULL, NULL);
 719 }
 720
 721 XML_Parser XMLCALL
 722 XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) {
 723   XML_Char tmp[2] = {nsSep, 0};
 724   return XML_ParserCreate_MM(encodingName, NULL, tmp);
 725 }
 726
 727 // "xml=http://www.w3.org/XML/1998/namespace"
 728 static const XML_Char implicitContext[]
 729     = {ASCII_x,     ASCII_m,     ASCII_l,      ASCII_EQUALS, ASCII_h,
 730        ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,  ASCII_SLASH,
 731        ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,      ASCII_PERIOD,
 732        ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,      ASCII_r,
 733        ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,      ASCII_L,
 734        ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,      ASCII_8,
 735        ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,      ASCII_e,
 736        ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,      ASCII_e,
 737        '\0'};
 738
 739 /* To avoid warnings about unused functions: */
 740 #if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
 741
 742 #  if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
 743
 744 /* Obtain entropy on Linux 3.17+ */
 745 static int
 746 writeRandomBytes_getrandom_nonblock(void *target, size_t count) {
 747   int success = 0; /* full count bytes written? */
 748   size_t bytesWrittenTotal = 0;
 749   const unsigned int getrandomFlags = GRND_NONBLOCK;
 750
 751   do {
 752     void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);
 753     const size_t bytesToWrite = count - bytesWrittenTotal;
 754
 755     const int bytesWrittenMore =
 756 #    if defined(HAVE_GETRANDOM)
 757         getrandom(currentTarget, bytesToWrite, getrandomFlags);
 758 #    else
 759         syscall(SYS_getrandom, currentTarget, bytesToWrite, getrandomFlags);
 760 #    endif
 761
 762     if (bytesWrittenMore > 0) {
 763       bytesWrittenTotal += bytesWrittenMore;
 764       if (bytesWrittenTotal >= count)
 765         success = 1;
 766     }
 767   } while (! success && (errno == EINTR));
 768
 769   return success;
 770 }
 771
 772 #  endif /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
 773
 774 #  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
 775
 776 /* Extract entropy from /dev/urandom */
 777 static int
 778 writeRandomBytes_dev_urandom(void *target, size_t count) {
 779   int success = 0; /* full count bytes written? */
 780   size_t bytesWrittenTotal = 0;
 781
 782   const int fd = open("/dev/urandom", O_RDONLY);
 783   if (fd < 0) {
 784     return 0;
 785   }
 786
 787   do {
 788     void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);
 789     const size_t bytesToWrite = count - bytesWrittenTotal;
 790
 791     const ssize_t bytesWrittenMore = read(fd, currentTarget, bytesToWrite);
 792
 793     if (bytesWrittenMore > 0) {
 794       bytesWrittenTotal += bytesWrittenMore;
 795       if (bytesWrittenTotal >= count)
 796         success = 1;
 797     }
 798   } while (! success && (errno == EINTR));
 799
 800   close(fd);
 801   return success;
 802 }
 803
 804 #  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
 805
 806 #endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
 807
 808 #if defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF)
 809
 810 static void
 811 writeRandomBytes_arc4random(void *target, size_t count) {
 812   size_t bytesWrittenTotal = 0;
 813
 814   while (bytesWrittenTotal < count) {
 815     const uint32_t random32 = arc4random();
 816     size_t i = 0;
 817
 818     for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
 819          i++, bytesWrittenTotal++) {
 820       const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
 821       ((uint8_t *)target)[bytesWrittenTotal] = random8;
 822     }
 823   }
 824 }
 825
 826 #endif /* defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF) */
 827
 828 #ifdef _WIN32
 829
 830 /* Provide declaration of rand_s() for MinGW-32 (not 64, which has it),
 831    as it didn't declare it in its header prior to version 5.3.0 of its
 832    runtime package (mingwrt, containing stdlib.h).  The upstream fix
 833    was introduced at https://osdn.net/projects/mingw/ticket/39658 . */
 834 #  if defined(__MINGW32__) && defined(__MINGW32_VERSION)                       \
 835       && __MINGW32_VERSION < 5003000L && ! defined(__MINGW64_VERSION_MAJOR)
 836 __declspec(dllimport) int rand_s(unsigned int *);
 837 #  endif
 838
 839 /* Obtain entropy on Windows using the rand_s() function which
 840  * generates cryptographically secure random numbers.  Internally it
 841  * uses RtlGenRandom API which is present in Windows XP and later.
 842  */
 843 static int
 844 writeRandomBytes_rand_s(void *target, size_t count) {
 845   size_t bytesWrittenTotal = 0;
 846
 847   while (bytesWrittenTotal < count) {
 848     unsigned int random32 = 0;
 849     size_t i = 0;
 850
 851     if (rand_s(&random32))
 852       return 0; /* failure */
 853
 854     for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
 855          i++, bytesWrittenTotal++) {
 856       const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
 857       ((uint8_t *)target)[bytesWrittenTotal] = random8;
 858     }
 859   }
 860   return 1; /* success */
 861 }
 862
 863 #endif /* _WIN32 */
 864
 865 #if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
 866
 867 static unsigned long
 868 gather_time_entropy(void) {
 869 #  ifdef _WIN32
 870   FILETIME ft;
 871   GetSystemTimeAsFileTime(&ft); /* never fails */
 872   return ft.dwHighDateTime ^ ft.dwLowDateTime;
 873 #  else
 874   struct timeval tv;
 875   int gettimeofday_res;
 876
 877   gettimeofday_res = gettimeofday(&tv, NULL);
 878
 879 #    if defined(NDEBUG)
 880   (void)gettimeofday_res;
 881 #    else
 882   assert(gettimeofday_res == 0);
 883 #    endif /* defined(NDEBUG) */
 884
 885   /* Microseconds time is <20 bits entropy */
 886   return tv.tv_usec;
 887 #  endif
 888 }
 889
 890 #endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
 891
 892 static unsigned long
 893 ENTROPY_DEBUG(const char *label, unsigned long entropy) {
 894   if (getDebugLevel("EXPAT_ENTROPY_DEBUG", 0) >= 1u) {
 895     fprintf(stderr, "expat: Entropy: %s --> 0x%0*lx (%lu bytes)\n", label,
 896             (int)sizeof(entropy) * 2, entropy, (unsigned long)sizeof(entropy));
 897   }
 898   return entropy;
 899 }
 900
 901 static unsigned long
 902 generate_hash_secret_salt(XML_Parser parser) {
 903   unsigned long entropy;
 904   (void)parser;
 905
 906   /* "Failproof" high quality providers: */
 907 #if defined(HAVE_ARC4RANDOM_BUF)
 908   arc4random_buf(&entropy, sizeof(entropy));
 909   return ENTROPY_DEBUG("arc4random_buf", entropy);
 910 #elif defined(HAVE_ARC4RANDOM)
 911   writeRandomBytes_arc4random((void *)&entropy, sizeof(entropy));
 912   return ENTROPY_DEBUG("arc4random", entropy);
 913 #else
 914   /* Try high quality providers first .. */
 915 #  ifdef _WIN32
 916   if (writeRandomBytes_rand_s((void *)&entropy, sizeof(entropy))) {
 917     return ENTROPY_DEBUG("rand_s", entropy);
 918   }
 919 #  elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
 920   if (writeRandomBytes_getrandom_nonblock((void *)&entropy, sizeof(entropy))) {
 921     return ENTROPY_DEBUG("getrandom", entropy);
 922   }
 923 #  endif
 924 #  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
 925   if (writeRandomBytes_dev_urandom((void *)&entropy, sizeof(entropy))) {
 926     return ENTROPY_DEBUG("/dev/urandom", entropy);
 927   }
 928 #  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
 929   /* .. and self-made low quality for backup: */
 930
 931   /* Process ID is 0 bits entropy if attacker has local access */
 932   entropy = gather_time_entropy() ^ getpid();
 933
 934   /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */
 935   if (sizeof(unsigned long) == 4) {
 936     return ENTROPY_DEBUG("fallback(4)", entropy * 2147483647);
 937   } else {
 938     return ENTROPY_DEBUG("fallback(8)",
 939                          entropy * (unsigned long)2305843009213693951ULL);
 940   }
 941 #endif
 942 }
 943
 944 static unsigned long
 945 get_hash_secret_salt(XML_Parser parser) {
 946   if (parser->m_parentParser != NULL)
 947     return get_hash_secret_salt(parser->m_parentParser);
 948   return parser->m_hash_secret_salt;
 949 }
 950
 951 static XML_Bool /* only valid for root parser */
 952 startParsing(XML_Parser parser) {
 953   /* hash functions must be initialized before setContext() is called */
 954   if (parser->m_hash_secret_salt == 0)
 955     parser->m_hash_secret_salt = generate_hash_secret_salt(parser);
 956   if (parser->m_ns) {
 957     /* implicit context only set for root parser, since child
 958        parsers (i.e. external entity parsers) will inherit it
 959     */
 960     return setContext(parser, implicitContext);
 961   }
 962   return XML_TRUE;
 963 }
 964
 965 XML_Parser XMLCALL
 966 XML_ParserCreate_MM(const XML_Char *encodingName,
 967                     const XML_Memory_Handling_Suite *memsuite,
 968                     const XML_Char *nameSep) {
 969   return parserCreate(encodingName, memsuite, nameSep, NULL);
 970 }
 971
 972 static XML_Parser
 973 parserCreate(const XML_Char *encodingName,
 974              const XML_Memory_Handling_Suite *memsuite, const XML_Char *nameSep,
 975              DTD *dtd) {
 976   XML_Parser parser;
 977
 978   if (memsuite) {
 979     XML_Memory_Handling_Suite *mtemp;
 980     parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
 981     if (parser != NULL) {
 982       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
 983       mtemp->malloc_fcn = memsuite->malloc_fcn;
 984       mtemp->realloc_fcn = memsuite->realloc_fcn;
 985       mtemp->free_fcn = memsuite->free_fcn;
 986     }
 987   } else {
 988     XML_Memory_Handling_Suite *mtemp;
 989     parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
 990     if (parser != NULL) {
 991       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
 992       mtemp->malloc_fcn = malloc;
 993       mtemp->realloc_fcn = realloc;
 994       mtemp->free_fcn = free;
 995     }
 996   }
 997
 998   if (! parser)
 999     return parser;
1000
1001   parser->m_buffer = NULL;
1002   parser->m_bufferLim = NULL;
1003
1004   parser->m_attsSize = INIT_ATTS_SIZE;
1005   parser->m_atts
1006       = (ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
1007   if (parser->m_atts == NULL) {
1008     FREE(parser, parser);
1009     return NULL;
1010   }
1011 #ifdef XML_ATTR_INFO
1012   parser->m_attInfo = (XML_AttrInfo *)MALLOC(
1013       parser, parser->m_attsSize * sizeof(XML_AttrInfo));
1014   if (parser->m_attInfo == NULL) {
1015     FREE(parser, parser->m_atts);
1016     FREE(parser, parser);
1017     return NULL;
1018   }
1019 #endif
1020   parser->m_dataBuf
1021       = (XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
1022   if (parser->m_dataBuf == NULL) {
1023     FREE(parser, parser->m_atts);
1024 #ifdef XML_ATTR_INFO
1025     FREE(parser, parser->m_attInfo);
1026 #endif
1027     FREE(parser, parser);
1028     return NULL;
1029   }
1030   parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;
1031
1032   if (dtd)
1033     parser->m_dtd = dtd;
1034   else {
1035     parser->m_dtd = dtdCreate(&parser->m_mem);
1036     if (parser->m_dtd == NULL) {
1037       FREE(parser, parser->m_dataBuf);
1038       FREE(parser, parser->m_atts);
1039 #ifdef XML_ATTR_INFO
1040       FREE(parser, parser->m_attInfo);
1041 #endif
1042       FREE(parser, parser);
1043       return NULL;
1044     }
1045   }
1046
1047   parser->m_freeBindingList = NULL;
1048   parser->m_freeTagList = NULL;
1049   parser->m_freeInternalEntities = NULL;
1050
1051   parser->m_groupSize = 0;
1052   parser->m_groupConnector = NULL;
1053
1054   parser->m_unknownEncodingHandler = NULL;
1055   parser->m_unknownEncodingHandlerData = NULL;
1056
1057   parser->m_namespaceSeparator = ASCII_EXCL;
1058   parser->m_ns = XML_FALSE;
1059   parser->m_ns_triplets = XML_FALSE;
1060
1061   parser->m_nsAtts = NULL;
1062   parser->m_nsAttsVersion = 0;
1063   parser->m_nsAttsPower = 0;
1064
1065   parser->m_protocolEncodingName = NULL;
1066
1067   poolInit(&parser->m_tempPool, &(parser->m_mem));
1068   poolInit(&parser->m_temp2Pool, &(parser->m_mem));
1069   parserInit(parser, encodingName);
1070
1071   if (encodingName && ! parser->m_protocolEncodingName) {
1072     if (dtd) {
1073       // We need to stop the upcoming call to XML_ParserFree from happily
1074       // destroying parser->m_dtd because the DTD is shared with the parent
1075       // parser and the only guard that keeps XML_ParserFree from destroying
1076       // parser->m_dtd is parser->m_isParamEntity but it will be set to
1077       // XML_TRUE only later in XML_ExternalEntityParserCreate (or not at all).
1078       parser->m_dtd = NULL;
1079     }
1080     XML_ParserFree(parser);
1081     return NULL;
1082   }
1083
1084   if (nameSep) {
1085     parser->m_ns = XML_TRUE;
1086     parser->m_internalEncoding = XmlGetInternalEncodingNS();
1087     parser->m_namespaceSeparator = *nameSep;
1088   } else {
1089     parser->m_internalEncoding = XmlGetInternalEncoding();
1090   }
1091
1092   return parser;
1093 }
1094
1095 static void
1096 parserInit(XML_Parser parser, const XML_Char *encodingName) {
1097   parser->m_processor = prologInitProcessor;
1098   XmlPrologStateInit(&parser->m_prologState);
1099   if (encodingName != NULL) {
1100     parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
1101   }
1102   parser->m_curBase = NULL;
1103   XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);
1104   parser->m_userData = NULL;
1105   parser->m_handlerArg = NULL;
1106   parser->m_startElementHandler = NULL;
1107   parser->m_endElementHandler = NULL;
1108   parser->m_characterDataHandler = NULL;
1109   parser->m_processingInstructionHandler = NULL;
1110   parser->m_commentHandler = NULL;
1111   parser->m_startCdataSectionHandler = NULL;
1112   parser->m_endCdataSectionHandler = NULL;
1113   parser->m_defaultHandler = NULL;
1114   parser->m_startDoctypeDeclHandler = NULL;
1115   parser->m_endDoctypeDeclHandler = NULL;
1116   parser->m_unparsedEntityDeclHandler = NULL;
1117   parser->m_notationDeclHandler = NULL;
1118   parser->m_startNamespaceDeclHandler = NULL;
1119   parser->m_endNamespaceDeclHandler = NULL;
1120   parser->m_notStandaloneHandler = NULL;
1121   parser->m_externalEntityRefHandler = NULL;
1122   parser->m_externalEntityRefHandlerArg = parser;
1123   parser->m_skippedEntityHandler = NULL;
1124   parser->m_elementDeclHandler = NULL;
1125   parser->m_attlistDeclHandler = NULL;
1126   parser->m_entityDeclHandler = NULL;
1127   parser->m_xmlDeclHandler = NULL;
1128   parser->m_bufferPtr = parser->m_buffer;
1129   parser->m_bufferEnd = parser->m_buffer;
1130   parser->m_parseEndByteIndex = 0;
1131   parser->m_parseEndPtr = NULL;
1132   parser->m_declElementType = NULL;
1133   parser->m_declAttributeId = NULL;
1134   parser->m_declEntity = NULL;
1135   parser->m_doctypeName = NULL;
1136   parser->m_doctypeSysid = NULL;
1137   parser->m_doctypePubid = NULL;
1138   parser->m_declAttributeType = NULL;
1139   parser->m_declNotationName = NULL;
1140   parser->m_declNotationPublicId = NULL;
1141   parser->m_declAttributeIsCdata = XML_FALSE;
1142   parser->m_declAttributeIsId = XML_FALSE;
1143   memset(&parser->m_position, 0, sizeof(POSITION));
1144   parser->m_errorCode = XML_ERROR_NONE;
1145   parser->m_eventPtr = NULL;
1146   parser->m_eventEndPtr = NULL;
1147   parser->m_positionPtr = NULL;
1148   parser->m_openInternalEntities = NULL;
1149   parser->m_defaultExpandInternalEntities = XML_TRUE;
1150   parser->m_tagLevel = 0;
1151   parser->m_tagStack = NULL;
1152   parser->m_inheritedBindings = NULL;
1153   parser->m_nSpecifiedAtts = 0;
1154   parser->m_unknownEncodingMem = NULL;
1155   parser->m_unknownEncodingRelease = NULL;
1156   parser->m_unknownEncodingData = NULL;
1157   parser->m_parentParser = NULL;
1158   parser->m_parsingStatus.parsing = XML_INITIALIZED;
1159 #ifdef XML_DTD
1160   parser->m_isParamEntity = XML_FALSE;
1161   parser->m_useForeignDTD = XML_FALSE;
1162   parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
1163 #endif
1164   parser->m_hash_secret_salt = 0;
1165
1166 #ifdef XML_DTD
1167   memset(&parser->m_accounting, 0, sizeof(ACCOUNTING));
1168   parser->m_accounting.debugLevel = getDebugLevel("EXPAT_ACCOUNTING_DEBUG", 0u);
1169   parser->m_accounting.maximumAmplificationFactor
1170       = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT;
1171   parser->m_accounting.activationThresholdBytes
1172       = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT;
1173
1174   memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS));
1175   parser->m_entity_stats.debugLevel = getDebugLevel("EXPAT_ENTITY_DEBUG", 0u);
1176 #endif
1177 }
1178
1179 /* moves list of bindings to m_freeBindingList */
1180 static void FASTCALL
1181 moveToFreeBindingList(XML_Parser parser, BINDING *bindings) {
1182   while (bindings) {
1183     BINDING *b = bindings;
1184     bindings = bindings->nextTagBinding;
1185     b->nextTagBinding = parser->m_freeBindingList;
1186     parser->m_freeBindingList = b;
1187   }
1188 }
1189
1190 XML_Bool XMLCALL
1191 XML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {
1192   TAG *tStk;
1193   OPEN_INTERNAL_ENTITY *openEntityList;
1194
1195   if (parser == NULL)
1196     return XML_FALSE;
1197
1198   if (parser->m_parentParser)
1199     return XML_FALSE;
1200   /* move m_tagStack to m_freeTagList */
1201   tStk = parser->m_tagStack;
1202   while (tStk) {
1203     TAG *tag = tStk;
1204     tStk = tStk->parent;
1205     tag->parent = parser->m_freeTagList;
1206     moveToFreeBindingList(parser, tag->bindings);
1207     tag->bindings = NULL;
1208     parser->m_freeTagList = tag;
1209   }
1210   /* move m_openInternalEntities to m_freeInternalEntities */
1211   openEntityList = parser->m_openInternalEntities;
1212   while (openEntityList) {
1213     OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
1214     openEntityList = openEntity->next;
1215     openEntity->next = parser->m_freeInternalEntities;
1216     parser->m_freeInternalEntities = openEntity;
1217   }
1218   moveToFreeBindingList(parser, parser->m_inheritedBindings);
1219   FREE(parser, parser->m_unknownEncodingMem);
1220   if (parser->m_unknownEncodingRelease)
1221     parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
1222   poolClear(&parser->m_tempPool);
1223   poolClear(&parser->m_temp2Pool);
1224   FREE(parser, (void *)parser->m_protocolEncodingName);
1225   parser->m_protocolEncodingName = NULL;
1226   parserInit(parser, encodingName);
1227   dtdReset(parser->m_dtd, &parser->m_mem);
1228   return XML_TRUE;
1229 }
1230
1231 enum XML_Status XMLCALL
1232 XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {
1233   if (parser == NULL)
1234     return XML_STATUS_ERROR;
1235   /* Block after XML_Parse()/XML_ParseBuffer() has been called.
1236      XXX There's no way for the caller to determine which of the
1237      XXX possible error cases caused the XML_STATUS_ERROR return.
1238   */
1239   if (parser->m_parsingStatus.parsing == XML_PARSING
1240       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1241     return XML_STATUS_ERROR;
1242
1243   /* Get rid of any previous encoding name */
1244   FREE(parser, (void *)parser->m_protocolEncodingName);
1245
1246   if (encodingName == NULL)
1247     /* No new encoding name */
1248     parser->m_protocolEncodingName = NULL;
1249   else {
1250     /* Copy the new encoding name into allocated memory */
1251     parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
1252     if (! parser->m_protocolEncodingName)
1253       return XML_STATUS_ERROR;
1254   }
1255   return XML_STATUS_OK;
1256 }
1257
1258 XML_Parser XMLCALL
1259 XML_ExternalEntityParserCreate(XML_Parser oldParser, const XML_Char *context,
1260                                const XML_Char *encodingName) {
1261   XML_Parser parser = oldParser;
1262   DTD *newDtd = NULL;
1263   DTD *oldDtd;
1264   XML_StartElementHandler oldStartElementHandler;
1265   XML_EndElementHandler oldEndElementHandler;
1266   XML_CharacterDataHandler oldCharacterDataHandler;
1267   XML_ProcessingInstructionHandler oldProcessingInstructionHandler;
1268   XML_CommentHandler oldCommentHandler;
1269   XML_StartCdataSectionHandler oldStartCdataSectionHandler;
1270   XML_EndCdataSectionHandler oldEndCdataSectionHandler;
1271   XML_DefaultHandler oldDefaultHandler;
1272   XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;
1273   XML_NotationDeclHandler oldNotationDeclHandler;
1274   XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;
1275   XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;
1276   XML_NotStandaloneHandler oldNotStandaloneHandler;
1277   XML_ExternalEntityRefHandler oldExternalEntityRefHandler;
1278   XML_SkippedEntityHandler oldSkippedEntityHandler;
1279   XML_UnknownEncodingHandler oldUnknownEncodingHandler;
1280   XML_ElementDeclHandler oldElementDeclHandler;
1281   XML_AttlistDeclHandler oldAttlistDeclHandler;
1282   XML_EntityDeclHandler oldEntityDeclHandler;
1283   XML_XmlDeclHandler oldXmlDeclHandler;
1284   ELEMENT_TYPE *oldDeclElementType;
1285
1286   void *oldUserData;
1287   void *oldHandlerArg;
1288   XML_Bool oldDefaultExpandInternalEntities;
1289   XML_Parser oldExternalEntityRefHandlerArg;
1290 #ifdef XML_DTD
1291   enum XML_ParamEntityParsing oldParamEntityParsing;
1292   int oldInEntityValue;
1293 #endif
1294   XML_Bool oldns_triplets;
1295   /* Note that the new parser shares the same hash secret as the old
1296      parser, so that dtdCopy and copyEntityTable can lookup values
1297      from hash tables associated with either parser without us having
1298      to worry which hash secrets each table has.
1299   */
1300   unsigned long oldhash_secret_salt;
1301
1302   /* Validate the oldParser parameter before we pull everything out of it */
1303   if (oldParser == NULL)
1304     return NULL;
1305
1306   /* Stash the original parser contents on the stack */
1307   oldDtd = parser->m_dtd;
1308   oldStartElementHandler = parser->m_startElementHandler;
1309   oldEndElementHandler = parser->m_endElementHandler;
1310   oldCharacterDataHandler = parser->m_characterDataHandler;
1311   oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
1312   oldCommentHandler = parser->m_commentHandler;
1313   oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
1314   oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
1315   oldDefaultHandler = parser->m_defaultHandler;
1316   oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
1317   oldNotationDeclHandler = parser->m_notationDeclHandler;
1318   oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
1319   oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
1320   oldNotStandaloneHandler = parser->m_notStandaloneHandler;
1321   oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
1322   oldSkippedEntityHandler = parser->m_skippedEntityHandler;
1323   oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
1324   oldElementDeclHandler = parser->m_elementDeclHandler;
1325   oldAttlistDeclHandler = parser->m_attlistDeclHandler;
1326   oldEntityDeclHandler = parser->m_entityDeclHandler;
1327   oldXmlDeclHandler = parser->m_xmlDeclHandler;
1328   oldDeclElementType = parser->m_declElementType;
1329
1330   oldUserData = parser->m_userData;
1331   oldHandlerArg = parser->m_handlerArg;
1332   oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
1333   oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
1334 #ifdef XML_DTD
1335   oldParamEntityParsing = parser->m_paramEntityParsing;
1336   oldInEntityValue = parser->m_prologState.inEntityValue;
1337 #endif
1338   oldns_triplets = parser->m_ns_triplets;
1339   /* Note that the new parser shares the same hash secret as the old
1340      parser, so that dtdCopy and copyEntityTable can lookup values
1341      from hash tables associated with either parser without us having
1342      to worry which hash secrets each table has.
1343   */
1344   oldhash_secret_salt = parser->m_hash_secret_salt;
1345
1346 #ifdef XML_DTD
1347   if (! context)
1348     newDtd = oldDtd;
1349 #endif /* XML_DTD */
1350
1351   /* Note that the magical uses of the pre-processor to make field
1352      access look more like C++ require that `parser' be overwritten
1353      here.  This makes this function more painful to follow than it
1354      would be otherwise.
1355   */
1356   if (parser->m_ns) {
1357     XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};
1358     parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
1359   } else {
1360     parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
1361   }
1362
1363   if (! parser)
1364     return NULL;
1365
1366   parser->m_startElementHandler = oldStartElementHandler;
1367   parser->m_endElementHandler = oldEndElementHandler;
1368   parser->m_characterDataHandler = oldCharacterDataHandler;
1369   parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
1370   parser->m_commentHandler = oldCommentHandler;
1371   parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
1372   parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
1373   parser->m_defaultHandler = oldDefaultHandler;
1374   parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
1375   parser->m_notationDeclHandler = oldNotationDeclHandler;
1376   parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
1377   parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
1378   parser->m_notStandaloneHandler = oldNotStandaloneHandler;
1379   parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
1380   parser->m_skippedEntityHandler = oldSkippedEntityHandler;
1381   parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
1382   parser->m_elementDeclHandler = oldElementDeclHandler;
1383   parser->m_attlistDeclHandler = oldAttlistDeclHandler;
1384   parser->m_entityDeclHandler = oldEntityDeclHandler;
1385   parser->m_xmlDeclHandler = oldXmlDeclHandler;
1386   parser->m_declElementType = oldDeclElementType;
1387   parser->m_userData = oldUserData;
1388   if (oldUserData == oldHandlerArg)
1389     parser->m_handlerArg = parser->m_userData;
1390   else
1391     parser->m_handlerArg = parser;
1392   if (oldExternalEntityRefHandlerArg != oldParser)
1393     parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
1394   parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
1395   parser->m_ns_triplets = oldns_triplets;
1396   parser->m_hash_secret_salt = oldhash_secret_salt;
1397   parser->m_parentParser = oldParser;
1398 #ifdef XML_DTD
1399   parser->m_paramEntityParsing = oldParamEntityParsing;
1400   parser->m_prologState.inEntityValue = oldInEntityValue;
1401   if (context) {
1402 #endif /* XML_DTD */
1403     if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
1404         || ! setContext(parser, context)) {
1405       XML_ParserFree(parser);
1406       return NULL;
1407     }
1408     parser->m_processor = externalEntityInitProcessor;
1409 #ifdef XML_DTD
1410   } else {
1411     /* The DTD instance referenced by parser->m_dtd is shared between the
1412        document's root parser and external PE parsers, therefore one does not
1413        need to call setContext. In addition, one also *must* not call
1414        setContext, because this would overwrite existing prefix->binding
1415        pointers in parser->m_dtd with ones that get destroyed with the external
1416        PE parser. This would leave those prefixes with dangling pointers.
1417     */
1418     parser->m_isParamEntity = XML_TRUE;
1419     XmlPrologStateInitExternalEntity(&parser->m_prologState);
1420     parser->m_processor = externalParEntInitProcessor;
1421   }
1422 #endif /* XML_DTD */
1423   return parser;
1424 }
1425
1426 static void FASTCALL
1427 destroyBindings(BINDING *bindings, XML_Parser parser) {
1428   for (;;) {
1429     BINDING *b = bindings;
1430     if (! b)
1431       break;
1432     bindings = b->nextTagBinding;
1433     FREE(parser, b->uri);
1434     FREE(parser, b);
1435   }
1436 }
1437
1438 void XMLCALL
1439 XML_ParserFree(XML_Parser parser) {
1440   TAG *tagList;
1441   OPEN_INTERNAL_ENTITY *entityList;
1442   if (parser == NULL)
1443     return;
1444   /* free m_tagStack and m_freeTagList */
1445   tagList = parser->m_tagStack;
1446   for (;;) {
1447     TAG *p;
1448     if (tagList == NULL) {
1449       if (parser->m_freeTagList == NULL)
1450         break;
1451       tagList = parser->m_freeTagList;
1452       parser->m_freeTagList = NULL;
1453     }
1454     p = tagList;
1455     tagList = tagList->parent;
1456     FREE(parser, p->buf);
1457     destroyBindings(p->bindings, parser);
1458     FREE(parser, p);
1459   }
1460   /* free m_openInternalEntities and m_freeInternalEntities */
1461   entityList = parser->m_openInternalEntities;
1462   for (;;) {
1463     OPEN_INTERNAL_ENTITY *openEntity;
1464     if (entityList == NULL) {
1465       if (parser->m_freeInternalEntities == NULL)
1466         break;
1467       entityList = parser->m_freeInternalEntities;
1468       parser->m_freeInternalEntities = NULL;
1469     }
1470     openEntity = entityList;
1471     entityList = entityList->next;
1472     FREE(parser, openEntity);
1473   }
1474
1475   destroyBindings(parser->m_freeBindingList, parser);
1476   destroyBindings(parser->m_inheritedBindings, parser);
1477   poolDestroy(&parser->m_tempPool);
1478   poolDestroy(&parser->m_temp2Pool);
1479   FREE(parser, (void *)parser->m_protocolEncodingName);
1480 #ifdef XML_DTD
1481   /* external parameter entity parsers share the DTD structure
1482      parser->m_dtd with the root parser, so we must not destroy it
1483   */
1484   if (! parser->m_isParamEntity && parser->m_dtd)
1485 #else
1486   if (parser->m_dtd)
1487 #endif /* XML_DTD */
1488     dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser,
1489                &parser->m_mem);
1490   FREE(parser, (void *)parser->m_atts);
1491 #ifdef XML_ATTR_INFO
1492   FREE(parser, (void *)parser->m_attInfo);
1493 #endif
1494   FREE(parser, parser->m_groupConnector);
1495   FREE(parser, parser->m_buffer);
1496   FREE(parser, parser->m_dataBuf);
1497   FREE(parser, parser->m_nsAtts);
1498   FREE(parser, parser->m_unknownEncodingMem);
1499   if (parser->m_unknownEncodingRelease)
1500     parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
1501   FREE(parser, parser);
1502 }
1503
1504 void XMLCALL
1505 XML_UseParserAsHandlerArg(XML_Parser parser) {
1506   if (parser != NULL)
1507     parser->m_handlerArg = parser;
1508 }
1509
1510 enum XML_Error XMLCALL
1511 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {
1512   if (parser == NULL)
1513     return XML_ERROR_INVALID_ARGUMENT;
1514 #ifdef XML_DTD
1515   /* block after XML_Parse()/XML_ParseBuffer() has been called */
1516   if (parser->m_parsingStatus.parsing == XML_PARSING
1517       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1518     return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
1519   parser->m_useForeignDTD = useDTD;
1520   return XML_ERROR_NONE;
1521 #else
1522   UNUSED_P(useDTD);
1523   return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
1524 #endif
1525 }
1526
1527 void XMLCALL
1528 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
1529   if (parser == NULL)
1530     return;
1531   /* block after XML_Parse()/XML_ParseBuffer() has been called */
1532   if (parser->m_parsingStatus.parsing == XML_PARSING
1533       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1534     return;
1535   parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
1536 }
1537
1538 void XMLCALL
1539 XML_SetUserData(XML_Parser parser, void *p) {
1540   if (parser == NULL)
1541     return;
1542   if (parser->m_handlerArg == parser->m_userData)
1543     parser->m_handlerArg = parser->m_userData = p;
1544   else
1545     parser->m_userData = p;
1546 }
1547
1548 enum XML_Status XMLCALL
1549 XML_SetBase(XML_Parser parser, const XML_Char *p) {
1550   if (parser == NULL)
1551     return XML_STATUS_ERROR;
1552   if (p) {
1553     p = poolCopyString(&parser->m_dtd->pool, p);
1554     if (! p)
1555       return XML_STATUS_ERROR;
1556     parser->m_curBase = p;
1557   } else
1558     parser->m_curBase = NULL;
1559   return XML_STATUS_OK;
1560 }
1561
1562 const XML_Char *XMLCALL
1563 XML_GetBase(XML_Parser parser) {
1564   if (parser == NULL)
1565     return NULL;
1566   return parser->m_curBase;
1567 }
1568
1569 int XMLCALL
1570 XML_GetSpecifiedAttributeCount(XML_Parser parser) {
1571   if (parser == NULL)
1572     return -1;
1573   return parser->m_nSpecifiedAtts;
1574 }
1575
1576 int XMLCALL
1577 XML_GetIdAttributeIndex(XML_Parser parser) {
1578   if (parser == NULL)
1579     return -1;
1580   return parser->m_idAttIndex;
1581 }
1582
1583 #ifdef XML_ATTR_INFO
1584 const XML_AttrInfo *XMLCALL
1585 XML_GetAttributeInfo(XML_Parser parser) {
1586   if (parser == NULL)
1587     return NULL;
1588   return parser->m_attInfo;
1589 }
1590 #endif
1591
1592 void XMLCALL
1593 XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
1594                       XML_EndElementHandler end) {
1595   if (parser == NULL)
1596     return;
1597   parser->m_startElementHandler = start;
1598   parser->m_endElementHandler = end;
1599 }
1600
1601 void XMLCALL
1602 XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {
1603   if (parser != NULL)
1604     parser->m_startElementHandler = start;
1605 }
1606
1607 void XMLCALL
1608 XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {
1609   if (parser != NULL)
1610     parser->m_endElementHandler = end;
1611 }
1612
1613 void XMLCALL
1614 XML_SetCharacterDataHandler(XML_Parser parser,
1615                             XML_CharacterDataHandler handler) {
1616   if (parser != NULL)
1617     parser->m_characterDataHandler = handler;
1618 }
1619
1620 void XMLCALL
1621 XML_SetProcessingInstructionHandler(XML_Parser parser,
1622                                     XML_ProcessingInstructionHandler handler) {
1623   if (parser != NULL)
1624     parser->m_processingInstructionHandler = handler;
1625 }
1626
1627 void XMLCALL
1628 XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {
1629   if (parser != NULL)
1630     parser->m_commentHandler = handler;
1631 }
1632
1633 void XMLCALL
1634 XML_SetCdataSectionHandler(XML_Parser parser,
1635                            XML_StartCdataSectionHandler start,
1636                            XML_EndCdataSectionHandler end) {
1637   if (parser == NULL)
1638     return;
1639   parser->m_startCdataSectionHandler = start;
1640   parser->m_endCdataSectionHandler = end;
1641 }
1642
1643 void XMLCALL
1644 XML_SetStartCdataSectionHandler(XML_Parser parser,
1645                                 XML_StartCdataSectionHandler start) {
1646   if (parser != NULL)
1647     parser->m_startCdataSectionHandler = start;
1648 }
1649
1650 void XMLCALL
1651 XML_SetEndCdataSectionHandler(XML_Parser parser,
1652                               XML_EndCdataSectionHandler end) {
1653   if (parser != NULL)
1654     parser->m_endCdataSectionHandler = end;
1655 }
1656
1657 void XMLCALL
1658 XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {
1659   if (parser == NULL)
1660     return;
1661   parser->m_defaultHandler = handler;
1662   parser->m_defaultExpandInternalEntities = XML_FALSE;
1663 }
1664
1665 void XMLCALL
1666 XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {
1667   if (parser == NULL)
1668     return;
1669   parser->m_defaultHandler = handler;
1670   parser->m_defaultExpandInternalEntities = XML_TRUE;
1671 }
1672
1673 void XMLCALL
1674 XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
1675                           XML_EndDoctypeDeclHandler end) {
1676   if (parser == NULL)
1677     return;
1678   parser->m_startDoctypeDeclHandler = start;
1679   parser->m_endDoctypeDeclHandler = end;
1680 }
1681
1682 void XMLCALL
1683 XML_SetStartDoctypeDeclHandler(XML_Parser parser,
1684                                XML_StartDoctypeDeclHandler start) {
1685   if (parser != NULL)
1686     parser->m_startDoctypeDeclHandler = start;
1687 }
1688
1689 void XMLCALL
1690 XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {
1691   if (parser != NULL)
1692     parser->m_endDoctypeDeclHandler = end;
1693 }
1694
1695 void XMLCALL
1696 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
1697                                  XML_UnparsedEntityDeclHandler handler) {
1698   if (parser != NULL)
1699     parser->m_unparsedEntityDeclHandler = handler;
1700 }
1701
1702 void XMLCALL
1703 XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {
1704   if (parser != NULL)
1705     parser->m_notationDeclHandler = handler;
1706 }
1707
1708 void XMLCALL
1709 XML_SetNamespaceDeclHandler(XML_Parser parser,
1710                             XML_StartNamespaceDeclHandler start,
1711                             XML_EndNamespaceDeclHandler end) {
1712   if (parser == NULL)
1713     return;
1714   parser->m_startNamespaceDeclHandler = start;
1715   parser->m_endNamespaceDeclHandler = end;
1716 }
1717
1718 void XMLCALL
1719 XML_SetStartNamespaceDeclHandler(XML_Parser parser,
1720                                  XML_StartNamespaceDeclHandler start) {
1721   if (parser != NULL)
1722     parser->m_startNamespaceDeclHandler = start;
1723 }
1724
1725 void XMLCALL
1726 XML_SetEndNamespaceDeclHandler(XML_Parser parser,
1727                                XML_EndNamespaceDeclHandler end) {
1728   if (parser != NULL)
1729     parser->m_endNamespaceDeclHandler = end;
1730 }
1731
1732 void XMLCALL
1733 XML_SetNotStandaloneHandler(XML_Parser parser,
1734                             XML_NotStandaloneHandler handler) {
1735   if (parser != NULL)
1736     parser->m_notStandaloneHandler = handler;
1737 }
1738
1739 void XMLCALL
1740 XML_SetExternalEntityRefHandler(XML_Parser parser,
1741                                 XML_ExternalEntityRefHandler handler) {
1742   if (parser != NULL)
1743     parser->m_externalEntityRefHandler = handler;
1744 }
1745
1746 void XMLCALL
1747 XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {
1748   if (parser == NULL)
1749     return;
1750   if (arg)
1751     parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
1752   else
1753     parser->m_externalEntityRefHandlerArg = parser;
1754 }
1755
1756 void XMLCALL
1757 XML_SetSkippedEntityHandler(XML_Parser parser,
1758                             XML_SkippedEntityHandler handler) {
1759   if (parser != NULL)
1760     parser->m_skippedEntityHandler = handler;
1761 }
1762
1763 void XMLCALL
1764 XML_SetUnknownEncodingHandler(XML_Parser parser,
1765                               XML_UnknownEncodingHandler handler, void *data) {
1766   if (parser == NULL)
1767     return;
1768   parser->m_unknownEncodingHandler = handler;
1769   parser->m_unknownEncodingHandlerData = data;
1770 }
1771
1772 void XMLCALL
1773 XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {
1774   if (parser != NULL)
1775     parser->m_elementDeclHandler = eldecl;
1776 }
1777
1778 void XMLCALL
1779 XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {
1780   if (parser != NULL)
1781     parser->m_attlistDeclHandler = attdecl;
1782 }
1783
1784 void XMLCALL
1785 XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {
1786   if (parser != NULL)
1787     parser->m_entityDeclHandler = handler;
1788 }
1789
1790 void XMLCALL
1791 XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {
1792   if (parser != NULL)
1793     parser->m_xmlDeclHandler = handler;
1794 }
1795
1796 int XMLCALL
1797 XML_SetParamEntityParsing(XML_Parser parser,
1798                           enum XML_ParamEntityParsing peParsing) {
1799   if (parser == NULL)
1800     return 0;
1801   /* block after XML_Parse()/XML_ParseBuffer() has been called */
1802   if (parser->m_parsingStatus.parsing == XML_PARSING
1803       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1804     return 0;
1805 #ifdef XML_DTD
1806   parser->m_paramEntityParsing = peParsing;
1807   return 1;
1808 #else
1809   return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
1810 #endif
1811 }
1812
1813 int XMLCALL
1814 XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {
1815   if (parser == NULL)
1816     return 0;
1817   if (parser->m_parentParser)
1818     return XML_SetHashSalt(parser->m_parentParser, hash_salt);
1819   /* block after XML_Parse()/XML_ParseBuffer() has been called */
1820   if (parser->m_parsingStatus.parsing == XML_PARSING
1821       || parser->m_parsingStatus.parsing == XML_SUSPENDED)
1822     return 0;
1823   parser->m_hash_secret_salt = hash_salt;
1824   return 1;
1825 }
1826
1827 enum XML_Status XMLCALL
1828 XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {
1829   if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
1830     if (parser != NULL)
1831       parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
1832     return XML_STATUS_ERROR;
1833   }
1834   switch (parser->m_parsingStatus.parsing) {
1835   case XML_SUSPENDED:
1836     parser->m_errorCode = XML_ERROR_SUSPENDED;
1837     return XML_STATUS_ERROR;
1838   case XML_FINISHED:
1839     parser->m_errorCode = XML_ERROR_FINISHED;
1840     return XML_STATUS_ERROR;
1841   case XML_INITIALIZED:
1842     if (parser->m_parentParser == NULL && ! startParsing(parser)) {
1843       parser->m_errorCode = XML_ERROR_NO_MEMORY;
1844       return XML_STATUS_ERROR;
1845     }
1846     /* fall through */
1847   default:
1848     parser->m_parsingStatus.parsing = XML_PARSING;
1849   }
1850
1851   if (len == 0) {
1852     parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
1853     if (! isFinal)
1854       return XML_STATUS_OK;
1855     parser->m_positionPtr = parser->m_bufferPtr;
1856     parser->m_parseEndPtr = parser->m_bufferEnd;
1857
1858     /* If data are left over from last buffer, and we now know that these
1859        data are the final chunk of input, then we have to check them again
1860        to detect errors based on that fact.
1861     */
1862     parser->m_errorCode
1863         = parser->m_processor(parser, parser->m_bufferPtr,
1864                               parser->m_parseEndPtr, &parser->m_bufferPtr);
1865
1866     if (parser->m_errorCode == XML_ERROR_NONE) {
1867       switch (parser->m_parsingStatus.parsing) {
1868       case XML_SUSPENDED:
1869         /* It is hard to be certain, but it seems that this case
1870          * cannot occur.  This code is cleaning up a previous parse
1871          * with no new data (since len == 0).  Changing the parsing
1872          * state requires getting to execute a handler function, and
1873          * there doesn't seem to be an opportunity for that while in
1874          * this circumstance.
1875          *
1876          * Given the uncertainty, we retain the code but exclude it
1877          * from coverage tests.
1878          *
1879          * LCOV_EXCL_START
1880          */
1881         XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
1882                           parser->m_bufferPtr, &parser->m_position);
1883         parser->m_positionPtr = parser->m_bufferPtr;
1884         return XML_STATUS_SUSPENDED;
1885         /* LCOV_EXCL_STOP */
1886       case XML_INITIALIZED:
1887       case XML_PARSING:
1888         parser->m_parsingStatus.parsing = XML_FINISHED;
1889         /* fall through */
1890       default:
1891         return XML_STATUS_OK;
1892       }
1893     }
1894     parser->m_eventEndPtr = parser->m_eventPtr;
1895     parser->m_processor = errorProcessor;
1896     return XML_STATUS_ERROR;
1897   }
1898 #ifndef XML_CONTEXT_BYTES
1899   else if (parser->m_bufferPtr == parser->m_bufferEnd) {
1900     const char *end;
1901     int nLeftOver;
1902     enum XML_Status result;
1903     /* Detect overflow (a+b > MAX <==> b > MAX-a) */
1904     if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
1905       parser->m_errorCode = XML_ERROR_NO_MEMORY;
1906       parser->m_eventPtr = parser->m_eventEndPtr = NULL;
1907       parser->m_processor = errorProcessor;
1908       return XML_STATUS_ERROR;
1909     }
1910     parser->m_parseEndByteIndex += len;
1911     parser->m_positionPtr = s;
1912     parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
1913
1914     parser->m_errorCode
1915         = parser->m_processor(parser, s, parser->m_parseEndPtr = s + len, &end);
1916
1917     if (parser->m_errorCode != XML_ERROR_NONE) {
1918       parser->m_eventEndPtr = parser->m_eventPtr;
1919       parser->m_processor = errorProcessor;
1920       return XML_STATUS_ERROR;
1921     } else {
1922       switch (parser->m_parsingStatus.parsing) {
1923       case XML_SUSPENDED:
1924         result = XML_STATUS_SUSPENDED;
1925         break;
1926       case XML_INITIALIZED:
1927       case XML_PARSING:
1928         if (isFinal) {
1929           parser->m_parsingStatus.parsing = XML_FINISHED;
1930           return XML_STATUS_OK;
1931         }
1932       /* fall through */
1933       default:
1934         result = XML_STATUS_OK;
1935       }
1936     }
1937
1938     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
1939                       &parser->m_position);
1940     nLeftOver = s + len - end;
1941     if (nLeftOver) {
1942       if (parser->m_buffer == NULL
1943           || nLeftOver > parser->m_bufferLim - parser->m_buffer) {
1944         /* avoid _signed_ integer overflow */
1945         char *temp = NULL;
1946         const int bytesToAllocate = (int)((unsigned)len * 2U);
1947         if (bytesToAllocate > 0) {
1948           temp = (char *)REALLOC(parser, parser->m_buffer, bytesToAllocate);
1949         }
1950         if (temp == NULL) {
1951           parser->m_errorCode = XML_ERROR_NO_MEMORY;
1952           parser->m_eventPtr = parser->m_eventEndPtr = NULL;
1953           parser->m_processor = errorProcessor;
1954           return XML_STATUS_ERROR;
1955         }
1956         parser->m_buffer = temp;
1957         parser->m_bufferLim = parser->m_buffer + bytesToAllocate;
1958       }
1959       memcpy(parser->m_buffer, end, nLeftOver);
1960     }
1961     parser->m_bufferPtr = parser->m_buffer;
1962     parser->m_bufferEnd = parser->m_buffer + nLeftOver;
1963     parser->m_positionPtr = parser->m_bufferPtr;
1964     parser->m_parseEndPtr = parser->m_bufferEnd;
1965     parser->m_eventPtr = parser->m_bufferPtr;
1966     parser->m_eventEndPtr = parser->m_bufferPtr;
1967     return result;
1968   }
1969 #endif /* not defined XML_CONTEXT_BYTES */
1970   else {
1971     void *buff = XML_GetBuffer(parser, len);
1972     if (buff == NULL)
1973       return XML_STATUS_ERROR;
1974     else {
1975       memcpy(buff, s, len);
1976       return XML_ParseBuffer(parser, len, isFinal);
1977     }
1978   }
1979 }
1980
1981 enum XML_Status XMLCALL
1982 XML_ParseBuffer(XML_Parser parser, int len, int isFinal) {
1983   const char *start;
1984   enum XML_Status result = XML_STATUS_OK;
1985
1986   if (parser == NULL)
1987     return XML_STATUS_ERROR;
1988   switch (parser->m_parsingStatus.parsing) {
1989   case XML_SUSPENDED:
1990     parser->m_errorCode = XML_ERROR_SUSPENDED;
1991     return XML_STATUS_ERROR;
1992   case XML_FINISHED:
1993     parser->m_errorCode = XML_ERROR_FINISHED;
1994     return XML_STATUS_ERROR;
1995   case XML_INITIALIZED:
1996     /* Has someone called XML_GetBuffer successfully before? */
1997     if (! parser->m_bufferPtr) {
1998       parser->m_errorCode = XML_ERROR_NO_BUFFER;
1999       return XML_STATUS_ERROR;
2000     }
2001
2002     if (parser->m_parentParser == NULL && ! startParsing(parser)) {
2003       parser->m_errorCode = XML_ERROR_NO_MEMORY;
2004       return XML_STATUS_ERROR;
2005     }
2006     /* fall through */
2007   default:
2008     parser->m_parsingStatus.parsing = XML_PARSING;
2009   }
2010
2011   start = parser->m_bufferPtr;
2012   parser->m_positionPtr = start;
2013   parser->m_bufferEnd += len;
2014   parser->m_parseEndPtr = parser->m_bufferEnd;
2015   parser->m_parseEndByteIndex += len;
2016   parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
2017
2018   parser->m_errorCode = parser->m_processor(
2019       parser, start, parser->m_parseEndPtr, &parser->m_bufferPtr);
2020
2021   if (parser->m_errorCode != XML_ERROR_NONE) {
2022     parser->m_eventEndPtr = parser->m_eventPtr;
2023     parser->m_processor = errorProcessor;
2024     return XML_STATUS_ERROR;
2025   } else {
2026     switch (parser->m_parsingStatus.parsing) {
2027     case XML_SUSPENDED:
2028       result = XML_STATUS_SUSPENDED;
2029       break;
2030     case XML_INITIALIZED:
2031     case XML_PARSING:
2032       if (isFinal) {
2033         parser->m_parsingStatus.parsing = XML_FINISHED;
2034         return result;
2035       }
2036     default:; /* should not happen */
2037     }
2038   }
2039
2040   XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2041                     parser->m_bufferPtr, &parser->m_position);
2042   parser->m_positionPtr = parser->m_bufferPtr;
2043   return result;
2044 }
2045
2046 void *XMLCALL
2047 XML_GetBuffer(XML_Parser parser, int len) {
2048   if (parser == NULL)
2049     return NULL;
2050   if (len < 0) {
2051     parser->m_errorCode = XML_ERROR_NO_MEMORY;
2052     return NULL;
2053   }
2054   switch (parser->m_parsingStatus.parsing) {
2055   case XML_SUSPENDED:
2056     parser->m_errorCode = XML_ERROR_SUSPENDED;
2057     return NULL;
2058   case XML_FINISHED:
2059     parser->m_errorCode = XML_ERROR_FINISHED;
2060     return NULL;
2061   default:;
2062   }
2063
2064   if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)) {
2065 #ifdef XML_CONTEXT_BYTES
2066     int keep;
2067 #endif /* defined XML_CONTEXT_BYTES */
2068     /* Do not invoke signed arithmetic overflow: */
2069     int neededSize = (int)((unsigned)len
2070                            + (unsigned)EXPAT_SAFE_PTR_DIFF(
2071                                parser->m_bufferEnd, parser->m_bufferPtr));
2072     if (neededSize < 0) {
2073       parser->m_errorCode = XML_ERROR_NO_MEMORY;
2074       return NULL;
2075     }
2076 #ifdef XML_CONTEXT_BYTES
2077     keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
2078     if (keep > XML_CONTEXT_BYTES)
2079       keep = XML_CONTEXT_BYTES;
2080     /* Detect and prevent integer overflow */
2081     if (keep > INT_MAX - neededSize) {
2082       parser->m_errorCode = XML_ERROR_NO_MEMORY;
2083       return NULL;
2084     }
2085     neededSize += keep;
2086 #endif /* defined XML_CONTEXT_BYTES */
2087     if (neededSize
2088         <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
2089 #ifdef XML_CONTEXT_BYTES
2090       if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
2091         int offset
2092             = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)
2093               - keep;
2094         /* The buffer pointers cannot be NULL here; we have at least some bytes
2095          * in the buffer */
2096         memmove(parser->m_buffer, &parser->m_buffer[offset],
2097                 parser->m_bufferEnd - parser->m_bufferPtr + keep);
2098         parser->m_bufferEnd -= offset;
2099         parser->m_bufferPtr -= offset;
2100       }
2101 #else
2102       if (parser->m_buffer && parser->m_bufferPtr) {
2103         memmove(parser->m_buffer, parser->m_bufferPtr,
2104                 EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
2105         parser->m_bufferEnd
2106             = parser->m_buffer
2107               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
2108         parser->m_bufferPtr = parser->m_buffer;
2109       }
2110 #endif /* not defined XML_CONTEXT_BYTES */
2111     } else {
2112       char *newBuf;
2113       int bufferSize
2114           = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferPtr);
2115       if (bufferSize == 0)
2116         bufferSize = INIT_BUFFER_SIZE;
2117       do {
2118         /* Do not invoke signed arithmetic overflow: */
2119         bufferSize = (int)(2U * (unsigned)bufferSize);
2120       } while (bufferSize < neededSize && bufferSize > 0);
2121       if (bufferSize <= 0) {
2122         parser->m_errorCode = XML_ERROR_NO_MEMORY;
2123         return NULL;
2124       }
2125       newBuf = (char *)MALLOC(parser, bufferSize);
2126       if (newBuf == 0) {
2127         parser->m_errorCode = XML_ERROR_NO_MEMORY;
2128         return NULL;
2129       }
2130       parser->m_bufferLim = newBuf + bufferSize;
2131 #ifdef XML_CONTEXT_BYTES
2132       if (parser->m_bufferPtr) {
2133         memcpy(newBuf, &parser->m_bufferPtr[-keep],
2134                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
2135                    + keep);
2136         FREE(parser, parser->m_buffer);
2137         parser->m_buffer = newBuf;
2138         parser->m_bufferEnd
2139             = parser->m_buffer
2140               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
2141               + keep;
2142         parser->m_bufferPtr = parser->m_buffer + keep;
2143       } else {
2144         /* This must be a brand new buffer with no data in it yet */
2145         parser->m_bufferEnd = newBuf;
2146         parser->m_bufferPtr = parser->m_buffer = newBuf;
2147       }
2148 #else
2149       if (parser->m_bufferPtr) {
2150         memcpy(newBuf, parser->m_bufferPtr,
2151                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
2152         FREE(parser, parser->m_buffer);
2153         parser->m_bufferEnd
2154             = newBuf
2155               + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
2156       } else {
2157         /* This must be a brand new buffer with no data in it yet */
2158         parser->m_bufferEnd = newBuf;
2159       }
2160       parser->m_bufferPtr = parser->m_buffer = newBuf;
2161 #endif /* not defined XML_CONTEXT_BYTES */
2162     }
2163     parser->m_eventPtr = parser->m_eventEndPtr = NULL;
2164     parser->m_positionPtr = NULL;
2165   }
2166   return parser->m_bufferEnd;
2167 }
2168
2169 enum XML_Status XMLCALL
2170 XML_StopParser(XML_Parser parser, XML_Bool resumable) {
2171   if (parser == NULL)
2172     return XML_STATUS_ERROR;
2173   switch (parser->m_parsingStatus.parsing) {
2174   case XML_SUSPENDED:
2175     if (resumable) {
2176       parser->m_errorCode = XML_ERROR_SUSPENDED;
2177       return XML_STATUS_ERROR;
2178     }
2179     parser->m_parsingStatus.parsing = XML_FINISHED;
2180     break;
2181   case XML_FINISHED:
2182     parser->m_errorCode = XML_ERROR_FINISHED;
2183     return XML_STATUS_ERROR;
2184   default:
2185     if (resumable) {
2186 #ifdef XML_DTD
2187       if (parser->m_isParamEntity) {
2188         parser->m_errorCode = XML_ERROR_SUSPEND_PE;
2189         return XML_STATUS_ERROR;
2190       }
2191 #endif
2192       parser->m_parsingStatus.parsing = XML_SUSPENDED;
2193     } else
2194       parser->m_parsingStatus.parsing = XML_FINISHED;
2195   }
2196   return XML_STATUS_OK;
2197 }
2198
2199 enum XML_Status XMLCALL
2200 XML_ResumeParser(XML_Parser parser) {
2201   enum XML_Status result = XML_STATUS_OK;
2202
2203   if (parser == NULL)
2204     return XML_STATUS_ERROR;
2205   if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
2206     parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
2207     return XML_STATUS_ERROR;
2208   }
2209   parser->m_parsingStatus.parsing = XML_PARSING;
2210
2211   parser->m_errorCode = parser->m_processor(
2212       parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
2213
2214   if (parser->m_errorCode != XML_ERROR_NONE) {
2215     parser->m_eventEndPtr = parser->m_eventPtr;
2216     parser->m_processor = errorProcessor;
2217     return XML_STATUS_ERROR;
2218   } else {
2219     switch (parser->m_parsingStatus.parsing) {
2220     case XML_SUSPENDED:
2221       result = XML_STATUS_SUSPENDED;
2222       break;
2223     case XML_INITIALIZED:
2224     case XML_PARSING:
2225       if (parser->m_parsingStatus.finalBuffer) {
2226         parser->m_parsingStatus.parsing = XML_FINISHED;
2227         return result;
2228       }
2229     default:;
2230     }
2231   }
2232
2233   XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2234                     parser->m_bufferPtr, &parser->m_position);
2235   parser->m_positionPtr = parser->m_bufferPtr;
2236   return result;
2237 }
2238
2239 void XMLCALL
2240 XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {
2241   if (parser == NULL)
2242     return;
2243   assert(status != NULL);
2244   *status = parser->m_parsingStatus;
2245 }
2246
2247 enum XML_Error XMLCALL
2248 XML_GetErrorCode(XML_Parser parser) {
2249   if (parser == NULL)
2250     return XML_ERROR_INVALID_ARGUMENT;
2251   return parser->m_errorCode;
2252 }
2253
2254 XML_Index XMLCALL
2255 XML_GetCurrentByteIndex(XML_Parser parser) {
2256   if (parser == NULL)
2257     return -1;
2258   if (parser->m_eventPtr)
2259     return (XML_Index)(parser->m_parseEndByteIndex
2260                        - (parser->m_parseEndPtr - parser->m_eventPtr));
2261   return -1;
2262 }
2263
2264 int XMLCALL
2265 XML_GetCurrentByteCount(XML_Parser parser) {
2266   if (parser == NULL)
2267     return 0;
2268   if (parser->m_eventEndPtr && parser->m_eventPtr)
2269     return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
2270   return 0;
2271 }
2272
2273 const char *XMLCALL
2274 XML_GetInputContext(XML_Parser parser, int *offset, int *size) {
2275 #ifdef XML_CONTEXT_BYTES
2276   if (parser == NULL)
2277     return NULL;
2278   if (parser->m_eventPtr && parser->m_buffer) {
2279     if (offset != NULL)
2280       *offset = (int)(parser->m_eventPtr - parser->m_buffer);
2281     if (size != NULL)
2282       *size = (int)(parser->m_bufferEnd - parser->m_buffer);
2283     return parser->m_buffer;
2284   }
2285 #else
2286   (void)parser;
2287   (void)offset;
2288   (void)size;
2289 #endif /* defined XML_CONTEXT_BYTES */
2290   return (const char *)0;
2291 }
2292
2293 XML_Size XMLCALL
2294 XML_GetCurrentLineNumber(XML_Parser parser) {
2295   if (parser == NULL)
2296     return 0;
2297   if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
2298     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2299                       parser->m_eventPtr, &parser->m_position);
2300     parser->m_positionPtr = parser->m_eventPtr;
2301   }
2302   return parser->m_position.lineNumber + 1;
2303 }
2304
2305 XML_Size XMLCALL
2306 XML_GetCurrentColumnNumber(XML_Parser parser) {
2307   if (parser == NULL)
2308     return 0;
2309   if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
2310     XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
2311                       parser->m_eventPtr, &parser->m_position);
2312     parser->m_positionPtr = parser->m_eventPtr;
2313   }
2314   return parser->m_position.columnNumber;
2315 }
2316
2317 void XMLCALL
2318 XML_FreeContentModel(XML_Parser parser, XML_Content *model) {
2319   if (parser != NULL)
2320     FREE(parser, model);
2321 }
2322
2323 void *XMLCALL
2324 XML_MemMalloc(XML_Parser parser, size_t size) {
2325   if (parser == NULL)
2326     return NULL;
2327   return MALLOC(parser, size);
2328 }
2329
2330 void *XMLCALL
2331 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {
2332   if (parser == NULL)
2333     return NULL;
2334   return REALLOC(parser, ptr, size);
2335 }
2336
2337 void XMLCALL
2338 XML_MemFree(XML_Parser parser, void *ptr) {
2339   if (parser != NULL)
2340     FREE(parser, ptr);
2341 }
2342
2343 void XMLCALL
2344 XML_DefaultCurrent(XML_Parser parser) {
2345   if (parser == NULL)
2346     return;
2347   if (parser->m_defaultHandler) {
2348     if (parser->m_openInternalEntities)
2349       reportDefault(parser, parser->m_internalEncoding,
2350                     parser->m_openInternalEntities->internalEventPtr,
2351                     parser->m_openInternalEntities->internalEventEndPtr);
2352     else
2353       reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
2354                     parser->m_eventEndPtr);
2355   }
2356 }
2357
2358 const XML_LChar *XMLCALL
2359 XML_ErrorString(enum XML_Error code) {
2360   switch (code) {
2361   case XML_ERROR_NONE:
2362     return NULL;
2363   case XML_ERROR_NO_MEMORY:
2364     return XML_L("out of memory");
2365   case XML_ERROR_SYNTAX:
2366     return XML_L("syntax error");
2367   case XML_ERROR_NO_ELEMENTS:
2368     return XML_L("no element found");
2369   case XML_ERROR_INVALID_TOKEN:
2370     return XML_L("not well-formed (invalid token)");
2371   case XML_ERROR_UNCLOSED_TOKEN:
2372     return XML_L("unclosed token");
2373   case XML_ERROR_PARTIAL_CHAR:
2374     return XML_L("partial character");
2375   case XML_ERROR_TAG_MISMATCH:
2376     return XML_L("mismatched tag");
2377   case XML_ERROR_DUPLICATE_ATTRIBUTE:
2378     return XML_L("duplicate attribute");
2379   case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
2380     return XML_L("junk after document element");
2381   case XML_ERROR_PARAM_ENTITY_REF:
2382     return XML_L("illegal parameter entity reference");
2383   case XML_ERROR_UNDEFINED_ENTITY:
2384     return XML_L("undefined entity");
2385   case XML_ERROR_RECURSIVE_ENTITY_REF:
2386     return XML_L("recursive entity reference");
2387   case XML_ERROR_ASYNC_ENTITY:
2388     return XML_L("asynchronous entity");
2389   case XML_ERROR_BAD_CHAR_REF:
2390     return XML_L("reference to invalid character number");
2391   case XML_ERROR_BINARY_ENTITY_REF:
2392     return XML_L("reference to binary entity");
2393   case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
2394     return XML_L("reference to external entity in attribute");
2395   case XML_ERROR_MISPLACED_XML_PI:
2396     return XML_L("XML or text declaration not at start of entity");
2397   case XML_ERROR_UNKNOWN_ENCODING:
2398     return XML_L("unknown encoding");
2399   case XML_ERROR_INCORRECT_ENCODING:
2400     return XML_L("encoding specified in XML declaration is incorrect");
2401   case XML_ERROR_UNCLOSED_CDATA_SECTION:
2402     return XML_L("unclosed CDATA section");
2403   case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
2404     return XML_L("error in processing external entity reference");
2405   case XML_ERROR_NOT_STANDALONE:
2406     return XML_L("document is not standalone");
2407   case XML_ERROR_UNEXPECTED_STATE:
2408     return XML_L("unexpected parser state - please send a bug report");
2409   case XML_ERROR_ENTITY_DECLARED_IN_PE:
2410     return XML_L("entity declared in parameter entity");
2411   case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
2412     return XML_L("requested feature requires XML_DTD support in Expat");
2413   case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
2414     return XML_L("cannot change setting once parsing has begun");
2415   /* Added in 1.95.7. */
2416   case XML_ERROR_UNBOUND_PREFIX:
2417     return XML_L("unbound prefix");
2418   /* Added in 1.95.8. */
2419   case XML_ERROR_UNDECLARING_PREFIX:
2420     return XML_L("must not undeclare prefix");
2421   case XML_ERROR_INCOMPLETE_PE:
2422     return XML_L("incomplete markup in parameter entity");
2423   case XML_ERROR_XML_DECL:
2424     return XML_L("XML declaration not well-formed");
2425   case XML_ERROR_TEXT_DECL:
2426     return XML_L("text declaration not well-formed");
2427   case XML_ERROR_PUBLICID:
2428     return XML_L("illegal character(s) in public id");
2429   case XML_ERROR_SUSPENDED:
2430     return XML_L("parser suspended");
2431   case XML_ERROR_NOT_SUSPENDED:
2432     return XML_L("parser not suspended");
2433   case XML_ERROR_ABORTED:
2434     return XML_L("parsing aborted");
2435   case XML_ERROR_FINISHED:
2436     return XML_L("parsing finished");
2437   case XML_ERROR_SUSPEND_PE:
2438     return XML_L("cannot suspend in external parameter entity");
2439   /* Added in 2.0.0. */
2440   case XML_ERROR_RESERVED_PREFIX_XML:
2441     return XML_L(
2442         "reserved prefix (xml) must not be undeclared or bound to another namespace name");
2443   case XML_ERROR_RESERVED_PREFIX_XMLNS:
2444     return XML_L("reserved prefix (xmlns) must not be declared or undeclared");
2445   case XML_ERROR_RESERVED_NAMESPACE_URI:
2446     return XML_L(
2447         "prefix must not be bound to one of the reserved namespace names");
2448   /* Added in 2.2.5. */
2449   case XML_ERROR_INVALID_ARGUMENT: /* Constant added in 2.2.1, already */
2450     return XML_L("invalid argument");
2451     /* Added in 2.3.0. */
2452   case XML_ERROR_NO_BUFFER:
2453     return XML_L(
2454         "a successful prior call to function XML_GetBuffer is required");
2455   /* Added in 2.4.0. */
2456   case XML_ERROR_AMPLIFICATION_LIMIT_BREACH:
2457     return XML_L(
2458         "limit on input amplification factor (from DTD and entities) breached");
2459   }
2460   return NULL;
2461 }
2462
2463 const XML_LChar *XMLCALL
2464 XML_ExpatVersion(void) {
2465   /* V1 is used to string-ize the version number. However, it would
2466      string-ize the actual version macro *names* unless we get them
2467      substituted before being passed to V1. CPP is defined to expand
2468      a macro, then rescan for more expansions. Thus, we use V2 to expand
2469      the version macros, then CPP will expand the resulting V1() macro
2470      with the correct numerals. */
2471   /* ### I'm assuming cpp is portable in this respect... */
2472
2473 #define V1(a, b, c) XML_L(#a) XML_L(".") XML_L(#b) XML_L(".") XML_L(#c)
2474 #define V2(a, b, c) XML_L("expat_") V1(a, b, c)
2475
2476   return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
2477
2478 #undef V1
2479 #undef V2
2480 }
2481
2482 XML_Expat_Version XMLCALL
2483 XML_ExpatVersionInfo(void) {
2484   XML_Expat_Version version;
2485
2486   version.major = XML_MAJOR_VERSION;
2487   version.minor = XML_MINOR_VERSION;
2488   version.micro = XML_MICRO_VERSION;
2489
2490   return version;
2491 }
2492
2493 const XML_Feature *XMLCALL
2494 XML_GetFeatureList(void) {
2495   static const XML_Feature features[] = {
2496       {XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"),
2497        sizeof(XML_Char)},
2498       {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
2499        sizeof(XML_LChar)},
2500 #ifdef XML_UNICODE
2501       {XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0},
2502 #endif
2503 #ifdef XML_UNICODE_WCHAR_T
2504       {XML_FEATURE_UNICODE_WCHAR_T, XML_L("XML_UNICODE_WCHAR_T"), 0},
2505 #endif
2506 #ifdef XML_DTD
2507       {XML_FEATURE_DTD, XML_L("XML_DTD"), 0},
2508 #endif
2509 #ifdef XML_CONTEXT_BYTES
2510       {XML_FEATURE_CONTEXT_BYTES, XML_L("XML_CONTEXT_BYTES"),
2511        XML_CONTEXT_BYTES},
2512 #endif
2513 #ifdef XML_MIN_SIZE
2514       {XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0},
2515 #endif
2516 #ifdef XML_NS
2517       {XML_FEATURE_NS, XML_L("XML_NS"), 0},
2518 #endif
2519 #ifdef XML_LARGE_SIZE
2520       {XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
2521 #endif
2522 #ifdef XML_ATTR_INFO
2523       {XML_FEATURE_ATTR_INFO, XML_L("XML_ATTR_INFO"), 0},
2524 #endif
2525 #ifdef XML_DTD
2526       /* Added in Expat 2.4.0. */
2527       {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,
2528        XML_L("XML_BLAP_MAX_AMP"),
2529        (long int)
2530            EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT},
2531       {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT,
2532        XML_L("XML_BLAP_ACT_THRES"),
2533        EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT},
2534 #endif
2535       {XML_FEATURE_END, NULL, 0}};
2536
2537   return features;
2538 }
2539
2540 #ifdef XML_DTD
2541 XML_Bool XMLCALL
2542 XML_SetBillionLaughsAttackProtectionMaximumAmplification(
2543     XML_Parser parser, float maximumAmplificationFactor) {
2544   if ((parser == NULL) || (parser->m_parentParser != NULL)
2545       || isnan(maximumAmplificationFactor)
2546       || (maximumAmplificationFactor < 1.0f)) {
2547     return XML_FALSE;
2548   }
2549   parser->m_accounting.maximumAmplificationFactor = maximumAmplificationFactor;
2550   return XML_TRUE;
2551 }
2552
2553 XML_Bool XMLCALL
2554 XML_SetBillionLaughsAttackProtectionActivationThreshold(
2555     XML_Parser parser, unsigned long long activationThresholdBytes) {
2556   if ((parser == NULL) || (parser->m_parentParser != NULL)) {
2557     return XML_FALSE;
2558   }
2559   parser->m_accounting.activationThresholdBytes = activationThresholdBytes;
2560   return XML_TRUE;
2561 }
2562 #endif /* XML_DTD */
2563
2564 /* Initially tag->rawName always points into the parse buffer;
2565    for those TAG instances opened while the current parse buffer was
2566    processed, and not yet closed, we need to store tag->rawName in a more
2567    permanent location, since the parse buffer is about to be discarded.
2568 */
2569 static XML_Bool
2570 storeRawNames(XML_Parser parser) {
2571   TAG *tag = parser->m_tagStack;
2572   while (tag) {
2573     int bufSize;
2574     int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
2575     size_t rawNameLen;
2576     char *rawNameBuf = tag->buf + nameLen;
2577     /* Stop if already stored.  Since m_tagStack is a stack, we can stop
2578        at the first entry that has already been copied; everything
2579        below it in the stack is already been accounted for in a
2580        previous call to this function.
2581     */
2582     if (tag->rawName == rawNameBuf)
2583       break;
2584     /* For re-use purposes we need to ensure that the
2585        size of tag->buf is a multiple of sizeof(XML_Char).
2586     */
2587     rawNameLen = ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
2588     /* Detect and prevent integer overflow. */
2589     if (rawNameLen > (size_t)INT_MAX - nameLen)
2590       return XML_FALSE;
2591     bufSize = nameLen + (int)rawNameLen;
2592     if (bufSize > tag->bufEnd - tag->buf) {
2593       char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
2594       if (temp == NULL)
2595         return XML_FALSE;
2596       /* if tag->name.str points to tag->buf (only when namespace
2597          processing is off) then we have to update it
2598       */
2599       if (tag->name.str == (XML_Char *)tag->buf)
2600         tag->name.str = (XML_Char *)temp;
2601       /* if tag->name.localPart is set (when namespace processing is on)
2602          then update it as well, since it will always point into tag->buf
2603       */
2604       if (tag->name.localPart)
2605         tag->name.localPart
2606             = (XML_Char *)temp + (tag->name.localPart - (XML_Char *)tag->buf);
2607       tag->buf = temp;
2608       tag->bufEnd = temp + bufSize;
2609       rawNameBuf = temp + nameLen;
2610     }
2611     memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
2612     tag->rawName = rawNameBuf;
2613     tag = tag->parent;
2614   }
2615   return XML_TRUE;
2616 }
2617
2618 static enum XML_Error PTRCALL
2619 contentProcessor(XML_Parser parser, const char *start, const char *end,
2620                  const char **endPtr) {
2621   enum XML_Error result = doContent(
2622       parser, 0, parser->m_encoding, start, end, endPtr,
2623       (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
2624   if (result == XML_ERROR_NONE) {
2625     if (! storeRawNames(parser))
2626       return XML_ERROR_NO_MEMORY;
2627   }
2628   return result;
2629 }
2630
2631 static enum XML_Error PTRCALL
2632 externalEntityInitProcessor(XML_Parser parser, const char *start,
2633                             const char *end, const char **endPtr) {
2634   enum XML_Error result = initializeEncoding(parser);
2635   if (result != XML_ERROR_NONE)
2636     return result;
2637   parser->m_processor = externalEntityInitProcessor2;
2638   return externalEntityInitProcessor2(parser, start, end, endPtr);
2639 }
2640
2641 static enum XML_Error PTRCALL
2642 externalEntityInitProcessor2(XML_Parser parser, const char *start,
2643                              const char *end, const char **endPtr) {
2644   const char *next = start; /* XmlContentTok doesn't always set the last arg */
2645   int tok = XmlContentTok(parser->m_encoding, start, end, &next);
2646   switch (tok) {
2647   case XML_TOK_BOM:
2648 #ifdef XML_DTD
2649     if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,
2650                                   XML_ACCOUNT_DIRECT)) {
2651       accountingOnAbort(parser);
2652       return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
2653     }
2654 #endif /* XML_DTD */
2655
2656     /* If we are at the end of the buffer, this would cause the next stage,
2657        i.e. externalEntityInitProcessor3, to pass control directly to
2658        doContent (by detecting XML_TOK_NONE) without processing any xml text
2659        declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
2660     */
2661     if (next == end && ! parser->m_parsingStatus.finalBuffer) {
2662       *endPtr = next;
2663       return XML_ERROR_NONE;
2664     }
2665     start = next;
2666     break;
2667   case XML_TOK_PARTIAL:
2668     if (! parser->m_parsingStatus.finalBuffer) {
2669       *endPtr = start;
2670       return XML_ERROR_NONE;
2671     }
2672     parser->m_eventPtr = start;
2673     return XML_ERROR_UNCLOSED_TOKEN;
2674   case XML_TOK_PARTIAL_CHAR:
2675     if (! parser->m_parsingStatus.finalBuffer) {
2676       *endPtr = start;
2677       return XML_ERROR_NONE;
2678     }
2679     parser->m_eventPtr = start;
2680     return XML_ERROR_PARTIAL_CHAR;
2681   }
2682   parser->m_processor = externalEntityInitProcessor3;
2683   return externalEntityInitProcessor3(parser, start, end, endPtr);
2684 }
2685
2686 static enum XML_Error PTRCALL
2687 externalEntityInitProcessor3(XML_Parser parser, const char *start,
2688                              const char *end, const char **endPtr) {
2689   int tok;
2690   const char *next = start; /* XmlContentTok doesn't always set the last arg */
2691   parser->m_eventPtr = start;
2692   tok = XmlContentTok(parser->m_encoding, start, end, &next);
2693   /* Note: These bytes are accounted later in:
2694            - processXmlDecl
2695            - externalEntityContentProcessor
2696   */
2697   parser->m_eventEndPtr = next;
2698
2699   switch (tok) {
2700   case XML_TOK_XML_DECL: {
2701     enum XML_Error result;
2702     result = processXmlDecl(parser, 1, start, next);
2703     if (result != XML_ERROR_NONE)
2704       return result;
2705     switch (parser->m_parsingStatus.parsing) {
2706     case XML_SUSPENDED:
2707       *endPtr = next;
2708       return XML_ERROR_NONE;
2709     case XML_FINISHED:
2710       return XML_ERROR_ABORTED;
2711     default:
2712       start = next;
2713     }
2714   } break;
2715   case XML_TOK_PARTIAL:
2716     if (! parser->m_parsingStatus.finalBuffer) {
2717       *endPtr = start;
2718       return XML_ERROR_NONE;
2719     }
2720     return XML_ERROR_UNCLOSED_TOKEN;
2721   case XML_TOK_PARTIAL_CHAR:
2722     if (! parser->m_parsingStatus.finalBuffer) {
2723       *endPtr = start;
2724       return XML_ERROR_NONE;
2725     }
2726     return XML_ERROR_PARTIAL_CHAR;
2727   }
2728   parser->m_processor = externalEntityContentProcessor;
2729   parser->m_tagLevel = 1;
2730   return externalEntityContentProcessor(parser, start, end, endPtr);
2731 }
2732
2733 static enum XML_Error PTRCALL
2734 externalEntityContentProcessor(XML_Parser parser, const char *start,
2735                                const char *end, const char **endPtr) {
2736   enum XML_Error result
2737       = doContent(parser, 1, parser->m_encoding, start, end, endPtr,
2738                   (XML_Bool)! parser->m_parsingStatus.finalBuffer,
2739                   XML_ACCOUNT_ENTITY_EXPANSION);
2740   if (result == XML_ERROR_NONE) {
2741     if (! storeRawNames(parser))
2742       return XML_ERROR_NO_MEMORY;
2743   }
2744   return result;
2745 }
2746
2747 static enum XML_Error
2748 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
2749           const char *s, const char *end, const char **nextPtr,
2750           XML_Bool haveMore, enum XML_Account account) {
2751   /* save one level of indirection */
2752   DTD *const dtd = parser->m_dtd;
2753
2754   const char **eventPP;
2755   const char **eventEndPP;
2756   if (enc == parser->m_encoding) {
2757     eventPP = &parser->m_eventPtr;
2758     eventEndPP = &parser->m_eventEndPtr;
2759   } else {
2760     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
2761     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
2762   }
2763   *eventPP = s;
2764
2765   for (;;) {
2766     const char *next = s; /* XmlContentTok doesn't always set the last arg */
2767     int tok = XmlContentTok(enc, s, end, &next);
2768 #ifdef XML_DTD
2769     const char *accountAfter
2770         = ((tok == XML_TOK_TRAILING_RSQB) || (tok == XML_TOK_TRAILING_CR))
2771               ? (haveMore ? s /* i.e. 0 bytes */ : end)
2772               : next;
2773     if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__,
2774                                   account)) {
2775       accountingOnAbort(parser);
2776       return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
2777     }
2778 #endif
2779     *eventEndPP = next;
2780     switch (tok) {
2781     case XML_TOK_TRAILING_CR:
2782       if (haveMore) {
2783         *nextPtr = s;
2784         return XML_ERROR_NONE;
2785       }
2786       *eventEndPP = end;
2787       if (parser->m_characterDataHandler) {
2788         XML_Char c = 0xA;
2789         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
2790       } else if (parser->m_defaultHandler)
2791         reportDefault(parser, enc, s, end);
2792       /* We are at the end of the final buffer, should we check for
2793          XML_SUSPENDED, XML_FINISHED?
2794       */
2795       if (startTagLevel == 0)
2796         return XML_ERROR_NO_ELEMENTS;
2797       if (parser->m_tagLevel != startTagLevel)
2798         return XML_ERROR_ASYNC_ENTITY;
2799       *nextPtr = end;
2800       return XML_ERROR_NONE;
2801     case XML_TOK_NONE:
2802       if (haveMore) {
2803         *nextPtr = s;
2804         return XML_ERROR_NONE;
2805       }
2806       if (startTagLevel > 0) {
2807         if (parser->m_tagLevel != startTagLevel)
2808           return XML_ERROR_ASYNC_ENTITY;
2809         *nextPtr = s;
2810         return XML_ERROR_NONE;
2811       }
2812       return XML_ERROR_NO_ELEMENTS;
2813     case XML_TOK_INVALID:
2814       *eventPP = next;
2815       return XML_ERROR_INVALID_TOKEN;
2816     case XML_TOK_PARTIAL:
2817       if (haveMore) {
2818         *nextPtr = s;
2819         return XML_ERROR_NONE;
2820       }
2821       return XML_ERROR_UNCLOSED_TOKEN;
2822     case XML_TOK_PARTIAL_CHAR:
2823       if (haveMore) {
2824         *nextPtr = s;
2825         return XML_ERROR_NONE;
2826       }
2827       return XML_ERROR_PARTIAL_CHAR;
2828     case XML_TOK_ENTITY_REF: {
2829       const XML_Char *name;
2830       ENTITY *entity;
2831       XML_Char ch = (XML_Char)XmlPredefinedEntityName(
2832           enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);
2833       if (ch) {
2834 #ifdef XML_DTD
2835         /* NOTE: We are replacing 4-6 characters original input for 1 character
2836          *       so there is no amplification and hence recording without
2837          *       protection. */
2838         accountingDiffTolerated(parser, tok, (char *)&ch,
2839                                 ((char *)&ch) + sizeof(XML_Char), __LINE__,
2840                                 XML_ACCOUNT_ENTITY_EXPANSION);
2841 #endif /* XML_DTD */
2842         if (parser->m_characterDataHandler)
2843           parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
2844         else if (parser->m_defaultHandler)
2845           reportDefault(parser, enc, s, next);
2846         break;
2847       }
2848       name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
2849                              next - enc->minBytesPerChar);
2850       if (! name)
2851         return XML_ERROR_NO_MEMORY;
2852       entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
2853       poolDiscard(&dtd->pool);
2854       /* First, determine if a check for an existing declaration is needed;
2855          if yes, check that the entity exists, and that it is internal,
2856          otherwise call the skipped entity or default handler.
2857       */
2858       if (! dtd->hasParamEntityRefs || dtd->standalone) {
2859         if (! entity)
2860           return XML_ERROR_UNDEFINED_ENTITY;
2861         else if (! entity->is_internal)
2862           return XML_ERROR_ENTITY_DECLARED_IN_PE;
2863       } else if (! entity) {
2864         if (parser->m_skippedEntityHandler)
2865           parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
2866         else if (parser->m_defaultHandler)
2867           reportDefault(parser, enc, s, next);
2868         break;
2869       }
2870       if (entity->open)
2871         return XML_ERROR_RECURSIVE_ENTITY_REF;
2872       if (entity->notation)
2873         return XML_ERROR_BINARY_ENTITY_REF;
2874       if (entity->textPtr) {
2875         enum XML_Error result;
2876         if (! parser->m_defaultExpandInternalEntities) {
2877           if (parser->m_skippedEntityHandler)
2878             parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
2879                                            0);
2880           else if (parser->m_defaultHandler)
2881             reportDefault(parser, enc, s, next);
2882           break;
2883         }
2884         result = processInternalEntity(parser, entity, XML_FALSE);
2885         if (result != XML_ERROR_NONE)
2886           return result;
2887       } else if (parser->m_externalEntityRefHandler) {
2888         const XML_Char *context;
2889         entity->open = XML_TRUE;
2890         context = getContext(parser);
2891         entity->open = XML_FALSE;
2892         if (! context)
2893           return XML_ERROR_NO_MEMORY;
2894         if (! parser->m_externalEntityRefHandler(
2895                 parser->m_externalEntityRefHandlerArg, context, entity->base,
2896                 entity->systemId, entity->publicId))
2897           return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
2898         poolDiscard(&parser->m_tempPool);
2899       } else if (parser->m_defaultHandler)
2900         reportDefault(parser, enc, s, next);
2901       break;
2902     }
2903     case XML_TOK_START_TAG_NO_ATTS:
2904       /* fall through */
2905     case XML_TOK_START_TAG_WITH_ATTS: {
2906       TAG *tag;
2907       enum XML_Error result;
2908       XML_Char *toPtr;
2909       if (parser->m_freeTagList) {
2910         tag = parser->m_freeTagList;
2911         parser->m_freeTagList = parser->m_freeTagList->parent;
2912       } else {
2913         tag = (TAG *)MALLOC(parser, sizeof(TAG));
2914         if (! tag)
2915           return XML_ERROR_NO_MEMORY;
2916         tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
2917         if (! tag->buf) {
2918           FREE(parser, tag);
2919           return XML_ERROR_NO_MEMORY;
2920         }
2921         tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
2922       }
2923       tag->bindings = NULL;
2924       tag->parent = parser->m_tagStack;
2925       parser->m_tagStack = tag;
2926       tag->name.localPart = NULL;
2927       tag->name.prefix = NULL;
2928       tag->rawName = s + enc->minBytesPerChar;
2929       tag->rawNameLength = XmlNameLength(enc, tag->rawName);
2930       ++parser->m_tagLevel;
2931       {
2932         const char *rawNameEnd = tag->rawName + tag->rawNameLength;
2933         const char *fromPtr = tag->rawName;
2934         toPtr = (XML_Char *)tag->buf;
2935         for (;;) {
2936           int bufSize;
2937           int convLen;
2938           const enum XML_Convert_Result convert_res
2939               = XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr,
2940                            (ICHAR *)tag->bufEnd - 1);
2941           convLen = (int)(toPtr - (XML_Char *)tag->buf);
2942           if ((fromPtr >= rawNameEnd)
2943               || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
2944             tag->name.strLen = convLen;
2945             break;
2946           }
2947           bufSize = (int)(tag->bufEnd - tag->buf) << 1;
2948           {
2949             char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
2950             if (temp == NULL)
2951               return XML_ERROR_NO_MEMORY;
2952             tag->buf = temp;
2953             tag->bufEnd = temp + bufSize;
2954             toPtr = (XML_Char *)temp + convLen;
2955           }
2956         }
2957       }
2958       tag->name.str = (XML_Char *)tag->buf;
2959       *toPtr = XML_T('\0');
2960       result
2961           = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account);
2962       if (result)
2963         return result;
2964       if (parser->m_startElementHandler)
2965         parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
2966                                       (const XML_Char **)parser->m_atts);
2967       else if (parser->m_defaultHandler)
2968         reportDefault(parser, enc, s, next);
2969       poolClear(&parser->m_tempPool);
2970       break;
2971     }
2972     case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
2973       /* fall through */
2974     case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: {
2975       const char *rawName = s + enc->minBytesPerChar;
2976       enum XML_Error result;
2977       BINDING *bindings = NULL;
2978       XML_Bool noElmHandlers = XML_TRUE;
2979       TAG_NAME name;
2980       name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
2981                                  rawName + XmlNameLength(enc, rawName));
2982       if (! name.str)
2983         return XML_ERROR_NO_MEMORY;
2984       poolFinish(&parser->m_tempPool);
2985       result = storeAtts(parser, enc, s, &name, &bindings,
2986                          XML_ACCOUNT_NONE /* token spans whole start tag */);
2987       if (result != XML_ERROR_NONE) {
2988         freeBindings(parser, bindings);
2989         return result;
2990       }
2991       poolFinish(&parser->m_tempPool);
2992       if (parser->m_startElementHandler) {
2993         parser->m_startElementHandler(parser->m_handlerArg, name.str,
2994                                       (const XML_Char **)parser->m_atts);
2995         noElmHandlers = XML_FALSE;
2996       }
2997       if (parser->m_endElementHandler) {
2998         if (parser->m_startElementHandler)
2999           *eventPP = *eventEndPP;
3000         parser->m_endElementHandler(parser->m_handlerArg, name.str);
3001         noElmHandlers = XML_FALSE;
3002       }
3003       if (noElmHandlers && parser->m_defaultHandler)
3004         reportDefault(parser, enc, s, next);
3005       poolClear(&parser->m_tempPool);
3006       freeBindings(parser, bindings);
3007     }
3008       if ((parser->m_tagLevel == 0)
3009           && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
3010         if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
3011           parser->m_processor = epilogProcessor;
3012         else
3013           return epilogProcessor(parser, next, end, nextPtr);
3014       }
3015       break;
3016     case XML_TOK_END_TAG:
3017       if (parser->m_tagLevel == startTagLevel)
3018         return XML_ERROR_ASYNC_ENTITY;
3019       else {
3020         int len;
3021         const char *rawName;
3022         TAG *tag = parser->m_tagStack;
3023         rawName = s + enc->minBytesPerChar * 2;
3024         len = XmlNameLength(enc, rawName);
3025         if (len != tag->rawNameLength
3026             || memcmp(tag->rawName, rawName, len) != 0) {
3027           *eventPP = rawName;
3028           return XML_ERROR_TAG_MISMATCH;
3029         }
3030         parser->m_tagStack = tag->parent;
3031         tag->parent = parser->m_freeTagList;
3032         parser->m_freeTagList = tag;
3033         --parser->m_tagLevel;
3034         if (parser->m_endElementHandler) {
3035           const XML_Char *localPart;
3036           const XML_Char *prefix;
3037           XML_Char *uri;
3038           localPart = tag->name.localPart;
3039           if (parser->m_ns && localPart) {
3040             /* localPart and prefix may have been overwritten in
3041                tag->name.str, since this points to the binding->uri
3042                buffer which gets re-used; so we have to add them again
3043             */
3044             uri = (XML_Char *)tag->name.str + tag->name.uriLen;
3045             /* don't need to check for space - already done in storeAtts() */
3046             while (*localPart)
3047               *uri++ = *localPart++;
3048             prefix = (XML_Char *)tag->name.prefix;
3049             if (parser->m_ns_triplets && prefix) {
3050               *uri++ = parser->m_namespaceSeparator;
3051               while (*prefix)
3052                 *uri++ = *prefix++;
3053             }
3054             *uri = XML_T('\0');
3055           }
3056           parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);
3057         } else if (parser->m_defaultHandler)
3058           reportDefault(parser, enc, s, next);
3059         while (tag->bindings) {
3060           BINDING *b = tag->bindings;
3061           if (parser->m_endNamespaceDeclHandler)
3062             parser->m_endNamespaceDeclHandler(parser->m_handlerArg,
3063                                               b->prefix->name);
3064           tag->bindings = tag->bindings->nextTagBinding;
3065           b->nextTagBinding = parser->m_freeBindingList;
3066           parser->m_freeBindingList = b;
3067           b->prefix->binding = b->prevPrefixBinding;
3068         }
3069         if ((parser->m_tagLevel == 0)
3070             && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
3071           if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
3072             parser->m_processor = epilogProcessor;
3073           else
3074             return epilogProcessor(parser, next, end, nextPtr);
3075         }
3076       }
3077       break;
3078     case XML_TOK_CHAR_REF: {
3079       int n = XmlCharRefNumber(enc, s);
3080       if (n < 0)
3081         return XML_ERROR_BAD_CHAR_REF;
3082       if (parser->m_characterDataHandler) {
3083         XML_Char buf[XML_ENCODE_MAX];
3084         parser->m_characterDataHandler(parser->m_handlerArg, buf,
3085                                        XmlEncode(n, (ICHAR *)buf));
3086       } else if (parser->m_defaultHandler)
3087         reportDefault(parser, enc, s, next);
3088     } break;
3089     case XML_TOK_XML_DECL:
3090       return XML_ERROR_MISPLACED_XML_PI;
3091     case XML_TOK_DATA_NEWLINE:
3092       if (parser->m_characterDataHandler) {
3093         XML_Char c = 0xA;
3094         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
3095       } else if (parser->m_defaultHandler)
3096         reportDefault(parser, enc, s, next);
3097       break;
3098     case XML_TOK_CDATA_SECT_OPEN: {
3099       enum XML_Error result;
3100       if (parser->m_startCdataSectionHandler)
3101         parser->m_startCdataSectionHandler(parser->m_handlerArg);
3102       /* BEGIN disabled code */
3103       /* Suppose you doing a transformation on a document that involves
3104          changing only the character data.  You set up a defaultHandler
3105          and a characterDataHandler.  The defaultHandler simply copies
3106          characters through.  The characterDataHandler does the
3107          transformation and writes the characters out escaping them as
3108          necessary.  This case will fail to work if we leave out the
3109          following two lines (because & and < inside CDATA sections will
3110          be incorrectly escaped).
3111
3112          However, now we have a start/endCdataSectionHandler, so it seems
3113          easier to let the user deal with this.
3114       */
3115       else if (0 && parser->m_characterDataHandler)
3116         parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3117                                        0);
3118       /* END disabled code */
3119       else if (parser->m_defaultHandler)
3120         reportDefault(parser, enc, s, next);
3121       result
3122           = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);
3123       if (result != XML_ERROR_NONE)
3124         return result;
3125       else if (! next) {
3126         parser->m_processor = cdataSectionProcessor;
3127         return result;
3128       }
3129     } break;
3130     case XML_TOK_TRAILING_RSQB:
3131       if (haveMore) {
3132         *nextPtr = s;
3133         return XML_ERROR_NONE;
3134       }
3135       if (parser->m_characterDataHandler) {
3136         if (MUST_CONVERT(enc, s)) {
3137           ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3138           XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3139           parser->m_characterDataHandler(
3140               parser->m_handlerArg, parser->m_dataBuf,
3141               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3142         } else
3143           parser->m_characterDataHandler(
3144               parser->m_handlerArg, (XML_Char *)s,
3145               (int)((XML_Char *)end - (XML_Char *)s));
3146       } else if (parser->m_defaultHandler)
3147         reportDefault(parser, enc, s, end);
3148       /* We are at the end of the final buffer, should we check for
3149          XML_SUSPENDED, XML_FINISHED?
3150       */
3151       if (startTagLevel == 0) {
3152         *eventPP = end;
3153         return XML_ERROR_NO_ELEMENTS;
3154       }
3155       if (parser->m_tagLevel != startTagLevel) {
3156         *eventPP = end;
3157         return XML_ERROR_ASYNC_ENTITY;
3158       }
3159       *nextPtr = end;
3160       return XML_ERROR_NONE;
3161     case XML_TOK_DATA_CHARS: {
3162       XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
3163       if (charDataHandler) {
3164         if (MUST_CONVERT(enc, s)) {
3165           for (;;) {
3166             ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
3167             const enum XML_Convert_Result convert_res = XmlConvert(
3168                 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3169             *eventEndPP = s;
3170             charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
3171                             (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
3172             if ((convert_res == XML_CONVERT_COMPLETED)
3173                 || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
3174               break;
3175             *eventPP = s;
3176           }
3177         } else
3178           charDataHandler(parser->m_handlerArg, (XML_Char *)s,
3179                           (int)((XML_Char *)next - (XML_Char *)s));
3180       } else if (parser->m_defaultHandler)
3181         reportDefault(parser, enc, s, next);
3182     } break;
3183     case XML_TOK_PI:
3184       if (! reportProcessingInstruction(parser, enc, s, next))
3185         return XML_ERROR_NO_MEMORY;
3186       break;
3187     case XML_TOK_COMMENT:
3188       if (! reportComment(parser, enc, s, next))
3189         return XML_ERROR_NO_MEMORY;
3190       break;
3191     default:
3192       /* All of the tokens produced by XmlContentTok() have their own
3193        * explicit cases, so this default is not strictly necessary.
3194        * However it is a useful safety net, so we retain the code and
3195        * simply exclude it from the coverage tests.
3196        *
3197        * LCOV_EXCL_START
3198        */
3199       if (parser->m_defaultHandler)
3200         reportDefault(parser, enc, s, next);
3201       break;
3202       /* LCOV_EXCL_STOP */
3203     }
3204     *eventPP = s = next;
3205     switch (parser->m_parsingStatus.parsing) {
3206     case XML_SUSPENDED:
3207       *nextPtr = next;
3208       return XML_ERROR_NONE;
3209     case XML_FINISHED:
3210       return XML_ERROR_ABORTED;
3211     default:;
3212     }
3213   }
3214   /* not reached */
3215 }
3216
3217 /* This function does not call free() on the allocated memory, merely
3218  * moving it to the parser's m_freeBindingList where it can be freed or
3219  * reused as appropriate.
3220  */
3221 static void
3222 freeBindings(XML_Parser parser, BINDING *bindings) {
3223   while (bindings) {
3224     BINDING *b = bindings;
3225
3226     /* m_startNamespaceDeclHandler will have been called for this
3227      * binding in addBindings(), so call the end handler now.
3228      */
3229     if (parser->m_endNamespaceDeclHandler)
3230       parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
3231
3232     bindings = bindings->nextTagBinding;
3233     b->nextTagBinding = parser->m_freeBindingList;
3234     parser->m_freeBindingList = b;
3235     b->prefix->binding = b->prevPrefixBinding;
3236   }
3237 }
3238
3239 /* Precondition: all arguments must be non-NULL;
3240    Purpose:
3241    - normalize attributes
3242    - check attributes for well-formedness
3243    - generate namespace aware attribute names (URI, prefix)
3244    - build list of attributes for startElementHandler
3245    - default attributes
3246    - process namespace declarations (check and report them)
3247    - generate namespace aware element name (URI, prefix)
3248 */
3249 static enum XML_Error
3250 storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,
3251           TAG_NAME *tagNamePtr, BINDING **bindingsPtr,
3252           enum XML_Account account) {
3253   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
3254   ELEMENT_TYPE *elementType;
3255   int nDefaultAtts;
3256   const XML_Char **appAtts; /* the attribute list for the application */
3257   int attIndex = 0;
3258   int prefixLen;
3259   int i;
3260   int n;
3261   XML_Char *uri;
3262   int nPrefixes = 0;
3263   BINDING *binding;
3264   const XML_Char *localPart;
3265
3266   /* lookup the element type name */
3267   elementType
3268       = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);
3269   if (! elementType) {
3270     const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
3271     if (! name)
3272       return XML_ERROR_NO_MEMORY;
3273     elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
3274                                          sizeof(ELEMENT_TYPE));
3275     if (! elementType)
3276       return XML_ERROR_NO_MEMORY;
3277     if (parser->m_ns && ! setElementTypePrefix(parser, elementType))
3278       return XML_ERROR_NO_MEMORY;
3279   }
3280   nDefaultAtts = elementType->nDefaultAtts;
3281
3282   /* get the attributes from the tokenizer */
3283   n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);
3284
3285   /* Detect and prevent integer overflow */
3286   if (n > INT_MAX - nDefaultAtts) {
3287     return XML_ERROR_NO_MEMORY;
3288   }
3289
3290   if (n + nDefaultAtts > parser->m_attsSize) {
3291     int oldAttsSize = parser->m_attsSize;
3292     ATTRIBUTE *temp;
3293 #ifdef XML_ATTR_INFO
3294     XML_AttrInfo *temp2;
3295 #endif
3296
3297     /* Detect and prevent integer overflow */
3298     if ((nDefaultAtts > INT_MAX - INIT_ATTS_SIZE)
3299         || (n > INT_MAX - (nDefaultAtts + INIT_ATTS_SIZE))) {
3300       return XML_ERROR_NO_MEMORY;
3301     }
3302
3303     parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
3304
3305     /* Detect and prevent integer overflow.
3306      * The preprocessor guard addresses the "always false" warning
3307      * from -Wtype-limits on platforms where
3308      * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
3309 #if UINT_MAX >= SIZE_MAX
3310     if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(ATTRIBUTE)) {
3311       parser->m_attsSize = oldAttsSize;
3312       return XML_ERROR_NO_MEMORY;
3313     }
3314 #endif
3315
3316     temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts,
3317                                 parser->m_attsSize * sizeof(ATTRIBUTE));
3318     if (temp == NULL) {
3319       parser->m_attsSize = oldAttsSize;
3320       return XML_ERROR_NO_MEMORY;
3321     }
3322     parser->m_atts = temp;
3323 #ifdef XML_ATTR_INFO
3324     /* Detect and prevent integer overflow.
3325      * The preprocessor guard addresses the "always false" warning
3326      * from -Wtype-limits on platforms where
3327      * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
3328 #  if UINT_MAX >= SIZE_MAX
3329     if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(XML_AttrInfo)) {
3330       parser->m_attsSize = oldAttsSize;
3331       return XML_ERROR_NO_MEMORY;
3332     }
3333 #  endif
3334
3335     temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo,
3336                                     parser->m_attsSize * sizeof(XML_AttrInfo));
3337     if (temp2 == NULL) {
3338       parser->m_attsSize = oldAttsSize;
3339       return XML_ERROR_NO_MEMORY;
3340     }
3341     parser->m_attInfo = temp2;
3342 #endif
3343     if (n > oldAttsSize)
3344       XmlGetAttributes(enc, attStr, n, parser->m_atts);
3345   }
3346
3347   appAtts = (const XML_Char **)parser->m_atts;
3348   for (i = 0; i < n; i++) {
3349     ATTRIBUTE *currAtt = &parser->m_atts[i];
3350 #ifdef XML_ATTR_INFO
3351     XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];
3352 #endif
3353     /* add the name and value to the attribute list */
3354     ATTRIBUTE_ID *attId
3355         = getAttributeId(parser, enc, currAtt->name,
3356                          currAtt->name + XmlNameLength(enc, currAtt->name));
3357     if (! attId)
3358       return XML_ERROR_NO_MEMORY;
3359 #ifdef XML_ATTR_INFO
3360     currAttInfo->nameStart
3361         = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
3362     currAttInfo->nameEnd
3363         = currAttInfo->nameStart + XmlNameLength(enc, currAtt->name);
3364     currAttInfo->valueStart = parser->m_parseEndByteIndex
3365                               - (parser->m_parseEndPtr - currAtt->valuePtr);
3366     currAttInfo->valueEnd = parser->m_parseEndByteIndex
3367                             - (parser->m_parseEndPtr - currAtt->valueEnd);
3368 #endif
3369     /* Detect duplicate attributes by their QNames. This does not work when
3370        namespace processing is turned on and different prefixes for the same
3371        namespace are used. For this case we have a check further down.
3372     */
3373     if ((attId->name)[-1]) {
3374       if (enc == parser->m_encoding)
3375         parser->m_eventPtr = parser->m_atts[i].name;
3376       return XML_ERROR_DUPLICATE_ATTRIBUTE;
3377     }
3378     (attId->name)[-1] = 1;
3379     appAtts[attIndex++] = attId->name;
3380     if (! parser->m_atts[i].normalized) {
3381       enum XML_Error result;
3382       XML_Bool isCdata = XML_TRUE;
3383
3384       /* figure out whether declared as other than CDATA */
3385       if (attId->maybeTokenized) {
3386         int j;
3387         for (j = 0; j < nDefaultAtts; j++) {
3388           if (attId == elementType->defaultAtts[j].id) {
3389             isCdata = elementType->defaultAtts[j].isCdata;
3390             break;
3391           }
3392         }
3393       }
3394
3395       /* normalize the attribute value */
3396       result = storeAttributeValue(
3397           parser, enc, isCdata, parser->m_atts[i].valuePtr,
3398           parser->m_atts[i].valueEnd, &parser->m_tempPool, account);
3399       if (result)
3400         return result;
3401       appAtts[attIndex] = poolStart(&parser->m_tempPool);
3402       poolFinish(&parser->m_tempPool);
3403     } else {
3404       /* the value did not need normalizing */
3405       appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,
3406                                           parser->m_atts[i].valuePtr,
3407                                           parser->m_atts[i].valueEnd);
3408       if (appAtts[attIndex] == 0)
3409         return XML_ERROR_NO_MEMORY;
3410       poolFinish(&parser->m_tempPool);
3411     }
3412     /* handle prefixed attribute names */
3413     if (attId->prefix) {
3414       if (attId->xmlns) {
3415         /* deal with namespace declarations here */
3416         enum XML_Error result = addBinding(parser, attId->prefix, attId,
3417                                            appAtts[attIndex], bindingsPtr);
3418         if (result)
3419           return result;
3420         --attIndex;
3421       } else {
3422         /* deal with other prefixed names later */
3423         attIndex++;
3424         nPrefixes++;
3425         (attId->name)[-1] = 2;
3426       }
3427     } else
3428       attIndex++;
3429   }
3430
3431   /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
3432   parser->m_nSpecifiedAtts = attIndex;
3433   if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
3434     for (i = 0; i < attIndex; i += 2)
3435       if (appAtts[i] == elementType->idAtt->name) {
3436         parser->m_idAttIndex = i;
3437         break;
3438       }
3439   } else
3440     parser->m_idAttIndex = -1;
3441
3442   /* do attribute defaulting */
3443   for (i = 0; i < nDefaultAtts; i++) {
3444     const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
3445     if (! (da->id->name)[-1] && da->value) {
3446       if (da->id->prefix) {
3447         if (da->id->xmlns) {
3448           enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
3449                                              da->value, bindingsPtr);
3450           if (result)
3451             return result;
3452         } else {
3453           (da->id->name)[-1] = 2;
3454           nPrefixes++;
3455           appAtts[attIndex++] = da->id->name;
3456           appAtts[attIndex++] = da->value;
3457         }
3458       } else {
3459         (da->id->name)[-1] = 1;
3460         appAtts[attIndex++] = da->id->name;
3461         appAtts[attIndex++] = da->value;
3462       }
3463     }
3464   }
3465   appAtts[attIndex] = 0;
3466
3467   /* expand prefixed attribute names, check for duplicates,
3468      and clear flags that say whether attributes were specified */
3469   i = 0;
3470   if (nPrefixes) {
3471     int j; /* hash table index */
3472     unsigned long version = parser->m_nsAttsVersion;
3473
3474     /* Detect and prevent invalid shift */
3475     if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) {
3476       return XML_ERROR_NO_MEMORY;
3477     }
3478
3479     unsigned int nsAttsSize = 1u << parser->m_nsAttsPower;
3480     unsigned char oldNsAttsPower = parser->m_nsAttsPower;
3481     /* size of hash table must be at least 2 * (# of prefixed attributes) */
3482     if ((nPrefixes << 1)
3483         >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */
3484       NS_ATT *temp;
3485       /* hash table size must also be a power of 2 and >= 8 */
3486       while (nPrefixes >> parser->m_nsAttsPower++)
3487         ;
3488       if (parser->m_nsAttsPower < 3)
3489         parser->m_nsAttsPower = 3;
3490
3491       /* Detect and prevent invalid shift */
3492       if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) {
3493         /* Restore actual size of memory in m_nsAtts */
3494         parser->m_nsAttsPower = oldNsAttsPower;
3495         return XML_ERROR_NO_MEMORY;
3496       }
3497
3498       nsAttsSize = 1u << parser->m_nsAttsPower;
3499
3500       /* Detect and prevent integer overflow.
3501        * The preprocessor guard addresses the "always false" warning
3502        * from -Wtype-limits on platforms where
3503        * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
3504 #if UINT_MAX >= SIZE_MAX
3505       if (nsAttsSize > (size_t)(-1) / sizeof(NS_ATT)) {
3506         /* Restore actual size of memory in m_nsAtts */
3507         parser->m_nsAttsPower = oldNsAttsPower;
3508         return XML_ERROR_NO_MEMORY;
3509       }
3510 #endif
3511
3512       temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts,
3513                                nsAttsSize * sizeof(NS_ATT));
3514       if (! temp) {
3515         /* Restore actual size of memory in m_nsAtts */
3516         parser->m_nsAttsPower = oldNsAttsPower;
3517         return XML_ERROR_NO_MEMORY;
3518       }
3519       parser->m_nsAtts = temp;
3520       version = 0; /* force re-initialization of m_nsAtts hash table */
3521     }
3522     /* using a version flag saves us from initializing m_nsAtts every time */
3523     if (! version) { /* initialize version flags when version wraps around */
3524       version = INIT_ATTS_VERSION;
3525       for (j = nsAttsSize; j != 0;)
3526         parser->m_nsAtts[--j].version = version;
3527     }
3528     parser->m_nsAttsVersion = --version;
3529
3530     /* expand prefixed names and check for duplicates */
3531     for (; i < attIndex; i += 2) {
3532       const XML_Char *s = appAtts[i];
3533       if (s[-1] == 2) { /* prefixed */
3534         ATTRIBUTE_ID *id;
3535         const BINDING *b;
3536         unsigned long uriHash;
3537         struct siphash sip_state;
3538         struct sipkey sip_key;
3539
3540         copy_salt_to_sipkey(parser, &sip_key);
3541         sip24_init(&sip_state, &sip_key);
3542
3543         ((XML_Char *)s)[-1] = 0; /* clear flag */
3544         id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
3545         if (! id || ! id->prefix) {
3546           /* This code is walking through the appAtts array, dealing
3547            * with (in this case) a prefixed attribute name.  To be in
3548            * the array, the attribute must have already been bound, so
3549            * has to have passed through the hash table lookup once
3550            * already.  That implies that an entry for it already
3551            * exists, so the lookup above will return a pointer to
3552            * already allocated memory.  There is no opportunaity for
3553            * the allocator to fail, so the condition above cannot be
3554            * fulfilled.
3555            *
3556            * Since it is difficult to be certain that the above
3557            * analysis is complete, we retain the test and merely
3558            * remove the code from coverage tests.
3559            */
3560           return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
3561         }
3562         b = id->prefix->binding;
3563         if (! b)
3564           return XML_ERROR_UNBOUND_PREFIX;
3565
3566         for (j = 0; j < b->uriLen; j++) {
3567           const XML_Char c = b->uri[j];
3568           if (! poolAppendChar(&parser->m_tempPool, c))
3569             return XML_ERROR_NO_MEMORY;
3570         }
3571
3572         sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char));
3573
3574         while (*s++ != XML_T(ASCII_COLON))
3575           ;
3576
3577         sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));
3578
3579         do { /* copies null terminator */
3580           if (! poolAppendChar(&parser->m_tempPool, *s))
3581             return XML_ERROR_NO_MEMORY;
3582         } while (*s++);
3583
3584         uriHash = (unsigned long)sip24_final(&sip_state);
3585
3586         { /* Check hash table for duplicate of expanded name (uriName).
3587              Derived from code in lookup(parser, HASH_TABLE *table, ...).
3588           */
3589           unsigned char step = 0;
3590           unsigned long mask = nsAttsSize - 1;
3591           j = uriHash & mask; /* index into hash table */
3592           while (parser->m_nsAtts[j].version == version) {
3593             /* for speed we compare stored hash values first */
3594             if (uriHash == parser->m_nsAtts[j].hash) {
3595               const XML_Char *s1 = poolStart(&parser->m_tempPool);
3596               const XML_Char *s2 = parser->m_nsAtts[j].uriName;
3597               /* s1 is null terminated, but not s2 */
3598               for (; *s1 == *s2 && *s1 != 0; s1++, s2++)
3599                 ;
3600               if (*s1 == 0)
3601                 return XML_ERROR_DUPLICATE_ATTRIBUTE;
3602             }
3603             if (! step)
3604               step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);
3605             j < step ? (j += nsAttsSize - step) : (j -= step);
3606           }
3607         }
3608
3609         if (parser->m_ns_triplets) { /* append namespace separator and prefix */
3610           parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;
3611           s = b->prefix->name;
3612           do {
3613             if (! poolAppendChar(&parser->m_tempPool, *s))
3614               return XML_ERROR_NO_MEMORY;
3615           } while (*s++);
3616         }
3617
3618         /* store expanded name in attribute list */
3619         s = poolStart(&parser->m_tempPool);
3620         poolFinish(&parser->m_tempPool);
3621         appAtts[i] = s;
3622
3623         /* fill empty slot with new version, uriName and hash value */
3624         parser->m_nsAtts[j].version = version;
3625         parser->m_nsAtts[j].hash = uriHash;
3626         parser->m_nsAtts[j].uriName = s;
3627
3628         if (! --nPrefixes) {
3629           i += 2;
3630           break;
3631         }
3632       } else                     /* not prefixed */
3633         ((XML_Char *)s)[-1] = 0; /* clear flag */
3634     }
3635   }
3636   /* clear flags for the remaining attributes */
3637   for (; i < attIndex; i += 2)
3638     ((XML_Char *)(appAtts[i]))[-1] = 0;
3639   for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
3640     binding->attId->name[-1] = 0;
3641
3642   if (! parser->m_ns)
3643     return XML_ERROR_NONE;
3644
3645   /* expand the element type name */
3646   if (elementType->prefix) {
3647     binding = elementType->prefix->binding;
3648     if (! binding)
3649       return XML_ERROR_UNBOUND_PREFIX;
3650     localPart = tagNamePtr->str;
3651     while (*localPart++ != XML_T(ASCII_COLON))
3652       ;
3653   } else if (dtd->defaultPrefix.binding) {
3654     binding = dtd->defaultPrefix.binding;
3655     localPart = tagNamePtr->str;
3656   } else
3657     return XML_ERROR_NONE;
3658   prefixLen = 0;
3659   if (parser->m_ns_triplets && binding->prefix->name) {
3660     for (; binding->prefix->name[prefixLen++];)
3661       ; /* prefixLen includes null terminator */
3662   }
3663   tagNamePtr->localPart = localPart;
3664   tagNamePtr->uriLen = binding->uriLen;
3665   tagNamePtr->prefix = binding->prefix->name;
3666   tagNamePtr->prefixLen = prefixLen;
3667   for (i = 0; localPart[i++];)
3668     ; /* i includes null terminator */
3669
3670   /* Detect and prevent integer overflow */
3671   if (binding->uriLen > INT_MAX - prefixLen
3672       || i > INT_MAX - (binding->uriLen + prefixLen)) {
3673     return XML_ERROR_NO_MEMORY;
3674   }
3675
3676   n = i + binding->uriLen + prefixLen;
3677   if (n > binding->uriAlloc) {
3678     TAG *p;
3679
3680     /* Detect and prevent integer overflow */
3681     if (n > INT_MAX - EXPAND_SPARE) {
3682       return XML_ERROR_NO_MEMORY;
3683     }
3684     /* Detect and prevent integer overflow.
3685      * The preprocessor guard addresses the "always false" warning
3686      * from -Wtype-limits on platforms where
3687      * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
3688 #if UINT_MAX >= SIZE_MAX
3689     if ((unsigned)(n + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
3690       return XML_ERROR_NO_MEMORY;
3691     }
3692 #endif
3693
3694     uri = (XML_Char *)MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));
3695     if (! uri)
3696       return XML_ERROR_NO_MEMORY;
3697     binding->uriAlloc = n + EXPAND_SPARE;
3698     memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
3699     for (p = parser->m_tagStack; p; p = p->parent)
3700       if (p->name.str == binding->uri)
3701         p->name.str = uri;
3702     FREE(parser, binding->uri);
3703     binding->uri = uri;
3704   }
3705   /* if m_namespaceSeparator != '\0' then uri includes it already */
3706   uri = binding->uri + binding->uriLen;
3707   memcpy(uri, localPart, i * sizeof(XML_Char));
3708   /* we always have a namespace separator between localPart and prefix */
3709   if (prefixLen) {
3710     uri += i - 1;
3711     *uri = parser->m_namespaceSeparator; /* replace null terminator */
3712     memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
3713   }
3714   tagNamePtr->str = binding->uri;
3715   return XML_ERROR_NONE;
3716 }
3717
3718 static XML_Bool
3719 is_rfc3986_uri_char(XML_Char candidate) {
3720   // For the RFC 3986 ANBF grammar see
3721   // https://datatracker.ietf.org/doc/html/rfc3986#appendix-A
3722
3723   switch (candidate) {
3724   // From rule "ALPHA" (uppercase half)
3725   case 'A':
3726   case 'B':
3727   case 'C':
3728   case 'D':
3729   case 'E':
3730   case 'F':
3731   case 'G':
3732   case 'H':
3733   case 'I':
3734   case 'J':
3735   case 'K':
3736   case 'L':
3737   case 'M':
3738   case 'N':
3739   case 'O':
3740   case 'P':
3741   case 'Q':
3742   case 'R':
3743   case 'S':
3744   case 'T':
3745   case 'U':
3746   case 'V':
3747   case 'W':
3748   case 'X':
3749   case 'Y':
3750   case 'Z':
3751
3752   // From rule "ALPHA" (lowercase half)
3753   case 'a':
3754   case 'b':
3755   case 'c':
3756   case 'd':
3757   case 'e':
3758   case 'f':
3759   case 'g':
3760   case 'h':
3761   case 'i':
3762   case 'j':
3763   case 'k':
3764   case 'l':
3765   case 'm':
3766   case 'n':
3767   case 'o':
3768   case 'p':
3769   case 'q':
3770   case 'r':
3771   case 's':
3772   case 't':
3773   case 'u':
3774   case 'v':
3775   case 'w':
3776   case 'x':
3777   case 'y':
3778   case 'z':
3779
3780   // From rule "DIGIT"
3781   case '0':
3782   case '1':
3783   case '2':
3784   case '3':
3785   case '4':
3786   case '5':
3787   case '6':
3788   case '7':
3789   case '8':
3790   case '9':
3791
3792   // From rule "pct-encoded"
3793   case '%':
3794
3795   // From rule "unreserved"
3796   case '-':
3797   case '.':
3798   case '_':
3799   case '~':
3800
3801   // From rule "gen-delims"
3802   case ':':
3803   case '/':
3804   case '?':
3805   case '#':
3806   case '[':
3807   case ']':
3808   case '@':
3809
3810   // From rule "sub-delims"
3811   case '!':
3812   case '$':
3813   case '&':
3814   case '\'':
3815   case '(':
3816   case ')':
3817   case '*':
3818   case '+':
3819   case ',':
3820   case ';':
3821   case '=':
3822     return XML_TRUE;
3823
3824   default:
3825     return XML_FALSE;
3826   }
3827 }
3828
3829 /* addBinding() overwrites the value of prefix->binding without checking.
3830    Therefore one must keep track of the old value outside of addBinding().
3831 */
3832 static enum XML_Error
3833 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
3834            const XML_Char *uri, BINDING **bindingsPtr) {
3835   // "http://www.w3.org/XML/1998/namespace"
3836   static const XML_Char xmlNamespace[]
3837       = {ASCII_h,      ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,
3838          ASCII_SLASH,  ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,
3839          ASCII_PERIOD, ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,
3840          ASCII_r,      ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,
3841          ASCII_L,      ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,
3842          ASCII_8,      ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,
3843          ASCII_e,      ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,
3844          ASCII_e,      '\0'};
3845   static const int xmlLen = (int)sizeof(xmlNamespace) / sizeof(XML_Char) - 1;
3846   // "http://www.w3.org/2000/xmlns/"
3847   static const XML_Char xmlnsNamespace[]
3848       = {ASCII_h,     ASCII_t,      ASCII_t, ASCII_p, ASCII_COLON,  ASCII_SLASH,
3849          ASCII_SLASH, ASCII_w,      ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w,
3850          ASCII_3,     ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,      ASCII_SLASH,
3851          ASCII_2,     ASCII_0,      ASCII_0, ASCII_0, ASCII_SLASH,  ASCII_x,
3852          ASCII_m,     ASCII_l,      ASCII_n, ASCII_s, ASCII_SLASH,  '\0'};
3853   static const int xmlnsLen
3854       = (int)sizeof(xmlnsNamespace) / sizeof(XML_Char) - 1;
3855
3856   XML_Bool mustBeXML = XML_FALSE;
3857   XML_Bool isXML = XML_TRUE;
3858   XML_Bool isXMLNS = XML_TRUE;
3859
3860   BINDING *b;
3861   int len;
3862
3863   /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */
3864   if (*uri == XML_T('\0') && prefix->name)
3865     return XML_ERROR_UNDECLARING_PREFIX;
3866
3867   if (prefix->name && prefix->name[0] == XML_T(ASCII_x)
3868       && prefix->name[1] == XML_T(ASCII_m)
3869       && prefix->name[2] == XML_T(ASCII_l)) {
3870     /* Not allowed to bind xmlns */
3871     if (prefix->name[3] == XML_T(ASCII_n) && prefix->name[4] == XML_T(ASCII_s)
3872         && prefix->name[5] == XML_T('\0'))
3873       return XML_ERROR_RESERVED_PREFIX_XMLNS;
3874
3875     if (prefix->name[3] == XML_T('\0'))
3876       mustBeXML = XML_TRUE;
3877   }
3878
3879   for (len = 0; uri[len]; len++) {
3880     if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
3881       isXML = XML_FALSE;
3882
3883     if (! mustBeXML && isXMLNS
3884         && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
3885       isXMLNS = XML_FALSE;
3886
3887     // NOTE: While Expat does not validate namespace URIs against RFC 3986
3888     //       today (and is not REQUIRED to do so with regard to the XML 1.0
3889     //       namespaces specification) we have to at least make sure, that
3890     //       the application on top of Expat (that is likely splitting expanded
3891     //       element names ("qualified names") of form
3892     //       "[uri sep] local [sep prefix] '\0'" back into 1, 2 or 3 pieces
3893     //       in its element handler code) cannot be confused by an attacker
3894     //       putting additional namespace separator characters into namespace
3895     //       declarations.  That would be ambiguous and not to be expected.
3896     //
3897     //       While the HTML API docs of function XML_ParserCreateNS have been
3898     //       advising against use of a namespace separator character that can
3899     //       appear in a URI for >20 years now, some widespread applications
3900     //       are using URI characters (':' (colon) in particular) for a
3901     //       namespace separator, in practice.  To keep these applications
3902     //       functional, we only reject namespaces URIs containing the
3903     //       application-chosen namespace separator if the chosen separator
3904     //       is a non-URI character with regard to RFC 3986.
3905     if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator)
3906         && ! is_rfc3986_uri_char(uri[len])) {
3907       return XML_ERROR_SYNTAX;
3908     }
3909   }
3910   isXML = isXML && len == xmlLen;
3911   isXMLNS = isXMLNS && len == xmlnsLen;
3912
3913   if (mustBeXML != isXML)
3914     return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML
3915                      : XML_ERROR_RESERVED_NAMESPACE_URI;
3916
3917   if (isXMLNS)
3918     return XML_ERROR_RESERVED_NAMESPACE_URI;
3919
3920   if (parser->m_namespaceSeparator)
3921     len++;
3922   if (parser->m_freeBindingList) {
3923     b = parser->m_freeBindingList;
3924     if (len > b->uriAlloc) {
3925       /* Detect and prevent integer overflow */
3926       if (len > INT_MAX - EXPAND_SPARE) {
3927         return XML_ERROR_NO_MEMORY;
3928       }
3929
3930       /* Detect and prevent integer overflow.
3931        * The preprocessor guard addresses the "always false" warning
3932        * from -Wtype-limits on platforms where
3933        * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
3934 #if UINT_MAX >= SIZE_MAX
3935       if ((unsigned)(len + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
3936         return XML_ERROR_NO_MEMORY;
3937       }
3938 #endif
3939
3940       XML_Char *temp = (XML_Char *)REALLOC(
3941           parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
3942       if (temp == NULL)
3943         return XML_ERROR_NO_MEMORY;
3944       b->uri = temp;
3945       b->uriAlloc = len + EXPAND_SPARE;
3946     }
3947     parser->m_freeBindingList = b->nextTagBinding;
3948   } else {
3949     b = (BINDING *)MALLOC(parser, sizeof(BINDING));
3950     if (! b)
3951       return XML_ERROR_NO_MEMORY;
3952
3953     /* Detect and prevent integer overflow */
3954     if (len > INT_MAX - EXPAND_SPARE) {
3955       return XML_ERROR_NO_MEMORY;
3956     }
3957     /* Detect and prevent integer overflow.
3958      * The preprocessor guard addresses the "always false" warning
3959      * from -Wtype-limits on platforms where
3960      * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
3961 #if UINT_MAX >= SIZE_MAX
3962     if ((unsigned)(len + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
3963       return XML_ERROR_NO_MEMORY;
3964     }
3965 #endif
3966
3967     b->uri
3968         = (XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
3969     if (! b->uri) {
3970       FREE(parser, b);
3971       return XML_ERROR_NO_MEMORY;
3972     }
3973     b->uriAlloc = len + EXPAND_SPARE;
3974   }
3975   b->uriLen = len;
3976   memcpy(b->uri, uri, len * sizeof(XML_Char));
3977   if (parser->m_namespaceSeparator)
3978     b->uri[len - 1] = parser->m_namespaceSeparator;
3979   b->prefix = prefix;
3980   b->attId = attId;
3981   b->prevPrefixBinding = prefix->binding;
3982   /* NULL binding when default namespace undeclared */
3983   if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix)
3984     prefix->binding = NULL;
3985   else
3986     prefix->binding = b;
3987   b->nextTagBinding = *bindingsPtr;
3988   *bindingsPtr = b;
3989   /* if attId == NULL then we are not starting a namespace scope */
3990   if (attId && parser->m_startNamespaceDeclHandler)
3991     parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,
3992                                         prefix->binding ? uri : 0);
3993   return XML_ERROR_NONE;
3994 }
3995
3996 /* The idea here is to avoid using stack for each CDATA section when
3997    the whole file is parsed with one call.
3998 */
3999 static enum XML_Error PTRCALL
4000 cdataSectionProcessor(XML_Parser parser, const char *start, const char *end,
4001                       const char **endPtr) {
4002   enum XML_Error result = doCdataSection(
4003       parser, parser->m_encoding, &start, end, endPtr,
4004       (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
4005   if (result != XML_ERROR_NONE)
4006     return result;
4007   if (start) {
4008     if (parser->m_parentParser) { /* we are parsing an external entity */
4009       parser->m_processor = externalEntityContentProcessor;
4010       return externalEntityContentProcessor(parser, start, end, endPtr);
4011     } else {
4012       parser->m_processor = contentProcessor;
4013       return contentProcessor(parser, start, end, endPtr);
4014     }
4015   }
4016   return result;
4017 }
4018
4019 /* startPtr gets set to non-null if the section is closed, and to null if
4020    the section is not yet closed.
4021 */
4022 static enum XML_Error
4023 doCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
4024                const char *end, const char **nextPtr, XML_Bool haveMore,
4025                enum XML_Account account) {
4026   const char *s = *startPtr;
4027   const char **eventPP;
4028   const char **eventEndPP;
4029   if (enc == parser->m_encoding) {
4030     eventPP = &parser->m_eventPtr;
4031     *eventPP = s;
4032     eventEndPP = &parser->m_eventEndPtr;
4033   } else {
4034     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4035     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4036   }
4037   *eventPP = s;
4038   *startPtr = NULL;
4039
4040   for (;;) {
4041     const char *next = s; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */
4042     int tok = XmlCdataSectionTok(enc, s, end, &next);
4043 #ifdef XML_DTD
4044     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4045       accountingOnAbort(parser);
4046       return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
4047     }
4048 #else
4049     UNUSED_P(account);
4050 #endif
4051     *eventEndPP = next;
4052     switch (tok) {
4053     case XML_TOK_CDATA_SECT_CLOSE:
4054       if (parser->m_endCdataSectionHandler)
4055         parser->m_endCdataSectionHandler(parser->m_handlerArg);
4056       /* BEGIN disabled code */
4057       /* see comment under XML_TOK_CDATA_SECT_OPEN */
4058       else if (0 && parser->m_characterDataHandler)
4059         parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
4060                                        0);
4061       /* END disabled code */
4062       else if (parser->m_defaultHandler)
4063         reportDefault(parser, enc, s, next);
4064       *startPtr = next;
4065       *nextPtr = next;
4066       if (parser->m_parsingStatus.parsing == XML_FINISHED)
4067         return XML_ERROR_ABORTED;
4068       else
4069         return XML_ERROR_NONE;
4070     case XML_TOK_DATA_NEWLINE:
4071       if (parser->m_characterDataHandler) {
4072         XML_Char c = 0xA;
4073         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
4074       } else if (parser->m_defaultHandler)
4075         reportDefault(parser, enc, s, next);
4076       break;
4077     case XML_TOK_DATA_CHARS: {
4078       XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
4079       if (charDataHandler) {
4080         if (MUST_CONVERT(enc, s)) {
4081           for (;;) {
4082             ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
4083             const enum XML_Convert_Result convert_res = XmlConvert(
4084                 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
4085             *eventEndPP = next;
4086             charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
4087                             (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
4088             if ((convert_res == XML_CONVERT_COMPLETED)
4089                 || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
4090               break;
4091             *eventPP = s;
4092           }
4093         } else
4094           charDataHandler(parser->m_handlerArg, (XML_Char *)s,
4095                           (int)((XML_Char *)next - (XML_Char *)s));
4096       } else if (parser->m_defaultHandler)
4097         reportDefault(parser, enc, s, next);
4098     } break;
4099     case XML_TOK_INVALID:
4100       *eventPP = next;
4101       return XML_ERROR_INVALID_TOKEN;
4102     case XML_TOK_PARTIAL_CHAR:
4103       if (haveMore) {
4104         *nextPtr = s;
4105         return XML_ERROR_NONE;
4106       }
4107       return XML_ERROR_PARTIAL_CHAR;
4108     case XML_TOK_PARTIAL:
4109     case XML_TOK_NONE:
4110       if (haveMore) {
4111         *nextPtr = s;
4112         return XML_ERROR_NONE;
4113       }
4114       return XML_ERROR_UNCLOSED_CDATA_SECTION;
4115     default:
4116       /* Every token returned by XmlCdataSectionTok() has its own
4117        * explicit case, so this default case will never be executed.
4118        * We retain it as a safety net and exclude it from the coverage
4119        * statistics.
4120        *
4121        * LCOV_EXCL_START
4122        */
4123       *eventPP = next;
4124       return XML_ERROR_UNEXPECTED_STATE;
4125       /* LCOV_EXCL_STOP */
4126     }
4127
4128     *eventPP = s = next;
4129     switch (parser->m_parsingStatus.parsing) {
4130     case XML_SUSPENDED:
4131       *nextPtr = next;
4132       return XML_ERROR_NONE;
4133     case XML_FINISHED:
4134       return XML_ERROR_ABORTED;
4135     default:;
4136     }
4137   }
4138   /* not reached */
4139 }
4140
4141 #ifdef XML_DTD
4142
4143 /* The idea here is to avoid using stack for each IGNORE section when
4144    the whole file is parsed with one call.
4145 */
4146 static enum XML_Error PTRCALL
4147 ignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,
4148                        const char **endPtr) {
4149   enum XML_Error result
4150       = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,
4151                         (XML_Bool)! parser->m_parsingStatus.finalBuffer);
4152   if (result != XML_ERROR_NONE)
4153     return result;
4154   if (start) {
4155     parser->m_processor = prologProcessor;
4156     return prologProcessor(parser, start, end, endPtr);
4157   }
4158   return result;
4159 }
4160
4161 /* startPtr gets set to non-null is the section is closed, and to null
4162    if the section is not yet closed.
4163 */
4164 static enum XML_Error
4165 doIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
4166                 const char *end, const char **nextPtr, XML_Bool haveMore) {
4167   const char *next = *startPtr; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */
4168   int tok;
4169   const char *s = *startPtr;
4170   const char **eventPP;
4171   const char **eventEndPP;
4172   if (enc == parser->m_encoding) {
4173     eventPP = &parser->m_eventPtr;
4174     *eventPP = s;
4175     eventEndPP = &parser->m_eventEndPtr;
4176   } else {
4177     /* It's not entirely clear, but it seems the following two lines
4178      * of code cannot be executed.  The only occasions on which 'enc'
4179      * is not 'encoding' are when this function is called
4180      * from the internal entity processing, and IGNORE sections are an
4181      * error in internal entities.
4182      *
4183      * Since it really isn't clear that this is true, we keep the code
4184      * and just remove it from our coverage tests.
4185      *
4186      * LCOV_EXCL_START
4187      */
4188     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4189     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4190     /* LCOV_EXCL_STOP */
4191   }
4192   *eventPP = s;
4193   *startPtr = NULL;
4194   tok = XmlIgnoreSectionTok(enc, s, end, &next);
4195 #  ifdef XML_DTD
4196   if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4197                                 XML_ACCOUNT_DIRECT)) {
4198     accountingOnAbort(parser);
4199     return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
4200   }
4201 #  endif
4202   *eventEndPP = next;
4203   switch (tok) {
4204   case XML_TOK_IGNORE_SECT:
4205     if (parser->m_defaultHandler)
4206       reportDefault(parser, enc, s, next);
4207     *startPtr = next;
4208     *nextPtr = next;
4209     if (parser->m_parsingStatus.parsing == XML_FINISHED)
4210       return XML_ERROR_ABORTED;
4211     else
4212       return XML_ERROR_NONE;
4213   case XML_TOK_INVALID:
4214     *eventPP = next;
4215     return XML_ERROR_INVALID_TOKEN;
4216   case XML_TOK_PARTIAL_CHAR:
4217     if (haveMore) {
4218       *nextPtr = s;
4219       return XML_ERROR_NONE;
4220     }
4221     return XML_ERROR_PARTIAL_CHAR;
4222   case XML_TOK_PARTIAL:
4223   case XML_TOK_NONE:
4224     if (haveMore) {
4225       *nextPtr = s;
4226       return XML_ERROR_NONE;
4227     }
4228     return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
4229   default:
4230     /* All of the tokens that XmlIgnoreSectionTok() returns have
4231      * explicit cases to handle them, so this default case is never
4232      * executed.  We keep it as a safety net anyway, and remove it
4233      * from our test coverage statistics.
4234      *
4235      * LCOV_EXCL_START
4236      */
4237     *eventPP = next;
4238     return XML_ERROR_UNEXPECTED_STATE;
4239     /* LCOV_EXCL_STOP */
4240   }
4241   /* not reached */
4242 }
4243
4244 #endif /* XML_DTD */
4245
4246 static enum XML_Error
4247 initializeEncoding(XML_Parser parser) {
4248   const char *s;
4249 #ifdef XML_UNICODE
4250   char encodingBuf[128];
4251   /* See comments about `protocolEncodingName` in parserInit() */
4252   if (! parser->m_protocolEncodingName)
4253     s = NULL;
4254   else {
4255     int i;
4256     for (i = 0; parser->m_protocolEncodingName[i]; i++) {
4257       if (i == sizeof(encodingBuf) - 1
4258           || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {
4259         encodingBuf[0] = '\0';
4260         break;
4261       }
4262       encodingBuf[i] = (char)parser->m_protocolEncodingName[i];
4263     }
4264     encodingBuf[i] = '\0';
4265     s = encodingBuf;
4266   }
4267 #else
4268   s = parser->m_protocolEncodingName;
4269 #endif
4270   if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(
4271           &parser->m_initEncoding, &parser->m_encoding, s))
4272     return XML_ERROR_NONE;
4273   return handleUnknownEncoding(parser, parser->m_protocolEncodingName);
4274 }
4275
4276 static enum XML_Error
4277 processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,
4278                const char *next) {
4279   const char *encodingName = NULL;
4280   const XML_Char *storedEncName = NULL;
4281   const ENCODING *newEncoding = NULL;
4282   const char *version = NULL;
4283   const char *versionend = NULL;
4284   const XML_Char *storedversion = NULL;
4285   int standalone = -1;
4286
4287 #ifdef XML_DTD
4288   if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,
4289                                 XML_ACCOUNT_DIRECT)) {
4290     accountingOnAbort(parser);
4291     return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
4292   }
4293 #endif
4294
4295   if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(
4296           isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
4297           &version, &versionend, &encodingName, &newEncoding, &standalone)) {
4298     if (isGeneralTextEntity)
4299       return XML_ERROR_TEXT_DECL;
4300     else
4301       return XML_ERROR_XML_DECL;
4302   }
4303   if (! isGeneralTextEntity && standalone == 1) {
4304     parser->m_dtd->standalone = XML_TRUE;
4305 #ifdef XML_DTD
4306     if (parser->m_paramEntityParsing
4307         == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
4308       parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
4309 #endif /* XML_DTD */
4310   }
4311   if (parser->m_xmlDeclHandler) {
4312     if (encodingName != NULL) {
4313       storedEncName = poolStoreString(
4314           &parser->m_temp2Pool, parser->m_encoding, encodingName,
4315           encodingName + XmlNameLength(parser->m_encoding, encodingName));
4316       if (! storedEncName)
4317         return XML_ERROR_NO_MEMORY;
4318       poolFinish(&parser->m_temp2Pool);
4319     }
4320     if (version) {
4321       storedversion
4322           = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,
4323                             versionend - parser->m_encoding->minBytesPerChar);
4324       if (! storedversion)
4325         return XML_ERROR_NO_MEMORY;
4326     }
4327     parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,
4328                              standalone);
4329   } else if (parser->m_defaultHandler)
4330     reportDefault(parser, parser->m_encoding, s, next);
4331   if (parser->m_protocolEncodingName == NULL) {
4332     if (newEncoding) {
4333       /* Check that the specified encoding does not conflict with what
4334        * the parser has already deduced.  Do we have the same number
4335        * of bytes in the smallest representation of a character?  If
4336        * this is UTF-16, is it the same endianness?
4337        */
4338       if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar
4339           || (newEncoding->minBytesPerChar == 2
4340               && newEncoding != parser->m_encoding)) {
4341         parser->m_eventPtr = encodingName;
4342         return XML_ERROR_INCORRECT_ENCODING;
4343       }
4344       parser->m_encoding = newEncoding;
4345     } else if (encodingName) {
4346       enum XML_Error result;
4347       if (! storedEncName) {
4348         storedEncName = poolStoreString(
4349             &parser->m_temp2Pool, parser->m_encoding, encodingName,
4350             encodingName + XmlNameLength(parser->m_encoding, encodingName));
4351         if (! storedEncName)
4352           return XML_ERROR_NO_MEMORY;
4353       }
4354       result = handleUnknownEncoding(parser, storedEncName);
4355       poolClear(&parser->m_temp2Pool);
4356       if (result == XML_ERROR_UNKNOWN_ENCODING)
4357         parser->m_eventPtr = encodingName;
4358       return result;
4359     }
4360   }
4361
4362   if (storedEncName || storedversion)
4363     poolClear(&parser->m_temp2Pool);
4364
4365   return XML_ERROR_NONE;
4366 }
4367
4368 static enum XML_Error
4369 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {
4370   if (parser->m_unknownEncodingHandler) {
4371     XML_Encoding info;
4372     int i;
4373     for (i = 0; i < 256; i++)
4374       info.map[i] = -1;
4375     info.convert = NULL;
4376     info.data = NULL;
4377     info.release = NULL;
4378     if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,
4379                                          encodingName, &info)) {
4380       ENCODING *enc;
4381       parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());
4382       if (! parser->m_unknownEncodingMem) {
4383         if (info.release)
4384           info.release(info.data);
4385         return XML_ERROR_NO_MEMORY;
4386       }
4387       enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(
4388           parser->m_unknownEncodingMem, info.map, info.convert, info.data);
4389       if (enc) {
4390         parser->m_unknownEncodingData = info.data;
4391         parser->m_unknownEncodingRelease = info.release;
4392         parser->m_encoding = enc;
4393         return XML_ERROR_NONE;
4394       }
4395     }
4396     if (info.release != NULL)
4397       info.release(info.data);
4398   }
4399   return XML_ERROR_UNKNOWN_ENCODING;
4400 }
4401
4402 static enum XML_Error PTRCALL
4403 prologInitProcessor(XML_Parser parser, const char *s, const char *end,
4404                     const char **nextPtr) {
4405   enum XML_Error result = initializeEncoding(parser);
4406   if (result != XML_ERROR_NONE)
4407     return result;
4408   parser->m_processor = prologProcessor;
4409   return prologProcessor(parser, s, end, nextPtr);
4410 }
4411
4412 #ifdef XML_DTD
4413
4414 static enum XML_Error PTRCALL
4415 externalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,
4416                             const char **nextPtr) {
4417   enum XML_Error result = initializeEncoding(parser);
4418   if (result != XML_ERROR_NONE)
4419     return result;
4420
4421   /* we know now that XML_Parse(Buffer) has been called,
4422      so we consider the external parameter entity read */
4423   parser->m_dtd->paramEntityRead = XML_TRUE;
4424
4425   if (parser->m_prologState.inEntityValue) {
4426     parser->m_processor = entityValueInitProcessor;
4427     return entityValueInitProcessor(parser, s, end, nextPtr);
4428   } else {
4429     parser->m_processor = externalParEntProcessor;
4430     return externalParEntProcessor(parser, s, end, nextPtr);
4431   }
4432 }
4433
4434 static enum XML_Error PTRCALL
4435 entityValueInitProcessor(XML_Parser parser, const char *s, const char *end,
4436                          const char **nextPtr) {
4437   int tok;
4438   const char *start = s;
4439   const char *next = start;
4440   parser->m_eventPtr = start;
4441
4442   for (;;) {
4443     tok = XmlPrologTok(parser->m_encoding, start, end, &next);
4444     /* Note: Except for XML_TOK_BOM below, these bytes are accounted later in:
4445              - storeEntityValue
4446              - processXmlDecl
4447     */
4448     parser->m_eventEndPtr = next;
4449     if (tok <= 0) {
4450       if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4451         *nextPtr = s;
4452         return XML_ERROR_NONE;
4453       }
4454       switch (tok) {
4455       case XML_TOK_INVALID:
4456         return XML_ERROR_INVALID_TOKEN;
4457       case XML_TOK_PARTIAL:
4458         return XML_ERROR_UNCLOSED_TOKEN;
4459       case XML_TOK_PARTIAL_CHAR:
4460         return XML_ERROR_PARTIAL_CHAR;
4461       case XML_TOK_NONE: /* start == end */
4462       default:
4463         break;
4464       }
4465       /* found end of entity value - can store it now */
4466       return storeEntityValue(parser, parser->m_encoding, s, end,
4467                               XML_ACCOUNT_DIRECT);
4468     } else if (tok == XML_TOK_XML_DECL) {
4469       enum XML_Error result;
4470       result = processXmlDecl(parser, 0, start, next);
4471       if (result != XML_ERROR_NONE)
4472         return result;
4473       /* At this point, m_parsingStatus.parsing cannot be XML_SUSPENDED.  For
4474        * that to happen, a parameter entity parsing handler must have attempted
4475        * to suspend the parser, which fails and raises an error.  The parser can
4476        * be aborted, but can't be suspended.
4477        */
4478       if (parser->m_parsingStatus.parsing == XML_FINISHED)
4479         return XML_ERROR_ABORTED;
4480       *nextPtr = next;
4481       /* stop scanning for text declaration - we found one */
4482       parser->m_processor = entityValueProcessor;
4483       return entityValueProcessor(parser, next, end, nextPtr);
4484     }
4485     /* If we are at the end of the buffer, this would cause XmlPrologTok to
4486        return XML_TOK_NONE on the next call, which would then cause the
4487        function to exit with *nextPtr set to s - that is what we want for other
4488        tokens, but not for the BOM - we would rather like to skip it;
4489        then, when this routine is entered the next time, XmlPrologTok will
4490        return XML_TOK_INVALID, since the BOM is still in the buffer
4491     */
4492     else if (tok == XML_TOK_BOM && next == end
4493              && ! parser->m_parsingStatus.finalBuffer) {
4494 #  ifdef XML_DTD
4495       if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4496                                     XML_ACCOUNT_DIRECT)) {
4497         accountingOnAbort(parser);
4498         return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
4499       }
4500 #  endif
4501
4502       *nextPtr = next;
4503       return XML_ERROR_NONE;
4504     }
4505     /* If we get this token, we have the start of what might be a
4506        normal tag, but not a declaration (i.e. it doesn't begin with
4507        "<!").  In a DTD context, that isn't legal.
4508     */
4509     else if (tok == XML_TOK_INSTANCE_START) {
4510       *nextPtr = next;
4511       return XML_ERROR_SYNTAX;
4512     }
4513     start = next;
4514     parser->m_eventPtr = start;
4515   }
4516 }
4517
4518 static enum XML_Error PTRCALL
4519 externalParEntProcessor(XML_Parser parser, const char *s, const char *end,
4520                         const char **nextPtr) {
4521   const char *next = s;
4522   int tok;
4523
4524   tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4525   if (tok <= 0) {
4526     if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4527       *nextPtr = s;
4528       return XML_ERROR_NONE;
4529     }
4530     switch (tok) {
4531     case XML_TOK_INVALID:
4532       return XML_ERROR_INVALID_TOKEN;
4533     case XML_TOK_PARTIAL:
4534       return XML_ERROR_UNCLOSED_TOKEN;
4535     case XML_TOK_PARTIAL_CHAR:
4536       return XML_ERROR_PARTIAL_CHAR;
4537     case XML_TOK_NONE: /* start == end */
4538     default:
4539       break;
4540     }
4541   }
4542   /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
4543      However, when parsing an external subset, doProlog will not accept a BOM
4544      as valid, and report a syntax error, so we have to skip the BOM, and
4545      account for the BOM bytes.
4546   */
4547   else if (tok == XML_TOK_BOM) {
4548     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4549                                   XML_ACCOUNT_DIRECT)) {
4550       accountingOnAbort(parser);
4551       return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
4552     }
4553
4554     s = next;
4555     tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4556   }
4557
4558   parser->m_processor = prologProcessor;
4559   return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4560                   (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
4561                   XML_ACCOUNT_DIRECT);
4562 }
4563
4564 static enum XML_Error PTRCALL
4565 entityValueProcessor(XML_Parser parser, const char *s, const char *end,
4566                      const char **nextPtr) {
4567   const char *start = s;
4568   const char *next = s;
4569   const ENCODING *enc = parser->m_encoding;
4570   int tok;
4571
4572   for (;;) {
4573     tok = XmlPrologTok(enc, start, end, &next);
4574     /* Note: These bytes are accounted later in:
4575              - storeEntityValue
4576     */
4577     if (tok <= 0) {
4578       if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
4579         *nextPtr = s;
4580         return XML_ERROR_NONE;
4581       }
4582       switch (tok) {
4583       case XML_TOK_INVALID:
4584         return XML_ERROR_INVALID_TOKEN;
4585       case XML_TOK_PARTIAL:
4586         return XML_ERROR_UNCLOSED_TOKEN;
4587       case XML_TOK_PARTIAL_CHAR:
4588         return XML_ERROR_PARTIAL_CHAR;
4589       case XML_TOK_NONE: /* start == end */
4590       default:
4591         break;
4592       }
4593       /* found end of entity value - can store it now */
4594       return storeEntityValue(parser, enc, s, end, XML_ACCOUNT_DIRECT);
4595     }
4596     start = next;
4597   }
4598 }
4599
4600 #endif /* XML_DTD */
4601
4602 static enum XML_Error PTRCALL
4603 prologProcessor(XML_Parser parser, const char *s, const char *end,
4604                 const char **nextPtr) {
4605   const char *next = s;
4606   int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4607   return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4608                   (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
4609                   XML_ACCOUNT_DIRECT);
4610 }
4611
4612 static enum XML_Error
4613 doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,
4614          int tok, const char *next, const char **nextPtr, XML_Bool haveMore,
4615          XML_Bool allowClosingDoctype, enum XML_Account account) {
4616 #ifdef XML_DTD
4617   static const XML_Char externalSubsetName[] = {ASCII_HASH, '\0'};
4618 #endif /* XML_DTD */
4619   static const XML_Char atypeCDATA[]
4620       = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
4621   static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\0'};
4622   static const XML_Char atypeIDREF[]
4623       = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
4624   static const XML_Char atypeIDREFS[]
4625       = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
4626   static const XML_Char atypeENTITY[]
4627       = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
4628   static const XML_Char atypeENTITIES[]
4629       = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,
4630          ASCII_I, ASCII_E, ASCII_S, '\0'};
4631   static const XML_Char atypeNMTOKEN[]
4632       = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
4633   static const XML_Char atypeNMTOKENS[]
4634       = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,
4635          ASCII_E, ASCII_N, ASCII_S, '\0'};
4636   static const XML_Char notationPrefix[]
4637       = {ASCII_N, ASCII_O, ASCII_T, ASCII_A,      ASCII_T,
4638          ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'};
4639   static const XML_Char enumValueSep[] = {ASCII_PIPE, '\0'};
4640   static const XML_Char enumValueStart[] = {ASCII_LPAREN, '\0'};
4641
4642 #ifndef XML_DTD
4643   UNUSED_P(account);
4644 #endif
4645
4646   /* save one level of indirection */
4647   DTD *const dtd = parser->m_dtd;
4648
4649   const char **eventPP;
4650   const char **eventEndPP;
4651   enum XML_Content_Quant quant;
4652
4653   if (enc == parser->m_encoding) {
4654     eventPP = &parser->m_eventPtr;
4655     eventEndPP = &parser->m_eventEndPtr;
4656   } else {
4657     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
4658     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
4659   }
4660
4661   for (;;) {
4662     int role;
4663     XML_Bool handleDefault = XML_TRUE;
4664     *eventPP = s;
4665     *eventEndPP = next;
4666     if (tok <= 0) {
4667       if (haveMore && tok != XML_TOK_INVALID) {
4668         *nextPtr = s;
4669         return XML_ERROR_NONE;
4670       }
4671       switch (tok) {
4672       case XML_TOK_INVALID:
4673         *eventPP = next;
4674         return XML_ERROR_INVALID_TOKEN;
4675       case XML_TOK_PARTIAL:
4676         return XML_ERROR_UNCLOSED_TOKEN;
4677       case XML_TOK_PARTIAL_CHAR:
4678         return XML_ERROR_PARTIAL_CHAR;
4679       case -XML_TOK_PROLOG_S:
4680         tok = -tok;
4681         break;
4682       case XML_TOK_NONE:
4683 #ifdef XML_DTD
4684         /* for internal PE NOT referenced between declarations */
4685         if (enc != parser->m_encoding
4686             && ! parser->m_openInternalEntities->betweenDecl) {
4687           *nextPtr = s;
4688           return XML_ERROR_NONE;
4689         }
4690         /* WFC: PE Between Declarations - must check that PE contains
4691            complete markup, not only for external PEs, but also for
4692            internal PEs if the reference occurs between declarations.
4693         */
4694         if (parser->m_isParamEntity || enc != parser->m_encoding) {
4695           if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)
4696               == XML_ROLE_ERROR)
4697             return XML_ERROR_INCOMPLETE_PE;
4698           *nextPtr = s;
4699           return XML_ERROR_NONE;
4700         }
4701 #endif /* XML_DTD */
4702         return XML_ERROR_NO_ELEMENTS;
4703       default:
4704         tok = -tok;
4705         next = end;
4706         break;
4707       }
4708     }
4709     role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
4710 #ifdef XML_DTD
4711     switch (role) {
4712     case XML_ROLE_INSTANCE_START: // bytes accounted in contentProcessor
4713     case XML_ROLE_XML_DECL:       // bytes accounted in processXmlDecl
4714     case XML_ROLE_TEXT_DECL:      // bytes accounted in processXmlDecl
4715       break;
4716     default:
4717       if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4718         accountingOnAbort(parser);
4719         return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
4720       }
4721     }
4722 #endif
4723     switch (role) {
4724     case XML_ROLE_XML_DECL: {
4725       enum XML_Error result = processXmlDecl(parser, 0, s, next);
4726       if (result != XML_ERROR_NONE)
4727         return result;
4728       enc = parser->m_encoding;
4729       handleDefault = XML_FALSE;
4730     } break;
4731     case XML_ROLE_DOCTYPE_NAME:
4732       if (parser->m_startDoctypeDeclHandler) {
4733         parser->m_doctypeName
4734             = poolStoreString(&parser->m_tempPool, enc, s, next);
4735         if (! parser->m_doctypeName)
4736           return XML_ERROR_NO_MEMORY;
4737         poolFinish(&parser->m_tempPool);
4738         parser->m_doctypePubid = NULL;
4739         handleDefault = XML_FALSE;
4740       }
4741       parser->m_doctypeSysid = NULL; /* always initialize to NULL */
4742       break;
4743     case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
4744       if (parser->m_startDoctypeDeclHandler) {
4745         parser->m_startDoctypeDeclHandler(
4746             parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
4747             parser->m_doctypePubid, 1);
4748         parser->m_doctypeName = NULL;
4749         poolClear(&parser->m_tempPool);
4750         handleDefault = XML_FALSE;
4751       }
4752       break;
4753 #ifdef XML_DTD
4754     case XML_ROLE_TEXT_DECL: {
4755       enum XML_Error result = processXmlDecl(parser, 1, s, next);
4756       if (result != XML_ERROR_NONE)
4757         return result;
4758       enc = parser->m_encoding;
4759       handleDefault = XML_FALSE;
4760     } break;
4761 #endif /* XML_DTD */
4762     case XML_ROLE_DOCTYPE_PUBLIC_ID:
4763 #ifdef XML_DTD
4764       parser->m_useForeignDTD = XML_FALSE;
4765       parser->m_declEntity = (ENTITY *)lookup(
4766           parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
4767       if (! parser->m_declEntity)
4768         return XML_ERROR_NO_MEMORY;
4769 #endif /* XML_DTD */
4770       dtd->hasParamEntityRefs = XML_TRUE;
4771       if (parser->m_startDoctypeDeclHandler) {
4772         XML_Char *pubId;
4773         if (! XmlIsPublicId(enc, s, next, eventPP))
4774           return XML_ERROR_PUBLICID;
4775         pubId = poolStoreString(&parser->m_tempPool, enc,
4776                                 s + enc->minBytesPerChar,
4777                                 next - enc->minBytesPerChar);
4778         if (! pubId)
4779           return XML_ERROR_NO_MEMORY;
4780         normalizePublicId(pubId);
4781         poolFinish(&parser->m_tempPool);
4782         parser->m_doctypePubid = pubId;
4783         handleDefault = XML_FALSE;
4784         goto alreadyChecked;
4785       }
4786       /* fall through */
4787     case XML_ROLE_ENTITY_PUBLIC_ID:
4788       if (! XmlIsPublicId(enc, s, next, eventPP))
4789         return XML_ERROR_PUBLICID;
4790     alreadyChecked:
4791       if (dtd->keepProcessing && parser->m_declEntity) {
4792         XML_Char *tem
4793             = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
4794                               next - enc->minBytesPerChar);
4795         if (! tem)
4796           return XML_ERROR_NO_MEMORY;
4797         normalizePublicId(tem);
4798         parser->m_declEntity->publicId = tem;
4799         poolFinish(&dtd->pool);
4800         /* Don't suppress the default handler if we fell through from
4801          * the XML_ROLE_DOCTYPE_PUBLIC_ID case.
4802          */
4803         if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)
4804           handleDefault = XML_FALSE;
4805       }
4806       break;
4807     case XML_ROLE_DOCTYPE_CLOSE:
4808       if (allowClosingDoctype != XML_TRUE) {
4809         /* Must not close doctype from within expanded parameter entities */
4810         return XML_ERROR_INVALID_TOKEN;
4811       }
4812
4813       if (parser->m_doctypeName) {
4814         parser->m_startDoctypeDeclHandler(
4815             parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
4816             parser->m_doctypePubid, 0);
4817         poolClear(&parser->m_tempPool);
4818         handleDefault = XML_FALSE;
4819       }
4820       /* parser->m_doctypeSysid will be non-NULL in the case of a previous
4821          XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler
4822          was not set, indicating an external subset
4823       */
4824 #ifdef XML_DTD
4825       if (parser->m_doctypeSysid || parser->m_useForeignDTD) {
4826         XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
4827         dtd->hasParamEntityRefs = XML_TRUE;
4828         if (parser->m_paramEntityParsing
4829             && parser->m_externalEntityRefHandler) {
4830           ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4831                                             externalSubsetName, sizeof(ENTITY));
4832           if (! entity) {
4833             /* The external subset name "#" will have already been
4834              * inserted into the hash table at the start of the
4835              * external entity parsing, so no allocation will happen
4836              * and lookup() cannot fail.
4837              */
4838             return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
4839           }
4840           if (parser->m_useForeignDTD)
4841             entity->base = parser->m_curBase;
4842           dtd->paramEntityRead = XML_FALSE;
4843           if (! parser->m_externalEntityRefHandler(
4844                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
4845                   entity->systemId, entity->publicId))
4846             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
4847           if (dtd->paramEntityRead) {
4848             if (! dtd->standalone && parser->m_notStandaloneHandler
4849                 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
4850               return XML_ERROR_NOT_STANDALONE;
4851           }
4852           /* if we didn't read the foreign DTD then this means that there
4853              is no external subset and we must reset dtd->hasParamEntityRefs
4854           */
4855           else if (! parser->m_doctypeSysid)
4856             dtd->hasParamEntityRefs = hadParamEntityRefs;
4857           /* end of DTD - no need to update dtd->keepProcessing */
4858         }
4859         parser->m_useForeignDTD = XML_FALSE;
4860       }
4861 #endif /* XML_DTD */
4862       if (parser->m_endDoctypeDeclHandler) {
4863         parser->m_endDoctypeDeclHandler(parser->m_handlerArg);
4864         handleDefault = XML_FALSE;
4865       }
4866       break;
4867     case XML_ROLE_INSTANCE_START:
4868 #ifdef XML_DTD
4869       /* if there is no DOCTYPE declaration then now is the
4870          last chance to read the foreign DTD
4871       */
4872       if (parser->m_useForeignDTD) {
4873         XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
4874         dtd->hasParamEntityRefs = XML_TRUE;
4875         if (parser->m_paramEntityParsing
4876             && parser->m_externalEntityRefHandler) {
4877           ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4878                                             externalSubsetName, sizeof(ENTITY));
4879           if (! entity)
4880             return XML_ERROR_NO_MEMORY;
4881           entity->base = parser->m_curBase;
4882           dtd->paramEntityRead = XML_FALSE;
4883           if (! parser->m_externalEntityRefHandler(
4884                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
4885                   entity->systemId, entity->publicId))
4886             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
4887           if (dtd->paramEntityRead) {
4888             if (! dtd->standalone && parser->m_notStandaloneHandler
4889                 && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
4890               return XML_ERROR_NOT_STANDALONE;
4891           }
4892           /* if we didn't read the foreign DTD then this means that there
4893              is no external subset and we must reset dtd->hasParamEntityRefs
4894           */
4895           else
4896             dtd->hasParamEntityRefs = hadParamEntityRefs;
4897           /* end of DTD - no need to update dtd->keepProcessing */
4898         }
4899       }
4900 #endif /* XML_DTD */
4901       parser->m_processor = contentProcessor;
4902       return contentProcessor(parser, s, end, nextPtr);
4903     case XML_ROLE_ATTLIST_ELEMENT_NAME:
4904       parser->m_declElementType = getElementType(parser, enc, s, next);
4905       if (! parser->m_declElementType)
4906         return XML_ERROR_NO_MEMORY;
4907       goto checkAttListDeclHandler;
4908     case XML_ROLE_ATTRIBUTE_NAME:
4909       parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
4910       if (! parser->m_declAttributeId)
4911         return XML_ERROR_NO_MEMORY;
4912       parser->m_declAttributeIsCdata = XML_FALSE;
4913       parser->m_declAttributeType = NULL;
4914       parser->m_declAttributeIsId = XML_FALSE;
4915       goto checkAttListDeclHandler;
4916     case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
4917       parser->m_declAttributeIsCdata = XML_TRUE;
4918       parser->m_declAttributeType = atypeCDATA;
4919       goto checkAttListDeclHandler;
4920     case XML_ROLE_ATTRIBUTE_TYPE_ID:
4921       parser->m_declAttributeIsId = XML_TRUE;
4922       parser->m_declAttributeType = atypeID;
4923       goto checkAttListDeclHandler;
4924     case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
4925       parser->m_declAttributeType = atypeIDREF;
4926       goto checkAttListDeclHandler;
4927     case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
4928       parser->m_declAttributeType = atypeIDREFS;
4929       goto checkAttListDeclHandler;
4930     case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
4931       parser->m_declAttributeType = atypeENTITY;
4932       goto checkAttListDeclHandler;
4933     case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
4934       parser->m_declAttributeType = atypeENTITIES;
4935       goto checkAttListDeclHandler;
4936     case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
4937       parser->m_declAttributeType = atypeNMTOKEN;
4938       goto checkAttListDeclHandler;
4939     case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
4940       parser->m_declAttributeType = atypeNMTOKENS;
4941     checkAttListDeclHandler:
4942       if (dtd->keepProcessing && parser->m_attlistDeclHandler)
4943         handleDefault = XML_FALSE;
4944       break;
4945     case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
4946     case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
4947       if (dtd->keepProcessing && parser->m_attlistDeclHandler) {
4948         const XML_Char *prefix;
4949         if (parser->m_declAttributeType) {
4950           prefix = enumValueSep;
4951         } else {
4952           prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE ? notationPrefix
4953                                                               : enumValueStart);
4954         }
4955         if (! poolAppendString(&parser->m_tempPool, prefix))
4956           return XML_ERROR_NO_MEMORY;
4957         if (! poolAppend(&parser->m_tempPool, enc, s, next))
4958           return XML_ERROR_NO_MEMORY;
4959         parser->m_declAttributeType = parser->m_tempPool.start;
4960         handleDefault = XML_FALSE;
4961       }
4962       break;
4963     case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
4964     case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
4965       if (dtd->keepProcessing) {
4966         if (! defineAttribute(parser->m_declElementType,
4967                               parser->m_declAttributeId,
4968                               parser->m_declAttributeIsCdata,
4969                               parser->m_declAttributeIsId, 0, parser))
4970           return XML_ERROR_NO_MEMORY;
4971         if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
4972           if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
4973               || (*parser->m_declAttributeType == XML_T(ASCII_N)
4974                   && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
4975             /* Enumerated or Notation type */
4976             if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
4977                 || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
4978               return XML_ERROR_NO_MEMORY;
4979             parser->m_declAttributeType = parser->m_tempPool.start;
4980             poolFinish(&parser->m_tempPool);
4981           }
4982           *eventEndPP = s;
4983           parser->m_attlistDeclHandler(
4984               parser->m_handlerArg, parser->m_declElementType->name,
4985               parser->m_declAttributeId->name, parser->m_declAttributeType, 0,
4986               role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
4987           handleDefault = XML_FALSE;
4988         }
4989       }
4990       poolClear(&parser->m_tempPool);
4991       break;
4992     case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
4993     case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
4994       if (dtd->keepProcessing) {
4995         const XML_Char *attVal;
4996         enum XML_Error result = storeAttributeValue(
4997             parser, enc, parser->m_declAttributeIsCdata,
4998             s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd->pool,
4999             XML_ACCOUNT_NONE);
5000         if (result)
5001           return result;
5002         attVal = poolStart(&dtd->pool);
5003         poolFinish(&dtd->pool);
5004         /* ID attributes aren't allowed to have a default */
5005         if (! defineAttribute(
5006                 parser->m_declElementType, parser->m_declAttributeId,
5007                 parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
5008           return XML_ERROR_NO_MEMORY;
5009         if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
5010           if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
5011               || (*parser->m_declAttributeType == XML_T(ASCII_N)
5012                   && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
5013             /* Enumerated or Notation type */
5014             if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
5015                 || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
5016               return XML_ERROR_NO_MEMORY;
5017             parser->m_declAttributeType = parser->m_tempPool.start;
5018             poolFinish(&parser->m_tempPool);
5019           }
5020           *eventEndPP = s;
5021           parser->m_attlistDeclHandler(
5022               parser->m_handlerArg, parser->m_declElementType->name,
5023               parser->m_declAttributeId->name, parser->m_declAttributeType,
5024               attVal, role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
5025           poolClear(&parser->m_tempPool);
5026           handleDefault = XML_FALSE;
5027         }
5028       }
5029       break;
5030     case XML_ROLE_ENTITY_VALUE:
5031       if (dtd->keepProcessing) {
5032         enum XML_Error result
5033             = storeEntityValue(parser, enc, s + enc->minBytesPerChar,
5034                                next - enc->minBytesPerChar, XML_ACCOUNT_NONE);
5035         if (parser->m_declEntity) {
5036           parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);
5037           parser->m_declEntity->textLen
5038               = (int)(poolLength(&dtd->entityValuePool));
5039           poolFinish(&dtd->entityValuePool);
5040           if (parser->m_entityDeclHandler) {
5041             *eventEndPP = s;
5042             parser->m_entityDeclHandler(
5043                 parser->m_handlerArg, parser->m_declEntity->name,
5044                 parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
5045                 parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
5046             handleDefault = XML_FALSE;
5047           }
5048         } else
5049           poolDiscard(&dtd->entityValuePool);
5050         if (result != XML_ERROR_NONE)
5051           return result;
5052       }
5053       break;
5054     case XML_ROLE_DOCTYPE_SYSTEM_ID:
5055 #ifdef XML_DTD
5056       parser->m_useForeignDTD = XML_FALSE;
5057 #endif /* XML_DTD */
5058       dtd->hasParamEntityRefs = XML_TRUE;
5059       if (parser->m_startDoctypeDeclHandler) {
5060         parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,
5061                                                  s + enc->minBytesPerChar,
5062                                                  next - enc->minBytesPerChar);
5063         if (parser->m_doctypeSysid == NULL)
5064           return XML_ERROR_NO_MEMORY;
5065         poolFinish(&parser->m_tempPool);
5066         handleDefault = XML_FALSE;
5067       }
5068 #ifdef XML_DTD
5069       else
5070         /* use externalSubsetName to make parser->m_doctypeSysid non-NULL
5071            for the case where no parser->m_startDoctypeDeclHandler is set */
5072         parser->m_doctypeSysid = externalSubsetName;
5073 #endif /* XML_DTD */
5074       if (! dtd->standalone
5075 #ifdef XML_DTD
5076           && ! parser->m_paramEntityParsing
5077 #endif /* XML_DTD */
5078           && parser->m_notStandaloneHandler
5079           && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5080         return XML_ERROR_NOT_STANDALONE;
5081 #ifndef XML_DTD
5082       break;
5083 #else  /* XML_DTD */
5084       if (! parser->m_declEntity) {
5085         parser->m_declEntity = (ENTITY *)lookup(
5086             parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
5087         if (! parser->m_declEntity)
5088           return XML_ERROR_NO_MEMORY;
5089         parser->m_declEntity->publicId = NULL;
5090       }
5091 #endif /* XML_DTD */
5092       /* fall through */
5093     case XML_ROLE_ENTITY_SYSTEM_ID:
5094       if (dtd->keepProcessing && parser->m_declEntity) {
5095         parser->m_declEntity->systemId
5096             = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
5097                               next - enc->minBytesPerChar);
5098         if (! parser->m_declEntity->systemId)
5099           return XML_ERROR_NO_MEMORY;
5100         parser->m_declEntity->base = parser->m_curBase;
5101         poolFinish(&dtd->pool);
5102         /* Don't suppress the default handler if we fell through from
5103          * the XML_ROLE_DOCTYPE_SYSTEM_ID case.
5104          */
5105         if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)
5106           handleDefault = XML_FALSE;
5107       }
5108       break;
5109     case XML_ROLE_ENTITY_COMPLETE:
5110       if (dtd->keepProcessing && parser->m_declEntity
5111           && parser->m_entityDeclHandler) {
5112         *eventEndPP = s;
5113         parser->m_entityDeclHandler(
5114             parser->m_handlerArg, parser->m_declEntity->name,
5115             parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,
5116             parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);
5117         handleDefault = XML_FALSE;
5118       }
5119       break;
5120     case XML_ROLE_ENTITY_NOTATION_NAME:
5121       if (dtd->keepProcessing && parser->m_declEntity) {
5122         parser->m_declEntity->notation
5123             = poolStoreString(&dtd->pool, enc, s, next);
5124         if (! parser->m_declEntity->notation)
5125           return XML_ERROR_NO_MEMORY;
5126         poolFinish(&dtd->pool);
5127         if (parser->m_unparsedEntityDeclHandler) {
5128           *eventEndPP = s;
5129           parser->m_unparsedEntityDeclHandler(
5130               parser->m_handlerArg, parser->m_declEntity->name,
5131               parser->m_declEntity->base, parser->m_declEntity->systemId,
5132               parser->m_declEntity->publicId, parser->m_declEntity->notation);
5133           handleDefault = XML_FALSE;
5134         } else if (parser->m_entityDeclHandler) {
5135           *eventEndPP = s;
5136           parser->m_entityDeclHandler(
5137               parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,
5138               parser->m_declEntity->base, parser->m_declEntity->systemId,
5139               parser->m_declEntity->publicId, parser->m_declEntity->notation);
5140           handleDefault = XML_FALSE;
5141         }
5142       }
5143       break;
5144     case XML_ROLE_GENERAL_ENTITY_NAME: {
5145       if (XmlPredefinedEntityName(enc, s, next)) {
5146         parser->m_declEntity = NULL;
5147         break;
5148       }
5149       if (dtd->keepProcessing) {
5150         const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
5151         if (! name)
5152           return XML_ERROR_NO_MEMORY;
5153         parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,
5154                                                 name, sizeof(ENTITY));
5155         if (! parser->m_declEntity)
5156           return XML_ERROR_NO_MEMORY;
5157         if (parser->m_declEntity->name != name) {
5158           poolDiscard(&dtd->pool);
5159           parser->m_declEntity = NULL;
5160         } else {
5161           poolFinish(&dtd->pool);
5162           parser->m_declEntity->publicId = NULL;
5163           parser->m_declEntity->is_param = XML_FALSE;
5164           /* if we have a parent parser or are reading an internal parameter
5165              entity, then the entity declaration is not considered "internal"
5166           */
5167           parser->m_declEntity->is_internal
5168               = ! (parser->m_parentParser || parser->m_openInternalEntities);
5169           if (parser->m_entityDeclHandler)
5170             handleDefault = XML_FALSE;
5171         }
5172       } else {
5173         poolDiscard(&dtd->pool);
5174         parser->m_declEntity = NULL;
5175       }
5176     } break;
5177     case XML_ROLE_PARAM_ENTITY_NAME:
5178 #ifdef XML_DTD
5179       if (dtd->keepProcessing) {
5180         const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
5181         if (! name)
5182           return XML_ERROR_NO_MEMORY;
5183         parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
5184                                                 name, sizeof(ENTITY));
5185         if (! parser->m_declEntity)
5186           return XML_ERROR_NO_MEMORY;
5187         if (parser->m_declEntity->name != name) {
5188           poolDiscard(&dtd->pool);
5189           parser->m_declEntity = NULL;
5190         } else {
5191           poolFinish(&dtd->pool);
5192           parser->m_declEntity->publicId = NULL;
5193           parser->m_declEntity->is_param = XML_TRUE;
5194           /* if we have a parent parser or are reading an internal parameter
5195              entity, then the entity declaration is not considered "internal"
5196           */
5197           parser->m_declEntity->is_internal
5198               = ! (parser->m_parentParser || parser->m_openInternalEntities);
5199           if (parser->m_entityDeclHandler)
5200             handleDefault = XML_FALSE;
5201         }
5202       } else {
5203         poolDiscard(&dtd->pool);
5204         parser->m_declEntity = NULL;
5205       }
5206 #else  /* not XML_DTD */
5207       parser->m_declEntity = NULL;
5208 #endif /* XML_DTD */
5209       break;
5210     case XML_ROLE_NOTATION_NAME:
5211       parser->m_declNotationPublicId = NULL;
5212       parser->m_declNotationName = NULL;
5213       if (parser->m_notationDeclHandler) {
5214         parser->m_declNotationName
5215             = poolStoreString(&parser->m_tempPool, enc, s, next);
5216         if (! parser->m_declNotationName)
5217           return XML_ERROR_NO_MEMORY;
5218         poolFinish(&parser->m_tempPool);
5219         handleDefault = XML_FALSE;
5220       }
5221       break;
5222     case XML_ROLE_NOTATION_PUBLIC_ID:
5223       if (! XmlIsPublicId(enc, s, next, eventPP))
5224         return XML_ERROR_PUBLICID;
5225       if (parser
5226               ->m_declNotationName) { /* means m_notationDeclHandler != NULL */
5227         XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,
5228                                         s + enc->minBytesPerChar,
5229                                         next - enc->minBytesPerChar);
5230         if (! tem)
5231           return XML_ERROR_NO_MEMORY;
5232         normalizePublicId(tem);
5233         parser->m_declNotationPublicId = tem;
5234         poolFinish(&parser->m_tempPool);
5235         handleDefault = XML_FALSE;
5236       }
5237       break;
5238     case XML_ROLE_NOTATION_SYSTEM_ID:
5239       if (parser->m_declNotationName && parser->m_notationDeclHandler) {
5240         const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,
5241                                                    s + enc->minBytesPerChar,
5242                                                    next - enc->minBytesPerChar);
5243         if (! systemId)
5244           return XML_ERROR_NO_MEMORY;
5245         *eventEndPP = s;
5246         parser->m_notationDeclHandler(
5247             parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
5248             systemId, parser->m_declNotationPublicId);
5249         handleDefault = XML_FALSE;
5250       }
5251       poolClear(&parser->m_tempPool);
5252       break;
5253     case XML_ROLE_NOTATION_NO_SYSTEM_ID:
5254       if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {
5255         *eventEndPP = s;
5256         parser->m_notationDeclHandler(
5257             parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
5258             0, parser->m_declNotationPublicId);
5259         handleDefault = XML_FALSE;
5260       }
5261       poolClear(&parser->m_tempPool);
5262       break;
5263     case XML_ROLE_ERROR:
5264       switch (tok) {
5265       case XML_TOK_PARAM_ENTITY_REF:
5266         /* PE references in internal subset are
5267            not allowed within declarations. */
5268         return XML_ERROR_PARAM_ENTITY_REF;
5269       case XML_TOK_XML_DECL:
5270         return XML_ERROR_MISPLACED_XML_PI;
5271       default:
5272         return XML_ERROR_SYNTAX;
5273       }
5274 #ifdef XML_DTD
5275     case XML_ROLE_IGNORE_SECT: {
5276       enum XML_Error result;
5277       if (parser->m_defaultHandler)
5278         reportDefault(parser, enc, s, next);
5279       handleDefault = XML_FALSE;
5280       result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
5281       if (result != XML_ERROR_NONE)
5282         return result;
5283       else if (! next) {
5284         parser->m_processor = ignoreSectionProcessor;
5285         return result;
5286       }
5287     } break;
5288 #endif /* XML_DTD */
5289     case XML_ROLE_GROUP_OPEN:
5290       if (parser->m_prologState.level >= parser->m_groupSize) {
5291         if (parser->m_groupSize) {
5292           {
5293             /* Detect and prevent integer overflow */
5294             if (parser->m_groupSize > (unsigned int)(-1) / 2u) {
5295               return XML_ERROR_NO_MEMORY;
5296             }
5297
5298             char *const new_connector = (char *)REALLOC(
5299                 parser, parser->m_groupConnector, parser->m_groupSize *= 2);
5300             if (new_connector == NULL) {
5301               parser->m_groupSize /= 2;
5302               return XML_ERROR_NO_MEMORY;
5303             }
5304             parser->m_groupConnector = new_connector;
5305           }
5306
5307           if (dtd->scaffIndex) {
5308             /* Detect and prevent integer overflow.
5309              * The preprocessor guard addresses the "always false" warning
5310              * from -Wtype-limits on platforms where
5311              * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
5312 #if UINT_MAX >= SIZE_MAX
5313             if (parser->m_groupSize > (size_t)(-1) / sizeof(int)) {
5314               return XML_ERROR_NO_MEMORY;
5315             }
5316 #endif
5317
5318             int *const new_scaff_index = (int *)REALLOC(
5319                 parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));
5320             if (new_scaff_index == NULL)
5321               return XML_ERROR_NO_MEMORY;
5322             dtd->scaffIndex = new_scaff_index;
5323           }
5324         } else {
5325           parser->m_groupConnector
5326               = (char *)MALLOC(parser, parser->m_groupSize = 32);
5327           if (! parser->m_groupConnector) {
5328             parser->m_groupSize = 0;
5329             return XML_ERROR_NO_MEMORY;
5330           }
5331         }
5332       }
5333       parser->m_groupConnector[parser->m_prologState.level] = 0;
5334       if (dtd->in_eldecl) {
5335         int myindex = nextScaffoldPart(parser);
5336         if (myindex < 0)
5337           return XML_ERROR_NO_MEMORY;
5338         assert(dtd->scaffIndex != NULL);
5339         dtd->scaffIndex[dtd->scaffLevel] = myindex;
5340         dtd->scaffLevel++;
5341         dtd->scaffold[myindex].type = XML_CTYPE_SEQ;
5342         if (parser->m_elementDeclHandler)
5343           handleDefault = XML_FALSE;
5344       }
5345       break;
5346     case XML_ROLE_GROUP_SEQUENCE:
5347       if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)
5348         return XML_ERROR_SYNTAX;
5349       parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;
5350       if (dtd->in_eldecl && parser->m_elementDeclHandler)
5351         handleDefault = XML_FALSE;
5352       break;
5353     case XML_ROLE_GROUP_CHOICE:
5354       if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)
5355         return XML_ERROR_SYNTAX;
5356       if (dtd->in_eldecl
5357           && ! parser->m_groupConnector[parser->m_prologState.level]
5358           && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
5359               != XML_CTYPE_MIXED)) {
5360         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
5361             = XML_CTYPE_CHOICE;
5362         if (parser->m_elementDeclHandler)
5363           handleDefault = XML_FALSE;
5364       }
5365       parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;
5366       break;
5367     case XML_ROLE_PARAM_ENTITY_REF:
5368 #ifdef XML_DTD
5369     case XML_ROLE_INNER_PARAM_ENTITY_REF:
5370       dtd->hasParamEntityRefs = XML_TRUE;
5371       if (! parser->m_paramEntityParsing)
5372         dtd->keepProcessing = dtd->standalone;
5373       else {
5374         const XML_Char *name;
5375         ENTITY *entity;
5376         name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
5377                                next - enc->minBytesPerChar);
5378         if (! name)
5379           return XML_ERROR_NO_MEMORY;
5380         entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
5381         poolDiscard(&dtd->pool);
5382         /* first, determine if a check for an existing declaration is needed;
5383            if yes, check that the entity exists, and that it is internal,
5384            otherwise call the skipped entity handler
5385         */
5386         if (parser->m_prologState.documentEntity
5387             && (dtd->standalone ? ! parser->m_openInternalEntities
5388                                 : ! dtd->hasParamEntityRefs)) {
5389           if (! entity)
5390             return XML_ERROR_UNDEFINED_ENTITY;
5391           else if (! entity->is_internal) {
5392             /* It's hard to exhaustively search the code to be sure,
5393              * but there doesn't seem to be a way of executing the
5394              * following line.  There are two cases:
5395              *
5396              * If 'standalone' is false, the DTD must have no
5397              * parameter entities or we wouldn't have passed the outer
5398              * 'if' statement.  That means the only entity in the hash
5399              * table is the external subset name "#" which cannot be
5400              * given as a parameter entity name in XML syntax, so the
5401              * lookup must have returned NULL and we don't even reach
5402              * the test for an internal entity.
5403              *
5404              * If 'standalone' is true, it does not seem to be
5405              * possible to create entities taking this code path that
5406              * are not internal entities, so fail the test above.
5407              *
5408              * Because this analysis is very uncertain, the code is
5409              * being left in place and merely removed from the
5410              * coverage test statistics.
5411              */
5412             return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */
5413           }
5414         } else if (! entity) {
5415           dtd->keepProcessing = dtd->standalone;
5416           /* cannot report skipped entities in declarations */
5417           if ((role == XML_ROLE_PARAM_ENTITY_REF)
5418               && parser->m_skippedEntityHandler) {
5419             parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);
5420             handleDefault = XML_FALSE;
5421           }
5422           break;
5423         }
5424         if (entity->open)
5425           return XML_ERROR_RECURSIVE_ENTITY_REF;
5426         if (entity->textPtr) {
5427           enum XML_Error result;
5428           XML_Bool betweenDecl
5429               = (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
5430           result = processInternalEntity(parser, entity, betweenDecl);
5431           if (result != XML_ERROR_NONE)
5432             return result;
5433           handleDefault = XML_FALSE;
5434           break;
5435         }
5436         if (parser->m_externalEntityRefHandler) {
5437           dtd->paramEntityRead = XML_FALSE;
5438           entity->open = XML_TRUE;
5439           entityTrackingOnOpen(parser, entity, __LINE__);
5440           if (! parser->m_externalEntityRefHandler(
5441                   parser->m_externalEntityRefHandlerArg, 0, entity->base,
5442                   entity->systemId, entity->publicId)) {
5443             entityTrackingOnClose(parser, entity, __LINE__);
5444             entity->open = XML_FALSE;
5445             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
5446           }
5447           entityTrackingOnClose(parser, entity, __LINE__);
5448           entity->open = XML_FALSE;
5449           handleDefault = XML_FALSE;
5450           if (! dtd->paramEntityRead) {
5451             dtd->keepProcessing = dtd->standalone;
5452             break;
5453           }
5454         } else {
5455           dtd->keepProcessing = dtd->standalone;
5456           break;
5457         }
5458       }
5459 #endif /* XML_DTD */
5460       if (! dtd->standalone && parser->m_notStandaloneHandler
5461           && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
5462         return XML_ERROR_NOT_STANDALONE;
5463       break;
5464
5465       /* Element declaration stuff */
5466
5467     case XML_ROLE_ELEMENT_NAME:
5468       if (parser->m_elementDeclHandler) {
5469         parser->m_declElementType = getElementType(parser, enc, s, next);
5470         if (! parser->m_declElementType)
5471           return XML_ERROR_NO_MEMORY;
5472         dtd->scaffLevel = 0;
5473         dtd->scaffCount = 0;
5474         dtd->in_eldecl = XML_TRUE;
5475         handleDefault = XML_FALSE;
5476       }
5477       break;
5478
5479     case XML_ROLE_CONTENT_ANY:
5480     case XML_ROLE_CONTENT_EMPTY:
5481       if (dtd->in_eldecl) {
5482         if (parser->m_elementDeclHandler) {
5483           XML_Content *content
5484               = (XML_Content *)MALLOC(parser, sizeof(XML_Content));
5485           if (! content)
5486             return XML_ERROR_NO_MEMORY;
5487           content->quant = XML_CQUANT_NONE;
5488           content->name = NULL;
5489           content->numchildren = 0;
5490           content->children = NULL;
5491           content->type = ((role == XML_ROLE_CONTENT_ANY) ? XML_CTYPE_ANY
5492                                                           : XML_CTYPE_EMPTY);
5493           *eventEndPP = s;
5494           parser->m_elementDeclHandler(
5495               parser->m_handlerArg, parser->m_declElementType->name, content);
5496           handleDefault = XML_FALSE;
5497         }
5498         dtd->in_eldecl = XML_FALSE;
5499       }
5500       break;
5501
5502     case XML_ROLE_CONTENT_PCDATA:
5503       if (dtd->in_eldecl) {
5504         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
5505             = XML_CTYPE_MIXED;
5506         if (parser->m_elementDeclHandler)
5507           handleDefault = XML_FALSE;
5508       }
5509       break;
5510
5511     case XML_ROLE_CONTENT_ELEMENT:
5512       quant = XML_CQUANT_NONE;
5513       goto elementContent;
5514     case XML_ROLE_CONTENT_ELEMENT_OPT:
5515       quant = XML_CQUANT_OPT;
5516       goto elementContent;
5517     case XML_ROLE_CONTENT_ELEMENT_REP:
5518       quant = XML_CQUANT_REP;
5519       goto elementContent;
5520     case XML_ROLE_CONTENT_ELEMENT_PLUS:
5521       quant = XML_CQUANT_PLUS;
5522     elementContent:
5523       if (dtd->in_eldecl) {
5524         ELEMENT_TYPE *el;
5525         const XML_Char *name;
5526         size_t nameLen;
5527         const char *nxt
5528             = (quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar);
5529         int myindex = nextScaffoldPart(parser);
5530         if (myindex < 0)
5531           return XML_ERROR_NO_MEMORY;
5532         dtd->scaffold[myindex].type = XML_CTYPE_NAME;
5533         dtd->scaffold[myindex].quant = quant;
5534         el = getElementType(parser, enc, s, nxt);
5535         if (! el)
5536           return XML_ERROR_NO_MEMORY;
5537         name = el->name;
5538         dtd->scaffold[myindex].name = name;
5539         nameLen = 0;
5540         for (; name[nameLen++];)
5541           ;
5542
5543         /* Detect and prevent integer overflow */
5544         if (nameLen > UINT_MAX - dtd->contentStringLen) {
5545           return XML_ERROR_NO_MEMORY;
5546         }
5547
5548         dtd->contentStringLen += (unsigned)nameLen;
5549         if (parser->m_elementDeclHandler)
5550           handleDefault = XML_FALSE;
5551       }
5552       break;
5553
5554     case XML_ROLE_GROUP_CLOSE:
5555       quant = XML_CQUANT_NONE;
5556       goto closeGroup;
5557     case XML_ROLE_GROUP_CLOSE_OPT:
5558       quant = XML_CQUANT_OPT;
5559       goto closeGroup;
5560     case XML_ROLE_GROUP_CLOSE_REP:
5561       quant = XML_CQUANT_REP;
5562       goto closeGroup;
5563     case XML_ROLE_GROUP_CLOSE_PLUS:
5564       quant = XML_CQUANT_PLUS;
5565     closeGroup:
5566       if (dtd->in_eldecl) {
5567         if (parser->m_elementDeclHandler)
5568           handleDefault = XML_FALSE;
5569         dtd->scaffLevel--;
5570         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;
5571         if (dtd->scaffLevel == 0) {
5572           if (! handleDefault) {
5573             XML_Content *model = build_model(parser);
5574             if (! model)
5575               return XML_ERROR_NO_MEMORY;
5576             *eventEndPP = s;
5577             parser->m_elementDeclHandler(
5578                 parser->m_handlerArg, parser->m_declElementType->name, model);
5579           }
5580           dtd->in_eldecl = XML_FALSE;
5581           dtd->contentStringLen = 0;
5582         }
5583       }
5584       break;
5585       /* End element declaration stuff */
5586
5587     case XML_ROLE_PI:
5588       if (! reportProcessingInstruction(parser, enc, s, next))
5589         return XML_ERROR_NO_MEMORY;
5590       handleDefault = XML_FALSE;
5591       break;
5592     case XML_ROLE_COMMENT:
5593       if (! reportComment(parser, enc, s, next))
5594         return XML_ERROR_NO_MEMORY;
5595       handleDefault = XML_FALSE;
5596       break;
5597     case XML_ROLE_NONE:
5598       switch (tok) {
5599       case XML_TOK_BOM:
5600         handleDefault = XML_FALSE;
5601         break;
5602       }
5603       break;
5604     case XML_ROLE_DOCTYPE_NONE:
5605       if (parser->m_startDoctypeDeclHandler)
5606         handleDefault = XML_FALSE;
5607       break;
5608     case XML_ROLE_ENTITY_NONE:
5609       if (dtd->keepProcessing && parser->m_entityDeclHandler)
5610         handleDefault = XML_FALSE;
5611       break;
5612     case XML_ROLE_NOTATION_NONE:
5613       if (parser->m_notationDeclHandler)
5614         handleDefault = XML_FALSE;
5615       break;
5616     case XML_ROLE_ATTLIST_NONE:
5617       if (dtd->keepProcessing && parser->m_attlistDeclHandler)
5618         handleDefault = XML_FALSE;
5619       break;
5620     case XML_ROLE_ELEMENT_NONE:
5621       if (parser->m_elementDeclHandler)
5622         handleDefault = XML_FALSE;
5623       break;
5624     } /* end of big switch */
5625
5626     if (handleDefault && parser->m_defaultHandler)
5627       reportDefault(parser, enc, s, next);
5628
5629     switch (parser->m_parsingStatus.parsing) {
5630     case XML_SUSPENDED:
5631       *nextPtr = next;
5632       return XML_ERROR_NONE;
5633     case XML_FINISHED:
5634       return XML_ERROR_ABORTED;
5635     default:
5636       s = next;
5637       tok = XmlPrologTok(enc, s, end, &next);
5638     }
5639   }
5640   /* not reached */
5641 }
5642
5643 static enum XML_Error PTRCALL
5644 epilogProcessor(XML_Parser parser, const char *s, const char *end,
5645                 const char **nextPtr) {
5646   parser->m_processor = epilogProcessor;
5647   parser->m_eventPtr = s;
5648   for (;;) {
5649     const char *next = NULL;
5650     int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5651 #ifdef XML_DTD
5652     if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
5653                                   XML_ACCOUNT_DIRECT)) {
5654       accountingOnAbort(parser);
5655       return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
5656     }
5657 #endif
5658     parser->m_eventEndPtr = next;
5659     switch (tok) {
5660     /* report partial linebreak - it might be the last token */
5661     case -XML_TOK_PROLOG_S:
5662       if (parser->m_defaultHandler) {
5663         reportDefault(parser, parser->m_encoding, s, next);
5664         if (parser->m_parsingStatus.parsing == XML_FINISHED)
5665           return XML_ERROR_ABORTED;
5666       }
5667       *nextPtr = next;
5668       return XML_ERROR_NONE;
5669     case XML_TOK_NONE:
5670       *nextPtr = s;
5671       return XML_ERROR_NONE;
5672     case XML_TOK_PROLOG_S:
5673       if (parser->m_defaultHandler)
5674         reportDefault(parser, parser->m_encoding, s, next);
5675       break;
5676     case XML_TOK_PI:
5677       if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))
5678         return XML_ERROR_NO_MEMORY;
5679       break;
5680     case XML_TOK_COMMENT:
5681       if (! reportComment(parser, parser->m_encoding, s, next))
5682         return XML_ERROR_NO_MEMORY;
5683       break;
5684     case XML_TOK_INVALID:
5685       parser->m_eventPtr = next;
5686       return XML_ERROR_INVALID_TOKEN;
5687     case XML_TOK_PARTIAL:
5688       if (! parser->m_parsingStatus.finalBuffer) {
5689         *nextPtr = s;
5690         return XML_ERROR_NONE;
5691       }
5692       return XML_ERROR_UNCLOSED_TOKEN;
5693     case XML_TOK_PARTIAL_CHAR:
5694       if (! parser->m_parsingStatus.finalBuffer) {
5695         *nextPtr = s;
5696         return XML_ERROR_NONE;
5697       }
5698       return XML_ERROR_PARTIAL_CHAR;
5699     default:
5700       return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
5701     }
5702     parser->m_eventPtr = s = next;
5703     switch (parser->m_parsingStatus.parsing) {
5704     case XML_SUSPENDED:
5705       *nextPtr = next;
5706       return XML_ERROR_NONE;
5707     case XML_FINISHED:
5708       return XML_ERROR_ABORTED;
5709     default:;
5710     }
5711   }
5712 }
5713
5714 static enum XML_Error
5715 processInternalEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl) {
5716   const char *textStart, *textEnd;
5717   const char *next;
5718   enum XML_Error result;
5719   OPEN_INTERNAL_ENTITY *openEntity;
5720
5721   if (parser->m_freeInternalEntities) {
5722     openEntity = parser->m_freeInternalEntities;
5723     parser->m_freeInternalEntities = openEntity->next;
5724   } else {
5725     openEntity
5726         = (OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
5727     if (! openEntity)
5728       return XML_ERROR_NO_MEMORY;
5729   }
5730   entity->open = XML_TRUE;
5731 #ifdef XML_DTD
5732   entityTrackingOnOpen(parser, entity, __LINE__);
5733 #endif
5734   entity->processed = 0;
5735   openEntity->next = parser->m_openInternalEntities;
5736   parser->m_openInternalEntities = openEntity;
5737   openEntity->entity = entity;
5738   openEntity->startTagLevel = parser->m_tagLevel;
5739   openEntity->betweenDecl = betweenDecl;
5740   openEntity->internalEventPtr = NULL;
5741   openEntity->internalEventEndPtr = NULL;
5742   textStart = (const char *)entity->textPtr;
5743   textEnd = (const char *)(entity->textPtr + entity->textLen);
5744   /* Set a safe default value in case 'next' does not get set */
5745   next = textStart;
5746
5747 #ifdef XML_DTD
5748   if (entity->is_param) {
5749     int tok
5750         = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
5751     result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
5752                       tok, next, &next, XML_FALSE, XML_FALSE,
5753                       XML_ACCOUNT_ENTITY_EXPANSION);
5754   } else
5755 #endif /* XML_DTD */
5756     result = doContent(parser, parser->m_tagLevel, parser->m_internalEncoding,
5757                        textStart, textEnd, &next, XML_FALSE,
5758                        XML_ACCOUNT_ENTITY_EXPANSION);
5759
5760   if (result == XML_ERROR_NONE) {
5761     if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5762       entity->processed = (int)(next - textStart);
5763       parser->m_processor = internalEntityProcessor;
5764     } else {
5765 #ifdef XML_DTD
5766       entityTrackingOnClose(parser, entity, __LINE__);
5767 #endif /* XML_DTD */
5768       entity->open = XML_FALSE;
5769       parser->m_openInternalEntities = openEntity->next;
5770       /* put openEntity back in list of free instances */
5771       openEntity->next = parser->m_freeInternalEntities;
5772       parser->m_freeInternalEntities = openEntity;
5773     }
5774   }
5775   return result;
5776 }
5777
5778 static enum XML_Error PTRCALL
5779 internalEntityProcessor(XML_Parser parser, const char *s, const char *end,
5780                         const char **nextPtr) {
5781   ENTITY *entity;
5782   const char *textStart, *textEnd;
5783   const char *next;
5784   enum XML_Error result;
5785   OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;
5786   if (! openEntity)
5787     return XML_ERROR_UNEXPECTED_STATE;
5788
5789   entity = openEntity->entity;
5790   textStart = ((const char *)entity->textPtr) + entity->processed;
5791   textEnd = (const char *)(entity->textPtr + entity->textLen);
5792   /* Set a safe default value in case 'next' does not get set */
5793   next = textStart;
5794
5795 #ifdef XML_DTD
5796   if (entity->is_param) {
5797     int tok
5798         = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
5799     result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
5800                       tok, next, &next, XML_FALSE, XML_TRUE,
5801                       XML_ACCOUNT_ENTITY_EXPANSION);
5802   } else
5803 #endif /* XML_DTD */
5804     result = doContent(parser, openEntity->startTagLevel,
5805                        parser->m_internalEncoding, textStart, textEnd, &next,
5806                        XML_FALSE, XML_ACCOUNT_ENTITY_EXPANSION);
5807
5808   if (result != XML_ERROR_NONE)
5809     return result;
5810
5811   if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5812     entity->processed = (int)(next - (const char *)entity->textPtr);
5813     return result;
5814   }
5815
5816 #ifdef XML_DTD
5817   entityTrackingOnClose(parser, entity, __LINE__);
5818 #endif
5819   entity->open = XML_FALSE;
5820   parser->m_openInternalEntities = openEntity->next;
5821   /* put openEntity back in list of free instances */
5822   openEntity->next = parser->m_freeInternalEntities;
5823   parser->m_freeInternalEntities = openEntity;
5824
5825   // If there are more open entities we want to stop right here and have the
5826   // upcoming call to XML_ResumeParser continue with entity content, or it would
5827   // be ignored altogether.
5828   if (parser->m_openInternalEntities != NULL
5829       && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5830     return XML_ERROR_NONE;
5831   }
5832
5833 #ifdef XML_DTD
5834   if (entity->is_param) {
5835     int tok;
5836     parser->m_processor = prologProcessor;
5837     tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5838     return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
5839                     (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
5840                     XML_ACCOUNT_DIRECT);
5841   } else
5842 #endif /* XML_DTD */
5843   {
5844     parser->m_processor = contentProcessor;
5845     /* see externalEntityContentProcessor vs contentProcessor */
5846     result = doContent(parser, parser->m_parentParser ? 1 : 0,
5847                        parser->m_encoding, s, end, nextPtr,
5848                        (XML_Bool)! parser->m_parsingStatus.finalBuffer,
5849                        XML_ACCOUNT_DIRECT);
5850     if (result == XML_ERROR_NONE) {
5851       if (! storeRawNames(parser))
5852         return XML_ERROR_NO_MEMORY;
5853     }
5854     return result;
5855   }
5856 }
5857
5858 static enum XML_Error PTRCALL
5859 errorProcessor(XML_Parser parser, const char *s, const char *end,
5860                const char **nextPtr) {
5861   UNUSED_P(s);
5862   UNUSED_P(end);
5863   UNUSED_P(nextPtr);
5864   return parser->m_errorCode;
5865 }
5866
5867 static enum XML_Error
5868 storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
5869                     const char *ptr, const char *end, STRING_POOL *pool,
5870                     enum XML_Account account) {
5871   enum XML_Error result
5872       = appendAttributeValue(parser, enc, isCdata, ptr, end, pool, account);
5873   if (result)
5874     return result;
5875   if (! isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
5876     poolChop(pool);
5877   if (! poolAppendChar(pool, XML_T('\0')))
5878     return XML_ERROR_NO_MEMORY;
5879   return XML_ERROR_NONE;
5880 }
5881
5882 static enum XML_Error
5883 appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
5884                      const char *ptr, const char *end, STRING_POOL *pool,
5885                      enum XML_Account account) {
5886   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
5887 #ifndef XML_DTD
5888   UNUSED_P(account);
5889 #endif
5890
5891   for (;;) {
5892     const char *next
5893         = ptr; /* XmlAttributeValueTok doesn't always set the last arg */
5894     int tok = XmlAttributeValueTok(enc, ptr, end, &next);
5895 #ifdef XML_DTD
5896     if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {
5897       accountingOnAbort(parser);
5898       return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
5899     }
5900 #endif
5901     switch (tok) {
5902     case XML_TOK_NONE:
5903       return XML_ERROR_NONE;
5904     case XML_TOK_INVALID:
5905       if (enc == parser->m_encoding)
5906         parser->m_eventPtr = next;
5907       return XML_ERROR_INVALID_TOKEN;
5908     case XML_TOK_PARTIAL:
5909       if (enc == parser->m_encoding)
5910         parser->m_eventPtr = ptr;
5911       return XML_ERROR_INVALID_TOKEN;
5912     case XML_TOK_CHAR_REF: {
5913       XML_Char buf[XML_ENCODE_MAX];
5914       int i;
5915       int n = XmlCharRefNumber(enc, ptr);
5916       if (n < 0) {
5917         if (enc == parser->m_encoding)
5918           parser->m_eventPtr = ptr;
5919         return XML_ERROR_BAD_CHAR_REF;
5920       }
5921       if (! isCdata && n == 0x20 /* space */
5922           && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
5923         break;
5924       n = XmlEncode(n, (ICHAR *)buf);
5925       /* The XmlEncode() functions can never return 0 here.  That
5926        * error return happens if the code point passed in is either
5927        * negative or greater than or equal to 0x110000.  The
5928        * XmlCharRefNumber() functions will all return a number
5929        * strictly less than 0x110000 or a negative value if an error
5930        * occurred.  The negative value is intercepted above, so
5931        * XmlEncode() is never passed a value it might return an
5932        * error for.
5933        */
5934       for (i = 0; i < n; i++) {
5935         if (! poolAppendChar(pool, buf[i]))
5936           return XML_ERROR_NO_MEMORY;
5937       }
5938     } break;
5939     case XML_TOK_DATA_CHARS:
5940       if (! poolAppend(pool, enc, ptr, next))
5941         return XML_ERROR_NO_MEMORY;
5942       break;
5943     case XML_TOK_TRAILING_CR:
5944       next = ptr + enc->minBytesPerChar;
5945       /* fall through */
5946     case XML_TOK_ATTRIBUTE_VALUE_S:
5947     case XML_TOK_DATA_NEWLINE:
5948       if (! isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
5949         break;
5950       if (! poolAppendChar(pool, 0x20))
5951         return XML_ERROR_NO_MEMORY;
5952       break;
5953     case XML_TOK_ENTITY_REF: {
5954       const XML_Char *name;
5955       ENTITY *entity;
5956       char checkEntityDecl;
5957       XML_Char ch = (XML_Char)XmlPredefinedEntityName(
5958           enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar);
5959       if (ch) {
5960 #ifdef XML_DTD
5961         /* NOTE: We are replacing 4-6 characters original input for 1 character
5962          *       so there is no amplification and hence recording without
5963          *       protection. */
5964         accountingDiffTolerated(parser, tok, (char *)&ch,
5965                                 ((char *)&ch) + sizeof(XML_Char), __LINE__,
5966                                 XML_ACCOUNT_ENTITY_EXPANSION);
5967 #endif /* XML_DTD */
5968         if (! poolAppendChar(pool, ch))
5969           return XML_ERROR_NO_MEMORY;
5970         break;
5971       }
5972       name = poolStoreString(&parser->m_temp2Pool, enc,
5973                              ptr + enc->minBytesPerChar,
5974                              next - enc->minBytesPerChar);
5975       if (! name)
5976         return XML_ERROR_NO_MEMORY;
5977       entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
5978       poolDiscard(&parser->m_temp2Pool);
5979       /* First, determine if a check for an existing declaration is needed;
5980          if yes, check that the entity exists, and that it is internal.
5981       */
5982       if (pool == &dtd->pool) /* are we called from prolog? */
5983         checkEntityDecl =
5984 #ifdef XML_DTD
5985             parser->m_prologState.documentEntity &&
5986 #endif /* XML_DTD */
5987             (dtd->standalone ? ! parser->m_openInternalEntities
5988                              : ! dtd->hasParamEntityRefs);
5989       else /* if (pool == &parser->m_tempPool): we are called from content */
5990         checkEntityDecl = ! dtd->hasParamEntityRefs || dtd->standalone;
5991       if (checkEntityDecl) {
5992         if (! entity)
5993           return XML_ERROR_UNDEFINED_ENTITY;
5994         else if (! entity->is_internal)
5995           return XML_ERROR_ENTITY_DECLARED_IN_PE;
5996       } else if (! entity) {
5997         /* Cannot report skipped entity here - see comments on
5998            parser->m_skippedEntityHandler.
5999         if (parser->m_skippedEntityHandler)
6000           parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
6001         */
6002         /* Cannot call the default handler because this would be
6003            out of sync with the call to the startElementHandler.
6004         if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
6005           reportDefault(parser, enc, ptr, next);
6006         */
6007         break;
6008       }
6009       if (entity->open) {
6010         if (enc == parser->m_encoding) {
6011           /* It does not appear that this line can be executed.
6012            *
6013            * The "if (entity->open)" check catches recursive entity
6014            * definitions.  In order to be called with an open
6015            * entity, it must have gone through this code before and
6016            * been through the recursive call to
6017            * appendAttributeValue() some lines below.  That call
6018            * sets the local encoding ("enc") to the parser's
6019            * internal encoding (internal_utf8 or internal_utf16),
6020            * which can never be the same as the principle encoding.
6021            * It doesn't appear there is another code path that gets
6022            * here with entity->open being TRUE.
6023            *
6024            * Since it is not certain that this logic is watertight,
6025            * we keep the line and merely exclude it from coverage
6026            * tests.
6027            */
6028           parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
6029         }
6030         return XML_ERROR_RECURSIVE_ENTITY_REF;
6031       }
6032       if (entity->notation) {
6033         if (enc == parser->m_encoding)
6034           parser->m_eventPtr = ptr;
6035         return XML_ERROR_BINARY_ENTITY_REF;
6036       }
6037       if (! entity->textPtr) {
6038         if (enc == parser->m_encoding)
6039           parser->m_eventPtr = ptr;
6040         return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
6041       } else {
6042         enum XML_Error result;
6043         const XML_Char *textEnd = entity->textPtr + entity->textLen;
6044         entity->open = XML_TRUE;
6045 #ifdef XML_DTD
6046         entityTrackingOnOpen(parser, entity, __LINE__);
6047 #endif
6048         result = appendAttributeValue(parser, parser->m_internalEncoding,
6049                                       isCdata, (const char *)entity->textPtr,
6050                                       (const char *)textEnd, pool,
6051                                       XML_ACCOUNT_ENTITY_EXPANSION);
6052 #ifdef XML_DTD
6053         entityTrackingOnClose(parser, entity, __LINE__);
6054 #endif
6055         entity->open = XML_FALSE;
6056         if (result)
6057           return result;
6058       }
6059     } break;
6060     default:
6061       /* The only token returned by XmlAttributeValueTok() that does
6062        * not have an explicit case here is XML_TOK_PARTIAL_CHAR.
6063        * Getting that would require an entity name to contain an
6064        * incomplete XML character (e.g. \xE2\x82); however previous
6065        * tokenisers will have already recognised and rejected such
6066        * names before XmlAttributeValueTok() gets a look-in.  This
6067        * default case should be retained as a safety net, but the code
6068        * excluded from coverage tests.
6069        *
6070        * LCOV_EXCL_START
6071        */
6072       if (enc == parser->m_encoding)
6073         parser->m_eventPtr = ptr;
6074       return XML_ERROR_UNEXPECTED_STATE;
6075       /* LCOV_EXCL_STOP */
6076     }
6077     ptr = next;
6078   }
6079   /* not reached */
6080 }
6081
6082 static enum XML_Error
6083 storeEntityValue(XML_Parser parser, const ENCODING *enc,
6084                  const char *entityTextPtr, const char *entityTextEnd,
6085                  enum XML_Account account) {
6086   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6087   STRING_POOL *pool = &(dtd->entityValuePool);
6088   enum XML_Error result = XML_ERROR_NONE;
6089 #ifdef XML_DTD
6090   int oldInEntityValue = parser->m_prologState.inEntityValue;
6091   parser->m_prologState.inEntityValue = 1;
6092 #else
6093   UNUSED_P(account);
6094 #endif /* XML_DTD */
6095   /* never return Null for the value argument in EntityDeclHandler,
6096      since this would indicate an external entity; therefore we
6097      have to make sure that entityValuePool.start is not null */
6098   if (! pool->blocks) {
6099     if (! poolGrow(pool))
6100       return XML_ERROR_NO_MEMORY;
6101   }
6102
6103   for (;;) {
6104     const char *next
6105         = entityTextPtr; /* XmlEntityValueTok doesn't always set the last arg */
6106     int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
6107
6108 #ifdef XML_DTD
6109     if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,
6110                                   account)) {
6111       accountingOnAbort(parser);
6112       result = XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
6113       goto endEntityValue;
6114     }
6115 #endif
6116
6117     switch (tok) {
6118     case XML_TOK_PARAM_ENTITY_REF:
6119 #ifdef XML_DTD
6120       if (parser->m_isParamEntity || enc != parser->m_encoding) {
6121         const XML_Char *name;
6122         ENTITY *entity;
6123         name = poolStoreString(&parser->m_tempPool, enc,
6124                                entityTextPtr + enc->minBytesPerChar,
6125                                next - enc->minBytesPerChar);
6126         if (! name) {
6127           result = XML_ERROR_NO_MEMORY;
6128           goto endEntityValue;
6129         }
6130         entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
6131         poolDiscard(&parser->m_tempPool);
6132         if (! entity) {
6133           /* not a well-formedness error - see XML 1.0: WFC Entity Declared */
6134           /* cannot report skipped entity here - see comments on
6135              parser->m_skippedEntityHandler
6136           if (parser->m_skippedEntityHandler)
6137             parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
6138           */
6139           dtd->keepProcessing = dtd->standalone;
6140           goto endEntityValue;
6141         }
6142         if (entity->open) {
6143           if (enc == parser->m_encoding)
6144             parser->m_eventPtr = entityTextPtr;
6145           result = XML_ERROR_RECURSIVE_ENTITY_REF;
6146           goto endEntityValue;
6147         }
6148         if (entity->systemId) {
6149           if (parser->m_externalEntityRefHandler) {
6150             dtd->paramEntityRead = XML_FALSE;
6151             entity->open = XML_TRUE;
6152             entityTrackingOnOpen(parser, entity, __LINE__);
6153             if (! parser->m_externalEntityRefHandler(
6154                     parser->m_externalEntityRefHandlerArg, 0, entity->base,
6155                     entity->systemId, entity->publicId)) {
6156               entityTrackingOnClose(parser, entity, __LINE__);
6157               entity->open = XML_FALSE;
6158               result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
6159               goto endEntityValue;
6160             }
6161             entityTrackingOnClose(parser, entity, __LINE__);
6162             entity->open = XML_FALSE;
6163             if (! dtd->paramEntityRead)
6164               dtd->keepProcessing = dtd->standalone;
6165           } else
6166             dtd->keepProcessing = dtd->standalone;
6167         } else {
6168           entity->open = XML_TRUE;
6169           entityTrackingOnOpen(parser, entity, __LINE__);
6170           result = storeEntityValue(
6171               parser, parser->m_internalEncoding, (const char *)entity->textPtr,
6172               (const char *)(entity->textPtr + entity->textLen),
6173               XML_ACCOUNT_ENTITY_EXPANSION);
6174           entityTrackingOnClose(parser, entity, __LINE__);
6175           entity->open = XML_FALSE;
6176           if (result)
6177             goto endEntityValue;
6178         }
6179         break;
6180       }
6181 #endif /* XML_DTD */
6182       /* In the internal subset, PE references are not legal
6183          within markup declarations, e.g entity values in this case. */
6184       parser->m_eventPtr = entityTextPtr;
6185       result = XML_ERROR_PARAM_ENTITY_REF;
6186       goto endEntityValue;
6187     case XML_TOK_NONE:
6188       result = XML_ERROR_NONE;
6189       goto endEntityValue;
6190     case XML_TOK_ENTITY_REF:
6191     case XML_TOK_DATA_CHARS:
6192       if (! poolAppend(pool, enc, entityTextPtr, next)) {
6193         result = XML_ERROR_NO_MEMORY;
6194         goto endEntityValue;
6195       }
6196       break;
6197     case XML_TOK_TRAILING_CR:
6198       next = entityTextPtr + enc->minBytesPerChar;
6199       /* fall through */
6200     case XML_TOK_DATA_NEWLINE:
6201       if (pool->end == pool->ptr && ! poolGrow(pool)) {
6202         result = XML_ERROR_NO_MEMORY;
6203         goto endEntityValue;
6204       }
6205       *(pool->ptr)++ = 0xA;
6206       break;
6207     case XML_TOK_CHAR_REF: {
6208       XML_Char buf[XML_ENCODE_MAX];
6209       int i;
6210       int n = XmlCharRefNumber(enc, entityTextPtr);
6211       if (n < 0) {
6212         if (enc == parser->m_encoding)
6213           parser->m_eventPtr = entityTextPtr;
6214         result = XML_ERROR_BAD_CHAR_REF;
6215         goto endEntityValue;
6216       }
6217       n = XmlEncode(n, (ICHAR *)buf);
6218       /* The XmlEncode() functions can never return 0 here.  That
6219        * error return happens if the code point passed in is either
6220        * negative or greater than or equal to 0x110000.  The
6221        * XmlCharRefNumber() functions will all return a number
6222        * strictly less than 0x110000 or a negative value if an error
6223        * occurred.  The negative value is intercepted above, so
6224        * XmlEncode() is never passed a value it might return an
6225        * error for.
6226        */
6227       for (i = 0; i < n; i++) {
6228         if (pool->end == pool->ptr && ! poolGrow(pool)) {
6229           result = XML_ERROR_NO_MEMORY;
6230           goto endEntityValue;
6231         }
6232         *(pool->ptr)++ = buf[i];
6233       }
6234     } break;
6235     case XML_TOK_PARTIAL:
6236       if (enc == parser->m_encoding)
6237         parser->m_eventPtr = entityTextPtr;
6238       result = XML_ERROR_INVALID_TOKEN;
6239       goto endEntityValue;
6240     case XML_TOK_INVALID:
6241       if (enc == parser->m_encoding)
6242         parser->m_eventPtr = next;
6243       result = XML_ERROR_INVALID_TOKEN;
6244       goto endEntityValue;
6245     default:
6246       /* This default case should be unnecessary -- all the tokens
6247        * that XmlEntityValueTok() can return have their own explicit
6248        * cases -- but should be retained for safety.  We do however
6249        * exclude it from the coverage statistics.
6250        *
6251        * LCOV_EXCL_START
6252        */
6253       if (enc == parser->m_encoding)
6254         parser->m_eventPtr = entityTextPtr;
6255       result = XML_ERROR_UNEXPECTED_STATE;
6256       goto endEntityValue;
6257       /* LCOV_EXCL_STOP */
6258     }
6259     entityTextPtr = next;
6260   }
6261 endEntityValue:
6262 #ifdef XML_DTD
6263   parser->m_prologState.inEntityValue = oldInEntityValue;
6264 #endif /* XML_DTD */
6265   return result;
6266 }
6267
6268 static void FASTCALL
6269 normalizeLines(XML_Char *s) {
6270   XML_Char *p;
6271   for (;; s++) {
6272     if (*s == XML_T('\0'))
6273       return;
6274     if (*s == 0xD)
6275       break;
6276   }
6277   p = s;
6278   do {
6279     if (*s == 0xD) {
6280       *p++ = 0xA;
6281       if (*++s == 0xA)
6282         s++;
6283     } else
6284       *p++ = *s++;
6285   } while (*s);
6286   *p = XML_T('\0');
6287 }
6288
6289 static int
6290 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
6291                             const char *start, const char *end) {
6292   const XML_Char *target;
6293   XML_Char *data;
6294   const char *tem;
6295   if (! parser->m_processingInstructionHandler) {
6296     if (parser->m_defaultHandler)
6297       reportDefault(parser, enc, start, end);
6298     return 1;
6299   }
6300   start += enc->minBytesPerChar * 2;
6301   tem = start + XmlNameLength(enc, start);
6302   target = poolStoreString(&parser->m_tempPool, enc, start, tem);
6303   if (! target)
6304     return 0;
6305   poolFinish(&parser->m_tempPool);
6306   data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),
6307                          end - enc->minBytesPerChar * 2);
6308   if (! data)
6309     return 0;
6310   normalizeLines(data);
6311   parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);
6312   poolClear(&parser->m_tempPool);
6313   return 1;
6314 }
6315
6316 static int
6317 reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
6318               const char *end) {
6319   XML_Char *data;
6320   if (! parser->m_commentHandler) {
6321     if (parser->m_defaultHandler)
6322       reportDefault(parser, enc, start, end);
6323     return 1;
6324   }
6325   data = poolStoreString(&parser->m_tempPool, enc,
6326                          start + enc->minBytesPerChar * 4,
6327                          end - enc->minBytesPerChar * 3);
6328   if (! data)
6329     return 0;
6330   normalizeLines(data);
6331   parser->m_commentHandler(parser->m_handlerArg, data);
6332   poolClear(&parser->m_tempPool);
6333   return 1;
6334 }
6335
6336 static void
6337 reportDefault(XML_Parser parser, const ENCODING *enc, const char *s,
6338               const char *end) {
6339   if (MUST_CONVERT(enc, s)) {
6340     enum XML_Convert_Result convert_res;
6341     const char **eventPP;
6342     const char **eventEndPP;
6343     if (enc == parser->m_encoding) {
6344       eventPP = &parser->m_eventPtr;
6345       eventEndPP = &parser->m_eventEndPtr;
6346     } else {
6347       /* To get here, two things must be true; the parser must be
6348        * using a character encoding that is not the same as the
6349        * encoding passed in, and the encoding passed in must need
6350        * conversion to the internal format (UTF-8 unless XML_UNICODE
6351        * is defined).  The only occasions on which the encoding passed
6352        * in is not the same as the parser's encoding are when it is
6353        * the internal encoding (e.g. a previously defined parameter
6354        * entity, already converted to internal format).  This by
6355        * definition doesn't need conversion, so the whole branch never
6356        * gets executed.
6357        *
6358        * For safety's sake we don't delete these lines and merely
6359        * exclude them from coverage statistics.
6360        *
6361        * LCOV_EXCL_START
6362        */
6363       eventPP = &(parser->m_openInternalEntities->internalEventPtr);
6364       eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
6365       /* LCOV_EXCL_STOP */
6366     }
6367     do {
6368       ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
6369       convert_res
6370           = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
6371       *eventEndPP = s;
6372       parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,
6373                                (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
6374       *eventPP = s;
6375     } while ((convert_res != XML_CONVERT_COMPLETED)
6376              && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
6377   } else
6378     parser->m_defaultHandler(parser->m_handlerArg, (XML_Char *)s,
6379                              (int)((XML_Char *)end - (XML_Char *)s));
6380 }
6381
6382 static int
6383 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
6384                 XML_Bool isId, const XML_Char *value, XML_Parser parser) {
6385   DEFAULT_ATTRIBUTE *att;
6386   if (value || isId) {
6387     /* The handling of default attributes gets messed up if we have
6388        a default which duplicates a non-default. */
6389     int i;
6390     for (i = 0; i < type->nDefaultAtts; i++)
6391       if (attId == type->defaultAtts[i].id)
6392         return 1;
6393     if (isId && ! type->idAtt && ! attId->xmlns)
6394       type->idAtt = attId;
6395   }
6396   if (type->nDefaultAtts == type->allocDefaultAtts) {
6397     if (type->allocDefaultAtts == 0) {
6398       type->allocDefaultAtts = 8;
6399       type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(
6400           parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
6401       if (! type->defaultAtts) {
6402         type->allocDefaultAtts = 0;
6403         return 0;
6404       }
6405     } else {
6406       DEFAULT_ATTRIBUTE *temp;
6407
6408       /* Detect and prevent integer overflow */
6409       if (type->allocDefaultAtts > INT_MAX / 2) {
6410         return 0;
6411       }
6412
6413       int count = type->allocDefaultAtts * 2;
6414
6415       /* Detect and prevent integer overflow.
6416        * The preprocessor guard addresses the "always false" warning
6417        * from -Wtype-limits on platforms where
6418        * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
6419 #if UINT_MAX >= SIZE_MAX
6420       if ((unsigned)count > (size_t)(-1) / sizeof(DEFAULT_ATTRIBUTE)) {
6421         return 0;
6422       }
6423 #endif
6424
6425       temp = (DEFAULT_ATTRIBUTE *)REALLOC(parser, type->defaultAtts,
6426                                           (count * sizeof(DEFAULT_ATTRIBUTE)));
6427       if (temp == NULL)
6428         return 0;
6429       type->allocDefaultAtts = count;
6430       type->defaultAtts = temp;
6431     }
6432   }
6433   att = type->defaultAtts + type->nDefaultAtts;
6434   att->id = attId;
6435   att->value = value;
6436   att->isCdata = isCdata;
6437   if (! isCdata)
6438     attId->maybeTokenized = XML_TRUE;
6439   type->nDefaultAtts += 1;
6440   return 1;
6441 }
6442
6443 static int
6444 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {
6445   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6446   const XML_Char *name;
6447   for (name = elementType->name; *name; name++) {
6448     if (*name == XML_T(ASCII_COLON)) {
6449       PREFIX *prefix;
6450       const XML_Char *s;
6451       for (s = elementType->name; s != name; s++) {
6452         if (! poolAppendChar(&dtd->pool, *s))
6453           return 0;
6454       }
6455       if (! poolAppendChar(&dtd->pool, XML_T('\0')))
6456         return 0;
6457       prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
6458                                 sizeof(PREFIX));
6459       if (! prefix)
6460         return 0;
6461       if (prefix->name == poolStart(&dtd->pool))
6462         poolFinish(&dtd->pool);
6463       else
6464         poolDiscard(&dtd->pool);
6465       elementType->prefix = prefix;
6466       break;
6467     }
6468   }
6469   return 1;
6470 }
6471
6472 static ATTRIBUTE_ID *
6473 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
6474                const char *end) {
6475   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6476   ATTRIBUTE_ID *id;
6477   const XML_Char *name;
6478   if (! poolAppendChar(&dtd->pool, XML_T('\0')))
6479     return NULL;
6480   name = poolStoreString(&dtd->pool, enc, start, end);
6481   if (! name)
6482     return NULL;
6483   /* skip quotation mark - its storage will be re-used (like in name[-1]) */
6484   ++name;
6485   id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,
6486                               sizeof(ATTRIBUTE_ID));
6487   if (! id)
6488     return NULL;
6489   if (id->name != name)
6490     poolDiscard(&dtd->pool);
6491   else {
6492     poolFinish(&dtd->pool);
6493     if (! parser->m_ns)
6494       ;
6495     else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m)
6496              && name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n)
6497              && name[4] == XML_T(ASCII_s)
6498              && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
6499       if (name[5] == XML_T('\0'))
6500         id->prefix = &dtd->defaultPrefix;
6501       else
6502         id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,
6503                                       sizeof(PREFIX));
6504       id->xmlns = XML_TRUE;
6505     } else {
6506       int i;
6507       for (i = 0; name[i]; i++) {
6508         /* attributes without prefix are *not* in the default namespace */
6509         if (name[i] == XML_T(ASCII_COLON)) {
6510           int j;
6511           for (j = 0; j < i; j++) {
6512             if (! poolAppendChar(&dtd->pool, name[j]))
6513               return NULL;
6514           }
6515           if (! poolAppendChar(&dtd->pool, XML_T('\0')))
6516             return NULL;
6517           id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,
6518                                         poolStart(&dtd->pool), sizeof(PREFIX));
6519           if (! id->prefix)
6520             return NULL;
6521           if (id->prefix->name == poolStart(&dtd->pool))
6522             poolFinish(&dtd->pool);
6523           else
6524             poolDiscard(&dtd->pool);
6525           break;
6526         }
6527       }
6528     }
6529   }
6530   return id;
6531 }
6532
6533 #define CONTEXT_SEP XML_T(ASCII_FF)
6534
6535 static const XML_Char *
6536 getContext(XML_Parser parser) {
6537   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6538   HASH_TABLE_ITER iter;
6539   XML_Bool needSep = XML_FALSE;
6540
6541   if (dtd->defaultPrefix.binding) {
6542     int i;
6543     int len;
6544     if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
6545       return NULL;
6546     len = dtd->defaultPrefix.binding->uriLen;
6547     if (parser->m_namespaceSeparator)
6548       len--;
6549     for (i = 0; i < len; i++) {
6550       if (! poolAppendChar(&parser->m_tempPool,
6551                            dtd->defaultPrefix.binding->uri[i])) {
6552         /* Because of memory caching, I don't believe this line can be
6553          * executed.
6554          *
6555          * This is part of a loop copying the default prefix binding
6556          * URI into the parser's temporary string pool.  Previously,
6557          * that URI was copied into the same string pool, with a
6558          * terminating NUL character, as part of setContext().  When
6559          * the pool was cleared, that leaves a block definitely big
6560          * enough to hold the URI on the free block list of the pool.
6561          * The URI copy in getContext() therefore cannot run out of
6562          * memory.
6563          *
6564          * If the pool is used between the setContext() and
6565          * getContext() calls, the worst it can do is leave a bigger
6566          * block on the front of the free list.  Given that this is
6567          * all somewhat inobvious and program logic can be changed, we
6568          * don't delete the line but we do exclude it from the test
6569          * coverage statistics.
6570          */
6571         return NULL; /* LCOV_EXCL_LINE */
6572       }
6573     }
6574     needSep = XML_TRUE;
6575   }
6576
6577   hashTableIterInit(&iter, &(dtd->prefixes));
6578   for (;;) {
6579     int i;
6580     int len;
6581     const XML_Char *s;
6582     PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
6583     if (! prefix)
6584       break;
6585     if (! prefix->binding) {
6586       /* This test appears to be (justifiable) paranoia.  There does
6587        * not seem to be a way of injecting a prefix without a binding
6588        * that doesn't get errored long before this function is called.
6589        * The test should remain for safety's sake, so we instead
6590        * exclude the following line from the coverage statistics.
6591        */
6592       continue; /* LCOV_EXCL_LINE */
6593     }
6594     if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
6595       return NULL;
6596     for (s = prefix->name; *s; s++)
6597       if (! poolAppendChar(&parser->m_tempPool, *s))
6598         return NULL;
6599     if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
6600       return NULL;
6601     len = prefix->binding->uriLen;
6602     if (parser->m_namespaceSeparator)
6603       len--;
6604     for (i = 0; i < len; i++)
6605       if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
6606         return NULL;
6607     needSep = XML_TRUE;
6608   }
6609
6610   hashTableIterInit(&iter, &(dtd->generalEntities));
6611   for (;;) {
6612     const XML_Char *s;
6613     ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
6614     if (! e)
6615       break;
6616     if (! e->open)
6617       continue;
6618     if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
6619       return NULL;
6620     for (s = e->name; *s; s++)
6621       if (! poolAppendChar(&parser->m_tempPool, *s))
6622         return 0;
6623     needSep = XML_TRUE;
6624   }
6625
6626   if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6627     return NULL;
6628   return parser->m_tempPool.start;
6629 }
6630
6631 static XML_Bool
6632 setContext(XML_Parser parser, const XML_Char *context) {
6633   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
6634   const XML_Char *s = context;
6635
6636   while (*context != XML_T('\0')) {
6637     if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
6638       ENTITY *e;
6639       if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6640         return XML_FALSE;
6641       e = (ENTITY *)lookup(parser, &dtd->generalEntities,
6642                            poolStart(&parser->m_tempPool), 0);
6643       if (e)
6644         e->open = XML_TRUE;
6645       if (*s != XML_T('\0'))
6646         s++;
6647       context = s;
6648       poolDiscard(&parser->m_tempPool);
6649     } else if (*s == XML_T(ASCII_EQUALS)) {
6650       PREFIX *prefix;
6651       if (poolLength(&parser->m_tempPool) == 0)
6652         prefix = &dtd->defaultPrefix;
6653       else {
6654         if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6655           return XML_FALSE;
6656         prefix
6657             = (PREFIX *)lookup(parser, &dtd->prefixes,
6658                                poolStart(&parser->m_tempPool), sizeof(PREFIX));
6659         if (! prefix)
6660           return XML_FALSE;
6661         if (prefix->name == poolStart(&parser->m_tempPool)) {
6662           prefix->name = poolCopyString(&dtd->pool, prefix->name);
6663           if (! prefix->name)
6664             return XML_FALSE;
6665         }
6666         poolDiscard(&parser->m_tempPool);
6667       }
6668       for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0');
6669            context++)
6670         if (! poolAppendChar(&parser->m_tempPool, *context))
6671           return XML_FALSE;
6672       if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
6673         return XML_FALSE;
6674       if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),
6675                      &parser->m_inheritedBindings)
6676           != XML_ERROR_NONE)
6677         return XML_FALSE;
6678       poolDiscard(&parser->m_tempPool);
6679       if (*context != XML_T('\0'))
6680         ++context;
6681       s = context;
6682     } else {
6683       if (! poolAppendChar(&parser->m_tempPool, *s))
6684         return XML_FALSE;
6685       s++;
6686     }
6687   }
6688   return XML_TRUE;
6689 }
6690
6691 static void FASTCALL
6692 normalizePublicId(XML_Char *publicId) {
6693   XML_Char *p = publicId;
6694   XML_Char *s;
6695   for (s = publicId; *s; s++) {
6696     switch (*s) {
6697     case 0x20:
6698     case 0xD:
6699     case 0xA:
6700       if (p != publicId && p[-1] != 0x20)
6701         *p++ = 0x20;
6702       break;
6703     default:
6704       *p++ = *s;
6705     }
6706   }
6707   if (p != publicId && p[-1] == 0x20)
6708     --p;
6709   *p = XML_T('\0');
6710 }
6711
6712 static DTD *
6713 dtdCreate(const XML_Memory_Handling_Suite *ms) {
6714   DTD *p = ms->malloc_fcn(sizeof(DTD));
6715   if (p == NULL)
6716     return p;
6717   poolInit(&(p->pool), ms);
6718   poolInit(&(p->entityValuePool), ms);
6719   hashTableInit(&(p->generalEntities), ms);
6720   hashTableInit(&(p->elementTypes), ms);
6721   hashTableInit(&(p->attributeIds), ms);
6722   hashTableInit(&(p->prefixes), ms);
6723 #ifdef XML_DTD
6724   p->paramEntityRead = XML_FALSE;
6725   hashTableInit(&(p->paramEntities), ms);
6726 #endif /* XML_DTD */
6727   p->defaultPrefix.name = NULL;
6728   p->defaultPrefix.binding = NULL;
6729
6730   p->in_eldecl = XML_FALSE;
6731   p->scaffIndex = NULL;
6732   p->scaffold = NULL;
6733   p->scaffLevel = 0;
6734   p->scaffSize = 0;
6735   p->scaffCount = 0;
6736   p->contentStringLen = 0;
6737
6738   p->keepProcessing = XML_TRUE;
6739   p->hasParamEntityRefs = XML_FALSE;
6740   p->standalone = XML_FALSE;
6741   return p;
6742 }
6743
6744 static void
6745 dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms) {
6746   HASH_TABLE_ITER iter;
6747   hashTableIterInit(&iter, &(p->elementTypes));
6748   for (;;) {
6749     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
6750     if (! e)
6751       break;
6752     if (e->allocDefaultAtts != 0)
6753       ms->free_fcn(e->defaultAtts);
6754   }
6755   hashTableClear(&(p->generalEntities));
6756 #ifdef XML_DTD
6757   p->paramEntityRead = XML_FALSE;
6758   hashTableClear(&(p->paramEntities));
6759 #endif /* XML_DTD */
6760   hashTableClear(&(p->elementTypes));
6761   hashTableClear(&(p->attributeIds));
6762   hashTableClear(&(p->prefixes));
6763   poolClear(&(p->pool));
6764   poolClear(&(p->entityValuePool));
6765   p->defaultPrefix.name = NULL;
6766   p->defaultPrefix.binding = NULL;
6767
6768   p->in_eldecl = XML_FALSE;
6769
6770   ms->free_fcn(p->scaffIndex);
6771   p->scaffIndex = NULL;
6772   ms->free_fcn(p->scaffold);
6773   p->scaffold = NULL;
6774
6775   p->scaffLevel = 0;
6776   p->scaffSize = 0;
6777   p->scaffCount = 0;
6778   p->contentStringLen = 0;
6779
6780   p->keepProcessing = XML_TRUE;
6781   p->hasParamEntityRefs = XML_FALSE;
6782   p->standalone = XML_FALSE;
6783 }
6784
6785 static void
6786 dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms) {
6787   HASH_TABLE_ITER iter;
6788   hashTableIterInit(&iter, &(p->elementTypes));
6789   for (;;) {
6790     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
6791     if (! e)
6792       break;
6793     if (e->allocDefaultAtts != 0)
6794       ms->free_fcn(e->defaultAtts);
6795   }
6796   hashTableDestroy(&(p->generalEntities));
6797 #ifdef XML_DTD
6798   hashTableDestroy(&(p->paramEntities));
6799 #endif /* XML_DTD */
6800   hashTableDestroy(&(p->elementTypes));
6801   hashTableDestroy(&(p->attributeIds));
6802   hashTableDestroy(&(p->prefixes));
6803   poolDestroy(&(p->pool));
6804   poolDestroy(&(p->entityValuePool));
6805   if (isDocEntity) {
6806     ms->free_fcn(p->scaffIndex);
6807     ms->free_fcn(p->scaffold);
6808   }
6809   ms->free_fcn(p);
6810 }
6811
6812 /* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.
6813    The new DTD has already been initialized.
6814 */
6815 static int
6816 dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
6817         const XML_Memory_Handling_Suite *ms) {
6818   HASH_TABLE_ITER iter;
6819
6820   /* Copy the prefix table. */
6821
6822   hashTableIterInit(&iter, &(oldDtd->prefixes));
6823   for (;;) {
6824     const XML_Char *name;
6825     const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
6826     if (! oldP)
6827       break;
6828     name = poolCopyString(&(newDtd->pool), oldP->name);
6829     if (! name)
6830       return 0;
6831     if (! lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
6832       return 0;
6833   }
6834
6835   hashTableIterInit(&iter, &(oldDtd->attributeIds));
6836
6837   /* Copy the attribute id table. */
6838
6839   for (;;) {
6840     ATTRIBUTE_ID *newA;
6841     const XML_Char *name;
6842     const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
6843
6844     if (! oldA)
6845       break;
6846     /* Remember to allocate the scratch byte before the name. */
6847     if (! poolAppendChar(&(newDtd->pool), XML_T('\0')))
6848       return 0;
6849     name = poolCopyString(&(newDtd->pool), oldA->name);
6850     if (! name)
6851       return 0;
6852     ++name;
6853     newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
6854                                   sizeof(ATTRIBUTE_ID));
6855     if (! newA)
6856       return 0;
6857     newA->maybeTokenized = oldA->maybeTokenized;
6858     if (oldA->prefix) {
6859       newA->xmlns = oldA->xmlns;
6860       if (oldA->prefix == &oldDtd->defaultPrefix)
6861         newA->prefix = &newDtd->defaultPrefix;
6862       else
6863         newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
6864                                         oldA->prefix->name, 0);
6865     }
6866   }
6867
6868   /* Copy the element type table. */
6869
6870   hashTableIterInit(&iter, &(oldDtd->elementTypes));
6871
6872   for (;;) {
6873     int i;
6874     ELEMENT_TYPE *newE;
6875     const XML_Char *name;
6876     const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
6877     if (! oldE)
6878       break;
6879     name = poolCopyString(&(newDtd->pool), oldE->name);
6880     if (! name)
6881       return 0;
6882     newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
6883                                   sizeof(ELEMENT_TYPE));
6884     if (! newE)
6885       return 0;
6886     if (oldE->nDefaultAtts) {
6887       newE->defaultAtts
6888           = ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
6889       if (! newE->defaultAtts) {
6890         return 0;
6891       }
6892     }
6893     if (oldE->idAtt)
6894       newE->idAtt = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds),
6895                                            oldE->idAtt->name, 0);
6896     newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
6897     if (oldE->prefix)
6898       newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
6899                                       oldE->prefix->name, 0);
6900     for (i = 0; i < newE->nDefaultAtts; i++) {
6901       newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(
6902           oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
6903       newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
6904       if (oldE->defaultAtts[i].value) {
6905         newE->defaultAtts[i].value
6906             = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
6907         if (! newE->defaultAtts[i].value)
6908           return 0;
6909       } else
6910         newE->defaultAtts[i].value = NULL;
6911     }
6912   }
6913
6914   /* Copy the entity tables. */
6915   if (! copyEntityTable(oldParser, &(newDtd->generalEntities), &(newDtd->pool),
6916                         &(oldDtd->generalEntities)))
6917     return 0;
6918
6919 #ifdef XML_DTD
6920   if (! copyEntityTable(oldParser, &(newDtd->paramEntities), &(newDtd->pool),
6921                         &(oldDtd->paramEntities)))
6922     return 0;
6923   newDtd->paramEntityRead = oldDtd->paramEntityRead;
6924 #endif /* XML_DTD */
6925
6926   newDtd->keepProcessing = oldDtd->keepProcessing;
6927   newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;
6928   newDtd->standalone = oldDtd->standalone;
6929
6930   /* Don't want deep copying for scaffolding */
6931   newDtd->in_eldecl = oldDtd->in_eldecl;
6932   newDtd->scaffold = oldDtd->scaffold;
6933   newDtd->contentStringLen = oldDtd->contentStringLen;
6934   newDtd->scaffSize = oldDtd->scaffSize;
6935   newDtd->scaffLevel = oldDtd->scaffLevel;
6936   newDtd->scaffIndex = oldDtd->scaffIndex;
6937
6938   return 1;
6939 } /* End dtdCopy */
6940
6941 static int
6942 copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,
6943                 STRING_POOL *newPool, const HASH_TABLE *oldTable) {
6944   HASH_TABLE_ITER iter;
6945   const XML_Char *cachedOldBase = NULL;
6946   const XML_Char *cachedNewBase = NULL;
6947
6948   hashTableIterInit(&iter, oldTable);
6949
6950   for (;;) {
6951     ENTITY *newE;
6952     const XML_Char *name;
6953     const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
6954     if (! oldE)
6955       break;
6956     name = poolCopyString(newPool, oldE->name);
6957     if (! name)
6958       return 0;
6959     newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
6960     if (! newE)
6961       return 0;
6962     if (oldE->systemId) {
6963       const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
6964       if (! tem)
6965         return 0;
6966       newE->systemId = tem;
6967       if (oldE->base) {
6968         if (oldE->base == cachedOldBase)
6969           newE->base = cachedNewBase;
6970         else {
6971           cachedOldBase = oldE->base;
6972           tem = poolCopyString(newPool, cachedOldBase);
6973           if (! tem)
6974             return 0;
6975           cachedNewBase = newE->base = tem;
6976         }
6977       }
6978       if (oldE->publicId) {
6979         tem = poolCopyString(newPool, oldE->publicId);
6980         if (! tem)
6981           return 0;
6982         newE->publicId = tem;
6983       }
6984     } else {
6985       const XML_Char *tem
6986           = poolCopyStringN(newPool, oldE->textPtr, oldE->textLen);
6987       if (! tem)
6988         return 0;
6989       newE->textPtr = tem;
6990       newE->textLen = oldE->textLen;
6991     }
6992     if (oldE->notation) {
6993       const XML_Char *tem = poolCopyString(newPool, oldE->notation);
6994       if (! tem)
6995         return 0;
6996       newE->notation = tem;
6997     }
6998     newE->is_param = oldE->is_param;
6999     newE->is_internal = oldE->is_internal;
7000   }
7001   return 1;
7002 }
7003
7004 #define INIT_POWER 6
7005
7006 static XML_Bool FASTCALL
7007 keyeq(KEY s1, KEY s2) {
7008   for (; *s1 == *s2; s1++, s2++)
7009     if (*s1 == 0)
7010       return XML_TRUE;
7011   return XML_FALSE;
7012 }
7013
7014 static size_t
7015 keylen(KEY s) {
7016   size_t len = 0;
7017   for (; *s; s++, len++)
7018     ;
7019   return len;
7020 }
7021
7022 static void
7023 copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {
7024   key->k[0] = 0;
7025   key->k[1] = get_hash_secret_salt(parser);
7026 }
7027
7028 static unsigned long FASTCALL
7029 hash(XML_Parser parser, KEY s) {
7030   struct siphash state;
7031   struct sipkey key;
7032   (void)sip24_valid;
7033   copy_salt_to_sipkey(parser, &key);
7034   sip24_init(&state, &key);
7035   sip24_update(&state, s, keylen(s) * sizeof(XML_Char));
7036   return (unsigned long)sip24_final(&state);
7037 }
7038
7039 static NAMED *
7040 lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {
7041   size_t i;
7042   if (table->size == 0) {
7043     size_t tsize;
7044     if (! createSize)
7045       return NULL;
7046     table->power = INIT_POWER;
7047     /* table->size is a power of 2 */
7048     table->size = (size_t)1 << INIT_POWER;
7049     tsize = table->size * sizeof(NAMED *);
7050     table->v = table->mem->malloc_fcn(tsize);
7051     if (! table->v) {
7052       table->size = 0;
7053       return NULL;
7054     }
7055     memset(table->v, 0, tsize);
7056     i = hash(parser, name) & ((unsigned long)table->size - 1);
7057   } else {
7058     unsigned long h = hash(parser, name);
7059     unsigned long mask = (unsigned long)table->size - 1;
7060     unsigned char step = 0;
7061     i = h & mask;
7062     while (table->v[i]) {
7063       if (keyeq(name, table->v[i]->name))
7064         return table->v[i];
7065       if (! step)
7066         step = PROBE_STEP(h, mask, table->power);
7067       i < step ? (i += table->size - step) : (i -= step);
7068     }
7069     if (! createSize)
7070       return NULL;
7071
7072     /* check for overflow (table is half full) */
7073     if (table->used >> (table->power - 1)) {
7074       unsigned char newPower = table->power + 1;
7075
7076       /* Detect and prevent invalid shift */
7077       if (newPower >= sizeof(unsigned long) * 8 /* bits per byte */) {
7078         return NULL;
7079       }
7080
7081       size_t newSize = (size_t)1 << newPower;
7082       unsigned long newMask = (unsigned long)newSize - 1;
7083
7084       /* Detect and prevent integer overflow */
7085       if (newSize > (size_t)(-1) / sizeof(NAMED *)) {
7086         return NULL;
7087       }
7088
7089       size_t tsize = newSize * sizeof(NAMED *);
7090       NAMED **newV = table->mem->malloc_fcn(tsize);
7091       if (! newV)
7092         return NULL;
7093       memset(newV, 0, tsize);
7094       for (i = 0; i < table->size; i++)
7095         if (table->v[i]) {
7096           unsigned long newHash = hash(parser, table->v[i]->name);
7097           size_t j = newHash & newMask;
7098           step = 0;
7099           while (newV[j]) {
7100             if (! step)
7101               step = PROBE_STEP(newHash, newMask, newPower);
7102             j < step ? (j += newSize - step) : (j -= step);
7103           }
7104           newV[j] = table->v[i];
7105         }
7106       table->mem->free_fcn(table->v);
7107       table->v = newV;
7108       table->power = newPower;
7109       table->size = newSize;
7110       i = h & newMask;
7111       step = 0;
7112       while (table->v[i]) {
7113         if (! step)
7114           step = PROBE_STEP(h, newMask, newPower);
7115         i < step ? (i += newSize - step) : (i -= step);
7116       }
7117     }
7118   }
7119   table->v[i] = table->mem->malloc_fcn(createSize);
7120   if (! table->v[i])
7121     return NULL;
7122   memset(table->v[i], 0, createSize);
7123   table->v[i]->name = name;
7124   (table->used)++;
7125   return table->v[i];
7126 }
7127
7128 static void FASTCALL
7129 hashTableClear(HASH_TABLE *table) {
7130   size_t i;
7131   for (i = 0; i < table->size; i++) {
7132     table->mem->free_fcn(table->v[i]);
7133     table->v[i] = NULL;
7134   }
7135   table->used = 0;
7136 }
7137
7138 static void FASTCALL
7139 hashTableDestroy(HASH_TABLE *table) {
7140   size_t i;
7141   for (i = 0; i < table->size; i++)
7142     table->mem->free_fcn(table->v[i]);
7143   table->mem->free_fcn(table->v);
7144 }
7145
7146 static void FASTCALL
7147 hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms) {
7148   p->power = 0;
7149   p->size = 0;
7150   p->used = 0;
7151   p->v = NULL;
7152   p->mem = ms;
7153 }
7154
7155 static void FASTCALL
7156 hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table) {
7157   iter->p = table->v;
7158   iter->end = iter->p ? iter->p + table->size : NULL;
7159 }
7160
7161 static NAMED *FASTCALL
7162 hashTableIterNext(HASH_TABLE_ITER *iter) {
7163   while (iter->p != iter->end) {
7164     NAMED *tem = *(iter->p)++;
7165     if (tem)
7166       return tem;
7167   }
7168   return NULL;
7169 }
7170
7171 static void FASTCALL
7172 poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms) {
7173   pool->blocks = NULL;
7174   pool->freeBlocks = NULL;
7175   pool->start = NULL;
7176   pool->ptr = NULL;
7177   pool->end = NULL;
7178   pool->mem = ms;
7179 }
7180
7181 static void FASTCALL
7182 poolClear(STRING_POOL *pool) {
7183   if (! pool->freeBlocks)
7184     pool->freeBlocks = pool->blocks;
7185   else {
7186     BLOCK *p = pool->blocks;
7187     while (p) {
7188       BLOCK *tem = p->next;
7189       p->next = pool->freeBlocks;
7190       pool->freeBlocks = p;
7191       p = tem;
7192     }
7193   }
7194   pool->blocks = NULL;
7195   pool->start = NULL;
7196   pool->ptr = NULL;
7197   pool->end = NULL;
7198 }
7199
7200 static void FASTCALL
7201 poolDestroy(STRING_POOL *pool) {
7202   BLOCK *p = pool->blocks;
7203   while (p) {
7204     BLOCK *tem = p->next;
7205     pool->mem->free_fcn(p);
7206     p = tem;
7207   }
7208   p = pool->freeBlocks;
7209   while (p) {
7210     BLOCK *tem = p->next;
7211     pool->mem->free_fcn(p);
7212     p = tem;
7213   }
7214 }
7215
7216 static XML_Char *
7217 poolAppend(STRING_POOL *pool, const ENCODING *enc, const char *ptr,
7218            const char *end) {
7219   if (! pool->ptr && ! poolGrow(pool))
7220     return NULL;
7221   for (;;) {
7222     const enum XML_Convert_Result convert_res = XmlConvert(
7223         enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
7224     if ((convert_res == XML_CONVERT_COMPLETED)
7225         || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
7226       break;
7227     if (! poolGrow(pool))
7228       return NULL;
7229   }
7230   return pool->start;
7231 }
7232
7233 static const XML_Char *FASTCALL
7234 poolCopyString(STRING_POOL *pool, const XML_Char *s) {
7235   do {
7236     if (! poolAppendChar(pool, *s))
7237       return NULL;
7238   } while (*s++);
7239   s = pool->start;
7240   poolFinish(pool);
7241   return s;
7242 }
7243
7244 static const XML_Char *
7245 poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n) {
7246   if (! pool->ptr && ! poolGrow(pool)) {
7247     /* The following line is unreachable given the current usage of
7248      * poolCopyStringN().  Currently it is called from exactly one
7249      * place to copy the text of a simple general entity.  By that
7250      * point, the name of the entity is already stored in the pool, so
7251      * pool->ptr cannot be NULL.
7252      *
7253      * If poolCopyStringN() is used elsewhere as it well might be,
7254      * this line may well become executable again.  Regardless, this
7255      * sort of check shouldn't be removed lightly, so we just exclude
7256      * it from the coverage statistics.
7257      */
7258     return NULL; /* LCOV_EXCL_LINE */
7259   }
7260   for (; n > 0; --n, s++) {
7261     if (! poolAppendChar(pool, *s))
7262       return NULL;
7263   }
7264   s = pool->start;
7265   poolFinish(pool);
7266   return s;
7267 }
7268
7269 static const XML_Char *FASTCALL
7270 poolAppendString(STRING_POOL *pool, const XML_Char *s) {
7271   while (*s) {
7272     if (! poolAppendChar(pool, *s))
7273       return NULL;
7274     s++;
7275   }
7276   return pool->start;
7277 }
7278
7279 static XML_Char *
7280 poolStoreString(STRING_POOL *pool, const ENCODING *enc, const char *ptr,
7281                 const char *end) {
7282   if (! poolAppend(pool, enc, ptr, end))
7283     return NULL;
7284   if (pool->ptr == pool->end && ! poolGrow(pool))
7285     return NULL;
7286   *(pool->ptr)++ = 0;
7287   return pool->start;
7288 }
7289
7290 static size_t
7291 poolBytesToAllocateFor(int blockSize) {
7292   /* Unprotected math would be:
7293   ** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char);
7294   **
7295   ** Detect overflow, avoiding _signed_ overflow undefined behavior
7296   ** For a + b * c we check b * c in isolation first, so that addition of a
7297   ** on top has no chance of making us accept a small non-negative number
7298   */
7299   const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */
7300
7301   if (blockSize <= 0)
7302     return 0;
7303
7304   if (blockSize > (int)(INT_MAX / stretch))
7305     return 0;
7306
7307   {
7308     const int stretchedBlockSize = blockSize * (int)stretch;
7309     const int bytesToAllocate
7310         = (int)(offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);
7311     if (bytesToAllocate < 0)
7312       return 0;
7313
7314     return (size_t)bytesToAllocate;
7315   }
7316 }
7317
7318 static XML_Bool FASTCALL
7319 poolGrow(STRING_POOL *pool) {
7320   if (pool->freeBlocks) {
7321     if (pool->start == 0) {
7322       pool->blocks = pool->freeBlocks;
7323       pool->freeBlocks = pool->freeBlocks->next;
7324       pool->blocks->next = NULL;
7325       pool->start = pool->blocks->s;
7326       pool->end = pool->start + pool->blocks->size;
7327       pool->ptr = pool->start;
7328       return XML_TRUE;
7329     }
7330     if (pool->end - pool->start < pool->freeBlocks->size) {
7331       BLOCK *tem = pool->freeBlocks->next;
7332       pool->freeBlocks->next = pool->blocks;
7333       pool->blocks = pool->freeBlocks;
7334       pool->freeBlocks = tem;
7335       memcpy(pool->blocks->s, pool->start,
7336              (pool->end - pool->start) * sizeof(XML_Char));
7337       pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
7338       pool->start = pool->blocks->s;
7339       pool->end = pool->start + pool->blocks->size;
7340       return XML_TRUE;
7341     }
7342   }
7343   if (pool->blocks && pool->start == pool->blocks->s) {
7344     BLOCK *temp;
7345     int blockSize = (int)((unsigned)(pool->end - pool->start) * 2U);
7346     size_t bytesToAllocate;
7347
7348     /* NOTE: Needs to be calculated prior to calling `realloc`
7349              to avoid dangling pointers: */
7350     const ptrdiff_t offsetInsideBlock = pool->ptr - pool->start;
7351
7352     if (blockSize < 0) {
7353       /* This condition traps a situation where either more than
7354        * INT_MAX/2 bytes have already been allocated.  This isn't
7355        * readily testable, since it is unlikely that an average
7356        * machine will have that much memory, so we exclude it from the
7357        * coverage statistics.
7358        */
7359       return XML_FALSE; /* LCOV_EXCL_LINE */
7360     }
7361
7362     bytesToAllocate = poolBytesToAllocateFor(blockSize);
7363     if (bytesToAllocate == 0)
7364       return XML_FALSE;
7365
7366     temp = (BLOCK *)pool->mem->realloc_fcn(pool->blocks,
7367                                            (unsigned)bytesToAllocate);
7368     if (temp == NULL)
7369       return XML_FALSE;
7370     pool->blocks = temp;
7371     pool->blocks->size = blockSize;
7372     pool->ptr = pool->blocks->s + offsetInsideBlock;
7373     pool->start = pool->blocks->s;
7374     pool->end = pool->start + blockSize;
7375   } else {
7376     BLOCK *tem;
7377     int blockSize = (int)(pool->end - pool->start);
7378     size_t bytesToAllocate;
7379
7380     if (blockSize < 0) {
7381       /* This condition traps a situation where either more than
7382        * INT_MAX bytes have already been allocated (which is prevented
7383        * by various pieces of program logic, not least this one, never
7384        * mind the unlikelihood of actually having that much memory) or
7385        * the pool control fields have been corrupted (which could
7386        * conceivably happen in an extremely buggy user handler
7387        * function).  Either way it isn't readily testable, so we
7388        * exclude it from the coverage statistics.
7389        */
7390       return XML_FALSE; /* LCOV_EXCL_LINE */
7391     }
7392
7393     if (blockSize < INIT_BLOCK_SIZE)
7394       blockSize = INIT_BLOCK_SIZE;
7395     else {
7396       /* Detect overflow, avoiding _signed_ overflow undefined behavior */
7397       if ((int)((unsigned)blockSize * 2U) < 0) {
7398         return XML_FALSE;
7399       }
7400       blockSize *= 2;
7401     }
7402
7403     bytesToAllocate = poolBytesToAllocateFor(blockSize);
7404     if (bytesToAllocate == 0)
7405       return XML_FALSE;
7406
7407     tem = pool->mem->malloc_fcn(bytesToAllocate);
7408     if (! tem)
7409       return XML_FALSE;
7410     tem->size = blockSize;
7411     tem->next = pool->blocks;
7412     pool->blocks = tem;
7413     if (pool->ptr != pool->start)
7414       memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
7415     pool->ptr = tem->s + (pool->ptr - pool->start);
7416     pool->start = tem->s;
7417     pool->end = tem->s + blockSize;
7418   }
7419   return XML_TRUE;
7420 }
7421
7422 static int FASTCALL
7423 nextScaffoldPart(XML_Parser parser) {
7424   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7425   CONTENT_SCAFFOLD *me;
7426   int next;
7427
7428   if (! dtd->scaffIndex) {
7429     dtd->scaffIndex = (int *)MALLOC(parser, parser->m_groupSize * sizeof(int));
7430     if (! dtd->scaffIndex)
7431       return -1;
7432     dtd->scaffIndex[0] = 0;
7433   }
7434
7435   if (dtd->scaffCount >= dtd->scaffSize) {
7436     CONTENT_SCAFFOLD *temp;
7437     if (dtd->scaffold) {
7438       /* Detect and prevent integer overflow */
7439       if (dtd->scaffSize > UINT_MAX / 2u) {
7440         return -1;
7441       }
7442       /* Detect and prevent integer overflow.
7443        * The preprocessor guard addresses the "always false" warning
7444        * from -Wtype-limits on platforms where
7445        * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
7446 #if UINT_MAX >= SIZE_MAX
7447       if (dtd->scaffSize > (size_t)(-1) / 2u / sizeof(CONTENT_SCAFFOLD)) {
7448         return -1;
7449       }
7450 #endif
7451
7452       temp = (CONTENT_SCAFFOLD *)REALLOC(
7453           parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
7454       if (temp == NULL)
7455         return -1;
7456       dtd->scaffSize *= 2;
7457     } else {
7458       temp = (CONTENT_SCAFFOLD *)MALLOC(parser, INIT_SCAFFOLD_ELEMENTS
7459                                                     * sizeof(CONTENT_SCAFFOLD));
7460       if (temp == NULL)
7461         return -1;
7462       dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
7463     }
7464     dtd->scaffold = temp;
7465   }
7466   next = dtd->scaffCount++;
7467   me = &dtd->scaffold[next];
7468   if (dtd->scaffLevel) {
7469     CONTENT_SCAFFOLD *parent
7470         = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]];
7471     if (parent->lastchild) {
7472       dtd->scaffold[parent->lastchild].nextsib = next;
7473     }
7474     if (! parent->childcnt)
7475       parent->firstchild = next;
7476     parent->lastchild = next;
7477     parent->childcnt++;
7478   }
7479   me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
7480   return next;
7481 }
7482
7483 static XML_Content *
7484 build_model(XML_Parser parser) {
7485   /* Function build_model transforms the existing parser->m_dtd->scaffold
7486    * array of CONTENT_SCAFFOLD tree nodes into a new array of
7487    * XML_Content tree nodes followed by a gapless list of zero-terminated
7488    * strings. */
7489   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7490   XML_Content *ret;
7491   XML_Char *str; /* the current string writing location */
7492
7493   /* Detect and prevent integer overflow.
7494    * The preprocessor guard addresses the "always false" warning
7495    * from -Wtype-limits on platforms where
7496    * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
7497 #if UINT_MAX >= SIZE_MAX
7498   if (dtd->scaffCount > (size_t)(-1) / sizeof(XML_Content)) {
7499     return NULL;
7500   }
7501   if (dtd->contentStringLen > (size_t)(-1) / sizeof(XML_Char)) {
7502     return NULL;
7503   }
7504 #endif
7505   if (dtd->scaffCount * sizeof(XML_Content)
7506       > (size_t)(-1) - dtd->contentStringLen * sizeof(XML_Char)) {
7507     return NULL;
7508   }
7509
7510   const size_t allocsize = (dtd->scaffCount * sizeof(XML_Content)
7511                             + (dtd->contentStringLen * sizeof(XML_Char)));
7512
7513   ret = (XML_Content *)MALLOC(parser, allocsize);
7514   if (! ret)
7515     return NULL;
7516
7517   /* What follows is an iterative implementation (of what was previously done
7518    * recursively in a dedicated function called "build_node".  The old recursive
7519    * build_node could be forced into stack exhaustion from input as small as a
7520    * few megabyte, and so that was a security issue.  Hence, a function call
7521    * stack is avoided now by resolving recursion.)
7522    *
7523    * The iterative approach works as follows:
7524    *
7525    * - We have two writing pointers, both walking up the result array; one does
7526    *   the work, the other creates "jobs" for its colleague to do, and leads
7527    *   the way:
7528    *
7529    *   - The faster one, pointer jobDest, always leads and writes "what job
7530    *     to do" by the other, once they reach that place in the
7531    *     array: leader "jobDest" stores the source node array index (relative
7532    *     to array dtd->scaffold) in field "numchildren".
7533    *
7534    *   - The slower one, pointer dest, looks at the value stored in the
7535    *     "numchildren" field (which actually holds a source node array index
7536    *     at that time) and puts the real data from dtd->scaffold in.
7537    *
7538    * - Before the loop starts, jobDest writes source array index 0
7539    *   (where the root node is located) so that dest will have something to do
7540    *   when it starts operation.
7541    *
7542    * - Whenever nodes with children are encountered, jobDest appends
7543    *   them as new jobs, in order.  As a result, tree node siblings are
7544    *   adjacent in the resulting array, for example:
7545    *
7546    *     [0] root, has two children
7547    *       [1] first child of 0, has three children
7548    *         [3] first child of 1, does not have children
7549    *         [4] second child of 1, does not have children
7550    *         [5] third child of 1, does not have children
7551    *       [2] second child of 0, does not have children
7552    *
7553    *   Or (the same data) presented in flat array view:
7554    *
7555    *     [0] root, has two children
7556    *
7557    *     [1] first child of 0, has three children
7558    *     [2] second child of 0, does not have children
7559    *
7560    *     [3] first child of 1, does not have children
7561    *     [4] second child of 1, does not have children
7562    *     [5] third child of 1, does not have children
7563    *
7564    * - The algorithm repeats until all target array indices have been processed.
7565    */
7566   XML_Content *dest = ret; /* tree node writing location, moves upwards */
7567   XML_Content *const destLimit = &ret[dtd->scaffCount];
7568   XML_Content *jobDest = ret; /* next free writing location in target array */
7569   str = (XML_Char *)&ret[dtd->scaffCount];
7570
7571   /* Add the starting job, the root node (index 0) of the source tree  */
7572   (jobDest++)->numchildren = 0;
7573
7574   for (; dest < destLimit; dest++) {
7575     /* Retrieve source tree array index from job storage */
7576     const int src_node = (int)dest->numchildren;
7577
7578     /* Convert item */
7579     dest->type = dtd->scaffold[src_node].type;
7580     dest->quant = dtd->scaffold[src_node].quant;
7581     if (dest->type == XML_CTYPE_NAME) {
7582       const XML_Char *src;
7583       dest->name = str;
7584       src = dtd->scaffold[src_node].name;
7585       for (;;) {
7586         *str++ = *src;
7587         if (! *src)
7588           break;
7589         src++;
7590       }
7591       dest->numchildren = 0;
7592       dest->children = NULL;
7593     } else {
7594       unsigned int i;
7595       int cn;
7596       dest->name = NULL;
7597       dest->numchildren = dtd->scaffold[src_node].childcnt;
7598       dest->children = jobDest;
7599
7600       /* Append scaffold indices of children to array */
7601       for (i = 0, cn = dtd->scaffold[src_node].firstchild;
7602            i < dest->numchildren; i++, cn = dtd->scaffold[cn].nextsib)
7603         (jobDest++)->numchildren = (unsigned int)cn;
7604     }
7605   }
7606
7607   return ret;
7608 }
7609
7610 static ELEMENT_TYPE *
7611 getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,
7612                const char *end) {
7613   DTD *const dtd = parser->m_dtd; /* save one level of indirection */
7614   const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
7615   ELEMENT_TYPE *ret;
7616
7617   if (! name)
7618     return NULL;
7619   ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
7620                                sizeof(ELEMENT_TYPE));
7621   if (! ret)
7622     return NULL;
7623   if (ret->name != name)
7624     poolDiscard(&dtd->pool);
7625   else {
7626     poolFinish(&dtd->pool);
7627     if (! setElementTypePrefix(parser, ret))
7628       return NULL;
7629   }
7630   return ret;
7631 }
7632
7633 static XML_Char *
7634 copyString(const XML_Char *s, const XML_Memory_Handling_Suite *memsuite) {
7635   size_t charsRequired = 0;
7636   XML_Char *result;
7637
7638   /* First determine how long the string is */
7639   while (s[charsRequired] != 0) {
7640     charsRequired++;
7641   }
7642   /* Include the terminator */
7643   charsRequired++;
7644
7645   /* Now allocate space for the copy */
7646   result = memsuite->malloc_fcn(charsRequired * sizeof(XML_Char));
7647   if (result == NULL)
7648     return NULL;
7649   /* Copy the original into place */
7650   memcpy(result, s, charsRequired * sizeof(XML_Char));
7651   return result;
7652 }
7653
7654 #ifdef XML_DTD
7655
7656 static float
7657 accountingGetCurrentAmplification(XML_Parser rootParser) {
7658   const XmlBigCount countBytesOutput
7659       = rootParser->m_accounting.countBytesDirect
7660         + rootParser->m_accounting.countBytesIndirect;
7661   const float amplificationFactor
7662       = rootParser->m_accounting.countBytesDirect
7663             ? (countBytesOutput
7664                / (float)(rootParser->m_accounting.countBytesDirect))
7665             : 1.0f;
7666   assert(! rootParser->m_parentParser);
7667   return amplificationFactor;
7668 }
7669
7670 static void
7671 accountingReportStats(XML_Parser originParser, const char *epilog) {
7672   const XML_Parser rootParser = getRootParserOf(originParser, NULL);
7673   assert(! rootParser->m_parentParser);
7674
7675   if (rootParser->m_accounting.debugLevel < 1) {
7676     return;
7677   }
7678
7679   const float amplificationFactor
7680       = accountingGetCurrentAmplification(rootParser);
7681   fprintf(stderr,
7682           "expat: Accounting(%p): Direct " EXPAT_FMT_ULL(
7683               "10") ", indirect " EXPAT_FMT_ULL("10") ", amplification %8.2f%s",
7684           (void *)rootParser, rootParser->m_accounting.countBytesDirect,
7685           rootParser->m_accounting.countBytesIndirect,
7686           (double)amplificationFactor, epilog);
7687 }
7688
7689 static void
7690 accountingOnAbort(XML_Parser originParser) {
7691   accountingReportStats(originParser, " ABORTING\n");
7692 }
7693
7694 static void
7695 accountingReportDiff(XML_Parser rootParser,
7696                      unsigned int levelsAwayFromRootParser, const char *before,
7697                      const char *after, ptrdiff_t bytesMore, int source_line,
7698                      enum XML_Account account) {
7699   assert(! rootParser->m_parentParser);
7700
7701   fprintf(stderr,
7702           " (+" EXPAT_FMT_PTRDIFF_T("6") " bytes %s|%d, xmlparse.c:%d) %*s\"",
7703           bytesMore, (account == XML_ACCOUNT_DIRECT) ? "DIR" : "EXP",
7704           levelsAwayFromRootParser, source_line, 10, "");
7705
7706   const char ellipis[] = "[..]";
7707   const size_t ellipsisLength = sizeof(ellipis) /* because compile-time */ - 1;
7708   const unsigned int contextLength = 10;
7709
7710   /* Note: Performance is of no concern here */
7711   const char *walker = before;
7712   if ((rootParser->m_accounting.debugLevel >= 3)
7713       || (after - before)
7714              <= (ptrdiff_t)(contextLength + ellipsisLength + contextLength)) {
7715     for (; walker < after; walker++) {
7716       fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
7717     }
7718   } else {
7719     for (; walker < before + contextLength; walker++) {
7720       fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
7721     }
7722     fprintf(stderr, ellipis);
7723     walker = after - contextLength;
7724     for (; walker < after; walker++) {
7725       fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
7726     }
7727   }
7728   fprintf(stderr, "\"\n");
7729 }
7730
7731 static XML_Bool
7732 accountingDiffTolerated(XML_Parser originParser, int tok, const char *before,
7733                         const char *after, int source_line,
7734                         enum XML_Account account) {
7735   /* Note: We need to check the token type *first* to be sure that
7736    *       we can even access variable <after>, safely.
7737    *       E.g. for XML_TOK_NONE <after> may hold an invalid pointer. */
7738   switch (tok) {
7739   case XML_TOK_INVALID:
7740   case XML_TOK_PARTIAL:
7741   case XML_TOK_PARTIAL_CHAR:
7742   case XML_TOK_NONE:
7743     return XML_TRUE;
7744   }
7745
7746   if (account == XML_ACCOUNT_NONE)
7747     return XML_TRUE; /* because these bytes have been accounted for, already */
7748
7749   unsigned int levelsAwayFromRootParser;
7750   const XML_Parser rootParser
7751       = getRootParserOf(originParser, &levelsAwayFromRootParser);
7752   assert(! rootParser->m_parentParser);
7753
7754   const int isDirect
7755       = (account == XML_ACCOUNT_DIRECT) && (originParser == rootParser);
7756   const ptrdiff_t bytesMore = after - before;
7757
7758   XmlBigCount *const additionTarget
7759       = isDirect ? &rootParser->m_accounting.countBytesDirect
7760                  : &rootParser->m_accounting.countBytesIndirect;
7761
7762   /* Detect and avoid integer overflow */
7763   if (*additionTarget > (XmlBigCount)(-1) - (XmlBigCount)bytesMore)
7764     return XML_FALSE;
7765   *additionTarget += bytesMore;
7766
7767   const XmlBigCount countBytesOutput
7768       = rootParser->m_accounting.countBytesDirect
7769         + rootParser->m_accounting.countBytesIndirect;
7770   const float amplificationFactor
7771       = accountingGetCurrentAmplification(rootParser);
7772   const XML_Bool tolerated
7773       = (countBytesOutput < rootParser->m_accounting.activationThresholdBytes)
7774         || (amplificationFactor
7775             <= rootParser->m_accounting.maximumAmplificationFactor);
7776
7777   if (rootParser->m_accounting.debugLevel >= 2) {
7778     accountingReportStats(rootParser, "");
7779     accountingReportDiff(rootParser, levelsAwayFromRootParser, before, after,
7780                          bytesMore, source_line, account);
7781   }
7782
7783   return tolerated;
7784 }
7785
7786 unsigned long long
7787 testingAccountingGetCountBytesDirect(XML_Parser parser) {
7788   if (! parser)
7789     return 0;
7790   return parser->m_accounting.countBytesDirect;
7791 }
7792
7793 unsigned long long
7794 testingAccountingGetCountBytesIndirect(XML_Parser parser) {
7795   if (! parser)
7796     return 0;
7797   return parser->m_accounting.countBytesIndirect;
7798 }
7799
7800 static void
7801 entityTrackingReportStats(XML_Parser rootParser, ENTITY *entity,
7802                           const char *action, int sourceLine) {
7803   assert(! rootParser->m_parentParser);
7804   if (rootParser->m_entity_stats.debugLevel < 1)
7805     return;
7806
7807 #  if defined(XML_UNICODE)
7808   const char *const entityName = "[..]";
7809 #  else
7810   const char *const entityName = entity->name;
7811 #  endif
7812
7813   fprintf(
7814       stderr,
7815       "expat: Entities(%p): Count %9d, depth %2d/%2d %*s%s%s; %s length %d (xmlparse.c:%d)\n",
7816       (void *)rootParser, rootParser->m_entity_stats.countEverOpened,
7817       rootParser->m_entity_stats.currentDepth,
7818       rootParser->m_entity_stats.maximumDepthSeen,
7819       (rootParser->m_entity_stats.currentDepth - 1) * 2, "",
7820       entity->is_param ? "%" : "&", entityName, action, entity->textLen,
7821       sourceLine);
7822 }
7823
7824 static void
7825 entityTrackingOnOpen(XML_Parser originParser, ENTITY *entity, int sourceLine) {
7826   const XML_Parser rootParser = getRootParserOf(originParser, NULL);
7827   assert(! rootParser->m_parentParser);
7828
7829   rootParser->m_entity_stats.countEverOpened++;
7830   rootParser->m_entity_stats.currentDepth++;
7831   if (rootParser->m_entity_stats.currentDepth
7832       > rootParser->m_entity_stats.maximumDepthSeen) {
7833     rootParser->m_entity_stats.maximumDepthSeen++;
7834   }
7835
7836   entityTrackingReportStats(rootParser, entity, "OPEN ", sourceLine);
7837 }
7838
7839 static void
7840 entityTrackingOnClose(XML_Parser originParser, ENTITY *entity, int sourceLine) {
7841   const XML_Parser rootParser = getRootParserOf(originParser, NULL);
7842   assert(! rootParser->m_parentParser);
7843
7844   entityTrackingReportStats(rootParser, entity, "CLOSE", sourceLine);
7845   rootParser->m_entity_stats.currentDepth--;
7846 }
7847
7848 static XML_Parser
7849 getRootParserOf(XML_Parser parser, unsigned int *outLevelDiff) {
7850   XML_Parser rootParser = parser;
7851   unsigned int stepsTakenUpwards = 0;
7852   while (rootParser->m_parentParser) {
7853     rootParser = rootParser->m_parentParser;
7854     stepsTakenUpwards++;
7855   }
7856   assert(! rootParser->m_parentParser);
7857   if (outLevelDiff != NULL) {
7858     *outLevelDiff = stepsTakenUpwards;
7859   }
7860   return rootParser;
7861 }
7862
7863 const char *
7864 unsignedCharToPrintable(unsigned char c) {
7865   switch (c) {
7866   case 0:
7867     return "\\0";
7868   case 1:
7869     return "\\x1";
7870   case 2:
7871     return "\\x2";
7872   case 3:
7873     return "\\x3";
7874   case 4:
7875     return "\\x4";
7876   case 5:
7877     return "\\x5";
7878   case 6:
7879     return "\\x6";
7880   case 7:
7881     return "\\x7";
7882   case 8:
7883     return "\\x8";
7884   case 9:
7885     return "\\t";
7886   case 10:
7887     return "\\n";
7888   case 11:
7889     return "\\xB";
7890   case 12:
7891     return "\\xC";
7892   case 13:
7893     return "\\r";
7894   case 14:
7895     return "\\xE";
7896   case 15:
7897     return "\\xF";
7898   case 16:
7899     return "\\x10";
7900   case 17:
7901     return "\\x11";
7902   case 18:
7903     return "\\x12";
7904   case 19:
7905     return "\\x13";
7906   case 20:
7907     return "\\x14";
7908   case 21:
7909     return "\\x15";
7910   case 22:
7911     return "\\x16";
7912   case 23:
7913     return "\\x17";
7914   case 24:
7915     return "\\x18";
7916   case 25:
7917     return "\\x19";
7918   case 26:
7919     return "\\x1A";
7920   case 27:
7921     return "\\x1B";
7922   case 28:
7923     return "\\x1C";
7924   case 29:
7925     return "\\x1D";
7926   case 30:
7927     return "\\x1E";
7928   case 31:
7929     return "\\x1F";
7930   case 32:
7931     return " ";
7932   case 33:
7933     return "!";
7934   case 34:
7935     return "\\\"";
7936   case 35:
7937     return "#";
7938   case 36:
7939     return "$";
7940   case 37:
7941     return "%";
7942   case 38:
7943     return "&";
7944   case 39:
7945     return "'";
7946   case 40:
7947     return "(";
7948   case 41:
7949     return ")";
7950   case 42:
7951     return "*";
7952   case 43:
7953     return "+";
7954   case 44:
7955     return ",";
7956   case 45:
7957     return "-";
7958   case 46:
7959     return ".";
7960   case 47:
7961     return "/";
7962   case 48:
7963     return "0";
7964   case 49:
7965     return "1";
7966   case 50:
7967     return "2";
7968   case 51:
7969     return "3";
7970   case 52:
7971     return "4";
7972   case 53:
7973     return "5";
7974   case 54:
7975     return "6";
7976   case 55:
7977     return "7";
7978   case 56:
7979     return "8";
7980   case 57:
7981     return "9";
7982   case 58:
7983     return ":";
7984   case 59:
7985     return ";";
7986   case 60:
7987     return "<";
7988   case 61:
7989     return "=";
7990   case 62:
7991     return ">";
7992   case 63:
7993     return "?";
7994   case 64:
7995     return "@";
7996   case 65:
7997     return "A";
7998   case 66:
7999     return "B";
8000   case 67:
8001     return "C";
8002   case 68:
8003     return "D";
8004   case 69:
8005     return "E";
8006   case 70:
8007     return "F";
8008   case 71:
8009     return "G";
8010   case 72:
8011     return "H";
8012   case 73:
8013     return "I";
8014   case 74:
8015     return "J";
8016   case 75:
8017     return "K";
8018   case 76:
8019     return "L";
8020   case 77:
8021     return "M";
8022   case 78:
8023     return "N";
8024   case 79:
8025     return "O";
8026   case 80:
8027     return "P";
8028   case 81:
8029     return "Q";
8030   case 82:
8031     return "R";
8032   case 83:
8033     return "S";
8034   case 84:
8035     return "T";
8036   case 85:
8037     return "U";
8038   case 86:
8039     return "V";
8040   case 87:
8041     return "W";
8042   case 88:
8043     return "X";
8044   case 89:
8045     return "Y";
8046   case 90:
8047     return "Z";
8048   case 91:
8049     return "[";
8050   case 92:
8051     return "\\\\";
8052   case 93:
8053     return "]";
8054   case 94:
8055     return "^";
8056   case 95:
8057     return "_";
8058   case 96:
8059     return "`";
8060   case 97:
8061     return "a";
8062   case 98:
8063     return "b";
8064   case 99:
8065     return "c";
8066   case 100:
8067     return "d";
8068   case 101:
8069     return "e";
8070   case 102:
8071     return "f";
8072   case 103:
8073     return "g";
8074   case 104:
8075     return "h";
8076   case 105:
8077     return "i";
8078   case 106:
8079     return "j";
8080   case 107:
8081     return "k";
8082   case 108:
8083     return "l";
8084   case 109:
8085     return "m";
8086   case 110:
8087     return "n";
8088   case 111:
8089     return "o";
8090   case 112:
8091     return "p";
8092   case 113:
8093     return "q";
8094   case 114:
8095     return "r";
8096   case 115:
8097     return "s";
8098   case 116:
8099     return "t";
8100   case 117:
8101     return "u";
8102   case 118:
8103     return "v";
8104   case 119:
8105     return "w";
8106   case 120:
8107     return "x";
8108   case 121:
8109     return "y";
8110   case 122:
8111     return "z";
8112   case 123:
8113     return "{";
8114   case 124:
8115     return "|";
8116   case 125:
8117     return "}";
8118   case 126:
8119     return "~";
8120   case 127:
8121     return "\\x7F";
8122   case 128:
8123     return "\\x80";
8124   case 129:
8125     return "\\x81";
8126   case 130:
8127     return "\\x82";
8128   case 131:
8129     return "\\x83";
8130   case 132:
8131     return "\\x84";
8132   case 133:
8133     return "\\x85";
8134   case 134:
8135     return "\\x86";
8136   case 135:
8137     return "\\x87";
8138   case 136:
8139     return "\\x88";
8140   case 137:
8141     return "\\x89";
8142   case 138:
8143     return "\\x8A";
8144   case 139:
8145     return "\\x8B";
8146   case 140:
8147     return "\\x8C";
8148   case 141:
8149     return "\\x8D";
8150   case 142:
8151     return "\\x8E";
8152   case 143:
8153     return "\\x8F";
8154   case 144:
8155     return "\\x90";
8156   case 145:
8157     return "\\x91";
8158   case 146:
8159     return "\\x92";
8160   case 147:
8161     return "\\x93";
8162   case 148:
8163     return "\\x94";
8164   case 149:
8165     return "\\x95";
8166   case 150:
8167     return "\\x96";
8168   case 151:
8169     return "\\x97";
8170   case 152:
8171     return "\\x98";
8172   case 153:
8173     return "\\x99";
8174   case 154:
8175     return "\\x9A";
8176   case 155:
8177     return "\\x9B";
8178   case 156:
8179     return "\\x9C";
8180   case 157:
8181     return "\\x9D";
8182   case 158:
8183     return "\\x9E";
8184   case 159:
8185     return "\\x9F";
8186   case 160:
8187     return "\\xA0";
8188   case 161:
8189     return "\\xA1";
8190   case 162:
8191     return "\\xA2";
8192   case 163:
8193     return "\\xA3";
8194   case 164:
8195     return "\\xA4";
8196   case 165:
8197     return "\\xA5";
8198   case 166:
8199     return "\\xA6";
8200   case 167:
8201     return "\\xA7";
8202   case 168:
8203     return "\\xA8";
8204   case 169:
8205     return "\\xA9";
8206   case 170:
8207     return "\\xAA";
8208   case 171:
8209     return "\\xAB";
8210   case 172:
8211     return "\\xAC";
8212   case 173:
8213     return "\\xAD";
8214   case 174:
8215     return "\\xAE";
8216   case 175:
8217     return "\\xAF";
8218   case 176:
8219     return "\\xB0";
8220   case 177:
8221     return "\\xB1";
8222   case 178:
8223     return "\\xB2";
8224   case 179:
8225     return "\\xB3";
8226   case 180:
8227     return "\\xB4";
8228   case 181:
8229     return "\\xB5";
8230   case 182:
8231     return "\\xB6";
8232   case 183:
8233     return "\\xB7";
8234   case 184:
8235     return "\\xB8";
8236   case 185:
8237     return "\\xB9";
8238   case 186:
8239     return "\\xBA";
8240   case 187:
8241     return "\\xBB";
8242   case 188:
8243     return "\\xBC";
8244   case 189:
8245     return "\\xBD";
8246   case 190:
8247     return "\\xBE";
8248   case 191:
8249     return "\\xBF";
8250   case 192:
8251     return "\\xC0";
8252   case 193:
8253     return "\\xC1";
8254   case 194:
8255     return "\\xC2";
8256   case 195:
8257     return "\\xC3";
8258   case 196:
8259     return "\\xC4";
8260   case 197:
8261     return "\\xC5";
8262   case 198:
8263     return "\\xC6";
8264   case 199:
8265     return "\\xC7";
8266   case 200:
8267     return "\\xC8";
8268   case 201:
8269     return "\\xC9";
8270   case 202:
8271     return "\\xCA";
8272   case 203:
8273     return "\\xCB";
8274   case 204:
8275     return "\\xCC";
8276   case 205:
8277     return "\\xCD";
8278   case 206:
8279     return "\\xCE";
8280   case 207:
8281     return "\\xCF";
8282   case 208:
8283     return "\\xD0";
8284   case 209:
8285     return "\\xD1";
8286   case 210:
8287     return "\\xD2";
8288   case 211:
8289     return "\\xD3";
8290   case 212:
8291     return "\\xD4";
8292   case 213:
8293     return "\\xD5";
8294   case 214:
8295     return "\\xD6";
8296   case 215:
8297     return "\\xD7";
8298   case 216:
8299     return "\\xD8";
8300   case 217:
8301     return "\\xD9";
8302   case 218:
8303     return "\\xDA";
8304   case 219:
8305     return "\\xDB";
8306   case 220:
8307     return "\\xDC";
8308   case 221:
8309     return "\\xDD";
8310   case 222:
8311     return "\\xDE";
8312   case 223:
8313     return "\\xDF";
8314   case 224:
8315     return "\\xE0";
8316   case 225:
8317     return "\\xE1";
8318   case 226:
8319     return "\\xE2";
8320   case 227:
8321     return "\\xE3";
8322   case 228:
8323     return "\\xE4";
8324   case 229:
8325     return "\\xE5";
8326   case 230:
8327     return "\\xE6";
8328   case 231:
8329     return "\\xE7";
8330   case 232:
8331     return "\\xE8";
8332   case 233:
8333     return "\\xE9";
8334   case 234:
8335     return "\\xEA";
8336   case 235:
8337     return "\\xEB";
8338   case 236:
8339     return "\\xEC";
8340   case 237:
8341     return "\\xED";
8342   case 238:
8343     return "\\xEE";
8344   case 239:
8345     return "\\xEF";
8346   case 240:
8347     return "\\xF0";
8348   case 241:
8349     return "\\xF1";
8350   case 242:
8351     return "\\xF2";
8352   case 243:
8353     return "\\xF3";
8354   case 244:
8355     return "\\xF4";
8356   case 245:
8357     return "\\xF5";
8358   case 246:
8359     return "\\xF6";
8360   case 247:
8361     return "\\xF7";
8362   case 248:
8363     return "\\xF8";
8364   case 249:
8365     return "\\xF9";
8366   case 250:
8367     return "\\xFA";
8368   case 251:
8369     return "\\xFB";
8370   case 252:
8371     return "\\xFC";
8372   case 253:
8373     return "\\xFD";
8374   case 254:
8375     return "\\xFE";
8376   case 255:
8377     return "\\xFF";
8378   default:
8379     assert(0); /* never gets here */
8380     return "dead code";
8381   }
8382   assert(0); /* never gets here */
8383 }
8384
8385 #endif /* XML_DTD */
8386
8387 static unsigned long
8388 getDebugLevel(const char *variableName, unsigned long defaultDebugLevel) {
8389   const char *const valueOrNull = getenv(variableName);
8390   if (valueOrNull == NULL) {
8391     return defaultDebugLevel;
8392   }
8393   const char *const value = valueOrNull;
8394
8395   errno = 0;
8396   char *afterValue = (char *)value;
8397   unsigned long debugLevel = strtoul(value, &afterValue, 10);
8398   if ((errno != 0) || (afterValue[0] != '\0')) {
8399     errno = 0;
8400     return defaultDebugLevel;
8401   }
8402
8403   return debugLevel;
8404 }