/*

 * testlimits.c: C program to run libxml2 regression tests checking various

 *       limits in document size. Will consume a lot of RAM and CPU cycles

 *

 * To compile on Unixes:

 * cc -o testlimits `xml2-config --cflags` testlimits.c `xml2-config --libs` -lpthread

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 */

#include "libxml.h"

#include <stdio.h>

#if !defined(_WIN32) || defined(__CYGWIN__)

#include <unistd.h>

#endif

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <time.h>

#include <libxml/parser.h>

#include <libxml/parserInternals.h>

#include <libxml/tree.h>

#include <libxml/uri.h>

#ifdef LIBXML_READER_ENABLED

#include <libxml/xmlreader.h>

#endif

static int verbose = 0;

static int tests_quiet = 0;

/************************************************************************

 *									*

 *		time handling                                           *

 *									*

 ************************************************************************/

/* maximum time for one parsing before declaring a timeout */

#define MAX_TIME 2 /* seconds */

static clock_t t0;

int timeout = 0;

static void reset_timout(void) {

    timeout = 0;

    t0 = clock();

}

static int check_time(void) {

    clock_t tnow = clock();

    if (((tnow - t0) / CLOCKS_PER_SEC) > MAX_TIME) {

        timeout = 1;

        return(0);

    }

    return(1);

}

/************************************************************************

 *									*

 *		Huge document generator					*

 *									*

 ************************************************************************/

#include <libxml/xmlIO.h>

/*

 * Huge documents are built using fixed start and end chunks

 * and filling between the two an unconventional amount of char data

 */

typedef struct hugeTest hugeTest;

typedef hugeTest *hugeTestPtr;

struct hugeTest {

    const char *description;

    const char *name;

    const char *start;

    const char *end;

};

static struct hugeTest hugeTests[] = {

    { "Huge text node", "huge:textNode", "<foo>", "</foo>" },

    { "Huge attribute node", "huge:attrNode", "<foo bar='", "'/>" },

    { "Huge comment node", "huge:commentNode", "<foo></foo>" },

    { "Huge PI node", "huge:piNode", "<foo></foo>" },

};

static const char *current;

static int rlen;

static unsigned int currentTest = 0;

static int instate = 0;

/**

 * hugeMatch:

 * @URI: an URI to test

 *

 * Check for an huge: query

 *

 * Returns 1 if yes and 0 if another Input module should be used

 */

static int

hugeMatch(const char * URI) {

    if ((URI != NULL) && (!strncmp(URI, "huge:", 5)))

        return(1);

    return(0);

}

/**

 * hugeOpen:

 * @URI: an URI to test

 *

 * Return a pointer to the huge: query handler, in this example simply

 * the current pointer...

 *

 * Returns an Input context or NULL in case or error

 */

static void *

hugeOpen(const char * URI) {

    if ((URI == NULL) || (strncmp(URI, "huge:", 5)))

        return(NULL);

    for (currentTest = 0;currentTest < sizeof(hugeTests)/sizeof(hugeTests[0]);

         currentTest++)

         if (!strcmp(hugeTests[currentTest].name, URI))

             goto found;

    return(NULL);

found:

    rlen = strlen(hugeTests[currentTest].start);

    current = hugeTests[currentTest].start;

    instate = 0;

    return((void *) current);

}

/**

 * hugeClose:

 * @context: the read context

 *

 * Close the huge: query handler

 *

 * Returns 0 or -1 in case of error

 */

static int

hugeClose(void * context) {

    if (context == NULL) return(-1);

    fprintf(stderr, "\n");

    return(0);

}

#define CHUNK 4096

char filling[CHUNK + 1];

static void fillFilling(void) {

    int i;

    for (i = 0;i < CHUNK;i++) {

        filling[i] = 'a';

    }

    filling[CHUNK] = 0;

}

size_t maxlen = 64 * 1024 * 1024;

size_t curlen = 0;

size_t dotlen;

/**

 * hugeRead:

 * @context: the read context

 * @buffer: where to store data

 * @len: number of bytes to read

 *

 * Implement an huge: query read.

 *

 * Returns the number of bytes read or -1 in case of error

 */

static int

hugeRead(void *context, char *buffer, int len)

{

    if ((context == NULL) || (buffer == NULL) || (len < 0))

        return (-1);

    if (instate == 0) {

        if (len >= rlen) {

            len = rlen;

            rlen = 0;

            memcpy(buffer, current, len);

            instate = 1;

            curlen = 0;

            dotlen = maxlen / 10;

        } else {

            memcpy(buffer, current, len);

            rlen -= len;

            current += len;

        }

    } else if (instate == 2) {

        if (len >= rlen) {

            len = rlen;

            rlen = 0;

            memcpy(buffer, current, len);

            instate = 3;

            curlen = 0;

        } else {

            memcpy(buffer, current, len);

            rlen -= len;

            current += len;

        }

    } else if (instate == 1) {

        if (len > CHUNK) len = CHUNK;

        memcpy(buffer, &filling[0], len);

        curlen += len;

        if (curlen >= maxlen) {

            rlen = strlen(hugeTests[currentTest].end);

            current = hugeTests[currentTest].end;

            instate = 2;

	} else {

            if (curlen > dotlen) {

                fprintf(stderr, ".");

                dotlen += maxlen / 10;

            }

        }

    } else

      len = 0;

    return (len);

}

/************************************************************************

 *									*

 *		Crazy document generator				*

 *									*

 ************************************************************************/

unsigned int crazy_indx = 0;

const char *crazy = "\

\

\

\

\

\

\

]>\

\

\

<foo bar='foo'>\

\

\

foo\

\

</foo>\

\

";

/**

 * crazyMatch:

 * @URI: an URI to test

 *

 * Check for a crazy: query

 *

 * Returns 1 if yes and 0 if another Input module should be used

 */

static int

crazyMatch(const char * URI) {

    if ((URI != NULL) && (!strncmp(URI, "crazy:", 6)))

        return(1);

    return(0);

}

/**

 * crazyOpen:

 * @URI: an URI to test

 *

 * Return a pointer to the crazy: query handler, in this example simply

 * the current pointer...

 *

 * Returns an Input context or NULL in case or error

 */

static void *

crazyOpen(const char * URI) {

    if ((URI == NULL) || (strncmp(URI, "crazy:", 6)))

        return(NULL);

    if (crazy_indx > strlen(crazy))

        return(NULL);

    reset_timout();

    rlen = crazy_indx;

    current = &crazy[0];

    instate = 0;

    return((void *) current);

}

/**

 * crazyClose:

 * @context: the read context

 *

 * Close the crazy: query handler

 *

 * Returns 0 or -1 in case of error

 */

static int

crazyClose(void * context) {

    if (context == NULL) return(-1);

    return(0);

}

/**

 * crazyRead:

 * @context: the read context

 * @buffer: where to store data

 * @len: number of bytes to read

 *

 * Implement an crazy: query read.

 *

 * Returns the number of bytes read or -1 in case of error

 */

static int

crazyRead(void *context, char *buffer, int len)

{

    if ((context == NULL) || (buffer == NULL) || (len < 0))

        return (-1);

    if ((check_time() <= 0) && (instate == 1)) {

        fprintf(stderr, "\ntimeout in crazy(%d)\n", crazy_indx);

        rlen = strlen(crazy) - crazy_indx;

        current = &crazy[crazy_indx];

        instate = 2;

    }

    if (instate == 0) {

        if (len >= rlen) {

            len = rlen;

            rlen = 0;

            memcpy(buffer, current, len);

            instate = 1;

            curlen = 0;

        } else {

            memcpy(buffer, current, len);

            rlen -= len;

            current += len;

        }

    } else if (instate == 2) {

        if (len >= rlen) {

            len = rlen;

            rlen = 0;

            memcpy(buffer, current, len);

            instate = 3;

            curlen = 0;

        } else {

            memcpy(buffer, current, len);

            rlen -= len;

            current += len;

        }

    } else if (instate == 1) {

        if (len > CHUNK) len = CHUNK;

        memcpy(buffer, &filling[0], len);

        curlen += len;

        if (curlen >= maxlen) {

            rlen = strlen(crazy) - crazy_indx;

            current = &crazy[crazy_indx];

            instate = 2;

        }

    } else

      len = 0;

    return (len);

}

/************************************************************************

 *									*

 *		Libxml2 specific routines				*

 *									*

 ************************************************************************/

static int nb_tests = 0;

static int nb_errors = 0;

static int nb_leaks = 0;

static int extraMemoryFromResolver = 0;

/*

 * We need to trap calls to the resolver to not account memory for the catalog

 * which is shared to the current running test. We also don't want to have

 * network downloads modifying tests.

 */

static xmlParserInputPtr

testExternalEntityLoader(const char *URL, const char *ID,

			 xmlParserCtxtPtr ctxt) {

    xmlParserInputPtr ret;

    int memused = xmlMemUsed();

    ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);

    extraMemoryFromResolver += xmlMemUsed() - memused;

    return(ret);

}

/*

 * Trapping the error messages at the generic level to grab the equivalent of

 * stderr messages on CLI tools.

 */

static char testErrors[32769];

static int testErrorsSize = 0;

static void XMLCDECL

channel(void *ctx  ATTRIBUTE_UNUSED, const char *msg, ...) {

    va_list args;

    int res;

    if (testErrorsSize >= 32768)

        return;

    va_start(args, msg);

    res = vsnprintf(&testErrors[testErrorsSize],

                    32768 - testErrorsSize,

		    msg, args);

    va_end(args);

    if (testErrorsSize + res >= 32768) {

        /* buffer is full */

	testErrorsSize = 32768;

	testErrors[testErrorsSize] = 0;

    } else {

        testErrorsSize += res;

    }

    testErrors[testErrorsSize] = 0;

}

/**

 * xmlParserPrintFileContext:

 * @input:  an xmlParserInputPtr input

 *

 * Displays current context within the input content for error tracking

 */

static void

xmlParserPrintFileContextInternal(xmlParserInputPtr input ,

		xmlGenericErrorFunc chanl, void *data ) {

    const xmlChar *cur, *base;

    unsigned int n, col;	/* GCC warns if signed, because compared with sizeof() */

    xmlChar  content[81]; /* space for 80 chars + line terminator */

    xmlChar *ctnt;

    if (input == NULL) return;

    cur = input->cur;

    base = input->base;

    /* skip backwards over any end-of-lines */

    while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {

	cur--;

    }

    n = 0;

    /* search backwards for beginning-of-line (to max buff size) */

    while ((n++ < (sizeof(content)-1)) && (cur > base) &&

   (*(cur) != '\n') && (*(cur) != '\r'))

        cur--;

    if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;

    /* calculate the error position in terms of the current position */

    col = input->cur - cur;

    /* search forward for end-of-line (to max buff size) */

    n = 0;

    ctnt = content;

    /* copy selected text to our buffer */

    while ((*cur != 0) && (*(cur) != '\n') &&

   (*(cur) != '\r') && (n < sizeof(content)-1)) {

		*ctnt++ = *cur++;

	n++;

    }

    *ctnt = 0;

    /* print out the selected text */

    chanl(data ,"%s\n", content);

    /* create blank line with problem pointer */

    n = 0;

    ctnt = content;

    /* (leave buffer space for pointer + line terminator) */

    while ((n

	if (*(ctnt) != '\t')

	    *(ctnt) = ' ';

	ctnt++;

    }

    *ctnt++ = '^';

    *ctnt = 0;

    chanl(data ,"%s\n", content);

}

static void

testStructuredErrorHandler(void *ctx  ATTRIBUTE_UNUSED, xmlErrorPtr err) {

    char *file = NULL;

    int line = 0;

    int code = -1;

    int domain;

    void *data = NULL;

    const char *str;

    const xmlChar *name = NULL;

    xmlNodePtr node;

    xmlErrorLevel level;

    xmlParserInputPtr input = NULL;

    xmlParserInputPtr cur = NULL;

    xmlParserCtxtPtr ctxt = NULL;

    if (err == NULL)

        return;

    file = err->file;

    line = err->line;

    code = err->code;

    domain = err->domain;

    level = err->level;

    node = err->node;

    if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||

        (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||

	(domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {

	ctxt = err->ctxt;

    }

    str = err->message;

    if (code == XML_ERR_OK)

        return;

    if ((node != NULL) && (node->type == XML_ELEMENT_NODE))

        name = node->name;

    /*

     * Maintain the compatibility with the legacy error handling

     */

    if (ctxt != NULL) {

        input = ctxt->input;

        if ((input != NULL) && (input->filename == NULL) &&

            (ctxt->inputNr > 1)) {

            cur = input;

            input = ctxt->inputTab[ctxt->inputNr - 2];

        }

        if (input != NULL) {

            if (input->filename)

                channel(data, "%s:%d: ", input->filename, input->line);

            else if ((line != 0) && (domain == XML_FROM_PARSER))

                channel(data, "Entity: line %d: ", input->line);

        }

    } else {

        if (file != NULL)

            channel(data, "%s:%d: ", file, line);

        else if ((line != 0) && (domain == XML_FROM_PARSER))

            channel(data, "Entity: line %d: ", line);

    }

    if (name != NULL) {

        channel(data, "element %s: ", name);

    }

    if (code == XML_ERR_OK)

        return;

    switch (domain) {

        case XML_FROM_PARSER:

            channel(data, "parser ");

            break;

        case XML_FROM_NAMESPACE:

            channel(data, "namespace ");

            break;

        case XML_FROM_DTD:

        case XML_FROM_VALID:

            channel(data, "validity ");

            break;

        case XML_FROM_HTML:

            channel(data, "HTML parser ");

            break;

        case XML_FROM_MEMORY:

            channel(data, "memory ");

            break;

        case XML_FROM_OUTPUT:

            channel(data, "output ");

            break;

        case XML_FROM_IO:

            channel(data, "I/O ");

            break;

        case XML_FROM_XINCLUDE:

            channel(data, "XInclude ");

            break;

        case XML_FROM_XPATH:

            channel(data, "XPath ");

            break;

        case XML_FROM_XPOINTER:

            channel(data, "parser ");

            break;

        case XML_FROM_REGEXP:

            channel(data, "regexp ");

            break;

        case XML_FROM_MODULE:

            channel(data, "module ");

            break;

        case XML_FROM_SCHEMASV:

            channel(data, "Schemas validity ");

            break;

        case XML_FROM_SCHEMASP:

            channel(data, "Schemas parser ");

            break;

        case XML_FROM_RELAXNGP:

            channel(data, "Relax-NG parser ");

            break;

        case XML_FROM_RELAXNGV:

            channel(data, "Relax-NG validity ");

            break;

        case XML_FROM_CATALOG:

            channel(data, "Catalog ");

            break;

        case XML_FROM_C14N:

            channel(data, "C14N ");

            break;

        case XML_FROM_XSLT:

            channel(data, "XSLT ");

            break;

        default:

            break;

    }

    if (code == XML_ERR_OK)

        return;

    switch (level) {

        case XML_ERR_NONE:

            channel(data, ": ");

            break;

        case XML_ERR_WARNING:

            channel(data, "warning : ");

            break;

        case XML_ERR_ERROR:

            channel(data, "error : ");

            break;

        case XML_ERR_FATAL:

            channel(data, "error : ");

            break;

    }

    if (code == XML_ERR_OK)

        return;

    if (str != NULL) {

        int len;

	len = xmlStrlen((const xmlChar *)str);

	if ((len > 0) && (str[len - 1] != '\n'))

	    channel(data, "%s\n", str);

	else

	    channel(data, "%s", str);

    } else {

        channel(data, "%s\n", "out of memory error");

    }

    if (code == XML_ERR_OK)

        return;

    if (ctxt != NULL) {

        xmlParserPrintFileContextInternal(input, channel, data);

        if (cur != NULL) {

            if (cur->filename)

                channel(data, "%s:%d: \n", cur->filename, cur->line);

            else if ((line != 0) && (domain == XML_FROM_PARSER))

                channel(data, "Entity: line %d: \n", cur->line);

            xmlParserPrintFileContextInternal(cur, channel, data);

        }

    }

    if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&

        (err->int1 < 100) &&

	(err->int1 < xmlStrlen((const xmlChar *)err->str1))) {

	xmlChar buf[150];

	int i;

	channel(data, "%s\n", err->str1);

	for (i=0;i < err->int1;i++)

	     buf[i] = ' ';

	buf[i++] = '^';

	buf[i] = 0;

	channel(data, "%s\n", buf);

    }

}

static void

initializeLibxml2(void) {

    xmlGetWarningsDefaultValue = 0;

    xmlPedanticParserDefault(0);

    xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);

    xmlInitParser();

    xmlSetExternalEntityLoader(testExternalEntityLoader);

    xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);

    /*

     * register the new I/O handlers

     */

    if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen,

                                  hugeRead, hugeClose) < 0) {

        fprintf(stderr, "failed to register Huge handlers\n");

	exit(1);

    }

    if (xmlRegisterInputCallbacks(crazyMatch, crazyOpen,

                                  crazyRead, crazyClose) < 0) {

        fprintf(stderr, "failed to register Crazy handlers\n");

	exit(1);

    }

}

/************************************************************************

 *									*

 *		SAX empty callbacks                                     *

 *									*

 ************************************************************************/

unsigned long callbacks = 0;

/**

 * isStandaloneCallback:

 * @ctxt:  An XML parser context

 *

 * Is this document tagged standalone ?

 *

 * Returns 1 if true

 */

static int

isStandaloneCallback(void *ctx ATTRIBUTE_UNUSED)

{

    callbacks++;

    return (0);

}

/**

 * hasInternalSubsetCallback:

 * @ctxt:  An XML parser context

 *

 * Does this document has an internal subset

 *

 * Returns 1 if true

 */

static int

hasInternalSubsetCallback(void *ctx ATTRIBUTE_UNUSED)

{

    callbacks++;

    return (0);

}

/**

 * hasExternalSubsetCallback:

 * @ctxt:  An XML parser context

 *

 * Does this document has an external subset

 *

 * Returns 1 if true

 */

static int

hasExternalSubsetCallback(void *ctx ATTRIBUTE_UNUSED)

{

    callbacks++;

    return (0);

}

/**

 * internalSubsetCallback:

 * @ctxt:  An XML parser context

 *

 * Does this document has an internal subset

 */

static void

internalSubsetCallback(void *ctx ATTRIBUTE_UNUSED,

                       const xmlChar * name ATTRIBUTE_UNUSED,

                       const xmlChar * ExternalID ATTRIBUTE_UNUSED,

                       const xmlChar * SystemID ATTRIBUTE_UNUSED)

{

    callbacks++;

    return;

}

/**

 * externalSubsetCallback:

 * @ctxt:  An XML parser context

 *

 * Does this document has an external subset

 */

static void

externalSubsetCallback(void *ctx ATTRIBUTE_UNUSED,

                       const xmlChar * name ATTRIBUTE_UNUSED,

                       const xmlChar * ExternalID ATTRIBUTE_UNUSED,

                       const xmlChar * SystemID ATTRIBUTE_UNUSED)

{

    callbacks++;

    return;

}

/**

 * resolveEntityCallback:

 * @ctxt:  An XML parser context

 * @publicId: The public ID of the entity

 * @systemId: The system ID of the entity

 *

 * Special entity resolver, better left to the parser, it has

 * more context than the application layer.

 * The default behaviour is to NOT resolve the entities, in that case

 * the ENTITY_REF nodes are built in the structure (and the parameter

 * values).

 *

 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.

 */

static xmlParserInputPtr

resolveEntityCallback(void *ctx ATTRIBUTE_UNUSED,

                      const xmlChar * publicId ATTRIBUTE_UNUSED,

                      const xmlChar * systemId ATTRIBUTE_UNUSED)

{

    callbacks++;

    return (NULL);

}

/**

 * getEntityCallback:

 * @ctxt:  An XML parser context

 * @name: The entity name

 *

 * Get an entity by name

 *

 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.

 */

static xmlEntityPtr

getEntityCallback(void *ctx ATTRIBUTE_UNUSED,

                  const xmlChar * name ATTRIBUTE_UNUSED)

{

    callbacks++;

    return (NULL);

}

/**

 * getParameterEntityCallback:

 * @ctxt:  An XML parser context

 * @name: The entity name

 *

 * Get a parameter entity by name

 *

 * Returns the xmlParserInputPtr

 */

static xmlEntityPtr

getParameterEntityCallback(void *ctx ATTRIBUTE_UNUSED,

                           const xmlChar * name ATTRIBUTE_UNUSED)

{

    callbacks++;

    return (NULL);

}

/**

 * entityDeclCallback:

 * @ctxt:  An XML parser context

 * @name:  the entity name

 * @type:  the entity type

 * @publicId: The public ID of the entity

 * @systemId: The system ID of the entity

 * @content: the entity value (without processing).

 *

 * An entity definition has been parsed

 */

static void

entityDeclCallback(void *ctx ATTRIBUTE_UNUSED,

                   const xmlChar * name ATTRIBUTE_UNUSED,

                   int type ATTRIBUTE_UNUSED,

                   const xmlChar * publicId ATTRIBUTE_UNUSED,

                   const xmlChar * systemId ATTRIBUTE_UNUSED,

                   xmlChar * content ATTRIBUTE_UNUSED)

{

    callbacks++;

    return;

}

/**

 * attributeDeclCallback:

 * @ctxt:  An XML parser context

 * @name:  the attribute name

 * @type:  the attribute type

 *

 * An attribute definition has been parsed

 */

static void

attributeDeclCallback(void *ctx ATTRIBUTE_UNUSED,

                      const xmlChar * elem ATTRIBUTE_UNUSED,

                      const xmlChar * name ATTRIBUTE_UNUSED,

                      int type ATTRIBUTE_UNUSED, int def ATTRIBUTE_UNUSED,

                      const xmlChar * defaultValue ATTRIBUTE_UNUSED,

                      xmlEnumerationPtr tree ATTRIBUTE_UNUSED)

{

    callbacks++;

    return;

}

/**

 * elementDeclCallback:

 * @ctxt:  An XML parser context

 * @name:  the element name

 * @type:  the element type

 * @content: the element value (without processing).