1 /*
2 * testrecurse.c: C program to run libxml2 regression tests checking entities
3 * recursions
4 *
5 * To compile on Unixes:
6 * cc -o testrecurse `xml2-config --cflags` testrecurse.c `xml2-config --libs` -lpthread
7 *
8 * See Copyright for the status of this software.
9 *
10 * [email protected]
11 */
12
13 #include "config.h"
14 #include <stdio.h>
15
16 #include <stdlib.h>
17 #include <string.h>
18 #include <sys/stat.h>
19
20 #include <libxml/parser.h>
21 #include <libxml/parserInternals.h>
22 #include <libxml/tree.h>
23 #include <libxml/uri.h>
24
25 /*
26 * O_BINARY is just for Windows compatibility - if it isn't defined
27 * on this system, avoid any compilation error
28 */
29 #ifdef O_BINARY
30 #define RD_FLAGS O_RDONLY | O_BINARY
31 #else
32 #define RD_FLAGS O_RDONLY
33 #endif
34
35 #define OPT_SAX (1<<0)
36 #define OPT_NO_SUBST (1<<1)
37
38 typedef int (*functest) (const char *filename, const char *result,
39 const char *error, int options);
40
41 typedef struct testDesc testDesc;
42 typedef testDesc *testDescPtr;
43 struct testDesc {
44 const char *desc; /* description of the test */
45 functest func; /* function implementing the test */
46 const char *in; /* glob to path for input files */
47 const char *out; /* output directory */
48 const char *suffix;/* suffix for output files */
49 const char *err; /* suffix for error output files */
50 int options; /* parser options for the test */
51 };
52
53 static int checkTestFile(const char *filename);
54
55
56 #if defined(_WIN32)
57
58 #include <windows.h>
59
60 typedef struct
61 {
62 size_t gl_pathc; /* Count of paths matched so far */
63 char **gl_pathv; /* List of matched pathnames. */
64 size_t gl_offs; /* Slots to reserve in 'gl_pathv'. */
65 } glob_t;
66
67 #define GLOB_DOOFFS 0
glob(const char * pattern,ATTRIBUTE_UNUSED int flags,ATTRIBUTE_UNUSED int errfunc (const char * epath,int eerrno),glob_t * pglob)68 static int glob(const char *pattern, ATTRIBUTE_UNUSED int flags,
69 ATTRIBUTE_UNUSED int errfunc(const char *epath, int eerrno),
70 glob_t *pglob) {
71 glob_t *ret;
72 WIN32_FIND_DATA FindFileData;
73 HANDLE hFind;
74 unsigned int nb_paths = 0;
75 char directory[500];
76 int len;
77
78 if ((pattern == NULL) || (pglob == NULL)) return(-1);
79
80 strncpy(directory, pattern, 499);
81 for (len = strlen(directory);len >= 0;len--) {
82 if (directory[len] == '/') {
83 len++;
84 directory[len] = 0;
85 break;
86 }
87 }
88 if (len <= 0)
89 len = 0;
90
91
92 ret = pglob;
93 memset(ret, 0, sizeof(glob_t));
94
95 hFind = FindFirstFileA(pattern, &FindFileData);
96 if (hFind == INVALID_HANDLE_VALUE)
97 return(0);
98 nb_paths = 20;
99 ret->gl_pathv = (char **) malloc(nb_paths * sizeof(char *));
100 if (ret->gl_pathv == NULL) {
101 FindClose(hFind);
102 return(-1);
103 }
104 strncpy(directory + len, FindFileData.cFileName, 499 - len);
105 ret->gl_pathv[ret->gl_pathc] = strdup(directory);
106 if (ret->gl_pathv[ret->gl_pathc] == NULL)
107 goto done;
108 ret->gl_pathc++;
109 while(FindNextFileA(hFind, &FindFileData)) {
110 if (FindFileData.cFileName[0] == '.')
111 continue;
112 if (ret->gl_pathc + 2 > nb_paths) {
113 char **tmp = realloc(ret->gl_pathv, nb_paths * 2 * sizeof(char *));
114 if (tmp == NULL)
115 break;
116 ret->gl_pathv = tmp;
117 nb_paths *= 2;
118 }
119 strncpy(directory + len, FindFileData.cFileName, 499 - len);
120 ret->gl_pathv[ret->gl_pathc] = strdup(directory);
121 if (ret->gl_pathv[ret->gl_pathc] == NULL)
122 break;
123 ret->gl_pathc++;
124 }
125 ret->gl_pathv[ret->gl_pathc] = NULL;
126
127 done:
128 FindClose(hFind);
129 return(0);
130 }
131
132
133
globfree(glob_t * pglob)134 static void globfree(glob_t *pglob) {
135 unsigned int i;
136 if (pglob == NULL)
137 return;
138
139 for (i = 0;i < pglob->gl_pathc;i++) {
140 if (pglob->gl_pathv[i] != NULL)
141 free(pglob->gl_pathv[i]);
142 }
143 }
144
145 #else
146 #include <glob.h>
147 #endif
148
149 /************************************************************************
150 * *
151 * Huge document generator *
152 * *
153 ************************************************************************/
154
155 #include <libxml/xmlIO.h>
156
157 typedef struct {
158 const char *URL;
159 const char *start;
160 const char *segment;
161 const char *finish;
162 } xmlHugeDocParts;
163
164 static const xmlHugeDocParts hugeDocTable[] = {
165 {
166 "test/recurse/huge.xml",
167
168 "<!DOCTYPE foo ["
169 "<!ELEMENT foo (bar*)> "
170 "<!ELEMENT bar (#PCDATA)> "
171 "<!ATTLIST bar attr CDATA #IMPLIED> "
172 "<!ENTITY a SYSTEM 'ga.ent'> "
173 "<!ENTITY b SYSTEM 'gb.ent'> "
174 "<!ENTITY c SYSTEM 'gc.ent'> "
175 "<!ENTITY f 'some internal data'> "
176 "<!ENTITY e '&f;&f;'> "
177 "<!ENTITY d '&e;&e;'> "
178 "]> "
179 "<foo>",
180
181 " <bar attr='&e; &f; &d;'>&a; &b; &c; &e; &f; &d;</bar>\n"
182 " <bar>_123456789_123456789_123456789_123456789</bar>\n"
183 " <bar>_123456789_123456789_123456789_123456789</bar>\n"
184 " <bar>_123456789_123456789_123456789_123456789</bar>\n"
185 " <bar>_123456789_123456789_123456789_123456789</bar>\n",
186
187 "</foo>"
188 },
189 {
190 "test/recurse/huge_dtd.dtd",
191
192 "<!ELEMENT foo (#PCDATA)>\n"
193 "<!ENTITY ent 'success'>\n"
194 "<!ENTITY % a SYSTEM 'pa.ent'>\n"
195 "<!ENTITY % b SYSTEM 'pb.ent'>\n"
196 "<!ENTITY % c SYSTEM 'pc.ent'>\n"
197 "<!ENTITY % d '<!-- comment -->'>\n"
198 "<!ENTITY % e '%d;%d;'>\n"
199 "<!ENTITY % f '%e;%e;'>\n",
200
201 "<!ENTITY ent '%a; %b; %c; %d; %e; %f;'>\n"
202 "%a; %b; %c; %d; %e; %f;\n"
203 "<!-- _123456789_123456789_123456789_123456789 -->\n"
204 "<!-- _123456789_123456789_123456789_123456789 -->\n"
205 "<!-- _123456789_123456789_123456789_123456789 -->\n",
206
207 ""
208 },
209 { NULL, NULL, NULL, NULL }
210 };
211
212 static const xmlHugeDocParts *hugeDocParts;
213 static int curseg = 0;
214 static const char *current;
215 static int rlen;
216
217 /**
218 * hugeMatch:
219 * @URI: an URI to test
220 *
221 * Check for a huge query
222 *
223 * Returns 1 if yes and 0 if another Input module should be used
224 */
225 static int
hugeMatch(const char * URI)226 hugeMatch(const char * URI) {
227 int i;
228
229 if (URI == NULL)
230 return(0);
231
232 for (i = 0; hugeDocTable[i].URL; i++) {
233 if (strcmp(URI, hugeDocTable[i].URL) == 0)
234 return(1);
235 }
236
237 return(0);
238 }
239
240 /**
241 * hugeOpen:
242 * @URI: an URI to test
243 *
244 * Return a pointer to the huge query handler, in this example simply
245 * the current pointer...
246 *
247 * Returns an Input context or NULL in case or error
248 */
249 static void *
hugeOpen(const char * URI)250 hugeOpen(const char * URI) {
251 int i;
252
253 if (URI == NULL)
254 return(NULL);
255
256 for (i = 0; hugeDocTable[i].URL; i++) {
257 if (strcmp(URI, hugeDocTable[i].URL) == 0) {
258 hugeDocParts = hugeDocTable + i;
259 curseg = 0;
260 current = hugeDocParts->start;
261 rlen = strlen(current);
262 return((void *) current);
263 }
264 }
265
266 return(NULL);
267 }
268
269 /**
270 * hugeClose:
271 * @context: the read context
272 *
273 * Close the huge query handler
274 *
275 * Returns 0 or -1 in case of error
276 */
277 static int
hugeClose(void * context)278 hugeClose(void * context) {
279 if (context == NULL) return(-1);
280 return(0);
281 }
282
283 #define MAX_NODES 1000
284
285 /**
286 * hugeRead:
287 * @context: the read context
288 * @buffer: where to store data
289 * @len: number of bytes to read
290 *
291 * Implement an huge query read.
292 *
293 * Returns the number of bytes read or -1 in case of error
294 */
295 static int
hugeRead(void * context,char * buffer,int len)296 hugeRead(void *context, char *buffer, int len)
297 {
298 if ((context == NULL) || (buffer == NULL) || (len < 0))
299 return (-1);
300
301 if (len >= rlen) {
302 if (curseg >= MAX_NODES + 1) {
303 rlen = 0;
304 return(0);
305 }
306 len = rlen;
307 rlen = 0;
308 memcpy(buffer, current, len);
309 curseg ++;
310 if (curseg == MAX_NODES) {
311 current = hugeDocParts->finish;
312 } else {
313 current = hugeDocParts->segment;
314 }
315 rlen = strlen(current);
316 } else {
317 memcpy(buffer, current, len);
318 rlen -= len;
319 current += len;
320 }
321 return (len);
322 }
323
324 /************************************************************************
325 * *
326 * Libxml2 specific routines *
327 * *
328 ************************************************************************/
329
330 static int nb_tests = 0;
331 static int nb_errors = 0;
332 static int nb_leaks = 0;
333 static int extraMemoryFromResolver = 0;
334
335 static int
fatalError(void)336 fatalError(void) {
337 fprintf(stderr, "Exitting tests on fatal error\n");
338 exit(1);
339 }
340
341 /*
342 * We need to trap calls to the resolver to not account memory for the catalog
343 * which is shared to the current running test. We also don't want to have
344 * network downloads modifying tests.
345 */
346 static xmlParserInputPtr
testExternalEntityLoader(const char * URL,const char * ID,xmlParserCtxtPtr ctxt)347 testExternalEntityLoader(const char *URL, const char *ID,
348 xmlParserCtxtPtr ctxt) {
349 xmlParserInputPtr ret;
350
351 if (checkTestFile(URL)) {
352 ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
353 } else {
354 int memused = xmlMemUsed();
355 ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
356 extraMemoryFromResolver += xmlMemUsed() - memused;
357 }
358
359 return(ret);
360 }
361
362 static void
initializeLibxml2(void)363 initializeLibxml2(void) {
364 xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
365 xmlInitParser();
366 xmlSetExternalEntityLoader(testExternalEntityLoader);
367 /*
368 * register the new I/O handlers
369 */
370 if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen,
371 hugeRead, hugeClose) < 0) {
372 fprintf(stderr, "failed to register Huge handler\n");
373 exit(1);
374 }
375 }
376
377 static void
initSAX(xmlParserCtxtPtr ctxt)378 initSAX(xmlParserCtxtPtr ctxt) {
379 ctxt->sax->startElementNs = NULL;
380 ctxt->sax->endElementNs = NULL;
381 ctxt->sax->startElement = NULL;
382 ctxt->sax->endElement = NULL;
383 ctxt->sax->characters = NULL;
384 ctxt->sax->cdataBlock = NULL;
385 ctxt->sax->ignorableWhitespace = NULL;
386 ctxt->sax->processingInstruction = NULL;
387 ctxt->sax->comment = NULL;
388 }
389
390 /************************************************************************
391 * *
392 * File name and path utilities *
393 * *
394 ************************************************************************/
395
baseFilename(const char * filename)396 static const char *baseFilename(const char *filename) {
397 const char *cur;
398 if (filename == NULL)
399 return(NULL);
400 cur = &filename[strlen(filename)];
401 while ((cur > filename) && (*cur != '/'))
402 cur--;
403 if (*cur == '/')
404 return(cur + 1);
405 return(cur);
406 }
407
resultFilename(const char * filename,const char * out,const char * suffix)408 static char *resultFilename(const char *filename, const char *out,
409 const char *suffix) {
410 const char *base;
411 char res[500];
412 char suffixbuff[500];
413
414 /*************
415 if ((filename[0] == 't') && (filename[1] == 'e') &&
416 (filename[2] == 's') && (filename[3] == 't') &&
417 (filename[4] == '/'))
418 filename = &filename[5];
419 *************/
420
421 base = baseFilename(filename);
422 if (suffix == NULL)
423 suffix = ".tmp";
424 if (out == NULL)
425 out = "";
426
427 strncpy(suffixbuff,suffix,499);
428
429 if (snprintf(res, 499, "%s%s%s", out, base, suffixbuff) >= 499)
430 res[499] = 0;
431 return(strdup(res));
432 }
433
checkTestFile(const char * filename)434 static int checkTestFile(const char *filename) {
435 struct stat buf;
436
437 if (stat(filename, &buf) == -1)
438 return(0);
439
440 #if defined(_WIN32)
441 if (!(buf.st_mode & _S_IFREG))
442 return(0);
443 #else
444 if (!S_ISREG(buf.st_mode))
445 return(0);
446 #endif
447
448 return(1);
449 }
450
451
452
453 /************************************************************************
454 * *
455 * Test to detect or not recursive entities *
456 * *
457 ************************************************************************/
458 /**
459 * recursiveDetectTest:
460 * @filename: the file to parse
461 * @result: the file with expected result
462 * @err: the file with error messages: unused
463 *
464 * Parse a file loading DTD and replacing entities check it fails for
465 * lol cases
466 *
467 * Returns 0 in case of success, an error code otherwise
468 */
469 static int
recursiveDetectTest(const char * filename,const char * result ATTRIBUTE_UNUSED,const char * err ATTRIBUTE_UNUSED,int options)470 recursiveDetectTest(const char *filename,
471 const char *result ATTRIBUTE_UNUSED,
472 const char *err ATTRIBUTE_UNUSED,
473 int options) {
474 xmlDocPtr doc;
475 xmlParserCtxtPtr ctxt;
476 int res = 0;
477 /*
478 * XML_PARSE_DTDVALID is the only way to load external entities
479 * without XML_PARSE_NOENT. The validation result doesn't matter
480 * anyway.
481 */
482 int parserOptions = XML_PARSE_DTDVALID | XML_PARSE_NOERROR;
483
484 nb_tests++;
485
486 ctxt = xmlNewParserCtxt();
487 if (options & OPT_SAX)
488 initSAX(ctxt);
489 if ((options & OPT_NO_SUBST) == 0)
490 parserOptions |= XML_PARSE_NOENT;
491 /*
492 * base of the test, parse with the old API
493 */
494 doc = xmlCtxtReadFile(ctxt, filename, NULL, parserOptions);
495 if ((doc != NULL) || (ctxt->lastError.code != XML_ERR_RESOURCE_LIMIT)) {
496 fprintf(stderr, "Failed to detect recursion in %s\n", filename);
497 xmlFreeParserCtxt(ctxt);
498 xmlFreeDoc(doc);
499 return(1);
500 }
501 xmlFreeParserCtxt(ctxt);
502
503 return(res);
504 }
505
506 /**
507 * notRecursiveDetectTest:
508 * @filename: the file to parse
509 * @result: the file with expected result
510 * @err: the file with error messages: unused
511 *
512 * Parse a file loading DTD and replacing entities check it works for
513 * good cases
514 *
515 * Returns 0 in case of success, an error code otherwise
516 */
517 static int
notRecursiveDetectTest(const char * filename,const char * result ATTRIBUTE_UNUSED,const char * err ATTRIBUTE_UNUSED,int options)518 notRecursiveDetectTest(const char *filename,
519 const char *result ATTRIBUTE_UNUSED,
520 const char *err ATTRIBUTE_UNUSED,
521 int options) {
522 xmlDocPtr doc;
523 xmlParserCtxtPtr ctxt;
524 int res = 0;
525 int parserOptions = XML_PARSE_DTDLOAD;
526
527 nb_tests++;
528
529 ctxt = xmlNewParserCtxt();
530 if (options & OPT_SAX)
531 initSAX(ctxt);
532 if ((options & OPT_NO_SUBST) == 0)
533 parserOptions |= XML_PARSE_NOENT;
534 /*
535 * base of the test, parse with the old API
536 */
537 doc = xmlCtxtReadFile(ctxt, filename, NULL, parserOptions);
538 if (doc == NULL) {
539 fprintf(stderr, "Failed to parse correct file %s\n", filename);
540 xmlFreeParserCtxt(ctxt);
541 return(1);
542 }
543 xmlFreeDoc(doc);
544 xmlFreeParserCtxt(ctxt);
545
546 return(res);
547 }
548
549 /**
550 * notRecursiveHugeTest:
551 * @filename: the file to parse
552 * @result: the file with expected result
553 * @err: the file with error messages: unused
554 *
555 * Parse a memory generated file
556 * good cases
557 *
558 * Returns 0 in case of success, an error code otherwise
559 */
560 static int
notRecursiveHugeTest(const char * filename ATTRIBUTE_UNUSED,const char * result ATTRIBUTE_UNUSED,const char * err ATTRIBUTE_UNUSED,int options)561 notRecursiveHugeTest(const char *filename ATTRIBUTE_UNUSED,
562 const char *result ATTRIBUTE_UNUSED,
563 const char *err ATTRIBUTE_UNUSED,
564 int options) {
565 xmlParserCtxtPtr ctxt;
566 xmlDocPtr doc;
567 int res = 0;
568 int parserOptions = XML_PARSE_DTDVALID;
569
570 nb_tests++;
571
572 ctxt = xmlNewParserCtxt();
573 if (options & OPT_SAX)
574 initSAX(ctxt);
575 if ((options & OPT_NO_SUBST) == 0)
576 parserOptions |= XML_PARSE_NOENT;
577 doc = xmlCtxtReadFile(ctxt, "test/recurse/huge.xml", NULL, parserOptions);
578 if (doc == NULL) {
579 fprintf(stderr, "Failed to parse huge.xml\n");
580 res = 1;
581 } else {
582 xmlEntityPtr ent;
583 unsigned long fixed_cost = 20;
584 unsigned long allowed_expansion = 1000000;
585 unsigned long f_size = xmlStrlen(BAD_CAST "some internal data");
586 unsigned long e_size;
587 unsigned long d_size;
588 unsigned long total_size;
589
590 ent = xmlGetDocEntity(doc, BAD_CAST "e");
591 e_size = f_size * 2 +
592 xmlStrlen(BAD_CAST "&f;") * 2 +
593 fixed_cost * 2;
594 if (ent->expandedSize != e_size) {
595 fprintf(stderr, "Wrong size for entity e: %lu (expected %lu)\n",
596 ent->expandedSize, e_size);
597 res = 1;
598 }
599
600 ent = xmlGetDocEntity(doc, BAD_CAST "b");
601 if (ent->expandedSize != e_size) {
602 fprintf(stderr, "Wrong size for entity b: %lu (expected %lu)\n",
603 ent->expandedSize, e_size);
604 res = 1;
605 }
606
607 ent = xmlGetDocEntity(doc, BAD_CAST "d");
608 d_size = e_size * 2 +
609 xmlStrlen(BAD_CAST "&e;") * 2 +
610 fixed_cost * 2;
611 if (ent->expandedSize != d_size) {
612 fprintf(stderr, "Wrong size for entity d: %lu (expected %lu)\n",
613 ent->expandedSize, d_size);
614 res = 1;
615 }
616
617 ent = xmlGetDocEntity(doc, BAD_CAST "c");
618 if (ent->expandedSize != d_size) {
619 fprintf(stderr, "Wrong size for entity c: %lu (expected %lu)\n",
620 ent->expandedSize, d_size);
621 res = 1;
622 }
623
624 if (ctxt->sizeentcopy < allowed_expansion) {
625 fprintf(stderr, "Total entity size too small: %lu\n",
626 ctxt->sizeentcopy);
627 res = 1;
628 }
629
630 total_size = (f_size + e_size + d_size + 3 * fixed_cost) *
631 (MAX_NODES - 1) * 3;
632 if (ctxt->sizeentcopy != total_size) {
633 fprintf(stderr, "Wrong total entity size: %lu (expected %lu)\n",
634 ctxt->sizeentcopy, total_size);
635 res = 1;
636 }
637
638 if (ctxt->sizeentities != 30) {
639 fprintf(stderr, "Wrong parsed entity size: %lu (expected %lu)\n",
640 ctxt->sizeentities, 30lu);
641 res = 1;
642 }
643 }
644
645 xmlFreeDoc(doc);
646 xmlFreeParserCtxt(ctxt);
647
648 return(res);
649 }
650
651 /**
652 * notRecursiveHugeTest:
653 * @filename: the file to parse
654 * @result: the file with expected result
655 * @err: the file with error messages: unused
656 *
657 * Parse a memory generated file
658 * good cases
659 *
660 * Returns 0 in case of success, an error code otherwise
661 */
662 static int
hugeDtdTest(const char * filename ATTRIBUTE_UNUSED,const char * result ATTRIBUTE_UNUSED,const char * err ATTRIBUTE_UNUSED,int options)663 hugeDtdTest(const char *filename ATTRIBUTE_UNUSED,
664 const char *result ATTRIBUTE_UNUSED,
665 const char *err ATTRIBUTE_UNUSED,
666 int options) {
667 xmlParserCtxtPtr ctxt;
668 xmlDocPtr doc;
669 int res = 0;
670 int parserOptions = XML_PARSE_DTDVALID;
671
672 nb_tests++;
673
674 ctxt = xmlNewParserCtxt();
675 if (options & OPT_SAX)
676 initSAX(ctxt);
677 if ((options & OPT_NO_SUBST) == 0)
678 parserOptions |= XML_PARSE_NOENT;
679 doc = xmlCtxtReadFile(ctxt, "test/recurse/huge_dtd.xml", NULL,
680 parserOptions);
681 if (doc == NULL) {
682 fprintf(stderr, "Failed to parse huge_dtd.xml\n");
683 res = 1;
684 } else {
685 unsigned long fixed_cost = 20;
686 unsigned long allowed_expansion = 1000000;
687 unsigned long a_size = xmlStrlen(BAD_CAST "<!-- comment -->");
688 unsigned long b_size;
689 unsigned long c_size;
690 unsigned long e_size;
691 unsigned long f_size;
692 unsigned long total_size;
693
694 if (ctxt->sizeentcopy < allowed_expansion) {
695 fprintf(stderr, "Total entity size too small: %lu\n",
696 ctxt->sizeentcopy);
697 res = 1;
698 }
699
700 b_size = (a_size + strlen("&a;") + fixed_cost) * 2;
701 c_size = (b_size + strlen("&b;") + fixed_cost) * 2;
702 /*
703 * Internal parameter entites are substitued eagerly and
704 * need different accounting.
705 */
706 e_size = a_size * 2;
707 f_size = e_size * 2;
708 total_size = /* internal */
709 e_size + f_size + fixed_cost * 4 +
710 (a_size + e_size + f_size + fixed_cost * 3) *
711 (MAX_NODES - 1) * 2 +
712 /* external */
713 (a_size + b_size + c_size + fixed_cost * 3) *
714 (MAX_NODES - 1) * 2 +
715 /* final reference in main doc */
716 strlen("success") + fixed_cost;
717 if (ctxt->sizeentcopy != total_size) {
718 fprintf(stderr, "Wrong total entity size: %lu (expected %lu)\n",
719 ctxt->sizeentcopy, total_size);
720 res = 1;
721 }
722
723 total_size = strlen(hugeDocParts->start) +
724 strlen(hugeDocParts->segment) * (MAX_NODES - 1) +
725 strlen(hugeDocParts->finish) +
726 /*
727 * Other external entities pa.ent, pb.ent, pc.ent.
728 * These are currently counted twice because they're
729 * used both in DTD and EntityValue.
730 */
731 (16 + 6 + 6) * 2;
732 if (ctxt->sizeentities != total_size) {
733 fprintf(stderr, "Wrong parsed entity size: %lu (expected %lu)\n",
734 ctxt->sizeentities, total_size);
735 res = 1;
736 }
737 }
738
739 xmlFreeDoc(doc);
740 xmlFreeParserCtxt(ctxt);
741
742 return(res);
743 }
744
745 /************************************************************************
746 * *
747 * Tests Descriptions *
748 * *
749 ************************************************************************/
750
751 static
752 testDesc testDescriptions[] = {
753 { "Parsing recursive test cases" ,
754 recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
755 0 },
756 { "Parsing recursive test cases (no substitution)" ,
757 recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
758 OPT_NO_SUBST },
759 { "Parsing recursive test cases (SAX)" ,
760 recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
761 OPT_SAX },
762 { "Parsing recursive test cases (SAX, no substitution)" ,
763 recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
764 OPT_SAX | OPT_NO_SUBST },
765 { "Parsing non-recursive test cases" ,
766 notRecursiveDetectTest, "./test/recurse/good*.xml", NULL, NULL, NULL,
767 0 },
768 { "Parsing non-recursive test cases (SAX)" ,
769 notRecursiveDetectTest, "./test/recurse/good*.xml", NULL, NULL, NULL,
770 OPT_SAX },
771 { "Parsing non-recursive huge case" ,
772 notRecursiveHugeTest, NULL, NULL, NULL, NULL,
773 0 },
774 { "Parsing non-recursive huge case (no substitution)" ,
775 notRecursiveHugeTest, NULL, NULL, NULL, NULL,
776 OPT_NO_SUBST },
777 { "Parsing non-recursive huge case (SAX)" ,
778 notRecursiveHugeTest, NULL, NULL, NULL, NULL,
779 OPT_SAX },
780 { "Parsing non-recursive huge case (SAX, no substitution)" ,
781 notRecursiveHugeTest, NULL, NULL, NULL, NULL,
782 OPT_SAX | OPT_NO_SUBST },
783 { "Parsing non-recursive huge DTD case" ,
784 hugeDtdTest, NULL, NULL, NULL, NULL,
785 0 },
786 {NULL, NULL, NULL, NULL, NULL, NULL, 0}
787 };
788
789 /************************************************************************
790 * *
791 * The main code driving the tests *
792 * *
793 ************************************************************************/
794
795 static int
launchTests(testDescPtr tst)796 launchTests(testDescPtr tst) {
797 int res = 0, err = 0;
798 size_t i;
799 char *result;
800 char *error;
801 int mem;
802
803 if (tst == NULL) return(-1);
804 if (tst->in != NULL) {
805 glob_t globbuf;
806
807 globbuf.gl_offs = 0;
808 glob(tst->in, GLOB_DOOFFS, NULL, &globbuf);
809 for (i = 0;i < globbuf.gl_pathc;i++) {
810 if (!checkTestFile(globbuf.gl_pathv[i]))
811 continue;
812 if (tst->suffix != NULL) {
813 result = resultFilename(globbuf.gl_pathv[i], tst->out,
814 tst->suffix);
815 if (result == NULL) {
816 fprintf(stderr, "Out of memory !\n");
817 fatalError();
818 }
819 } else {
820 result = NULL;
821 }
822 if (tst->err != NULL) {
823 error = resultFilename(globbuf.gl_pathv[i], tst->out,
824 tst->err);
825 if (error == NULL) {
826 fprintf(stderr, "Out of memory !\n");
827 fatalError();
828 }
829 } else {
830 error = NULL;
831 }
832 if ((result) &&(!checkTestFile(result))) {
833 fprintf(stderr, "Missing result file %s\n", result);
834 } else if ((error) &&(!checkTestFile(error))) {
835 fprintf(stderr, "Missing error file %s\n", error);
836 } else {
837 mem = xmlMemUsed();
838 extraMemoryFromResolver = 0;
839 res = tst->func(globbuf.gl_pathv[i], result, error,
840 tst->options | XML_PARSE_COMPACT);
841 xmlResetLastError();
842 if (res != 0) {
843 fprintf(stderr, "File %s generated an error\n",
844 globbuf.gl_pathv[i]);
845 nb_errors++;
846 err++;
847 }
848 else if (xmlMemUsed() != mem) {
849 if ((xmlMemUsed() != mem) &&
850 (extraMemoryFromResolver == 0)) {
851 fprintf(stderr, "File %s leaked %d bytes\n",
852 globbuf.gl_pathv[i], xmlMemUsed() - mem);
853 nb_leaks++;
854 err++;
855 }
856 }
857 }
858 if (result)
859 free(result);
860 if (error)
861 free(error);
862 }
863 globfree(&globbuf);
864 } else {
865 extraMemoryFromResolver = 0;
866 res = tst->func(NULL, NULL, NULL, tst->options);
867 if (res != 0) {
868 nb_errors++;
869 err++;
870 }
871 }
872 return(err);
873 }
874
875 static int verbose = 0;
876 static int tests_quiet = 0;
877
878 static int
runtest(int i)879 runtest(int i) {
880 int ret = 0, res;
881 int old_errors, old_tests, old_leaks;
882
883 old_errors = nb_errors;
884 old_tests = nb_tests;
885 old_leaks = nb_leaks;
886 if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL))
887 printf("## %s\n", testDescriptions[i].desc);
888 res = launchTests(&testDescriptions[i]);
889 if (res != 0)
890 ret++;
891 if (verbose) {
892 if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
893 printf("Ran %d tests, no errors\n", nb_tests - old_tests);
894 else
895 printf("Ran %d tests, %d errors, %d leaks\n",
896 nb_tests - old_tests,
897 nb_errors - old_errors,
898 nb_leaks - old_leaks);
899 }
900 return(ret);
901 }
902
903 int
main(int argc ATTRIBUTE_UNUSED,char ** argv ATTRIBUTE_UNUSED)904 main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
905 int i, a, ret = 0;
906 int subset = 0;
907
908 initializeLibxml2();
909
910 for (a = 1; a < argc;a++) {
911 if (!strcmp(argv[a], "-v"))
912 verbose = 1;
913 else if (!strcmp(argv[a], "-quiet"))
914 tests_quiet = 1;
915 else {
916 for (i = 0; testDescriptions[i].func != NULL; i++) {
917 if (strstr(testDescriptions[i].desc, argv[a])) {
918 ret += runtest(i);
919 subset++;
920 }
921 }
922 }
923 }
924 if (subset == 0) {
925 for (i = 0; testDescriptions[i].func != NULL; i++) {
926 ret += runtest(i);
927 }
928 }
929 if ((nb_errors == 0) && (nb_leaks == 0)) {
930 ret = 0;
931 printf("Total %d tests, no errors\n",
932 nb_tests);
933 } else {
934 ret = 1;
935 printf("Total %d tests, %d errors, %d leaks\n",
936 nb_tests, nb_errors, nb_leaks);
937 }
938 xmlCleanupParser();
939
940 return(ret);
941 }
942