/**

 * Test the UTF-8 decoding routines

 *

 * author: Daniel Veillard

 * copy: see Copyright for the status of this software.

 */

#include <stdio.h>

#include <string.h>

#include <libxml/parser.h>

#include <libxml/parserInternals.h>

#include "buf.h"

int lastError;

static void errorHandler(void *unused, xmlErrorPtr err) {

    if ((unused == NULL) && (err != NULL) && (lastError == 0)) {

        lastError = err->code;

    }

}

char document1[100] = "<doc>XXXX</doc>";

char document2[100] = "<doc foo='XXXX'/>";

static void testDocumentRangeByte1(xmlParserCtxtPtr ctxt, char *document,

                  int len,  char *data, int forbid1, int forbid2) {

    int i;

    xmlDocPtr res;

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

	lastError = 0;

	xmlCtxtReset(ctxt);

        data[0] = i;

	res = xmlReadMemory(document, len, "test", NULL, 0);

	if ((i == forbid1) || (i == forbid2)) {

	    if ((lastError == 0) || (res != NULL))

	        fprintf(stderr,

		    "Failed to detect invalid char for Byte 0x%02X: %c\n",

		        i, i);

	}

	else if ((i == '<') || (i == '&')) {

	    if ((lastError == 0) || (res != NULL))

	        fprintf(stderr,

		    "Failed to detect illegal char %c for Byte 0x%02X\n", i, i);

	}

	else if (((i < 0x20) || (i >= 0x80)) &&

	    (i != 0x9) && (i != 0xA) && (i != 0xD)) {

	    if ((lastError != XML_ERR_INVALID_CHAR) && (res != NULL))

	        fprintf(stderr,

		    "Failed to detect invalid char for Byte 0x%02X\n", i);

	}

	else if (res == NULL) {

	    fprintf(stderr,

		"Failed to parse valid char for Byte 0x%02X : %c\n", i, i);

	}

	if (res != NULL)

	    xmlFreeDoc(res);

    }

}

static void testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,

                  int len,  char *data) {

    int i, j;

    xmlDocPtr res;

    for (i = 0x80;i <= 0xFF;i++) {

    for (j = 0;j <= 0xFF;j++) {

	lastError = 0;

	xmlCtxtReset(ctxt);

        data[0] = i;

        data[1] = j;

	res = xmlReadMemory(document, len, "test", NULL, 0);

	/* if first bit of first char is set, then second bit must too */

	if ((i & 0x80) && ((i & 0x40) == 0)) {

	    if ((lastError == 0) || (res != NULL))

		fprintf(stderr,

		"Failed to detect invalid char for Bytes 0x%02X 0x%02X\n",

			i, j);

	}

	/*

	 * if first bit of first char is set, then second char first

	 * bits must be 10

	 */

	else if ((i & 0x80) && ((j & 0xC0) != 0x80)) {

	    if ((lastError == 0) || (res != NULL))

		fprintf(stderr,

	    "Failed to detect invalid char for Bytes 0x%02X 0x%02X\n",

			i, j);

	}

	/*

	 * if using a 2 byte encoding then the value must be greater

	 * than 0x80, i.e. one of bits 5 to 1 of i must be set

	 */

	else if ((i & 0x80) && ((i & 0x1E) == 0)) {

	    if ((lastError == 0) || (res != NULL))

		fprintf(stderr,

	    "Failed to detect invalid char for Bytes 0x%02X 0x%02X\n",

			i, j);

	}

	/*

	 * if third bit of first char is set, then the sequence would need

	 * at least 3 bytes, but we give only 2 !

	 */

	else if ((i & 0xE0) == 0xE0) {

	    if ((lastError == 0) || (res != NULL))

		fprintf(stderr,

	    "Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x00\n",

			i, j);

	}

	/*

	 * We should see no error in remaning cases

	 */

	else if ((lastError != 0) || (res == NULL)) {

	    fprintf(stderr,

		"Failed to parse document for Bytes 0x%02X 0x%02X\n", i, j);

	}

	if (res != NULL)

	    xmlFreeDoc(res);

    }

    }

}

/**

 * testDocumentRanges:

 *

 * Test the correct UTF8 character parsing in context of XML documents

 * Those are in-context injection tests checking the parser behaviour on

 * edge case values at different point in content, beginning and end of

 * CDATA in text or in attribute values.

 */

static void testDocumentRanges(void) {

    xmlParserCtxtPtr ctxt;

    char *data;

    /*

     * Set up a parsing context using the first document as

     * the current input source.

     */

    ctxt = xmlNewParserCtxt();

    if (ctxt == NULL) {

        fprintf(stderr, "Failed to allocate parser context\n");

	return;

    }

    printf("testing 1 byte char in document: 1");

    fflush(stdout);

    data = &document1[5];

    data[0] = ' ';

    data[1] = ' ';

    data[2] = ' ';

    data[3] = ' ';

    /* test 1 byte injection at beginning of area */

    testDocumentRangeByte1(ctxt, &document1[0], strlen(document1),

                           data, -1, -1);

    printf(" 2");

    fflush(stdout);

    data[0] = ' ';

    data[1] = ' ';

    data[2] = ' ';

    data[3] = ' ';

    /* test 1 byte injection at end of area */

    testDocumentRangeByte1(ctxt, &document1[0], strlen(document1),

                           data + 3, -1, -1);

    printf(" 3");

    fflush(stdout);

    data = &document2[10];

    data[0] = ' ';

    data[1] = ' ';

    data[2] = ' ';

    data[3] = ' ';

    /* test 1 byte injection at beginning of area */

    testDocumentRangeByte1(ctxt, &document2[0], strlen(document2),

                           data, '\'', -1);

    printf(" 4");

    fflush(stdout);

    data[0] = ' ';

    data[1] = ' ';

    data[2] = ' ';

    data[3] = ' ';

    /* test 1 byte injection at end of area */

    testDocumentRangeByte1(ctxt, &document2[0], strlen(document2),

                           data + 3, '\'', -1);

    printf(" done\n");

    printf("testing 2 byte char in document: 1");

    fflush(stdout);

    data = &document1[5];

    data[0] = ' ';

    data[1] = ' ';

    data[2] = ' ';

    data[3] = ' ';

    /* test 2 byte injection at beginning of area */

    testDocumentRangeByte2(ctxt, &document1[0], strlen(document1),

                           data);

    printf(" 2");

    fflush(stdout);

    data[0] = ' ';

    data[1] = ' ';

    data[2] = ' ';

    data[3] = ' ';

    /* test 2 byte injection at end of area */

    testDocumentRangeByte2(ctxt, &document1[0], strlen(document1),

                           data + 2);

    printf(" 3");

    fflush(stdout);

    data = &document2[10];

    data[0] = ' ';

    data[1] = ' ';

    data[2] = ' ';

    data[3] = ' ';

    /* test 2 byte injection at beginning of area */

    testDocumentRangeByte2(ctxt, &document2[0], strlen(document2),

                           data);

    printf(" 4");

    fflush(stdout);

    data[0] = ' ';

    data[1] = ' ';

    data[2] = ' ';

    data[3] = ' ';

    /* test 2 byte injection at end of area */

    testDocumentRangeByte2(ctxt, &document2[0], strlen(document2),

                           data + 2);

    printf(" done\n");

    xmlFreeParserCtxt(ctxt);

}

static void testCharRangeByte1(xmlParserCtxtPtr ctxt, char *data) {

    int i = 0;

    int len, c;

    data[1] = 0;

    data[2] = 0;

    data[3] = 0;

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

        data[0] = i;

	ctxt->charset = XML_CHAR_ENCODING_UTF8;

	lastError = 0;

        c = xmlCurrentChar(ctxt, &len;;

	if ((i == 0) || (i >= 0x80)) {

	    /* we must see an error there */

	    if (lastError != XML_ERR_INVALID_CHAR)

	        fprintf(stderr,

		    "Failed to detect invalid char for Byte 0x%02X\n", i);

	} else if (i == 0xD) {

	    if ((c != 0xA) || (len != 1))

		fprintf(stderr, "Failed to convert char for Byte 0x%02X\n", i);

	} else if ((c != i) || (len != 1)) {

	    fprintf(stderr, "Failed to parse char for Byte 0x%02X\n", i);

	}

    }

}

static void testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {

    int i, j;

    int len, c;

    data[2] = 0;

    data[3] = 0;

    for (i = 0x80;i <= 0xFF;i++) {

	for (j = 0;j <= 0xFF;j++) {

	    data[0] = i;

	    data[1] = j;

	    ctxt->charset = XML_CHAR_ENCODING_UTF8;

	    lastError = 0;

	    c = xmlCurrentChar(ctxt, &len;;

	    /* if first bit of first char is set, then second bit must too */

	    if ((i & 0x80) && ((i & 0x40) == 0)) {

		if (lastError != XML_ERR_INVALID_CHAR)

		    fprintf(stderr,

		    "Failed to detect invalid char for Bytes 0x%02X 0x%02X\n",

		            i, j);

	    }

	    /*

	     * if first bit of first char is set, then second char first

	     * bits must be 10

	     */

	    else if ((i & 0x80) && ((j & 0xC0) != 0x80)) {

		if (lastError != XML_ERR_INVALID_CHAR)

		    fprintf(stderr,

		"Failed to detect invalid char for Bytes 0x%02X 0x%02X: %d\n",

		            i, j, c);

	    }

	    /*

	     * if using a 2 byte encoding then the value must be greater

	     * than 0x80, i.e. one of bits 5 to 1 of i must be set

	     */

	    else if ((i & 0x80) && ((i & 0x1E) == 0)) {

		if (lastError != XML_ERR_INVALID_CHAR)

		    fprintf(stderr,

		"Failed to detect invalid char for Bytes 0x%02X 0x%02X: %d\n",

		            i, j, c);

	    }

	    /*

	     * if third bit of first char is set, then the sequence would need

	     * at least 3 bytes, but we give only 2 !

	     */

	    else if ((i & 0xE0) == 0xE0) {

		if (lastError != XML_ERR_INVALID_CHAR)

		    fprintf(stderr,

		"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x00\n",

		            i, j);

	    }

            /*

	     * We should see no error in remaning cases

	     */

	    else if ((lastError != 0) || (len != 2)) {

		fprintf(stderr,

		    "Failed to parse char for Bytes 0x%02X 0x%02X\n", i, j);

	    }

            /*

	     * Finally check the value is right

	     */

	    else if (c != (j & 0x3F) + ((i & 0x1F) << 6)) {

		fprintf(stderr,

	"Failed to parse char for Bytes 0x%02X 0x%02X: expect %d got %d\n",

	                i, j, ((j & 0x3F) + ((i & 0x1F) << 6)), c);

	    }

        }

    }

}

static void testCharRangeByte3(xmlParserCtxtPtr ctxt, char *data) {

    int i, j, k, K;

    int len, c;

    unsigned char lows[6] = {0, 0x80, 0x81, 0xC1, 0xFF, 0xBF};

    int value;

    data[3] = 0;

    for (i = 0xE0;i <= 0xFF;i++) {

    for (j = 0;j <= 0xFF;j++) {

    for (k = 0;k < 6;k++) {

	data[0] = i;

	data[1] = j;

	K = lows[k];

	data[2] = (char) K;

	value = (K & 0x3F) + ((j & 0x3F) << 6) + ((i & 0xF) << 12);

	ctxt->charset = XML_CHAR_ENCODING_UTF8;

	lastError = 0;

	c = xmlCurrentChar(ctxt, &len;;

	/*

	 * if fourth bit of first char is set, then the sequence would need

	 * at least 4 bytes, but we give only 3 !

	 */

	if ((i & 0xF0) == 0xF0) {

	    if (lastError != XML_ERR_INVALID_CHAR)

		fprintf(stderr,

	"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",

			i, j, K, data[3]);

	}

        /*

	 * The second and the third bytes must start with 10

	 */

	else if (((j & 0xC0) != 0x80) || ((K & 0xC0) != 0x80)) {

	    if (lastError != XML_ERR_INVALID_CHAR)

		fprintf(stderr,

	"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X\n",

			i, j, K);

	}

	/*

	 * if using a 3 byte encoding then the value must be greater

	 * than 0x800, i.e. one of bits 4 to 0 of i must be set or

	 * the 6th byte of data[1] must be set

	 */

	else if (((i & 0xF) == 0) && ((j & 0x20) == 0)) {

	    if (lastError != XML_ERR_INVALID_CHAR)

		fprintf(stderr,

	    "Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X\n",

			i, j, K);

	}

        /*

	 * There are values in that range that are not allowed in XML-1.0

	 */

	else if (((value > 0xD7FF) && (value <0xE000)) ||

	         ((value > 0xFFFD) && (value <0x10000))) {

	    if (lastError != XML_ERR_INVALID_CHAR)

		fprintf(stderr,

	"Failed to detect invalid char 0x%04X for Bytes 0x%02X 0x%02X 0x%02X\n",

			value, i, j, K);

	}

	/*

	 * We should see no error in remaining cases

	 */

	else if ((lastError != 0) || (len != 3)) {

	    fprintf(stderr,

		"Failed to parse char for Bytes 0x%02X 0x%02X 0x%02X\n",

		    i, j, K);

	}

	/*

	 * Finally check the value is right

	 */

	else if (c != value) {

	    fprintf(stderr,

    "Failed to parse char for Bytes 0x%02X 0x%02X 0x%02X: expect %d got %d\n",

		i, j, data[2], value, c);

	}

    }

    }

    }

}

static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {

    int i, j, k, K, l, L;

    int len, c;

    unsigned char lows[6] = {0, 0x80, 0x81, 0xC1, 0xFF, 0xBF};

    int value;

    data[4] = 0;

    for (i = 0xF0;i <= 0xFF;i++) {

    for (j = 0;j <= 0xFF;j++) {

    for (k = 0;k < 6;k++) {

    for (l = 0;l < 6;l++) {

	data[0] = i;

	data[1] = j;

	K = lows[k];

	data[2] = (char) K;

	L = lows[l];

	data[3] = (char) L;

	value = (L & 0x3F) + ((K & 0x3F) << 6) + ((j & 0x3F) << 12) +

	        ((i & 0x7) << 18);

	ctxt->charset = XML_CHAR_ENCODING_UTF8;

	lastError = 0;

	c = xmlCurrentChar(ctxt, &len;;

	/*

	 * if fifth bit of first char is set, then the sequence would need

	 * at least 5 bytes, but we give only 4 !

	 */

	if ((i & 0xF8) == 0xF8) {

	    if (lastError != XML_ERR_INVALID_CHAR)

		fprintf(stderr,

  "Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",

			i, j, K, data[3]);

	}

        /*

	 * The second, third and fourth bytes must start with 10

	 */

	else if (((j & 0xC0) != 0x80) || ((K & 0xC0) != 0x80) ||

	         ((L & 0xC0) != 0x80)) {

	    if (lastError != XML_ERR_INVALID_CHAR)

		fprintf(stderr,

	"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",

			i, j, K, L);

	}

	/*

	 * if using a 3 byte encoding then the value must be greater

	 * than 0x10000, i.e. one of bits 3 to 0 of i must be set or

	 * the 6 or 5th byte of j must be set

	 */

	else if (((i & 0x7) == 0) && ((j & 0x30) == 0)) {

	    if (lastError != XML_ERR_INVALID_CHAR)

		fprintf(stderr,

	"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",

			i, j, K, L);

	}

        /*

	 * There are values in that range that are not allowed in XML-1.0

	 */

	else if (((value > 0xD7FF) && (value <0xE000)) ||

	         ((value > 0xFFFD) && (value <0x10000)) ||

		 (value > 0x10FFFF)) {

	    if (lastError != XML_ERR_INVALID_CHAR)

		fprintf(stderr,

"Failed to detect invalid char 0x%04X for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",

			value, i, j, K, L);

	}

	/*

	 * We should see no error in remaining cases

	 */

	else if ((lastError != 0) || (len != 4)) {

	    fprintf(stderr,

		"Failed to parse char for Bytes 0x%02X 0x%02X 0x%02X\n",

		    i, j, K);

	}

	/*

	 * Finally check the value is right

	 */

	else if (c != value) {

	    fprintf(stderr,

    "Failed to parse char for Bytes 0x%02X 0x%02X 0x%02X: expect %d got %d\n",

		i, j, data[2], value, c);

	}

    }

    }

    }

    }

}

/**

 * testCharRanges:

 *

 * Test the correct UTF8 character parsing in isolation i.e.

 * not when parsing a full document, this is less expensive and we can

 * cover the full range of UTF-8 chars accepted by XML-1.0

 */

static void testCharRanges(void) {

    char data[5];

    xmlParserCtxtPtr ctxt;

    xmlParserInputBufferPtr buf;

    xmlParserInputPtr input;

    memset(data, 0, 5);

    /*

     * Set up a parsing context using the above data buffer as

     * the current input source.

     */

    ctxt = xmlNewParserCtxt();

    if (ctxt == NULL) {

        fprintf(stderr, "Failed to allocate parser context\n");

	return;

    }

    buf = xmlParserInputBufferCreateStatic(data, sizeof(data),

                                           XML_CHAR_ENCODING_NONE);

    if (buf == NULL) {

        fprintf(stderr, "Failed to allocate input buffer\n");

	goto error;

    }

    input = xmlNewInputStream(ctxt);

    if (input == NULL) {

        xmlFreeParserInputBuffer(buf);

	goto error;

    }

    input->filename = NULL;

    input->buf = buf;

    input->cur =

    input->base = xmlBufContent(input->buf->buffer);

    input->end = input->base + 4;

    inputPush(ctxt, input);

    printf("testing char range: 1");

    fflush(stdout);

    testCharRangeByte1(ctxt, data);

    printf(" 2");

    fflush(stdout);

    testCharRangeByte2(ctxt, data);

    printf(" 3");

    fflush(stdout);

    testCharRangeByte3(ctxt, data);

    printf(" 4");

    fflush(stdout);

    testCharRangeByte4(ctxt, data);

    printf(" done\n");

    fflush(stdout);

error:

    xmlFreeParserCtxt(ctxt);

}

int main(void) {

    /*

     * this initialize the library and check potential ABI mismatches

     * between the version it was compiled for and the actual shared

     * library used.

     */

    LIBXML_TEST_VERSION

    /*

     * Catch errors separately

     */

    xmlSetStructuredErrorFunc(NULL, errorHandler);

    /*

     * Run the tests

     */

    testCharRanges();

    testDocumentRanges();

    /*

     * Cleanup function for the XML library.

     */

    xmlCleanupParser();

    /*

     * this is to debug memory for regression tests

     */

    xmlMemoryDump();

    return(0);

}