#define XML_BUILDING_EXPAT 1

#include "expat_config.h"

#if ! defined(XML_GE) || (1 - XML_GE - 1 == 2) || (XML_GE < 0) || (XML_GE > 1)

# error XML_GE (for general entities) must be defined, non-empty, either 1 or 0 (0 to disable, 1 to enable; 1 is a common default)

#if defined(XML_DTD) && XML_GE == 0

# error Either undefine XML_DTD or define XML_GE to 1.

#if ! defined(XML_CONTEXT_BYTES) || (1 - XML_CONTEXT_BYTES - 1 == 2) \

|| (XML_CONTEXT_BYTES + 0 < 0)

# error XML_CONTEXT_BYTES must be defined, non-empty and >=0 (0 to disable, >=1 to enable; 1024 is a common default)

#include <stdbool.h>

#include <stddef.h>

#include <string.h> /* memset(), memcpy() */

#include <assert.h>

#include <limits.h> /* INT_MAX, UINT_MAX */

#include <stdio.h> /* fprintf */

#include <stdlib.h> /* getenv */

#include <stdint.h> /* SIZE_MAX, UINT64_MAX, uint64_t, uintptr_t */

#include <math.h> /* isnan */

#include <errno.h>

#ifdef _WIN32

# define getpid GetCurrentProcessId

# include <sys/time.h> /* gettimeofday() */

# include <sys/types.h> /* getpid() */

# include <unistd.h> /* getpid() */

# include <fcntl.h> /* O_RDONLY */

# include <errno.h>

#ifdef _WIN32

# include "winconfig.h"

#include "ascii.h"

#include "expat.h"

#include "siphash.h"

#include "xcsinc.c"

#if defined(HAVE_ARC4RANDOM)

# include "random_arc4random.h"

#endif /* defined(HAVE_ARC4RANDOM) */

#if defined(HAVE_ARC4RANDOM_BUF)

# include "random_arc4random_buf.h"

#endif // defined(HAVE_ARC4RANDOM_BUF)

#if defined(XML_DEV_URANDOM)

# include "random_dev_urandom.h"

#endif /* defined(XML_DEV_URANDOM) */

#if defined(HAVE_GETENTROPY)

# include "random_getentropy.h"

#endif // defined(HAVE_GETENTROPY)

#if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)

# include "random_getrandom.h"

#endif /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */

#if defined(_WIN32) && ! defined(XML_POOR_ENTROPY)

# include "random_rand_s.h"

#endif /* defined(_WIN32) && ! defined(XML_POOR_ENTROPY) */

#if ! defined(HAVE_GETRANDOM) && ! defined(HAVE_SYSCALL_GETRANDOM) \

&& ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) \

&& ! defined(HAVE_GETENTROPY) && ! defined(XML_DEV_URANDOM) \

&& ! defined(_WIN32) && ! defined(XML_POOR_ENTROPY)

# error You do not have support for any sources of high quality entropy \

enabled. For end user security, that is probably not what you want. \

\

Your options include: \

* Linux >=3.17 + glibc >=2.25 (getrandom): HAVE_GETRANDOM, \

* Linux >=3.17 + glibc (including <2.25) (syscall SYS_getrandom): HAVE_SYSCALL_GETRANDOM, \

* BSD / macOS >=10.7 / glibc >=2.36 (arc4random_buf): HAVE_ARC4RANDOM_BUF, \

* BSD / macOS (including <10.7) / glibc >=2.36 (arc4random): HAVE_ARC4RANDOM, \

* BSD / macOS >=10.12 / glibc >=2.25 (getentropy): HAVE_GETENTROPY, \

* Linux (including <3.17) / BSD / macOS (including <10.7) / Solaris >=8 (/dev/urandom): XML_DEV_URANDOM, \

* Windows >=Vista (rand_s): _WIN32. \

\

If you insist on not using any of these, bypass this error by defining \

XML_POOR_ENTROPY and be vulnerable to hash flooding; you have been warned. \

\

If you have reasons to patch this detection code away or need changes \

to the build system, please open a bug. Thank you!

#ifdef XML_UNICODE

# define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX

# define XmlConvert XmlUtf16Convert

# define XmlGetInternalEncoding XmlGetUtf16InternalEncoding

# define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS

# define XmlEncode XmlUtf16Encode

# define MUST_CONVERT(enc, s) (! (enc)->isUtf16 || (((uintptr_t)(s)) & 1))

typedef unsigned short ICHAR;

# define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX

# define XmlConvert XmlUtf8Convert

# define XmlGetInternalEncoding XmlGetUtf8InternalEncoding

# define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS

# define XmlEncode XmlUtf8Encode

# define MUST_CONVERT(enc, s) (! (enc)->isUtf8)

typedef char ICHAR;

#ifndef XML_NS

# define XmlInitEncodingNS XmlInitEncoding

# define XmlInitUnknownEncodingNS XmlInitUnknownEncoding

# undef XmlGetInternalEncodingNS

# define XmlGetInternalEncodingNS XmlGetInternalEncoding

# define XmlParseXmlDeclNS XmlParseXmlDecl

#ifdef XML_UNICODE

# ifdef XML_UNICODE_WCHAR_T

# define XML_T(x) (const wchar_t) x

# define XML_L(x) L##x

# define XML_T(x) (const unsigned short)x

# define XML_L(x) x

# define XML_T(x) x

# define XML_L(x) x

#define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))

#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0)

#define EXPAT_MIN(a, b) (((a) < (b)) ? (a) : (b))

#include "internal.h"

#include "hash_table.h"

#include "xmltok.h"

#include "xmlrole.h"

static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);

#define SECOND_HASH(hash, mask, power) \

((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))

#define PROBE_STEP(hash, mask, power) \

((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))

#define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */

#define INIT_DATA_BUF_SIZE 1024

#define INIT_ATTS_SIZE 16

#define INIT_ATTS_VERSION 0xFFFFFFFF

#define INIT_BLOCK_SIZE 1024

#define INIT_BUFFER_SIZE 1024

#define EXPAND_SPARE 24

typedef struct binding {

} BINDING;

typedef struct prefix {

const XML_Char *name;

BINDING *binding;

} PREFIX;

typedef struct {

const XML_Char *str;

const XML_Char *localPart;

const XML_Char *prefix;

size_t strLen;

size_t uriLen;

size_t prefixLen;

} TAG_NAME;

typedef struct tag {

} TAG;

typedef struct {

const XML_Char *name;

const XML_Char *textPtr;

int textLen; /* length in XML_Chars */

int processed; /* # of processed bytes - when suspended */

const XML_Char *systemId;

const XML_Char *base;

const XML_Char *publicId;

const XML_Char *notation;

bool open;

bool hasMore; /* true if entity has not been completely processed */

/* An entity can be open while being already completely processed (!hasMore).

bool is_param;

bool is_internal; /* true if declared in internal subset outside PE */

} ENTITY;

typedef struct {

enum XML_Content_Type type;

enum XML_Content_Quant quant;

const XML_Char *name;

int firstchild;

int lastchild;

int childcnt;

int nextsib;

} CONTENT_SCAFFOLD;

#define INIT_SCAFFOLD_ELEMENTS 32

typedef struct block {

} BLOCK;

typedef struct {

BLOCK *blocks;

BLOCK *freeBlocks;

const XML_Char *end;

XML_Char *ptr;

XML_Char *start;

XML_Parser parser;

} STRING_POOL;

typedef struct attribute_id {

} ATTRIBUTE_ID;

typedef struct {

const ATTRIBUTE_ID *id;

XML_Bool isCdata;

const XML_Char *value;

} DEFAULT_ATTRIBUTE;

typedef struct {

// Member `name` goes first to make this structure compatible with structure

// `NAMED` (further up), which is needed to support use of structure

// `NAME_AND_DEFAULT_ATTRIBUTE` in a hash table as implemented by function

// `lookup` (further down).

const XML_Char *name;

// We would store a `DEFAULT_ATTRIBUTE *` here but the backing array

// can be reallocated which would invalidate the pointer. Using an index

// into the array instead, avoids that problem.

size_t attIndex;

// This is set to `false` by function `lookup`.

bool initialized;

} NAME_AND_DEFAULT_ATTRIBUTE;

typedef struct {

unsigned long version;

unsigned long hash;

const XML_Char *uriName;

} NS_ATT;

typedef struct {

const XML_Char *name;

PREFIX *prefix;

const ATTRIBUTE_ID *idAtt;

size_t nDefaultAtts;

size_t allocDefaultAtts;

DEFAULT_ATTRIBUTE *defaultAtts;

HASH_TABLE defaultAttForName;

} ELEMENT_TYPE;

typedef struct {

HASH_TABLE generalEntities;

HASH_TABLE elementTypes;

HASH_TABLE attributeIds;

HASH_TABLE prefixes;

STRING_POOL pool;

STRING_POOL entityValuePool;

/* false once a parameter entity reference has been skipped */

XML_Bool keepProcessing;

/* true once an internal or external PE reference has been encountered;

XML_Bool hasParamEntityRefs;

XML_Bool standalone;

#ifdef XML_DTD

/* indicates if external PE has been read */

bool paramEntityRead;

HASH_TABLE paramEntities;

#endif /* XML_DTD */

PREFIX defaultPrefix;

/* === scaffolding for building content model === */

bool in_eldecl;

CONTENT_SCAFFOLD *scaffold;

unsigned contentStringLen;

unsigned scaffSize;

unsigned scaffCount;

int scaffLevel;

int *scaffIndex;

size_t scaffIndexSize;

} DTD;

enum EntityType {

};

typedef struct open_internal_entity {

} OPEN_INTERNAL_ENTITY;

enum XML_Account {

};

#if XML_GE == 1

typedef unsigned long long XmlBigCount;

typedef struct accounting {

} ACCOUNTING;

typedef struct MALLOC_TRACKER {

} MALLOC_TRACKER;

typedef struct entity_stats {

} ENTITY_STATS;

#endif /* XML_GE == 1 */

typedef enum XML_Error Processor(XML_Parser parser, const char *start,

const char *end, const char **endPtr);

static Processor prologProcessor;

static Processor prologInitProcessor;

static Processor contentProcessor;

static Processor cdataSectionProcessor;

#ifdef XML_DTD

static Processor ignoreSectionProcessor;

static Processor externalParEntProcessor;

static Processor externalParEntInitProcessor;

static Processor entityValueProcessor;

static Processor entityValueInitProcessor;

#endif /* XML_DTD */

static Processor epilogProcessor;

static Processor errorProcessor;

static Processor externalEntityInitProcessor;

static Processor externalEntityInitProcessor2;

static Processor externalEntityInitProcessor3;

static Processor externalEntityContentProcessor;

static Processor internalEntityProcessor;

static enum XML_Error handleUnknownEncoding(XML_Parser parser,

const XML_Char *encodingName);

static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

const char *s, const char *next);

static enum XML_Error initializeEncoding(XML_Parser parser);

static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,

enum XML_Account account);

static enum XML_Error processEntity(XML_Parser parser, ENTITY *entity,

bool betweenDecl, enum EntityType type);

static enum XML_Error doContent(XML_Parser parser, int startTagLevel,

const ENCODING *enc, const char *start,

const char *end, const char **endPtr,

XML_Bool haveMore, enum XML_Account account);

static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *enc,

const char **startPtr, const char *end,

const char **nextPtr, XML_Bool haveMore,

enum XML_Account account);

#ifdef XML_DTD

static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *enc,

const char **startPtr, const char *end,

const char **nextPtr, XML_Bool haveMore);

#endif /* XML_DTD */

static void freeBindings(XML_Parser parser, BINDING *bindings);

static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,

const char *attStr, TAG_NAME *tagNamePtr,

BINDING **bindingsPtr,

enum XML_Account account);

static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,

const ATTRIBUTE_ID *attId, const XML_Char *uri,

BINDING **bindingsPtr);

static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId,

XML_Bool isCdata, XML_Bool isId,

const XML_Char *value, XML_Parser parser);

static enum XML_Error storeAttributeValue(XML_Parser parser,

enum XML_Account account);

static enum XML_Error

appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,

const char *ptr, const char *end, STRING_POOL *pool,

enum XML_Account account, const char **nextPtr);

static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,

const char *start, const char *end);

static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType);

#if XML_GE == 1

static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,

const char *start, const char *end,

enum XML_Account account,

const char **nextPtr);

static enum XML_Error callStoreEntityValue(XML_Parser parser,

const ENCODING *enc,

const char *start, const char *end,

enum XML_Account account);

static enum XML_Error storeSelfEntityValue(XML_Parser parser, ENTITY *entity);

static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,

const char *start, const char *end);

static int reportComment(XML_Parser parser, const ENCODING *enc,

const char *start, const char *end);

static void reportDefault(XML_Parser parser, const ENCODING *enc,

const char *start, const char *end);

static const XML_Char *getContext(XML_Parser parser);

static XML_Bool setContext(XML_Parser parser, const XML_Char *context);

static void normalizePublicId(XML_Char *s);

static DTD *dtdCreate(XML_Parser parser);

static void dtdReset(DTD *p, XML_Parser parser);

static void dtdDestroy(DTD *p, XML_Bool isDocEntity, XML_Parser parser);

static int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,

XML_Parser parser);

static int copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,

STRING_POOL *newPool, const HASH_TABLE *oldTable);

static void poolInit(STRING_POOL *pool, XML_Parser parser);

static void poolClear(STRING_POOL *pool);

static void poolDestroy(STRING_POOL *pool);

static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,

const char *ptr, const char *end);

static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,

const char *ptr, const char *end);

static XML_Bool poolGrow(STRING_POOL *pool);

static bool poolGrowUntil(STRING_POOL *pool, size_t needed);

static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s);

static const XML_Char *poolCopyStringNoFinish(STRING_POOL *pool,

const XML_Char *s);

static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,

int n);

static const XML_Char *poolAppendString(STRING_POOL *pool, const XML_Char *s);

static int nextScaffoldPart(XML_Parser parser);

static XML_Content *build_model(XML_Parser parser);

static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,

const char *ptr, const char *end);

static XML_Char *copyString(const XML_Char *s, XML_Parser parser);

static struct sipkey generate_hash_secret_salt(void);

static XML_Bool startParsing(XML_Parser parser);

static XML_Parser parserCreate(const XML_Char *encodingName,

const XML_Memory_Handling_Suite *memsuite,

const XML_Char *nameSep, DTD *dtd,

XML_Parser parentParser);

static void parserInit(XML_Parser parser, const XML_Char *encodingName);

#if XML_GE == 1

static float accountingGetCurrentAmplification(XML_Parser rootParser);

static void accountingReportStats(XML_Parser originParser, const char *epilog);

static void accountingOnAbort(XML_Parser originParser);

static void accountingReportDiff(XML_Parser rootParser,

enum XML_Account account);

static XML_Bool accountingDiffTolerated(XML_Parser originParser, int tok,

const char *before, const char *after,

int source_line,

enum XML_Account account);

static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,

const char *action, int sourceLine);

static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,

int sourceLine);

static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,

int sourceLine);

#endif /* XML_GE == 1 */

static XML_Parser getRootParserOf(XML_Parser parser,

unsigned int *outLevelDiff);

static unsigned long getDebugLevel(const char *variableName,

unsigned long defaultDebugLevel);

static bool poolAppendChar(STRING_POOL *pool, XML_Char c);

static bool poolAppendChars(STRING_POOL *pool, const XML_Char *s, size_t len);

#define poolStart(pool) ((pool)->start)

#define poolLength(pool) ((pool)->ptr - (pool)->start)

#define poolChop(pool) ((void)--(pool->ptr))

#define poolLastChar(pool) (((pool)->ptr)[-1])

#define poolDiscard(pool) ((pool)->ptr = (pool)->start)

#define poolFinish(pool) ((pool)->start = (pool)->ptr)

poolAppendChar(STRING_POOL *pool, XML_Char c) {

if (pool->ptr == pool->end && ! poolGrow(pool))

return false;

*(pool->ptr)++ = c;

return true;

}

poolAppendChars(STRING_POOL *pool, const XML_Char *s, size_t len) {

// Detect and prevent integer overflow

if (len > SIZE_MAX / sizeof(XML_Char))

return false;

if (! poolGrowUntil(pool, len))

return false;

memcpy(pool->ptr, s, len * sizeof(XML_Char));

pool->ptr += len;

return true;

}

#if ! defined(XML_TESTING)

XML_Bool g_reparseDeferralEnabledDefault

= XML_TRUE; // write ONLY in runtests.c

#if defined(XML_TESTING)

unsigned int g_bytesScanned = 0; // used for testing only

struct XML_ParserStruct {

};

#if XML_GE == 1

# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__))

# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__))

# define FREE(parser, p) (expat_free((parser), (p), __LINE__))

# define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))

# define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))

# define FREE(parser, p) (parser->m_mem.free_fcn((p)))

#if XML_GE == 1

static void

expat_heap_stat(XML_Parser rootParser, char operator, XmlBigCount absDiff,

XmlBigCount newTotal, XmlBigCount peakTotal, int sourceLine) {

// NOTE: This can be +infinity or -nan

const float amplification

= (float)newTotal / (float)rootParser->m_accounting.countBytesDirect;

fprintf(

stderr,

"expat: Allocations(%p): Direct " EXPAT_FMT_ULL("10") ", allocated %c" EXPAT_FMT_ULL(

"10") " to " EXPAT_FMT_ULL("10") " (" EXPAT_FMT_ULL("10") " peak), amplification %8.2f (xmlparse.c:%d)\n",

(void *)rootParser, rootParser->m_accounting.countBytesDirect, operator,

absDiff, newTotal, peakTotal, (double)amplification, sourceLine);

}

static bool

expat_heap_increase_tolerable(XML_Parser rootParser, XmlBigCount increase,

int sourceLine) {

assert(rootParser != NULL);

assert(increase > 0);

XmlBigCount newTotal = 0;

bool tolerable = true;

// Detect integer overflow

if ((XmlBigCount)-1 - rootParser->m_alloc_tracker.bytesAllocated < increase) {

tolerable = false;

} else {

newTotal = rootParser->m_alloc_tracker.bytesAllocated + increase;

if (newTotal >= rootParser->m_alloc_tracker.activationThresholdBytes) {

assert(newTotal > 0);

// NOTE: This can be +infinity when dividing by zero but not -nan

const float amplification

= (float)newTotal / (float)rootParser->m_accounting.countBytesDirect;

if (amplification

> rootParser->m_alloc_tracker.maximumAmplificationFactor) {

tolerable = false;

}

}

}

if (! tolerable && (rootParser->m_alloc_tracker.debugLevel >= 1)) {

expat_heap_stat(rootParser, '+', increase, newTotal, newTotal, sourceLine);

}

return tolerable;

}

# if defined(XML_TESTING)

void *

static void *

expat_malloc(XML_Parser parser, size_t size, int sourceLine) {

// Detect integer overflow

if (SIZE_MAX - size < sizeof(size_t) + EXPAT_MALLOC_PADDING) {

return NULL;

}

const XML_Parser rootParser = getRootParserOf(parser, NULL);

assert(rootParser->m_parentParser == NULL);

const size_t bytesToAllocate = sizeof(size_t) + EXPAT_MALLOC_PADDING + size;

if ((XmlBigCount)-1 - rootParser->m_alloc_tracker.bytesAllocated

< bytesToAllocate) {

return NULL; // i.e. signal integer overflow as out-of-memory

}

if (! expat_heap_increase_tolerable(rootParser, bytesToAllocate,

sourceLine)) {

return NULL; // i.e. signal violation as out-of-memory

}

// Actually allocate

void *const mallocedPtr = parser->m_mem.malloc_fcn(bytesToAllocate);

if (mallocedPtr == NULL) {

return NULL;

}

// Update in-block recorded size

*(size_t *)mallocedPtr = size;

// Update accounting

rootParser->m_alloc_tracker.bytesAllocated += bytesToAllocate;

// Report as needed

if (rootParser->m_alloc_tracker.debugLevel >= 2) {

if (rootParser->m_alloc_tracker.bytesAllocated

> rootParser->m_alloc_tracker.peakBytesAllocated) {

rootParser->m_alloc_tracker.peakBytesAllocated

= rootParser->m_alloc_tracker.bytesAllocated;

}

expat_heap_stat(rootParser, '+', bytesToAllocate,

rootParser->m_alloc_tracker.bytesAllocated,

rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine);

}

return (char *)mallocedPtr + sizeof(size_t) + EXPAT_MALLOC_PADDING;

}

# if defined(XML_TESTING)

static void

expat_free(XML_Parser parser, void *ptr, int sourceLine) {

assert(parser != NULL);

if (ptr == NULL) {

return;

}

const XML_Parser rootParser = getRootParserOf(parser, NULL);

assert(rootParser->m_parentParser == NULL);

// Extract size (to the eyes of malloc_fcn/realloc_fcn) and

// the original pointer returned by malloc/realloc

void *const mallocedPtr = (char *)ptr - EXPAT_MALLOC_PADDING - sizeof(size_t);

const size_t bytesAllocated

= sizeof(size_t) + EXPAT_MALLOC_PADDING + *(size_t *)mallocedPtr;

// Update accounting

assert(rootParser->m_alloc_tracker.bytesAllocated >= bytesAllocated);

rootParser->m_alloc_tracker.bytesAllocated -= bytesAllocated;

// Report as needed

if (rootParser->m_alloc_tracker.debugLevel >= 2) {

expat_heap_stat(rootParser, '-', bytesAllocated,

rootParser->m_alloc_tracker.bytesAllocated,

rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine);

}

// NOTE: This may be freeing rootParser, so freeing has to come last

parser->m_mem.free_fcn(mallocedPtr);

}

# if defined(XML_TESTING)

void *

static void *

expat_realloc(XML_Parser parser, void *ptr, size_t size, int sourceLine) {

assert(parser != NULL);

if (ptr == NULL) {

return expat_malloc(parser, size, sourceLine);

}

if (size == 0) {

expat_free(parser, ptr, sourceLine);

return NULL;

}

const XML_Parser rootParser = getRootParserOf(parser, NULL);

assert(rootParser->m_parentParser == NULL);

// Extract original size (to the eyes of the caller) and the original

// pointer returned by malloc/realloc

void *mallocedPtr = (char *)ptr - EXPAT_MALLOC_PADDING - sizeof(size_t);

const size_t prevSize = *(size_t *)mallocedPtr;

// Classify upcoming change

const bool isIncrease = (size > prevSize);

const size_t absDiff

= (size > prevSize) ? (size - prevSize) : (prevSize - size);

// Ask for permission from accounting

if (isIncrease) {

if (! expat_heap_increase_tolerable(rootParser, absDiff, sourceLine)) {

return NULL; // i.e. signal violation as out-of-memory

}

}