/*
 * testOOM.c: Test out-of-memory handling
 *
 * See Copyright for the status of this software.
 *
 * hp@redhat.com
 */

#include "libxml.h"

#include <string.h>
#include <stdarg.h>

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include <libxml/xmlreader.h>

#include "testOOMlib.h"

#ifndef TRUE
#define TRUE (1)
#endif
#ifndef FALSE
#define FALSE (0)
#endif

#define EXIT_OOM 2

int error = FALSE;
int errcount = 0;
int noent = 0;
int count = 0;
int valid = 0;
int showErrs = 0;

/*
 * Since we are using the xmlTextReader functions, we set up
 * strings for the element types to help in debugging any error
 * output
 */
const char *elementNames[] = {
    "XML_READER_TYPE_NONE",
    "XML_READER_TYPE_ELEMENT",
    "XML_READER_TYPE_ATTRIBUTE",
    "XML_READER_TYPE_TEXT",
    "XML_READER_TYPE_CDATA",
    "XML_READER_TYPE_ENTITY_REFERENCE",
    "XML_READER_TYPE_ENTITY",
    "XML_READER_TYPE_PROCESSING_INSTRUCTION",
    "XML_READER_TYPE_COMMENT",
    "XML_READER_TYPE_DOCUMENT",
    "XML_READER_TYPE_DOCUMENT_TYPE",
    "XML_READER_TYPE_DOCUMENT_FRAGMENT",
    "XML_READER_TYPE_NOTATION",
    "XML_READER_TYPE_WHITESPACE",
    "XML_READER_TYPE_SIGNIFICANT_WHITESPACE",
    "XML_READER_TYPE_END_ELEMENT",
    "XML_READER_TYPE_END_ENTITY",
    "XML_READER_TYPE_XML_DECLARATION"};

/* not using xmlBuff here because I don't want those
 * mallocs to interfere */
struct buffer {
    char *str;
    size_t len;
    size_t max;
};

static struct buffer *buffer_create (size_t init_len)
{
    struct buffer *b;
    b = malloc (sizeof *b);
    if (b == NULL)
	exit (EXIT_OOM);
    if (init_len) {
	b->str = malloc (init_len);
	if (b->str == NULL)
	    exit (EXIT_OOM);
    }
    else
	b->str = NULL;
    b->len = 0;
    b->max = init_len;
    return b;
}

static void buffer_free (struct buffer *b)
{
    free (b->str);
    free (b);
}

static size_t buffer_get_length (struct buffer *b)
{
    return b->len;
}

static void buffer_expand (struct buffer *b, size_t min)
{
    void *new_str;
    size_t new_size = b->max ? b->max : 512;
    while (new_size < b->len + min)
	new_size *= 2;
    if (new_size > b->max) {
	new_str = realloc (b->str, new_size);
	if (new_str == NULL)
	    exit (EXIT_OOM);
	b->str = new_str;
	b->max = new_size;
    }
}

static void buffer_add_char (struct buffer *b, char c)
{
    buffer_expand (b, 1);
    b->str[b->len] = c;
    b->len += 1;
}

static void buffer_add_string (struct buffer *b, const char *s)
{
    size_t size = strlen(s) + 1;
    unsigned int ix;
    for (ix=0; ix<size-1; ix++) {
        if (s[ix] < 0x20)
	    printf ("binary data [0x%02x]?\n", (unsigned char)s[ix]);
    }
    buffer_expand (b, size);
    strcpy (b->str + b->len, s);
    b->str[b->len+size-1] = '\n';	/* replace string term with newline */
    b->len += size;
}

static int buffer_equal (struct buffer *b1, struct buffer *b2)
{
    return (b1->len == b2->len &&
	    (b1->len == 0 || (memcmp (b1->str, b2->str, b1->len) == 0)));
}

static void buffer_dump (struct buffer *b, const char *fname)
{
    FILE *f = fopen (fname, "wb");
    if (f != NULL) {
	fwrite (b->str, 1, b->len, f);
	fclose (f);
    }
}


static void usage(const char *progname) {
    printf("Usage : %s [options] XMLfiles ...\n", progname);
    printf("\tParse the XML files using the xmlTextReader API\n");
    printf("\t --count: count the number of attribute and elements\n");
    printf("\t --valid: validate the document\n");
    printf("\t --show:  display the error messages encountered\n");
    exit(1);
}
static unsigned int elem, attrs, chars;

static int processNode (xmlTextReaderPtr reader, void *data)
{
    struct buffer *buff = data;
    int type;

    type = xmlTextReaderNodeType(reader);
    if (count) {
	if (type == 1) {
	    elem++;
	    attrs += xmlTextReaderAttributeCount(reader);
	} else if (type == 3) {
	  const xmlChar *txt;
	  txt = xmlTextReaderConstValue(reader);
	  if (txt != NULL)
	    chars += xmlStrlen (txt);
	  else
	    return FALSE;
	}
    }

    if (buff != NULL) {
	int ret;
	const char *s;

	buffer_add_string (buff, elementNames[type]);

	if (type == 1) {
	    s = (const char *)xmlTextReaderConstName (reader);
	    if (s == NULL) return FALSE;
	    buffer_add_string (buff, s);
	    while ((ret = xmlTextReaderMoveToNextAttribute (reader)) == 1) {
		s = (const char *)xmlTextReaderConstName (reader);
		if (s == NULL) return FALSE;
		buffer_add_string (buff, s);
		buffer_add_char (buff, '=');
		s = (const char *)xmlTextReaderConstValue (reader);
		if (s == NULL) return FALSE;
		buffer_add_string (buff, s);
	    }
	    if (ret == -1) return FALSE;
	}
	else if (type == 3) {
	    s = (const char *)xmlTextReaderConstValue (reader);
	    if (s == NULL) return FALSE;
	    buffer_add_string (buff, s);
	}
    }

    return TRUE;
}


struct file_params {
    const char *filename;
    struct buffer *verif_buff;
};

static void
error_func (void *data ATTRIBUTE_UNUSED, xmlErrorPtr err)
{

    errcount++;
    if (err->level == XML_ERR_ERROR ||
        err->level == XML_ERR_FATAL)
        error = TRUE;
    if (showErrs) {
        printf("%3d line %d: %s\n", error, err->line, err->message);
    }
}

static int
check_load_file_memory_func (void *data)
{
     struct file_params *p = data;
     struct buffer *b;
     xmlTextReaderPtr reader;
     int ret, status, first_run;

     if (count) {
         elem = 0;
         attrs = 0;
         chars = 0;
     }

     first_run = p->verif_buff == NULL;
     status = TRUE;
     error = FALSE;
     if (first_run)
	 b = buffer_create (0);
     else
	 b = buffer_create (buffer_get_length (p->verif_buff));

     reader = xmlNewTextReaderFilename (p->filename);
     if (reader == NULL)
       goto out;

     xmlTextReaderSetStructuredErrorHandler (reader, error_func, NULL);
     xmlSetStructuredErrorFunc(NULL, error_func);

     if (valid) {
       if (xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE, 1) == -1)
	 goto out;
     }

     /*
      * Process all nodes in sequence
      */
     while ((ret = xmlTextReaderRead(reader)) == 1) {
	 if (!processNode(reader, b))
	 goto out;
     }
     if (ret == -1)
       goto out;

     if (error) {
	 fprintf (stdout, "error handler was called but parse completed successfully (last error #%d)\n", errcount);
	 return FALSE;
     }

     /*
      * Done, cleanup and status
      */
     if (! first_run) {
	 status = buffer_equal (p->verif_buff, b);
	 if (! status) {
	     buffer_dump (p->verif_buff, ".OOM.verif_buff");
	     buffer_dump (b, ".OOM.buff");
	 }
     }

     if (count)
       {
	   fprintf (stdout, "# %s: %u elems, %u attrs, %u chars %s\n",
		    p->filename, elem, attrs, chars,
		    status ? "ok" : "wrong");
       }

 out:
     if (first_run)
	 p->verif_buff = b;
     else
	 buffer_free (b);
     if (reader)
	 xmlFreeTextReader (reader);
     return status;
}

int main(int argc, char **argv) {
    int i;
    int files = 0;

    if (argc <= 1) {
	usage(argv[0]);
	return(1);
    }
    LIBXML_TEST_VERSION;

    xmlMemSetup (test_free,
                 test_malloc,
                 test_realloc,
                 test_strdup);

    xmlInitParser();

    for (i = 1; i < argc ; i++) {
        if ((!strcmp(argv[i], "-count")) || (!strcmp(argv[i], "--count")))
	    count++;
	else if ((!strcmp(argv[i], "-valid")) || (!strcmp(argv[i], "--valid")))
	    valid++;
	else if ((!strcmp(argv[i], "-noent")) ||
	         (!strcmp(argv[i], "--noent")))
	    noent++;
	else if ((!strcmp(argv[i], "-show")) ||
		 (!strcmp(argv[i], "--show")))
	    showErrs++;
    }
    if (noent != 0)
      xmlSubstituteEntitiesDefault(1);
    for (i = 1; i < argc ; i++) {
	if (argv[i][0] != '-') {
             struct file_params p;
	     p.filename = argv[i];
	     p.verif_buff = NULL;

             if (!test_oom_handling (check_load_file_memory_func,
                                     &p)) {
                  fprintf (stdout, "Failed!\n");
                  return 1;
             }

	     buffer_free (p.verif_buff);
             xmlCleanupParser();

             if (test_get_malloc_blocks_outstanding () > 0) {
                  fprintf (stdout, "%d blocks leaked\n",
                           test_get_malloc_blocks_outstanding ());
		  xmlMemoryDump();
                  return 1;
             }

	    files ++;
	}
    }
    xmlMemoryDump();

    return 0;
}