#define XML_BUILDING_EXPAT 1

#include <expat_config.h>

#if ! defined(_GNU_SOURCE)

# define _GNU_SOURCE 1 /* syscall prototype */

#ifdef _WIN32

# if ! defined(_CRT_RAND_S)

# define _CRT_RAND_S

#include <stddef.h>

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

#include <assert.h>

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

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

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

#include <stdint.h> /* uintptr_t */

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

#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"

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

# if defined(HAVE_GETRANDOM)

# include <sys/random.h> /* getrandom */

# include <unistd.h> /* syscall */

# include <sys/syscall.h> /* SYS_getrandom */

# if ! defined(GRND_NONBLOCK)

# define GRND_NONBLOCK 0x0001

# endif /* defined(GRND_NONBLOCK) */

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

#if defined(HAVE_LIBBSD) \

&& (defined(HAVE_ARC4RANDOM_BUF) || defined(HAVE_ARC4RANDOM))

# include <bsd/stdlib.h>

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

# define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800

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

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

&& ! 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 (arc4random_buf): HAVE_ARC4RANDOM_BUF, \

* BSD / macOS (including <10.7) (arc4random): HAVE_ARC4RANDOM, \

* libbsd (arc4random_buf): HAVE_ARC4RANDOM_BUF + HAVE_LIBBSD, \

* libbsd (arc4random): HAVE_ARC4RANDOM + HAVE_LIBBSD, \

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

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

\

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

XML_POOR_ENTROPY; 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)

#include "internal.h"

#include "xmltok.h"

#include "xmlrole.h"

typedef const XML_Char *KEY;

typedef struct {

KEY name;

} NAMED;

typedef struct {

NAMED **v;

unsigned char power;

size_t size;

size_t used;

const XML_Memory_Handling_Suite *mem;

} HASH_TABLE;

static size_t keylen(KEY s);

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))

typedef struct {

NAMED **p;

NAMED **end;

} HASH_TABLE_ITER;

#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;

int strLen;

int uriLen;

int 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;

XML_Bool open;

XML_Bool is_param;

XML_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;

const XML_Memory_Handling_Suite *mem;

} 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 {

unsigned long version;

unsigned long hash;

const XML_Char *uriName;

} NS_ATT;

typedef struct {

const XML_Char *name;

PREFIX *prefix;

const ATTRIBUTE_ID *idAtt;

int nDefaultAtts;

int allocDefaultAtts;

DEFAULT_ATTRIBUTE *defaultAtts;

} 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 */

XML_Bool paramEntityRead;

HASH_TABLE paramEntities;

#endif /* XML_DTD */

PREFIX defaultPrefix;

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

XML_Bool in_eldecl;

CONTENT_SCAFFOLD *scaffold;

unsigned contentStringLen;

unsigned scaffSize;

unsigned scaffCount;

int scaffLevel;

int *scaffIndex;

} DTD;

typedef struct open_internal_entity {

} OPEN_INTERNAL_ENTITY;

enum XML_Account {

};

#ifdef XML_DTD

typedef unsigned long long XmlBigCount;

typedef struct accounting {

} ACCOUNTING;

typedef struct entity_stats {

} ENTITY_STATS;

#endif /* XML_DTD */

typedef enum XML_Error PTRCALL 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 processInternalEntity(XML_Parser parser, ENTITY *entity,

XML_Bool betweenDecl);

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 *,

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 *,

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 *,

const char *s, 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 *, XML_Bool isCdata,

XML_Bool isId, const XML_Char *dfltValue,

XML_Parser parser);

static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *,

XML_Bool isCdata, const char *,

const char *, STRING_POOL *,

enum XML_Account account);

static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *,

XML_Bool isCdata, const char *,

const char *, STRING_POOL *,

enum XML_Account account);

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

const char *start, const char *end);

static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);

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

const char *start, const char *end,

enum XML_Account account);

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 FASTCALL normalizePublicId(XML_Char *s);

static DTD *dtdCreate(const XML_Memory_Handling_Suite *ms);

static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);

static void dtdDestroy(DTD *p, XML_Bool isDocEntity,

const XML_Memory_Handling_Suite *ms);

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

const XML_Memory_Handling_Suite *ms);

static int copyEntityTable(XML_Parser oldParser, HASH_TABLE *, STRING_POOL *,

const HASH_TABLE *);

static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,

size_t createSize);

static void FASTCALL hashTableInit(HASH_TABLE *,

const XML_Memory_Handling_Suite *ms);

static void FASTCALL hashTableClear(HASH_TABLE *);

static void FASTCALL hashTableDestroy(HASH_TABLE *);

static void FASTCALL hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);

static NAMED *FASTCALL hashTableIterNext(HASH_TABLE_ITER *);

static void FASTCALL poolInit(STRING_POOL *,

const XML_Memory_Handling_Suite *ms);

static void FASTCALL poolClear(STRING_POOL *);

static void FASTCALL poolDestroy(STRING_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 FASTCALL poolGrow(STRING_POOL *pool);

static const XML_Char *FASTCALL poolCopyString(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 *FASTCALL poolAppendString(STRING_POOL *pool,

const XML_Char *s);

static int FASTCALL 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,

const XML_Memory_Handling_Suite *memsuite);

static unsigned long generate_hash_secret_salt(XML_Parser parser);

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);

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

#ifdef XML_DTD

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);

static XML_Parser getRootParserOf(XML_Parser parser,

unsigned int *outLevelDiff);

#endif /* XML_DTD */

static unsigned long getDebugLevel(const char *variableName,

unsigned long defaultDebugLevel);

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

#define poolEnd(pool) ((pool)->ptr)

#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)

#define poolAppendChar(pool, c) \

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

? 0 \

: ((*((pool)->ptr)++ = c), 1))

struct XML_ParserStruct {

};

#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)))

XML_Parser XMLCALL

XML_ParserCreate(const XML_Char *encodingName) {

return XML_ParserCreate_MM(encodingName, NULL, NULL);

}

XML_Parser XMLCALL

XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) {

XML_Char tmp[2];

*tmp = nsSep;

return XML_ParserCreate_MM(encodingName, NULL, tmp);

}

static const XML_Char implicitContext[]

= {ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h,

ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH,

ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD,

ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r,

ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L,

ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ASCII_8,

ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,

ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e,

'\0'};

#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)

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

static int

writeRandomBytes_getrandom_nonblock(void *target, size_t count) {

int success = 0; /* full count bytes written? */

size_t bytesWrittenTotal = 0;

const unsigned int getrandomFlags = GRND_NONBLOCK;

do {

void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);

const size_t bytesToWrite = count - bytesWrittenTotal;

const int bytesWrittenMore =

# if defined(HAVE_GETRANDOM)

getrandom(currentTarget, bytesToWrite, getrandomFlags);

syscall(SYS_getrandom, currentTarget, bytesToWrite, getrandomFlags);

if (bytesWrittenMore > 0) {

bytesWrittenTotal += bytesWrittenMore;

if (bytesWrittenTotal >= count)

success = 1;

}

} while (! success && (errno == EINTR));

return success;

}

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

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

static int

writeRandomBytes_dev_urandom(void *target, size_t count) {

int success = 0; /* full count bytes written? */

size_t bytesWrittenTotal = 0;

const int fd = open("/dev/urandom", O_RDONLY);

if (fd < 0) {

return 0;

}

do {

void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);

const size_t bytesToWrite = count - bytesWrittenTotal;

const ssize_t bytesWrittenMore = read(fd, currentTarget, bytesToWrite);

if (bytesWrittenMore > 0) {

bytesWrittenTotal += bytesWrittenMore;

if (bytesWrittenTotal >= count)

success = 1;

}

} while (! success && (errno == EINTR));

close(fd);

return success;

}

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

#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */

#if defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF)

static void

writeRandomBytes_arc4random(void *target, size_t count) {

size_t bytesWrittenTotal = 0;

while (bytesWrittenTotal < count) {

const uint32_t random32 = arc4random();

size_t i = 0;

for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);

i++, bytesWrittenTotal++) {

const uint8_t random8 = (uint8_t)(random32 >> (i * 8));

((uint8_t *)target)[bytesWrittenTotal] = random8;

}

}

}

#endif /* defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF) */

#ifdef _WIN32

# if defined(__MINGW32__) && defined(__MINGW32_VERSION) \

&& __MINGW32_VERSION < 5003000L && ! defined(__MINGW64_VERSION_MAJOR)

__declspec(dllimport) int rand_s(unsigned int *);

static int

writeRandomBytes_rand_s(void *target, size_t count) {

size_t bytesWrittenTotal = 0;

while (bytesWrittenTotal < count) {

unsigned int random32 = 0;

size_t i = 0;

if (rand_s(&random32))

return 0; /* failure */

for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);

i++, bytesWrittenTotal++) {

const uint8_t random8 = (uint8_t)(random32 >> (i * 8));

((uint8_t *)target)[bytesWrittenTotal] = random8;

}

}

return 1; /* success */

}

#endif /* _WIN32 */

#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)

static unsigned long

gather_time_entropy(void) {

# ifdef _WIN32

FILETIME ft;

GetSystemTimeAsFileTime(&ft); /* never fails */

return ft.dwHighDateTime ^ ft.dwLowDateTime;

struct timeval tv;

int gettimeofday_res;

gettimeofday_res = gettimeofday(&tv, NULL);

# if defined(NDEBUG)

(void)gettimeofday_res;

assert(gettimeofday_res == 0);

# endif /* defined(NDEBUG) */

/* Microseconds time is <20 bits entropy */

return tv.tv_usec;

}

#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */

static unsigned long

ENTROPY_DEBUG(const char *label, unsigned long entropy) {

if (getDebugLevel("EXPAT_ENTROPY_DEBUG", 0) >= 1u) {

fprintf(stderr, "expat: Entropy: %s --> 0x%0*lx (%lu bytes)\n", label,

(int)sizeof(entropy) * 2, entropy, (unsigned long)sizeof(entropy));

}

return entropy;

}

static unsigned long

generate_hash_secret_salt(XML_Parser parser) {

unsigned long entropy;

(void)parser;

/* "Failproof" high quality providers: */

#if defined(HAVE_ARC4RANDOM_BUF)

arc4random_buf(&entropy, sizeof(entropy));

return ENTROPY_DEBUG("arc4random_buf", entropy);

#elif defined(HAVE_ARC4RANDOM)

writeRandomBytes_arc4random((void *)&entropy, sizeof(entropy));

return ENTROPY_DEBUG("arc4random", entropy);

/* Try high quality providers first .. */

# ifdef _WIN32

if (writeRandomBytes_rand_s((void *)&entropy, sizeof(entropy))) {

return ENTROPY_DEBUG("rand_s", entropy);

}

# elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)

if (writeRandomBytes_getrandom_nonblock((void *)&entropy, sizeof(entropy))) {

return ENTROPY_DEBUG("getrandom", entropy);

}

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

if (writeRandomBytes_dev_urandom((void *)&entropy, sizeof(entropy))) {

return ENTROPY_DEBUG("/dev/urandom", entropy);

}

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

/* .. and self-made low quality for backup: */

/* Process ID is 0 bits entropy if attacker has local access */

entropy = gather_time_entropy() ^ getpid();

/* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */

if (sizeof(unsigned long) == 4) {

return ENTROPY_DEBUG("fallback(4)", entropy * 2147483647);

} else {

return ENTROPY_DEBUG("fallback(8)",

entropy * (unsigned long)2305843009213693951ULL);

}

}

static unsigned long

get_hash_secret_salt(XML_Parser parser) {

if (parser->m_parentParser != NULL)

return get_hash_secret_salt(parser->m_parentParser);

return parser->m_hash_secret_salt;

}

static XML_Bool /* only valid for root parser */

startParsing(XML_Parser parser) {

/* hash functions must be initialized before setContext() is called */

if (parser->m_hash_secret_salt == 0)

parser->m_hash_secret_salt = generate_hash_secret_salt(parser);

if (parser->m_ns) {

/* implicit context only set for root parser, since child

return setContext(parser, implicitContext);

}

return XML_TRUE;

}

XML_Parser XMLCALL

XML_ParserCreate_MM(const XML_Char *encodingName,

const XML_Memory_Handling_Suite *memsuite,

const XML_Char *nameSep) {

return parserCreate(encodingName, memsuite, nameSep, NULL);

}

static XML_Parser

parserCreate(const XML_Char *encodingName,

const XML_Memory_Handling_Suite *memsuite, const XML_Char *nameSep,

DTD *dtd) {

XML_Parser parser;

if (memsuite) {

XML_Memory_Handling_Suite *mtemp;

parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));

if (parser != NULL) {

mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);

mtemp->malloc_fcn = memsuite->malloc_fcn;

mtemp->realloc_fcn = memsuite->realloc_fcn;

mtemp->free_fcn = memsuite->free_fcn;

}

} else {

XML_Memory_Handling_Suite *mtemp;

parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));

if (parser != NULL) {

mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);

mtemp->malloc_fcn = malloc;

mtemp->realloc_fcn = realloc;

mtemp->free_fcn = free;

}

}

if (! parser)

return parser;

parser->m_buffer = NULL;

parser->m_bufferLim = NULL;