testrecurse.c

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