Apache HTTPD
alloc_tests.c
Go to the documentation of this file.
1/* Tests in the "allocation" 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. <[email protected]>
10 Copyright (c) 2003 Greg Stein <[email protected]>
11 Copyright (c) 2005-2007 Steven Solie <[email protected]>
12 Copyright (c) 2005-2012 Karl Waclawek <[email protected]>
13 Copyright (c) 2016-2023 Sebastian Pipping <[email protected]>
14 Copyright (c) 2017-2022 Rhodri James <[email protected]>
15 Copyright (c) 2017 Joe Orton <[email protected]>
16 Copyright (c) 2017 José Gutiérrez de la Concha <[email protected]>
17 Copyright (c) 2018 Marco Maggi <[email protected]>
18 Copyright (c) 2019 David Loffredo <[email protected]>
19 Copyright (c) 2020 Tim Gates <[email protected]>
20 Copyright (c) 2021 Donghee Na <[email protected]>
21 Copyright (c) 2023 Sony Corporation / Snild Dolkow <[email protected]>
22 Licensed under the MIT license:
23
24 Permission is hereby granted, free of charge, to any person obtaining
25 a copy of this software and associated documentation files (the
26 "Software"), to deal in the Software without restriction, including
27 without limitation the rights to use, copy, modify, merge, publish,
28 distribute, sublicense, and/or sell copies of the Software, and to permit
29 persons to whom the Software is furnished to do so, subject to the
30 following conditions:
31
32 The above copyright notice and this permission notice shall be included
33 in all copies or substantial portions of the Software.
34
35 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
36 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
37 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
38 NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
39 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
40 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
41 USE OR OTHER DEALINGS IN THE SOFTWARE.
42*/
43
44#if defined(NDEBUG)
45# undef NDEBUG /* because test suite relies on assert(...) at the moment */
46#endif
47
48#include <string.h>
49#include <assert.h>
50
51#include "expat.h"
52#include "common.h"
53#include "minicheck.h"
54#include "dummy.h"
55#include "handlers.h"
56#include "alloc_tests.h"
57
58static void
59alloc_setup(void) {
60 XML_Memory_Handling_Suite memsuite = {duff_allocator, duff_reallocator, free};
61
62 /* Ensure the parser creation will go through */
63 g_allocation_count = ALLOC_ALWAYS_SUCCEED;
64 g_reallocation_count = REALLOC_ALWAYS_SUCCEED;
65 g_parser = XML_ParserCreate_MM(NULL, &memsuite, NULL);
66 if (g_parser == NULL)
67 fail("Parser not created");
68}
69
70static void
74
75/* Test the effects of allocation failures on xml declaration processing */
76START_TEST(test_alloc_parse_xdecl) {
77 const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
78 "<doc>Hello, world</doc>";
79 int i;
80 const int max_alloc_count = 15;
81
82 for (i = 0; i < max_alloc_count; i++) {
83 g_allocation_count = i;
84 XML_SetXmlDeclHandler(g_parser, dummy_xdecl_handler);
85 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
86 != XML_STATUS_ERROR)
87 break;
88 /* Resetting the parser is insufficient, because some memory
89 * allocations are cached within the parser. Instead we use
90 * the teardown and setup routines to ensure that we have the
91 * right sort of parser back in our hands.
92 */
93 alloc_teardown();
94 alloc_setup();
95 }
96 if (i == 0)
97 fail("Parse succeeded despite failing allocator");
98 if (i == max_alloc_count)
99 fail("Parse failed with max allocations");
100}
101END_TEST
102
103/* As above, but with an encoding big enough to cause storing the
104 * version information to expand the string pool being used.
105 */
106START_TEST(test_alloc_parse_xdecl_2) {
107 const char *text
108 = "<?xml version='1.0' encoding='"
109 /* Each line is 64 characters */
110 "ThisIsAStupidlyLongEncodingNameIntendedToTriggerPoolGrowth123456"
111 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
112 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
113 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
114 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
115 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
116 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
117 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
118 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
119 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
120 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
121 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
122 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
123 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
124 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
125 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN"
126 "'?>"
127 "<doc>Hello, world</doc>";
128 int i;
129 const int max_alloc_count = 20;
130
131 for (i = 0; i < max_alloc_count; i++) {
132 g_allocation_count = i;
133 XML_SetXmlDeclHandler(g_parser, dummy_xdecl_handler);
134 XML_SetUnknownEncodingHandler(g_parser, long_encoding_handler, NULL);
135 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
136 != XML_STATUS_ERROR)
137 break;
138 /* See comment in test_alloc_parse_xdecl() */
139 alloc_teardown();
140 alloc_setup();
141 }
142 if (i == 0)
143 fail("Parse succeeded despite failing allocator");
144 if (i == max_alloc_count)
145 fail("Parse failed with max allocations");
146}
147END_TEST
148
149/* Test the effects of allocation failures on a straightforward parse */
150START_TEST(test_alloc_parse_pi) {
151 const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
152 "<?pi unknown?>\n"
153 "<doc>"
154 "Hello, world"
155 "</doc>";
156 int i;
157 const int max_alloc_count = 15;
158
159 for (i = 0; i < max_alloc_count; i++) {
160 g_allocation_count = i;
161 XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
162 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
163 != XML_STATUS_ERROR)
164 break;
165 /* See comment in test_alloc_parse_xdecl() */
166 alloc_teardown();
167 alloc_setup();
168 }
169 if (i == 0)
170 fail("Parse succeeded despite failing allocator");
171 if (i == max_alloc_count)
172 fail("Parse failed with max allocations");
173}
174END_TEST
175
176START_TEST(test_alloc_parse_pi_2) {
177 const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
178 "<doc>"
179 "Hello, world"
180 "<?pi unknown?>\n"
181 "</doc>";
182 int i;
183 const int max_alloc_count = 15;
184
185 for (i = 0; i < max_alloc_count; i++) {
186 g_allocation_count = i;
187 XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
188 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
189 != XML_STATUS_ERROR)
190 break;
191 /* See comment in test_alloc_parse_xdecl() */
192 alloc_teardown();
193 alloc_setup();
194 }
195 if (i == 0)
196 fail("Parse succeeded despite failing allocator");
197 if (i == max_alloc_count)
198 fail("Parse failed with max allocations");
199}
200END_TEST
201
202START_TEST(test_alloc_parse_pi_3) {
203 const char *text
204 = "<?"
205 /* 64 characters per line */
206 "This processing instruction should be long enough to ensure that"
207 "it triggers the growth of an internal string pool when the "
208 "allocator fails at a cruicial moment FGHIJKLMNOPABCDEFGHIJKLMNOP"
209 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
210 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
211 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
212 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
213 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
214 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
215 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
216 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
217 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
218 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
219 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
220 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
221 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
222 "Q?><doc/>";
223 int i;
224 const int max_alloc_count = 20;
225
226 for (i = 0; i < max_alloc_count; i++) {
227 g_allocation_count = i;
228 XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
229 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
230 != XML_STATUS_ERROR)
231 break;
232 /* See comment in test_alloc_parse_xdecl() */
233 alloc_teardown();
234 alloc_setup();
235 }
236 if (i == 0)
237 fail("Parse succeeded despite failing allocator");
238 if (i == max_alloc_count)
239 fail("Parse failed with max allocations");
240}
241END_TEST
242
243START_TEST(test_alloc_parse_comment) {
244 const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
245 "<!-- Test parsing this comment -->"
246 "<doc>Hi</doc>";
247 int i;
248 const int max_alloc_count = 15;
249
250 for (i = 0; i < max_alloc_count; i++) {
251 g_allocation_count = i;
252 XML_SetCommentHandler(g_parser, dummy_comment_handler);
253 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
254 != XML_STATUS_ERROR)
255 break;
256 /* See comment in test_alloc_parse_xdecl() */
257 alloc_teardown();
258 alloc_setup();
259 }
260 if (i == 0)
261 fail("Parse succeeded despite failing allocator");
262 if (i == max_alloc_count)
263 fail("Parse failed with max allocations");
264}
265END_TEST
266
267START_TEST(test_alloc_parse_comment_2) {
268 const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
269 "<doc>"
270 "Hello, world"
271 "<!-- Parse this comment too -->"
272 "</doc>";
273 int i;
274 const int max_alloc_count = 15;
275
276 for (i = 0; i < max_alloc_count; i++) {
277 g_allocation_count = i;
278 XML_SetCommentHandler(g_parser, dummy_comment_handler);
279 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
280 != XML_STATUS_ERROR)
281 break;
282 /* See comment in test_alloc_parse_xdecl() */
283 alloc_teardown();
284 alloc_setup();
285 }
286 if (i == 0)
287 fail("Parse succeeded despite failing allocator");
288 if (i == max_alloc_count)
289 fail("Parse failed with max allocations");
290}
291END_TEST
292
293/* Test that external parser creation running out of memory is
294 * correctly reported. Based on the external entity test cases.
295 */
296START_TEST(test_alloc_create_external_parser) {
297 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
298 "<!DOCTYPE doc SYSTEM 'foo'>\n"
299 "<doc>&entity;</doc>";
300 char foo_text[] = "<!ELEMENT doc (#PCDATA)*>";
301
302 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
303 XML_SetUserData(g_parser, foo_text);
304 XML_SetExternalEntityRefHandler(g_parser, external_entity_duff_loader);
305 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
306 != XML_STATUS_ERROR) {
307 fail("External parser allocator returned success incorrectly");
308 }
309}
310END_TEST
311
312/* More external parser memory allocation testing */
313START_TEST(test_alloc_run_external_parser) {
314 const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
315 "<!DOCTYPE doc SYSTEM 'foo'>\n"
316 "<doc>&entity;</doc>";
317 char foo_text[] = "<!ELEMENT doc (#PCDATA)*>";
318 unsigned int i;
319 const unsigned int max_alloc_count = 15;
320
321 for (i = 0; i < max_alloc_count; i++) {
322 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
323 XML_SetUserData(g_parser, foo_text);
324 XML_SetExternalEntityRefHandler(g_parser, external_entity_null_loader);
325 g_allocation_count = i;
326 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
327 != XML_STATUS_ERROR)
328 break;
329 /* See comment in test_alloc_parse_xdecl() */
330 alloc_teardown();
331 alloc_setup();
332 }
333 if (i == 0)
334 fail("Parsing ignored failing allocator");
335 else if (i == max_alloc_count)
336 fail("Parsing failed with allocation count 10");
337}
338END_TEST
339
340/* Test that running out of memory in dtdCopy is correctly reported.
341 * Based on test_default_ns_from_ext_subset_and_ext_ge()
342 */
343START_TEST(test_alloc_dtd_copy_default_atts) {
344 const char *text = "<?xml version='1.0'?>\n"
345 "<!DOCTYPE doc SYSTEM 'http://example.org/doc.dtd' [\n"
346 " <!ENTITY en SYSTEM 'http://example.org/entity.ent'>\n"
347 "]>\n"
348 "<doc xmlns='http://example.org/ns1'>\n"
349 "&en;\n"
350 "</doc>";
351 int callno = 0;
352
353 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
354 XML_SetExternalEntityRefHandler(g_parser, external_entity_dbl_handler);
355 XML_SetUserData(g_parser, &callno);
356 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
357 == XML_STATUS_ERROR)
358 xml_failure(g_parser);
359}
360END_TEST
361
362/* Test more external entity allocation failure paths */
363START_TEST(test_alloc_external_entity) {
364 const char *text = "<?xml version='1.0'?>\n"
365 "<!DOCTYPE doc SYSTEM 'http://example.org/doc.dtd' [\n"
366 " <!ENTITY en SYSTEM 'http://example.org/entity.ent'>\n"
367 "]>\n"
368 "<doc xmlns='http://example.org/ns1'>\n"
369 "&en;\n"
370 "</doc>";
371 int i;
372 const int alloc_test_max_repeats = 50;
373 int callno = 0;
374
375 for (i = 0; i < alloc_test_max_repeats; i++) {
376 g_allocation_count = -1;
377 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
378 XML_SetExternalEntityRefHandler(g_parser, external_entity_dbl_handler_2);
379 callno = 0;
380 XML_SetUserData(g_parser, &callno);
381 g_allocation_count = i;
382 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
383 == XML_STATUS_OK)
384 break;
385 /* See comment in test_alloc_parse_xdecl() */
386 alloc_teardown();
387 alloc_setup();
388 }
389 g_allocation_count = -1;
390 if (i == 0)
391 fail("External entity parsed despite duff allocator");
392 if (i == alloc_test_max_repeats)
393 fail("External entity not parsed at max allocation count");
394}
395END_TEST
396
397/* Test more allocation failure paths */
398START_TEST(test_alloc_ext_entity_set_encoding) {
399 const char *text = "<!DOCTYPE doc [\n"
400 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
401 "]>\n"
402 "<doc>&en;</doc>";
403 int i;
404 const int max_allocation_count = 30;
405
406 for (i = 0; i < max_allocation_count; i++) {
407 XML_SetExternalEntityRefHandler(g_parser,
408 external_entity_alloc_set_encoding);
409 g_allocation_count = i;
410 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
411 == XML_STATUS_OK)
412 break;
413 g_allocation_count = -1;
414 /* See comment in test_alloc_parse_xdecl() */
415 alloc_teardown();
416 alloc_setup();
417 }
418 if (i == 0)
419 fail("Encoding check succeeded despite failing allocator");
420 if (i == max_allocation_count)
421 fail("Encoding failed at max allocation count");
422}
423END_TEST
424
425/* Test the effects of allocation failure in internal entities.
426 * Based on test_unknown_encoding_internal_entity
427 */
428START_TEST(test_alloc_internal_entity) {
429 const char *text = "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
430 "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
431 "<test a='&foo;'/>";
432 unsigned int i;
433 const unsigned int max_alloc_count = 20;
434
435 for (i = 0; i < max_alloc_count; i++) {
436 g_allocation_count = i;
437 XML_SetUnknownEncodingHandler(g_parser, unknown_released_encoding_handler,
438 NULL);
439 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
440 != XML_STATUS_ERROR)
441 break;
442 /* See comment in test_alloc_parse_xdecl() */
443 alloc_teardown();
444 alloc_setup();
445 }
446 if (i == 0)
447 fail("Internal entity worked despite failing allocations");
448 else if (i == max_alloc_count)
449 fail("Internal entity failed at max allocation count");
450}
451END_TEST
452
453/* Test the robustness against allocation failure of element handling
454 * Based on test_dtd_default_handling().
455 */
456START_TEST(test_alloc_dtd_default_handling) {
457 const char *text = "<!DOCTYPE doc [\n"
458 "<!ENTITY e SYSTEM 'http://example.org/e'>\n"
459 "<!NOTATION n SYSTEM 'http://example.org/n'>\n"
460 "<!ENTITY e1 SYSTEM 'http://example.org/e' NDATA n>\n"
461 "<!ELEMENT doc (#PCDATA)>\n"
462 "<!ATTLIST doc a CDATA #IMPLIED>\n"
463 "<?pi in dtd?>\n"
464 "<!--comment in dtd-->\n"
465 "]>\n"
466 "<doc><![CDATA[text in doc]]></doc>";
467 const XML_Char *expected = XCS("\n\n\n\n\n\n\n\n\n<doc>text in doc</doc>");
468 CharData storage;
469 int i;
470 const int max_alloc_count = 25;
471
472 for (i = 0; i < max_alloc_count; i++) {
473 g_allocation_count = i;
474 init_dummy_handlers();
475 XML_SetDefaultHandler(g_parser, accumulate_characters);
476 XML_SetDoctypeDeclHandler(g_parser, dummy_start_doctype_handler,
477 dummy_end_doctype_handler);
478 XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
479 XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
480 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
481 XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
482 XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
483 XML_SetCommentHandler(g_parser, dummy_comment_handler);
484 XML_SetCdataSectionHandler(g_parser, dummy_start_cdata_handler,
485 dummy_end_cdata_handler);
486 XML_SetUnparsedEntityDeclHandler(g_parser,
487 dummy_unparsed_entity_decl_handler);
488 CharData_Init(&storage);
489 XML_SetUserData(g_parser, &storage);
490 XML_SetCharacterDataHandler(g_parser, accumulate_characters);
491 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
492 != XML_STATUS_ERROR)
493 break;
494 /* See comment in test_alloc_parse_xdecl() */
495 alloc_teardown();
496 alloc_setup();
497 }
498 if (i == 0)
499 fail("Default DTD parsed despite allocation failures");
500 if (i == max_alloc_count)
501 fail("Default DTD not parsed with maximum alloc count");
502 CharData_CheckXMLChars(&storage, expected);
503 if (get_dummy_handler_flags()
504 != (DUMMY_START_DOCTYPE_HANDLER_FLAG | DUMMY_END_DOCTYPE_HANDLER_FLAG
505 | DUMMY_ENTITY_DECL_HANDLER_FLAG | DUMMY_NOTATION_DECL_HANDLER_FLAG
506 | DUMMY_ELEMENT_DECL_HANDLER_FLAG | DUMMY_ATTLIST_DECL_HANDLER_FLAG
507 | DUMMY_COMMENT_HANDLER_FLAG | DUMMY_PI_HANDLER_FLAG
508 | DUMMY_START_CDATA_HANDLER_FLAG | DUMMY_END_CDATA_HANDLER_FLAG
509 | DUMMY_UNPARSED_ENTITY_DECL_HANDLER_FLAG))
510 fail("Not all handlers were called");
511}
512END_TEST
513
514/* Test robustness of XML_SetEncoding() with a failing allocator */
515START_TEST(test_alloc_explicit_encoding) {
516 int i;
517 const int max_alloc_count = 5;
518
519 for (i = 0; i < max_alloc_count; i++) {
520 g_allocation_count = i;
521 if (XML_SetEncoding(g_parser, XCS("us-ascii")) == XML_STATUS_OK)
522 break;
523 }
524 if (i == 0)
525 fail("Encoding set despite failing allocator");
526 else if (i == max_alloc_count)
527 fail("Encoding not set at max allocation count");
528}
529END_TEST
530
531/* Test robustness of XML_SetBase against a failing allocator */
532START_TEST(test_alloc_set_base) {
533 const XML_Char *new_base = XCS("/local/file/name.xml");
534 int i;
535 const int max_alloc_count = 5;
536
537 for (i = 0; i < max_alloc_count; i++) {
538 g_allocation_count = i;
539 if (XML_SetBase(g_parser, new_base) == XML_STATUS_OK)
540 break;
541 }
542 if (i == 0)
543 fail("Base set despite failing allocator");
544 else if (i == max_alloc_count)
545 fail("Base not set with max allocation count");
546}
547END_TEST
548
549/* Test buffer extension in the face of a duff reallocator */
550START_TEST(test_alloc_realloc_buffer) {
551 const char *text = get_buffer_test_text;
552 void *buffer;
553 int i;
554 const int max_realloc_count = 10;
555
556 /* Get a smallish buffer */
557 for (i = 0; i < max_realloc_count; i++) {
558 g_reallocation_count = i;
559 buffer = XML_GetBuffer(g_parser, 1536);
560 if (buffer == NULL)
561 fail("1.5K buffer reallocation failed");
562 assert(buffer != NULL);
563 memcpy(buffer, text, strlen(text));
564 if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_FALSE)
565 == XML_STATUS_OK)
566 break;
567 /* See comment in test_alloc_parse_xdecl() */
568 alloc_teardown();
569 alloc_setup();
570 }
571 g_reallocation_count = -1;
572 if (i == 0)
573 fail("Parse succeeded with no reallocation");
574 else if (i == max_realloc_count)
575 fail("Parse failed with max reallocation count");
576}
577END_TEST
578
579/* Same test for external entity parsers */
580START_TEST(test_alloc_ext_entity_realloc_buffer) {
581 const char *text = "<!DOCTYPE doc [\n"
582 " <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
583 "]>\n"
584 "<doc>&en;</doc>";
585 int i;
586 const int max_realloc_count = 10;
587
588 for (i = 0; i < max_realloc_count; i++) {
589 XML_SetExternalEntityRefHandler(g_parser, external_entity_reallocator);
590 XML_SetUserData(g_parser, &i);
591 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
592 == XML_STATUS_OK)
593 break;
594 /* See comment in test_alloc_parse_xdecl() */
595 alloc_teardown();
596 alloc_setup();
597 }
598 if (i == 0)
599 fail("Succeeded with no reallocations");
600 if (i == max_realloc_count)
601 fail("Failed with max reallocations");
602}
603END_TEST
604
605/* Test elements with many attributes are handled correctly */
606START_TEST(test_alloc_realloc_many_attributes) {
607 const char *text = "<!DOCTYPE doc [\n"
608 "<!ATTLIST doc za CDATA 'default'>\n"
609 "<!ATTLIST doc zb CDATA 'def2'>\n"
610 "<!ATTLIST doc zc CDATA 'def3'>\n"
611 "]>\n"
612 "<doc a='1'"
613 " b='2'"
614 " c='3'"
615 " d='4'"
616 " e='5'"
617 " f='6'"
618 " g='7'"
619 " h='8'"
620 " i='9'"
621 " j='10'"
622 " k='11'"
623 " l='12'"
624 " m='13'"
625 " n='14'"
626 " p='15'"
627 " q='16'"
628 " r='17'"
629 " s='18'>"
630 "</doc>";
631 int i;
632 const int max_realloc_count = 10;
633
634 for (i = 0; i < max_realloc_count; i++) {
635 g_reallocation_count = i;
636 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
637 != XML_STATUS_ERROR)
638 break;
639 /* See comment in test_alloc_parse_xdecl() */
640 alloc_teardown();
641 alloc_setup();
642 }
643 if (i == 0)
644 fail("Parse succeeded despite no reallocations");
645 if (i == max_realloc_count)
646 fail("Parse failed at max reallocations");
647}
648END_TEST
649
650/* Test handling of a public entity with failing allocator */
651START_TEST(test_alloc_public_entity_value) {
652 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
653 "<doc></doc>\n";
654 char dtd_text[]
655 = "<!ELEMENT doc EMPTY>\n"
656 "<!ENTITY % e1 PUBLIC 'foo' 'bar.ent'>\n"
657 "<!ENTITY % "
658 /* Each line is 64 characters */
659 "ThisIsAStupidlyLongParameterNameIntendedToTriggerPoolGrowth12345"
660 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
661 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
662 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
663 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
664 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
665 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
666 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
667 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
668 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
669 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
670 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
671 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
672 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
673 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
674 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
675 " '%e1;'>\n"
676 "%e1;\n";
677 int i;
678 const int max_alloc_count = 50;
679
680 for (i = 0; i < max_alloc_count; i++) {
681 g_allocation_count = i;
682 init_dummy_handlers();
683 XML_SetUserData(g_parser, dtd_text);
684 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
685 XML_SetExternalEntityRefHandler(g_parser, external_entity_public);
686 /* Provoke a particular code path */
687 XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
688 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
689 != XML_STATUS_ERROR)
690 break;
691 /* See comment in test_alloc_parse_xdecl() */
692 alloc_teardown();
693 alloc_setup();
694 }
695 if (i == 0)
696 fail("Parsing worked despite failing allocation");
697 if (i == max_alloc_count)
698 fail("Parsing failed at max allocation count");
699 if (get_dummy_handler_flags() != DUMMY_ENTITY_DECL_HANDLER_FLAG)
700 fail("Entity declaration handler not called");
701}
702END_TEST
703
704START_TEST(test_alloc_realloc_subst_public_entity_value) {
705 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
706 "<doc></doc>\n";
707 char dtd_text[]
708 = "<!ELEMENT doc EMPTY>\n"
709 "<!ENTITY % "
710 /* Each line is 64 characters */
711 "ThisIsAStupidlyLongParameterNameIntendedToTriggerPoolGrowth12345"
712 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
713 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
714 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
715 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
716 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
717 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
718 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
719 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
720 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
721 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
722 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
723 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
724 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
725 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
726 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
727 " PUBLIC 'foo' 'bar.ent'>\n"
728 "%ThisIsAStupidlyLongParameterNameIntendedToTriggerPoolGrowth12345"
729 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
730 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
731 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
732 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
733 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
734 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
735 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
736 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
737 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
738 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
739 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
740 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
741 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
742 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
743 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP;";
744 int i;
745 const int max_realloc_count = 10;
746
747 for (i = 0; i < max_realloc_count; i++) {
748 g_reallocation_count = i;
749 XML_SetUserData(g_parser, dtd_text);
750 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
751 XML_SetExternalEntityRefHandler(g_parser, external_entity_public);
752 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
753 != XML_STATUS_ERROR)
754 break;
755 /* See comment in test_alloc_parse_xdecl() */
756 alloc_teardown();
757 alloc_setup();
758 }
759 if (i == 0)
760 fail("Parsing worked despite failing reallocation");
761 if (i == max_realloc_count)
762 fail("Parsing failed at max reallocation count");
763}
764END_TEST
765
766START_TEST(test_alloc_parse_public_doctype) {
767 const char *text
768 = "<?xml version='1.0' encoding='utf-8'?>\n"
769 "<!DOCTYPE doc PUBLIC '"
770 /* 64 characters per line */
771 "http://example.com/a/long/enough/name/to/trigger/pool/growth/zz/"
772 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
773 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
774 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
775 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
776 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
777 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
778 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
779 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
780 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
781 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
782 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
783 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
784 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
785 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
786 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
787 "' 'test'>\n"
788 "<doc></doc>";
789 int i;
790 const int max_alloc_count = 25;
791
792 for (i = 0; i < max_alloc_count; i++) {
793 g_allocation_count = i;
794 init_dummy_handlers();
795 XML_SetDoctypeDeclHandler(g_parser, dummy_start_doctype_decl_handler,
796 dummy_end_doctype_decl_handler);
797 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
798 != XML_STATUS_ERROR)
799 break;
800 /* See comment in test_alloc_parse_xdecl() */
801 alloc_teardown();
802 alloc_setup();
803 }
804 if (i == 0)
805 fail("Parse succeeded despite failing allocator");
806 if (i == max_alloc_count)
807 fail("Parse failed at maximum allocation count");
808 if (get_dummy_handler_flags()
809 != (DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG
810 | DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG))
811 fail("Doctype handler functions not called");
812}
813END_TEST
814
815START_TEST(test_alloc_parse_public_doctype_long_name) {
816 const char *text
817 = "<?xml version='1.0' encoding='utf-8'?>\n"
818 "<!DOCTYPE doc PUBLIC 'http://example.com/foo' '"
819 /* 64 characters per line */
820 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
821 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
822 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
823 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
824 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
825 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
826 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
827 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
828 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
829 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
830 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
831 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
832 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
833 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
834 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
835 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
836 "'>\n"
837 "<doc></doc>";
838 int i;
839 const int max_alloc_count = 25;
840
841 for (i = 0; i < max_alloc_count; i++) {
842 g_allocation_count = i;
843 XML_SetDoctypeDeclHandler(g_parser, dummy_start_doctype_decl_handler,
844 dummy_end_doctype_decl_handler);
845 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
846 != XML_STATUS_ERROR)
847 break;
848 /* See comment in test_alloc_parse_xdecl() */
849 alloc_teardown();
850 alloc_setup();
851 }
852 if (i == 0)
853 fail("Parse succeeded despite failing allocator");
854 if (i == max_alloc_count)
855 fail("Parse failed at maximum allocation count");
856}
857END_TEST
858
859/* Test foreign DTD handling */
860START_TEST(test_alloc_set_foreign_dtd) {
861 const char *text1 = "<?xml version='1.0' encoding='us-ascii'?>\n"
862 "<doc>&entity;</doc>";
863 char text2[] = "<!ELEMENT doc (#PCDATA)*>";
864 int i;
865 const int max_alloc_count = 25;
866
867 for (i = 0; i < max_alloc_count; i++) {
868 g_allocation_count = i;
869 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
870 XML_SetUserData(g_parser, &text2);
871 XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
872 if (XML_UseForeignDTD(g_parser, XML_TRUE) != XML_ERROR_NONE)
873 fail("Could not set foreign DTD");
874 if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_TRUE)
875 != XML_STATUS_ERROR)
876 break;
877 /* See comment in test_alloc_parse_xdecl() */
878 alloc_teardown();
879 alloc_setup();
880 }
881 if (i == 0)
882 fail("Parse succeeded despite failing allocator");
883 if (i == max_alloc_count)
884 fail("Parse failed at maximum allocation count");
885}
886END_TEST
887
888/* Test based on ibm/valid/P32/ibm32v04.xml */
889START_TEST(test_alloc_attribute_enum_value) {
890 const char *text = "<?xml version='1.0' standalone='no'?>\n"
891 "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
892 "<animal>This is a \n <a/> \n\nyellow tiger</animal>";
893 char dtd_text[] = "<!ELEMENT animal (#PCDATA|a)*>\n"
894 "<!ELEMENT a EMPTY>\n"
895 "<!ATTLIST animal xml:space (default|preserve) 'preserve'>";
896 int i;
897 const int max_alloc_count = 30;
898
899 for (i = 0; i < max_alloc_count; i++) {
900 g_allocation_count = i;
901 XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
902 XML_SetUserData(g_parser, dtd_text);
903 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
904 /* An attribute list handler provokes a different code path */
905 XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
906 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
907 != XML_STATUS_ERROR)
908 break;
909 /* See comment in test_alloc_parse_xdecl() */
910 alloc_teardown();
911 alloc_setup();
912 }
913 if (i == 0)
914 fail("Parse succeeded despite failing allocator");
915 if (i == max_alloc_count)
916 fail("Parse failed at maximum allocation count");
917}
918END_TEST
919
920/* Test attribute enums sufficient to overflow the string pool */
921START_TEST(test_alloc_realloc_attribute_enum_value) {
922 const char *text = "<?xml version='1.0' standalone='no'?>\n"
923 "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
924 "<animal>This is a yellow tiger</animal>";
925 /* We wish to define a collection of attribute enums that will
926 * cause the string pool storing them to have to expand. This
927 * means more than 1024 bytes, including the parentheses and
928 * separator bars.
929 */
930 char dtd_text[]
931 = "<!ELEMENT animal (#PCDATA)*>\n"
932 "<!ATTLIST animal thing "
933 "(default"
934 /* Each line is 64 characters */
935 "|ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
936 "|BBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
937 "|CBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
938 "|DBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
939 "|EBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
940 "|FBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
941 "|GBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
942 "|HBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
943 "|IBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
944 "|JBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
945 "|KBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
946 "|LBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
947 "|MBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
948 "|NBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
949 "|OBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
950 "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO)"
951 " 'default'>";
952 int i;
953 const int max_realloc_count = 10;
954
955 for (i = 0; i < max_realloc_count; i++) {
956 g_reallocation_count = i;
957 XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
958 XML_SetUserData(g_parser, dtd_text);
959 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
960 /* An attribute list handler provokes a different code path */
961 XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
962 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
963 != XML_STATUS_ERROR)
964 break;
965 /* See comment in test_alloc_parse_xdecl() */
966 alloc_teardown();
967 alloc_setup();
968 }
969 if (i == 0)
970 fail("Parse succeeded despite failing reallocator");
971 if (i == max_realloc_count)
972 fail("Parse failed at maximum reallocation count");
973}
974END_TEST
975
976/* Test attribute enums in a #IMPLIED attribute forcing pool growth */
977START_TEST(test_alloc_realloc_implied_attribute) {
978 /* Forcing this particular code path is a balancing act. The
979 * addition of the closing parenthesis and terminal NUL must be
980 * what pushes the string of enums over the 1024-byte limit,
981 * otherwise a different code path will pick up the realloc.
982 */
983 const char *text
984 = "<!DOCTYPE doc [\n"
985 "<!ELEMENT doc EMPTY>\n"
986 "<!ATTLIST doc a "
987 /* Each line is 64 characters */
988 "(ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
989 "|BBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
990 "|CBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
991 "|DBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
992 "|EBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
993 "|FBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
994 "|GBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
995 "|HBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
996 "|IBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
997 "|JBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
998 "|KBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
999 "|LBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1000 "|MBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1001 "|NBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1002 "|OBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1003 "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN)"
1004 " #IMPLIED>\n"
1005 "]><doc/>";
1006 int i;
1007 const int max_realloc_count = 10;
1008
1009 for (i = 0; i < max_realloc_count; i++) {
1010 g_reallocation_count = i;
1011 XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
1012 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1013 != XML_STATUS_ERROR)
1014 break;
1015 /* See comment in test_alloc_parse_xdecl() */
1016 alloc_teardown();
1017 alloc_setup();
1018 }
1019 if (i == 0)
1020 fail("Parse succeeded despite failing reallocator");
1021 if (i == max_realloc_count)
1022 fail("Parse failed at maximum reallocation count");
1023}
1024END_TEST
1025
1026/* Test attribute enums in a defaulted attribute forcing pool growth */
1027START_TEST(test_alloc_realloc_default_attribute) {
1028 /* Forcing this particular code path is a balancing act. The
1029 * addition of the closing parenthesis and terminal NUL must be
1030 * what pushes the string of enums over the 1024-byte limit,
1031 * otherwise a different code path will pick up the realloc.
1032 */
1033 const char *text
1034 = "<!DOCTYPE doc [\n"
1035 "<!ELEMENT doc EMPTY>\n"
1036 "<!ATTLIST doc a "
1037 /* Each line is 64 characters */
1038 "(ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1039 "|BBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1040 "|CBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1041 "|DBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1042 "|EBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1043 "|FBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1044 "|GBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1045 "|HBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1046 "|IBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1047 "|JBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1048 "|KBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1049 "|LBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1050 "|MBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1051 "|NBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1052 "|OBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
1053 "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN)"
1054 " 'ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO'"
1055 ">\n]><doc/>";
1056 int i;
1057 const int max_realloc_count = 10;
1058
1059 for (i = 0; i < max_realloc_count; i++) {
1060 g_reallocation_count = i;
1061 XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
1062 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1063 != XML_STATUS_ERROR)
1064 break;
1065 /* See comment in test_alloc_parse_xdecl() */
1066 alloc_teardown();
1067 alloc_setup();
1068 }
1069 if (i == 0)
1070 fail("Parse succeeded despite failing reallocator");
1071 if (i == max_realloc_count)
1072 fail("Parse failed at maximum reallocation count");
1073}
1074END_TEST
1075
1076/* Test long notation name with dodgy allocator */
1077START_TEST(test_alloc_notation) {
1078 const char *text
1079 = "<!DOCTYPE doc [\n"
1080 "<!NOTATION "
1081 /* Each line is 64 characters */
1082 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1083 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1084 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1085 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1086 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1087 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1088 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1089 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1090 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1091 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1092 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1093 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1094 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1095 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1096 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1097 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1098 " SYSTEM 'http://example.org/n'>\n"
1099 "<!ENTITY e SYSTEM 'http://example.org/e' NDATA "
1100 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1101 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1102 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1103 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1104 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1105 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1106 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1107 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1108 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1109 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1110 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1111 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1112 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1113 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1114 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1115 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1116 ">\n"
1117 "<!ELEMENT doc EMPTY>\n"
1118 "]>\n<doc/>";
1119 int i;
1120 const int max_alloc_count = 20;
1121
1122 for (i = 0; i < max_alloc_count; i++) {
1123 g_allocation_count = i;
1124 init_dummy_handlers();
1125 XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
1126 XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
1127 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1128 != XML_STATUS_ERROR)
1129 break;
1130 /* See comment in test_alloc_parse_xdecl() */
1131 alloc_teardown();
1132 alloc_setup();
1133 }
1134 if (i == 0)
1135 fail("Parse succeeded despite allocation failures");
1136 if (i == max_alloc_count)
1137 fail("Parse failed at maximum allocation count");
1138 if (get_dummy_handler_flags()
1139 != (DUMMY_ENTITY_DECL_HANDLER_FLAG | DUMMY_NOTATION_DECL_HANDLER_FLAG))
1140 fail("Entity declaration handler not called");
1141}
1142END_TEST
1143
1144/* Test public notation with dodgy allocator */
1145START_TEST(test_alloc_public_notation) {
1146 const char *text
1147 = "<!DOCTYPE doc [\n"
1148 "<!NOTATION note PUBLIC '"
1149 /* 64 characters per line */
1150 "http://example.com/a/long/enough/name/to/trigger/pool/growth/zz/"
1151 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1152 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1153 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1154 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1155 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1156 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1157 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1158 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1159 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1160 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1161 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1162 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1163 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1164 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1165 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1166 "' 'foo'>\n"
1167 "<!ENTITY e SYSTEM 'http://example.com/e' NDATA note>\n"
1168 "<!ELEMENT doc EMPTY>\n"
1169 "]>\n<doc/>";
1170 int i;
1171 const int max_alloc_count = 20;
1172
1173 for (i = 0; i < max_alloc_count; i++) {
1174 g_allocation_count = i;
1175 init_dummy_handlers();
1176 XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
1177 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1178 != XML_STATUS_ERROR)
1179 break;
1180 /* See comment in test_alloc_parse_xdecl() */
1181 alloc_teardown();
1182 alloc_setup();
1183 }
1184 if (i == 0)
1185 fail("Parse succeeded despite allocation failures");
1186 if (i == max_alloc_count)
1187 fail("Parse failed at maximum allocation count");
1188 if (get_dummy_handler_flags() != DUMMY_NOTATION_DECL_HANDLER_FLAG)
1189 fail("Notation handler not called");
1190}
1191END_TEST
1192
1193/* Test public notation with dodgy allocator */
1194START_TEST(test_alloc_system_notation) {
1195 const char *text
1196 = "<!DOCTYPE doc [\n"
1197 "<!NOTATION note SYSTEM '"
1198 /* 64 characters per line */
1199 "http://example.com/a/long/enough/name/to/trigger/pool/growth/zz/"
1200 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1201 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1202 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1203 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1204 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1205 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1206 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1207 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1208 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1209 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1210 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1211 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1212 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1213 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1214 "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
1215 "'>\n"
1216 "<!ENTITY e SYSTEM 'http://example.com/e' NDATA note>\n"
1217 "<!ELEMENT doc EMPTY>\n"
1218 "]>\n<doc/>";
1219 int i;
1220 const int max_alloc_count = 20;
1221
1222 for (i = 0; i < max_alloc_count; i++) {
1223 g_allocation_count = i;
1224 init_dummy_handlers();
1225 XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
1226 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1227 != XML_STATUS_ERROR)
1228 break;
1229 /* See comment in test_alloc_parse_xdecl() */
1230 alloc_teardown();
1231 alloc_setup();
1232 }
1233 if (i == 0)
1234 fail("Parse succeeded despite allocation failures");
1235 if (i == max_alloc_count)
1236 fail("Parse failed at maximum allocation count");
1237 if (get_dummy_handler_flags() != DUMMY_NOTATION_DECL_HANDLER_FLAG)
1238 fail("Notation handler not called");
1239}
1240END_TEST
1241
1242START_TEST(test_alloc_nested_groups) {
1243 const char *text
1244 = "<!DOCTYPE doc [\n"
1245 "<!ELEMENT doc "
1246 /* Sixteen elements per line */
1247 "(e,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,"
1248 "(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?"
1249 "))))))))))))))))))))))))))))))))>\n"
1250 "<!ELEMENT e EMPTY>"
1251 "]>\n"
1252 "<doc><e/></doc>";
1253 CharData storage;
1254 int i;
1255 const int max_alloc_count = 20;
1256
1257 for (i = 0; i < max_alloc_count; i++) {
1258 g_allocation_count = i;
1259 CharData_Init(&storage);
1260 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
1261 XML_SetStartElementHandler(g_parser, record_element_start_handler);
1262 XML_SetUserData(g_parser, &storage);
1263 init_dummy_handlers();
1264 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1265 != XML_STATUS_ERROR)
1266 break;
1267 /* See comment in test_alloc_parse_xdecl() */
1268 alloc_teardown();
1269 alloc_setup();
1270 }
1271
1272 if (i == 0)
1273 fail("Parse succeeded despite failing reallocator");
1274 if (i == max_alloc_count)
1275 fail("Parse failed at maximum reallocation count");
1276 CharData_CheckXMLChars(&storage, XCS("doce"));
1277 if (get_dummy_handler_flags() != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
1278 fail("Element handler not fired");
1279}
1280END_TEST
1281
1282START_TEST(test_alloc_realloc_nested_groups) {
1283 const char *text
1284 = "<!DOCTYPE doc [\n"
1285 "<!ELEMENT doc "
1286 /* Sixteen elements per line */
1287 "(e,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,"
1288 "(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?"
1289 "))))))))))))))))))))))))))))))))>\n"
1290 "<!ELEMENT e EMPTY>"
1291 "]>\n"
1292 "<doc><e/></doc>";
1293 CharData storage;
1294 int i;
1295 const int max_realloc_count = 10;
1296
1297 for (i = 0; i < max_realloc_count; i++) {
1298 g_reallocation_count = i;
1299 CharData_Init(&storage);
1300 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
1301 XML_SetStartElementHandler(g_parser, record_element_start_handler);
1302 XML_SetUserData(g_parser, &storage);
1303 init_dummy_handlers();
1304 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1305 != XML_STATUS_ERROR)
1306 break;
1307 /* See comment in test_alloc_parse_xdecl() */
1308 alloc_teardown();
1309 alloc_setup();
1310 }
1311
1312 if (i == 0)
1313 fail("Parse succeeded despite failing reallocator");
1314 if (i == max_realloc_count)
1315 fail("Parse failed at maximum reallocation count");
1316 CharData_CheckXMLChars(&storage, XCS("doce"));
1317 if (get_dummy_handler_flags() != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
1318 fail("Element handler not fired");
1319}
1320END_TEST
1321
1322START_TEST(test_alloc_large_group) {
1323 const char *text = "<!DOCTYPE doc [\n"
1324 "<!ELEMENT doc ("
1325 "a1|a2|a3|a4|a5|a6|a7|a8|"
1326 "b1|b2|b3|b4|b5|b6|b7|b8|"
1327 "c1|c2|c3|c4|c5|c6|c7|c8|"
1328 "d1|d2|d3|d4|d5|d6|d7|d8|"
1329 "e1"
1330 ")+>\n"
1331 "]>\n"
1332 "<doc>\n"
1333 "<a1/>\n"
1334 "</doc>\n";
1335 int i;
1336 const int max_alloc_count = 50;
1337
1338 for (i = 0; i < max_alloc_count; i++) {
1339 g_allocation_count = i;
1340 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
1341 init_dummy_handlers();
1342 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1343 != XML_STATUS_ERROR)
1344 break;
1345 /* See comment in test_alloc_parse_xdecl() */
1346 alloc_teardown();
1347 alloc_setup();
1348 }
1349 if (i == 0)
1350 fail("Parse succeeded despite failing allocator");
1351 if (i == max_alloc_count)
1352 fail("Parse failed at maximum allocation count");
1353 if (get_dummy_handler_flags() != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
1354 fail("Element handler flag not raised");
1355}
1356END_TEST
1357
1358START_TEST(test_alloc_realloc_group_choice) {
1359 const char *text = "<!DOCTYPE doc [\n"
1360 "<!ELEMENT doc ("
1361 "a1|a2|a3|a4|a5|a6|a7|a8|"
1362 "b1|b2|b3|b4|b5|b6|b7|b8|"
1363 "c1|c2|c3|c4|c5|c6|c7|c8|"
1364 "d1|d2|d3|d4|d5|d6|d7|d8|"
1365 "e1"
1366 ")+>\n"
1367 "]>\n"
1368 "<doc>\n"
1369 "<a1/>\n"
1370 "<b2 attr='foo'>This is a foo</b2>\n"
1371 "<c3></c3>\n"
1372 "</doc>\n";
1373 int i;
1374 const int max_realloc_count = 10;
1375
1376 for (i = 0; i < max_realloc_count; i++) {
1377 g_reallocation_count = i;
1378 XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
1379 init_dummy_handlers();
1380 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1381 != XML_STATUS_ERROR)
1382 break;
1383 /* See comment in test_alloc_parse_xdecl() */
1384 alloc_teardown();
1385 alloc_setup();
1386 }
1387 if (i == 0)
1388 fail("Parse succeeded despite failing reallocator");
1389 if (i == max_realloc_count)
1390 fail("Parse failed at maximum reallocation count");
1391 if (get_dummy_handler_flags() != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
1392 fail("Element handler flag not raised");
1393}
1394END_TEST
1395
1396START_TEST(test_alloc_pi_in_epilog) {
1397 const char *text = "<doc></doc>\n"
1398 "<?pi in epilog?>";
1399 int i;
1400 const int max_alloc_count = 15;
1401
1402 for (i = 0; i < max_alloc_count; i++) {
1403 g_allocation_count = i;
1404 XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
1405 init_dummy_handlers();
1406 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1407 != XML_STATUS_ERROR)
1408 break;
1409 /* See comment in test_alloc_parse_xdecl() */
1410 alloc_teardown();
1411 alloc_setup();
1412 }
1413 if (i == 0)
1414 fail("Parse completed despite failing allocator");
1415 if (i == max_alloc_count)
1416 fail("Parse failed at maximum allocation count");
1417 if (get_dummy_handler_flags() != DUMMY_PI_HANDLER_FLAG)
1418 fail("Processing instruction handler not invoked");
1419}
1420END_TEST
1421
1422START_TEST(test_alloc_comment_in_epilog) {
1423 const char *text = "<doc></doc>\n"
1424 "<!-- comment in epilog -->";
1425 int i;
1426 const int max_alloc_count = 15;
1427
1428 for (i = 0; i < max_alloc_count; i++) {
1429 g_allocation_count = i;
1430 XML_SetCommentHandler(g_parser, dummy_comment_handler);
1431 init_dummy_handlers();
1432 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1433 != XML_STATUS_ERROR)
1434 break;
1435 /* See comment in test_alloc_parse_xdecl() */
1436 alloc_teardown();
1437 alloc_setup();
1438 }
1439 if (i == 0)
1440 fail("Parse completed despite failing allocator");
1441 if (i == max_alloc_count)
1442 fail("Parse failed at maximum allocation count");
1443 if (get_dummy_handler_flags() != DUMMY_COMMENT_HANDLER_FLAG)
1444 fail("Processing instruction handler not invoked");
1445}
1446END_TEST
1447
1448START_TEST(test_alloc_realloc_long_attribute_value) {
1449 const char *text
1450 = "<!DOCTYPE doc [<!ENTITY foo '"
1451 /* Each line is 64 characters */
1452 "This entity will be substituted as an attribute value, and is "
1453 "calculated to be exactly long enough that the terminating NUL "
1454 "that the library adds internally will trigger the string pool to"
1455 "grow. GHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1456 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1457 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1458 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1459 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1460 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1461 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1462 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1463 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1464 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1465 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1466 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1467 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1468 "'>]>\n"
1469 "<doc a='&foo;'></doc>";
1470 int i;
1471 const int max_realloc_count = 10;
1472
1473 for (i = 0; i < max_realloc_count; i++) {
1474 g_reallocation_count = i;
1475 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1476 != XML_STATUS_ERROR)
1477 break;
1478 /* See comment in test_alloc_parse_xdecl() */
1479 alloc_teardown();
1480 alloc_setup();
1481 }
1482 if (i == 0)
1483 fail("Parse succeeded despite failing reallocator");
1484 if (i == max_realloc_count)
1485 fail("Parse failed at maximum reallocation count");
1486}
1487END_TEST
1488
1489START_TEST(test_alloc_attribute_whitespace) {
1490 const char *text = "<doc a=' '></doc>";
1491 int i;
1492 const int max_alloc_count = 15;
1493
1494 for (i = 0; i < max_alloc_count; i++) {
1495 g_allocation_count = i;
1496 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1497 != XML_STATUS_ERROR)
1498 break;
1499 /* See comment in test_alloc_parse_xdecl() */
1500 alloc_teardown();
1501 alloc_setup();
1502 }
1503 if (i == 0)
1504 fail("Parse succeeded despite failing allocator");
1505 if (i == max_alloc_count)
1506 fail("Parse failed at maximum allocation count");
1507}
1508END_TEST
1509
1510START_TEST(test_alloc_attribute_predefined_entity) {
1511 const char *text = "<doc a='&amp;'></doc>";
1512 int i;
1513 const int max_alloc_count = 15;
1514
1515 for (i = 0; i < max_alloc_count; i++) {
1516 g_allocation_count = i;
1517 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1518 != XML_STATUS_ERROR)
1519 break;
1520 /* See comment in test_alloc_parse_xdecl() */
1521 alloc_teardown();
1522 alloc_setup();
1523 }
1524 if (i == 0)
1525 fail("Parse succeeded despite failing allocator");
1526 if (i == max_alloc_count)
1527 fail("Parse failed at maximum allocation count");
1528}
1529END_TEST
1530
1531/* Test that a character reference at the end of a suitably long
1532 * default value for an attribute can trigger pool growth, and recovers
1533 * if the allocator fails on it.
1534 */
1535START_TEST(test_alloc_long_attr_default_with_char_ref) {
1536 const char *text
1537 = "<!DOCTYPE doc [<!ATTLIST doc a CDATA '"
1538 /* 64 characters per line */
1539 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1540 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1541 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1542 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1543 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1544 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1545 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1546 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1547 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1548 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1549 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1550 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1551 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1552 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1553 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1554 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHI"
1555 "&#x31;'>]>\n"
1556 "<doc/>";
1557 int i;
1558 const int max_alloc_count = 20;
1559
1560 for (i = 0; i < max_alloc_count; i++) {
1561 g_allocation_count = i;
1562 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1563 != XML_STATUS_ERROR)
1564 break;
1565 /* See comment in test_alloc_parse_xdecl() */
1566 alloc_teardown();
1567 alloc_setup();
1568 }
1569 if (i == 0)
1570 fail("Parse succeeded despite failing allocator");
1571 if (i == max_alloc_count)
1572 fail("Parse failed at maximum allocation count");
1573}
1574END_TEST
1575
1576/* Test that a long character reference substitution triggers a pool
1577 * expansion correctly for an attribute value.
1578 */
1579START_TEST(test_alloc_long_attr_value) {
1580 const char *text
1581 = "<!DOCTYPE test [<!ENTITY foo '\n"
1582 /* 64 characters per line */
1583 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1584 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1585 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1586 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1587 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1588 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1589 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1590 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1591 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1592 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1593 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1594 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1595 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1596 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1597 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1598 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1599 "'>]>\n"
1600 "<test a='&foo;'/>";
1601 int i;
1602 const int max_alloc_count = 25;
1603
1604 for (i = 0; i < max_alloc_count; i++) {
1605 g_allocation_count = i;
1606 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1607 != XML_STATUS_ERROR)
1608 break;
1609 /* See comment in test_alloc_parse_xdecl() */
1610 alloc_teardown();
1611 alloc_setup();
1612 }
1613 if (i == 0)
1614 fail("Parse succeeded despite failing allocator");
1615 if (i == max_alloc_count)
1616 fail("Parse failed at maximum allocation count");
1617}
1618END_TEST
1619
1620/* Test that an error in a nested parameter entity substitution is
1621 * handled correctly. It seems unlikely that the code path being
1622 * exercised can be reached purely by carefully crafted XML, but an
1623 * allocation error in the right place will definitely do it.
1624 */
1625START_TEST(test_alloc_nested_entities) {
1626 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
1627 "<doc />";
1628 ExtFaults test_data
1629 = {"<!ENTITY % pe1 '"
1630 /* 64 characters per line */
1631 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1632 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1633 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1634 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1635 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1636 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1637 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1638 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1639 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1640 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1641 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1642 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1643 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1644 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1645 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1646 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1647 "'>\n"
1648 "<!ENTITY % pe2 '%pe1;'>\n"
1649 "<!ENTITY % pe3 '%pe2;'>",
1650 "Memory Fail not faulted", NULL, XML_ERROR_NO_MEMORY};
1651
1652 /* Causes an allocation error in a nested storeEntityValue() */
1653 g_allocation_count = 12;
1654 XML_SetUserData(g_parser, &test_data);
1655 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1656 XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
1657 expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
1658 "Entity allocation failure not noted");
1659}
1660END_TEST
1661
1662START_TEST(test_alloc_realloc_param_entity_newline) {
1663 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
1664 "<doc/>";
1665 char dtd_text[]
1666 = "<!ENTITY % pe '<!ATTLIST doc att CDATA \""
1667 /* 64 characters per line */
1668 "This default value is carefully crafted so that the carriage "
1669 "return right at the end of the entity string causes an internal "
1670 "string pool to have to grow. This allows us to test the alloc "
1671 "failure path from that point. OPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1672 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1673 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1674 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1675 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1676 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1677 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1678 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1679 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1680 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1681 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1682 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1683 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDE"
1684 "\">\n'>"
1685 "%pe;\n";
1686 int i;
1687 const int max_realloc_count = 5;
1688
1689 for (i = 0; i < max_realloc_count; i++) {
1690 g_reallocation_count = i;
1691 XML_SetUserData(g_parser, dtd_text);
1692 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1693 XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
1694 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1695 != XML_STATUS_ERROR)
1696 break;
1697 /* See comment in test_alloc_parse_xdecl() */
1698 alloc_teardown();
1699 alloc_setup();
1700 }
1701 if (i == 0)
1702 fail("Parse succeeded despite failing reallocator");
1703 if (i == max_realloc_count)
1704 fail("Parse failed at maximum reallocation count");
1705}
1706END_TEST
1707
1708START_TEST(test_alloc_realloc_ce_extends_pe) {
1709 const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
1710 "<doc/>";
1711 char dtd_text[]
1712 = "<!ENTITY % pe '<!ATTLIST doc att CDATA \""
1713 /* 64 characters per line */
1714 "This default value is carefully crafted so that the character "
1715 "entity at the end causes an internal string pool to have to "
1716 "grow. This allows us to test the allocation failure path from "
1717 "that point onwards. EFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1718 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1719 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1720 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1721 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1722 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1723 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1724 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1725 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1726 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1727 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1728 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
1729 "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFG&#x51;"
1730 "\">\n'>"
1731 "%pe;\n";
1732 int i;
1733 const int max_realloc_count = 5;
1734
1735 for (i = 0; i < max_realloc_count; i++) {
1736 g_reallocation_count = i;
1737 XML_SetUserData(g_parser, dtd_text);
1738 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1739 XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
1740 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1741 != XML_STATUS_ERROR)
1742 break;
1743 /* See comment in test_alloc_parse_xdecl() */
1744 alloc_teardown();
1745 alloc_setup();
1746 }
1747 if (i == 0)
1748 fail("Parse succeeded despite failing reallocator");
1749 if (i == max_realloc_count)
1750 fail("Parse failed at maximum reallocation count");
1751}
1752END_TEST
1753
1754START_TEST(test_alloc_realloc_attributes) {
1755 const char *text = "<!DOCTYPE doc [\n"
1756 " <!ATTLIST doc\n"
1757 " a1 (a|b|c) 'a'\n"
1758 " a2 (foo|bar) #IMPLIED\n"
1759 " a3 NMTOKEN #IMPLIED\n"
1760 " a4 NMTOKENS #IMPLIED\n"
1761 " a5 ID #IMPLIED\n"
1762 " a6 IDREF #IMPLIED\n"
1763 " a7 IDREFS #IMPLIED\n"
1764 " a8 ENTITY #IMPLIED\n"
1765 " a9 ENTITIES #IMPLIED\n"
1766 " a10 CDATA #IMPLIED\n"
1767 " >]>\n"
1768 "<doc>wombat</doc>\n";
1769 int i;
1770 const int max_realloc_count = 5;
1771
1772 for (i = 0; i < max_realloc_count; i++) {
1773 g_reallocation_count = i;
1774 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1775 != XML_STATUS_ERROR)
1776 break;
1777 /* See comment in test_alloc_parse_xdecl() */
1778 alloc_teardown();
1779 alloc_setup();
1780 }
1781
1782 if (i == 0)
1783 fail("Parse succeeded despite failing reallocator");
1784 if (i == max_realloc_count)
1785 fail("Parse failed at maximum reallocation count");
1786}
1787END_TEST
1788
1789START_TEST(test_alloc_long_doc_name) {
1790 const char *text =
1791 /* 64 characters per line */
1792 "<LongRootElementNameThatWillCauseTheNextAllocationToExpandTheStr"
1793 "ingPoolForTheDTDQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1794 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1795 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1796 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1797 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1798 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1799 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1800 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1801 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1802 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1803 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1804 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1805 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1806 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1807 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
1808 " a='1'/>";
1809 int i;
1810 const int max_alloc_count = 20;
1811
1812 for (i = 0; i < max_alloc_count; i++) {
1813 g_allocation_count = i;
1814 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1815 != XML_STATUS_ERROR)
1816 break;
1817 /* See comment in test_alloc_parse_xdecl() */
1818 alloc_teardown();
1819 alloc_setup();
1820 }
1821 if (i == 0)
1822 fail("Parsing worked despite failing reallocations");
1823 else if (i == max_alloc_count)
1824 fail("Parsing failed even at max reallocation count");
1825}
1826END_TEST
1827
1828START_TEST(test_alloc_long_base) {
1829 const char *text = "<!DOCTYPE doc [\n"
1830 " <!ENTITY e SYSTEM 'foo'>\n"
1831 "]>\n"
1832 "<doc>&e;</doc>";
1833 char entity_text[] = "Hello world";
1834 const XML_Char *base =
1835 /* 64 characters per line */
1836 /* clang-format off */
1837 XCS("LongBaseURI/that/will/overflow/an/internal/buffer/and/cause/it/t")
1838 XCS("o/have/to/grow/PQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1839 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1840 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1841 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1842 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1843 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1844 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1845 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1846 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1847 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1848 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1849 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1850 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1851 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
1852 XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/");
1853 /* clang-format on */
1854 int i;
1855 const int max_alloc_count = 25;
1856
1857 for (i = 0; i < max_alloc_count; i++) {
1858 g_allocation_count = i;
1859 XML_SetUserData(g_parser, entity_text);
1860 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1861 XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
1862 if (XML_SetBase(g_parser, base) == XML_STATUS_ERROR) {
1863 XML_ParserReset(g_parser, NULL);
1864 continue;
1865 }
1866 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1867 != XML_STATUS_ERROR)
1868 break;
1869 /* See comment in test_alloc_parse_xdecl() */
1870 alloc_teardown();
1871 alloc_setup();
1872 }
1873 if (i == 0)
1874 fail("Parsing worked despite failing allocations");
1875 else if (i == max_alloc_count)
1876 fail("Parsing failed even at max allocation count");
1877}
1878END_TEST
1879
1880START_TEST(test_alloc_long_public_id) {
1881 const char *text
1882 = "<!DOCTYPE doc [\n"
1883 " <!ENTITY e PUBLIC '"
1884 /* 64 characters per line */
1885 "LongPublicIDThatShouldResultInAnInternalStringPoolGrowingAtASpec"
1886 "ificMomentKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1887 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1888 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1889 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1890 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1891 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1892 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1893 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1894 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1895 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1896 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1897 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1898 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1899 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1900 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1901 "' 'bar'>\n"
1902 "]>\n"
1903 "<doc>&e;</doc>";
1904 char entity_text[] = "Hello world";
1905 int i;
1906 const int max_alloc_count = 40;
1907
1908 for (i = 0; i < max_alloc_count; i++) {
1909 g_allocation_count = i;
1910 XML_SetUserData(g_parser, entity_text);
1911 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1912 XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
1913 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1914 != XML_STATUS_ERROR)
1915 break;
1916 /* See comment in test_alloc_parse_xdecl() */
1917 alloc_teardown();
1918 alloc_setup();
1919 }
1920 if (i == 0)
1921 fail("Parsing worked despite failing allocations");
1922 else if (i == max_alloc_count)
1923 fail("Parsing failed even at max allocation count");
1924}
1925END_TEST
1926
1927START_TEST(test_alloc_long_entity_value) {
1928 const char *text
1929 = "<!DOCTYPE doc [\n"
1930 " <!ENTITY e1 '"
1931 /* 64 characters per line */
1932 "Long entity value that should provoke a string pool to grow whil"
1933 "e setting up to parse the external entity below. xyz0123456789AB"
1934 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1935 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1936 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1937 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1938 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1939 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1940 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1941 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1942 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1943 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1944 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1945 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1946 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1947 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1948 "'>\n"
1949 " <!ENTITY e2 SYSTEM 'bar'>\n"
1950 "]>\n"
1951 "<doc>&e2;</doc>";
1952 char entity_text[] = "Hello world";
1953 int i;
1954 const int max_alloc_count = 40;
1955
1956 for (i = 0; i < max_alloc_count; i++) {
1957 g_allocation_count = i;
1958 XML_SetUserData(g_parser, entity_text);
1959 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1960 XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
1961 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
1962 != XML_STATUS_ERROR)
1963 break;
1964 /* See comment in test_alloc_parse_xdecl() */
1965 alloc_teardown();
1966 alloc_setup();
1967 }
1968 if (i == 0)
1969 fail("Parsing worked despite failing allocations");
1970 else if (i == max_alloc_count)
1971 fail("Parsing failed even at max allocation count");
1972}
1973END_TEST
1974
1975START_TEST(test_alloc_long_notation) {
1976 const char *text
1977 = "<!DOCTYPE doc [\n"
1978 " <!NOTATION note SYSTEM '"
1979 /* 64 characters per line */
1980 "ALongNotationNameThatShouldProvokeStringPoolGrowthWhileCallingAn"
1981 "ExternalEntityParserUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1982 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1983 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1984 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1985 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1986 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1987 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1988 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1989 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1990 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1991 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1992 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1993 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1994 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1995 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
1996 "'>\n"
1997 " <!ENTITY e1 SYSTEM 'foo' NDATA "
1998 /* 64 characters per line */
1999 "ALongNotationNameThatShouldProvokeStringPoolGrowthWhileCallingAn"
2000 "ExternalEntityParserUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2001 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2002 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2003 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2004 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2005 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2006 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2007 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2008 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2009 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2010 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2011 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2012 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2013 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2014 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
2015 ">\n"
2016 " <!ENTITY e2 SYSTEM 'bar'>\n"
2017 "]>\n"
2018 "<doc>&e2;</doc>";
2019 ExtOption options[]
2020 = {{XCS("foo"), "Entity Foo"}, {XCS("bar"), "Entity Bar"}, {NULL, NULL}};
2021 int i;
2022 const int max_alloc_count = 40;
2023
2024 for (i = 0; i < max_alloc_count; i++) {
2025 g_allocation_count = i;
2026 XML_SetUserData(g_parser, options);
2027 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2028 XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
2029 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2030 != XML_STATUS_ERROR)
2031 break;
2032
2033 /* See comment in test_alloc_parse_xdecl() */
2034 alloc_teardown();
2035 alloc_setup();
2036 }
2037 if (i == 0)
2038 fail("Parsing worked despite failing allocations");
2039 else if (i == max_alloc_count)
2040 fail("Parsing failed even at max allocation count");
2041}
2042END_TEST
2043
2044START_TEST(test_alloc_reset_after_external_entity_parser_create_fail) {
2045 const char *const text = "<!DOCTYPE doc SYSTEM 'foo'><doc/>";
2046
2047 XML_SetExternalEntityRefHandler(
2048 g_parser, external_entity_parser_create_alloc_fail_handler);
2049 XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
2050
2051 if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
2052 != XML_STATUS_ERROR)
2053 fail("Call to parse was expected to fail");
2054
2055 if (XML_GetErrorCode(g_parser) != XML_ERROR_EXTERNAL_ENTITY_HANDLING)
2056 fail("Call to parse was expected to fail from the external entity handler");
2057
2058 XML_ParserReset(g_parser, NULL);
2059}
2060END_TEST
2061
2062void
2063make_alloc_test_case(Suite *s) {
2064 TCase *tc_alloc = tcase_create("allocation tests");
2065
2066 suite_add_tcase(s, tc_alloc);
2067 tcase_add_checked_fixture(tc_alloc, alloc_setup, alloc_teardown);
2068
2069 tcase_add_test(tc_alloc, test_alloc_parse_xdecl);
2070 tcase_add_test(tc_alloc, test_alloc_parse_xdecl_2);
2071 tcase_add_test(tc_alloc, test_alloc_parse_pi);
2072 tcase_add_test(tc_alloc, test_alloc_parse_pi_2);
2073 tcase_add_test(tc_alloc, test_alloc_parse_pi_3);
2074 tcase_add_test(tc_alloc, test_alloc_parse_comment);
2075 tcase_add_test(tc_alloc, test_alloc_parse_comment_2);
2076 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_create_external_parser);
2077 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_run_external_parser);
2078 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_dtd_copy_default_atts);
2079 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_external_entity);
2080 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_ext_entity_set_encoding);
2081 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_internal_entity);
2082 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_dtd_default_handling);
2083 tcase_add_test(tc_alloc, test_alloc_explicit_encoding);
2084 tcase_add_test(tc_alloc, test_alloc_set_base);
2085 tcase_add_test(tc_alloc, test_alloc_realloc_buffer);
2086 tcase_add_test__if_xml_ge(tc_alloc, test_alloc_ext_entity_realloc_buffer);
2087 tcase_add_test(tc_alloc, test_alloc_realloc_many_attributes);
2088 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_public_entity_value);
2089 tcase_add_test__ifdef_xml_dtd(tc_alloc,
2090 test_alloc_realloc_subst_public_entity_value);
2091 tcase_add_test(tc_alloc, test_alloc_parse_public_doctype);
2092 tcase_add_test(tc_alloc, test_alloc_parse_public_doctype_long_name);
2093 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_set_foreign_dtd);
2094 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_attribute_enum_value);
2095 tcase_add_test__ifdef_xml_dtd(tc_alloc,
2096 test_alloc_realloc_attribute_enum_value);
2097 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_realloc_implied_attribute);
2098 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_realloc_default_attribute);
2099 tcase_add_test__if_xml_ge(tc_alloc, test_alloc_notation);
2100 tcase_add_test(tc_alloc, test_alloc_public_notation);
2101 tcase_add_test(tc_alloc, test_alloc_system_notation);
2102 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_nested_groups);
2103 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_realloc_nested_groups);
2104 tcase_add_test(tc_alloc, test_alloc_large_group);
2105 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_realloc_group_choice);
2106 tcase_add_test(tc_alloc, test_alloc_pi_in_epilog);
2107 tcase_add_test(tc_alloc, test_alloc_comment_in_epilog);
2108 tcase_add_test__ifdef_xml_dtd(tc_alloc,
2109 test_alloc_realloc_long_attribute_value);
2110 tcase_add_test(tc_alloc, test_alloc_attribute_whitespace);
2111 tcase_add_test(tc_alloc, test_alloc_attribute_predefined_entity);
2112 tcase_add_test(tc_alloc, test_alloc_long_attr_default_with_char_ref);
2113 tcase_add_test__if_xml_ge(tc_alloc, test_alloc_long_attr_value);
2114 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_nested_entities);
2115 tcase_add_test__ifdef_xml_dtd(tc_alloc,
2116 test_alloc_realloc_param_entity_newline);
2117 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_realloc_ce_extends_pe);
2118 tcase_add_test__ifdef_xml_dtd(tc_alloc, test_alloc_realloc_attributes);
2119 tcase_add_test(tc_alloc, test_alloc_long_doc_name);
2120 tcase_add_test__if_xml_ge(tc_alloc, test_alloc_long_base);
2121 tcase_add_test__if_xml_ge(tc_alloc, test_alloc_long_public_id);
2122 tcase_add_test__if_xml_ge(tc_alloc, test_alloc_long_entity_value);
2123 tcase_add_test__if_xml_ge(tc_alloc, test_alloc_long_notation);
2124
2125 tcase_add_test__ifdef_xml_dtd(
2126 tc_alloc, test_alloc_reset_after_external_entity_parser_create_fail);
2127}
test_alloc_create_external_parser
static void test_alloc_create_external_parser(void)
Definition alloc_tests.c:296
test_alloc_realloc_many_attributes
static void test_alloc_realloc_many_attributes(void)
Definition alloc_tests.c:606
test_alloc_nested_groups
static void test_alloc_nested_groups(void)
Definition alloc_tests.c:1242
test_alloc_nested_entities
static void test_alloc_nested_entities(void)
Definition alloc_tests.c:1625
alloc_teardown
static void alloc_teardown(void)
Definition alloc_tests.c:71
test_alloc_realloc_long_attribute_value
static void test_alloc_realloc_long_attribute_value(void)
Definition alloc_tests.c:1448
test_alloc_external_entity
static void test_alloc_external_entity(void)
Definition alloc_tests.c:363
test_alloc_set_foreign_dtd
static void test_alloc_set_foreign_dtd(void)
Definition alloc_tests.c:860
test_alloc_notation
static void test_alloc_notation(void)
Definition alloc_tests.c:1077
test_alloc_comment_in_epilog
static void test_alloc_comment_in_epilog(void)
Definition alloc_tests.c:1422
test_alloc_ext_entity_set_encoding
static void test_alloc_ext_entity_set_encoding(void)
Definition alloc_tests.c:398
test_alloc_set_base
static void test_alloc_set_base(void)
Definition alloc_tests.c:532
test_alloc_realloc_subst_public_entity_value
static void test_alloc_realloc_subst_public_entity_value(void)
Definition alloc_tests.c:704
test_alloc_ext_entity_realloc_buffer
static void test_alloc_ext_entity_realloc_buffer(void)
Definition alloc_tests.c:580
test_alloc_long_public_id
static void test_alloc_long_public_id(void)
Definition alloc_tests.c:1880
test_alloc_internal_entity
static void test_alloc_internal_entity(void)
Definition alloc_tests.c:428
test_alloc_dtd_copy_default_atts
static void test_alloc_dtd_copy_default_atts(void)
Definition alloc_tests.c:343
test_alloc_parse_pi
static void test_alloc_parse_pi(void)
Definition alloc_tests.c:150
test_alloc_parse_comment
static void test_alloc_parse_comment(void)
Definition alloc_tests.c:243
test_alloc_attribute_whitespace
static void test_alloc_attribute_whitespace(void)
Definition alloc_tests.c:1489
test_alloc_long_entity_value
static void test_alloc_long_entity_value(void)
Definition alloc_tests.c:1927
test_alloc_parse_public_doctype_long_name
static void test_alloc_parse_public_doctype_long_name(void)
Definition alloc_tests.c:815
test_alloc_attribute_enum_value
static void test_alloc_attribute_enum_value(void)
Definition alloc_tests.c:889
test_alloc_long_base
static void test_alloc_long_base(void)
Definition alloc_tests.c:1828
test_alloc_long_doc_name
static void test_alloc_long_doc_name(void)
Definition alloc_tests.c:1789
alloc_setup
static void alloc_setup(void)
Definition alloc_tests.c:59
make_alloc_test_case
void make_alloc_test_case(Suite *s)
Definition alloc_tests.c:2063
test_alloc_long_notation
static void test_alloc_long_notation(void)
Definition alloc_tests.c:1975
test_alloc_realloc_nested_groups
static void test_alloc_realloc_nested_groups(void)
Definition alloc_tests.c:1282
test_alloc_realloc_group_choice
static void test_alloc_realloc_group_choice(void)
Definition alloc_tests.c:1358
test_alloc_attribute_predefined_entity
static void test_alloc_attribute_predefined_entity(void)
Definition alloc_tests.c:1510
test_alloc_pi_in_epilog
static void test_alloc_pi_in_epilog(void)
Definition alloc_tests.c:1396
test_alloc_realloc_ce_extends_pe
static void test_alloc_realloc_ce_extends_pe(void)
Definition alloc_tests.c:1708
test_alloc_realloc_default_attribute
static void test_alloc_realloc_default_attribute(void)
Definition alloc_tests.c:1027
test_alloc_system_notation
static void test_alloc_system_notation(void)
Definition alloc_tests.c:1194
test_alloc_realloc_implied_attribute
static void test_alloc_realloc_implied_attribute(void)
Definition alloc_tests.c:977
test_alloc_run_external_parser
static void test_alloc_run_external_parser(void)
Definition alloc_tests.c:313
test_alloc_public_notation
static void test_alloc_public_notation(void)
Definition alloc_tests.c:1145
test_alloc_parse_xdecl
static void test_alloc_parse_xdecl(void)
Definition alloc_tests.c:76
test_alloc_explicit_encoding
static void test_alloc_explicit_encoding(void)
Definition alloc_tests.c:515
test_alloc_parse_comment_2
static void test_alloc_parse_comment_2(void)
Definition alloc_tests.c:267
test_alloc_parse_xdecl_2
static void test_alloc_parse_xdecl_2(void)
Definition alloc_tests.c:106
test_alloc_parse_pi_3
static void test_alloc_parse_pi_3(void)
Definition alloc_tests.c:202
test_alloc_reset_after_external_entity_parser_create_fail
static void test_alloc_reset_after_external_entity_parser_create_fail(void)
Definition alloc_tests.c:2044
test_alloc_realloc_attribute_enum_value
static void test_alloc_realloc_attribute_enum_value(void)
Definition alloc_tests.c:921
test_alloc_realloc_attributes
static void test_alloc_realloc_attributes(void)
Definition alloc_tests.c:1754
test_alloc_realloc_buffer
static void test_alloc_realloc_buffer(void)
Definition alloc_tests.c:550
test_alloc_long_attr_value
static void test_alloc_long_attr_value(void)
Definition alloc_tests.c:1579
test_alloc_realloc_param_entity_newline
static void test_alloc_realloc_param_entity_newline(void)
Definition alloc_tests.c:1662
test_alloc_dtd_default_handling
static void test_alloc_dtd_default_handling(void)
Definition alloc_tests.c:456
test_alloc_long_attr_default_with_char_ref
static void test_alloc_long_attr_default_with_char_ref(void)
Definition alloc_tests.c:1535
test_alloc_parse_public_doctype
static void test_alloc_parse_public_doctype(void)
Definition alloc_tests.c:766
test_alloc_parse_pi_2
static void test_alloc_parse_pi_2(void)
Definition alloc_tests.c:176
test_alloc_large_group
static void test_alloc_large_group(void)
Definition alloc_tests.c:1322
test_alloc_public_entity_value
static void test_alloc_public_entity_value(void)
Definition alloc_tests.c:651
alloc_tests.h
tcase_add_test__if_xml_ge
void tcase_add_test__if_xml_ge(TCase *tc, tcase_test_function test)
Definition common.c:159
tcase_add_test__ifdef_xml_dtd
void tcase_add_test__ifdef_xml_dtd(TCase *tc, tcase_test_function test)
Definition common.c:149
basic_teardown
void basic_teardown(void)
Definition common.c:169
g_reallocation_count
int g_reallocation_count
Definition common.c:276
_XML_Parse_SINGLE_BYTES
enum XML_Status _XML_Parse_SINGLE_BYTES(XML_Parser parser, const char *s, int len, int isFinal)
Definition common.c:193
REALLOC_ALWAYS_SUCCEED
#define REALLOC_ALWAYS_SUCCEED
Definition common.c:273
duff_reallocator
void * duff_reallocator(void *ptr, size_t size)
Definition common.c:290
get_buffer_test_text
const char * get_buffer_test_text
Definition common.c:112
g_allocation_count
int g_allocation_count
Definition common.c:275
duff_allocator
void * duff_allocator(size_t size)
Definition common.c:280
ALLOC_ALWAYS_SUCCEED
#define ALLOC_ALWAYS_SUCCEED
Definition common.c:272
CharData_Init
void CharData_Init(CharData *storage)
Definition chardata.c:61
CharData_CheckXMLChars
int CharData_CheckXMLChars(CharData *storage, const XML_Char *expected)
Definition chardata.c:87
XCS
#define XCS(s)
Definition common.h:77
g_parser
XML_Parser g_parser
Definition runtests.c:62
expect_failure
#define expect_failure(text, errorCode, errorMessage)
Definition common.h:108
xml_failure
#define xml_failure(parser)
Definition common.h:99
dummy_unparsed_entity_decl_handler
void XMLCALL dummy_unparsed_entity_decl_handler(void *userData, const XML_Char *entityName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName)
Definition dummy.c:215
dummy_element_decl_handler
void XMLCALL dummy_element_decl_handler(void *userData, const XML_Char *name, XML_Content *model)
Definition dummy.c:121
dummy_comment_handler
void XMLCALL dummy_comment_handler(void *userData, const XML_Char *data)
Definition dummy.c:147
dummy_end_doctype_handler
void XMLCALL dummy_end_doctype_handler(void *userData)
Definition dummy.c:85
dummy_start_cdata_handler
void XMLCALL dummy_start_cdata_handler(void *userData)
Definition dummy.c:177
dummy_start_doctype_decl_handler
void XMLCALL dummy_start_doctype_decl_handler(void *userData, const XML_Char *doctypeName, const XML_Char *sysid, const XML_Char *pubid, int has_internal_subset)
Definition dummy.c:237
dummy_attlist_decl_handler
void XMLCALL dummy_attlist_decl_handler(void *userData, const XML_Char *elname, const XML_Char *attname, const XML_Char *att_type, const XML_Char *dflt, int isrequired)
Definition dummy.c:134
dummy_end_doctype_decl_handler
void XMLCALL dummy_end_doctype_decl_handler(void *userData)
Definition dummy.c:249
dummy_start_doctype_handler
void XMLCALL dummy_start_doctype_handler(void *userData, const XML_Char *doctypeName, const XML_Char *sysid, const XML_Char *pubid, int has_internal_subset)
Definition dummy.c:73
dummy_end_cdata_handler
void XMLCALL dummy_end_cdata_handler(void *userData)
Definition dummy.c:183
dummy_pi_handler
void XMLCALL dummy_pi_handler(void *userData, const XML_Char *target, const XML_Char *data)
Definition dummy.c:154
dummy_entity_decl_handler
void XMLCALL dummy_entity_decl_handler(void *userData, const XML_Char *entityName, int is_parameter_entity, const XML_Char *value, int value_length, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName)
Definition dummy.c:91
dummy_xdecl_handler
void XMLCALL dummy_xdecl_handler(void *userData, const XML_Char *version, const XML_Char *encoding, int standalone)
Definition dummy.c:64
dummy_notation_decl_handler
void XMLCALL dummy_notation_decl_handler(void *userData, const XML_Char *notationName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition dummy.c:109
init_dummy_handlers
void init_dummy_handlers(void)
Definition dummy.c:54
get_dummy_handler_flags
unsigned long get_dummy_handler_flags(void)
Definition dummy.c:59
DUMMY_ELEMENT_DECL_HANDLER_FLAG
#define DUMMY_ELEMENT_DECL_HANDLER_FLAG
Definition dummy.h:54
DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG
#define DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG
Definition dummy.h:64
DUMMY_ENTITY_DECL_HANDLER_FLAG
#define DUMMY_ENTITY_DECL_HANDLER_FLAG
Definition dummy.h:52
DUMMY_UNPARSED_ENTITY_DECL_HANDLER_FLAG
#define DUMMY_UNPARSED_ENTITY_DECL_HANDLER_FLAG
Definition dummy.h:61
DUMMY_START_DOCTYPE_HANDLER_FLAG
#define DUMMY_START_DOCTYPE_HANDLER_FLAG
Definition dummy.h:50
DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG
#define DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG
Definition dummy.h:65
DUMMY_COMMENT_HANDLER_FLAG
#define DUMMY_COMMENT_HANDLER_FLAG
Definition dummy.h:56
DUMMY_START_CDATA_HANDLER_FLAG
#define DUMMY_START_CDATA_HANDLER_FLAG
Definition dummy.h:59
DUMMY_NOTATION_DECL_HANDLER_FLAG
#define DUMMY_NOTATION_DECL_HANDLER_FLAG
Definition dummy.h:53
DUMMY_END_DOCTYPE_HANDLER_FLAG
#define DUMMY_END_DOCTYPE_HANDLER_FLAG
Definition dummy.h:51
DUMMY_PI_HANDLER_FLAG
#define DUMMY_PI_HANDLER_FLAG
Definition dummy.h:57
DUMMY_END_CDATA_HANDLER_FLAG
#define DUMMY_END_CDATA_HANDLER_FLAG
Definition dummy.h:60
DUMMY_ATTLIST_DECL_HANDLER_FLAG
#define DUMMY_ATTLIST_DECL_HANDLER_FLAG
Definition dummy.h:55
XML_FALSE
#define XML_FALSE
Definition expat.h:59
XML_STATUS_ERROR
#define XML_STATUS_ERROR
Definition expat.h:76
XML_SetCdataSectionHandler
void XML_SetCdataSectionHandler(XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end)
Definition xmlparse.c:1732
XML_SetEncoding
enum XML_Status XML_SetEncoding(XML_Parser parser, const XML_Char *encoding)
Definition xmlparse.c:1327
XML_SetStartElementHandler
void XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler handler)
Definition xmlparse.c:1700
XML_SetCommentHandler
void XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler)
Definition xmlparse.c:1726
XML_SetElementDeclHandler
void XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl)
Definition xmlparse.c:1871
XML_SetCharacterDataHandler
void XML_SetCharacterDataHandler(XML_Parser parser, XML_CharacterDataHandler handler)
Definition xmlparse.c:1712
XML_ParserReset
XML_Bool XML_ParserReset(XML_Parser parser, const XML_Char *encoding)
Definition xmlparse.c:1286
XML_ERROR_EXTERNAL_ENTITY_HANDLING
@ XML_ERROR_EXTERNAL_ENTITY_HANDLING
Definition expat.h:105
XML_ERROR_NO_MEMORY
@ XML_ERROR_NO_MEMORY
Definition expat.h:85
XML_ERROR_NONE
@ XML_ERROR_NONE
Definition expat.h:84
XML_SetEntityDeclHandler
void XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler)
Definition xmlparse.c:1883
XML_SetUnknownEncodingHandler
void XML_SetUnknownEncodingHandler(XML_Parser parser, XML_UnknownEncodingHandler handler, void *encodingHandlerData)
Definition xmlparse.c:1862
XML_GetErrorCode
enum XML_Error XML_GetErrorCode(XML_Parser parser)
Definition xmlparse.c:2318
XML_PARAM_ENTITY_PARSING_ALWAYS
@ XML_PARAM_ENTITY_PARSING_ALWAYS
Definition expat.h:883
XML_SetDoctypeDeclHandler
void XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start, XML_EndDoctypeDeclHandler end)
Definition xmlparse.c:1772
XML_SetDefaultHandler
void XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler)
Definition xmlparse.c:1756
XML_SetNotationDeclHandler
void XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler)
Definition xmlparse.c:1801
XML_SetUserData
void XML_SetUserData(XML_Parser parser, void *userData)
Definition xmlparse.c:1637
XML_STATUS_OK
#define XML_STATUS_OK
Definition expat.h:78
XML_SetBase
enum XML_Status XML_SetBase(XML_Parser parser, const XML_Char *base)
Definition xmlparse.c:1647
XML_UseForeignDTD
enum XML_Error XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)
Definition xmlparse.c:1609
XML_SetProcessingInstructionHandler
void XML_SetProcessingInstructionHandler(XML_Parser parser, XML_ProcessingInstructionHandler handler)
Definition xmlparse.c:1719
XML_ParseBuffer
enum XML_Status XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
Definition xmlparse.c:2037
XML_SetExternalEntityRefHandler
void XML_SetExternalEntityRefHandler(XML_Parser parser, XML_ExternalEntityRefHandler handler)
Definition xmlparse.c:1838
XML_SetXmlDeclHandler
void XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler xmldecl)
Definition xmlparse.c:1889
XML_GetBuffer
void * XML_GetBuffer(XML_Parser parser, int len)
Definition xmlparse.c:2108
XML_ParserCreate_MM
XML_Parser XML_ParserCreate_MM(const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite, const XML_Char *namespaceSeparator)
Definition xmlparse.c:1058
XML_SetUnparsedEntityDeclHandler
void XML_SetUnparsedEntityDeclHandler(XML_Parser parser, XML_UnparsedEntityDeclHandler handler)
Definition xmlparse.c:1794
XML_TRUE
#define XML_TRUE
Definition expat.h:58
XML_SetParamEntityParsing
int XML_SetParamEntityParsing(XML_Parser parser, enum XML_ParamEntityParsing parsing)
Definition xmlparse.c:1895
XML_SetAttlistDeclHandler
void XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl)
Definition xmlparse.c:1877
XML_Char
char XML_Char
Definition expat_external.h:149
base
ap_conf_vector_t * base
Definition http_config.h:1125
text
apr_text_header const char * text
Definition apr_xml.h:78
size
apr_size_t size
Definition apr_allocator.h:115
buffer
char * buffer
Definition apr_file_io.h:667
s
const char * s
Definition apr_strings.h:95
accumulate_characters
void XMLCALL accumulate_characters(void *userData, const XML_Char *s, int len)
Definition handlers.c:1910
external_entity_optioner
int XMLCALL external_entity_optioner(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:413
external_entity_duff_loader
int XMLCALL external_entity_duff_loader(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:1267
record_element_start_handler
void XMLCALL record_element_start_handler(void *userData, const XML_Char *name, const XML_Char **atts)
Definition handlers.c:1705
long_encoding_handler
int XMLCALL long_encoding_handler(void *userData, const XML_Char *encoding, XML_Encoding *info)
Definition handlers.c:396
external_entity_reallocator
int XMLCALL external_entity_reallocator(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:1423
external_entity_alloc
int XMLCALL external_entity_alloc(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:1451
external_entity_public
int XMLCALL external_entity_public(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:1073
external_entity_alloc_set_encoding
int XMLCALL external_entity_alloc_set_encoding(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:1394
external_entity_dbl_handler_2
int XMLCALL external_entity_dbl_handler_2(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:1356
external_entity_parser_create_alloc_fail_handler
int XMLCALL external_entity_parser_create_alloc_fail_handler(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:1471
external_entity_null_loader
int XMLCALL external_entity_null_loader(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:494
unknown_released_encoding_handler
int XMLCALL unknown_released_encoding_handler(void *data, const XML_Char *encoding, XML_Encoding *info)
Definition handlers.c:314
external_entity_faulter
int XMLCALL external_entity_faulter(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:466
external_entity_dbl_handler
int XMLCALL external_entity_dbl_handler(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
Definition handlers.c:1299
tcase_add_test
void tcase_add_test(TCase *tc, tcase_test_function test)
Definition minicheck.c:92
suite_add_tcase
void suite_add_tcase(Suite *suite, TCase *tc)
Definition minicheck.c:74
tcase_add_checked_fixture
void tcase_add_checked_fixture(TCase *tc, tcase_setup_function setup, tcase_teardown_function teardown)
Definition minicheck.c:84
tcase_create
TCase * tcase_create(const char *name)
Definition minicheck.c:65
fail
#define fail(msg)
Definition minicheck.h:87
END_TEST
#define END_TEST
Definition minicheck.h:81
START_TEST
#define START_TEST(testname)
Definition minicheck.h:77
storage
static const ap_slotmem_provider_t * storage
Definition mod_heartmonitor.c:40
NULL
return NULL
Definition mod_so.c:359
i
int i
Definition mod_so.c:347
XML_Memory_Handling_Suite
Definition expat.h:226
ext_faults
Definition handlers.h:181
Generated by doxygen 1.9.8