jcs.org
jcs's openbsd hax
openbsd
1/* Tests in the "basic" test case for the Expat test suite
2 __ __ _
3 ___\ \/ /_ __ __ _| |_
4 / _ \\ /| '_ \ / _` | __|
5 | __// \| |_) | (_| | |_
6 \___/_/\_\ .__/ \__,_|\__|
7 |_| XML parser
8
9 Copyright (c) 2001-2006 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
10 Copyright (c) 2003 Greg Stein <gstein@users.sourceforge.net>
11 Copyright (c) 2005-2007 Steven Solie <steven@solie.ca>
12 Copyright (c) 2005-2012 Karl Waclawek <karl@waclawek.net>
13 Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>
14 Copyright (c) 2017-2022 Rhodri James <rhodri@wildebeest.org.uk>
15 Copyright (c) 2017 Joe Orton <jorton@redhat.com>
16 Copyright (c) 2017 José Gutiérrez de la Concha <jose@zeroc.com>
17 Copyright (c) 2018 Marco Maggi <marco.maggi-ipsu@poste.it>
18 Copyright (c) 2019 David Loffredo <loffredo@steptools.com>
19 Copyright (c) 2020 Tim Gates <tim.gates@iress.com>
20 Copyright (c) 2021 Donghee Na <donghee.na@python.org>
21 Copyright (c) 2023-2024 Sony Corporation / Snild Dolkow <snild@sony.com>
22 Copyright (c) 2024-2025 Berkay Eren Ürün <berkay.ueruen@siemens.com>
23 Licensed under the MIT license:
24
25 Permission is hereby granted, free of charge, to any person obtaining
26 a copy of this software and associated documentation files (the
27 "Software"), to deal in the Software without restriction, including
28 without limitation the rights to use, copy, modify, merge, publish,
29 distribute, sublicense, and/or sell copies of the Software, and to permit
30 persons to whom the Software is furnished to do so, subject to the
31 following conditions:
32
33 The above copyright notice and this permission notice shall be included
34 in all copies or substantial portions of the Software.
35
36 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
37 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
38 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
39 NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
40 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
41 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
42 USE OR OTHER DEALINGS IN THE SOFTWARE.
43*/
44
45#if defined(NDEBUG)
46# undef NDEBUG /* because test suite relies on assert(...) at the moment */
47#endif
48
49#include <assert.h>
50
51#include <stdio.h>
52#include <string.h>
53#include <time.h>
54
55#if ! defined(__cplusplus)
56# include <stdbool.h>
57#endif
58
59#include "expat_config.h"
60
61#include "expat.h"
62#include "internal.h"
63#include "minicheck.h"
64#include "structdata.h"
65#include "common.h"
66#include "dummy.h"
67#include "handlers.h"
68#include "siphash.h"
69#include "basic_tests.h"
70
71static void
72basic_setup(void) {
73 g_parser = XML_ParserCreate(NULL);
74 if (g_parser == NULL)
75 fail("Parser not created.");
76}
77
78/*
79 * Character & encoding tests.
80 */
81
82START_TEST(test_nul_byte) {
83 char text[] = "<doc>\0</doc>";
84
85 /* test that a NUL byte (in US-ASCII data) is an error */
86 if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
87 == XML_STATUS_OK)
88 fail("Parser did not report error on NUL-byte.");
89 if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
90 xml_failure(g_parser);
91}
92END_TEST
93
94START_TEST(test_u0000_char) {
95 /* test that a NUL byte (in US-ASCII data) is an error */
96 expect_failure("<doc>�</doc>", XML_ERROR_BAD_CHAR_REF,
97 "Parser did not report error on NUL-byte.");
98}
99END_TEST
100
101START_TEST(test_siphash_self) {
102 if (! sip24_valid())
103 fail("SipHash self-test failed");
104}
105END_TEST
106
107START_TEST(test_siphash_spec) {
108 /* https://131002.net/siphash/siphash.pdf (page 19, "Test values") */
109 const char message[] = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09"
110 "\x0a\x0b\x0c\x0d\x0e";
111 const size_t len = sizeof(message) - 1;
112 const uint64_t expected = SIP_ULL(0xa129ca61U, 0x49be45e5U);
113 struct siphash state;
114 struct sipkey key;
115
116 sip_tokey(&key, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09"
117 "\x0a\x0b\x0c\x0d\x0e\x0f");
118 sip24_init(&state, &key);
119
120 /* Cover spread across calls */
121 sip24_update(&state, message, 4);
122 sip24_update(&state, message + 4, len - 4);
123
124 /* Cover null length */
125 sip24_update(&state, message, 0);
126
127 if (sip24_final(&state) != expected)
128 fail("sip24_final failed spec test\n");
129
130 /* Cover wrapper */
131 if (siphash24(message, len, &key) != expected)
132 fail("siphash24 failed spec test\n");
133}
134END_TEST
135
136START_TEST(test_bom_utf8) {
137 /* This test is really just making sure we don't core on a UTF-8 BOM. */
138 const char *text = "\357\273\277<e/>";
139
140 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
141 == XML_STATUS_ERROR)
142 xml_failure(g_parser);
143}
144END_TEST
145
146START_TEST(test_bom_utf16_be) {
147 char text[] = "\376\377\0<\0e\0/\0>";
148
149 if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
150 == XML_STATUS_ERROR)
151 xml_failure(g_parser);
152}
153END_TEST
154
155START_TEST(test_bom_utf16_le) {
156 char text[] = "\377\376<\0e\0/\0>\0";
157
158 if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
159 == XML_STATUS_ERROR)
160 xml_failure(g_parser);
161}
162END_TEST
163
164START_TEST(test_nobom_utf16_le) {
165 char text[] = " \0<\0e\0/\0>\0";
166
167 if (g_chunkSize == 1) {
168 // TODO: with just the first byte, we can't tell the difference between
169 // UTF-16-LE and UTF-8. Avoid the failure for now.
170 return;
171 }
172
173 if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
174 == XML_STATUS_ERROR)
175 xml_failure(g_parser);
176}
177END_TEST
178
179START_TEST(test_hash_collision) {
180 /* For full coverage of the lookup routine, we need to ensure a
181 * hash collision even though we can only tell that we have one
182 * through breakpoint debugging or coverage statistics. The
183 * following will cause a hash collision on machines with a 64-bit
184 * long type; others will have to experiment. The full coverage
185 * tests invoked from qa.sh usually provide a hash collision, but
186 * not always. This is an attempt to provide insurance.
187 */
188#define COLLIDING_HASH_SALT (unsigned long)SIP_ULL(0xffffffffU, 0xff99fc90U)
189 const char *text
190 = "<doc>\n"
191 "<a1/><a2/><a3/><a4/><a5/><a6/><a7/><a8/>\n"
192 "<b1></b1><b2 attr='foo'>This is a foo</b2><b3></b3><b4></b4>\n"
193 "<b5></b5><b6></b6><b7></b7><b8></b8>\n"
194 "<c1/><c2/><c3/><c4/><c5/><c6/><c7/><c8/>\n"
195 "<d1/><d2/><d3/><d4/><d5/><d6/><d7/>\n"
196 "<d8>This triggers the table growth and collides with b2</d8>\n"
197 "</doc>\n";
198
199 XML_SetHashSalt(g_parser, COLLIDING_HASH_SALT);
200 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
201 == XML_STATUS_ERROR)
202 xml_failure(g_parser);
203}
204END_TEST
205#undef COLLIDING_HASH_SALT
206
207/* Regression test for SF bug #491986. */
208START_TEST(test_danish_latin1) {
209 const char *text = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
210 "<e>J\xF8rgen \xE6\xF8\xE5\xC6\xD8\xC5</e>";
211#ifdef XML_UNICODE
212 const XML_Char *expected
213 = XCS("J\x00f8rgen \x00e6\x00f8\x00e5\x00c6\x00d8\x00c5");
214#else
215 const XML_Char *expected
216 = XCS("J\xC3\xB8rgen \xC3\xA6\xC3\xB8\xC3\xA5\xC3\x86\xC3\x98\xC3\x85");
217#endif
218 run_character_check(text, expected);
219}
220END_TEST
221
222/* Regression test for SF bug #514281. */
223START_TEST(test_french_charref_hexidecimal) {
224 const char *text = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
225 "<doc>éèàçêÈ</doc>";
226#ifdef XML_UNICODE
227 const XML_Char *expected = XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
228#else
229 const XML_Char *expected
230 = XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
231#endif
232 run_character_check(text, expected);
233}
234END_TEST
235
236START_TEST(test_french_charref_decimal) {
237 const char *text = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
238 "<doc>éèàçêÈ</doc>";
239#ifdef XML_UNICODE
240 const XML_Char *expected = XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
241#else
242 const XML_Char *expected
243 = XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
244#endif
245 run_character_check(text, expected);
246}
247END_TEST
248
249START_TEST(test_french_latin1) {
250 const char *text = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
251 "<doc>\xE9\xE8\xE0\xE7\xEa\xC8</doc>";
252#ifdef XML_UNICODE
253 const XML_Char *expected = XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
254#else
255 const XML_Char *expected
256 = XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
257#endif
258 run_character_check(text, expected);
259}
260END_TEST
261
262START_TEST(test_french_utf8) {
263 const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
264 "<doc>\xC3\xA9</doc>";
265#ifdef XML_UNICODE
266 const XML_Char *expected = XCS("\x00e9");
267#else
268 const XML_Char *expected = XCS("\xC3\xA9");
269#endif
270 run_character_check(text, expected);
271}
272END_TEST
273
274/* Regression test for SF bug #600479.
275 XXX There should be a test that exercises all legal XML Unicode
276 characters as PCDATA and attribute value content, and XML Name
277 characters as part of element and attribute names.
278*/
279START_TEST(test_utf8_false_rejection) {
280 const char *text = "<doc>\xEF\xBA\xBF</doc>";
281#ifdef XML_UNICODE
282 const XML_Char *expected = XCS("\xfebf");
283#else
284 const XML_Char *expected = XCS("\xEF\xBA\xBF");
285#endif
286 run_character_check(text, expected);
287}
288END_TEST
289
290/* Regression test for SF bug #477667.
291 This test assures that any 8-bit character followed by a 7-bit
292 character will not be mistakenly interpreted as a valid UTF-8
293 sequence.
294*/
295START_TEST(test_illegal_utf8) {
296 char text[100];
297 int i;
298
299 for (i = 128; i <= 255; ++i) {
300 snprintf(text, sizeof(text), "<e>%ccd</e>", i);
301 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
302 == XML_STATUS_OK) {
303 snprintf(text, sizeof(text),
304 "expected token error for '%c' (ordinal %d) in UTF-8 text", i,
305 i);
306 fail(text);
307 } else if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
308 xml_failure(g_parser);
309 /* Reset the parser since we use the same parser repeatedly. */
310 XML_ParserReset(g_parser, NULL);
311 }
312}
313END_TEST
314
315/* Examples, not masks: */
316#define UTF8_LEAD_1 "\x7f" /* 0b01111111 */
317#define UTF8_LEAD_2 "\xdf" /* 0b11011111 */
318#define UTF8_LEAD_3 "\xef" /* 0b11101111 */
319#define UTF8_LEAD_4 "\xf7" /* 0b11110111 */
320#define UTF8_FOLLOW "\xbf" /* 0b10111111 */
321
322START_TEST(test_utf8_auto_align) {
323 struct TestCase {
324 ptrdiff_t expectedMovementInChars;
325 const char *input;
326 };
327
328 struct TestCase cases[] = {
329 {00, ""},
330
331 {00, UTF8_LEAD_1},
332
333 {-1, UTF8_LEAD_2},
334 {00, UTF8_LEAD_2 UTF8_FOLLOW},
335
336 {-1, UTF8_LEAD_3},
337 {-2, UTF8_LEAD_3 UTF8_FOLLOW},
338 {00, UTF8_LEAD_3 UTF8_FOLLOW UTF8_FOLLOW},
339
340 {-1, UTF8_LEAD_4},
341 {-2, UTF8_LEAD_4 UTF8_FOLLOW},
342 {-3, UTF8_LEAD_4 UTF8_FOLLOW UTF8_FOLLOW},
343 {00, UTF8_LEAD_4 UTF8_FOLLOW UTF8_FOLLOW UTF8_FOLLOW},
344 };
345
346 size_t i = 0;
347 bool success = true;
348 for (; i < sizeof(cases) / sizeof(*cases); i++) {
349 const char *fromLim = cases[i].input + strlen(cases[i].input);
350 const char *const fromLimInitially = fromLim;
351 ptrdiff_t actualMovementInChars;
352
353 _INTERNAL_trim_to_complete_utf8_characters(cases[i].input, &fromLim);
354
355 actualMovementInChars = (fromLim - fromLimInitially);
356 if (actualMovementInChars != cases[i].expectedMovementInChars) {
357 size_t j = 0;
358 success = false;
359 printf("[-] UTF-8 case %2u: Expected movement by %2d chars"
360 ", actually moved by %2d chars: \"",
361 (unsigned)(i + 1), (int)cases[i].expectedMovementInChars,
362 (int)actualMovementInChars);
363 for (; j < strlen(cases[i].input); j++) {
364 printf("\\x%02x", (unsigned char)cases[i].input[j]);
365 }
366 printf("\"\n");
367 }
368 }
369
370 if (! success) {
371 fail("UTF-8 auto-alignment is not bullet-proof\n");
372 }
373}
374END_TEST
375
376START_TEST(test_utf16) {
377 /* <?xml version="1.0" encoding="UTF-16"?>
378 * <doc a='123'>some {A} text</doc>
379 *
380 * where {A} is U+FF21, FULLWIDTH LATIN CAPITAL LETTER A
381 */
382 char text[]
383 = "\000<\000?\000x\000m\000\154\000 \000v\000e\000r\000s\000i\000o"
384 "\000n\000=\000'\0001\000.\000\060\000'\000 \000e\000n\000c\000o"
385 "\000d\000i\000n\000g\000=\000'\000U\000T\000F\000-\0001\000\066"
386 "\000'\000?\000>\000\n"
387 "\000<\000d\000o\000c\000 \000a\000=\000'\0001\0002\0003\000'\000>"
388 "\000s\000o\000m\000e\000 \xff\x21\000 \000t\000e\000x\000t\000"
389 "<\000/\000d\000o\000c\000>";
390#ifdef XML_UNICODE
391 const XML_Char *expected = XCS("some \xff21 text");
392#else
393 const XML_Char *expected = XCS("some \357\274\241 text");
394#endif
395 CharData storage;
396
397 CharData_Init(&storage);
398 XML_SetUserData(g_parser, &storage);
399 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
400 if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
401 == XML_STATUS_ERROR)
402 xml_failure(g_parser);
403 CharData_CheckXMLChars(&storage, expected);
404}
405END_TEST
406
407START_TEST(test_utf16_le_epilog_newline) {
408 unsigned int first_chunk_bytes = 17;
409 char text[] = "\xFF\xFE" /* BOM */
410 "<\000e\000/\000>\000" /* document element */
411 "\r\000\n\000\r\000\n\000"; /* epilog */
412
413 if (first_chunk_bytes >= sizeof(text) - 1)
414 fail("bad value of first_chunk_bytes");
415 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)first_chunk_bytes, XML_FALSE)
416 == XML_STATUS_ERROR)
417 xml_failure(g_parser);
418 else {
419 enum XML_Status rc;
420 rc = _XML_Parse_SINGLE_BYTES(g_parser, text + first_chunk_bytes,
421 (int)(sizeof(text) - first_chunk_bytes - 1),
422 XML_TRUE);
423 if (rc == XML_STATUS_ERROR)
424 xml_failure(g_parser);
425 }
426}
427END_TEST
428
429/* Test that an outright lie in the encoding is faulted */
430START_TEST(test_not_utf16) {
431 const char *text = "<?xml version='1.0' encoding='utf-16'?>"
432 "<doc>Hi</doc>";
433
434 /* Use a handler to provoke the appropriate code paths */
435 XML_SetXmlDeclHandler(g_parser, dummy_xdecl_handler);
436 expect_failure(text, XML_ERROR_INCORRECT_ENCODING,
437 "UTF-16 declared in UTF-8 not faulted");
438}
439END_TEST
440
441/* Test that an unknown encoding is rejected */
442START_TEST(test_bad_encoding) {
443 const char *text = "<doc>Hi</doc>";
444
445 if (! XML_SetEncoding(g_parser, XCS("unknown-encoding")))
446 fail("XML_SetEncoding failed");
447 expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
448 "Unknown encoding not faulted");
449}
450END_TEST
451
452/* Regression test for SF bug #481609, #774028. */
453START_TEST(test_latin1_umlauts) {
454 const char *text
455 = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
456 "<e a='\xE4 \xF6 \xFC ä ö ü ä ö ü >'\n"
457 " >\xE4 \xF6 \xFC ä ö ü ä ö ü ></e>";
458#ifdef XML_UNICODE
459 /* Expected results in UTF-16 */
460 const XML_Char *expected = XCS("\x00e4 \x00f6 \x00fc ")
461 XCS("\x00e4 \x00f6 \x00fc ") XCS("\x00e4 \x00f6 \x00fc >");
462#else
463 /* Expected results in UTF-8 */
464 const XML_Char *expected = XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC ")
465 XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC ") XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC >");
466#endif
467
468 run_character_check(text, expected);
469 XML_ParserReset(g_parser, NULL);
470 run_attribute_check(text, expected);
471 /* Repeat with a default handler */
472 XML_ParserReset(g_parser, NULL);
473 XML_SetDefaultHandler(g_parser, dummy_default_handler);
474 run_character_check(text, expected);
475 XML_ParserReset(g_parser, NULL);
476 XML_SetDefaultHandler(g_parser, dummy_default_handler);
477 run_attribute_check(text, expected);
478}
479END_TEST
480
481/* Test that an element name with a 4-byte UTF-8 character is rejected */
482START_TEST(test_long_utf8_character) {
483 const char *text
484 = "<?xml version='1.0' encoding='utf-8'?>\n"
485 /* 0xf0 0x90 0x80 0x80 = U+10000, the first Linear B character */
486 "<do\xf0\x90\x80\x80/>";
487 expect_failure(text, XML_ERROR_INVALID_TOKEN,
488 "4-byte UTF-8 character in element name not faulted");
489}
490END_TEST
491
492/* Test that a long latin-1 attribute (too long to convert in one go)
493 * is correctly converted
494 */
495START_TEST(test_long_latin1_attribute) {
496 const char *text
497 = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
498 "<doc att='"
499 /* 64 characters per line */
500 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
501 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
502 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
503 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
504 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
505 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
506 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
507 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
508 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
509 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
510 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
511 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
512 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
513 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
514 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
515 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
516 /* Last character splits across a buffer boundary */
517 "\xe4'>\n</doc>";
518
519 const XML_Char *expected =
520 /* 64 characters per line */
521 /* clang-format off */
522 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
523 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
524 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
525 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
526 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
527 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
528 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
529 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
530 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
531 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
532 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
533 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
534 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
535 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
536 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
537 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO")
538 /* clang-format on */
539#ifdef XML_UNICODE
540 XCS("\x00e4");
541#else
542 XCS("\xc3\xa4");
543#endif
544
545 run_attribute_check(text, expected);
546}
547END_TEST
548
549/* Test that a long ASCII attribute (too long to convert in one go)
550 * is correctly converted
551 */
552START_TEST(test_long_ascii_attribute) {
553 const char *text
554 = "<?xml version='1.0' encoding='us-ascii'?>\n"
555 "<doc att='"
556 /* 64 characters per line */
557 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
558 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
559 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
560 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
561 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
562 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
563 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
564 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
565 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
566 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
567 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
568 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
569 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
570 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
571 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
572 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
573 "01234'>\n</doc>";
574 const XML_Char *expected =
575 /* 64 characters per line */
576 /* clang-format off */
577 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
578 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
579 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
580 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
581 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
582 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
583 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
584 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
585 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
586 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
587 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
588 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
589 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
590 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
591 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
592 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
593 XCS("01234");
594 /* clang-format on */
595
596 run_attribute_check(text, expected);
597}
598END_TEST
599
600/* Regression test #1 for SF bug #653180. */
601START_TEST(test_line_number_after_parse) {
602 const char *text = "<tag>\n"
603 "\n"
604 "\n</tag>";
605 XML_Size lineno;
606
607 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
608 == XML_STATUS_ERROR)
609 xml_failure(g_parser);
610 lineno = XML_GetCurrentLineNumber(g_parser);
611 if (lineno != 4) {
612 char buffer[100];
613 snprintf(buffer, sizeof(buffer),
614 "expected 4 lines, saw %" XML_FMT_INT_MOD "u", lineno);
615 fail(buffer);
616 }
617}
618END_TEST
619
620/* Regression test #2 for SF bug #653180. */
621START_TEST(test_column_number_after_parse) {
622 const char *text = "<tag></tag>";
623 XML_Size colno;
624
625 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
626 == XML_STATUS_ERROR)
627 xml_failure(g_parser);
628 colno = XML_GetCurrentColumnNumber(g_parser);
629 if (colno != 11) {
630 char buffer[100];
631 snprintf(buffer, sizeof(buffer),
632 "expected 11 columns, saw %" XML_FMT_INT_MOD "u", colno);
633 fail(buffer);
634 }
635}
636END_TEST
637
638/* Regression test #3 for SF bug #653180. */
639START_TEST(test_line_and_column_numbers_inside_handlers) {
640 const char *text = "<a>\n" /* Unix end-of-line */
641 " <b>\r\n" /* Windows end-of-line */
642 " <c/>\r" /* Mac OS end-of-line */
643 " </b>\n"
644 " <d>\n"
645 " <f/>\n"
646 " </d>\n"
647 "</a>";
648 const StructDataEntry expected[]
649 = {{XCS("a"), 0, 1, STRUCT_START_TAG}, {XCS("b"), 2, 2, STRUCT_START_TAG},
650 {XCS("c"), 4, 3, STRUCT_START_TAG}, {XCS("c"), 8, 3, STRUCT_END_TAG},
651 {XCS("b"), 2, 4, STRUCT_END_TAG}, {XCS("d"), 2, 5, STRUCT_START_TAG},
652 {XCS("f"), 4, 6, STRUCT_START_TAG}, {XCS("f"), 8, 6, STRUCT_END_TAG},
653 {XCS("d"), 2, 7, STRUCT_END_TAG}, {XCS("a"), 0, 8, STRUCT_END_TAG}};
654 const int expected_count = sizeof(expected) / sizeof(StructDataEntry);
655 StructData storage;
656
657 StructData_Init(&storage);
658 XML_SetUserData(g_parser, &storage);
659 XML_SetStartElementHandler(g_parser, start_element_event_handler2);
660 XML_SetEndElementHandler(g_parser, end_element_event_handler2);
661 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
662 == XML_STATUS_ERROR)
663 xml_failure(g_parser);
664
665 StructData_CheckItems(&storage, expected, expected_count);
666 StructData_Dispose(&storage);
667}
668END_TEST
669
670/* Regression test #4 for SF bug #653180. */
671START_TEST(test_line_number_after_error) {
672 const char *text = "<a>\n"
673 " <b>\n"
674 " </a>"; /* missing </b> */
675 XML_Size lineno;
676 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
677 != XML_STATUS_ERROR)
678 fail("Expected a parse error");
679
680 lineno = XML_GetCurrentLineNumber(g_parser);
681 if (lineno != 3) {
682 char buffer[100];
683 snprintf(buffer, sizeof(buffer),
684 "expected 3 lines, saw %" XML_FMT_INT_MOD "u", lineno);
685 fail(buffer);
686 }
687}
688END_TEST
689
690/* Regression test #5 for SF bug #653180. */
691START_TEST(test_column_number_after_error) {
692 const char *text = "<a>\n"
693 " <b>\n"
694 " </a>"; /* missing </b> */
695 XML_Size colno;
696 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
697 != XML_STATUS_ERROR)
698 fail("Expected a parse error");
699
700 colno = XML_GetCurrentColumnNumber(g_parser);
701 if (colno != 4) {
702 char buffer[100];
703 snprintf(buffer, sizeof(buffer),
704 "expected 4 columns, saw %" XML_FMT_INT_MOD "u", colno);
705 fail(buffer);
706 }
707}
708END_TEST
709
710/* Regression test for SF bug #478332. */
711START_TEST(test_really_long_lines) {
712 /* This parses an input line longer than INIT_DATA_BUF_SIZE
713 characters long (defined to be 1024 in xmlparse.c). We take a
714 really cheesy approach to building the input buffer, because
715 this avoids writing bugs in buffer-filling code.
716 */
717 const char *text
718 = "<e>"
719 /* 64 chars */
720 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
721 /* until we have at least 1024 characters on the line: */
722 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
723 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
724 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
725 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
726 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
727 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
728 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
729 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
730 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
731 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
732 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
733 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
734 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
735 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
736 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
737 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
738 "</e>";
739 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
740 == XML_STATUS_ERROR)
741 xml_failure(g_parser);
742}
743END_TEST
744
745/* Test cdata processing across a buffer boundary */
746START_TEST(test_really_long_encoded_lines) {
747 /* As above, except that we want to provoke an output buffer
748 * overflow with a non-trivial encoding. For this we need to pass
749 * the whole cdata in one go, not byte-by-byte.
750 */
751 void *buffer;
752 const char *text
753 = "<?xml version='1.0' encoding='iso-8859-1'?>"
754 "<e>"
755 /* 64 chars */
756 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
757 /* until we have at least 1024 characters on the line: */
758 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
759 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
760 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
761 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
762 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
763 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
764 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
765 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
766 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
767 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
768 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
769 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
770 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
771 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
772 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
773 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
774 "</e>";
775 int parse_len = (int)strlen(text);
776
777 /* Need a cdata handler to provoke the code path we want to test */
778 XML_SetCharacterDataHandler(g_parser, dummy_cdata_handler);
779 buffer = XML_GetBuffer(g_parser, parse_len);
780 if (buffer == NULL)
781 fail("Could not allocate parse buffer");
782 assert(buffer != NULL);
783 memcpy(buffer, text, parse_len);
784 if (XML_ParseBuffer(g_parser, parse_len, XML_TRUE) == XML_STATUS_ERROR)
785 xml_failure(g_parser);
786}
787END_TEST
788
789/*
790 * Element event tests.
791 */
792
793START_TEST(test_end_element_events) {
794 const char *text = "<a><b><c/></b><d><f/></d></a>";
795 const XML_Char *expected = XCS("/c/b/f/d/a");
796 CharData storage;
797
798 CharData_Init(&storage);
799 XML_SetUserData(g_parser, &storage);
800 XML_SetEndElementHandler(g_parser, end_element_event_handler);
801 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
802 == XML_STATUS_ERROR)
803 xml_failure(g_parser);
804 CharData_CheckXMLChars(&storage, expected);
805}
806END_TEST
807
808/*
809 * Attribute tests.
810 */
811
812/* Helper used by the following tests; this checks any "attr" and "refs"
813 attributes to make sure whitespace has been normalized.
814
815 Return true if whitespace has been normalized in a string, using
816 the rules for attribute value normalization. The 'is_cdata' flag
817 is needed since CDATA attributes don't need to have multiple
818 whitespace characters collapsed to a single space, while other
819 attribute data types do. (Section 3.3.3 of the recommendation.)
820*/
821static int
822is_whitespace_normalized(const XML_Char *s, int is_cdata) {
823 int blanks = 0;
824 int at_start = 1;
825 while (*s) {
826 if (*s == XCS(' '))
827 ++blanks;
828 else if (*s == XCS('\t') || *s == XCS('\n') || *s == XCS('\r'))
829 return 0;
830 else {
831 if (at_start) {
832 at_start = 0;
833 if (blanks && ! is_cdata)
834 /* illegal leading blanks */
835 return 0;
836 } else if (blanks > 1 && ! is_cdata)
837 return 0;
838 blanks = 0;
839 }
840 ++s;
841 }
842 if (blanks && ! is_cdata)
843 return 0;
844 return 1;
845}
846
847/* Check the attribute whitespace checker: */
848START_TEST(test_helper_is_whitespace_normalized) {
849 assert(is_whitespace_normalized(XCS("abc"), 0));
850 assert(is_whitespace_normalized(XCS("abc"), 1));
851 assert(is_whitespace_normalized(XCS("abc def ghi"), 0));
852 assert(is_whitespace_normalized(XCS("abc def ghi"), 1));
853 assert(! is_whitespace_normalized(XCS(" abc def ghi"), 0));
854 assert(is_whitespace_normalized(XCS(" abc def ghi"), 1));
855 assert(! is_whitespace_normalized(XCS("abc def ghi"), 0));
856 assert(is_whitespace_normalized(XCS("abc def ghi"), 1));
857 assert(! is_whitespace_normalized(XCS("abc def ghi "), 0));
858 assert(is_whitespace_normalized(XCS("abc def ghi "), 1));
859 assert(! is_whitespace_normalized(XCS(" "), 0));
860 assert(is_whitespace_normalized(XCS(" "), 1));
861 assert(! is_whitespace_normalized(XCS("\t"), 0));
862 assert(! is_whitespace_normalized(XCS("\t"), 1));
863 assert(! is_whitespace_normalized(XCS("\n"), 0));
864 assert(! is_whitespace_normalized(XCS("\n"), 1));
865 assert(! is_whitespace_normalized(XCS("\r"), 0));
866 assert(! is_whitespace_normalized(XCS("\r"), 1));
867 assert(! is_whitespace_normalized(XCS("abc\t def"), 1));
868}
869END_TEST
870
871static void XMLCALL
872check_attr_contains_normalized_whitespace(void *userData, const XML_Char *name,
873 const XML_Char **atts) {
874 int i;
875 UNUSED_P(userData);
876 UNUSED_P(name);
877 for (i = 0; atts[i] != NULL; i += 2) {
878 const XML_Char *attrname = atts[i];
879 const XML_Char *value = atts[i + 1];
880 if (xcstrcmp(XCS("attr"), attrname) == 0
881 || xcstrcmp(XCS("ents"), attrname) == 0
882 || xcstrcmp(XCS("refs"), attrname) == 0) {
883 if (! is_whitespace_normalized(value, 0)) {
884 char buffer[256];
885 snprintf(buffer, sizeof(buffer),
886 "attribute value not normalized: %" XML_FMT_STR
887 "='%" XML_FMT_STR "'",
888 attrname, value);
889 fail(buffer);
890 }
891 }
892 }
893}
894
895START_TEST(test_attr_whitespace_normalization) {
896 const char *text
897 = "<!DOCTYPE doc [\n"
898 " <!ATTLIST doc\n"
899 " attr NMTOKENS #REQUIRED\n"
900 " ents ENTITIES #REQUIRED\n"
901 " refs IDREFS #REQUIRED>\n"
902 "]>\n"
903 "<doc attr=' a b c\t\td\te\t' refs=' id-1 \t id-2\t\t' \n"
904 " ents=' ent-1 \t\r\n"
905 " ent-2 ' >\n"
906 " <e id='id-1'/>\n"
907 " <e id='id-2'/>\n"
908 "</doc>";
909
910 XML_SetStartElementHandler(g_parser,
911 check_attr_contains_normalized_whitespace);
912 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
913 == XML_STATUS_ERROR)
914 xml_failure(g_parser);
915}
916END_TEST
917
918/*
919 * XML declaration tests.
920 */
921
922START_TEST(test_xmldecl_misplaced) {
923 expect_failure("\n"
924 "<?xml version='1.0'?>\n"
925 "<a/>",
926 XML_ERROR_MISPLACED_XML_PI,
927 "failed to report misplaced XML declaration");
928}
929END_TEST
930
931START_TEST(test_xmldecl_invalid) {
932 expect_failure("<?xml version='1.0' \xc3\xa7?>\n<doc/>", XML_ERROR_XML_DECL,
933 "Failed to report invalid XML declaration");
934}
935END_TEST
936
937START_TEST(test_xmldecl_missing_attr) {
938 expect_failure("<?xml ='1.0'?>\n<doc/>\n", XML_ERROR_XML_DECL,
939 "Failed to report missing XML declaration attribute");
940}
941END_TEST
942
943START_TEST(test_xmldecl_missing_value) {
944 expect_failure("<?xml version='1.0' encoding='us-ascii' standalone?>\n"
945 "<doc/>",
946 XML_ERROR_XML_DECL,
947 "Failed to report missing attribute value");
948}
949END_TEST
950
951/* Regression test for SF bug #584832. */
952START_TEST(test_unknown_encoding_internal_entity) {
953 const char *text = "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
954 "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
955 "<test a='&foo;'/>";
956
957 XML_SetUnknownEncodingHandler(g_parser, UnknownEncodingHandler, NULL);
958 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
959 == XML_STATUS_ERROR)
960 xml_failure(g_parser);
961}
962END_TEST
963
964/* Test unrecognised encoding handler */
965START_TEST(test_unrecognised_encoding_internal_entity) {
966 const char *text = "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
967 "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
968 "<test a='&foo;'/>";
969
970 XML_SetUnknownEncodingHandler(g_parser, UnrecognisedEncodingHandler, NULL);
971 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
972 != XML_STATUS_ERROR)
973 fail("Unrecognised encoding not rejected");
974}
975END_TEST
976
977/* Regression test for SF bug #620106. */
978START_TEST(test_ext_entity_set_encoding) {
979 const char *text = "<!DOCTYPE doc [\n"
980 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
981 "]>\n"
982 "<doc>&en;</doc>";
983 ExtTest test_data
984 = {/* This text says it's an unsupported encoding, but it's really
985 UTF-8, which we tell Expat using XML_SetEncoding().
986 */
987 "<?xml encoding='iso-8859-3'?>\xC3\xA9", XCS("utf-8"), NULL};
988#ifdef XML_UNICODE
989 const XML_Char *expected = XCS("\x00e9");
990#else
991 const XML_Char *expected = XCS("\xc3\xa9");
992#endif
993
994 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
995 run_ext_character_check(text, &test_data, expected);
996}
997END_TEST
998
999/* Test external entities with no handler */
1000START_TEST(test_ext_entity_no_handler) {
1001 const char *text = "<!DOCTYPE doc [\n"
1002 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
1003 "]>\n"
1004 "<doc>&en;</doc>";
1005
1006 XML_SetDefaultHandler(g_parser, dummy_default_handler);
1007 run_character_check(text, XCS(""));
1008}
1009END_TEST
1010
1011/* Test UTF-8 BOM is accepted */
1012START_TEST(test_ext_entity_set_bom) {
1013 const char *text = "<!DOCTYPE doc [\n"
1014 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
1015 "]>\n"
1016 "<doc>&en;</doc>";
1017 ExtTest test_data = {"\xEF\xBB\xBF" /* BOM */
1018 "<?xml encoding='iso-8859-3'?>"
1019 "\xC3\xA9",
1020 XCS("utf-8"), NULL};
1021#ifdef XML_UNICODE
1022 const XML_Char *expected = XCS("\x00e9");
1023#else
1024 const XML_Char *expected = XCS("\xc3\xa9");
1025#endif
1026
1027 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
1028 run_ext_character_check(text, &test_data, expected);
1029}
1030END_TEST
1031
1032/* Test that bad encodings are faulted */
1033START_TEST(test_ext_entity_bad_encoding) {
1034 const char *text = "<!DOCTYPE doc [\n"
1035 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
1036 "]>\n"
1037 "<doc>&en;</doc>";
1038 ExtFaults fault
1039 = {"<?xml encoding='iso-8859-3'?>u", "Unsupported encoding not faulted",
1040 XCS("unknown"), XML_ERROR_UNKNOWN_ENCODING};
1041
1042 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
1043 XML_SetUserData(g_parser, &fault);
1044 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
1045 "Bad encoding should not have been accepted");
1046}
1047END_TEST
1048
1049/* Try handing an invalid encoding to an external entity parser */
1050START_TEST(test_ext_entity_bad_encoding_2) {
1051 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
1052 "<!DOCTYPE doc SYSTEM 'foo'>\n"
1053 "<doc>&entity;</doc>";
1054 ExtFaults fault
1055 = {"<!ELEMENT doc (#PCDATA)*>", "Unknown encoding not faulted",
1056 XCS("unknown-encoding"), XML_ERROR_UNKNOWN_ENCODING};
1057
1058 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1059 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
1060 XML_SetUserData(g_parser, &fault);
1061 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
1062 "Bad encoding not faulted in external entity handler");
1063}
1064END_TEST
1065
1066/* Test that no error is reported for unknown entities if we don't
1067 read an external subset. This was fixed in Expat 1.95.5.
1068*/
1069START_TEST(test_wfc_undeclared_entity_unread_external_subset) {
1070 const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
1071 "<doc>&entity;</doc>";
1072
1073 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1074 == XML_STATUS_ERROR)
1075 xml_failure(g_parser);
1076}
1077END_TEST
1078
1079/* Test that an error is reported for unknown entities if we don't
1080 have an external subset.
1081*/
1082START_TEST(test_wfc_undeclared_entity_no_external_subset) {
1083 expect_failure("<doc>&entity;</doc>", XML_ERROR_UNDEFINED_ENTITY,
1084 "Parser did not report undefined entity w/out a DTD.");
1085}
1086END_TEST
1087
1088/* Test that an error is reported for unknown entities if we don't
1089 read an external subset, but have been declared standalone.
1090*/
1091START_TEST(test_wfc_undeclared_entity_standalone) {
1092 const char *text
1093 = "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
1094 "<!DOCTYPE doc SYSTEM 'foo'>\n"
1095 "<doc>&entity;</doc>";
1096
1097 expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
1098 "Parser did not report undefined entity (standalone).");
1099}
1100END_TEST
1101
1102/* Test that an error is reported for unknown entities if we have read
1103 an external subset, and standalone is true.
1104*/
1105START_TEST(test_wfc_undeclared_entity_with_external_subset_standalone) {
1106 const char *text
1107 = "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
1108 "<!DOCTYPE doc SYSTEM 'foo'>\n"
1109 "<doc>&entity;</doc>";
1110 ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
1111
1112 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1113 XML_SetUserData(g_parser, &test_data);
1114 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
1115 expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
1116 "Parser did not report undefined entity (external DTD).");
1117}
1118END_TEST
1119
1120/* Test that external entity handling is not done if the parsing flag
1121 * is set to UNLESS_STANDALONE
1122 */
1123START_TEST(test_entity_with_external_subset_unless_standalone) {
1124 const char *text
1125 = "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
1126 "<!DOCTYPE doc SYSTEM 'foo'>\n"
1127 "<doc>&entity;</doc>";
1128 ExtTest test_data = {"<!ENTITY entity 'bar'>", NULL, NULL};
1129
1130 XML_SetParamEntityParsing(g_parser,
1131 XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
1132 XML_SetUserData(g_parser, &test_data);
1133 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
1134 expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
1135 "Parser did not report undefined entity");
1136}
1137END_TEST
1138
1139/* Test that no error is reported for unknown entities if we have read
1140 an external subset, and standalone is false.
1141*/
1142START_TEST(test_wfc_undeclared_entity_with_external_subset) {
1143 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
1144 "<!DOCTYPE doc SYSTEM 'foo'>\n"
1145 "<doc>&entity;</doc>";
1146 ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
1147
1148 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1149 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
1150 run_ext_character_check(text, &test_data, XCS(""));
1151}
1152END_TEST
1153
1154/* Test that an error is reported if our NotStandalone handler fails */
1155START_TEST(test_not_standalone_handler_reject) {
1156 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
1157 "<!DOCTYPE doc SYSTEM 'foo'>\n"
1158 "<doc>&entity;</doc>";
1159 ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
1160
1161 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1162 XML_SetUserData(g_parser, &test_data);
1163 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
1164 XML_SetNotStandaloneHandler(g_parser, reject_not_standalone_handler);
1165 expect_failure(text, XML_ERROR_NOT_STANDALONE,
1166 "NotStandalone handler failed to reject");
1167
1168 /* Try again but without external entity handling */
1169 XML_ParserReset(g_parser, NULL);
1170 XML_SetNotStandaloneHandler(g_parser, reject_not_standalone_handler);
1171 expect_failure(text, XML_ERROR_NOT_STANDALONE,
1172 "NotStandalone handler failed to reject");
1173}
1174END_TEST
1175
1176/* Test that no error is reported if our NotStandalone handler succeeds */
1177START_TEST(test_not_standalone_handler_accept) {
1178 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
1179 "<!DOCTYPE doc SYSTEM 'foo'>\n"
1180 "<doc>&entity;</doc>";
1181 ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
1182
1183 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1184 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
1185 XML_SetNotStandaloneHandler(g_parser, accept_not_standalone_handler);
1186 run_ext_character_check(text, &test_data, XCS(""));
1187
1188 /* Repeat without the external entity handler */
1189 XML_ParserReset(g_parser, NULL);
1190 XML_SetNotStandaloneHandler(g_parser, accept_not_standalone_handler);
1191 run_character_check(text, XCS(""));
1192}
1193END_TEST
1194
1195START_TEST(test_entity_start_tag_level_greater_than_one) {
1196 const char *const text = "<!DOCTYPE t1 [\n"
1197 " <!ENTITY e1 'hello'>\n"
1198 "]>\n"
1199 "<t1>\n"
1200 " <t2>&e1;</t2>\n"
1201 "</t1>\n";
1202
1203 XML_Parser parser = XML_ParserCreate(NULL);
1204 assert_true(_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
1205 /*isFinal*/ XML_TRUE)
1206 == XML_STATUS_OK);
1207 XML_ParserFree(parser);
1208}
1209END_TEST
1210
1211START_TEST(test_wfc_no_recursive_entity_refs) {
1212 const char *text = "<!DOCTYPE doc [\n"
1213 " <!ENTITY entity '&entity;'>\n"
1214 "]>\n"
1215 "<doc>&entity;</doc>";
1216
1217 expect_failure(text, XML_ERROR_RECURSIVE_ENTITY_REF,
1218 "Parser did not report recursive entity reference.");
1219}
1220END_TEST
1221
1222START_TEST(test_no_indirectly_recursive_entity_refs) {
1223 struct TestCase {
1224 const char *doc;
1225 bool usesParameterEntities;
1226 };
1227
1228 const struct TestCase cases[] = {
1229 // general entity + character data
1230 {"<!DOCTYPE a [\n"
1231 " <!ENTITY e1 '&e2;'>\n"
1232 " <!ENTITY e2 '&e1;'>\n"
1233 "]><a>&e2;</a>\n",
1234 false},
1235
1236 // general entity + attribute value
1237 {"<!DOCTYPE a [\n"
1238 " <!ENTITY e1 '&e2;'>\n"
1239 " <!ENTITY e2 '&e1;'>\n"
1240 "]><a k1='&e2;' />\n",
1241 false},
1242
1243 // parameter entity
1244 {"<!DOCTYPE doc [\n"
1245 " <!ENTITY % p1 '%p2;'>\n"
1246 " <!ENTITY % p2 '%p1;'>\n"
1247 " <!ENTITY % define_g \"<!ENTITY g '%p2;'>\">\n"
1248 " %define_g;\n"
1249 "]>\n"
1250 "<doc/>\n",
1251 true},
1252 };
1253 const XML_Bool reset_or_not[] = {XML_TRUE, XML_FALSE};
1254
1255 for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
1256 for (size_t j = 0; j < sizeof(reset_or_not) / sizeof(reset_or_not[0]);
1257 j++) {
1258 const XML_Bool reset_wanted = reset_or_not[j];
1259 const char *const doc = cases[i].doc;
1260 const bool usesParameterEntities = cases[i].usesParameterEntities;
1261
1262 set_subtest("[%i,reset=%i] %s", (int)i, (int)j, doc);
1263
1264#ifdef XML_DTD // both GE and DTD
1265 const bool rejection_expected = true;
1266#elif XML_GE == 1 // GE but not DTD
1267 const bool rejection_expected = ! usesParameterEntities;
1268#else // neither DTD nor GE
1269 const bool rejection_expected = false;
1270#endif
1271
1272 XML_Parser parser = XML_ParserCreate(NULL);
1273
1274#ifdef XML_DTD
1275 if (usesParameterEntities) {
1276 assert_true(
1277 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS)
1278 == 1);
1279 }
1280#else
1281 UNUSED_P(usesParameterEntities);
1282#endif // XML_DTD
1283
1284 const enum XML_Status status
1285 = _XML_Parse_SINGLE_BYTES(parser, doc, (int)strlen(doc),
1286 /*isFinal*/ XML_TRUE);
1287
1288 if (rejection_expected) {
1289 assert_true(status == XML_STATUS_ERROR);
1290 assert_true(XML_GetErrorCode(parser) == XML_ERROR_RECURSIVE_ENTITY_REF);
1291 } else {
1292 assert_true(status == XML_STATUS_OK);
1293 }
1294
1295 if (reset_wanted) {
1296 // This covers free'ing of (eventually) all three open entity lists by
1297 // XML_ParserReset.
1298 XML_ParserReset(parser, NULL);
1299 }
1300
1301 // This covers free'ing of (eventually) all three open entity lists by
1302 // XML_ParserFree (unless XML_ParserReset has already done that above).
1303 XML_ParserFree(parser);
1304 }
1305 }
1306}
1307END_TEST
1308
1309START_TEST(test_recursive_external_parameter_entity_2) {
1310 struct TestCase {
1311 const char *doc;
1312 enum XML_Status expectedStatus;
1313 };
1314
1315 struct TestCase cases[] = {
1316 {"<!ENTITY % p1 '%p1;'>", XML_STATUS_ERROR},
1317 {"<!ENTITY % p1 '%p1;'>"
1318 "<!ENTITY % p1 'first declaration wins'>",
1319 XML_STATUS_ERROR},
1320 {"<!ENTITY % p1 'first declaration wins'>"
1321 "<!ENTITY % p1 '%p1;'>",
1322 XML_STATUS_OK},
1323 {"<!ENTITY % p1 '%p1;'>", XML_STATUS_OK},
1324 };
1325
1326 for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
1327 const char *const doc = cases[i].doc;
1328 const enum XML_Status expectedStatus = cases[i].expectedStatus;
1329 set_subtest("%s", doc);
1330
1331 XML_Parser parser = XML_ParserCreate(NULL);
1332 assert_true(parser != NULL);
1333
1334 XML_Parser ext_parser = XML_ExternalEntityParserCreate(parser, NULL, NULL);
1335 assert_true(ext_parser != NULL);
1336
1337 const enum XML_Status actualStatus
1338 = _XML_Parse_SINGLE_BYTES(ext_parser, doc, (int)strlen(doc), XML_TRUE);
1339
1340 assert_true(actualStatus == expectedStatus);
1341 if (actualStatus != XML_STATUS_OK) {
1342 assert_true(XML_GetErrorCode(ext_parser)
1343 == XML_ERROR_RECURSIVE_ENTITY_REF);
1344 }
1345
1346 XML_ParserFree(ext_parser);
1347 XML_ParserFree(parser);
1348 }
1349}
1350END_TEST
1351
1352/* Test incomplete external entities are faulted */
1353START_TEST(test_ext_entity_invalid_parse) {
1354 const char *text = "<!DOCTYPE doc [\n"
1355 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
1356 "]>\n"
1357 "<doc>&en;</doc>";
1358 const ExtFaults faults[]
1359 = {{"<", "Incomplete element declaration not faulted", NULL,
1360 XML_ERROR_UNCLOSED_TOKEN},
1361 {"<\xe2\x82", /* First two bytes of a three-byte char */
1362 "Incomplete character not faulted", NULL, XML_ERROR_PARTIAL_CHAR},
1363 {"<tag>\xe2\x82", "Incomplete character in CDATA not faulted", NULL,
1364 XML_ERROR_PARTIAL_CHAR},
1365 {NULL, NULL, NULL, XML_ERROR_NONE}};
1366 const ExtFaults *fault = faults;
1367
1368 for (; fault->parse_text != NULL; fault++) {
1369 set_subtest("\"%s\"", fault->parse_text);
1370 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1371 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
1372 XML_SetUserData(g_parser, (void *)fault);
1373 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
1374 "Parser did not report external entity error");
1375 XML_ParserReset(g_parser, NULL);
1376 }
1377}
1378END_TEST
1379
1380/* Regression test for SF bug #483514. */
1381START_TEST(test_dtd_default_handling) {
1382 const char *text = "<!DOCTYPE doc [\n"
1383 "<!ENTITY e SYSTEM 'http://example.org/e'>\n"
1384 "<!NOTATION n SYSTEM 'http://example.org/n'>\n"
1385 "<!ELEMENT doc EMPTY>\n"
1386 "<!ATTLIST doc a CDATA #IMPLIED>\n"
1387 "<?pi in dtd?>\n"
1388 "<!--comment in dtd-->\n"
1389 "]><doc/>";
1390
1391 XML_SetDefaultHandler(g_parser, accumulate_characters);
1392 XML_SetStartDoctypeDeclHandler(g_parser, dummy_start_doctype_handler);
1393 XML_SetEndDoctypeDeclHandler(g_parser, dummy_end_doctype_handler);
1394 XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
1395 XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
1396 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
1397 XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
1398 XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
1399 XML_SetCommentHandler(g_parser, dummy_comment_handler);
1400 XML_SetStartCdataSectionHandler(g_parser, dummy_start_cdata_handler);
1401 XML_SetEndCdataSectionHandler(g_parser, dummy_end_cdata_handler);
1402 run_character_check(text, XCS("\n\n\n\n\n\n\n<doc/>"));
1403}
1404END_TEST
1405
1406/* Test handling of attribute declarations */
1407START_TEST(test_dtd_attr_handling) {
1408 const char *prolog = "<!DOCTYPE doc [\n"
1409 "<!ELEMENT doc EMPTY>\n";
1410 AttTest attr_data[]
1411 = {{"<!ATTLIST doc a ( one | two | three ) #REQUIRED>\n"
1412 "]>"
1413 "<doc a='two'/>",
1414 XCS("doc"), XCS("a"),
1415 XCS("(one|two|three)"), /* Extraneous spaces will be removed */
1416 NULL, XML_TRUE},
1417 {"<!NOTATION foo SYSTEM 'http://example.org/foo'>\n"
1418 "<!ATTLIST doc a NOTATION (foo) #IMPLIED>\n"
1419 "]>"
1420 "<doc/>",
1421 XCS("doc"), XCS("a"), XCS("NOTATION(foo)"), NULL, XML_FALSE},
1422 {"<!ATTLIST doc a NOTATION (foo) 'bar'>\n"
1423 "]>"
1424 "<doc/>",
1425 XCS("doc"), XCS("a"), XCS("NOTATION(foo)"), XCS("bar"), XML_FALSE},
1426 {"<!ATTLIST doc a CDATA '\xdb\xb2'>\n"
1427 "]>"
1428 "<doc/>",
1429 XCS("doc"), XCS("a"), XCS("CDATA"),
1430#ifdef XML_UNICODE
1431 XCS("\x06f2"),
1432#else
1433 XCS("\xdb\xb2"),
1434#endif
1435 XML_FALSE},
1436 {NULL, NULL, NULL, NULL, NULL, XML_FALSE}};
1437 AttTest *test;
1438
1439 for (test = attr_data; test->definition != NULL; test++) {
1440 set_subtest("%s", test->definition);
1441 XML_SetAttlistDeclHandler(g_parser, verify_attlist_decl_handler);
1442 XML_SetUserData(g_parser, test);
1443 if (_XML_Parse_SINGLE_BYTES(g_parser, prolog, (int)strlen(prolog),
1444 XML_FALSE)
1445 == XML_STATUS_ERROR)
1446 xml_failure(g_parser);
1447 if (_XML_Parse_SINGLE_BYTES(g_parser, test->definition,
1448 (int)strlen(test->definition), XML_TRUE)
1449 == XML_STATUS_ERROR)
1450 xml_failure(g_parser);
1451 XML_ParserReset(g_parser, NULL);
1452 }
1453}
1454END_TEST
1455
1456/* See related SF bug #673791.
1457 When namespace processing is enabled, setting the namespace URI for
1458 a prefix is not allowed; this test ensures that it *is* allowed
1459 when namespace processing is not enabled.
1460 (See Namespaces in XML, section 2.)
1461*/
1462START_TEST(test_empty_ns_without_namespaces) {
1463 const char *text = "<doc xmlns:prefix='http://example.org/'>\n"
1464 " <e xmlns:prefix=''/>\n"
1465 "</doc>";
1466
1467 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1468 == XML_STATUS_ERROR)
1469 xml_failure(g_parser);
1470}
1471END_TEST
1472
1473/* Regression test for SF bug #824420.
1474 Checks that an xmlns:prefix attribute set in an attribute's default
1475 value isn't misinterpreted.
1476*/
1477START_TEST(test_ns_in_attribute_default_without_namespaces) {
1478 const char *text = "<!DOCTYPE e:element [\n"
1479 " <!ATTLIST e:element\n"
1480 " xmlns:e CDATA 'http://example.org/'>\n"
1481 " ]>\n"
1482 "<e:element/>";
1483
1484 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1485 == XML_STATUS_ERROR)
1486 xml_failure(g_parser);
1487}
1488END_TEST
1489
1490/* Regression test for SF bug #1515266: missing check of stopped
1491 parser in doContext() 'for' loop. */
1492START_TEST(test_stop_parser_between_char_data_calls) {
1493 /* The sample data must be big enough that there are two calls to
1494 the character data handler from within the inner "for" loop of
1495 the XML_TOK_DATA_CHARS case in doContent(), and the character
1496 handler must stop the parser and clear the character data
1497 handler.
1498 */
1499 const char *text = long_character_data_text;
1500
1501 XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
1502 g_resumable = XML_FALSE;
1503 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1504 != XML_STATUS_ERROR)
1505 xml_failure(g_parser);
1506 if (XML_GetErrorCode(g_parser) != XML_ERROR_ABORTED)
1507 xml_failure(g_parser);
1508}
1509END_TEST
1510
1511/* Regression test for SF bug #1515266: missing check of stopped
1512 parser in doContext() 'for' loop. */
1513START_TEST(test_suspend_parser_between_char_data_calls) {
1514 /* The sample data must be big enough that there are two calls to
1515 the character data handler from within the inner "for" loop of
1516 the XML_TOK_DATA_CHARS case in doContent(), and the character
1517 handler must stop the parser and clear the character data
1518 handler.
1519 */
1520 const char *text = long_character_data_text;
1521
1522 XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
1523 g_resumable = XML_TRUE;
1524 // can't use SINGLE_BYTES here, because it'll return early on suspension, and
1525 // we won't know exactly how much input we actually managed to give Expat.
1526 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
1527 != XML_STATUS_SUSPENDED)
1528 xml_failure(g_parser);
1529 if (XML_GetErrorCode(g_parser) != XML_ERROR_NONE)
1530 xml_failure(g_parser);
1531 /* Try parsing directly */
1532 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1533 != XML_STATUS_ERROR)
1534 fail("Attempt to continue parse while suspended not faulted");
1535 if (XML_GetErrorCode(g_parser) != XML_ERROR_SUSPENDED)
1536 fail("Suspended parse not faulted with correct error");
1537}
1538END_TEST
1539
1540/* Test repeated calls to XML_StopParser are handled correctly */
1541START_TEST(test_repeated_stop_parser_between_char_data_calls) {
1542 const char *text = long_character_data_text;
1543
1544 XML_SetCharacterDataHandler(g_parser, parser_stop_character_handler);
1545 g_resumable = XML_FALSE;
1546 g_abortable = XML_FALSE;
1547 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1548 != XML_STATUS_ERROR)
1549 fail("Failed to double-stop parser");
1550
1551 XML_ParserReset(g_parser, NULL);
1552 XML_SetCharacterDataHandler(g_parser, parser_stop_character_handler);
1553 g_resumable = XML_TRUE;
1554 g_abortable = XML_FALSE;
1555 // can't use SINGLE_BYTES here, because it'll return early on suspension, and
1556 // we won't know exactly how much input we actually managed to give Expat.
1557 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
1558 != XML_STATUS_SUSPENDED)
1559 fail("Failed to double-suspend parser");
1560
1561 XML_ParserReset(g_parser, NULL);
1562 XML_SetCharacterDataHandler(g_parser, parser_stop_character_handler);
1563 g_resumable = XML_TRUE;
1564 g_abortable = XML_TRUE;
1565 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1566 != XML_STATUS_ERROR)
1567 fail("Failed to suspend-abort parser");
1568}
1569END_TEST
1570
1571START_TEST(test_good_cdata_ascii) {
1572 const char *text = "<a><![CDATA[<greeting>Hello, world!</greeting>]]></a>";
1573 const XML_Char *expected = XCS("<greeting>Hello, world!</greeting>");
1574
1575 CharData storage;
1576 CharData_Init(&storage);
1577 XML_SetUserData(g_parser, &storage);
1578 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
1579 /* Add start and end handlers for coverage */
1580 XML_SetStartCdataSectionHandler(g_parser, dummy_start_cdata_handler);
1581 XML_SetEndCdataSectionHandler(g_parser, dummy_end_cdata_handler);
1582
1583 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1584 == XML_STATUS_ERROR)
1585 xml_failure(g_parser);
1586 CharData_CheckXMLChars(&storage, expected);
1587
1588 /* Try again, this time with a default handler */
1589 XML_ParserReset(g_parser, NULL);
1590 CharData_Init(&storage);
1591 XML_SetUserData(g_parser, &storage);
1592 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
1593 XML_SetDefaultHandler(g_parser, dummy_default_handler);
1594
1595 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1596 == XML_STATUS_ERROR)
1597 xml_failure(g_parser);
1598 CharData_CheckXMLChars(&storage, expected);
1599}
1600END_TEST
1601
1602START_TEST(test_good_cdata_utf16) {
1603 /* Test data is:
1604 * <?xml version='1.0' encoding='utf-16'?>
1605 * <a><![CDATA[hello]]></a>
1606 */
1607 const char text[]
1608 = "\0<\0?\0x\0m\0l\0"
1609 " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
1610 " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
1611 "1\0"
1612 "6\0'"
1613 "\0?\0>\0\n"
1614 "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0[\0h\0e\0l\0l\0o\0]\0]\0>\0<\0/\0a\0>";
1615 const XML_Char *expected = XCS("hello");
1616
1617 CharData storage;
1618 CharData_Init(&storage);
1619 XML_SetUserData(g_parser, &storage);
1620 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
1621
1622 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
1623 == XML_STATUS_ERROR)
1624 xml_failure(g_parser);
1625 CharData_CheckXMLChars(&storage, expected);
1626}
1627END_TEST
1628
1629START_TEST(test_good_cdata_utf16_le) {
1630 /* Test data is:
1631 * <?xml version='1.0' encoding='utf-16'?>
1632 * <a><![CDATA[hello]]></a>
1633 */
1634 const char text[]
1635 = "<\0?\0x\0m\0l\0"
1636 " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
1637 " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
1638 "1\0"
1639 "6\0'"
1640 "\0?\0>\0\n"
1641 "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0[\0h\0e\0l\0l\0o\0]\0]\0>\0<\0/\0a\0>\0";
1642 const XML_Char *expected = XCS("hello");
1643
1644 CharData storage;
1645 CharData_Init(&storage);
1646 XML_SetUserData(g_parser, &storage);
1647 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
1648
1649 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
1650 == XML_STATUS_ERROR)
1651 xml_failure(g_parser);
1652 CharData_CheckXMLChars(&storage, expected);
1653}
1654END_TEST
1655
1656/* Test UTF16 conversion of a long cdata string */
1657
1658/* 16 characters: handy macro to reduce visual clutter */
1659#define A_TO_P_IN_UTF16 "\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P"
1660
1661START_TEST(test_long_cdata_utf16) {
1662 /* Test data is:
1663 * <?xlm version='1.0' encoding='utf-16'?>
1664 * <a><![CDATA[
1665 * ABCDEFGHIJKLMNOP
1666 * ]]></a>
1667 */
1668 const char text[]
1669 = "\0<\0?\0x\0m\0l\0 "
1670 "\0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0 "
1671 "\0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0\x31\0\x36\0'\0?\0>"
1672 "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
1673 /* 64 characters per line */
1674 /* clang-format off */
1675 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1676 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1677 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1678 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1679 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1680 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1681 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1682 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1683 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1684 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1685 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1686 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1687 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1688 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1689 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1690 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
1691 A_TO_P_IN_UTF16
1692 /* clang-format on */
1693 "\0]\0]\0>\0<\0/\0a\0>";
1694 const XML_Char *expected =
1695 /* clang-format off */
1696 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1697 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1698 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1699 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1700 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1701 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1702 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1703 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1704 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1705 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1706 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1707 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1708 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1709 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1710 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1711 XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
1712 XCS("ABCDEFGHIJKLMNOP");
1713 /* clang-format on */
1714 CharData storage;
1715 void *buffer;
1716
1717 CharData_Init(&storage);
1718 XML_SetUserData(g_parser, &storage);
1719 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
1720 buffer = XML_GetBuffer(g_parser, sizeof(text) - 1);
1721 if (buffer == NULL)
1722 fail("Could not allocate parse buffer");
1723 assert(buffer != NULL);
1724 memcpy(buffer, text, sizeof(text) - 1);
1725 if (XML_ParseBuffer(g_parser, sizeof(text) - 1, XML_TRUE) == XML_STATUS_ERROR)
1726 xml_failure(g_parser);
1727 CharData_CheckXMLChars(&storage, expected);
1728}
1729END_TEST
1730
1731/* Test handling of multiple unit UTF-16 characters */
1732START_TEST(test_multichar_cdata_utf16) {
1733 /* Test data is:
1734 * <?xml version='1.0' encoding='utf-16'?>
1735 * <a><![CDATA[{MINIM}{CROTCHET}]]></a>
1736 *
1737 * where {MINIM} is U+1d15e (a minim or half-note)
1738 * UTF-16: 0xd834 0xdd5e
1739 * UTF-8: 0xf0 0x9d 0x85 0x9e
1740 * and {CROTCHET} is U+1d15f (a crotchet or quarter-note)
1741 * UTF-16: 0xd834 0xdd5f
1742 * UTF-8: 0xf0 0x9d 0x85 0x9f
1743 */
1744 const char text[] = "\0<\0?\0x\0m\0l\0"
1745 " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
1746 " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
1747 "1\0"
1748 "6\0'"
1749 "\0?\0>\0\n"
1750 "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
1751 "\xd8\x34\xdd\x5e\xd8\x34\xdd\x5f"
1752 "\0]\0]\0>\0<\0/\0a\0>";
1753#ifdef XML_UNICODE
1754 const XML_Char *expected = XCS("\xd834\xdd5e\xd834\xdd5f");
1755#else
1756 const XML_Char *expected = XCS("\xf0\x9d\x85\x9e\xf0\x9d\x85\x9f");
1757#endif
1758 CharData storage;
1759
1760 CharData_Init(&storage);
1761 XML_SetUserData(g_parser, &storage);
1762 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
1763
1764 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
1765 == XML_STATUS_ERROR)
1766 xml_failure(g_parser);
1767 CharData_CheckXMLChars(&storage, expected);
1768}
1769END_TEST
1770
1771/* Test that an element name with a UTF-16 surrogate pair is rejected */
1772START_TEST(test_utf16_bad_surrogate_pair) {
1773 /* Test data is:
1774 * <?xml version='1.0' encoding='utf-16'?>
1775 * <a><![CDATA[{BADLINB}]]></a>
1776 *
1777 * where {BADLINB} is U+10000 (the first Linear B character)
1778 * with the UTF-16 surrogate pair in the wrong order, i.e.
1779 * 0xdc00 0xd800
1780 */
1781 const char text[] = "\0<\0?\0x\0m\0l\0"
1782 " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
1783 " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
1784 "1\0"
1785 "6\0'"
1786 "\0?\0>\0\n"
1787 "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
1788 "\xdc\x00\xd8\x00"
1789 "\0]\0]\0>\0<\0/\0a\0>";
1790
1791 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
1792 != XML_STATUS_ERROR)
1793 fail("Reversed UTF-16 surrogate pair not faulted");
1794 if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
1795 xml_failure(g_parser);
1796}
1797END_TEST
1798
1799START_TEST(test_bad_cdata) {
1800 struct CaseData {
1801 const char *text;
1802 enum XML_Error expectedError;
1803 };
1804
1805 struct CaseData cases[]
1806 = {{"<a><", XML_ERROR_UNCLOSED_TOKEN},
1807 {"<a><!", XML_ERROR_UNCLOSED_TOKEN},
1808 {"<a><![", XML_ERROR_UNCLOSED_TOKEN},
1809 {"<a><![C", XML_ERROR_UNCLOSED_TOKEN},
1810 {"<a><![CD", XML_ERROR_UNCLOSED_TOKEN},
1811 {"<a><![CDA", XML_ERROR_UNCLOSED_TOKEN},
1812 {"<a><![CDAT", XML_ERROR_UNCLOSED_TOKEN},
1813 {"<a><![CDATA", XML_ERROR_UNCLOSED_TOKEN},
1814
1815 {"<a><![CDATA[", XML_ERROR_UNCLOSED_CDATA_SECTION},
1816 {"<a><![CDATA[]", XML_ERROR_UNCLOSED_CDATA_SECTION},
1817 {"<a><![CDATA[]]", XML_ERROR_UNCLOSED_CDATA_SECTION},
1818
1819 {"<a><!<a/>", XML_ERROR_INVALID_TOKEN},
1820 {"<a><![<a/>", XML_ERROR_UNCLOSED_TOKEN}, /* ?! */
1821 {"<a><![C<a/>", XML_ERROR_UNCLOSED_TOKEN}, /* ?! */
1822 {"<a><![CD<a/>", XML_ERROR_INVALID_TOKEN},
1823 {"<a><![CDA<a/>", XML_ERROR_INVALID_TOKEN},
1824 {"<a><![CDAT<a/>", XML_ERROR_INVALID_TOKEN},
1825 {"<a><![CDATA<a/>", XML_ERROR_INVALID_TOKEN},
1826
1827 {"<a><![CDATA[<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION},
1828 {"<a><![CDATA[]<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION},
1829 {"<a><![CDATA[]]<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION}};
1830
1831 size_t i = 0;
1832 for (; i < sizeof(cases) / sizeof(struct CaseData); i++) {
1833 set_subtest("%s", cases[i].text);
1834 const enum XML_Status actualStatus = _XML_Parse_SINGLE_BYTES(
1835 g_parser, cases[i].text, (int)strlen(cases[i].text), XML_TRUE);
1836 const enum XML_Error actualError = XML_GetErrorCode(g_parser);
1837
1838 assert(actualStatus == XML_STATUS_ERROR);
1839
1840 if (actualError != cases[i].expectedError) {
1841 char message[100];
1842 snprintf(message, sizeof(message),
1843 "Expected error %d but got error %d for case %u: \"%s\"\n",
1844 cases[i].expectedError, actualError, (unsigned int)i + 1,
1845 cases[i].text);
1846 fail(message);
1847 }
1848
1849 XML_ParserReset(g_parser, NULL);
1850 }
1851}
1852END_TEST
1853
1854/* Test failures in UTF-16 CDATA */
1855START_TEST(test_bad_cdata_utf16) {
1856 struct CaseData {
1857 size_t text_bytes;
1858 const char *text;
1859 enum XML_Error expected_error;
1860 };
1861
1862 const char prolog[] = "\0<\0?\0x\0m\0l\0"
1863 " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
1864 " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
1865 "1\0"
1866 "6\0'"
1867 "\0?\0>\0\n"
1868 "\0<\0a\0>";
1869 struct CaseData cases[] = {
1870 {1, "\0", XML_ERROR_UNCLOSED_TOKEN},
1871 {2, "\0<", XML_ERROR_UNCLOSED_TOKEN},
1872 {3, "\0<\0", XML_ERROR_UNCLOSED_TOKEN},
1873 {4, "\0<\0!", XML_ERROR_UNCLOSED_TOKEN},
1874 {5, "\0<\0!\0", XML_ERROR_UNCLOSED_TOKEN},
1875 {6, "\0<\0!\0[", XML_ERROR_UNCLOSED_TOKEN},
1876 {7, "\0<\0!\0[\0", XML_ERROR_UNCLOSED_TOKEN},
1877 {8, "\0<\0!\0[\0C", XML_ERROR_UNCLOSED_TOKEN},
1878 {9, "\0<\0!\0[\0C\0", XML_ERROR_UNCLOSED_TOKEN},
1879 {10, "\0<\0!\0[\0C\0D", XML_ERROR_UNCLOSED_TOKEN},
1880 {11, "\0<\0!\0[\0C\0D\0", XML_ERROR_UNCLOSED_TOKEN},
1881 {12, "\0<\0!\0[\0C\0D\0A", XML_ERROR_UNCLOSED_TOKEN},
1882 {13, "\0<\0!\0[\0C\0D\0A\0", XML_ERROR_UNCLOSED_TOKEN},
1883 {14, "\0<\0!\0[\0C\0D\0A\0T", XML_ERROR_UNCLOSED_TOKEN},
1884 {15, "\0<\0!\0[\0C\0D\0A\0T\0", XML_ERROR_UNCLOSED_TOKEN},
1885 {16, "\0<\0!\0[\0C\0D\0A\0T\0A", XML_ERROR_UNCLOSED_TOKEN},
1886 {17, "\0<\0!\0[\0C\0D\0A\0T\0A\0", XML_ERROR_UNCLOSED_TOKEN},
1887 {18, "\0<\0!\0[\0C\0D\0A\0T\0A\0[", XML_ERROR_UNCLOSED_CDATA_SECTION},
1888 {19, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0", XML_ERROR_UNCLOSED_CDATA_SECTION},
1889 {20, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z", XML_ERROR_UNCLOSED_CDATA_SECTION},
1890 /* Now add a four-byte UTF-16 character */
1891 {21, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8",
1892 XML_ERROR_UNCLOSED_CDATA_SECTION},
1893 {22, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34", XML_ERROR_PARTIAL_CHAR},
1894 {23, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34\xdd",
1895 XML_ERROR_PARTIAL_CHAR},
1896 {24, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34\xdd\x5e",
1897 XML_ERROR_UNCLOSED_CDATA_SECTION}};
1898 size_t i;
1899
1900 for (i = 0; i < sizeof(cases) / sizeof(struct CaseData); i++) {
1901 set_subtest("case %lu", (long unsigned)(i + 1));
1902 enum XML_Status actual_status;
1903 enum XML_Error actual_error;
1904
1905 if (_XML_Parse_SINGLE_BYTES(g_parser, prolog, (int)sizeof(prolog) - 1,
1906 XML_FALSE)
1907 == XML_STATUS_ERROR)
1908 xml_failure(g_parser);
1909 actual_status = _XML_Parse_SINGLE_BYTES(g_parser, cases[i].text,
1910 (int)cases[i].text_bytes, XML_TRUE);
1911 assert(actual_status == XML_STATUS_ERROR);
1912 actual_error = XML_GetErrorCode(g_parser);
1913 if (actual_error != cases[i].expected_error) {
1914 char message[1024];
1915
1916 snprintf(message, sizeof(message),
1917 "Expected error %d (%" XML_FMT_STR "), got %d (%" XML_FMT_STR
1918 ") for case %lu\n",
1919 cases[i].expected_error,
1920 XML_ErrorString(cases[i].expected_error), actual_error,
1921 XML_ErrorString(actual_error), (long unsigned)(i + 1));
1922 fail(message);
1923 }
1924 XML_ParserReset(g_parser, NULL);
1925 }
1926}
1927END_TEST
1928
1929/* Test stopping the parser in cdata handler */
1930START_TEST(test_stop_parser_between_cdata_calls) {
1931 const char *text = long_cdata_text;
1932
1933 XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
1934 g_resumable = XML_FALSE;
1935 expect_failure(text, XML_ERROR_ABORTED, "Parse not aborted in CDATA handler");
1936}
1937END_TEST
1938
1939/* Test suspending the parser in cdata handler */
1940START_TEST(test_suspend_parser_between_cdata_calls) {
1941 if (g_chunkSize != 0) {
1942 // this test does not use SINGLE_BYTES, because of suspension
1943 return;
1944 }
1945
1946 const char *text = long_cdata_text;
1947 enum XML_Status result;
1948
1949 XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
1950 g_resumable = XML_TRUE;
1951 // can't use SINGLE_BYTES here, because it'll return early on suspension, and
1952 // we won't know exactly how much input we actually managed to give Expat.
1953 result = XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE);
1954 if (result != XML_STATUS_SUSPENDED) {
1955 if (result == XML_STATUS_ERROR)
1956 xml_failure(g_parser);
1957 fail("Parse not suspended in CDATA handler");
1958 }
1959 if (XML_GetErrorCode(g_parser) != XML_ERROR_NONE)
1960 xml_failure(g_parser);
1961}
1962END_TEST
1963
1964/* Test memory allocation functions */
1965START_TEST(test_memory_allocation) {
1966 char *buffer = (char *)XML_MemMalloc(g_parser, 256);
1967 char *p;
1968
1969 if (buffer == NULL) {
1970 fail("Allocation failed");
1971 } else {
1972 /* Try writing to memory; some OSes try to cheat! */
1973 buffer[0] = 'T';
1974 buffer[1] = 'E';
1975 buffer[2] = 'S';
1976 buffer[3] = 'T';
1977 buffer[4] = '\0';
1978 if (strcmp(buffer, "TEST") != 0) {
1979 fail("Memory not writable");
1980 } else {
1981 p = (char *)XML_MemRealloc(g_parser, buffer, 512);
1982 if (p == NULL) {
1983 fail("Reallocation failed");
1984 } else {
1985 /* Write again, just to be sure */
1986 buffer = p;
1987 buffer[0] = 'V';
1988 if (strcmp(buffer, "VEST") != 0) {
1989 fail("Reallocated memory not writable");
1990 }
1991 }
1992 }
1993 XML_MemFree(g_parser, buffer);
1994 }
1995}
1996END_TEST
1997
1998/* Test XML_DefaultCurrent() passes handling on correctly */
1999START_TEST(test_default_current) {
2000 const char *text = "<doc>hell]</doc>";
2001 const char *entity_text = "<!DOCTYPE doc [\n"
2002 "<!ENTITY entity '%'>\n"
2003 "]>\n"
2004 "<doc>&entity;</doc>";
2005
2006 set_subtest("with defaulting");
2007 {
2008 struct handler_record_list storage;
2009 storage.count = 0;
2010 XML_SetDefaultHandler(g_parser, record_default_handler);
2011 XML_SetCharacterDataHandler(g_parser, record_cdata_handler);
2012 XML_SetUserData(g_parser, &storage);
2013 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2014 == XML_STATUS_ERROR)
2015 xml_failure(g_parser);
2016 int i = 0;
2017 assert_record_handler_called(&storage, i++, "record_default_handler", 5);
2018 // we should have gotten one or more cdata callbacks, totaling 5 chars
2019 int cdata_len_remaining = 5;
2020 while (cdata_len_remaining > 0) {
2021 const struct handler_record_entry *c_entry
2022 = handler_record_get(&storage, i++);
2023 assert_true(strcmp(c_entry->name, "record_cdata_handler") == 0);
2024 assert_true(c_entry->arg > 0);
2025 assert_true(c_entry->arg <= cdata_len_remaining);
2026 cdata_len_remaining -= c_entry->arg;
2027 // default handler must follow, with the exact same len argument.
2028 assert_record_handler_called(&storage, i++, "record_default_handler",
2029 c_entry->arg);
2030 }
2031 assert_record_handler_called(&storage, i++, "record_default_handler", 6);
2032 assert_true(storage.count == i);
2033 }
2034
2035 /* Again, without the defaulting */
2036 set_subtest("no defaulting");
2037 {
2038 struct handler_record_list storage;
2039 storage.count = 0;
2040 XML_ParserReset(g_parser, NULL);
2041 XML_SetDefaultHandler(g_parser, record_default_handler);
2042 XML_SetCharacterDataHandler(g_parser, record_cdata_nodefault_handler);
2043 XML_SetUserData(g_parser, &storage);
2044 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2045 == XML_STATUS_ERROR)
2046 xml_failure(g_parser);
2047 int i = 0;
2048 assert_record_handler_called(&storage, i++, "record_default_handler", 5);
2049 // we should have gotten one or more cdata callbacks, totaling 5 chars
2050 int cdata_len_remaining = 5;
2051 while (cdata_len_remaining > 0) {
2052 const struct handler_record_entry *c_entry
2053 = handler_record_get(&storage, i++);
2054 assert_true(strcmp(c_entry->name, "record_cdata_nodefault_handler") == 0);
2055 assert_true(c_entry->arg > 0);
2056 assert_true(c_entry->arg <= cdata_len_remaining);
2057 cdata_len_remaining -= c_entry->arg;
2058 }
2059 assert_record_handler_called(&storage, i++, "record_default_handler", 6);
2060 assert_true(storage.count == i);
2061 }
2062
2063 /* Now with an internal entity to complicate matters */
2064 set_subtest("with internal entity");
2065 {
2066 struct handler_record_list storage;
2067 storage.count = 0;
2068 XML_ParserReset(g_parser, NULL);
2069 XML_SetDefaultHandler(g_parser, record_default_handler);
2070 XML_SetCharacterDataHandler(g_parser, record_cdata_handler);
2071 XML_SetUserData(g_parser, &storage);
2072 if (_XML_Parse_SINGLE_BYTES(g_parser, entity_text, (int)strlen(entity_text),
2073 XML_TRUE)
2074 == XML_STATUS_ERROR)
2075 xml_failure(g_parser);
2076 /* The default handler suppresses the entity */
2077 assert_record_handler_called(&storage, 0, "record_default_handler", 9);
2078 assert_record_handler_called(&storage, 1, "record_default_handler", 1);
2079 assert_record_handler_called(&storage, 2, "record_default_handler", 3);
2080 assert_record_handler_called(&storage, 3, "record_default_handler", 1);
2081 assert_record_handler_called(&storage, 4, "record_default_handler", 1);
2082 assert_record_handler_called(&storage, 5, "record_default_handler", 1);
2083 assert_record_handler_called(&storage, 6, "record_default_handler", 8);
2084 assert_record_handler_called(&storage, 7, "record_default_handler", 1);
2085 assert_record_handler_called(&storage, 8, "record_default_handler", 6);
2086 assert_record_handler_called(&storage, 9, "record_default_handler", 1);
2087 assert_record_handler_called(&storage, 10, "record_default_handler", 7);
2088 assert_record_handler_called(&storage, 11, "record_default_handler", 1);
2089 assert_record_handler_called(&storage, 12, "record_default_handler", 1);
2090 assert_record_handler_called(&storage, 13, "record_default_handler", 1);
2091 assert_record_handler_called(&storage, 14, "record_default_handler", 1);
2092 assert_record_handler_called(&storage, 15, "record_default_handler", 1);
2093 assert_record_handler_called(&storage, 16, "record_default_handler", 5);
2094 assert_record_handler_called(&storage, 17, "record_default_handler", 8);
2095 assert_record_handler_called(&storage, 18, "record_default_handler", 6);
2096 assert_true(storage.count == 19);
2097 }
2098
2099 /* Again, with a skip handler */
2100 set_subtest("with skip handler");
2101 {
2102 struct handler_record_list storage;
2103 storage.count = 0;
2104 XML_ParserReset(g_parser, NULL);
2105 XML_SetDefaultHandler(g_parser, record_default_handler);
2106 XML_SetCharacterDataHandler(g_parser, record_cdata_handler);
2107 XML_SetSkippedEntityHandler(g_parser, record_skip_handler);
2108 XML_SetUserData(g_parser, &storage);
2109 if (_XML_Parse_SINGLE_BYTES(g_parser, entity_text, (int)strlen(entity_text),
2110 XML_TRUE)
2111 == XML_STATUS_ERROR)
2112 xml_failure(g_parser);
2113 /* The default handler suppresses the entity */
2114 assert_record_handler_called(&storage, 0, "record_default_handler", 9);
2115 assert_record_handler_called(&storage, 1, "record_default_handler", 1);
2116 assert_record_handler_called(&storage, 2, "record_default_handler", 3);
2117 assert_record_handler_called(&storage, 3, "record_default_handler", 1);
2118 assert_record_handler_called(&storage, 4, "record_default_handler", 1);
2119 assert_record_handler_called(&storage, 5, "record_default_handler", 1);
2120 assert_record_handler_called(&storage, 6, "record_default_handler", 8);
2121 assert_record_handler_called(&storage, 7, "record_default_handler", 1);
2122 assert_record_handler_called(&storage, 8, "record_default_handler", 6);
2123 assert_record_handler_called(&storage, 9, "record_default_handler", 1);
2124 assert_record_handler_called(&storage, 10, "record_default_handler", 7);
2125 assert_record_handler_called(&storage, 11, "record_default_handler", 1);
2126 assert_record_handler_called(&storage, 12, "record_default_handler", 1);
2127 assert_record_handler_called(&storage, 13, "record_default_handler", 1);
2128 assert_record_handler_called(&storage, 14, "record_default_handler", 1);
2129 assert_record_handler_called(&storage, 15, "record_default_handler", 1);
2130 assert_record_handler_called(&storage, 16, "record_default_handler", 5);
2131 assert_record_handler_called(&storage, 17, "record_skip_handler", 0);
2132 assert_record_handler_called(&storage, 18, "record_default_handler", 6);
2133 assert_true(storage.count == 19);
2134 }
2135
2136 /* This time, allow the entity through */
2137 set_subtest("allow entity");
2138 {
2139 struct handler_record_list storage;
2140 storage.count = 0;
2141 XML_ParserReset(g_parser, NULL);
2142 XML_SetDefaultHandlerExpand(g_parser, record_default_handler);
2143 XML_SetCharacterDataHandler(g_parser, record_cdata_handler);
2144 XML_SetUserData(g_parser, &storage);
2145 if (_XML_Parse_SINGLE_BYTES(g_parser, entity_text, (int)strlen(entity_text),
2146 XML_TRUE)
2147 == XML_STATUS_ERROR)
2148 xml_failure(g_parser);
2149 assert_record_handler_called(&storage, 0, "record_default_handler", 9);
2150 assert_record_handler_called(&storage, 1, "record_default_handler", 1);
2151 assert_record_handler_called(&storage, 2, "record_default_handler", 3);
2152 assert_record_handler_called(&storage, 3, "record_default_handler", 1);
2153 assert_record_handler_called(&storage, 4, "record_default_handler", 1);
2154 assert_record_handler_called(&storage, 5, "record_default_handler", 1);
2155 assert_record_handler_called(&storage, 6, "record_default_handler", 8);
2156 assert_record_handler_called(&storage, 7, "record_default_handler", 1);
2157 assert_record_handler_called(&storage, 8, "record_default_handler", 6);
2158 assert_record_handler_called(&storage, 9, "record_default_handler", 1);
2159 assert_record_handler_called(&storage, 10, "record_default_handler", 7);
2160 assert_record_handler_called(&storage, 11, "record_default_handler", 1);
2161 assert_record_handler_called(&storage, 12, "record_default_handler", 1);
2162 assert_record_handler_called(&storage, 13, "record_default_handler", 1);
2163 assert_record_handler_called(&storage, 14, "record_default_handler", 1);
2164 assert_record_handler_called(&storage, 15, "record_default_handler", 1);
2165 assert_record_handler_called(&storage, 16, "record_default_handler", 5);
2166 assert_record_handler_called(&storage, 17, "record_cdata_handler", 1);
2167 assert_record_handler_called(&storage, 18, "record_default_handler", 1);
2168 assert_record_handler_called(&storage, 19, "record_default_handler", 6);
2169 assert_true(storage.count == 20);
2170 }
2171
2172 /* Finally, without passing the cdata to the default handler */
2173 set_subtest("not passing cdata");
2174 {
2175 struct handler_record_list storage;
2176 storage.count = 0;
2177 XML_ParserReset(g_parser, NULL);
2178 XML_SetDefaultHandlerExpand(g_parser, record_default_handler);
2179 XML_SetCharacterDataHandler(g_parser, record_cdata_nodefault_handler);
2180 XML_SetUserData(g_parser, &storage);
2181 if (_XML_Parse_SINGLE_BYTES(g_parser, entity_text, (int)strlen(entity_text),
2182 XML_TRUE)
2183 == XML_STATUS_ERROR)
2184 xml_failure(g_parser);
2185 assert_record_handler_called(&storage, 0, "record_default_handler", 9);
2186 assert_record_handler_called(&storage, 1, "record_default_handler", 1);
2187 assert_record_handler_called(&storage, 2, "record_default_handler", 3);
2188 assert_record_handler_called(&storage, 3, "record_default_handler", 1);
2189 assert_record_handler_called(&storage, 4, "record_default_handler", 1);
2190 assert_record_handler_called(&storage, 5, "record_default_handler", 1);
2191 assert_record_handler_called(&storage, 6, "record_default_handler", 8);
2192 assert_record_handler_called(&storage, 7, "record_default_handler", 1);
2193 assert_record_handler_called(&storage, 8, "record_default_handler", 6);
2194 assert_record_handler_called(&storage, 9, "record_default_handler", 1);
2195 assert_record_handler_called(&storage, 10, "record_default_handler", 7);
2196 assert_record_handler_called(&storage, 11, "record_default_handler", 1);
2197 assert_record_handler_called(&storage, 12, "record_default_handler", 1);
2198 assert_record_handler_called(&storage, 13, "record_default_handler", 1);
2199 assert_record_handler_called(&storage, 14, "record_default_handler", 1);
2200 assert_record_handler_called(&storage, 15, "record_default_handler", 1);
2201 assert_record_handler_called(&storage, 16, "record_default_handler", 5);
2202 assert_record_handler_called(&storage, 17, "record_cdata_nodefault_handler",
2203 1);
2204 assert_record_handler_called(&storage, 18, "record_default_handler", 6);
2205 assert_true(storage.count == 19);
2206 }
2207}
2208END_TEST
2209
2210/* Test DTD element parsing code paths */
2211START_TEST(test_dtd_elements) {
2212 const char *text = "<!DOCTYPE doc [\n"
2213 "<!ELEMENT doc (chapter)>\n"
2214 "<!ELEMENT chapter (#PCDATA)>\n"
2215 "]>\n"
2216 "<doc><chapter>Wombats are go</chapter></doc>";
2217
2218 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
2219 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2220 == XML_STATUS_ERROR)
2221 xml_failure(g_parser);
2222}
2223END_TEST
2224
2225static void XMLCALL
2226element_decl_check_model(void *userData, const XML_Char *name,
2227 XML_Content *model) {
2228 UNUSED_P(userData);
2229 uint32_t errorFlags = 0;
2230
2231 /* Expected model array structure is this:
2232 * [0] (type 6, quant 0)
2233 * [1] (type 5, quant 0)
2234 * [3] (type 4, quant 0, name "bar")
2235 * [4] (type 4, quant 0, name "foo")
2236 * [5] (type 4, quant 3, name "xyz")
2237 * [2] (type 4, quant 2, name "zebra")
2238 */
2239 errorFlags |= ((xcstrcmp(name, XCS("junk")) == 0) ? 0 : (1u << 0));
2240 errorFlags |= ((model != NULL) ? 0 : (1u << 1));
2241
2242 if (model != NULL) {
2243 errorFlags |= ((model[0].type == XML_CTYPE_SEQ) ? 0 : (1u << 2));
2244 errorFlags |= ((model[0].quant == XML_CQUANT_NONE) ? 0 : (1u << 3));
2245 errorFlags |= ((model[0].numchildren == 2) ? 0 : (1u << 4));
2246 errorFlags |= ((model[0].children == &model[1]) ? 0 : (1u << 5));
2247 errorFlags |= ((model[0].name == NULL) ? 0 : (1u << 6));
2248
2249 errorFlags |= ((model[1].type == XML_CTYPE_CHOICE) ? 0 : (1u << 7));
2250 errorFlags |= ((model[1].quant == XML_CQUANT_NONE) ? 0 : (1u << 8));
2251 errorFlags |= ((model[1].numchildren == 3) ? 0 : (1u << 9));
2252 errorFlags |= ((model[1].children == &model[3]) ? 0 : (1u << 10));
2253 errorFlags |= ((model[1].name == NULL) ? 0 : (1u << 11));
2254
2255 errorFlags |= ((model[2].type == XML_CTYPE_NAME) ? 0 : (1u << 12));
2256 errorFlags |= ((model[2].quant == XML_CQUANT_REP) ? 0 : (1u << 13));
2257 errorFlags |= ((model[2].numchildren == 0) ? 0 : (1u << 14));
2258 errorFlags |= ((model[2].children == NULL) ? 0 : (1u << 15));
2259 errorFlags
2260 |= ((xcstrcmp(model[2].name, XCS("zebra")) == 0) ? 0 : (1u << 16));
2261
2262 errorFlags |= ((model[3].type == XML_CTYPE_NAME) ? 0 : (1u << 17));
2263 errorFlags |= ((model[3].quant == XML_CQUANT_NONE) ? 0 : (1u << 18));
2264 errorFlags |= ((model[3].numchildren == 0) ? 0 : (1u << 19));
2265 errorFlags |= ((model[3].children == NULL) ? 0 : (1u << 20));
2266 errorFlags |= ((xcstrcmp(model[3].name, XCS("bar")) == 0) ? 0 : (1u << 21));
2267
2268 errorFlags |= ((model[4].type == XML_CTYPE_NAME) ? 0 : (1u << 22));
2269 errorFlags |= ((model[4].quant == XML_CQUANT_NONE) ? 0 : (1u << 23));
2270 errorFlags |= ((model[4].numchildren == 0) ? 0 : (1u << 24));
2271 errorFlags |= ((model[4].children == NULL) ? 0 : (1u << 25));
2272 errorFlags |= ((xcstrcmp(model[4].name, XCS("foo")) == 0) ? 0 : (1u << 26));
2273
2274 errorFlags |= ((model[5].type == XML_CTYPE_NAME) ? 0 : (1u << 27));
2275 errorFlags |= ((model[5].quant == XML_CQUANT_PLUS) ? 0 : (1u << 28));
2276 errorFlags |= ((model[5].numchildren == 0) ? 0 : (1u << 29));
2277 errorFlags |= ((model[5].children == NULL) ? 0 : (1u << 30));
2278 errorFlags |= ((xcstrcmp(model[5].name, XCS("xyz")) == 0) ? 0 : (1u << 31));
2279 }
2280
2281 XML_SetUserData(g_parser, (void *)(uintptr_t)errorFlags);
2282 XML_FreeContentModel(g_parser, model);
2283}
2284
2285START_TEST(test_dtd_elements_nesting) {
2286 // Payload inspired by a test in Perl's XML::Parser
2287 const char *text = "<!DOCTYPE foo [\n"
2288 "<!ELEMENT junk ((bar|foo|xyz+), zebra*)>\n"
2289 "]>\n"
2290 "<foo/>";
2291
2292 XML_SetUserData(g_parser, (void *)(uintptr_t)-1);
2293
2294 XML_SetElementDeclHandler(g_parser, element_decl_check_model);
2295 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2296 == XML_STATUS_ERROR)
2297 xml_failure(g_parser);
2298
2299 if ((uint32_t)(uintptr_t)XML_GetUserData(g_parser) != 0)
2300 fail("Element declaration model regression detected");
2301}
2302END_TEST
2303
2304/* Test foreign DTD handling */
2305START_TEST(test_set_foreign_dtd) {
2306 const char *text1 = "<?xml version='1.0' encoding='us-ascii'?>\n";
2307 const char *text2 = "<doc>&entity;</doc>";
2308 ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
2309
2310 /* Check hash salt is passed through too */
2311 XML_SetHashSalt(g_parser, 0x12345678);
2312 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2313 XML_SetUserData(g_parser, &test_data);
2314 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
2315 /* Add a default handler to exercise more code paths */
2316 XML_SetDefaultHandler(g_parser, dummy_default_handler);
2317 if (XML_UseForeignDTD(g_parser, XML_TRUE) != XML_ERROR_NONE)
2318 fail("Could not set foreign DTD");
2319 if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
2320 == XML_STATUS_ERROR)
2321 xml_failure(g_parser);
2322
2323 /* Ensure that trying to set the DTD after parsing has started
2324 * is faulted, even if it's the same setting.
2325 */
2326 if (XML_UseForeignDTD(g_parser, XML_TRUE)
2327 != XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING)
2328 fail("Failed to reject late foreign DTD setting");
2329 /* Ditto for the hash salt */
2330 if (XML_SetHashSalt(g_parser, 0x23456789))
2331 fail("Failed to reject late hash salt change");
2332
2333 /* Now finish the parse */
2334 if (_XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2), XML_TRUE)
2335 == XML_STATUS_ERROR)
2336 xml_failure(g_parser);
2337}
2338END_TEST
2339
2340/* Test foreign DTD handling with a failing NotStandalone handler */
2341START_TEST(test_foreign_dtd_not_standalone) {
2342 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
2343 "<doc>&entity;</doc>";
2344 ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
2345
2346 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2347 XML_SetUserData(g_parser, &test_data);
2348 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
2349 XML_SetNotStandaloneHandler(g_parser, reject_not_standalone_handler);
2350 if (XML_UseForeignDTD(g_parser, XML_TRUE) != XML_ERROR_NONE)
2351 fail("Could not set foreign DTD");
2352 expect_failure(text, XML_ERROR_NOT_STANDALONE,
2353 "NotStandalonehandler failed to reject");
2354}
2355END_TEST
2356
2357/* Test invalid character in a foreign DTD is faulted */
2358START_TEST(test_invalid_foreign_dtd) {
2359 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
2360 "<doc>&entity;</doc>";
2361 ExtFaults test_data
2362 = {"$", "Dollar not faulted", NULL, XML_ERROR_INVALID_TOKEN};
2363
2364 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2365 XML_SetUserData(g_parser, &test_data);
2366 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
2367 XML_UseForeignDTD(g_parser, XML_TRUE);
2368 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
2369 "Bad DTD should not have been accepted");
2370}
2371END_TEST
2372
2373/* Test foreign DTD use with a doctype */
2374START_TEST(test_foreign_dtd_with_doctype) {
2375 const char *text1 = "<?xml version='1.0' encoding='us-ascii'?>\n"
2376 "<!DOCTYPE doc [<!ENTITY entity 'hello world'>]>\n";
2377 const char *text2 = "<doc>&entity;</doc>";
2378 ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
2379
2380 /* Check hash salt is passed through too */
2381 XML_SetHashSalt(g_parser, 0x12345678);
2382 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2383 XML_SetUserData(g_parser, &test_data);
2384 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
2385 /* Add a default handler to exercise more code paths */
2386 XML_SetDefaultHandler(g_parser, dummy_default_handler);
2387 if (XML_UseForeignDTD(g_parser, XML_TRUE) != XML_ERROR_NONE)
2388 fail("Could not set foreign DTD");
2389 if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
2390 == XML_STATUS_ERROR)
2391 xml_failure(g_parser);
2392
2393 /* Ensure that trying to set the DTD after parsing has started
2394 * is faulted, even if it's the same setting.
2395 */
2396 if (XML_UseForeignDTD(g_parser, XML_TRUE)
2397 != XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING)
2398 fail("Failed to reject late foreign DTD setting");
2399 /* Ditto for the hash salt */
2400 if (XML_SetHashSalt(g_parser, 0x23456789))
2401 fail("Failed to reject late hash salt change");
2402
2403 /* Now finish the parse */
2404 if (_XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2), XML_TRUE)
2405 == XML_STATUS_ERROR)
2406 xml_failure(g_parser);
2407}
2408END_TEST
2409
2410/* Test XML_UseForeignDTD with no external subset present */
2411START_TEST(test_foreign_dtd_without_external_subset) {
2412 const char *text = "<!DOCTYPE doc [<!ENTITY foo 'bar'>]>\n"
2413 "<doc>&foo;</doc>";
2414
2415 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2416 XML_SetUserData(g_parser, NULL);
2417 XML_SetExternalEntityRefHandler(g_parser, external_entity_null_loader);
2418 XML_UseForeignDTD(g_parser, XML_TRUE);
2419 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2420 == XML_STATUS_ERROR)
2421 xml_failure(g_parser);
2422}
2423END_TEST
2424
2425START_TEST(test_empty_foreign_dtd) {
2426 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
2427 "<doc>&entity;</doc>";
2428
2429 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2430 XML_SetExternalEntityRefHandler(g_parser, external_entity_null_loader);
2431 XML_UseForeignDTD(g_parser, XML_TRUE);
2432 expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
2433 "Undefined entity not faulted");
2434}
2435END_TEST
2436
2437/* Test XML Base is set and unset appropriately */
2438START_TEST(test_set_base) {
2439 const XML_Char *old_base;
2440 const XML_Char *new_base = XCS("/local/file/name.xml");
2441
2442 old_base = XML_GetBase(g_parser);
2443 if (XML_SetBase(g_parser, new_base) != XML_STATUS_OK)
2444 fail("Unable to set base");
2445 if (xcstrcmp(XML_GetBase(g_parser), new_base) != 0)
2446 fail("Base setting not correct");
2447 if (XML_SetBase(g_parser, NULL) != XML_STATUS_OK)
2448 fail("Unable to NULL base");
2449 if (XML_GetBase(g_parser) != NULL)
2450 fail("Base setting not nulled");
2451 XML_SetBase(g_parser, old_base);
2452}
2453END_TEST
2454
2455/* Test attribute counts, indexing, etc */
2456START_TEST(test_attributes) {
2457 const char *text = "<!DOCTYPE doc [\n"
2458 "<!ELEMENT doc (tag)>\n"
2459 "<!ATTLIST doc id ID #REQUIRED>\n"
2460 "]>"
2461 "<doc a='1' id='one' b='2'>"
2462 "<tag c='3'/>"
2463 "</doc>";
2464 AttrInfo doc_info[] = {{XCS("a"), XCS("1")},
2465 {XCS("b"), XCS("2")},
2466 {XCS("id"), XCS("one")},
2467 {NULL, NULL}};
2468 AttrInfo tag_info[] = {{XCS("c"), XCS("3")}, {NULL, NULL}};
2469 ElementInfo info[] = {{XCS("doc"), 3, XCS("id"), NULL},
2470 {XCS("tag"), 1, NULL, NULL},
2471 {NULL, 0, NULL, NULL}};
2472 info[0].attributes = doc_info;
2473 info[1].attributes = tag_info;
2474
2475 XML_Parser parser = XML_ParserCreate(NULL);
2476 assert_true(parser != NULL);
2477 ParserAndElementInfo parserAndElementInfos = {
2478 parser,
2479 info,
2480 };
2481
2482 XML_SetStartElementHandler(parser, counting_start_element_handler);
2483 XML_SetUserData(parser, &parserAndElementInfos);
2484 if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE)
2485 == XML_STATUS_ERROR)
2486 xml_failure(parser);
2487
2488 XML_ParserFree(parser);
2489}
2490END_TEST
2491
2492/* Test reset works correctly in the middle of processing an internal
2493 * entity. Exercises some obscure code in XML_ParserReset().
2494 */
2495START_TEST(test_reset_in_entity) {
2496 if (g_chunkSize != 0) {
2497 // this test does not use SINGLE_BYTES, because of suspension
2498 return;
2499 }
2500
2501 const char *text = "<!DOCTYPE doc [\n"
2502 "<!ENTITY wombat 'wom'>\n"
2503 "<!ENTITY entity 'hi &wom; there'>\n"
2504 "]>\n"
2505 "<doc>&entity;</doc>";
2506 XML_ParsingStatus status;
2507
2508 g_resumable = XML_TRUE;
2509 XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
2510 // can't use SINGLE_BYTES here, because it'll return early on suspension, and
2511 // we won't know exactly how much input we actually managed to give Expat.
2512 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
2513 == XML_STATUS_ERROR)
2514 xml_failure(g_parser);
2515 XML_GetParsingStatus(g_parser, &status);
2516 if (status.parsing != XML_SUSPENDED)
2517 fail("Parsing status not SUSPENDED");
2518 XML_ParserReset(g_parser, NULL);
2519 XML_GetParsingStatus(g_parser, &status);
2520 if (status.parsing != XML_INITIALIZED)
2521 fail("Parsing status doesn't reset to INITIALIZED");
2522}
2523END_TEST
2524
2525/* Test that resume correctly passes through parse errors */
2526START_TEST(test_resume_invalid_parse) {
2527 const char *text = "<doc>Hello</doc"; /* Missing closing wedge */
2528
2529 g_resumable = XML_TRUE;
2530 XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
2531 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
2532 == XML_STATUS_ERROR)
2533 xml_failure(g_parser);
2534 if (XML_ResumeParser(g_parser) == XML_STATUS_OK)
2535 fail("Resumed invalid parse not faulted");
2536 if (XML_GetErrorCode(g_parser) != XML_ERROR_UNCLOSED_TOKEN)
2537 fail("Invalid parse not correctly faulted");
2538}
2539END_TEST
2540
2541/* Test that re-suspended parses are correctly passed through */
2542START_TEST(test_resume_resuspended) {
2543 const char *text = "<doc>Hello<meep/>world</doc>";
2544
2545 g_resumable = XML_TRUE;
2546 XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
2547 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
2548 == XML_STATUS_ERROR)
2549 xml_failure(g_parser);
2550 g_resumable = XML_TRUE;
2551 XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
2552 if (XML_ResumeParser(g_parser) != XML_STATUS_SUSPENDED)
2553 fail("Resumption not suspended");
2554 /* This one should succeed and finish up */
2555 if (XML_ResumeParser(g_parser) != XML_STATUS_OK)
2556 xml_failure(g_parser);
2557}
2558END_TEST
2559
2560/* Test that CDATA shows up correctly through a default handler */
2561START_TEST(test_cdata_default) {
2562 const char *text = "<doc><![CDATA[Hello\nworld]]></doc>";
2563 const XML_Char *expected = XCS("<doc><![CDATA[Hello\nworld]]></doc>");
2564 CharData storage;
2565
2566 CharData_Init(&storage);
2567 XML_SetUserData(g_parser, &storage);
2568 XML_SetDefaultHandler(g_parser, accumulate_characters);
2569
2570 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2571 == XML_STATUS_ERROR)
2572 xml_failure(g_parser);
2573 CharData_CheckXMLChars(&storage, expected);
2574}
2575END_TEST
2576
2577/* Test resetting a subordinate parser does exactly nothing */
2578START_TEST(test_subordinate_reset) {
2579 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
2580 "<!DOCTYPE doc SYSTEM 'foo'>\n"
2581 "<doc>&entity;</doc>";
2582
2583 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2584 XML_SetExternalEntityRefHandler(g_parser, external_entity_resetter);
2585 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2586 == XML_STATUS_ERROR)
2587 xml_failure(g_parser);
2588}
2589END_TEST
2590
2591/* Test suspending a subordinate parser */
2592START_TEST(test_subordinate_suspend) {
2593 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
2594 "<!DOCTYPE doc SYSTEM 'foo'>\n"
2595 "<doc>&entity;</doc>";
2596
2597 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2598 XML_SetExternalEntityRefHandler(g_parser, external_entity_suspender);
2599 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2600 == XML_STATUS_ERROR)
2601 xml_failure(g_parser);
2602}
2603END_TEST
2604
2605/* Test suspending a subordinate parser from an XML declaration */
2606/* Increases code coverage of the tests */
2607
2608START_TEST(test_subordinate_xdecl_suspend) {
2609 const char *text
2610 = "<!DOCTYPE doc [\n"
2611 " <!ENTITY entity SYSTEM 'http://example.org/dummy.ent'>\n"
2612 "]>\n"
2613 "<doc>&entity;</doc>";
2614
2615 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2616 XML_SetExternalEntityRefHandler(g_parser, external_entity_suspend_xmldecl);
2617 g_resumable = XML_TRUE;
2618 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2619 == XML_STATUS_ERROR)
2620 xml_failure(g_parser);
2621}
2622END_TEST
2623
2624START_TEST(test_subordinate_xdecl_abort) {
2625 const char *text
2626 = "<!DOCTYPE doc [\n"
2627 " <!ENTITY entity SYSTEM 'http://example.org/dummy.ent'>\n"
2628 "]>\n"
2629 "<doc>&entity;</doc>";
2630
2631 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2632 XML_SetExternalEntityRefHandler(g_parser, external_entity_suspend_xmldecl);
2633 g_resumable = XML_FALSE;
2634 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2635 == XML_STATUS_ERROR)
2636 xml_failure(g_parser);
2637}
2638END_TEST
2639
2640/* Test external entity fault handling with suspension */
2641START_TEST(test_ext_entity_invalid_suspended_parse) {
2642 const char *text = "<!DOCTYPE doc [\n"
2643 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
2644 "]>\n"
2645 "<doc>&en;</doc>";
2646 ExtFaults faults[]
2647 = {{"<?xml version='1.0' encoding='us-ascii'?><",
2648 "Incomplete element declaration not faulted", NULL,
2649 XML_ERROR_UNCLOSED_TOKEN},
2650 {/* First two bytes of a three-byte char */
2651 "<?xml version='1.0' encoding='utf-8'?>\xe2\x82",
2652 "Incomplete character not faulted", NULL, XML_ERROR_PARTIAL_CHAR},
2653 {NULL, NULL, NULL, XML_ERROR_NONE}};
2654 ExtFaults *fault;
2655
2656 for (fault = &faults[0]; fault->parse_text != NULL; fault++) {
2657 set_subtest("%s", fault->parse_text);
2658 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2659 XML_SetExternalEntityRefHandler(g_parser,
2660 external_entity_suspending_faulter);
2661 XML_SetUserData(g_parser, fault);
2662 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
2663 "Parser did not report external entity error");
2664 XML_ParserReset(g_parser, NULL);
2665 }
2666}
2667END_TEST
2668
2669/* Test setting an explicit encoding */
2670START_TEST(test_explicit_encoding) {
2671 const char *text1 = "<doc>Hello ";
2672 const char *text2 = " World</doc>";
2673
2674 /* Just check that we can set the encoding to NULL before starting */
2675 if (XML_SetEncoding(g_parser, NULL) != XML_STATUS_OK)
2676 fail("Failed to initialise encoding to NULL");
2677 /* Say we are UTF-8 */
2678 if (XML_SetEncoding(g_parser, XCS("utf-8")) != XML_STATUS_OK)
2679 fail("Failed to set explicit encoding");
2680 if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
2681 == XML_STATUS_ERROR)
2682 xml_failure(g_parser);
2683 /* Try to switch encodings mid-parse */
2684 if (XML_SetEncoding(g_parser, XCS("us-ascii")) != XML_STATUS_ERROR)
2685 fail("Allowed encoding change");
2686 if (_XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2), XML_TRUE)
2687 == XML_STATUS_ERROR)
2688 xml_failure(g_parser);
2689 /* Try now the parse is over */
2690 if (XML_SetEncoding(g_parser, NULL) != XML_STATUS_OK)
2691 fail("Failed to unset encoding");
2692}
2693END_TEST
2694
2695/* Test handling of trailing CR (rather than newline) */
2696START_TEST(test_trailing_cr) {
2697 const char *text = "<doc>\r";
2698 int found_cr;
2699
2700 /* Try with a character handler, for code coverage */
2701 XML_SetCharacterDataHandler(g_parser, cr_cdata_handler);
2702 XML_SetUserData(g_parser, &found_cr);
2703 found_cr = 0;
2704 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2705 == XML_STATUS_OK)
2706 fail("Failed to fault unclosed doc");
2707 if (found_cr == 0)
2708 fail("Did not catch the carriage return");
2709 XML_ParserReset(g_parser, NULL);
2710
2711 /* Now with a default handler instead */
2712 XML_SetDefaultHandler(g_parser, cr_cdata_handler);
2713 XML_SetUserData(g_parser, &found_cr);
2714 found_cr = 0;
2715 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2716 == XML_STATUS_OK)
2717 fail("Failed to fault unclosed doc");
2718 if (found_cr == 0)
2719 fail("Did not catch default carriage return");
2720}
2721END_TEST
2722
2723/* Test trailing CR in an external entity parse */
2724START_TEST(test_ext_entity_trailing_cr) {
2725 const char *text = "<!DOCTYPE doc [\n"
2726 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
2727 "]>\n"
2728 "<doc>&en;</doc>";
2729 int found_cr;
2730
2731 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2732 XML_SetExternalEntityRefHandler(g_parser, external_entity_cr_catcher);
2733 XML_SetUserData(g_parser, &found_cr);
2734 found_cr = 0;
2735 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2736 != XML_STATUS_OK)
2737 xml_failure(g_parser);
2738 if (found_cr == 0)
2739 fail("No carriage return found");
2740 XML_ParserReset(g_parser, NULL);
2741
2742 /* Try again with a different trailing CR */
2743 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2744 XML_SetExternalEntityRefHandler(g_parser, external_entity_bad_cr_catcher);
2745 XML_SetUserData(g_parser, &found_cr);
2746 found_cr = 0;
2747 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2748 != XML_STATUS_OK)
2749 xml_failure(g_parser);
2750 if (found_cr == 0)
2751 fail("No carriage return found");
2752}
2753END_TEST
2754
2755/* Test handling of trailing square bracket */
2756START_TEST(test_trailing_rsqb) {
2757 const char *text8 = "<doc>]";
2758 const char text16[] = "\xFF\xFE<\000d\000o\000c\000>\000]\000";
2759 int found_rsqb;
2760 int text8_len = (int)strlen(text8);
2761
2762 XML_SetCharacterDataHandler(g_parser, rsqb_handler);
2763 XML_SetUserData(g_parser, &found_rsqb);
2764 found_rsqb = 0;
2765 if (_XML_Parse_SINGLE_BYTES(g_parser, text8, text8_len, XML_TRUE)
2766 == XML_STATUS_OK)
2767 fail("Failed to fault unclosed doc");
2768 if (found_rsqb == 0)
2769 fail("Did not catch the right square bracket");
2770
2771 /* Try again with a different encoding */
2772 XML_ParserReset(g_parser, NULL);
2773 XML_SetCharacterDataHandler(g_parser, rsqb_handler);
2774 XML_SetUserData(g_parser, &found_rsqb);
2775 found_rsqb = 0;
2776 if (_XML_Parse_SINGLE_BYTES(g_parser, text16, (int)sizeof(text16) - 1,
2777 XML_TRUE)
2778 == XML_STATUS_OK)
2779 fail("Failed to fault unclosed doc");
2780 if (found_rsqb == 0)
2781 fail("Did not catch the right square bracket");
2782
2783 /* And finally with a default handler */
2784 XML_ParserReset(g_parser, NULL);
2785 XML_SetDefaultHandler(g_parser, rsqb_handler);
2786 XML_SetUserData(g_parser, &found_rsqb);
2787 found_rsqb = 0;
2788 if (_XML_Parse_SINGLE_BYTES(g_parser, text16, (int)sizeof(text16) - 1,
2789 XML_TRUE)
2790 == XML_STATUS_OK)
2791 fail("Failed to fault unclosed doc");
2792 if (found_rsqb == 0)
2793 fail("Did not catch the right square bracket");
2794}
2795END_TEST
2796
2797/* Test trailing right square bracket in an external entity parse */
2798START_TEST(test_ext_entity_trailing_rsqb) {
2799 const char *text = "<!DOCTYPE doc [\n"
2800 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
2801 "]>\n"
2802 "<doc>&en;</doc>";
2803 int found_rsqb;
2804
2805 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2806 XML_SetExternalEntityRefHandler(g_parser, external_entity_rsqb_catcher);
2807 XML_SetUserData(g_parser, &found_rsqb);
2808 found_rsqb = 0;
2809 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2810 != XML_STATUS_OK)
2811 xml_failure(g_parser);
2812 if (found_rsqb == 0)
2813 fail("No right square bracket found");
2814}
2815END_TEST
2816
2817/* Test CDATA handling in an external entity */
2818START_TEST(test_ext_entity_good_cdata) {
2819 const char *text = "<!DOCTYPE doc [\n"
2820 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
2821 "]>\n"
2822 "<doc>&en;</doc>";
2823
2824 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2825 XML_SetExternalEntityRefHandler(g_parser, external_entity_good_cdata_ascii);
2826 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2827 != XML_STATUS_OK)
2828 xml_failure(g_parser);
2829}
2830END_TEST
2831
2832/* Test user parameter settings */
2833START_TEST(test_user_parameters) {
2834 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
2835 "<!-- Primary parse -->\n"
2836 "<!DOCTYPE doc SYSTEM 'foo'>\n"
2837 "<doc>&entity;";
2838 const char *epilog = "<!-- Back to primary parser -->\n"
2839 "</doc>";
2840
2841 g_comment_count = 0;
2842 g_skip_count = 0;
2843 g_xdecl_count = 0;
2844 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2845 XML_SetXmlDeclHandler(g_parser, xml_decl_handler);
2846 XML_SetExternalEntityRefHandler(g_parser, external_entity_param_checker);
2847 XML_SetCommentHandler(g_parser, data_check_comment_handler);
2848 XML_SetSkippedEntityHandler(g_parser, param_check_skip_handler);
2849 XML_UseParserAsHandlerArg(g_parser);
2850 XML_SetUserData(g_parser, (void *)1);
2851 g_handler_data = g_parser;
2852 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
2853 == XML_STATUS_ERROR)
2854 xml_failure(g_parser);
2855 /* Ensure we can't change policy mid-parse */
2856 if (XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_NEVER))
2857 fail("Changed param entity parsing policy while parsing");
2858 if (_XML_Parse_SINGLE_BYTES(g_parser, epilog, (int)strlen(epilog), XML_TRUE)
2859 == XML_STATUS_ERROR)
2860 xml_failure(g_parser);
2861 if (g_comment_count != 3)
2862 fail("Comment handler not invoked enough times");
2863 if (g_skip_count != 1)
2864 fail("Skip handler not invoked enough times");
2865 if (g_xdecl_count != 1)
2866 fail("XML declaration handler not invoked");
2867}
2868END_TEST
2869
2870/* Test that an explicit external entity handler argument replaces
2871 * the parser as the first argument.
2872 *
2873 * We do not call the first parameter to the external entity handler
2874 * 'parser' for once, since the first time the handler is called it
2875 * will actually be a text string. We need to be able to access the
2876 * global 'parser' variable to create our external entity parser from,
2877 * since there are code paths we need to ensure get executed.
2878 */
2879START_TEST(test_ext_entity_ref_parameter) {
2880 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
2881 "<!DOCTYPE doc SYSTEM 'foo'>\n"
2882 "<doc>&entity;</doc>";
2883
2884 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2885 XML_SetExternalEntityRefHandler(g_parser, external_entity_ref_param_checker);
2886 /* Set a handler arg that is not NULL and not parser (which is
2887 * what NULL would cause to be passed.
2888 */
2889 XML_SetExternalEntityRefHandlerArg(g_parser, (void *)text);
2890 g_handler_data = text;
2891 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2892 == XML_STATUS_ERROR)
2893 xml_failure(g_parser);
2894
2895 /* Now try again with unset args */
2896 XML_ParserReset(g_parser, NULL);
2897 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2898 XML_SetExternalEntityRefHandler(g_parser, external_entity_ref_param_checker);
2899 XML_SetExternalEntityRefHandlerArg(g_parser, NULL);
2900 g_handler_data = g_parser;
2901 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2902 == XML_STATUS_ERROR)
2903 xml_failure(g_parser);
2904}
2905END_TEST
2906
2907/* Test the parsing of an empty string */
2908START_TEST(test_empty_parse) {
2909 const char *text = "<doc></doc>";
2910 const char *partial = "<doc>";
2911
2912 if (XML_Parse(g_parser, NULL, 0, XML_FALSE) == XML_STATUS_ERROR)
2913 fail("Parsing empty string faulted");
2914 if (XML_Parse(g_parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
2915 fail("Parsing final empty string not faulted");
2916 if (XML_GetErrorCode(g_parser) != XML_ERROR_NO_ELEMENTS)
2917 fail("Parsing final empty string faulted for wrong reason");
2918
2919 /* Now try with valid text before the empty end */
2920 XML_ParserReset(g_parser, NULL);
2921 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
2922 == XML_STATUS_ERROR)
2923 xml_failure(g_parser);
2924 if (XML_Parse(g_parser, NULL, 0, XML_TRUE) == XML_STATUS_ERROR)
2925 fail("Parsing final empty string faulted");
2926
2927 /* Now try with invalid text before the empty end */
2928 XML_ParserReset(g_parser, NULL);
2929 if (_XML_Parse_SINGLE_BYTES(g_parser, partial, (int)strlen(partial),
2930 XML_FALSE)
2931 == XML_STATUS_ERROR)
2932 xml_failure(g_parser);
2933 if (XML_Parse(g_parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
2934 fail("Parsing final incomplete empty string not faulted");
2935}
2936END_TEST
2937
2938/* Test XML_Parse for len < 0 */
2939START_TEST(test_negative_len_parse) {
2940 const char *const doc = "<root/>";
2941 for (int isFinal = 0; isFinal < 2; isFinal++) {
2942 set_subtest("isFinal=%d", isFinal);
2943
2944 XML_Parser parser = XML_ParserCreate(NULL);
2945
2946 if (XML_GetErrorCode(parser) != XML_ERROR_NONE)
2947 fail("There was not supposed to be any initial parse error.");
2948
2949 const enum XML_Status status = XML_Parse(parser, doc, -1, isFinal);
2950
2951 if (status != XML_STATUS_ERROR)
2952 fail("Negative len was expected to fail the parse but did not.");
2953
2954 if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_ARGUMENT)
2955 fail("Parse error does not match XML_ERROR_INVALID_ARGUMENT.");
2956
2957 XML_ParserFree(parser);
2958 }
2959}
2960END_TEST
2961
2962/* Test XML_ParseBuffer for len < 0 */
2963START_TEST(test_negative_len_parse_buffer) {
2964 const char *const doc = "<root/>";
2965 for (int isFinal = 0; isFinal < 2; isFinal++) {
2966 set_subtest("isFinal=%d", isFinal);
2967
2968 XML_Parser parser = XML_ParserCreate(NULL);
2969
2970 if (XML_GetErrorCode(parser) != XML_ERROR_NONE)
2971 fail("There was not supposed to be any initial parse error.");
2972
2973 void *const buffer = XML_GetBuffer(parser, (int)strlen(doc));
2974
2975 if (buffer == NULL)
2976 fail("XML_GetBuffer failed.");
2977
2978 memcpy(buffer, doc, strlen(doc));
2979
2980 const enum XML_Status status = XML_ParseBuffer(parser, -1, isFinal);
2981
2982 if (status != XML_STATUS_ERROR)
2983 fail("Negative len was expected to fail the parse but did not.");
2984
2985 if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_ARGUMENT)
2986 fail("Parse error does not match XML_ERROR_INVALID_ARGUMENT.");
2987
2988 XML_ParserFree(parser);
2989 }
2990}
2991END_TEST
2992
2993/* Test odd corners of the XML_GetBuffer interface */
2994static enum XML_Status
2995get_feature(enum XML_FeatureEnum feature_id, long *presult) {
2996 const XML_Feature *feature = XML_GetFeatureList();
2997
2998 if (feature == NULL)
2999 return XML_STATUS_ERROR;
3000 for (; feature->feature != XML_FEATURE_END; feature++) {
3001 if (feature->feature == feature_id) {
3002 *presult = feature->value;
3003 return XML_STATUS_OK;
3004 }
3005 }
3006 return XML_STATUS_ERROR;
3007}
3008
3009/* Test odd corners of the XML_GetBuffer interface */
3010START_TEST(test_get_buffer_1) {
3011 const char *text = get_buffer_test_text;
3012 void *buffer;
3013 long context_bytes;
3014
3015 /* Attempt to allocate a negative length buffer */
3016 if (XML_GetBuffer(g_parser, -12) != NULL)
3017 fail("Negative length buffer not failed");
3018
3019 /* Now get a small buffer and extend it past valid length */
3020 buffer = XML_GetBuffer(g_parser, 1536);
3021 if (buffer == NULL)
3022 fail("1.5K buffer failed");
3023 assert(buffer != NULL);
3024 memcpy(buffer, text, strlen(text));
3025 if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_FALSE)
3026 == XML_STATUS_ERROR)
3027 xml_failure(g_parser);
3028 if (XML_GetBuffer(g_parser, INT_MAX) != NULL)
3029 fail("INT_MAX buffer not failed");
3030
3031 /* Now try extending it a more reasonable but still too large
3032 * amount. The allocator in XML_GetBuffer() doubles the buffer
3033 * size until it exceeds the requested amount or INT_MAX. If it
3034 * exceeds INT_MAX, it rejects the request, so we want a request
3035 * between INT_MAX and INT_MAX/2. A gap of 1K seems comfortable,
3036 * with an extra byte just to ensure that the request is off any
3037 * boundary. The request will be inflated internally by
3038 * XML_CONTEXT_BYTES (if >=1), so we subtract that from our
3039 * request.
3040 */
3041 if (get_feature(XML_FEATURE_CONTEXT_BYTES, &context_bytes) != XML_STATUS_OK)
3042 context_bytes = 0;
3043 if (XML_GetBuffer(g_parser, INT_MAX - (context_bytes + 1025)) != NULL)
3044 fail("INT_MAX- buffer not failed");
3045
3046 /* Now try extending it a carefully crafted amount */
3047 if (XML_GetBuffer(g_parser, 1000) == NULL)
3048 fail("1000 buffer failed");
3049}
3050END_TEST
3051
3052/* Test more corners of the XML_GetBuffer interface */
3053START_TEST(test_get_buffer_2) {
3054 const char *text = get_buffer_test_text;
3055 void *buffer;
3056
3057 /* Now get a decent buffer */
3058 buffer = XML_GetBuffer(g_parser, 1536);
3059 if (buffer == NULL)
3060 fail("1.5K buffer failed");
3061 assert(buffer != NULL);
3062 memcpy(buffer, text, strlen(text));
3063 if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_FALSE)
3064 == XML_STATUS_ERROR)
3065 xml_failure(g_parser);
3066
3067 /* Extend it, to catch a different code path */
3068 if (XML_GetBuffer(g_parser, 1024) == NULL)
3069 fail("1024 buffer failed");
3070}
3071END_TEST
3072
3073/* Test for signed integer overflow CVE-2022-23852 */
3074#if XML_CONTEXT_BYTES > 0
3075START_TEST(test_get_buffer_3_overflow) {
3076 XML_Parser parser = XML_ParserCreate(NULL);
3077 assert(parser != NULL);
3078
3079 const char *const text = "\n";
3080 const int expectedKeepValue = (int)strlen(text);
3081
3082 // After this call, variable "keep" in XML_GetBuffer will
3083 // have value expectedKeepValue
3084 if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
3085 XML_FALSE /* isFinal */)
3086 == XML_STATUS_ERROR)
3087 xml_failure(parser);
3088
3089 assert(expectedKeepValue > 0);
3090 if (XML_GetBuffer(parser, INT_MAX - expectedKeepValue + 1) != NULL)
3091 fail("enlarging buffer not failed");
3092
3093 XML_ParserFree(parser);
3094}
3095END_TEST
3096#endif // XML_CONTEXT_BYTES > 0
3097
3098START_TEST(test_buffer_can_grow_to_max) {
3099 const char *const prefixes[] = {
3100 "",
3101 "<",
3102 "<x a='",
3103 "<doc><x a='",
3104 "<document><x a='",
3105 "<averylongelementnamesuchthatitwillhopefullystretchacrossmultiplelinesand"
3106 "lookprettyridiculousitsalsoveryhardtoreadandifyouredoingitihavetowonderif"
3107 "youreallydonthaveanythingbettertodoofcourseiguessicouldveputsomethingbadin"
3108 "herebutipromisethatididntheybtwhowgreatarespacesandpunctuationforhelping"
3109 "withreadabilityprettygreatithinkanywaysthisisprobablylongenoughbye><x a='"};
3110 const int num_prefixes = sizeof(prefixes) / sizeof(prefixes[0]);
3111 int maxbuf = INT_MAX / 2 + (INT_MAX & 1); // round up without overflow
3112#if defined(__MINGW32__) && ! defined(__MINGW64__)
3113 // workaround for mingw/wine32 on GitHub CI not being able to reach 1GiB
3114 // Can we make a big allocation?
3115 void *big = malloc(maxbuf);
3116 if (! big) {
3117 // The big allocation failed. Let's be a little lenient.
3118 maxbuf = maxbuf / 2;
3119 }
3120 free(big);
3121#endif
3122
3123 for (int i = 0; i < num_prefixes; ++i) {
3124 set_subtest("\"%s\"", prefixes[i]);
3125 XML_Parser parser = XML_ParserCreate(NULL);
3126#if XML_GE == 1
3127 assert_true(XML_SetAllocTrackerActivationThreshold(parser, (size_t)-1)
3128 == XML_TRUE); // i.e. deactivate
3129#endif
3130 const int prefix_len = (int)strlen(prefixes[i]);
3131 const enum XML_Status s
3132 = _XML_Parse_SINGLE_BYTES(parser, prefixes[i], prefix_len, XML_FALSE);
3133 if (s != XML_STATUS_OK)
3134 xml_failure(parser);
3135
3136 // XML_CONTEXT_BYTES of the prefix may remain in the buffer;
3137 // subtracting the whole prefix is easiest, and close enough.
3138 assert_true(XML_GetBuffer(parser, maxbuf - prefix_len) != NULL);
3139 // The limit should be consistent; no prefix should allow us to
3140 // reach above the max buffer size.
3141 assert_true(XML_GetBuffer(parser, maxbuf + 1) == NULL);
3142 XML_ParserFree(parser);
3143 }
3144}
3145END_TEST
3146
3147START_TEST(test_getbuffer_allocates_on_zero_len) {
3148 for (int first_len = 1; first_len >= 0; first_len--) {
3149 set_subtest("with len=%d first", first_len);
3150 XML_Parser parser = XML_ParserCreate(NULL);
3151 assert_true(parser != NULL);
3152 assert_true(XML_GetBuffer(parser, first_len) != NULL);
3153 assert_true(XML_GetBuffer(parser, 0) != NULL);
3154 if (XML_ParseBuffer(parser, 0, XML_FALSE) != XML_STATUS_OK)
3155 xml_failure(parser);
3156 XML_ParserFree(parser);
3157 }
3158}
3159END_TEST
3160
3161/* Test position information macros */
3162START_TEST(test_byte_info_at_end) {
3163 const char *text = "<doc></doc>";
3164
3165 if (XML_GetCurrentByteIndex(g_parser) != -1
3166 || XML_GetCurrentByteCount(g_parser) != 0)
3167 fail("Byte index/count incorrect at start of parse");
3168 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3169 == XML_STATUS_ERROR)
3170 xml_failure(g_parser);
3171 /* At end, the count will be zero and the index the end of string */
3172 if (XML_GetCurrentByteCount(g_parser) != 0)
3173 fail("Terminal byte count incorrect");
3174 if (XML_GetCurrentByteIndex(g_parser) != (XML_Index)strlen(text))
3175 fail("Terminal byte index incorrect");
3176}
3177END_TEST
3178
3179/* Test position information from errors */
3180#define PRE_ERROR_STR "<doc></"
3181#define POST_ERROR_STR "wombat></doc>"
3182START_TEST(test_byte_info_at_error) {
3183 const char *text = PRE_ERROR_STR POST_ERROR_STR;
3184
3185 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3186 == XML_STATUS_OK)
3187 fail("Syntax error not faulted");
3188 if (XML_GetCurrentByteCount(g_parser) != 0)
3189 fail("Error byte count incorrect");
3190 if (XML_GetCurrentByteIndex(g_parser) != strlen(PRE_ERROR_STR))
3191 fail("Error byte index incorrect");
3192}
3193END_TEST
3194#undef PRE_ERROR_STR
3195#undef POST_ERROR_STR
3196
3197/* Test position information in handler */
3198#define START_ELEMENT "<e>"
3199#define CDATA_TEXT "Hello"
3200#define END_ELEMENT "</e>"
3201START_TEST(test_byte_info_at_cdata) {
3202 const char *text = START_ELEMENT CDATA_TEXT END_ELEMENT;
3203 int offset, size;
3204 ByteTestData data;
3205
3206 /* Check initial context is empty */
3207 if (XML_GetInputContext(g_parser, &offset, &size) != NULL)
3208 fail("Unexpected context at start of parse");
3209
3210 data.start_element_len = (int)strlen(START_ELEMENT);
3211 data.cdata_len = (int)strlen(CDATA_TEXT);
3212 data.total_string_len = (int)strlen(text);
3213 XML_SetCharacterDataHandler(g_parser, byte_character_handler);
3214 XML_SetUserData(g_parser, &data);
3215 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_OK)
3216 xml_failure(g_parser);
3217}
3218END_TEST
3219#undef START_ELEMENT
3220#undef CDATA_TEXT
3221#undef END_ELEMENT
3222
3223/* Test predefined entities are correctly recognised */
3224START_TEST(test_predefined_entities) {
3225 const char *text = "<doc><>&"'</doc>";
3226 const XML_Char *expected = XCS("<doc><>&"'</doc>");
3227 const XML_Char *result = XCS("<>&\"'");
3228 CharData storage;
3229
3230 XML_SetDefaultHandler(g_parser, accumulate_characters);
3231 /* run_character_check uses XML_SetCharacterDataHandler(), which
3232 * unfortunately heads off a code path that we need to exercise.
3233 */
3234 CharData_Init(&storage);
3235 XML_SetUserData(g_parser, &storage);
3236 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3237 == XML_STATUS_ERROR)
3238 xml_failure(g_parser);
3239 /* The default handler doesn't translate the entities */
3240 CharData_CheckXMLChars(&storage, expected);
3241
3242 /* Now try again and check the translation */
3243 XML_ParserReset(g_parser, NULL);
3244 run_character_check(text, result);
3245}
3246END_TEST
3247
3248/* Regression test that an invalid tag in an external parameter
3249 * reference in an external DTD is correctly faulted.
3250 *
3251 * Only a few specific tags are legal in DTDs ignoring comments and
3252 * processing instructions, all of which begin with an exclamation
3253 * mark. "<el/>" is not one of them, so the parser should raise an
3254 * error on encountering it.
3255 */
3256START_TEST(test_invalid_tag_in_dtd) {
3257 const char *text = "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
3258 "<doc></doc>\n";
3259
3260 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3261 XML_SetExternalEntityRefHandler(g_parser, external_entity_param);
3262 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
3263 "Invalid tag IN DTD external param not rejected");
3264}
3265END_TEST
3266
3267/* Test entities not quite the predefined ones are not mis-recognised */
3268START_TEST(test_not_predefined_entities) {
3269 const char *text[] = {"<doc>&pt;</doc>", "<doc>&amo;</doc>",
3270 "<doc>&quid;</doc>", "<doc>&apod;</doc>", NULL};
3271 int i = 0;
3272
3273 while (text[i] != NULL) {
3274 expect_failure(text[i], XML_ERROR_UNDEFINED_ENTITY,
3275 "Undefined entity not rejected");
3276 XML_ParserReset(g_parser, NULL);
3277 i++;
3278 }
3279}
3280END_TEST
3281
3282/* Test conditional inclusion (IGNORE) */
3283START_TEST(test_ignore_section) {
3284 const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
3285 "<doc><e>&entity;</e></doc>";
3286 const XML_Char *expected
3287 = XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&entity;");
3288 CharData storage;
3289
3290 CharData_Init(&storage);
3291 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3292 XML_SetUserData(g_parser, &storage);
3293 XML_SetExternalEntityRefHandler(g_parser, external_entity_load_ignore);
3294 XML_SetDefaultHandler(g_parser, accumulate_characters);
3295 XML_SetStartDoctypeDeclHandler(g_parser, dummy_start_doctype_handler);
3296 XML_SetEndDoctypeDeclHandler(g_parser, dummy_end_doctype_handler);
3297 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
3298 XML_SetStartElementHandler(g_parser, dummy_start_element);
3299 XML_SetEndElementHandler(g_parser, dummy_end_element);
3300 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3301 == XML_STATUS_ERROR)
3302 xml_failure(g_parser);
3303 CharData_CheckXMLChars(&storage, expected);
3304}
3305END_TEST
3306
3307START_TEST(test_ignore_section_utf16) {
3308 const char text[] =
3309 /* <!DOCTYPE d SYSTEM 's'> */
3310 "<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 "
3311 "\0S\0Y\0S\0T\0E\0M\0 \0'\0s\0'\0>\0\n\0"
3312 /* <d><e>&en;</e></d> */
3313 "<\0d\0>\0<\0e\0>\0&\0e\0n\0;\0<\0/\0e\0>\0<\0/\0d\0>\0";
3314 const XML_Char *expected = XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;");
3315 CharData storage;
3316
3317 CharData_Init(&storage);
3318 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3319 XML_SetUserData(g_parser, &storage);
3320 XML_SetExternalEntityRefHandler(g_parser, external_entity_load_ignore_utf16);
3321 XML_SetDefaultHandler(g_parser, accumulate_characters);
3322 XML_SetStartDoctypeDeclHandler(g_parser, dummy_start_doctype_handler);
3323 XML_SetEndDoctypeDeclHandler(g_parser, dummy_end_doctype_handler);
3324 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
3325 XML_SetStartElementHandler(g_parser, dummy_start_element);
3326 XML_SetEndElementHandler(g_parser, dummy_end_element);
3327 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
3328 == XML_STATUS_ERROR)
3329 xml_failure(g_parser);
3330 CharData_CheckXMLChars(&storage, expected);
3331}
3332END_TEST
3333
3334START_TEST(test_ignore_section_utf16_be) {
3335 const char text[] =
3336 /* <!DOCTYPE d SYSTEM 's'> */
3337 "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 "
3338 "\0S\0Y\0S\0T\0E\0M\0 \0'\0s\0'\0>\0\n"
3339 /* <d><e>&en;</e></d> */
3340 "\0<\0d\0>\0<\0e\0>\0&\0e\0n\0;\0<\0/\0e\0>\0<\0/\0d\0>";
3341 const XML_Char *expected = XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;");
3342 CharData storage;
3343
3344 CharData_Init(&storage);
3345 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3346 XML_SetUserData(g_parser, &storage);
3347 XML_SetExternalEntityRefHandler(g_parser,
3348 external_entity_load_ignore_utf16_be);
3349 XML_SetDefaultHandler(g_parser, accumulate_characters);
3350 XML_SetStartDoctypeDeclHandler(g_parser, dummy_start_doctype_handler);
3351 XML_SetEndDoctypeDeclHandler(g_parser, dummy_end_doctype_handler);
3352 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
3353 XML_SetStartElementHandler(g_parser, dummy_start_element);
3354 XML_SetEndElementHandler(g_parser, dummy_end_element);
3355 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
3356 == XML_STATUS_ERROR)
3357 xml_failure(g_parser);
3358 CharData_CheckXMLChars(&storage, expected);
3359}
3360END_TEST
3361
3362/* Test mis-formatted conditional exclusion */
3363START_TEST(test_bad_ignore_section) {
3364 const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
3365 "<doc><e>&entity;</e></doc>";
3366 ExtFaults faults[]
3367 = {{"<![IGNORE[<!ELEM", "Broken-off declaration not faulted", NULL,
3368 XML_ERROR_SYNTAX},
3369 {"<![IGNORE[\x01]]>", "Invalid XML character not faulted", NULL,
3370 XML_ERROR_INVALID_TOKEN},
3371 {/* FIrst two bytes of a three-byte char */
3372 "<![IGNORE[\xe2\x82", "Partial XML character not faulted", NULL,
3373 XML_ERROR_PARTIAL_CHAR},
3374 {NULL, NULL, NULL, XML_ERROR_NONE}};
3375 ExtFaults *fault;
3376
3377 for (fault = &faults[0]; fault->parse_text != NULL; fault++) {
3378 set_subtest("%s", fault->parse_text);
3379 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3380 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
3381 XML_SetUserData(g_parser, fault);
3382 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
3383 "Incomplete IGNORE section not failed");
3384 XML_ParserReset(g_parser, NULL);
3385 }
3386}
3387END_TEST
3388
3389struct bom_testdata {
3390 const char *external;
3391 int split;
3392 XML_Bool nested_callback_happened;
3393};
3394
3395static int XMLCALL
3396external_bom_checker(XML_Parser parser, const XML_Char *context,
3397 const XML_Char *base, const XML_Char *systemId,
3398 const XML_Char *publicId) {
3399 const char *text;
3400 UNUSED_P(base);
3401 UNUSED_P(systemId);
3402 UNUSED_P(publicId);
3403
3404 XML_Parser ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
3405 if (ext_parser == NULL)
3406 fail("Could not create external entity parser");
3407
3408 if (! xcstrcmp(systemId, XCS("004-2.ent"))) {
3409 struct bom_testdata *const testdata
3410 = (struct bom_testdata *)XML_GetUserData(parser);
3411 const char *const external = testdata->external;
3412 const int split = testdata->split;
3413 testdata->nested_callback_happened = XML_TRUE;
3414
3415 if (_XML_Parse_SINGLE_BYTES(ext_parser, external, split, XML_FALSE)
3416 != XML_STATUS_OK) {
3417 xml_failure(ext_parser);
3418 }
3419 text = external + split; // the parse below will continue where we left off.
3420 } else if (! xcstrcmp(systemId, XCS("004-1.ent"))) {
3421 text = "<!ELEMENT doc EMPTY>\n"
3422 "<!ENTITY % e1 SYSTEM '004-2.ent'>\n"
3423 "<!ENTITY % e2 '%e1;'>\n";
3424 } else {
3425 fail("unknown systemId");
3426 }
3427
3428 if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
3429 != XML_STATUS_OK)
3430 xml_failure(ext_parser);
3431
3432 XML_ParserFree(ext_parser);
3433 return XML_STATUS_OK;
3434}
3435
3436/* regression test: BOM should be consumed when followed by a partial token. */
3437START_TEST(test_external_bom_consumed) {
3438 const char *const text = "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
3439 "<doc></doc>\n";
3440 const char *const external = "\xEF\xBB\xBF<!ATTLIST doc a1 CDATA 'value'>";
3441 const int len = (int)strlen(external);
3442 for (int split = 0; split <= len; ++split) {
3443 set_subtest("split at byte %d", split);
3444
3445 struct bom_testdata testdata;
3446 testdata.external = external;
3447 testdata.split = split;
3448 testdata.nested_callback_happened = XML_FALSE;
3449
3450 XML_Parser parser = XML_ParserCreate(NULL);
3451 if (parser == NULL) {
3452 fail("Couldn't create parser");
3453 }
3454 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3455 XML_SetExternalEntityRefHandler(parser, external_bom_checker);
3456 XML_SetUserData(parser, &testdata);
3457 if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE)
3458 == XML_STATUS_ERROR)
3459 xml_failure(parser);
3460 if (! testdata.nested_callback_happened) {
3461 fail("ref handler not called");
3462 }
3463 XML_ParserFree(parser);
3464 }
3465}
3466END_TEST
3467
3468/* Test recursive parsing */
3469START_TEST(test_external_entity_values) {
3470 const char *text = "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
3471 "<doc></doc>\n";
3472 ExtFaults data_004_2[] = {
3473 {"<!ATTLIST doc a1 CDATA 'value'>", NULL, NULL, XML_ERROR_NONE},
3474 {"<!ATTLIST $doc a1 CDATA 'value'>", "Invalid token not faulted", NULL,
3475 XML_ERROR_INVALID_TOKEN},
3476 {"'wombat", "Unterminated string not faulted", NULL,
3477 XML_ERROR_UNCLOSED_TOKEN},
3478 {"\xe2\x82", "Partial UTF-8 character not faulted", NULL,
3479 XML_ERROR_PARTIAL_CHAR},
3480 {"<?xml version='1.0' encoding='utf-8'?>\n", NULL, NULL, XML_ERROR_NONE},
3481 {"<?xml?>", "Malformed XML declaration not faulted", NULL,
3482 XML_ERROR_XML_DECL},
3483 {/* UTF-8 BOM */
3484 "\xEF\xBB\xBF<!ATTLIST doc a1 CDATA 'value'>", NULL, NULL,
3485 XML_ERROR_NONE},
3486 {"<?xml version='1.0' encoding='utf-8'?>\n$",
3487 "Invalid token after text declaration not faulted", NULL,
3488 XML_ERROR_INVALID_TOKEN},
3489 {"<?xml version='1.0' encoding='utf-8'?>\n'wombat",
3490 "Unterminated string after text decl not faulted", NULL,
3491 XML_ERROR_UNCLOSED_TOKEN},
3492 {"<?xml version='1.0' encoding='utf-8'?>\n\xe2\x82",
3493 "Partial UTF-8 character after text decl not faulted", NULL,
3494 XML_ERROR_PARTIAL_CHAR},
3495 {"%e1;", "Recursive parameter entity not faulted", NULL,
3496 XML_ERROR_RECURSIVE_ENTITY_REF},
3497 {NULL, NULL, NULL, XML_ERROR_NONE}};
3498 int i;
3499
3500 for (i = 0; data_004_2[i].parse_text != NULL; i++) {
3501 set_subtest("%s", data_004_2[i].parse_text);
3502 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3503 XML_SetExternalEntityRefHandler(g_parser, external_entity_valuer);
3504 XML_SetUserData(g_parser, &data_004_2[i]);
3505 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3506 == XML_STATUS_ERROR)
3507 xml_failure(g_parser);
3508 XML_ParserReset(g_parser, NULL);
3509 }
3510}
3511END_TEST
3512
3513/* Test the recursive parse interacts with a not standalone handler */
3514START_TEST(test_ext_entity_not_standalone) {
3515 const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
3516 "<doc></doc>";
3517
3518 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3519 XML_SetExternalEntityRefHandler(g_parser, external_entity_not_standalone);
3520 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
3521 "Standalone rejection not caught");
3522}
3523END_TEST
3524
3525START_TEST(test_ext_entity_value_abort) {
3526 const char *text = "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
3527 "<doc></doc>\n";
3528
3529 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3530 XML_SetExternalEntityRefHandler(g_parser, external_entity_value_aborter);
3531 g_resumable = XML_FALSE;
3532 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3533 == XML_STATUS_ERROR)
3534 xml_failure(g_parser);
3535}
3536END_TEST
3537
3538START_TEST(test_bad_public_doctype) {
3539 const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
3540 "<!DOCTYPE doc PUBLIC '{BadName}' 'test'>\n"
3541 "<doc></doc>";
3542
3543 /* Setting a handler provokes a particular code path */
3544 XML_SetDoctypeDeclHandler(g_parser, dummy_start_doctype_handler,
3545 dummy_end_doctype_handler);
3546 expect_failure(text, XML_ERROR_PUBLICID, "Bad Public ID not failed");
3547}
3548END_TEST
3549
3550/* Test based on ibm/valid/P32/ibm32v04.xml */
3551START_TEST(test_attribute_enum_value) {
3552 const char *text = "<?xml version='1.0' standalone='no'?>\n"
3553 "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
3554 "<animal>This is a \n <a/> \n\nyellow tiger</animal>";
3555 ExtTest dtd_data
3556 = {"<!ELEMENT animal (#PCDATA|a)*>\n"
3557 "<!ELEMENT a EMPTY>\n"
3558 "<!ATTLIST animal xml:space (default|preserve) 'preserve'>",
3559 NULL, NULL};
3560 const XML_Char *expected = XCS("This is a \n \n\nyellow tiger");
3561
3562 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
3563 XML_SetUserData(g_parser, &dtd_data);
3564 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3565 /* An attribute list handler provokes a different code path */
3566 XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
3567 run_ext_character_check(text, &dtd_data, expected);
3568}
3569END_TEST
3570
3571/* Slightly bizarrely, the library seems to silently ignore entity
3572 * definitions for predefined entities, even when they are wrong. The
3573 * language of the XML 1.0 spec is somewhat unhelpful as to what ought
3574 * to happen, so this is currently treated as acceptable.
3575 */
3576START_TEST(test_predefined_entity_redefinition) {
3577 const char *text = "<!DOCTYPE doc [\n"
3578 "<!ENTITY apos 'foo'>\n"
3579 "]>\n"
3580 "<doc>'</doc>";
3581 run_character_check(text, XCS("'"));
3582}
3583END_TEST
3584
3585/* Test that the parser stops processing the DTD after an unresolved
3586 * parameter entity is encountered.
3587 */
3588START_TEST(test_dtd_stop_processing) {
3589 const char *text = "<!DOCTYPE doc [\n"
3590 "%foo;\n"
3591 "<!ENTITY bar 'bas'>\n"
3592 "]><doc/>";
3593
3594 XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
3595 init_dummy_handlers();
3596 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3597 == XML_STATUS_ERROR)
3598 xml_failure(g_parser);
3599 if (get_dummy_handler_flags() != 0)
3600 fail("DTD processing still going after undefined PE");
3601}
3602END_TEST
3603
3604/* Test public notations with no system ID */
3605START_TEST(test_public_notation_no_sysid) {
3606 const char *text = "<!DOCTYPE doc [\n"
3607 "<!NOTATION note PUBLIC 'foo'>\n"
3608 "<!ELEMENT doc EMPTY>\n"
3609 "]>\n<doc/>";
3610
3611 init_dummy_handlers();
3612 XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
3613 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3614 == XML_STATUS_ERROR)
3615 xml_failure(g_parser);
3616 if (get_dummy_handler_flags() != DUMMY_NOTATION_DECL_HANDLER_FLAG)
3617 fail("Notation declaration handler not called");
3618}
3619END_TEST
3620
3621START_TEST(test_nested_groups) {
3622 const char *text
3623 = "<!DOCTYPE doc [\n"
3624 "<!ELEMENT doc "
3625 /* Sixteen elements per line */
3626 "(e,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,"
3627 "(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?"
3628 "))))))))))))))))))))))))))))))))>\n"
3629 "<!ELEMENT e EMPTY>"
3630 "]>\n"
3631 "<doc><e/></doc>";
3632 CharData storage;
3633
3634 CharData_Init(&storage);
3635 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
3636 XML_SetStartElementHandler(g_parser, record_element_start_handler);
3637 XML_SetUserData(g_parser, &storage);
3638 init_dummy_handlers();
3639 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3640 == XML_STATUS_ERROR)
3641 xml_failure(g_parser);
3642 CharData_CheckXMLChars(&storage, XCS("doce"));
3643 if (get_dummy_handler_flags() != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
3644 fail("Element handler not fired");
3645}
3646END_TEST
3647
3648START_TEST(test_group_choice) {
3649 const char *text = "<!DOCTYPE doc [\n"
3650 "<!ELEMENT doc (a|b|c)+>\n"
3651 "<!ELEMENT a EMPTY>\n"
3652 "<!ELEMENT b (#PCDATA)>\n"
3653 "<!ELEMENT c ANY>\n"
3654 "]>\n"
3655 "<doc>\n"
3656 "<a/>\n"
3657 "<b attr='foo'>This is a foo</b>\n"
3658 "<c></c>\n"
3659 "</doc>\n";
3660
3661 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
3662 init_dummy_handlers();
3663 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3664 == XML_STATUS_ERROR)
3665 xml_failure(g_parser);
3666 if (get_dummy_handler_flags() != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
3667 fail("Element handler flag not raised");
3668}
3669END_TEST
3670
3671START_TEST(test_standalone_parameter_entity) {
3672 const char *text = "<?xml version='1.0' standalone='yes'?>\n"
3673 "<!DOCTYPE doc SYSTEM 'http://example.org/' [\n"
3674 "<!ENTITY % entity '<!ELEMENT doc (#PCDATA)>'>\n"
3675 "%entity;\n"
3676 "]>\n"
3677 "<doc></doc>";
3678 char dtd_data[] = "<!ENTITY % e1 'foo'>\n";
3679
3680 XML_SetUserData(g_parser, dtd_data);
3681 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3682 XML_SetExternalEntityRefHandler(g_parser, external_entity_public);
3683 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3684 == XML_STATUS_ERROR)
3685 xml_failure(g_parser);
3686}
3687END_TEST
3688
3689/* Test skipping of parameter entity in an external DTD */
3690/* Derived from ibm/invalid/P69/ibm69i01.xml */
3691START_TEST(test_skipped_parameter_entity) {
3692 const char *text = "<?xml version='1.0'?>\n"
3693 "<!DOCTYPE root SYSTEM 'http://example.org/dtd.ent' [\n"
3694 "<!ELEMENT root (#PCDATA|a)* >\n"
3695 "]>\n"
3696 "<root></root>";
3697 ExtTest dtd_data = {"%pe2;", NULL, NULL};
3698
3699 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
3700 XML_SetUserData(g_parser, &dtd_data);
3701 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3702 XML_SetSkippedEntityHandler(g_parser, dummy_skip_handler);
3703 init_dummy_handlers();
3704 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3705 == XML_STATUS_ERROR)
3706 xml_failure(g_parser);
3707 if (get_dummy_handler_flags() != DUMMY_SKIP_HANDLER_FLAG)
3708 fail("Skip handler not executed");
3709}
3710END_TEST
3711
3712/* Test recursive parameter entity definition rejected in external DTD */
3713START_TEST(test_recursive_external_parameter_entity) {
3714 const char *text = "<?xml version='1.0'?>\n"
3715 "<!DOCTYPE root SYSTEM 'http://example.org/dtd.ent' [\n"
3716 "<!ELEMENT root (#PCDATA|a)* >\n"
3717 "]>\n"
3718 "<root></root>";
3719 ExtFaults dtd_data = {"<!ENTITY % pe2 '%pe2;'>\n%pe2;",
3720 "Recursive external parameter entity not faulted", NULL,
3721 XML_ERROR_RECURSIVE_ENTITY_REF};
3722
3723 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
3724 XML_SetUserData(g_parser, &dtd_data);
3725 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3726 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
3727 "Recursive external parameter not spotted");
3728}
3729END_TEST
3730
3731/* Test undefined parameter entity in external entity handler */
3732START_TEST(test_undefined_ext_entity_in_external_dtd) {
3733 const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
3734 "<doc></doc>\n";
3735
3736 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3737 XML_SetExternalEntityRefHandler(g_parser, external_entity_devaluer);
3738 XML_SetUserData(g_parser, NULL);
3739 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3740 == XML_STATUS_ERROR)
3741 xml_failure(g_parser);
3742
3743 /* Now repeat without the external entity ref handler invoking
3744 * another copy of itself.
3745 */
3746 XML_ParserReset(g_parser, NULL);
3747 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3748 XML_SetExternalEntityRefHandler(g_parser, external_entity_devaluer);
3749 XML_SetUserData(g_parser, g_parser); /* Any non-NULL value will do */
3750 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3751 == XML_STATUS_ERROR)
3752 xml_failure(g_parser);
3753}
3754END_TEST
3755
3756/* Test suspending the parse on receiving an XML declaration works */
3757START_TEST(test_suspend_xdecl) {
3758 const char *text = long_character_data_text;
3759
3760 XML_SetXmlDeclHandler(g_parser, entity_suspending_xdecl_handler);
3761 XML_SetUserData(g_parser, g_parser);
3762 g_resumable = XML_TRUE;
3763 // can't use SINGLE_BYTES here, because it'll return early on suspension, and
3764 // we won't know exactly how much input we actually managed to give Expat.
3765 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
3766 != XML_STATUS_SUSPENDED)
3767 xml_failure(g_parser);
3768 if (XML_GetErrorCode(g_parser) != XML_ERROR_NONE)
3769 xml_failure(g_parser);
3770 /* Attempt to start a new parse while suspended */
3771 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3772 != XML_STATUS_ERROR)
3773 fail("Attempt to parse while suspended not faulted");
3774 if (XML_GetErrorCode(g_parser) != XML_ERROR_SUSPENDED)
3775 fail("Suspended parse not faulted with correct error");
3776}
3777END_TEST
3778
3779/* Test aborting the parse in an epilog works */
3780START_TEST(test_abort_epilog) {
3781 const char *text = "<doc></doc>\n\r\n";
3782 XML_Char trigger_char = XCS('\r');
3783
3784 XML_SetDefaultHandler(g_parser, selective_aborting_default_handler);
3785 XML_SetUserData(g_parser, &trigger_char);
3786 g_resumable = XML_FALSE;
3787 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3788 != XML_STATUS_ERROR)
3789 fail("Abort not triggered");
3790 if (XML_GetErrorCode(g_parser) != XML_ERROR_ABORTED)
3791 xml_failure(g_parser);
3792}
3793END_TEST
3794
3795/* Test a different code path for abort in the epilog */
3796START_TEST(test_abort_epilog_2) {
3797 const char *text = "<doc></doc>\n";
3798 XML_Char trigger_char = XCS('\n');
3799
3800 XML_SetDefaultHandler(g_parser, selective_aborting_default_handler);
3801 XML_SetUserData(g_parser, &trigger_char);
3802 g_resumable = XML_FALSE;
3803 expect_failure(text, XML_ERROR_ABORTED, "Abort not triggered");
3804}
3805END_TEST
3806
3807/* Test suspension from the epilog */
3808START_TEST(test_suspend_epilog) {
3809 const char *text = "<doc></doc>\n";
3810 XML_Char trigger_char = XCS('\n');
3811
3812 XML_SetDefaultHandler(g_parser, selective_aborting_default_handler);
3813 XML_SetUserData(g_parser, &trigger_char);
3814 g_resumable = XML_TRUE;
3815 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
3816 != XML_STATUS_SUSPENDED)
3817 xml_failure(g_parser);
3818}
3819END_TEST
3820
3821START_TEST(test_suspend_in_sole_empty_tag) {
3822 const char *text = "<doc/>";
3823 enum XML_Status rc;
3824
3825 XML_SetEndElementHandler(g_parser, suspending_end_handler);
3826 XML_SetUserData(g_parser, g_parser);
3827 rc = _XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE);
3828 if (rc == XML_STATUS_ERROR)
3829 xml_failure(g_parser);
3830 else if (rc != XML_STATUS_SUSPENDED)
3831 fail("Suspend not triggered");
3832 rc = XML_ResumeParser(g_parser);
3833 if (rc == XML_STATUS_ERROR)
3834 xml_failure(g_parser);
3835 else if (rc != XML_STATUS_OK)
3836 fail("Resume failed");
3837}
3838END_TEST
3839
3840START_TEST(test_unfinished_epilog) {
3841 const char *text = "<doc></doc><";
3842
3843 expect_failure(text, XML_ERROR_UNCLOSED_TOKEN,
3844 "Incomplete epilog entry not faulted");
3845}
3846END_TEST
3847
3848START_TEST(test_partial_char_in_epilog) {
3849 const char *text = "<doc></doc>\xe2\x82";
3850
3851 /* First check that no fault is raised if the parse is not finished */
3852 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
3853 == XML_STATUS_ERROR)
3854 xml_failure(g_parser);
3855 /* Now check that it is faulted once we finish */
3856 if (XML_ParseBuffer(g_parser, 0, XML_TRUE) != XML_STATUS_ERROR)
3857 fail("Partial character in epilog not faulted");
3858 if (XML_GetErrorCode(g_parser) != XML_ERROR_PARTIAL_CHAR)
3859 xml_failure(g_parser);
3860}
3861END_TEST
3862
3863/* Test resuming a parse suspended in entity substitution */
3864START_TEST(test_suspend_resume_internal_entity) {
3865 const char *text
3866 = "<!DOCTYPE doc [\n"
3867 "<!ENTITY foo '<suspend>Hi<suspend>Ho</suspend></suspend>'>\n"
3868 "]>\n"
3869 "<doc>&foo;</doc>\n";
3870 const XML_Char *expected1 = XCS("Hi");
3871 const XML_Char *expected2 = XCS("HiHo");
3872 CharData storage;
3873
3874 CharData_Init(&storage);
3875 XML_SetStartElementHandler(g_parser, start_element_suspender);
3876 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
3877 XML_SetUserData(g_parser, &storage);
3878 // can't use SINGLE_BYTES here, because it'll return early on suspension, and
3879 // we won't know exactly how much input we actually managed to give Expat.
3880 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
3881 != XML_STATUS_SUSPENDED)
3882 xml_failure(g_parser);
3883 CharData_CheckXMLChars(&storage, XCS(""));
3884 if (XML_ResumeParser(g_parser) != XML_STATUS_SUSPENDED)
3885 xml_failure(g_parser);
3886 CharData_CheckXMLChars(&storage, expected1);
3887 if (XML_ResumeParser(g_parser) != XML_STATUS_OK)
3888 xml_failure(g_parser);
3889 CharData_CheckXMLChars(&storage, expected2);
3890}
3891END_TEST
3892
3893START_TEST(test_suspend_resume_internal_entity_issue_629) {
3894 const char *const text
3895 = "<!DOCTYPE a [<!ENTITY e '<!--COMMENT-->a'>]><a>&e;<b>\n"
3896 "<"
3897 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3898 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3899 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3900 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3901 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3902 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3903 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3904 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3905 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3906 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3907 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3908 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3909 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3910 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3911 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3912 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3913 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3914 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3915 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3916 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3917 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3918 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3919 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3920 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3921 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3922 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3923 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3924 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3925 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3926 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3927 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3928 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3929 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3930 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3931 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3932 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3933 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3934 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3935 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3936 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
3937 "/>"
3938 "</b></a>";
3939 const size_t firstChunkSizeBytes = 54;
3940
3941 XML_Parser parser = XML_ParserCreate(NULL);
3942 XML_SetUserData(parser, parser);
3943 XML_SetCommentHandler(parser, suspending_comment_handler);
3944
3945 if (XML_Parse(parser, text, (int)firstChunkSizeBytes, XML_FALSE)
3946 != XML_STATUS_SUSPENDED)
3947 xml_failure(parser);
3948 if (XML_ResumeParser(parser) != XML_STATUS_OK)
3949 xml_failure(parser);
3950 if (_XML_Parse_SINGLE_BYTES(parser, text + firstChunkSizeBytes,
3951 (int)(strlen(text) - firstChunkSizeBytes),
3952 XML_TRUE)
3953 != XML_STATUS_OK)
3954 xml_failure(parser);
3955 XML_ParserFree(parser);
3956}
3957END_TEST
3958
3959/* Test syntax error is caught at parse resumption */
3960START_TEST(test_resume_entity_with_syntax_error) {
3961 if (g_chunkSize != 0) {
3962 // this test does not use SINGLE_BYTES, because of suspension
3963 return;
3964 }
3965
3966 const char *text = "<!DOCTYPE doc [\n"
3967 "<!ENTITY foo '<suspend>Hi</wombat>'>\n"
3968 "]>\n"
3969 "<doc>&foo;</doc>\n";
3970
3971 XML_SetStartElementHandler(g_parser, start_element_suspender);
3972 // can't use SINGLE_BYTES here, because it'll return early on suspension, and
3973 // we won't know exactly how much input we actually managed to give Expat.
3974 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
3975 != XML_STATUS_SUSPENDED)
3976 xml_failure(g_parser);
3977 if (XML_ResumeParser(g_parser) != XML_STATUS_ERROR)
3978 fail("Syntax error in entity not faulted");
3979 if (XML_GetErrorCode(g_parser) != XML_ERROR_TAG_MISMATCH)
3980 xml_failure(g_parser);
3981}
3982END_TEST
3983
3984/* Test suspending and resuming in a parameter entity substitution */
3985START_TEST(test_suspend_resume_parameter_entity) {
3986 const char *text = "<!DOCTYPE doc [\n"
3987 "<!ENTITY % foo '<!ELEMENT doc (#PCDATA)*>'>\n"
3988 "%foo;\n"
3989 "]>\n"
3990 "<doc>Hello, world</doc>";
3991 const XML_Char *expected = XCS("Hello, world");
3992 CharData storage;
3993
3994 CharData_Init(&storage);
3995 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
3996 XML_SetElementDeclHandler(g_parser, element_decl_suspender);
3997 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
3998 XML_SetUserData(g_parser, &storage);
3999 if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
4000 != XML_STATUS_SUSPENDED)
4001 xml_failure(g_parser);
4002 CharData_CheckXMLChars(&storage, XCS(""));
4003 if (XML_ResumeParser(g_parser) != XML_STATUS_OK)
4004 xml_failure(g_parser);
4005 CharData_CheckXMLChars(&storage, expected);
4006}
4007END_TEST
4008
4009/* Test attempting to use parser after an error is faulted */
4010START_TEST(test_restart_on_error) {
4011 const char *text = "<$doc><doc></doc>";
4012
4013 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4014 != XML_STATUS_ERROR)
4015 fail("Invalid tag name not faulted");
4016 if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
4017 xml_failure(g_parser);
4018 if (XML_Parse(g_parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
4019 fail("Restarting invalid parse not faulted");
4020 if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
4021 xml_failure(g_parser);
4022}
4023END_TEST
4024
4025/* Test that angle brackets in an attribute default value are faulted */
4026START_TEST(test_reject_lt_in_attribute_value) {
4027 const char *text = "<!DOCTYPE doc [<!ATTLIST doc a CDATA '<bar>'>]>\n"
4028 "<doc></doc>";
4029
4030 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4031 "Bad attribute default not faulted");
4032}
4033END_TEST
4034
4035START_TEST(test_reject_unfinished_param_in_att_value) {
4036 const char *text = "<!DOCTYPE doc [<!ATTLIST doc a CDATA '&foo'>]>\n"
4037 "<doc></doc>";
4038
4039 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4040 "Bad attribute default not faulted");
4041}
4042END_TEST
4043
4044START_TEST(test_trailing_cr_in_att_value) {
4045 const char *text = "<doc a='value\r'/>";
4046
4047 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4048 == XML_STATUS_ERROR)
4049 xml_failure(g_parser);
4050}
4051END_TEST
4052
4053/* Try parsing a general entity within a parameter entity in a
4054 * standalone internal DTD. Covers a corner case in the parser.
4055 */
4056START_TEST(test_standalone_internal_entity) {
4057 const char *text = "<?xml version='1.0' standalone='yes' ?>\n"
4058 "<!DOCTYPE doc [\n"
4059 " <!ELEMENT doc (#PCDATA)>\n"
4060 " <!ENTITY % pe '<!ATTLIST doc att2 CDATA \"≥\">'>\n"
4061 " <!ENTITY ge 'AttDefaultValue'>\n"
4062 " %pe;\n"
4063 "]>\n"
4064 "<doc att2='any'/>";
4065
4066 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
4067 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4068 == XML_STATUS_ERROR)
4069 xml_failure(g_parser);
4070}
4071END_TEST
4072
4073/* Test that a reference to an unknown external entity is skipped */
4074START_TEST(test_skipped_external_entity) {
4075 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
4076 "<doc></doc>\n";
4077 ExtTest test_data = {"<!ELEMENT doc EMPTY>\n"
4078 "<!ENTITY % e2 '%e1;'>\n",
4079 NULL, NULL};
4080
4081 XML_SetUserData(g_parser, &test_data);
4082 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
4083 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
4084 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4085 == XML_STATUS_ERROR)
4086 xml_failure(g_parser);
4087}
4088END_TEST
4089
4090/* Test a different form of unknown external entity */
4091START_TEST(test_skipped_null_loaded_ext_entity) {
4092 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
4093 "<doc />";
4094 ExtHdlrData test_data
4095 = {"<!ENTITY % pe1 SYSTEM 'http://example.org/two.ent'>\n"
4096 "<!ENTITY % pe2 '%pe1;'>\n"
4097 "%pe2;\n",
4098 external_entity_null_loader, NULL};
4099
4100 XML_SetUserData(g_parser, &test_data);
4101 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
4102 XML_SetExternalEntityRefHandler(g_parser, external_entity_oneshot_loader);
4103 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4104 == XML_STATUS_ERROR)
4105 xml_failure(g_parser);
4106}
4107END_TEST
4108
4109START_TEST(test_skipped_unloaded_ext_entity) {
4110 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
4111 "<doc />";
4112 ExtHdlrData test_data
4113 = {"<!ENTITY % pe1 SYSTEM 'http://example.org/two.ent'>\n"
4114 "<!ENTITY % pe2 '%pe1;'>\n"
4115 "%pe2;\n",
4116 NULL, NULL};
4117
4118 XML_SetUserData(g_parser, &test_data);
4119 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
4120 XML_SetExternalEntityRefHandler(g_parser, external_entity_oneshot_loader);
4121 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4122 == XML_STATUS_ERROR)
4123 xml_failure(g_parser);
4124}
4125END_TEST
4126
4127/* Test that a parameter entity value ending with a carriage return
4128 * has it translated internally into a newline.
4129 */
4130START_TEST(test_param_entity_with_trailing_cr) {
4131#define PARAM_ENTITY_NAME "pe"
4132#define PARAM_ENTITY_CORE_VALUE "<!ATTLIST doc att CDATA \"default\">"
4133 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
4134 "<doc/>";
4135 ExtTest test_data
4136 = {"<!ENTITY % " PARAM_ENTITY_NAME " '" PARAM_ENTITY_CORE_VALUE "\r'>\n"
4137 "%" PARAM_ENTITY_NAME ";\n",
4138 NULL, NULL};
4139
4140 XML_SetUserData(g_parser, &test_data);
4141 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
4142 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
4143 XML_SetEntityDeclHandler(g_parser, param_entity_match_handler);
4144 param_entity_match_init(XCS(PARAM_ENTITY_NAME),
4145 XCS(PARAM_ENTITY_CORE_VALUE) XCS("\n"));
4146 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4147 == XML_STATUS_ERROR)
4148 xml_failure(g_parser);
4149 int entity_match_flag = get_param_entity_match_flag();
4150 if (entity_match_flag == ENTITY_MATCH_FAIL)
4151 fail("Parameter entity CR->NEWLINE conversion failed");
4152 else if (entity_match_flag == ENTITY_MATCH_NOT_FOUND)
4153 fail("Parameter entity not parsed");
4154}
4155#undef PARAM_ENTITY_NAME
4156#undef PARAM_ENTITY_CORE_VALUE
4157END_TEST
4158
4159START_TEST(test_invalid_character_entity) {
4160 const char *text = "<!DOCTYPE doc [\n"
4161 " <!ENTITY entity '�'>\n"
4162 "]>\n"
4163 "<doc>&entity;</doc>";
4164
4165 expect_failure(text, XML_ERROR_BAD_CHAR_REF,
4166 "Out of range character reference not faulted");
4167}
4168END_TEST
4169
4170START_TEST(test_invalid_character_entity_2) {
4171 const char *text = "<!DOCTYPE doc [\n"
4172 " <!ENTITY entity '&#xg0;'>\n"
4173 "]>\n"
4174 "<doc>&entity;</doc>";
4175
4176 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4177 "Out of range character reference not faulted");
4178}
4179END_TEST
4180
4181START_TEST(test_invalid_character_entity_3) {
4182 const char text[] =
4183 /* <!DOCTYPE doc [\n */
4184 "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0\n"
4185 /* U+0E04 = KHO KHWAI
4186 * U+0E08 = CHO CHAN */
4187 /* <!ENTITY entity '&\u0e04\u0e08;'>\n */
4188 "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0e\0n\0t\0i\0t\0y\0 "
4189 "\0'\0&\x0e\x04\x0e\x08\0;\0'\0>\0\n"
4190 /* ]>\n */
4191 "\0]\0>\0\n"
4192 /* <doc>&entity;</doc> */
4193 "\0<\0d\0o\0c\0>\0&\0e\0n\0t\0i\0t\0y\0;\0<\0/\0d\0o\0c\0>";
4194
4195 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
4196 != XML_STATUS_ERROR)
4197 fail("Invalid start of entity name not faulted");
4198 if (XML_GetErrorCode(g_parser) != XML_ERROR_UNDEFINED_ENTITY)
4199 xml_failure(g_parser);
4200}
4201END_TEST
4202
4203START_TEST(test_invalid_character_entity_4) {
4204 const char *text = "<!DOCTYPE doc [\n"
4205 " <!ENTITY entity '�'>\n" /* = � */
4206 "]>\n"
4207 "<doc>&entity;</doc>";
4208
4209 expect_failure(text, XML_ERROR_BAD_CHAR_REF,
4210 "Out of range character reference not faulted");
4211}
4212END_TEST
4213
4214/* Test that processing instructions are picked up by a default handler */
4215START_TEST(test_pi_handled_in_default) {
4216 const char *text = "<?test processing instruction?>\n<doc/>";
4217 const XML_Char *expected = XCS("<?test processing instruction?>\n<doc/>");
4218 CharData storage;
4219
4220 CharData_Init(&storage);
4221 XML_SetDefaultHandler(g_parser, accumulate_characters);
4222 XML_SetUserData(g_parser, &storage);
4223 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4224 == XML_STATUS_ERROR)
4225 xml_failure(g_parser);
4226 CharData_CheckXMLChars(&storage, expected);
4227}
4228END_TEST
4229
4230/* Test that comments are picked up by a default handler */
4231START_TEST(test_comment_handled_in_default) {
4232 const char *text = "<!-- This is a comment -->\n<doc/>";
4233 const XML_Char *expected = XCS("<!-- This is a comment -->\n<doc/>");
4234 CharData storage;
4235
4236 CharData_Init(&storage);
4237 XML_SetDefaultHandler(g_parser, accumulate_characters);
4238 XML_SetUserData(g_parser, &storage);
4239 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4240 == XML_STATUS_ERROR)
4241 xml_failure(g_parser);
4242 CharData_CheckXMLChars(&storage, expected);
4243}
4244END_TEST
4245
4246/* Test PIs that look almost but not quite like XML declarations */
4247START_TEST(test_pi_yml) {
4248 const char *text = "<?yml something like data?><doc/>";
4249 const XML_Char *expected = XCS("yml: something like data\n");
4250 CharData storage;
4251
4252 CharData_Init(&storage);
4253 XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
4254 XML_SetUserData(g_parser, &storage);
4255 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4256 == XML_STATUS_ERROR)
4257 xml_failure(g_parser);
4258 CharData_CheckXMLChars(&storage, expected);
4259}
4260END_TEST
4261
4262START_TEST(test_pi_xnl) {
4263 const char *text = "<?xnl nothing like data?><doc/>";
4264 const XML_Char *expected = XCS("xnl: nothing like data\n");
4265 CharData storage;
4266
4267 CharData_Init(&storage);
4268 XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
4269 XML_SetUserData(g_parser, &storage);
4270 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4271 == XML_STATUS_ERROR)
4272 xml_failure(g_parser);
4273 CharData_CheckXMLChars(&storage, expected);
4274}
4275END_TEST
4276
4277START_TEST(test_pi_xmm) {
4278 const char *text = "<?xmm everything like data?><doc/>";
4279 const XML_Char *expected = XCS("xmm: everything like data\n");
4280 CharData storage;
4281
4282 CharData_Init(&storage);
4283 XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
4284 XML_SetUserData(g_parser, &storage);
4285 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4286 == XML_STATUS_ERROR)
4287 xml_failure(g_parser);
4288 CharData_CheckXMLChars(&storage, expected);
4289}
4290END_TEST
4291
4292START_TEST(test_utf16_pi) {
4293 const char text[] =
4294 /* <?{KHO KHWAI}{CHO CHAN}?>
4295 * where {KHO KHWAI} = U+0E04
4296 * and {CHO CHAN} = U+0E08
4297 */
4298 "<\0?\0\x04\x0e\x08\x0e?\0>\0"
4299 /* <q/> */
4300 "<\0q\0/\0>\0";
4301#ifdef XML_UNICODE
4302 const XML_Char *expected = XCS("\x0e04\x0e08: \n");
4303#else
4304 const XML_Char *expected = XCS("\xe0\xb8\x84\xe0\xb8\x88: \n");
4305#endif
4306 CharData storage;
4307
4308 CharData_Init(&storage);
4309 XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
4310 XML_SetUserData(g_parser, &storage);
4311 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
4312 == XML_STATUS_ERROR)
4313 xml_failure(g_parser);
4314 CharData_CheckXMLChars(&storage, expected);
4315}
4316END_TEST
4317
4318START_TEST(test_utf16_be_pi) {
4319 const char text[] =
4320 /* <?{KHO KHWAI}{CHO CHAN}?>
4321 * where {KHO KHWAI} = U+0E04
4322 * and {CHO CHAN} = U+0E08
4323 */
4324 "\0<\0?\x0e\x04\x0e\x08\0?\0>"
4325 /* <q/> */
4326 "\0<\0q\0/\0>";
4327#ifdef XML_UNICODE
4328 const XML_Char *expected = XCS("\x0e04\x0e08: \n");
4329#else
4330 const XML_Char *expected = XCS("\xe0\xb8\x84\xe0\xb8\x88: \n");
4331#endif
4332 CharData storage;
4333
4334 CharData_Init(&storage);
4335 XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
4336 XML_SetUserData(g_parser, &storage);
4337 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
4338 == XML_STATUS_ERROR)
4339 xml_failure(g_parser);
4340 CharData_CheckXMLChars(&storage, expected);
4341}
4342END_TEST
4343
4344/* Test that comments can be picked up and translated */
4345START_TEST(test_utf16_be_comment) {
4346 const char text[] =
4347 /* <!-- Comment A --> */
4348 "\0<\0!\0-\0-\0 \0C\0o\0m\0m\0e\0n\0t\0 \0A\0 \0-\0-\0>\0\n"
4349 /* <doc/> */
4350 "\0<\0d\0o\0c\0/\0>";
4351 const XML_Char *expected = XCS(" Comment A ");
4352 CharData storage;
4353
4354 CharData_Init(&storage);
4355 XML_SetCommentHandler(g_parser, accumulate_comment);
4356 XML_SetUserData(g_parser, &storage);
4357 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
4358 == XML_STATUS_ERROR)
4359 xml_failure(g_parser);
4360 CharData_CheckXMLChars(&storage, expected);
4361}
4362END_TEST
4363
4364START_TEST(test_utf16_le_comment) {
4365 const char text[] =
4366 /* <!-- Comment B --> */
4367 "<\0!\0-\0-\0 \0C\0o\0m\0m\0e\0n\0t\0 \0B\0 \0-\0-\0>\0\n\0"
4368 /* <doc/> */
4369 "<\0d\0o\0c\0/\0>\0";
4370 const XML_Char *expected = XCS(" Comment B ");
4371 CharData storage;
4372
4373 CharData_Init(&storage);
4374 XML_SetCommentHandler(g_parser, accumulate_comment);
4375 XML_SetUserData(g_parser, &storage);
4376 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
4377 == XML_STATUS_ERROR)
4378 xml_failure(g_parser);
4379 CharData_CheckXMLChars(&storage, expected);
4380}
4381END_TEST
4382
4383/* Test that the unknown encoding handler with map entries that expect
4384 * conversion but no conversion function is faulted
4385 */
4386START_TEST(test_missing_encoding_conversion_fn) {
4387 const char *text = "<?xml version='1.0' encoding='no-conv'?>\n"
4388 "<doc>\x81</doc>";
4389
4390 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4391 /* MiscEncodingHandler sets up an encoding with every top-bit-set
4392 * character introducing a two-byte sequence. For this, it
4393 * requires a convert function. The above function call doesn't
4394 * pass one through, so when BadEncodingHandler actually gets
4395 * called it should supply an invalid encoding.
4396 */
4397 expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
4398 "Encoding with missing convert() not faulted");
4399}
4400END_TEST
4401
4402START_TEST(test_failing_encoding_conversion_fn) {
4403 const char *text = "<?xml version='1.0' encoding='failing-conv'?>\n"
4404 "<doc>\x81</doc>";
4405
4406 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4407 /* BadEncodingHandler sets up an encoding with every top-bit-set
4408 * character introducing a two-byte sequence. For this, it
4409 * requires a convert function. The above function call passes
4410 * one that insists all possible sequences are invalid anyway.
4411 */
4412 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4413 "Encoding with failing convert() not faulted");
4414}
4415END_TEST
4416
4417/* Test unknown encoding conversions */
4418START_TEST(test_unknown_encoding_success) {
4419 const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
4420 /* Equivalent to <eoc>Hello, world</eoc> */
4421 "<\x81\x64\x80oc>Hello, world</\x81\x64\x80oc>";
4422
4423 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4424 run_character_check(text, XCS("Hello, world"));
4425}
4426END_TEST
4427
4428/* Test bad name character in unknown encoding */
4429START_TEST(test_unknown_encoding_bad_name) {
4430 const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
4431 "<\xff\x64oc>Hello, world</\xff\x64oc>";
4432
4433 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4434 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4435 "Bad name start in unknown encoding not faulted");
4436}
4437END_TEST
4438
4439/* Test bad mid-name character in unknown encoding */
4440START_TEST(test_unknown_encoding_bad_name_2) {
4441 const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
4442 "<d\xffoc>Hello, world</d\xffoc>";
4443
4444 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4445 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4446 "Bad name in unknown encoding not faulted");
4447}
4448END_TEST
4449
4450/* Test element name that is long enough to fill the conversion buffer
4451 * in an unknown encoding, finishing with an encoded character.
4452 */
4453START_TEST(test_unknown_encoding_long_name_1) {
4454 const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
4455 "<abcdefghabcdefghabcdefghijkl\x80m\x80n\x80o\x80p>"
4456 "Hi"
4457 "</abcdefghabcdefghabcdefghijkl\x80m\x80n\x80o\x80p>";
4458 const XML_Char *expected = XCS("abcdefghabcdefghabcdefghijklmnop");
4459 CharData storage;
4460
4461 CharData_Init(&storage);
4462 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4463 XML_SetStartElementHandler(g_parser, record_element_start_handler);
4464 XML_SetUserData(g_parser, &storage);
4465 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4466 == XML_STATUS_ERROR)
4467 xml_failure(g_parser);
4468 CharData_CheckXMLChars(&storage, expected);
4469}
4470END_TEST
4471
4472/* Test element name that is long enough to fill the conversion buffer
4473 * in an unknown encoding, finishing with an simple character.
4474 */
4475START_TEST(test_unknown_encoding_long_name_2) {
4476 const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
4477 "<abcdefghabcdefghabcdefghijklmnop>"
4478 "Hi"
4479 "</abcdefghabcdefghabcdefghijklmnop>";
4480 const XML_Char *expected = XCS("abcdefghabcdefghabcdefghijklmnop");
4481 CharData storage;
4482
4483 CharData_Init(&storage);
4484 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4485 XML_SetStartElementHandler(g_parser, record_element_start_handler);
4486 XML_SetUserData(g_parser, &storage);
4487 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4488 == XML_STATUS_ERROR)
4489 xml_failure(g_parser);
4490 CharData_CheckXMLChars(&storage, expected);
4491}
4492END_TEST
4493
4494START_TEST(test_invalid_unknown_encoding) {
4495 const char *text = "<?xml version='1.0' encoding='invalid-9'?>\n"
4496 "<doc>Hello world</doc>";
4497
4498 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4499 expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
4500 "Invalid unknown encoding not faulted");
4501}
4502END_TEST
4503
4504START_TEST(test_unknown_ascii_encoding_ok) {
4505 const char *text = "<?xml version='1.0' encoding='ascii-like'?>\n"
4506 "<doc>Hello, world</doc>";
4507
4508 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4509 run_character_check(text, XCS("Hello, world"));
4510}
4511END_TEST
4512
4513START_TEST(test_unknown_ascii_encoding_fail) {
4514 const char *text = "<?xml version='1.0' encoding='ascii-like'?>\n"
4515 "<doc>Hello, \x80 world</doc>";
4516
4517 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4518 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4519 "Invalid character not faulted");
4520}
4521END_TEST
4522
4523START_TEST(test_unknown_encoding_invalid_length) {
4524 const char *text = "<?xml version='1.0' encoding='invalid-len'?>\n"
4525 "<doc>Hello, world</doc>";
4526
4527 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4528 expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
4529 "Invalid unknown encoding not faulted");
4530}
4531END_TEST
4532
4533START_TEST(test_unknown_encoding_invalid_topbit) {
4534 const char *text = "<?xml version='1.0' encoding='invalid-a'?>\n"
4535 "<doc>Hello, world</doc>";
4536
4537 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4538 expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
4539 "Invalid unknown encoding not faulted");
4540}
4541END_TEST
4542
4543START_TEST(test_unknown_encoding_invalid_surrogate) {
4544 const char *text = "<?xml version='1.0' encoding='invalid-surrogate'?>\n"
4545 "<doc>Hello, \x82 world</doc>";
4546
4547 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4548 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4549 "Invalid unknown encoding not faulted");
4550}
4551END_TEST
4552
4553START_TEST(test_unknown_encoding_invalid_high) {
4554 const char *text = "<?xml version='1.0' encoding='invalid-high'?>\n"
4555 "<doc>Hello, world</doc>";
4556
4557 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4558 expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
4559 "Invalid unknown encoding not faulted");
4560}
4561END_TEST
4562
4563START_TEST(test_unknown_encoding_invalid_attr_value) {
4564 const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
4565 "<doc attr='\xff\x30'/>";
4566
4567 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
4568 expect_failure(text, XML_ERROR_INVALID_TOKEN,
4569 "Invalid attribute valid not faulted");
4570}
4571END_TEST
4572
4573START_TEST(test_unknown_encoding_user_data_primary) {
4574 // This test is based on ideas contributed by Artiphishell Inc.
4575 const char *const text = "<?xml version='1.0' encoding='x-unk'?>\n"
4576 "<root />\n";
4577 XML_Parser parser = XML_ParserCreate(NULL);
4578 XML_SetUnknownEncodingHandler(parser,
4579 user_data_checking_unknown_encoding_handler,
4580 (void *)(intptr_t)0xC0FFEE);
4581
4582 assert_true(_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE)
4583 == XML_STATUS_OK);
4584
4585 XML_ParserFree(parser);
4586}
4587END_TEST
4588
4589START_TEST(test_unknown_encoding_user_data_secondary) {
4590 // This test is based on ideas contributed by Artiphishell Inc.
4591 const char *const text_main = "<!DOCTYPE r [\n"
4592 " <!ENTITY ext SYSTEM 'ext.ent'>\n"
4593 "]>\n"
4594 "<r>&ext;</r>\n";
4595 const char *const text_external = "<?xml version='1.0' encoding='x-unk'?>\n"
4596 "<e>data</e>";
4597 ExtTest2 test_data = {text_external, (int)strlen(text_external), NULL, NULL};
4598 XML_Parser parser = XML_ParserCreate(NULL);
4599 XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
4600 XML_SetUnknownEncodingHandler(parser,
4601 user_data_checking_unknown_encoding_handler,
4602 (void *)(intptr_t)0xC0FFEE);
4603 XML_SetUserData(parser, &test_data);
4604
4605 assert_true(_XML_Parse_SINGLE_BYTES(parser, text_main, (int)strlen(text_main),
4606 XML_TRUE)
4607 == XML_STATUS_OK);
4608
4609 XML_ParserFree(parser);
4610}
4611END_TEST
4612
4613/* Test an external entity parser set to use latin-1 detects UTF-16
4614 * BOMs correctly.
4615 */
4616/* Test that UTF-16 BOM does not select UTF-16 given explicit encoding */
4617START_TEST(test_ext_entity_latin1_utf16le_bom) {
4618 const char *text = "<!DOCTYPE doc [\n"
4619 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
4620 "]>\n"
4621 "<doc>&en;</doc>";
4622 ExtTest2 test_data
4623 = {/* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
4624 /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
4625 * 0x4c = L and 0x20 is a space
4626 */
4627 "\xff\xfe\x4c\x20", 4, XCS("iso-8859-1"), NULL};
4628#ifdef XML_UNICODE
4629 const XML_Char *expected = XCS("\x00ff\x00feL ");
4630#else
4631 /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
4632 const XML_Char *expected = XCS("\xc3\xbf\xc3\xbeL ");
4633#endif
4634 CharData storage;
4635
4636 CharData_Init(&storage);
4637 test_data.storage = &storage;
4638 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
4639 XML_SetUserData(g_parser, &test_data);
4640 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
4641 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4642 == XML_STATUS_ERROR)
4643 xml_failure(g_parser);
4644 CharData_CheckXMLChars(&storage, expected);
4645}
4646END_TEST
4647
4648START_TEST(test_ext_entity_latin1_utf16be_bom) {
4649 const char *text = "<!DOCTYPE doc [\n"
4650 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
4651 "]>\n"
4652 "<doc>&en;</doc>";
4653 ExtTest2 test_data
4654 = {/* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
4655 /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
4656 * 0x4c = L and 0x20 is a space
4657 */
4658 "\xfe\xff\x20\x4c", 4, XCS("iso-8859-1"), NULL};
4659#ifdef XML_UNICODE
4660 const XML_Char *expected = XCS("\x00fe\x00ff L");
4661#else
4662 /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
4663 const XML_Char *expected = XCS("\xc3\xbe\xc3\xbf L");
4664#endif
4665 CharData storage;
4666
4667 CharData_Init(&storage);
4668 test_data.storage = &storage;
4669 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
4670 XML_SetUserData(g_parser, &test_data);
4671 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
4672 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4673 == XML_STATUS_ERROR)
4674 xml_failure(g_parser);
4675 CharData_CheckXMLChars(&storage, expected);
4676}
4677END_TEST
4678
4679/* Parsing the full buffer rather than a byte at a time makes a
4680 * difference to the encoding scanning code, so repeat the above tests
4681 * without breaking them down by byte.
4682 */
4683START_TEST(test_ext_entity_latin1_utf16le_bom2) {
4684 const char *text = "<!DOCTYPE doc [\n"
4685 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
4686 "]>\n"
4687 "<doc>&en;</doc>";
4688 ExtTest2 test_data
4689 = {/* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
4690 /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
4691 * 0x4c = L and 0x20 is a space
4692 */
4693 "\xff\xfe\x4c\x20", 4, XCS("iso-8859-1"), NULL};
4694#ifdef XML_UNICODE
4695 const XML_Char *expected = XCS("\x00ff\x00feL ");
4696#else
4697 /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
4698 const XML_Char *expected = XCS("\xc3\xbf\xc3\xbeL ");
4699#endif
4700 CharData storage;
4701
4702 CharData_Init(&storage);
4703 test_data.storage = &storage;
4704 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
4705 XML_SetUserData(g_parser, &test_data);
4706 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
4707 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4708 == XML_STATUS_ERROR)
4709 xml_failure(g_parser);
4710 CharData_CheckXMLChars(&storage, expected);
4711}
4712END_TEST
4713
4714START_TEST(test_ext_entity_latin1_utf16be_bom2) {
4715 const char *text = "<!DOCTYPE doc [\n"
4716 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
4717 "]>\n"
4718 "<doc>&en;</doc>";
4719 ExtTest2 test_data
4720 = {/* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
4721 /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
4722 * 0x4c = L and 0x20 is a space
4723 */
4724 "\xfe\xff\x20\x4c", 4, XCS("iso-8859-1"), NULL};
4725#ifdef XML_UNICODE
4726 const XML_Char *expected = XCS("\x00fe\x00ff L");
4727#else
4728 /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
4729 const XML_Char *expected = "\xc3\xbe\xc3\xbf L";
4730#endif
4731 CharData storage;
4732
4733 CharData_Init(&storage);
4734 test_data.storage = &storage;
4735 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
4736 XML_SetUserData(g_parser, &test_data);
4737 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
4738 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4739 == XML_STATUS_ERROR)
4740 xml_failure(g_parser);
4741 CharData_CheckXMLChars(&storage, expected);
4742}
4743END_TEST
4744
4745/* Test little-endian UTF-16 given an explicit big-endian encoding */
4746START_TEST(test_ext_entity_utf16_be) {
4747 const char *text = "<!DOCTYPE doc [\n"
4748 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
4749 "]>\n"
4750 "<doc>&en;</doc>";
4751 ExtTest2 test_data = {"<\0e\0/\0>\0", 8, XCS("utf-16be"), NULL};
4752#ifdef XML_UNICODE
4753 const XML_Char *expected = XCS("\x3c00\x6500\x2f00\x3e00");
4754#else
4755 const XML_Char *expected = XCS("\xe3\xb0\x80" /* U+3C00 */
4756 "\xe6\x94\x80" /* U+6500 */
4757 "\xe2\xbc\x80" /* U+2F00 */
4758 "\xe3\xb8\x80"); /* U+3E00 */
4759#endif
4760 CharData storage;
4761
4762 CharData_Init(&storage);
4763 test_data.storage = &storage;
4764 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
4765 XML_SetUserData(g_parser, &test_data);
4766 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
4767 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4768 == XML_STATUS_ERROR)
4769 xml_failure(g_parser);
4770 CharData_CheckXMLChars(&storage, expected);
4771}
4772END_TEST
4773
4774/* Test big-endian UTF-16 given an explicit little-endian encoding */
4775START_TEST(test_ext_entity_utf16_le) {
4776 const char *text = "<!DOCTYPE doc [\n"
4777 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
4778 "]>\n"
4779 "<doc>&en;</doc>";
4780 ExtTest2 test_data = {"\0<\0e\0/\0>", 8, XCS("utf-16le"), NULL};
4781#ifdef XML_UNICODE
4782 const XML_Char *expected = XCS("\x3c00\x6500\x2f00\x3e00");
4783#else
4784 const XML_Char *expected = XCS("\xe3\xb0\x80" /* U+3C00 */
4785 "\xe6\x94\x80" /* U+6500 */
4786 "\xe2\xbc\x80" /* U+2F00 */
4787 "\xe3\xb8\x80"); /* U+3E00 */
4788#endif
4789 CharData storage;
4790
4791 CharData_Init(&storage);
4792 test_data.storage = &storage;
4793 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
4794 XML_SetUserData(g_parser, &test_data);
4795 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
4796 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4797 == XML_STATUS_ERROR)
4798 xml_failure(g_parser);
4799 CharData_CheckXMLChars(&storage, expected);
4800}
4801END_TEST
4802
4803/* Test little-endian UTF-16 given no explicit encoding.
4804 * The existing default encoding (UTF-8) is assumed to hold without a
4805 * BOM to contradict it, so the entity value will in fact provoke an
4806 * error because 0x00 is not a valid XML character. We parse the
4807 * whole buffer in one go rather than feeding it in byte by byte to
4808 * exercise different code paths in the initial scanning routines.
4809 */
4810START_TEST(test_ext_entity_utf16_unknown) {
4811 const char *text = "<!DOCTYPE doc [\n"
4812 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
4813 "]>\n"
4814 "<doc>&en;</doc>";
4815 ExtFaults2 test_data
4816 = {"a\0b\0c\0", 6, "Invalid character in entity not faulted", NULL,
4817 XML_ERROR_INVALID_TOKEN};
4818
4819 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter2);
4820 XML_SetUserData(g_parser, &test_data);
4821 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
4822 "Invalid character should not have been accepted");
4823}
4824END_TEST
4825
4826/* Test not-quite-UTF-8 BOM (0xEF 0xBB 0xBF) */
4827START_TEST(test_ext_entity_utf8_non_bom) {
4828 const char *text = "<!DOCTYPE doc [\n"
4829 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
4830 "]>\n"
4831 "<doc>&en;</doc>";
4832 ExtTest2 test_data
4833 = {"\xef\xbb\x80", /* Arabic letter DAD medial form, U+FEC0 */
4834 3, NULL, NULL};
4835#ifdef XML_UNICODE
4836 const XML_Char *expected = XCS("\xfec0");
4837#else
4838 const XML_Char *expected = XCS("\xef\xbb\x80");
4839#endif
4840 CharData storage;
4841
4842 CharData_Init(&storage);
4843 test_data.storage = &storage;
4844 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
4845 XML_SetUserData(g_parser, &test_data);
4846 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
4847 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4848 == XML_STATUS_ERROR)
4849 xml_failure(g_parser);
4850 CharData_CheckXMLChars(&storage, expected);
4851}
4852END_TEST
4853
4854/* Test that UTF-8 in a CDATA section is correctly passed through */
4855START_TEST(test_utf8_in_cdata_section) {
4856 const char *text = "<doc><![CDATA[one \xc3\xa9 two]]></doc>";
4857#ifdef XML_UNICODE
4858 const XML_Char *expected = XCS("one \x00e9 two");
4859#else
4860 const XML_Char *expected = XCS("one \xc3\xa9 two");
4861#endif
4862
4863 run_character_check(text, expected);
4864}
4865END_TEST
4866
4867/* Test that little-endian UTF-16 in a CDATA section is handled */
4868START_TEST(test_utf8_in_cdata_section_2) {
4869 const char *text = "<doc><![CDATA[\xc3\xa9]\xc3\xa9two]]></doc>";
4870#ifdef XML_UNICODE
4871 const XML_Char *expected = XCS("\x00e9]\x00e9two");
4872#else
4873 const XML_Char *expected = XCS("\xc3\xa9]\xc3\xa9two");
4874#endif
4875
4876 run_character_check(text, expected);
4877}
4878END_TEST
4879
4880START_TEST(test_utf8_in_start_tags) {
4881 struct test_case {
4882 bool goodName;
4883 bool goodNameStart;
4884 const char *tagName;
4885 };
4886
4887 // The idea with the tests below is this:
4888 // We want to cover 1-, 2- and 3-byte sequences, 4-byte sequences
4889 // go to isNever and are hence not a concern.
4890 //
4891 // We start with a character that is a valid name character
4892 // (or even name-start character, see XML 1.0r4 spec) and then we flip
4893 // single bits at places where (1) the result leaves the UTF-8 encoding space
4894 // and (2) we stay in the same n-byte sequence family.
4895 //
4896 // The flipped bits are highlighted in angle brackets in comments,
4897 // e.g. "[<1>011 1001]" means we had [0011 1001] but we now flipped
4898 // the most significant bit to 1 to leave UTF-8 encoding space.
4899 struct test_case cases[] = {
4900 // 1-byte UTF-8: [0xxx xxxx]
4901 {true, true, "\x3A"}, // [0011 1010] = ASCII colon ':'
4902 {false, false, "\xBA"}, // [<1>011 1010]
4903 {true, false, "\x39"}, // [0011 1001] = ASCII nine '9'
4904 {false, false, "\xB9"}, // [<1>011 1001]
4905
4906 // 2-byte UTF-8: [110x xxxx] [10xx xxxx]
4907 {true, true, "\xDB\xA5"}, // [1101 1011] [1010 0101] =
4908 // Arabic small waw U+06E5
4909 {false, false, "\x9B\xA5"}, // [1<0>01 1011] [1010 0101]
4910 {false, false, "\xDB\x25"}, // [1101 1011] [<0>010 0101]
4911 {false, false, "\xDB\xE5"}, // [1101 1011] [1<1>10 0101]
4912 {true, false, "\xCC\x81"}, // [1100 1100] [1000 0001] =
4913 // combining char U+0301
4914 {false, false, "\x8C\x81"}, // [1<0>00 1100] [1000 0001]
4915 {false, false, "\xCC\x01"}, // [1100 1100] [<0>000 0001]
4916 {false, false, "\xCC\xC1"}, // [1100 1100] [1<1>00 0001]
4917
4918 // 3-byte UTF-8: [1110 xxxx] [10xx xxxx] [10xxxxxx]
4919 {true, true, "\xE0\xA4\x85"}, // [1110 0000] [1010 0100] [1000 0101] =
4920 // Devanagari Letter A U+0905
4921 {false, false, "\xA0\xA4\x85"}, // [1<0>10 0000] [1010 0100] [1000 0101]
4922 {false, false, "\xE0\x24\x85"}, // [1110 0000] [<0>010 0100] [1000 0101]
4923 {false, false, "\xE0\xE4\x85"}, // [1110 0000] [1<1>10 0100] [1000 0101]
4924 {false, false, "\xE0\xA4\x05"}, // [1110 0000] [1010 0100] [<0>000 0101]
4925 {false, false, "\xE0\xA4\xC5"}, // [1110 0000] [1010 0100] [1<1>00 0101]
4926 {true, false, "\xE0\xA4\x81"}, // [1110 0000] [1010 0100] [1000 0001] =
4927 // combining char U+0901
4928 {false, false, "\xA0\xA4\x81"}, // [1<0>10 0000] [1010 0100] [1000 0001]
4929 {false, false, "\xE0\x24\x81"}, // [1110 0000] [<0>010 0100] [1000 0001]
4930 {false, false, "\xE0\xE4\x81"}, // [1110 0000] [1<1>10 0100] [1000 0001]
4931 {false, false, "\xE0\xA4\x01"}, // [1110 0000] [1010 0100] [<0>000 0001]
4932 {false, false, "\xE0\xA4\xC1"}, // [1110 0000] [1010 0100] [1<1>00 0001]
4933 };
4934 const bool atNameStart[] = {true, false};
4935
4936 size_t i = 0;
4937 char doc[1024];
4938 size_t failCount = 0;
4939
4940 // we need all the bytes to be parsed, but we don't want the errors that can
4941 // trigger on isFinal=XML_TRUE, so we skip the test if the heuristic is on.
4942 if (g_reparseDeferralEnabledDefault) {
4943 return;
4944 }
4945
4946 for (; i < sizeof(cases) / sizeof(cases[0]); i++) {
4947 size_t j = 0;
4948 for (; j < sizeof(atNameStart) / sizeof(atNameStart[0]); j++) {
4949 const bool expectedSuccess
4950 = atNameStart[j] ? cases[i].goodNameStart : cases[i].goodName;
4951 snprintf(doc, sizeof(doc), "<%s%s><!--", atNameStart[j] ? "" : "a",
4952 cases[i].tagName);
4953 XML_Parser parser = XML_ParserCreate(NULL);
4954
4955 const enum XML_Status status = _XML_Parse_SINGLE_BYTES(
4956 parser, doc, (int)strlen(doc), /*isFinal=*/XML_FALSE);
4957
4958 bool success = true;
4959 if ((status == XML_STATUS_OK) != expectedSuccess) {
4960 success = false;
4961 }
4962 if ((status == XML_STATUS_ERROR)
4963 && (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)) {
4964 success = false;
4965 }
4966
4967 if (! success) {
4968 fprintf(
4969 stderr,
4970 "FAIL case %2u (%sat name start, %u-byte sequence, error code %d)\n",
4971 (unsigned)i + 1u, atNameStart[j] ? " " : "not ",
4972 (unsigned)strlen(cases[i].tagName), XML_GetErrorCode(parser));
4973 failCount++;
4974 }
4975
4976 XML_ParserFree(parser);
4977 }
4978 }
4979
4980 if (failCount > 0) {
4981 fail("UTF-8 regression detected");
4982 }
4983}
4984END_TEST
4985
4986/* Test trailing spaces in elements are accepted */
4987START_TEST(test_trailing_spaces_in_elements) {
4988 const char *text = "<doc >Hi</doc >";
4989 const XML_Char *expected = XCS("doc/doc");
4990 CharData storage;
4991
4992 CharData_Init(&storage);
4993 XML_SetElementHandler(g_parser, record_element_start_handler,
4994 record_element_end_handler);
4995 XML_SetUserData(g_parser, &storage);
4996 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
4997 == XML_STATUS_ERROR)
4998 xml_failure(g_parser);
4999 CharData_CheckXMLChars(&storage, expected);
5000}
5001END_TEST
5002
5003START_TEST(test_utf16_attribute) {
5004 const char text[] =
5005 /* <d {KHO KHWAI}{CHO CHAN}='a'/>
5006 * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
5007 * and {CHO CHAN} = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
5008 */
5009 "<\0d\0 \0\x04\x0e\x08\x0e=\0'\0a\0'\0/\0>\0";
5010 const XML_Char *expected = XCS("a");
5011 CharData storage;
5012
5013 CharData_Init(&storage);
5014 XML_SetStartElementHandler(g_parser, accumulate_attribute);
5015 XML_SetUserData(g_parser, &storage);
5016 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5017 == XML_STATUS_ERROR)
5018 xml_failure(g_parser);
5019 CharData_CheckXMLChars(&storage, expected);
5020}
5021END_TEST
5022
5023START_TEST(test_utf16_second_attr) {
5024 /* <d a='1' {KHO KHWAI}{CHO CHAN}='2'/>
5025 * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
5026 * and {CHO CHAN} = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
5027 */
5028 const char text[] = "<\0d\0 \0a\0=\0'\0\x31\0'\0 \0"
5029 "\x04\x0e\x08\x0e=\0'\0\x32\0'\0/\0>\0";
5030 const XML_Char *expected = XCS("1");
5031 CharData storage;
5032
5033 CharData_Init(&storage);
5034 XML_SetStartElementHandler(g_parser, accumulate_attribute);
5035 XML_SetUserData(g_parser, &storage);
5036 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5037 == XML_STATUS_ERROR)
5038 xml_failure(g_parser);
5039 CharData_CheckXMLChars(&storage, expected);
5040}
5041END_TEST
5042
5043START_TEST(test_attr_after_solidus) {
5044 const char *text = "<doc attr1='a' / attr2='b'>";
5045
5046 expect_failure(text, XML_ERROR_INVALID_TOKEN, "Misplaced / not faulted");
5047}
5048END_TEST
5049
5050START_TEST(test_utf16_pe) {
5051 /* <!DOCTYPE doc [
5052 * <!ENTITY % {KHO KHWAI}{CHO CHAN} '<!ELEMENT doc (#PCDATA)>'>
5053 * %{KHO KHWAI}{CHO CHAN};
5054 * ]>
5055 * <doc></doc>
5056 *
5057 * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
5058 * and {CHO CHAN} = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
5059 */
5060 const char text[] = "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0\n"
5061 "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \x0e\x04\x0e\x08\0 "
5062 "\0'\0<\0!\0E\0L\0E\0M\0E\0N\0T\0 "
5063 "\0d\0o\0c\0 \0(\0#\0P\0C\0D\0A\0T\0A\0)\0>\0'\0>\0\n"
5064 "\0%\x0e\x04\x0e\x08\0;\0\n"
5065 "\0]\0>\0\n"
5066 "\0<\0d\0o\0c\0>\0<\0/\0d\0o\0c\0>";
5067#ifdef XML_UNICODE
5068 const XML_Char *expected = XCS("\x0e04\x0e08=<!ELEMENT doc (#PCDATA)>\n");
5069#else
5070 const XML_Char *expected
5071 = XCS("\xe0\xb8\x84\xe0\xb8\x88=<!ELEMENT doc (#PCDATA)>\n");
5072#endif
5073 CharData storage;
5074
5075 CharData_Init(&storage);
5076 XML_SetUserData(g_parser, &storage);
5077 XML_SetEntityDeclHandler(g_parser, accumulate_entity_decl);
5078 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5079 == XML_STATUS_ERROR)
5080 xml_failure(g_parser);
5081 CharData_CheckXMLChars(&storage, expected);
5082}
5083END_TEST
5084
5085/* Test that duff attribute description keywords are rejected */
5086START_TEST(test_bad_attr_desc_keyword) {
5087 const char *text = "<!DOCTYPE doc [\n"
5088 " <!ATTLIST doc attr CDATA #!IMPLIED>\n"
5089 "]>\n"
5090 "<doc />";
5091
5092 expect_failure(text, XML_ERROR_INVALID_TOKEN,
5093 "Bad keyword !IMPLIED not faulted");
5094}
5095END_TEST
5096
5097/* Test that an invalid attribute description keyword consisting of
5098 * UTF-16 characters with their top bytes non-zero are correctly
5099 * faulted
5100 */
5101START_TEST(test_bad_attr_desc_keyword_utf16) {
5102 /* <!DOCTYPE d [
5103 * <!ATTLIST d a CDATA #{KHO KHWAI}{CHO CHAN}>
5104 * ]><d/>
5105 *
5106 * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
5107 * and {CHO CHAN} = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
5108 */
5109 const char text[]
5110 = "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n"
5111 "\0<\0!\0A\0T\0T\0L\0I\0S\0T\0 \0d\0 \0a\0 \0C\0D\0A\0T\0A\0 "
5112 "\0#\x0e\x04\x0e\x08\0>\0\n"
5113 "\0]\0>\0<\0d\0/\0>";
5114
5115 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5116 != XML_STATUS_ERROR)
5117 fail("Invalid UTF16 attribute keyword not faulted");
5118 if (XML_GetErrorCode(g_parser) != XML_ERROR_SYNTAX)
5119 xml_failure(g_parser);
5120}
5121END_TEST
5122
5123/* Test that invalid syntax in a <!DOCTYPE> is rejected. Do this
5124 * using prefix-encoding (see above) to trigger specific code paths
5125 */
5126START_TEST(test_bad_doctype) {
5127 const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
5128 "<!DOCTYPE doc [ \x80\x44 ]><doc/>";
5129
5130 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
5131 expect_failure(text, XML_ERROR_SYNTAX,
5132 "Invalid bytes in DOCTYPE not faulted");
5133}
5134END_TEST
5135
5136START_TEST(test_bad_doctype_utf8) {
5137 const char *text = "<!DOCTYPE \xDB\x25"
5138 "doc><doc/>"; // [1101 1011] [<0>010 0101]
5139 expect_failure(text, XML_ERROR_INVALID_TOKEN,
5140 "Invalid UTF-8 in DOCTYPE not faulted");
5141}
5142END_TEST
5143
5144START_TEST(test_bad_doctype_utf16) {
5145 const char text[] =
5146 /* <!DOCTYPE doc [ \x06f2 ]><doc/>
5147 *
5148 * U+06F2 = EXTENDED ARABIC-INDIC DIGIT TWO, a valid number
5149 * (name character) but not a valid letter (name start character)
5150 */
5151 "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0 "
5152 "\x06\xf2"
5153 "\0 \0]\0>\0<\0d\0o\0c\0/\0>";
5154
5155 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5156 != XML_STATUS_ERROR)
5157 fail("Invalid bytes in DOCTYPE not faulted");
5158 if (XML_GetErrorCode(g_parser) != XML_ERROR_SYNTAX)
5159 xml_failure(g_parser);
5160}
5161END_TEST
5162
5163START_TEST(test_bad_doctype_plus) {
5164 const char *text = "<!DOCTYPE 1+ [ <!ENTITY foo 'bar'> ]>\n"
5165 "<1+>&foo;</1+>";
5166
5167 expect_failure(text, XML_ERROR_INVALID_TOKEN,
5168 "'+' in document name not faulted");
5169}
5170END_TEST
5171
5172START_TEST(test_bad_doctype_star) {
5173 const char *text = "<!DOCTYPE 1* [ <!ENTITY foo 'bar'> ]>\n"
5174 "<1*>&foo;</1*>";
5175
5176 expect_failure(text, XML_ERROR_INVALID_TOKEN,
5177 "'*' in document name not faulted");
5178}
5179END_TEST
5180
5181START_TEST(test_bad_doctype_query) {
5182 const char *text = "<!DOCTYPE 1? [ <!ENTITY foo 'bar'> ]>\n"
5183 "<1?>&foo;</1?>";
5184
5185 expect_failure(text, XML_ERROR_INVALID_TOKEN,
5186 "'?' in document name not faulted");
5187}
5188END_TEST
5189
5190START_TEST(test_unknown_encoding_bad_ignore) {
5191 const char *text = "<?xml version='1.0' encoding='prefix-conv'?>"
5192 "<!DOCTYPE doc SYSTEM 'foo'>"
5193 "<doc><e>&entity;</e></doc>";
5194 ExtFaults fault = {"<![IGNORE[<!ELEMENT \xffG (#PCDATA)*>]]>",
5195 "Invalid character not faulted", XCS("prefix-conv"),
5196 XML_ERROR_INVALID_TOKEN};
5197
5198 XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
5199 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
5200 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
5201 XML_SetUserData(g_parser, &fault);
5202 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
5203 "Bad IGNORE section with unknown encoding not failed");
5204}
5205END_TEST
5206
5207START_TEST(test_entity_in_utf16_be_attr) {
5208 const char text[] =
5209 /* <e a='ä ä'></e> */
5210 "\0<\0e\0 \0a\0=\0'\0&\0#\0\x32\0\x32\0\x38\0;\0 "
5211 "\0&\0#\0x\0\x30\0\x30\0E\0\x34\0;\0'\0>\0<\0/\0e\0>";
5212#ifdef XML_UNICODE
5213 const XML_Char *expected = XCS("\x00e4 \x00e4");
5214#else
5215 const XML_Char *expected = XCS("\xc3\xa4 \xc3\xa4");
5216#endif
5217 CharData storage;
5218
5219 CharData_Init(&storage);
5220 XML_SetUserData(g_parser, &storage);
5221 XML_SetStartElementHandler(g_parser, accumulate_attribute);
5222 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5223 == XML_STATUS_ERROR)
5224 xml_failure(g_parser);
5225 CharData_CheckXMLChars(&storage, expected);
5226}
5227END_TEST
5228
5229START_TEST(test_entity_in_utf16_le_attr) {
5230 const char text[] =
5231 /* <e a='ä ä'></e> */
5232 "<\0e\0 \0a\0=\0'\0&\0#\0\x32\0\x32\0\x38\0;\0 \0"
5233 "&\0#\0x\0\x30\0\x30\0E\0\x34\0;\0'\0>\0<\0/\0e\0>\0";
5234#ifdef XML_UNICODE
5235 const XML_Char *expected = XCS("\x00e4 \x00e4");
5236#else
5237 const XML_Char *expected = XCS("\xc3\xa4 \xc3\xa4");
5238#endif
5239 CharData storage;
5240
5241 CharData_Init(&storage);
5242 XML_SetUserData(g_parser, &storage);
5243 XML_SetStartElementHandler(g_parser, accumulate_attribute);
5244 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5245 == XML_STATUS_ERROR)
5246 xml_failure(g_parser);
5247 CharData_CheckXMLChars(&storage, expected);
5248}
5249END_TEST
5250
5251START_TEST(test_entity_public_utf16_be) {
5252 const char text[] =
5253 /* <!DOCTYPE d [ */
5254 "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n"
5255 /* <!ENTITY % e PUBLIC 'foo' 'bar.ent'> */
5256 "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \0e\0 \0P\0U\0B\0L\0I\0C\0 "
5257 "\0'\0f\0o\0o\0'\0 \0'\0b\0a\0r\0.\0e\0n\0t\0'\0>\0\n"
5258 /* %e; */
5259 "\0%\0e\0;\0\n"
5260 /* ]> */
5261 "\0]\0>\0\n"
5262 /* <d>&j;</d> */
5263 "\0<\0d\0>\0&\0j\0;\0<\0/\0d\0>";
5264 ExtTest2 test_data
5265 = {/* <!ENTITY j 'baz'> */
5266 "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0j\0 \0'\0b\0a\0z\0'\0>", 34, NULL, NULL};
5267 const XML_Char *expected = XCS("baz");
5268 CharData storage;
5269
5270 CharData_Init(&storage);
5271 test_data.storage = &storage;
5272 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
5273 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
5274 XML_SetUserData(g_parser, &test_data);
5275 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
5276 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5277 == XML_STATUS_ERROR)
5278 xml_failure(g_parser);
5279 CharData_CheckXMLChars(&storage, expected);
5280}
5281END_TEST
5282
5283START_TEST(test_entity_public_utf16_le) {
5284 const char text[] =
5285 /* <!DOCTYPE d [ */
5286 "<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n\0"
5287 /* <!ENTITY % e PUBLIC 'foo' 'bar.ent'> */
5288 "<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \0e\0 \0P\0U\0B\0L\0I\0C\0 \0"
5289 "'\0f\0o\0o\0'\0 \0'\0b\0a\0r\0.\0e\0n\0t\0'\0>\0\n\0"
5290 /* %e; */
5291 "%\0e\0;\0\n\0"
5292 /* ]> */
5293 "]\0>\0\n\0"
5294 /* <d>&j;</d> */
5295 "<\0d\0>\0&\0j\0;\0<\0/\0d\0>\0";
5296 ExtTest2 test_data
5297 = {/* <!ENTITY j 'baz'> */
5298 "<\0!\0E\0N\0T\0I\0T\0Y\0 \0j\0 \0'\0b\0a\0z\0'\0>\0", 34, NULL, NULL};
5299 const XML_Char *expected = XCS("baz");
5300 CharData storage;
5301
5302 CharData_Init(&storage);
5303 test_data.storage = &storage;
5304 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
5305 XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
5306 XML_SetUserData(g_parser, &test_data);
5307 XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
5308 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
5309 == XML_STATUS_ERROR)
5310 xml_failure(g_parser);
5311 CharData_CheckXMLChars(&storage, expected);
5312}
5313END_TEST
5314
5315/* Test that a doctype with neither an internal nor external subset is
5316 * faulted
5317 */
5318START_TEST(test_short_doctype) {
5319 const char *text = "<!DOCTYPE doc></doc>";
5320 expect_failure(text, XML_ERROR_INVALID_TOKEN,
5321 "DOCTYPE without subset not rejected");
5322}
5323END_TEST
5324
5325START_TEST(test_short_doctype_2) {
5326 const char *text = "<!DOCTYPE doc PUBLIC></doc>";
5327 expect_failure(text, XML_ERROR_SYNTAX,
5328 "DOCTYPE without Public ID not rejected");
5329}
5330END_TEST
5331
5332START_TEST(test_short_doctype_3) {
5333 const char *text = "<!DOCTYPE doc SYSTEM></doc>";
5334 expect_failure(text, XML_ERROR_SYNTAX,
5335 "DOCTYPE without System ID not rejected");
5336}
5337END_TEST
5338
5339START_TEST(test_long_doctype) {
5340 const char *text = "<!DOCTYPE doc PUBLIC 'foo' 'bar' 'baz'></doc>";
5341 expect_failure(text, XML_ERROR_SYNTAX, "DOCTYPE with extra ID not rejected");
5342}
5343END_TEST
5344
5345START_TEST(test_bad_entity) {
5346 const char *text = "<!DOCTYPE doc [\n"
5347 " <!ENTITY foo PUBLIC>\n"
5348 "]>\n"
5349 "<doc/>";
5350 expect_failure(text, XML_ERROR_SYNTAX,
5351 "ENTITY without Public ID is not rejected");
5352}
5353END_TEST
5354
5355/* Test unquoted value is faulted */
5356START_TEST(test_bad_entity_2) {
5357 const char *text = "<!DOCTYPE doc [\n"
5358 " <!ENTITY % foo bar>\n"
5359 "]>\n"
5360 "<doc/>";
5361 expect_failure(text, XML_ERROR_SYNTAX,
5362 "ENTITY without Public ID is not rejected");
5363}
5364END_TEST
5365
5366START_TEST(test_bad_entity_3) {
5367 const char *text = "<!DOCTYPE doc [\n"
5368 " <!ENTITY % foo PUBLIC>\n"
5369 "]>\n"
5370 "<doc/>";
5371 expect_failure(text, XML_ERROR_SYNTAX,
5372 "Parameter ENTITY without Public ID is not rejected");
5373}
5374END_TEST
5375
5376START_TEST(test_bad_entity_4) {
5377 const char *text = "<!DOCTYPE doc [\n"
5378 " <!ENTITY % foo SYSTEM>\n"
5379 "]>\n"
5380 "<doc/>";
5381 expect_failure(text, XML_ERROR_SYNTAX,
5382 "Parameter ENTITY without Public ID is not rejected");
5383}
5384END_TEST
5385
5386START_TEST(test_bad_notation) {
5387 const char *text = "<!DOCTYPE doc [\n"
5388 " <!NOTATION n SYSTEM>\n"
5389 "]>\n"
5390 "<doc/>";
5391 expect_failure(text, XML_ERROR_SYNTAX,
5392 "Notation without System ID is not rejected");
5393}
5394END_TEST
5395
5396/* Test for issue #11, wrongly suppressed default handler */
5397START_TEST(test_default_doctype_handler) {
5398 const char *text = "<!DOCTYPE doc PUBLIC 'pubname' 'test.dtd' [\n"
5399 " <!ENTITY foo 'bar'>\n"
5400 "]>\n"
5401 "<doc>&foo;</doc>";
5402 DefaultCheck test_data[] = {{XCS("'pubname'"), 9, XML_FALSE},
5403 {XCS("'test.dtd'"), 10, XML_FALSE},
5404 {NULL, 0, XML_FALSE}};
5405 int i;
5406
5407 XML_SetUserData(g_parser, &test_data);
5408 XML_SetDefaultHandler(g_parser, checking_default_handler);
5409 XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
5410 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
5411 == XML_STATUS_ERROR)
5412 xml_failure(g_parser);
5413 for (i = 0; test_data[i].expected != NULL; i++)
5414 if (! test_data[i].seen)
5415 fail("Default handler not run for public !DOCTYPE");
5416}
5417END_TEST
5418
5419START_TEST(test_empty_element_abort) {
5420 const char *text = "<abort/>";
5421
5422 XML_SetStartElementHandler(g_parser, start_element_suspender);
5423 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
5424 != XML_STATUS_ERROR)
5425 fail("Expected to error on abort");
5426}
5427END_TEST
5428
5429/* Regression test for GH issue #612: unfinished m_declAttributeType
5430 * allocation in ->m_tempPool can corrupt following allocation.
5431 */
5432START_TEST(test_pool_integrity_with_unfinished_attr) {
5433 const char *text = "<?xml version='1.0' encoding='UTF-8'?>\n"
5434 "<!DOCTYPE foo [\n"
5435 "<!ELEMENT foo ANY>\n"
5436 "<!ENTITY % entp SYSTEM \"external.dtd\">\n"
5437 "%entp;\n"
5438 "]>\n"
5439 "<a></a>\n";
5440 const XML_Char *expected = XCS("COMMENT");
5441 CharData storage;
5442
5443 CharData_Init(&storage);
5444 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
5445 XML_SetExternalEntityRefHandler(g_parser, external_entity_unfinished_attlist);
5446 XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
5447 XML_SetCommentHandler(g_parser, accumulate_comment);
5448 XML_SetUserData(g_parser, &storage);
5449 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
5450 == XML_STATUS_ERROR)
5451 xml_failure(g_parser);
5452 CharData_CheckXMLChars(&storage, expected);
5453}
5454END_TEST
5455
5456/* Test a possible early return location in internalEntityProcessor */
5457START_TEST(test_entity_ref_no_elements) {
5458 const char *const text = "<!DOCTYPE foo [\n"
5459 "<!ENTITY e1 \"test\">\n"
5460 "]> <foo>&e1;"; // intentionally missing newline
5461
5462 XML_Parser parser = XML_ParserCreate(NULL);
5463 assert_true(_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE)
5464 == XML_STATUS_ERROR);
5465 assert_true(XML_GetErrorCode(parser) == XML_ERROR_NO_ELEMENTS);
5466 XML_ParserFree(parser);
5467}
5468END_TEST
5469
5470/* Tests if chained entity references lead to unbounded recursion */
5471START_TEST(test_deep_nested_entity) {
5472 const size_t N_LINES = 60000;
5473 const size_t SIZE_PER_LINE = 50;
5474
5475 char *const text = (char *)malloc((N_LINES + 4) * SIZE_PER_LINE);
5476 if (text == NULL) {
5477 fail("malloc failed");
5478 }
5479
5480 char *textPtr = text;
5481
5482 // Create the XML
5483 textPtr += snprintf(textPtr, SIZE_PER_LINE,
5484 "<!DOCTYPE foo [\n"
5485 " <!ENTITY s0 'deepText'>\n");
5486
5487 for (size_t i = 1; i < N_LINES; ++i) {
5488 textPtr += snprintf(textPtr, SIZE_PER_LINE, " <!ENTITY s%lu '&s%lu;'>\n",
5489 (long unsigned)i, (long unsigned)(i - 1));
5490 }
5491
5492 snprintf(textPtr, SIZE_PER_LINE, "]> <foo>&s%lu;</foo>\n",
5493 (long unsigned)(N_LINES - 1));
5494
5495 const XML_Char *const expected = XCS("deepText");
5496
5497 CharData storage;
5498 CharData_Init(&storage);
5499
5500 XML_Parser parser = XML_ParserCreate(NULL);
5501
5502 XML_SetCharacterDataHandler(parser, accumulate_characters);
5503 XML_SetUserData(parser, &storage);
5504
5505 if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE)
5506 == XML_STATUS_ERROR)
5507 xml_failure(parser);
5508
5509 CharData_CheckXMLChars(&storage, expected);
5510 XML_ParserFree(parser);
5511 free(text);
5512}
5513END_TEST
5514
5515/* Tests if chained entity references in attributes
5516lead to unbounded recursion */
5517START_TEST(test_deep_nested_attribute_entity) {
5518 const size_t N_LINES = 60000;
5519 const size_t SIZE_PER_LINE = 100;
5520
5521 char *const text = (char *)malloc((N_LINES + 4) * SIZE_PER_LINE);
5522 if (text == NULL) {
5523 fail("malloc failed");
5524 }
5525
5526 char *textPtr = text;
5527
5528 // Create the XML
5529 textPtr += snprintf(textPtr, SIZE_PER_LINE,
5530 "<!DOCTYPE foo [\n"
5531 " <!ENTITY s0 'deepText'>\n");
5532
5533 for (size_t i = 1; i < N_LINES; ++i) {
5534 textPtr += snprintf(textPtr, SIZE_PER_LINE, " <!ENTITY s%lu '&s%lu;'>\n",
5535 (long unsigned)i, (long unsigned)(i - 1));
5536 }
5537
5538 snprintf(textPtr, SIZE_PER_LINE, "]> <foo name='&s%lu;'>mainText</foo>\n",
5539 (long unsigned)(N_LINES - 1));
5540
5541 AttrInfo doc_info[] = {{XCS("name"), XCS("deepText")}, {NULL, NULL}};
5542 ElementInfo info[] = {{XCS("foo"), 1, NULL, NULL}, {NULL, 0, NULL, NULL}};
5543 info[0].attributes = doc_info;
5544
5545 XML_Parser parser = XML_ParserCreate(NULL);
5546 ParserAndElementInfo parserPlusElemenInfo = {parser, info};
5547
5548 XML_SetStartElementHandler(parser, counting_start_element_handler);
5549 XML_SetUserData(parser, &parserPlusElemenInfo);
5550
5551 if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE)
5552 == XML_STATUS_ERROR)
5553 xml_failure(parser);
5554
5555 XML_ParserFree(parser);
5556 free(text);
5557}
5558END_TEST
5559
5560START_TEST(test_deep_nested_entity_delayed_interpretation) {
5561 const size_t N_LINES = 70000;
5562 const size_t SIZE_PER_LINE = 100;
5563
5564 char *const text = (char *)malloc((N_LINES + 4) * SIZE_PER_LINE);
5565 if (text == NULL) {
5566 fail("malloc failed");
5567 }
5568
5569 char *textPtr = text;
5570
5571 // Create the XML
5572 textPtr += snprintf(textPtr, SIZE_PER_LINE,
5573 "<!DOCTYPE foo [\n"
5574 " <!ENTITY %% s0 'deepText'>\n");
5575
5576 for (size_t i = 1; i < N_LINES; ++i) {
5577 textPtr += snprintf(textPtr, SIZE_PER_LINE,
5578 " <!ENTITY %% s%lu '%s%lu;'>\n", (long unsigned)i,
5579 (long unsigned)(i - 1));
5580 }
5581
5582 snprintf(textPtr, SIZE_PER_LINE,
5583 " <!ENTITY %% define_g \"<!ENTITY g '%s%lu;'>\">\n"
5584 " %%define_g;\n"
5585 "]>\n"
5586 "<foo/>\n",
5587 (long unsigned)(N_LINES - 1));
5588
5589 XML_Parser parser = XML_ParserCreate(NULL);
5590
5591 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
5592 if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE)
5593 == XML_STATUS_ERROR)
5594 xml_failure(parser);
5595
5596 XML_ParserFree(parser);
5597 free(text);
5598}
5599END_TEST
5600
5601START_TEST(test_nested_entity_suspend) {
5602 const char *const text = "<!DOCTYPE a [\n"
5603 " <!ENTITY e1 '<!--e1-->'>\n"
5604 " <!ENTITY e2 '<!--e2 head-->&e1;<!--e2 tail-->'>\n"
5605 " <!ENTITY e3 '<!--e3 head-->&e2;<!--e3 tail-->'>\n"
5606 "]>\n"
5607 "<a><!--start-->&e3;<!--end--></a>";
5608 const XML_Char *const expected = XCS("start") XCS("e3 head") XCS("e2 head")
5609 XCS("e1") XCS("e2 tail") XCS("e3 tail") XCS("end");
5610 CharData storage;
5611 CharData_Init(&storage);
5612 XML_Parser parser = XML_ParserCreate(NULL);
5613 ParserPlusStorage parserPlusStorage = {parser, &storage};
5614
5615 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
5616 XML_SetCommentHandler(parser, accumulate_and_suspend_comment_handler);
5617 XML_SetUserData(parser, &parserPlusStorage);
5618
5619 enum XML_Status status = XML_Parse(parser, text, (int)strlen(text), XML_TRUE);
5620 while (status == XML_STATUS_SUSPENDED) {
5621 status = XML_ResumeParser(parser);
5622 }
5623 if (status != XML_STATUS_OK)
5624 xml_failure(parser);
5625
5626 CharData_CheckXMLChars(&storage, expected);
5627 XML_ParserFree(parser);
5628}
5629END_TEST
5630
5631START_TEST(test_nested_entity_suspend_2) {
5632 const char *const text = "<!DOCTYPE doc [\n"
5633 " <!ENTITY ge1 'head1Ztail1'>\n"
5634 " <!ENTITY ge2 'head2&ge1;tail2'>\n"
5635 " <!ENTITY ge3 'head3&ge2;tail3'>\n"
5636 "]>\n"
5637 "<doc>&ge3;</doc>";
5638 const XML_Char *const expected = XCS("head3") XCS("head2") XCS("head1")
5639 XCS("Z") XCS("tail1") XCS("tail2") XCS("tail3");
5640 CharData storage;
5641 CharData_Init(&storage);
5642 XML_Parser parser = XML_ParserCreate(NULL);
5643 ParserPlusStorage parserPlusStorage = {parser, &storage};
5644
5645 XML_SetCharacterDataHandler(parser, accumulate_char_data_and_suspend);
5646 XML_SetUserData(parser, &parserPlusStorage);
5647
5648 enum XML_Status status = XML_Parse(parser, text, (int)strlen(text), XML_TRUE);
5649 while (status == XML_STATUS_SUSPENDED) {
5650 status = XML_ResumeParser(parser);
5651 }
5652 if (status != XML_STATUS_OK)
5653 xml_failure(parser);
5654
5655 CharData_CheckXMLChars(&storage, expected);
5656 XML_ParserFree(parser);
5657}
5658END_TEST
5659
5660#if defined(XML_TESTING)
5661/* Regression test for quadratic parsing on large tokens */
5662START_TEST(test_big_tokens_scale_linearly) {
5663 const struct {
5664 const char *pre;
5665 const char *post;
5666 } text[] = {
5667 {"<a>", "</a>"}, // assumed good, used as baseline
5668 {"<b><![CDATA[ value: ", " ]]></b>"}, // CDATA, performed OK before patch
5669 {"<c attr='", "'></c>"}, // big attribute, used to be O(N²)
5670 {"<d><!-- ", " --></d>"}, // long comment, used to be O(N²)
5671 {"<e><", "/></e>"}, // big elem name, used to be O(N²)
5672 };
5673 const int num_cases = sizeof(text) / sizeof(text[0]);
5674 char aaaaaa[4096];
5675 const int fillsize = (int)sizeof(aaaaaa);
5676 const int fillcount = 100;
5677 const unsigned approx_bytes = fillsize * fillcount; // ignore pre/post.
5678 const unsigned max_factor = 4;
5679 const unsigned max_scanned = max_factor * approx_bytes;
5680
5681 memset(aaaaaa, 'a', fillsize);
5682
5683 if (! g_reparseDeferralEnabledDefault) {
5684 return; // heuristic is disabled; we would get O(n^2) and fail.
5685 }
5686
5687 for (int i = 0; i < num_cases; ++i) {
5688 XML_Parser parser = XML_ParserCreate(NULL);
5689 assert_true(parser != NULL);
5690 enum XML_Status status;
5691 set_subtest("text=\"%saaaaaa%s\"", text[i].pre, text[i].post);
5692
5693 // parse the start text
5694 g_bytesScanned = 0;
5695 status = _XML_Parse_SINGLE_BYTES(parser, text[i].pre,
5696 (int)strlen(text[i].pre), XML_FALSE);
5697 if (status != XML_STATUS_OK) {
5698 xml_failure(parser);
5699 }
5700
5701 // parse lots of 'a', failing the test early if it takes too long
5702 unsigned past_max_count = 0;
5703 for (int f = 0; f < fillcount; ++f) {
5704 status = _XML_Parse_SINGLE_BYTES(parser, aaaaaa, fillsize, XML_FALSE);
5705 if (status != XML_STATUS_OK) {
5706 xml_failure(parser);
5707 }
5708 if (g_bytesScanned > max_scanned) {
5709 // We're not done, and have already passed the limit -- the test will
5710 // definitely fail. This block allows us to save time by failing early.
5711 const unsigned pushed
5712 = (unsigned)strlen(text[i].pre) + (f + 1) * fillsize;
5713 fprintf(
5714 stderr,
5715 "after %d/%d loops: pushed=%u scanned=%u (factor ~%.2f) max_scanned: %u (factor ~%u)\n",
5716 f + 1, fillcount, pushed, g_bytesScanned,
5717 g_bytesScanned / (double)pushed, max_scanned, max_factor);
5718 past_max_count++;
5719 // We are failing, but allow a few log prints first. If we don't reach
5720 // a count of five, the test will fail after the loop instead.
5721 assert_true(past_max_count < 5);
5722 }
5723 }
5724
5725 // parse the end text
5726 status = _XML_Parse_SINGLE_BYTES(parser, text[i].post,
5727 (int)strlen(text[i].post), XML_TRUE);
5728 if (status != XML_STATUS_OK) {
5729 xml_failure(parser);
5730 }
5731
5732 assert_true(g_bytesScanned > approx_bytes); // or the counter isn't working
5733 if (g_bytesScanned > max_scanned) {
5734 fprintf(
5735 stderr,
5736 "after all input: scanned=%u (factor ~%.2f) max_scanned: %u (factor ~%u)\n",
5737 g_bytesScanned, g_bytesScanned / (double)approx_bytes, max_scanned,
5738 max_factor);
5739 fail("scanned too many bytes");
5740 }
5741
5742 XML_ParserFree(parser);
5743 }
5744}
5745END_TEST
5746#endif
5747
5748START_TEST(test_set_reparse_deferral) {
5749 const char *const pre = "<d>";
5750 const char *const start = "<x attr='";
5751 const char *const end = "'></x>";
5752 char eeeeee[100];
5753 const int fillsize = (int)sizeof(eeeeee);
5754 memset(eeeeee, 'e', fillsize);
5755
5756 for (int enabled = 0; enabled <= 1; enabled += 1) {
5757 set_subtest("deferral=%d", enabled);
5758
5759 XML_Parser parser = XML_ParserCreate(NULL);
5760 assert_true(parser != NULL);
5761 assert_true(XML_SetReparseDeferralEnabled(parser, enabled));
5762 // pre-grow the buffer to avoid reparsing due to almost-fullness
5763 assert_true(XML_GetBuffer(parser, fillsize * 10103) != NULL);
5764
5765 CharData storage;
5766 CharData_Init(&storage);
5767 XML_SetUserData(parser, &storage);
5768 XML_SetStartElementHandler(parser, start_element_event_handler);
5769
5770 enum XML_Status status;
5771 // parse the start text
5772 status = XML_Parse(parser, pre, (int)strlen(pre), XML_FALSE);
5773 if (status != XML_STATUS_OK) {
5774 xml_failure(parser);
5775 }
5776 CharData_CheckXMLChars(&storage, XCS("d")); // first element should be done
5777
5778 // ..and the start of the token
5779 status = XML_Parse(parser, start, (int)strlen(start), XML_FALSE);
5780 if (status != XML_STATUS_OK) {
5781 xml_failure(parser);
5782 }
5783 CharData_CheckXMLChars(&storage, XCS("d")); // still just the first one
5784
5785 // try to parse lots of 'e', but the token isn't finished
5786 for (int c = 0; c < 100; ++c) {
5787 status = XML_Parse(parser, eeeeee, fillsize, XML_FALSE);
5788 if (status != XML_STATUS_OK) {
5789 xml_failure(parser);
5790 }
5791 }
5792 CharData_CheckXMLChars(&storage, XCS("d")); // *still* just the first one
5793
5794 // end the <x> token.
5795 status = XML_Parse(parser, end, (int)strlen(end), XML_FALSE);
5796 if (status != XML_STATUS_OK) {
5797 xml_failure(parser);
5798 }
5799
5800 if (enabled) {
5801 // In general, we may need to push more data to trigger a reparse attempt,
5802 // but in this test, the data is constructed to always require it.
5803 CharData_CheckXMLChars(&storage, XCS("d")); // or the test is incorrect
5804 // 2x the token length should suffice; the +1 covers the start and end.
5805 for (int c = 0; c < 101; ++c) {
5806 status = XML_Parse(parser, eeeeee, fillsize, XML_FALSE);
5807 if (status != XML_STATUS_OK) {
5808 xml_failure(parser);
5809 }
5810 }
5811 }
5812 CharData_CheckXMLChars(&storage, XCS("dx")); // the <x> should be done
5813
5814 XML_ParserFree(parser);
5815 }
5816}
5817END_TEST
5818
5819struct element_decl_data {
5820 XML_Parser parser;
5821 int count;
5822};
5823
5824static void
5825element_decl_counter(void *userData, const XML_Char *name, XML_Content *model) {
5826 UNUSED_P(name);
5827 struct element_decl_data *testdata = (struct element_decl_data *)userData;
5828 testdata->count += 1;
5829 XML_FreeContentModel(testdata->parser, model);
5830}
5831
5832static int
5833external_inherited_parser(XML_Parser p, const XML_Char *context,
5834 const XML_Char *base, const XML_Char *systemId,
5835 const XML_Char *publicId) {
5836 UNUSED_P(base);
5837 UNUSED_P(systemId);
5838 UNUSED_P(publicId);
5839 const char *const pre = "<!ELEMENT document ANY>\n";
5840 const char *const start = "<!ELEMENT ";
5841 const char *const end = " ANY>\n";
5842 const char *const post = "<!ELEMENT xyz ANY>\n";
5843 const int enabled = *(int *)XML_GetUserData(p);
5844 char eeeeee[100];
5845 char spaces[100];
5846 const int fillsize = (int)sizeof(eeeeee);
5847 assert_true(fillsize == (int)sizeof(spaces));
5848 memset(eeeeee, 'e', fillsize);
5849 memset(spaces, ' ', fillsize);
5850
5851 XML_Parser parser = XML_ExternalEntityParserCreate(p, context, NULL);
5852 assert_true(parser != NULL);
5853 // pre-grow the buffer to avoid reparsing due to almost-fullness
5854 assert_true(XML_GetBuffer(parser, fillsize * 10103) != NULL);
5855
5856 struct element_decl_data testdata;
5857 testdata.parser = parser;
5858 testdata.count = 0;
5859 XML_SetUserData(parser, &testdata);
5860 XML_SetElementDeclHandler(parser, element_decl_counter);
5861
5862 enum XML_Status status;
5863 // parse the initial text
5864 status = XML_Parse(parser, pre, (int)strlen(pre), XML_FALSE);
5865 if (status != XML_STATUS_OK) {
5866 xml_failure(parser);
5867 }
5868 assert_true(testdata.count == 1); // first element should be done
5869
5870 // ..and the start of the big token
5871 status = XML_Parse(parser, start, (int)strlen(start), XML_FALSE);
5872 if (status != XML_STATUS_OK) {
5873 xml_failure(parser);
5874 }
5875 assert_true(testdata.count == 1); // still just the first one
5876
5877 // try to parse lots of 'e', but the token isn't finished
5878 for (int c = 0; c < 100; ++c) {
5879 status = XML_Parse(parser, eeeeee, fillsize, XML_FALSE);
5880 if (status != XML_STATUS_OK) {
5881 xml_failure(parser);
5882 }
5883 }
5884 assert_true(testdata.count == 1); // *still* just the first one
5885
5886 // end the big token.
5887 status = XML_Parse(parser, end, (int)strlen(end), XML_FALSE);
5888 if (status != XML_STATUS_OK) {
5889 xml_failure(parser);
5890 }
5891
5892 if (enabled) {
5893 // In general, we may need to push more data to trigger a reparse attempt,
5894 // but in this test, the data is constructed to always require it.
5895 assert_true(testdata.count == 1); // or the test is incorrect
5896 // 2x the token length should suffice; the +1 covers the start and end.
5897 for (int c = 0; c < 101; ++c) {
5898 status = XML_Parse(parser, spaces, fillsize, XML_FALSE);
5899 if (status != XML_STATUS_OK) {
5900 xml_failure(parser);
5901 }
5902 }
5903 }
5904 assert_true(testdata.count == 2); // the big token should be done
5905
5906 // parse the final text
5907 status = XML_Parse(parser, post, (int)strlen(post), XML_TRUE);
5908 if (status != XML_STATUS_OK) {
5909 xml_failure(parser);
5910 }
5911 assert_true(testdata.count == 3); // after isFinal=XML_TRUE, all must be done
5912
5913 XML_ParserFree(parser);
5914 return XML_STATUS_OK;
5915}
5916
5917START_TEST(test_reparse_deferral_is_inherited) {
5918 const char *const text
5919 = "<!DOCTYPE document SYSTEM 'something.ext'><document/>";
5920 for (int enabled = 0; enabled <= 1; ++enabled) {
5921 set_subtest("deferral=%d", enabled);
5922
5923 XML_Parser parser = XML_ParserCreate(NULL);
5924 assert_true(parser != NULL);
5925 XML_SetUserData(parser, (void *)&enabled);
5926 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
5927 // this handler creates a sub-parser and checks that its deferral behavior
5928 // is what we expected, based on the value of `enabled` (in userdata).
5929 XML_SetExternalEntityRefHandler(parser, external_inherited_parser);
5930 assert_true(XML_SetReparseDeferralEnabled(parser, enabled));
5931 if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_OK)
5932 xml_failure(parser);
5933
5934 XML_ParserFree(parser);
5935 }
5936}
5937END_TEST
5938
5939START_TEST(test_set_reparse_deferral_on_null_parser) {
5940 assert_true(XML_SetReparseDeferralEnabled(NULL, 0) == XML_FALSE);
5941 assert_true(XML_SetReparseDeferralEnabled(NULL, 1) == XML_FALSE);
5942 assert_true(XML_SetReparseDeferralEnabled(NULL, 10) == XML_FALSE);
5943 assert_true(XML_SetReparseDeferralEnabled(NULL, 100) == XML_FALSE);
5944 assert_true(XML_SetReparseDeferralEnabled(NULL, (XML_Bool)INT_MIN)
5945 == XML_FALSE);
5946 assert_true(XML_SetReparseDeferralEnabled(NULL, (XML_Bool)INT_MAX)
5947 == XML_FALSE);
5948}
5949END_TEST
5950
5951START_TEST(test_set_reparse_deferral_on_the_fly) {
5952 const char *const pre = "<d><x attr='";
5953 const char *const end = "'></x>";
5954 char iiiiii[100];
5955 const int fillsize = (int)sizeof(iiiiii);
5956 memset(iiiiii, 'i', fillsize);
5957
5958 XML_Parser parser = XML_ParserCreate(NULL);
5959 assert_true(parser != NULL);
5960 assert_true(XML_SetReparseDeferralEnabled(parser, XML_TRUE));
5961
5962 CharData storage;
5963 CharData_Init(&storage);
5964 XML_SetUserData(parser, &storage);
5965 XML_SetStartElementHandler(parser, start_element_event_handler);
5966
5967 enum XML_Status status;
5968 // parse the start text
5969 status = XML_Parse(parser, pre, (int)strlen(pre), XML_FALSE);
5970 if (status != XML_STATUS_OK) {
5971 xml_failure(parser);
5972 }
5973 CharData_CheckXMLChars(&storage, XCS("d")); // first element should be done
5974
5975 // try to parse some 'i', but the token isn't finished
5976 status = XML_Parse(parser, iiiiii, fillsize, XML_FALSE);
5977 if (status != XML_STATUS_OK) {
5978 xml_failure(parser);
5979 }
5980 CharData_CheckXMLChars(&storage, XCS("d")); // *still* just the first one
5981
5982 // end the <x> token.
5983 status = XML_Parse(parser, end, (int)strlen(end), XML_FALSE);
5984 if (status != XML_STATUS_OK) {
5985 xml_failure(parser);
5986 }
5987 CharData_CheckXMLChars(&storage, XCS("d")); // not yet.
5988
5989 // now change the heuristic setting and add *no* data
5990 assert_true(XML_SetReparseDeferralEnabled(parser, XML_FALSE));
5991 // we avoid isFinal=XML_TRUE, because that would force-bypass the heuristic.
5992 status = XML_Parse(parser, "", 0, XML_FALSE);
5993 if (status != XML_STATUS_OK) {
5994 xml_failure(parser);
5995 }
5996 CharData_CheckXMLChars(&storage, XCS("dx"));
5997
5998 XML_ParserFree(parser);
5999}
6000END_TEST
6001
6002START_TEST(test_set_bad_reparse_option) {
6003 XML_Parser parser = XML_ParserCreate(NULL);
6004 assert_true(XML_FALSE == XML_SetReparseDeferralEnabled(parser, 2));
6005 assert_true(XML_FALSE == XML_SetReparseDeferralEnabled(parser, 3));
6006 assert_true(XML_FALSE == XML_SetReparseDeferralEnabled(parser, 99));
6007 assert_true(XML_FALSE == XML_SetReparseDeferralEnabled(parser, 127));
6008 assert_true(XML_FALSE == XML_SetReparseDeferralEnabled(parser, 128));
6009 assert_true(XML_FALSE == XML_SetReparseDeferralEnabled(parser, 129));
6010 assert_true(XML_FALSE == XML_SetReparseDeferralEnabled(parser, 255));
6011 assert_true(XML_TRUE == XML_SetReparseDeferralEnabled(parser, 0));
6012 assert_true(XML_TRUE == XML_SetReparseDeferralEnabled(parser, 1));
6013 XML_ParserFree(parser);
6014}
6015END_TEST
6016
6017static size_t g_totalAlloc = 0;
6018static size_t g_biggestAlloc = 0;
6019
6020static void *
6021counting_realloc(void *ptr, size_t size) {
6022 g_totalAlloc += size;
6023 if (size > g_biggestAlloc) {
6024 g_biggestAlloc = size;
6025 }
6026 return realloc(ptr, size);
6027}
6028
6029static void *
6030counting_malloc(size_t size) {
6031 return counting_realloc(NULL, size);
6032}
6033
6034START_TEST(test_bypass_heuristic_when_close_to_bufsize) {
6035 if (g_chunkSize != 0) {
6036 // this test does not use SINGLE_BYTES, because it depends on very precise
6037 // buffer fills.
6038 return;
6039 }
6040 if (! g_reparseDeferralEnabledDefault) {
6041 return; // this test is irrelevant when the deferral heuristic is disabled.
6042 }
6043
6044 const int document_length = 65536;
6045 char *const document = (char *)malloc(document_length);
6046
6047 const XML_Memory_Handling_Suite memfuncs = {
6048 counting_malloc,
6049 counting_realloc,
6050 free,
6051 };
6052
6053 const int leading_list[] = {0, 3, 61, 96, 400, 401, 4000, 4010, 4099, -1};
6054 const int bigtoken_list[] = {3000, 4000, 4001, 4096, 4099, 5000, 20000, -1};
6055 const int fillsize_list[] = {131, 256, 399, 400, 401, 1025, 4099, 4321, -1};
6056
6057 for (const int *leading = leading_list; *leading >= 0; leading++) {
6058 for (const int *bigtoken = bigtoken_list; *bigtoken >= 0; bigtoken++) {
6059 for (const int *fillsize = fillsize_list; *fillsize >= 0; fillsize++) {
6060 set_subtest("leading=%d bigtoken=%d fillsize=%d", *leading, *bigtoken,
6061 *fillsize);
6062 // start by checking that the test looks reasonably valid
6063 assert_true(*leading + *bigtoken <= document_length);
6064
6065 // put 'x' everywhere; some will be overwritten by elements.
6066 memset(document, 'x', document_length);
6067 // maybe add an initial tag
6068 if (*leading) {
6069 assert_true(*leading >= 3); // or the test case is invalid
6070 memcpy(document, "<a>", 3);
6071 }
6072 // add the large token
6073 document[*leading + 0] = '<';
6074 document[*leading + 1] = 'b';
6075 memset(&document[*leading + 2], ' ', *bigtoken - 2); // a spacy token
6076 document[*leading + *bigtoken - 1] = '>';
6077
6078 // 1 for 'b', plus 1 or 0 depending on the presence of 'a'
6079 const int expected_elem_total = 1 + (*leading ? 1 : 0);
6080
6081 XML_Parser parser = XML_ParserCreate_MM(NULL, &memfuncs, NULL);
6082 assert_true(parser != NULL);
6083
6084 CharData storage;
6085 CharData_Init(&storage);
6086 XML_SetUserData(parser, &storage);
6087 XML_SetStartElementHandler(parser, start_element_event_handler);
6088
6089 g_biggestAlloc = 0;
6090 g_totalAlloc = 0;
6091 int offset = 0;
6092 // fill data until the big token is covered (but not necessarily parsed)
6093 while (offset < *leading + *bigtoken) {
6094 assert_true(offset + *fillsize <= document_length);
6095 const enum XML_Status status
6096 = XML_Parse(parser, &document[offset], *fillsize, XML_FALSE);
6097 if (status != XML_STATUS_OK) {
6098 xml_failure(parser);
6099 }
6100 offset += *fillsize;
6101 }
6102 // Now, check that we've had a buffer allocation that could fit the
6103 // context bytes and our big token. In order to detect a special case,
6104 // we need to know how many bytes of our big token were included in the
6105 // first push that contained _any_ bytes of the big token:
6106 const int bigtok_first_chunk_bytes = *fillsize - (*leading % *fillsize);
6107 if (bigtok_first_chunk_bytes >= *bigtoken && XML_CONTEXT_BYTES == 0) {
6108 // Special case: we aren't saving any context, and the whole big token
6109 // was covered by a single fill, so Expat may have parsed directly
6110 // from our input pointer, without allocating an internal buffer.
6111 } else if (*leading < XML_CONTEXT_BYTES) {
6112 assert_true(g_biggestAlloc >= *leading + (size_t)*bigtoken);
6113 } else {
6114 assert_true(g_biggestAlloc >= XML_CONTEXT_BYTES + (size_t)*bigtoken);
6115 }
6116 // fill data until the big token is actually parsed
6117 while (storage.count < expected_elem_total) {
6118 const size_t alloc_before = g_totalAlloc;
6119 assert_true(offset + *fillsize <= document_length);
6120 const enum XML_Status status
6121 = XML_Parse(parser, &document[offset], *fillsize, XML_FALSE);
6122 if (status != XML_STATUS_OK) {
6123 xml_failure(parser);
6124 }
6125 offset += *fillsize;
6126 // since all the bytes of the big token are already in the buffer,
6127 // the bufsize ceiling should make us finish its parsing without any
6128 // further buffer allocations. We assume that there will be no other
6129 // large allocations in this test.
6130 assert_true(g_totalAlloc - alloc_before < 4096);
6131 }
6132 // test-the-test: was our alloc even called?
6133 assert_true(g_totalAlloc > 0);
6134 // test-the-test: there shouldn't be any extra start elements
6135 assert_true(storage.count == expected_elem_total);
6136
6137 XML_ParserFree(parser);
6138 }
6139 }
6140 }
6141 free(document);
6142}
6143END_TEST
6144
6145#if defined(XML_TESTING)
6146START_TEST(test_varying_buffer_fills) {
6147 const int KiB = 1024;
6148 const int MiB = 1024 * KiB;
6149 const int document_length = 16 * MiB;
6150 const int big = 7654321; // arbitrarily chosen between 4 and 8 MiB
6151
6152 if (g_chunkSize != 0) {
6153 return; // this test is slow, and doesn't use _XML_Parse_SINGLE_BYTES().
6154 }
6155
6156 char *const document = (char *)malloc(document_length);
6157 assert_true(document != NULL);
6158 memset(document, 'x', document_length);
6159 document[0] = '<';
6160 document[1] = 't';
6161 memset(&document[2], ' ', big - 2); // a very spacy token
6162 document[big - 1] = '>';
6163
6164 // Each testcase is a list of buffer fill sizes, terminated by a value < 0.
6165 // When reparse deferral is enabled, the final (negated) value is the expected
6166 // maximum number of bytes scanned in parse attempts.
6167 const int testcases[][30] = {
6168 {8 * MiB, -8 * MiB},
6169 {4 * MiB, 4 * MiB, -12 * MiB}, // try at 4MB, then 8MB = 12 MB total
6170 // zero-size fills shouldn't trigger the bypass
6171 {4 * MiB, 0, 4 * MiB, -12 * MiB},
6172 {4 * MiB, 0, 0, 4 * MiB, -12 * MiB},
6173 {4 * MiB, 0, 1 * MiB, 0, 3 * MiB, -12 * MiB},
6174 // try to hit the buffer ceiling only once (at the end)
6175 {4 * MiB, 2 * MiB, 1 * MiB, 512 * KiB, 256 * KiB, 256 * KiB, -12 * MiB},
6176 // try to hit the same buffer ceiling multiple times
6177 {4 * MiB + 1, 2 * MiB, 1 * MiB, 512 * KiB, -25 * MiB},
6178
6179 // try to hit every ceiling, by always landing 1K shy of the buffer size
6180 {1 * KiB, 2 * KiB, 4 * KiB, 8 * KiB, 16 * KiB, 32 * KiB, 64 * KiB,
6181 128 * KiB, 256 * KiB, 512 * KiB, 1 * MiB, 2 * MiB, 4 * MiB, -16 * MiB},
6182
6183 // try to avoid every ceiling, by always landing 1B past the buffer size
6184 // the normal 2x heuristic threshold still forces parse attempts.
6185 {2 * KiB + 1, // will attempt 2KiB + 1 ==> total 2KiB + 1
6186 2 * KiB, 4 * KiB, // will attempt 8KiB + 1 ==> total 10KiB + 2
6187 8 * KiB, 16 * KiB, // will attempt 32KiB + 1 ==> total 42KiB + 3
6188 32 * KiB, 64 * KiB, // will attempt 128KiB + 1 ==> total 170KiB + 4
6189 128 * KiB, 256 * KiB, // will attempt 512KiB + 1 ==> total 682KiB + 5
6190 512 * KiB, 1 * MiB, // will attempt 2MiB + 1 ==> total 2M + 682K + 6
6191 2 * MiB, 4 * MiB, // will attempt 8MiB + 1 ==> total 10M + 682K + 7
6192 -(10 * MiB + 682 * KiB + 7)},
6193 // try to avoid every ceiling again, except on our last fill.
6194 {2 * KiB + 1, // will attempt 2KiB + 1 ==> total 2KiB + 1
6195 2 * KiB, 4 * KiB, // will attempt 8KiB + 1 ==> total 10KiB + 2
6196 8 * KiB, 16 * KiB, // will attempt 32KiB + 1 ==> total 42KiB + 3
6197 32 * KiB, 64 * KiB, // will attempt 128KiB + 1 ==> total 170KiB + 4
6198 128 * KiB, 256 * KiB, // will attempt 512KiB + 1 ==> total 682KiB + 5
6199 512 * KiB, 1 * MiB, // will attempt 2MiB + 1 ==> total 2M + 682K + 6
6200 2 * MiB, 4 * MiB - 1, // will attempt 8MiB ==> total 10M + 682K + 6
6201 -(10 * MiB + 682 * KiB + 6)},
6202
6203 // try to hit ceilings on the way multiple times
6204 {512 * KiB + 1, 256 * KiB, 128 * KiB, 128 * KiB - 1, // 1 MiB buffer
6205 512 * KiB + 1, 256 * KiB, 128 * KiB, 128 * KiB - 1, // 2 MiB buffer
6206 1 * MiB + 1, 512 * KiB, 256 * KiB, 256 * KiB - 1, // 4 MiB buffer
6207 2 * MiB + 1, 1 * MiB, 512 * KiB, // 8 MiB buffer
6208 // we'll make a parse attempt at every parse call
6209 -(45 * MiB + 12)},
6210 };
6211 const int testcount = sizeof(testcases) / sizeof(testcases[0]);
6212 for (int test_i = 0; test_i < testcount; test_i++) {
6213 const int *fillsize = testcases[test_i];
6214 set_subtest("#%d {%d %d %d %d ...}", test_i, fillsize[0], fillsize[1],
6215 fillsize[2], fillsize[3]);
6216 XML_Parser parser = XML_ParserCreate(NULL);
6217 assert_true(parser != NULL);
6218
6219 CharData storage;
6220 CharData_Init(&storage);
6221 XML_SetUserData(parser, &storage);
6222 XML_SetStartElementHandler(parser, start_element_event_handler);
6223
6224 g_bytesScanned = 0;
6225 int worstcase_bytes = 0; // sum of (buffered bytes at each XML_Parse call)
6226 int offset = 0;
6227 while (*fillsize >= 0) {
6228 assert_true(offset + *fillsize <= document_length); // or test is invalid
6229 const enum XML_Status status
6230 = XML_Parse(parser, &document[offset], *fillsize, XML_FALSE);
6231 if (status != XML_STATUS_OK) {
6232 xml_failure(parser);
6233 }
6234 offset += *fillsize;
6235 fillsize++;
6236 assert_true(offset <= INT_MAX - worstcase_bytes); // avoid overflow
6237 worstcase_bytes += offset; // we might've tried to parse all pending bytes
6238 }
6239 assert_true(storage.count == 1); // the big token should've been parsed
6240 assert_true(g_bytesScanned > 0); // test-the-test: does our counter work?
6241 if (g_reparseDeferralEnabledDefault) {
6242 // heuristic is enabled; some XML_Parse calls may have deferred reparsing
6243 const unsigned max_bytes_scanned = -*fillsize;
6244 if (g_bytesScanned > max_bytes_scanned) {
6245 fprintf(stderr,
6246 "bytes scanned in parse attempts: actual=%u limit=%u \n",
6247 g_bytesScanned, max_bytes_scanned);
6248 fail("too many bytes scanned in parse attempts");
6249 }
6250 }
6251 assert_true(g_bytesScanned <= (unsigned)worstcase_bytes);
6252
6253 XML_ParserFree(parser);
6254 }
6255 free(document);
6256}
6257END_TEST
6258#endif
6259
6260void
6261make_basic_test_case(Suite *s) {
6262 TCase *tc_basic = tcase_create("basic tests");
6263
6264 suite_add_tcase(s, tc_basic);
6265 tcase_add_checked_fixture(tc_basic, basic_setup, basic_teardown);
6266
6267 tcase_add_test(tc_basic, test_nul_byte);
6268 tcase_add_test(tc_basic, test_u0000_char);
6269 tcase_add_test(tc_basic, test_siphash_self);
6270 tcase_add_test(tc_basic, test_siphash_spec);
6271 tcase_add_test(tc_basic, test_bom_utf8);
6272 tcase_add_test(tc_basic, test_bom_utf16_be);
6273 tcase_add_test(tc_basic, test_bom_utf16_le);
6274 tcase_add_test(tc_basic, test_nobom_utf16_le);
6275 tcase_add_test(tc_basic, test_hash_collision);
6276 tcase_add_test(tc_basic, test_illegal_utf8);
6277 tcase_add_test(tc_basic, test_utf8_auto_align);
6278 tcase_add_test(tc_basic, test_utf16);
6279 tcase_add_test(tc_basic, test_utf16_le_epilog_newline);
6280 tcase_add_test(tc_basic, test_not_utf16);
6281 tcase_add_test(tc_basic, test_bad_encoding);
6282 tcase_add_test(tc_basic, test_latin1_umlauts);
6283 tcase_add_test(tc_basic, test_long_utf8_character);
6284 tcase_add_test(tc_basic, test_long_latin1_attribute);
6285 tcase_add_test(tc_basic, test_long_ascii_attribute);
6286 /* Regression test for SF bug #491986. */
6287 tcase_add_test(tc_basic, test_danish_latin1);
6288 /* Regression test for SF bug #514281. */
6289 tcase_add_test(tc_basic, test_french_charref_hexidecimal);
6290 tcase_add_test(tc_basic, test_french_charref_decimal);
6291 tcase_add_test(tc_basic, test_french_latin1);
6292 tcase_add_test(tc_basic, test_french_utf8);
6293 tcase_add_test(tc_basic, test_utf8_false_rejection);
6294 tcase_add_test(tc_basic, test_line_number_after_parse);
6295 tcase_add_test(tc_basic, test_column_number_after_parse);
6296 tcase_add_test(tc_basic, test_line_and_column_numbers_inside_handlers);
6297 tcase_add_test(tc_basic, test_line_number_after_error);
6298 tcase_add_test(tc_basic, test_column_number_after_error);
6299 tcase_add_test(tc_basic, test_really_long_lines);
6300 tcase_add_test(tc_basic, test_really_long_encoded_lines);
6301 tcase_add_test(tc_basic, test_end_element_events);
6302 tcase_add_test(tc_basic, test_helper_is_whitespace_normalized);
6303 tcase_add_test(tc_basic, test_attr_whitespace_normalization);
6304 tcase_add_test(tc_basic, test_xmldecl_misplaced);
6305 tcase_add_test(tc_basic, test_xmldecl_invalid);
6306 tcase_add_test(tc_basic, test_xmldecl_missing_attr);
6307 tcase_add_test(tc_basic, test_xmldecl_missing_value);
6308 tcase_add_test__if_xml_ge(tc_basic, test_unknown_encoding_internal_entity);
6309 tcase_add_test(tc_basic, test_unrecognised_encoding_internal_entity);
6310 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_set_encoding);
6311 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_no_handler);
6312 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_set_bom);
6313 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_bad_encoding);
6314 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_bad_encoding_2);
6315 tcase_add_test(tc_basic, test_wfc_undeclared_entity_unread_external_subset);
6316 tcase_add_test(tc_basic, test_wfc_undeclared_entity_no_external_subset);
6317 tcase_add_test(tc_basic, test_wfc_undeclared_entity_standalone);
6318 tcase_add_test(tc_basic,
6319 test_wfc_undeclared_entity_with_external_subset_standalone);
6320 tcase_add_test(tc_basic, test_entity_with_external_subset_unless_standalone);
6321 tcase_add_test(tc_basic, test_wfc_undeclared_entity_with_external_subset);
6322 tcase_add_test(tc_basic, test_not_standalone_handler_reject);
6323 tcase_add_test(tc_basic, test_not_standalone_handler_accept);
6324 tcase_add_test(tc_basic, test_entity_start_tag_level_greater_than_one);
6325 tcase_add_test__if_xml_ge(tc_basic, test_wfc_no_recursive_entity_refs);
6326 tcase_add_test(tc_basic, test_no_indirectly_recursive_entity_refs);
6327 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_invalid_parse);
6328 tcase_add_test__if_xml_ge(tc_basic, test_dtd_default_handling);
6329 tcase_add_test(tc_basic, test_dtd_attr_handling);
6330 tcase_add_test(tc_basic, test_empty_ns_without_namespaces);
6331 tcase_add_test(tc_basic, test_ns_in_attribute_default_without_namespaces);
6332 tcase_add_test(tc_basic, test_stop_parser_between_char_data_calls);
6333 tcase_add_test(tc_basic, test_suspend_parser_between_char_data_calls);
6334 tcase_add_test(tc_basic, test_repeated_stop_parser_between_char_data_calls);
6335 tcase_add_test(tc_basic, test_good_cdata_ascii);
6336 tcase_add_test(tc_basic, test_good_cdata_utf16);
6337 tcase_add_test(tc_basic, test_good_cdata_utf16_le);
6338 tcase_add_test(tc_basic, test_long_cdata_utf16);
6339 tcase_add_test(tc_basic, test_multichar_cdata_utf16);
6340 tcase_add_test(tc_basic, test_utf16_bad_surrogate_pair);
6341 tcase_add_test(tc_basic, test_bad_cdata);
6342 tcase_add_test(tc_basic, test_bad_cdata_utf16);
6343 tcase_add_test(tc_basic, test_stop_parser_between_cdata_calls);
6344 tcase_add_test(tc_basic, test_suspend_parser_between_cdata_calls);
6345 tcase_add_test(tc_basic, test_memory_allocation);
6346 tcase_add_test__if_xml_ge(tc_basic, test_default_current);
6347 tcase_add_test(tc_basic, test_dtd_elements);
6348 tcase_add_test(tc_basic, test_dtd_elements_nesting);
6349 tcase_add_test__ifdef_xml_dtd(tc_basic, test_set_foreign_dtd);
6350 tcase_add_test__ifdef_xml_dtd(tc_basic, test_foreign_dtd_not_standalone);
6351 tcase_add_test__ifdef_xml_dtd(tc_basic, test_invalid_foreign_dtd);
6352 tcase_add_test__ifdef_xml_dtd(tc_basic, test_foreign_dtd_with_doctype);
6353 tcase_add_test__ifdef_xml_dtd(tc_basic,
6354 test_foreign_dtd_without_external_subset);
6355 tcase_add_test__ifdef_xml_dtd(tc_basic, test_empty_foreign_dtd);
6356 tcase_add_test(tc_basic, test_set_base);
6357 tcase_add_test(tc_basic, test_attributes);
6358 tcase_add_test__if_xml_ge(tc_basic, test_reset_in_entity);
6359 tcase_add_test(tc_basic, test_resume_invalid_parse);
6360 tcase_add_test(tc_basic, test_resume_resuspended);
6361 tcase_add_test(tc_basic, test_cdata_default);
6362 tcase_add_test(tc_basic, test_subordinate_reset);
6363 tcase_add_test(tc_basic, test_subordinate_suspend);
6364 tcase_add_test__if_xml_ge(tc_basic, test_subordinate_xdecl_suspend);
6365 tcase_add_test__if_xml_ge(tc_basic, test_subordinate_xdecl_abort);
6366 tcase_add_test__ifdef_xml_dtd(tc_basic,
6367 test_ext_entity_invalid_suspended_parse);
6368 tcase_add_test(tc_basic, test_explicit_encoding);
6369 tcase_add_test(tc_basic, test_trailing_cr);
6370 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_trailing_cr);
6371 tcase_add_test(tc_basic, test_trailing_rsqb);
6372 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_trailing_rsqb);
6373 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_good_cdata);
6374 tcase_add_test__ifdef_xml_dtd(tc_basic, test_user_parameters);
6375 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_ref_parameter);
6376 tcase_add_test(tc_basic, test_empty_parse);
6377 tcase_add_test(tc_basic, test_negative_len_parse);
6378 tcase_add_test(tc_basic, test_negative_len_parse_buffer);
6379 tcase_add_test(tc_basic, test_get_buffer_1);
6380 tcase_add_test(tc_basic, test_get_buffer_2);
6381#if XML_CONTEXT_BYTES > 0
6382 tcase_add_test(tc_basic, test_get_buffer_3_overflow);
6383#endif
6384 tcase_add_test(tc_basic, test_buffer_can_grow_to_max);
6385 tcase_add_test(tc_basic, test_getbuffer_allocates_on_zero_len);
6386 tcase_add_test(tc_basic, test_byte_info_at_end);
6387 tcase_add_test(tc_basic, test_byte_info_at_error);
6388 tcase_add_test(tc_basic, test_byte_info_at_cdata);
6389 tcase_add_test(tc_basic, test_predefined_entities);
6390 tcase_add_test__ifdef_xml_dtd(tc_basic, test_invalid_tag_in_dtd);
6391 tcase_add_test(tc_basic, test_not_predefined_entities);
6392 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ignore_section);
6393 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ignore_section_utf16);
6394 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ignore_section_utf16_be);
6395 tcase_add_test__ifdef_xml_dtd(tc_basic, test_bad_ignore_section);
6396 tcase_add_test__ifdef_xml_dtd(tc_basic, test_external_bom_consumed);
6397 tcase_add_test__ifdef_xml_dtd(tc_basic, test_external_entity_values);
6398 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_not_standalone);
6399 tcase_add_test__ifdef_xml_dtd(tc_basic, test_ext_entity_value_abort);
6400 tcase_add_test(tc_basic, test_bad_public_doctype);
6401 tcase_add_test(tc_basic, test_attribute_enum_value);
6402 tcase_add_test(tc_basic, test_predefined_entity_redefinition);
6403 tcase_add_test__ifdef_xml_dtd(tc_basic, test_dtd_stop_processing);
6404 tcase_add_test(tc_basic, test_public_notation_no_sysid);
6405 tcase_add_test(tc_basic, test_nested_groups);
6406 tcase_add_test(tc_basic, test_group_choice);
6407 tcase_add_test(tc_basic, test_standalone_parameter_entity);
6408 tcase_add_test__ifdef_xml_dtd(tc_basic, test_skipped_parameter_entity);
6409 tcase_add_test__ifdef_xml_dtd(tc_basic,
6410 test_recursive_external_parameter_entity);
6411 tcase_add_test__ifdef_xml_dtd(tc_basic,
6412 test_recursive_external_parameter_entity_2);
6413 tcase_add_test(tc_basic, test_undefined_ext_entity_in_external_dtd);
6414 tcase_add_test(tc_basic, test_suspend_xdecl);
6415 tcase_add_test(tc_basic, test_abort_epilog);
6416 tcase_add_test(tc_basic, test_abort_epilog_2);
6417 tcase_add_test(tc_basic, test_suspend_epilog);
6418 tcase_add_test(tc_basic, test_suspend_in_sole_empty_tag);
6419 tcase_add_test(tc_basic, test_unfinished_epilog);
6420 tcase_add_test(tc_basic, test_partial_char_in_epilog);
6421 tcase_add_test__ifdef_xml_dtd(tc_basic, test_suspend_resume_internal_entity);
6422 tcase_add_test__ifdef_xml_dtd(tc_basic,
6423 test_suspend_resume_internal_entity_issue_629);
6424 tcase_add_test__ifdef_xml_dtd(tc_basic, test_resume_entity_with_syntax_error);
6425 tcase_add_test__ifdef_xml_dtd(tc_basic, test_suspend_resume_parameter_entity);
6426 tcase_add_test(tc_basic, test_restart_on_error);
6427 tcase_add_test(tc_basic, test_reject_lt_in_attribute_value);
6428 tcase_add_test(tc_basic, test_reject_unfinished_param_in_att_value);
6429 tcase_add_test(tc_basic, test_trailing_cr_in_att_value);
6430 tcase_add_test(tc_basic, test_standalone_internal_entity);
6431 tcase_add_test(tc_basic, test_skipped_external_entity);
6432 tcase_add_test(tc_basic, test_skipped_null_loaded_ext_entity);
6433 tcase_add_test(tc_basic, test_skipped_unloaded_ext_entity);
6434 tcase_add_test__ifdef_xml_dtd(tc_basic, test_param_entity_with_trailing_cr);
6435 tcase_add_test__if_xml_ge(tc_basic, test_invalid_character_entity);
6436 tcase_add_test__if_xml_ge(tc_basic, test_invalid_character_entity_2);
6437 tcase_add_test__if_xml_ge(tc_basic, test_invalid_character_entity_3);
6438 tcase_add_test__if_xml_ge(tc_basic, test_invalid_character_entity_4);
6439 tcase_add_test(tc_basic, test_pi_handled_in_default);
6440 tcase_add_test(tc_basic, test_comment_handled_in_default);
6441 tcase_add_test(tc_basic, test_pi_yml);
6442 tcase_add_test(tc_basic, test_pi_xnl);
6443 tcase_add_test(tc_basic, test_pi_xmm);
6444 tcase_add_test(tc_basic, test_utf16_pi);
6445 tcase_add_test(tc_basic, test_utf16_be_pi);
6446 tcase_add_test(tc_basic, test_utf16_be_comment);
6447 tcase_add_test(tc_basic, test_utf16_le_comment);
6448 tcase_add_test(tc_basic, test_missing_encoding_conversion_fn);
6449 tcase_add_test(tc_basic, test_failing_encoding_conversion_fn);
6450 tcase_add_test(tc_basic, test_unknown_encoding_success);
6451 tcase_add_test(tc_basic, test_unknown_encoding_bad_name);
6452 tcase_add_test(tc_basic, test_unknown_encoding_bad_name_2);
6453 tcase_add_test(tc_basic, test_unknown_encoding_long_name_1);
6454 tcase_add_test(tc_basic, test_unknown_encoding_long_name_2);
6455 tcase_add_test(tc_basic, test_invalid_unknown_encoding);
6456 tcase_add_test(tc_basic, test_unknown_ascii_encoding_ok);
6457 tcase_add_test(tc_basic, test_unknown_ascii_encoding_fail);
6458 tcase_add_test(tc_basic, test_unknown_encoding_invalid_length);
6459 tcase_add_test(tc_basic, test_unknown_encoding_invalid_topbit);
6460 tcase_add_test(tc_basic, test_unknown_encoding_invalid_surrogate);
6461 tcase_add_test(tc_basic, test_unknown_encoding_invalid_high);
6462 tcase_add_test(tc_basic, test_unknown_encoding_invalid_attr_value);
6463 tcase_add_test(tc_basic, test_unknown_encoding_user_data_primary);
6464 tcase_add_test(tc_basic, test_unknown_encoding_user_data_secondary);
6465 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_latin1_utf16le_bom);
6466 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_latin1_utf16be_bom);
6467 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_latin1_utf16le_bom2);
6468 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_latin1_utf16be_bom2);
6469 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_utf16_be);
6470 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_utf16_le);
6471 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_utf16_unknown);
6472 tcase_add_test__if_xml_ge(tc_basic, test_ext_entity_utf8_non_bom);
6473 tcase_add_test(tc_basic, test_utf8_in_cdata_section);
6474 tcase_add_test(tc_basic, test_utf8_in_cdata_section_2);
6475 tcase_add_test(tc_basic, test_utf8_in_start_tags);
6476 tcase_add_test(tc_basic, test_trailing_spaces_in_elements);
6477 tcase_add_test(tc_basic, test_utf16_attribute);
6478 tcase_add_test(tc_basic, test_utf16_second_attr);
6479 tcase_add_test(tc_basic, test_attr_after_solidus);
6480 tcase_add_test__ifdef_xml_dtd(tc_basic, test_utf16_pe);
6481 tcase_add_test(tc_basic, test_bad_attr_desc_keyword);
6482 tcase_add_test(tc_basic, test_bad_attr_desc_keyword_utf16);
6483 tcase_add_test(tc_basic, test_bad_doctype);
6484 tcase_add_test(tc_basic, test_bad_doctype_utf8);
6485 tcase_add_test(tc_basic, test_bad_doctype_utf16);
6486 tcase_add_test(tc_basic, test_bad_doctype_plus);
6487 tcase_add_test(tc_basic, test_bad_doctype_star);
6488 tcase_add_test(tc_basic, test_bad_doctype_query);
6489 tcase_add_test__ifdef_xml_dtd(tc_basic, test_unknown_encoding_bad_ignore);
6490 tcase_add_test(tc_basic, test_entity_in_utf16_be_attr);
6491 tcase_add_test(tc_basic, test_entity_in_utf16_le_attr);
6492 tcase_add_test__ifdef_xml_dtd(tc_basic, test_entity_public_utf16_be);
6493 tcase_add_test__ifdef_xml_dtd(tc_basic, test_entity_public_utf16_le);
6494 tcase_add_test(tc_basic, test_short_doctype);
6495 tcase_add_test(tc_basic, test_short_doctype_2);
6496 tcase_add_test(tc_basic, test_short_doctype_3);
6497 tcase_add_test(tc_basic, test_long_doctype);
6498 tcase_add_test(tc_basic, test_bad_entity);
6499 tcase_add_test(tc_basic, test_bad_entity_2);
6500 tcase_add_test(tc_basic, test_bad_entity_3);
6501 tcase_add_test(tc_basic, test_bad_entity_4);
6502 tcase_add_test(tc_basic, test_bad_notation);
6503 tcase_add_test(tc_basic, test_default_doctype_handler);
6504 tcase_add_test(tc_basic, test_empty_element_abort);
6505 tcase_add_test__ifdef_xml_dtd(tc_basic,
6506 test_pool_integrity_with_unfinished_attr);
6507 tcase_add_test__if_xml_ge(tc_basic, test_entity_ref_no_elements);
6508 tcase_add_test__if_xml_ge(tc_basic, test_deep_nested_entity);
6509 tcase_add_test__if_xml_ge(tc_basic, test_deep_nested_attribute_entity);
6510 tcase_add_test__if_xml_ge(tc_basic,
6511 test_deep_nested_entity_delayed_interpretation);
6512 tcase_add_test__if_xml_ge(tc_basic, test_nested_entity_suspend);
6513 tcase_add_test__if_xml_ge(tc_basic, test_nested_entity_suspend_2);
6514#if defined(XML_TESTING)
6515 tcase_add_test(tc_basic, test_big_tokens_scale_linearly);
6516#endif
6517 tcase_add_test(tc_basic, test_set_reparse_deferral);
6518 tcase_add_test(tc_basic, test_reparse_deferral_is_inherited);
6519 tcase_add_test(tc_basic, test_set_reparse_deferral_on_null_parser);
6520 tcase_add_test(tc_basic, test_set_reparse_deferral_on_the_fly);
6521 tcase_add_test(tc_basic, test_set_bad_reparse_option);
6522 tcase_add_test(tc_basic, test_bypass_heuristic_when_close_to_bufsize);
6523#if defined(XML_TESTING)
6524 tcase_add_test(tc_basic, test_varying_buffer_fills);
6525#endif
6526}