catalog.c

   1 /**
   2  * catalog.c: set of generic Catalog related routines
   3  *
   4  * Reference:  SGML Open Technical Resolution TR9401:1997.
   5  *             http://www.jclark.com/sp/catalog.htm
   6  *
   7  *             XML Catalogs Working Draft 06 August 2001
   8  *             http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
   9  *
  10  * See Copyright for the status of this software.
  11  *
  12  * Daniel.Veillard@imag.fr
  13  */
  14
  15 #define IN_LIBXML
  16 #include "libxml.h"
  17
  18 #ifdef LIBXML_CATALOG_ENABLED
  19 #ifdef HAVE_SYS_TYPES_H
  20 #include <sys/types.h>
  21 #endif
  22 #ifdef HAVE_SYS_STAT_H
  23 #include <sys/stat.h>
  24 #endif
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28 #ifdef HAVE_FCNTL_H
  29 #include <fcntl.h>
  30 #endif
  31 #ifdef HAVE_STDLIB_H
  32 #include <stdlib.h>
  33 #endif
  34 #include <string.h>
  35 #include <libxml/xmlmemory.h>
  36 #include <libxml/hash.h>
  37 #include <libxml/uri.h>
  38 #include <libxml/parserInternals.h>
  39 #include <libxml/catalog.h>
  40 #include <libxml/xmlerror.h>
  41 #include <libxml/threads.h>
  42 #include <libxml/globals.h>
  43
  44 #define MAX_DELEGATE    50
  45 #define MAX_CATAL_DEPTH 50
  46
  47 #ifdef _WIN32
  48 # define PATH_SEAPARATOR ';'
  49 #else
  50 # define PATH_SEAPARATOR ':'
  51 #endif
  52
  53 /**
  54  * TODO:
  55  *
  56  * macro to flag unimplemented blocks
  57  * XML_CATALOG_PREFER user env to select between system/public prefered
  58  * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
  59  *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
  60  *> values "system" and "public".  I have made the default be "system" to
  61  *> match yours.
  62  */
  63 #define TODO                                                            \
  64     xmlGenericError(xmlGenericErrorContext,                             \
  65             "Unimplemented block at %s:%d\n",                           \
  66             __FILE__, __LINE__);
  67
  68 #define XML_URN_PUBID "urn:publicid:"
  69 #define XML_CATAL_BREAK ((xmlChar *) -1)
  70 #ifndef XML_XML_DEFAULT_CATALOG
  71 #define XML_XML_DEFAULT_CATALOG "file:///etc/xml/catalog"
  72 #endif
  73 #ifndef XML_SGML_DEFAULT_CATALOG
  74 #define XML_SGML_DEFAULT_CATALOG "file:///etc/sgml/catalog"
  75 #endif
  76
  77 #if defined(_WIN32) && defined(_MSC_VER)
  78 #undef XML_XML_DEFAULT_CATALOG
  79 static char XML_XML_DEFAULT_CATALOG[256] = "file:///etc/xml/catalog";
  80 #if defined(_WIN32_WCE)
  81 /* Windows CE don't have a A variant */
  82 #define GetModuleHandleA GetModuleHandle
  83 #define GetModuleFileNameA GetModuleFileName
  84 #else
  85 void* __stdcall GetModuleHandleA(const char*);
  86 unsigned long __stdcall GetModuleFileNameA(void*, char*, unsigned long);
  87 #endif
  88 #endif
  89
  90 static xmlChar *xmlCatalogNormalizePublic(const xmlChar *pubID);
  91 static int xmlExpandCatalog(xmlCatalogPtr catal, const char *filename);
  92
  93 /************************************************************************
  94  *                                                                      *
  95  *                      Types, all private                              *
  96  *                                                                      *
  97  ************************************************************************/
  98
  99 typedef enum {
 100     XML_CATA_REMOVED = -1,
 101     XML_CATA_NONE = 0,
 102     XML_CATA_CATALOG,
 103     XML_CATA_BROKEN_CATALOG,
 104     XML_CATA_NEXT_CATALOG,
 105     XML_CATA_GROUP,
 106     XML_CATA_PUBLIC,
 107     XML_CATA_SYSTEM,
 108     XML_CATA_REWRITE_SYSTEM,
 109     XML_CATA_DELEGATE_PUBLIC,
 110     XML_CATA_DELEGATE_SYSTEM,
 111     XML_CATA_URI,
 112     XML_CATA_REWRITE_URI,
 113     XML_CATA_DELEGATE_URI,
 114     SGML_CATA_SYSTEM,
 115     SGML_CATA_PUBLIC,
 116     SGML_CATA_ENTITY,
 117     SGML_CATA_PENTITY,
 118     SGML_CATA_DOCTYPE,
 119     SGML_CATA_LINKTYPE,
 120     SGML_CATA_NOTATION,
 121     SGML_CATA_DELEGATE,
 122     SGML_CATA_BASE,
 123     SGML_CATA_CATALOG,
 124     SGML_CATA_DOCUMENT,
 125     SGML_CATA_SGMLDECL
 126 } xmlCatalogEntryType;
 127
 128 typedef struct _xmlCatalogEntry xmlCatalogEntry;
 129 typedef xmlCatalogEntry *xmlCatalogEntryPtr;
 130 struct _xmlCatalogEntry {
 131     struct _xmlCatalogEntry *next;
 132     struct _xmlCatalogEntry *parent;
 133     struct _xmlCatalogEntry *children;
 134     xmlCatalogEntryType type;
 135     xmlChar *name;
 136     xmlChar *value;
 137     xmlChar *URL;  /* The expanded URL using the base */
 138     xmlCatalogPrefer prefer;
 139     int dealloc;
 140     int depth;
 141     struct _xmlCatalogEntry *group;
 142 };
 143
 144 typedef enum {
 145     XML_XML_CATALOG_TYPE = 1,
 146     XML_SGML_CATALOG_TYPE
 147 } xmlCatalogType;
 148
 149 #define XML_MAX_SGML_CATA_DEPTH 10
 150 struct _xmlCatalog {
 151     xmlCatalogType type;        /* either XML or SGML */
 152
 153     /*
 154      * SGML Catalogs are stored as a simple hash table of catalog entries
 155      * Catalog stack to check against overflows when building the
 156      * SGML catalog
 157      */
 158     char *catalTab[XML_MAX_SGML_CATA_DEPTH];    /* stack of catals */
 159     int          catalNr;       /* Number of current catal streams */
 160     int          catalMax;      /* Max number of catal streams */
 161     xmlHashTablePtr sgml;
 162
 163     /*
 164      * XML Catalogs are stored as a tree of Catalog entries
 165      */
 166     xmlCatalogPrefer prefer;
 167     xmlCatalogEntryPtr xml;
 168 };
 169
 170 /************************************************************************
 171  *                                                                      *
 172  *                      Global variables                                *
 173  *                                                                      *
 174  ************************************************************************/
 175
 176 /*
 177  * Those are preferences
 178  */
 179 static int xmlDebugCatalogs = 0;   /* used for debugging */
 180 static xmlCatalogAllow xmlCatalogDefaultAllow = XML_CATA_ALLOW_ALL;
 181 static xmlCatalogPrefer xmlCatalogDefaultPrefer = XML_CATA_PREFER_PUBLIC;
 182
 183 /*
 184  * Hash table containing all the trees of XML catalogs parsed by
 185  * the application.
 186  */
 187 static xmlHashTablePtr xmlCatalogXMLFiles = NULL;
 188
 189 /*
 190  * The default catalog in use by the application
 191  */
 192 static xmlCatalogPtr xmlDefaultCatalog = NULL;
 193
 194 /*
 195  * A mutex for modifying the shared global catalog(s)
 196  * xmlDefaultCatalog tree.
 197  * It also protects xmlCatalogXMLFiles
 198  * The core of this readers/writer scheme is in xmlFetchXMLCatalogFile()
 199  */
 200 static xmlRMutexPtr xmlCatalogMutex = NULL;
 201
 202 /*
 203  * Whether the catalog support was initialized.
 204  */
 205 static int xmlCatalogInitialized = 0;
 206
 207 /************************************************************************
 208  *                                                                      *
 209  *                      Catalog error handlers                          *
 210  *                                                                      *
 211  ************************************************************************/
 212
 213 /**
 214  * xmlCatalogErrMemory:
 215  * @extra:  extra informations
 216  *
 217  * Handle an out of memory condition
 218  */
 219 static void
 220 xmlCatalogErrMemory(const char *extra)
 221 {
 222     __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_CATALOG,
 223                     XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0,
 224                     extra, NULL, NULL, 0, 0,
 225                     "Memory allocation failed : %s\n", extra);
 226 }
 227
 228 /**
 229  * xmlCatalogErr:
 230  * @catal: the Catalog entry
 231  * @node: the context node
 232  * @msg:  the error message
 233  * @extra:  extra informations
 234  *
 235  * Handle a catalog error
 236  */
 237 static void
 238 xmlCatalogErr(xmlCatalogEntryPtr catal, xmlNodePtr node, int error,
 239                const char *msg, const xmlChar *str1, const xmlChar *str2,
 240                const xmlChar *str3)
 241 {
 242     __xmlRaiseError(NULL, NULL, NULL, catal, node, XML_FROM_CATALOG,
 243                     error, XML_ERR_ERROR, NULL, 0,
 244                     (const char *) str1, (const char *) str2,
 245                     (const char *) str3, 0, 0,
 246                     msg, str1, str2, str3);
 247 }
 248
 249
 250 /************************************************************************
 251  *                                                                      *
 252  *                      Allocation and Freeing                          *
 253  *                                                                      *
 254  ************************************************************************/
 255
 256 /**
 257  * xmlNewCatalogEntry:
 258  * @type:  type of entry
 259  * @name:  name of the entry
 260  * @value:  value of the entry
 261  * @prefer:  the PUBLIC vs. SYSTEM current preference value
 262  * @group:  for members of a group, the group entry
 263  *
 264  * create a new Catalog entry, this type is shared both by XML and
 265  * SGML catalogs, but the acceptable types values differs.
 266  *
 267  * Returns the xmlCatalogEntryPtr or NULL in case of error
 268  */
 269 static xmlCatalogEntryPtr
 270 xmlNewCatalogEntry(xmlCatalogEntryType type, const xmlChar *name,
 271            const xmlChar *value, const xmlChar *URL, xmlCatalogPrefer prefer,
 272            xmlCatalogEntryPtr group) {
 273     xmlCatalogEntryPtr ret;
 274     xmlChar *normid = NULL;
 275
 276     ret = (xmlCatalogEntryPtr) xmlMalloc(sizeof(xmlCatalogEntry));
 277     if (ret == NULL) {
 278         xmlCatalogErrMemory("allocating catalog entry");
 279         return(NULL);
 280     }
 281     ret->next = NULL;
 282     ret->parent = NULL;
 283     ret->children = NULL;
 284     ret->type = type;
 285     if (type == XML_CATA_PUBLIC || type == XML_CATA_DELEGATE_PUBLIC) {
 286         normid = xmlCatalogNormalizePublic(name);
 287         if (normid != NULL)
 288             name = (*normid != 0 ? normid : NULL);
 289     }
 290     if (name != NULL)
 291         ret->name = xmlStrdup(name);
 292     else
 293         ret->name = NULL;
 294     if (normid != NULL)
 295         xmlFree(normid);
 296     if (value != NULL)
 297         ret->value = xmlStrdup(value);
 298     else
 299         ret->value = NULL;
 300     if (URL == NULL)
 301         URL = value;
 302     if (URL != NULL)
 303         ret->URL = xmlStrdup(URL);
 304     else
 305         ret->URL = NULL;
 306     ret->prefer = prefer;
 307     ret->dealloc = 0;
 308     ret->depth = 0;
 309     ret->group = group;
 310     return(ret);
 311 }
 312
 313 static void
 314 xmlFreeCatalogEntryList(xmlCatalogEntryPtr ret);
 315
 316 /**
 317  * xmlFreeCatalogEntry:
 318  * @ret:  a Catalog entry
 319  *
 320  * Free the memory allocated to a Catalog entry
 321  */
 322 static void
 323 xmlFreeCatalogEntry(xmlCatalogEntryPtr ret) {
 324     if (ret == NULL)
 325         return;
 326     /*
 327      * Entries stored in the file hash must be deallocated
 328      * only by the file hash cleaner !
 329      */
 330     if (ret->dealloc == 1)
 331         return;
 332
 333     if (xmlDebugCatalogs) {
 334         if (ret->name != NULL)
 335             xmlGenericError(xmlGenericErrorContext,
 336                     "Free catalog entry %s\n", ret->name);
 337         else if (ret->value != NULL)
 338             xmlGenericError(xmlGenericErrorContext,
 339                     "Free catalog entry %s\n", ret->value);
 340         else
 341             xmlGenericError(xmlGenericErrorContext,
 342                     "Free catalog entry\n");
 343     }
 344
 345     if (ret->name != NULL)
 346         xmlFree(ret->name);
 347     if (ret->value != NULL)
 348         xmlFree(ret->value);
 349     if (ret->URL != NULL)
 350         xmlFree(ret->URL);
 351     xmlFree(ret);
 352 }
 353
 354 /**
 355  * xmlFreeCatalogEntryList:
 356  * @ret:  a Catalog entry list
 357  *
 358  * Free the memory allocated to a full chained list of Catalog entries
 359  */
 360 static void
 361 xmlFreeCatalogEntryList(xmlCatalogEntryPtr ret) {
 362     xmlCatalogEntryPtr next;
 363
 364     while (ret != NULL) {
 365         next = ret->next;
 366         xmlFreeCatalogEntry(ret);
 367         ret = next;
 368     }
 369 }
 370
 371 /**
 372  * xmlFreeCatalogHashEntryList:
 373  * @ret:  a Catalog entry list
 374  *
 375  * Free the memory allocated to list of Catalog entries from the
 376  * catalog file hash.
 377  */
 378 static void
 379 xmlFreeCatalogHashEntryList(xmlCatalogEntryPtr catal) {
 380     xmlCatalogEntryPtr children, next;
 381
 382     if (catal == NULL)
 383         return;
 384
 385     children = catal->children;
 386     while (children != NULL) {
 387         next = children->next;
 388         children->dealloc = 0;
 389         children->children = NULL;
 390         xmlFreeCatalogEntry(children);
 391         children = next;
 392     }
 393     catal->dealloc = 0;
 394     xmlFreeCatalogEntry(catal);
 395 }
 396
 397 /**
 398  * xmlCreateNewCatalog:
 399  * @type:  type of catalog
 400  * @prefer:  the PUBLIC vs. SYSTEM current preference value
 401  *
 402  * create a new Catalog, this type is shared both by XML and
 403  * SGML catalogs, but the acceptable types values differs.
 404  *
 405  * Returns the xmlCatalogPtr or NULL in case of error
 406  */
 407 static xmlCatalogPtr
 408 xmlCreateNewCatalog(xmlCatalogType type, xmlCatalogPrefer prefer) {
 409     xmlCatalogPtr ret;
 410
 411     ret = (xmlCatalogPtr) xmlMalloc(sizeof(xmlCatalog));
 412     if (ret == NULL) {
 413         xmlCatalogErrMemory("allocating catalog");
 414         return(NULL);
 415     }
 416     memset(ret, 0, sizeof(xmlCatalog));
 417     ret->type = type;
 418     ret->catalNr = 0;
 419     ret->catalMax = XML_MAX_SGML_CATA_DEPTH;
 420     ret->prefer = prefer;
 421     if (ret->type == XML_SGML_CATALOG_TYPE)
 422         ret->sgml = xmlHashCreate(10);
 423     return(ret);
 424 }
 425
 426 /**
 427  * xmlFreeCatalog:
 428  * @catal:  a Catalog
 429  *
 430  * Free the memory allocated to a Catalog
 431  */
 432 void
 433 xmlFreeCatalog(xmlCatalogPtr catal) {
 434     if (catal == NULL)
 435         return;
 436     if (catal->xml != NULL)
 437         xmlFreeCatalogEntryList(catal->xml);
 438     if (catal->sgml != NULL)
 439         xmlHashFree(catal->sgml,
 440                 (xmlHashDeallocator) xmlFreeCatalogEntry);
 441     xmlFree(catal);
 442 }
 443
 444 /************************************************************************
 445  *                                                                      *
 446  *                      Serializing Catalogs                            *
 447  *                                                                      *
 448  ************************************************************************/
 449
 450 #ifdef LIBXML_OUTPUT_ENABLED
 451 /**
 452  * xmlCatalogDumpEntry:
 453  * @entry:  the catalog entry
 454  * @out:  the file.
 455  *
 456  * Serialize an SGML Catalog entry
 457  */
 458 static void
 459 xmlCatalogDumpEntry(xmlCatalogEntryPtr entry, FILE *out) {
 460     if ((entry == NULL) || (out == NULL))
 461         return;
 462     switch (entry->type) {
 463         case SGML_CATA_ENTITY:
 464             fprintf(out, "ENTITY "); break;
 465         case SGML_CATA_PENTITY:
 466             fprintf(out, "ENTITY %%"); break;
 467         case SGML_CATA_DOCTYPE:
 468             fprintf(out, "DOCTYPE "); break;
 469         case SGML_CATA_LINKTYPE:
 470             fprintf(out, "LINKTYPE "); break;
 471         case SGML_CATA_NOTATION:
 472             fprintf(out, "NOTATION "); break;
 473         case SGML_CATA_PUBLIC:
 474             fprintf(out, "PUBLIC "); break;
 475         case SGML_CATA_SYSTEM:
 476             fprintf(out, "SYSTEM "); break;
 477         case SGML_CATA_DELEGATE:
 478             fprintf(out, "DELEGATE "); break;
 479         case SGML_CATA_BASE:
 480             fprintf(out, "BASE "); break;
 481         case SGML_CATA_CATALOG:
 482             fprintf(out, "CATALOG "); break;
 483         case SGML_CATA_DOCUMENT:
 484             fprintf(out, "DOCUMENT "); break;
 485         case SGML_CATA_SGMLDECL:
 486             fprintf(out, "SGMLDECL "); break;
 487         default:
 488             return;
 489     }
 490     switch (entry->type) {
 491         case SGML_CATA_ENTITY:
 492         case SGML_CATA_PENTITY:
 493         case SGML_CATA_DOCTYPE:
 494         case SGML_CATA_LINKTYPE:
 495         case SGML_CATA_NOTATION:
 496             fprintf(out, "%s", (const char *) entry->name); break;
 497         case SGML_CATA_PUBLIC:
 498         case SGML_CATA_SYSTEM:
 499         case SGML_CATA_SGMLDECL:
 500         case SGML_CATA_DOCUMENT:
 501         case SGML_CATA_CATALOG:
 502         case SGML_CATA_BASE:
 503         case SGML_CATA_DELEGATE:
 504             fprintf(out, "\"%s\"", entry->name); break;
 505         default:
 506             break;
 507     }
 508     switch (entry->type) {
 509         case SGML_CATA_ENTITY:
 510         case SGML_CATA_PENTITY:
 511         case SGML_CATA_DOCTYPE:
 512         case SGML_CATA_LINKTYPE:
 513         case SGML_CATA_NOTATION:
 514         case SGML_CATA_PUBLIC:
 515         case SGML_CATA_SYSTEM:
 516         case SGML_CATA_DELEGATE:
 517             fprintf(out, " \"%s\"", entry->value); break;
 518         default:
 519             break;
 520     }
 521     fprintf(out, "\n");
 522 }
 523
 524 /**
 525  * xmlDumpXMLCatalogNode:
 526  * @catal:  top catalog entry
 527  * @catalog: pointer to the xml tree
 528  * @doc: the containing document
 529  * @ns: the current namespace
 530  * @cgroup: group node for group members
 531  *
 532  * Serializes a Catalog entry, called by xmlDumpXMLCatalog and recursively
 533  * for group entries
 534  */
 535 static void xmlDumpXMLCatalogNode(xmlCatalogEntryPtr catal, xmlNodePtr catalog,
 536                     xmlDocPtr doc, xmlNsPtr ns, xmlCatalogEntryPtr cgroup) {
 537     xmlNodePtr node;
 538     xmlCatalogEntryPtr cur;
 539     /*
 540      * add all the catalog entries
 541      */
 542     cur = catal;
 543     while (cur != NULL) {
 544         if (cur->group == cgroup) {
 545             switch (cur->type) {
 546                 case XML_CATA_REMOVED:
 547                     break;
 548                 case XML_CATA_BROKEN_CATALOG:
 549                 case XML_CATA_CATALOG:
 550                     if (cur == catal) {
 551                         cur = cur->children;
 552                         continue;
 553                     }
 554                     break;
 555                 case XML_CATA_NEXT_CATALOG:
 556                     node = xmlNewDocNode(doc, ns, BAD_CAST "nextCatalog", NULL);
 557                     xmlSetProp(node, BAD_CAST "catalog", cur->value);
 558                     xmlAddChild(catalog, node);
 559                     break;
 560                 case XML_CATA_NONE:
 561                     break;
 562                 case XML_CATA_GROUP:
 563                     node = xmlNewDocNode(doc, ns, BAD_CAST "group", NULL);
 564                     xmlSetProp(node, BAD_CAST "id", cur->name);
 565                     if (cur->value != NULL) {
 566                         xmlNsPtr xns;
 567                         xns = xmlSearchNsByHref(doc, node, XML_XML_NAMESPACE);
 568                         if (xns != NULL)
 569                             xmlSetNsProp(node, xns, BAD_CAST "base",
 570                                          cur->value);
 571                     }
 572                     switch (cur->prefer) {
 573                         case XML_CATA_PREFER_NONE:
 574                             break;
 575                         case XML_CATA_PREFER_PUBLIC:
 576                             xmlSetProp(node, BAD_CAST "prefer", BAD_CAST "public");
 577                             break;
 578                         case XML_CATA_PREFER_SYSTEM:
 579                             xmlSetProp(node, BAD_CAST "prefer", BAD_CAST "system");
 580                             break;
 581                     }
 582                     xmlDumpXMLCatalogNode(cur->next, node, doc, ns, cur);
 583                     xmlAddChild(catalog, node);
 584                     break;
 585                 case XML_CATA_PUBLIC:
 586                     node = xmlNewDocNode(doc, ns, BAD_CAST "public", NULL);
 587                     xmlSetProp(node, BAD_CAST "publicId", cur->name);
 588                     xmlSetProp(node, BAD_CAST "uri", cur->value);
 589                     xmlAddChild(catalog, node);
 590                     break;
 591                 case XML_CATA_SYSTEM:
 592                     node = xmlNewDocNode(doc, ns, BAD_CAST "system", NULL);
 593                     xmlSetProp(node, BAD_CAST "systemId", cur->name);
 594                     xmlSetProp(node, BAD_CAST "uri", cur->value);
 595                     xmlAddChild(catalog, node);
 596                     break;
 597                 case XML_CATA_REWRITE_SYSTEM:
 598                     node = xmlNewDocNode(doc, ns, BAD_CAST "rewriteSystem", NULL);
 599                     xmlSetProp(node, BAD_CAST "systemIdStartString", cur->name);
 600                     xmlSetProp(node, BAD_CAST "rewritePrefix", cur->value);
 601                     xmlAddChild(catalog, node);
 602                     break;
 603                 case XML_CATA_DELEGATE_PUBLIC:
 604                     node = xmlNewDocNode(doc, ns, BAD_CAST "delegatePublic", NULL);
 605                     xmlSetProp(node, BAD_CAST "publicIdStartString", cur->name);
 606                     xmlSetProp(node, BAD_CAST "catalog", cur->value);
 607                     xmlAddChild(catalog, node);
 608                     break;
 609                 case XML_CATA_DELEGATE_SYSTEM:
 610                     node = xmlNewDocNode(doc, ns, BAD_CAST "delegateSystem", NULL);
 611                     xmlSetProp(node, BAD_CAST "systemIdStartString", cur->name);
 612                     xmlSetProp(node, BAD_CAST "catalog", cur->value);
 613                     xmlAddChild(catalog, node);
 614                     break;
 615                 case XML_CATA_URI:
 616                     node = xmlNewDocNode(doc, ns, BAD_CAST "uri", NULL);
 617                     xmlSetProp(node, BAD_CAST "name", cur->name);
 618                     xmlSetProp(node, BAD_CAST "uri", cur->value);
 619                     xmlAddChild(catalog, node);
 620                     break;
 621                 case XML_CATA_REWRITE_URI:
 622                     node = xmlNewDocNode(doc, ns, BAD_CAST "rewriteURI", NULL);
 623                     xmlSetProp(node, BAD_CAST "uriStartString", cur->name);
 624                     xmlSetProp(node, BAD_CAST "rewritePrefix", cur->value);
 625                     xmlAddChild(catalog, node);
 626                     break;
 627                 case XML_CATA_DELEGATE_URI:
 628                     node = xmlNewDocNode(doc, ns, BAD_CAST "delegateURI", NULL);
 629                     xmlSetProp(node, BAD_CAST "uriStartString", cur->name);
 630                     xmlSetProp(node, BAD_CAST "catalog", cur->value);
 631                     xmlAddChild(catalog, node);
 632                     break;
 633                 case SGML_CATA_SYSTEM:
 634                 case SGML_CATA_PUBLIC:
 635                 case SGML_CATA_ENTITY:
 636                 case SGML_CATA_PENTITY:
 637                 case SGML_CATA_DOCTYPE:
 638                 case SGML_CATA_LINKTYPE:
 639                 case SGML_CATA_NOTATION:
 640                 case SGML_CATA_DELEGATE:
 641                 case SGML_CATA_BASE:
 642                 case SGML_CATA_CATALOG:
 643                 case SGML_CATA_DOCUMENT:
 644                 case SGML_CATA_SGMLDECL:
 645                     break;
 646             }
 647         }
 648         cur = cur->next;
 649     }
 650 }
 651
 652 static int
 653 xmlDumpXMLCatalog(FILE *out, xmlCatalogEntryPtr catal) {
 654     int ret;
 655     xmlDocPtr doc;
 656     xmlNsPtr ns;
 657     xmlDtdPtr dtd;
 658     xmlNodePtr catalog;
 659     xmlOutputBufferPtr buf;
 660
 661     /*
 662      * Rebuild a catalog
 663      */
 664     doc = xmlNewDoc(NULL);
 665     if (doc == NULL)
 666         return(-1);
 667     dtd = xmlNewDtd(doc, BAD_CAST "catalog",
 668                BAD_CAST "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN",
 669 BAD_CAST "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd");
 670
 671     xmlAddChild((xmlNodePtr) doc, (xmlNodePtr) dtd);
 672
 673     ns = xmlNewNs(NULL, XML_CATALOGS_NAMESPACE, NULL);
 674     if (ns == NULL) {
 675         xmlFreeDoc(doc);
 676         return(-1);
 677     }
 678     catalog = xmlNewDocNode(doc, ns, BAD_CAST "catalog", NULL);
 679     if (catalog == NULL) {
 680         xmlFreeNs(ns);
 681         xmlFreeDoc(doc);
 682         return(-1);
 683     }
 684     catalog->nsDef = ns;
 685     xmlAddChild((xmlNodePtr) doc, catalog);
 686
 687     xmlDumpXMLCatalogNode(catal, catalog, doc, ns, NULL);
 688
 689     /*
 690      * reserialize it
 691      */
 692     buf = xmlOutputBufferCreateFile(out, NULL);
 693     if (buf == NULL) {
 694         xmlFreeDoc(doc);
 695         return(-1);
 696     }
 697     ret = xmlSaveFormatFileTo(buf, doc, NULL, 1);
 698
 699     /*
 700      * Free it
 701      */
 702     xmlFreeDoc(doc);
 703
 704     return(ret);
 705 }
 706 #endif /* LIBXML_OUTPUT_ENABLED */
 707
 708 /************************************************************************
 709  *                                                                      *
 710  *                      Converting SGML Catalogs to XML                 *
 711  *                                                                      *
 712  ************************************************************************/
 713
 714 /**
 715  * xmlCatalogConvertEntry:
 716  * @entry:  the entry
 717  * @catal:  pointer to the catalog being converted
 718  *
 719  * Convert one entry from the catalog
 720  */
 721 static void
 722 xmlCatalogConvertEntry(xmlCatalogEntryPtr entry, xmlCatalogPtr catal) {
 723     if ((entry == NULL) || (catal == NULL) || (catal->sgml == NULL) ||
 724         (catal->xml == NULL))
 725         return;
 726     switch (entry->type) {
 727         case SGML_CATA_ENTITY:
 728             entry->type = XML_CATA_PUBLIC;
 729             break;
 730         case SGML_CATA_PENTITY:
 731             entry->type = XML_CATA_PUBLIC;
 732             break;
 733         case SGML_CATA_DOCTYPE:
 734             entry->type = XML_CATA_PUBLIC;
 735             break;
 736         case SGML_CATA_LINKTYPE:
 737             entry->type = XML_CATA_PUBLIC;
 738             break;
 739         case SGML_CATA_NOTATION:
 740             entry->type = XML_CATA_PUBLIC;
 741             break;
 742         case SGML_CATA_PUBLIC:
 743             entry->type = XML_CATA_PUBLIC;
 744             break;
 745         case SGML_CATA_SYSTEM:
 746             entry->type = XML_CATA_SYSTEM;
 747             break;
 748         case SGML_CATA_DELEGATE:
 749             entry->type = XML_CATA_DELEGATE_PUBLIC;
 750             break;
 751         case SGML_CATA_CATALOG:
 752             entry->type = XML_CATA_CATALOG;
 753             break;
 754         default:
 755             xmlHashRemoveEntry(catal->sgml, entry->name,
 756                                (xmlHashDeallocator) xmlFreeCatalogEntry);
 757             return;
 758     }
 759     /*
 760      * Conversion successful, remove from the SGML catalog
 761      * and add it to the default XML one
 762      */
 763     xmlHashRemoveEntry(catal->sgml, entry->name, NULL);
 764     entry->parent = catal->xml;
 765     entry->next = NULL;
 766     if (catal->xml->children == NULL)
 767         catal->xml->children = entry;
 768     else {
 769         xmlCatalogEntryPtr prev;
 770
 771         prev = catal->xml->children;
 772         while (prev->next != NULL)
 773             prev = prev->next;
 774         prev->next = entry;
 775     }
 776 }
 777
 778 /**
 779  * xmlConvertSGMLCatalog:
 780  * @catal: the catalog
 781  *
 782  * Convert all the SGML catalog entries as XML ones
 783  *
 784  * Returns the number of entries converted if successful, -1 otherwise
 785  */
 786 int
 787 xmlConvertSGMLCatalog(xmlCatalogPtr catal) {
 788
 789     if ((catal == NULL) || (catal->type != XML_SGML_CATALOG_TYPE))
 790         return(-1);
 791
 792     if (xmlDebugCatalogs) {
 793         xmlGenericError(xmlGenericErrorContext,
 794                 "Converting SGML catalog to XML\n");
 795     }
 796     xmlHashScan(catal->sgml,
 797                 (xmlHashScanner) xmlCatalogConvertEntry,
 798                 &catal);
 799     return(0);
 800 }
 801
 802 /************************************************************************
 803  *                                                                      *
 804  *                      Helper function                                 *
 805  *                                                                      *
 806  ************************************************************************/
 807
 808 /**
 809  * xmlCatalogUnWrapURN:
 810  * @urn:  an "urn:publicid:" to unwrap
 811  *
 812  * Expand the URN into the equivalent Public Identifier
 813  *
 814  * Returns the new identifier or NULL, the string must be deallocated
 815  *         by the caller.
 816  */
 817 static xmlChar *
 818 xmlCatalogUnWrapURN(const xmlChar *urn) {
 819     xmlChar result[2000];
 820     unsigned int i = 0;
 821
 822     if (xmlStrncmp(urn, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1))
 823         return(NULL);
 824     urn += sizeof(XML_URN_PUBID) - 1;
 825
 826     while (*urn != 0) {
 827         if (i > sizeof(result) - 4)
 828             break;
 829         if (*urn == '+') {
 830             result[i++] = ' ';
 831             urn++;
 832         } else if (*urn == ':') {
 833             result[i++] = '/';
 834             result[i++] = '/';
 835             urn++;
 836         } else if (*urn == ';') {
 837             result[i++] = ':';
 838             result[i++] = ':';
 839             urn++;
 840         } else if (*urn == '%') {
 841             if ((urn[1] == '2') && (urn[2] == 'B'))
 842                 result[i++] = '+';
 843             else if ((urn[1] == '3') && (urn[2] == 'A'))
 844                 result[i++] = ':';
 845             else if ((urn[1] == '2') && (urn[2] == 'F'))
 846                 result[i++] = '/';
 847             else if ((urn[1] == '3') && (urn[2] == 'B'))
 848                 result[i++] = ';';
 849             else if ((urn[1] == '2') && (urn[2] == '7'))
 850                 result[i++] = '\'';
 851             else if ((urn[1] == '3') && (urn[2] == 'F'))
 852                 result[i++] = '?';
 853             else if ((urn[1] == '2') && (urn[2] == '3'))
 854                 result[i++] = '#';
 855             else if ((urn[1] == '2') && (urn[2] == '5'))
 856                 result[i++] = '%';
 857             else {
 858                 result[i++] = *urn;
 859                 urn++;
 860                 continue;
 861             }
 862             urn += 3;
 863         } else {
 864             result[i++] = *urn;
 865             urn++;
 866         }
 867     }
 868     result[i] = 0;
 869
 870     return(xmlStrdup(result));
 871 }
 872
 873 /**
 874  * xmlParseCatalogFile:
 875  * @filename:  the filename
 876  *
 877  * parse an XML file and build a tree. It's like xmlParseFile()
 878  * except it bypass all catalog lookups.
 879  *
 880  * Returns the resulting document tree or NULL in case of error
 881  */
 882
 883 xmlDocPtr
 884 xmlParseCatalogFile(const char *filename) {
 885     xmlDocPtr ret;
 886     xmlParserCtxtPtr ctxt;
 887     char *directory = NULL;
 888     xmlParserInputPtr inputStream;
 889     xmlParserInputBufferPtr buf;
 890
 891     ctxt = xmlNewParserCtxt();
 892     if (ctxt == NULL) {
 893 #ifdef LIBXML_SAX1_ENABLED
 894         if (xmlDefaultSAXHandler.error != NULL) {
 895             xmlDefaultSAXHandler.error(NULL, "out of memory\n");
 896         }
 897 #endif
 898         return(NULL);
 899     }
 900
 901     buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
 902     if (buf == NULL) {
 903         xmlFreeParserCtxt(ctxt);
 904         return(NULL);
 905     }
 906
 907     inputStream = xmlNewInputStream(ctxt);
 908     if (inputStream == NULL) {
 909         xmlFreeParserCtxt(ctxt);
 910         return(NULL);
 911     }
 912
 913     inputStream->filename = (char *) xmlCanonicPath((const xmlChar *)filename);
 914     inputStream->buf = buf;
 915     inputStream->base = inputStream->buf->buffer->content;
 916     inputStream->cur = inputStream->buf->buffer->content;
 917     inputStream->end =
 918         &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
 919
 920     inputPush(ctxt, inputStream);
 921     if ((ctxt->directory == NULL) && (directory == NULL))
 922         directory = xmlParserGetDirectory(filename);
 923     if ((ctxt->directory == NULL) && (directory != NULL))
 924         ctxt->directory = directory;
 925     ctxt->valid = 0;
 926     ctxt->validate = 0;
 927     ctxt->loadsubset = 0;
 928     ctxt->pedantic = 0;
 929     ctxt->dictNames = 1;
 930
 931     xmlParseDocument(ctxt);
 932
 933     if (ctxt->wellFormed)
 934         ret = ctxt->myDoc;
 935     else {
 936         ret = NULL;
 937         xmlFreeDoc(ctxt->myDoc);
 938         ctxt->myDoc = NULL;
 939     }
 940     xmlFreeParserCtxt(ctxt);
 941
 942     return(ret);
 943 }
 944
 945 /**
 946  * xmlLoadFileContent:
 947  * @filename:  a file path
 948  *
 949  * Load a file content into memory.
 950  *
 951  * Returns a pointer to the 0 terminated string or NULL in case of error
 952  */
 953 static xmlChar *
 954 xmlLoadFileContent(const char *filename)
 955 {
 956 #ifdef HAVE_STAT
 957     int fd;
 958 #else
 959     FILE *fd;
 960 #endif
 961     int len;
 962     long size;
 963
 964 #ifdef HAVE_STAT
 965     struct stat info;
 966 #endif
 967     xmlChar *content;
 968
 969     if (filename == NULL)
 970         return (NULL);
 971
 972 #ifdef HAVE_STAT
 973     if (stat(filename, &info) < 0)
 974         return (NULL);
 975 #endif
 976
 977 #ifdef HAVE_STAT
 978     if ((fd = open(filename, O_RDONLY)) < 0)
 979 #else
 980     if ((fd = fopen(filename, "rb")) == NULL)
 981 #endif
 982     {
 983         return (NULL);
 984     }
 985 #ifdef HAVE_STAT
 986     size = info.st_size;
 987 #else
 988     if (fseek(fd, 0, SEEK_END) || (size = ftell(fd)) == EOF || fseek(fd, 0, SEEK_SET)) {        /* File operations denied? ok, just close and return failure */
 989         fclose(fd);
 990         return (NULL);
 991     }
 992 #endif
 993     content = xmlMallocAtomic(size + 10);
 994     if (content == NULL) {
 995         xmlCatalogErrMemory("allocating catalog data");
 996         return (NULL);
 997     }
 998 #ifdef HAVE_STAT
 999     len = read(fd, content, size);
1000     close(fd);
1001 #else
1002     len = fread(content, 1, size, fd);
1003     fclose(fd);
1004 #endif
1005     if (len < 0) {
1006         xmlFree(content);
1007         return (NULL);
1008     }
1009     content[len] = 0;
1010
1011     return(content);
1012 }
1013
1014 /**
1015  * xmlCatalogNormalizePublic:
1016  * @pubID:  the public ID string
1017  *
1018  *  Normalizes the Public Identifier
1019  *
1020  * Implements 6.2. Public Identifier Normalization
1021  * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
1022  *
1023  * Returns the new string or NULL, the string must be deallocated
1024  *         by the caller.
1025  */
1026 static xmlChar *
1027 xmlCatalogNormalizePublic(const xmlChar *pubID)
1028 {
1029     int ok = 1;
1030     int white;
1031     const xmlChar *p;
1032     xmlChar *ret;
1033     xmlChar *q;
1034
1035     if (pubID == NULL)
1036         return(NULL);
1037
1038     white = 1;
1039     for (p = pubID;*p != 0 && ok;p++) {
1040         if (!xmlIsBlank_ch(*p))
1041             white = 0;
1042         else if (*p == 0x20 && !white)
1043             white = 1;
1044         else
1045             ok = 0;
1046     }
1047     if (ok && !white)   /* is normalized */
1048         return(NULL);
1049
1050     ret = xmlStrdup(pubID);
1051     q = ret;
1052     white = 0;
1053     for (p = pubID;*p != 0;p++) {
1054         if (xmlIsBlank_ch(*p)) {
1055             if (q != ret)
1056                 white = 1;
1057         } else {
1058             if (white) {
1059                 *(q++) = 0x20;
1060                 white = 0;
1061             }
1062             *(q++) = *p;
1063         }
1064     }
1065     *q = 0;
1066     return(ret);
1067 }
1068
1069 /************************************************************************
1070  *                                                                      *
1071  *                      The XML Catalog parser                          *
1072  *                                                                      *
1073  ************************************************************************/
1074
1075 static xmlCatalogEntryPtr
1076 xmlParseXMLCatalogFile(xmlCatalogPrefer prefer, const xmlChar *filename);
1077 static void
1078 xmlParseXMLCatalogNodeList(xmlNodePtr cur, xmlCatalogPrefer prefer,
1079                            xmlCatalogEntryPtr parent, xmlCatalogEntryPtr cgroup);
1080 static xmlChar *
1081 xmlCatalogListXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
1082                       const xmlChar *sysID);
1083 static xmlChar *
1084 xmlCatalogListXMLResolveURI(xmlCatalogEntryPtr catal, const xmlChar *URI);
1085
1086
1087 /**
1088  * xmlGetXMLCatalogEntryType:
1089  * @name:  the name
1090  *
1091  * lookup the internal type associated to an XML catalog entry name
1092  *
1093  * Returns the type associated with that name
1094  */
1095 static xmlCatalogEntryType
1096 xmlGetXMLCatalogEntryType(const xmlChar *name) {
1097     xmlCatalogEntryType type = XML_CATA_NONE;
1098     if (xmlStrEqual(name, (const xmlChar *) "system"))
1099         type = XML_CATA_SYSTEM;
1100     else if (xmlStrEqual(name, (const xmlChar *) "public"))
1101         type = XML_CATA_PUBLIC;
1102     else if (xmlStrEqual(name, (const xmlChar *) "rewriteSystem"))
1103         type = XML_CATA_REWRITE_SYSTEM;
1104     else if (xmlStrEqual(name, (const xmlChar *) "delegatePublic"))
1105         type = XML_CATA_DELEGATE_PUBLIC;
1106     else if (xmlStrEqual(name, (const xmlChar *) "delegateSystem"))
1107         type = XML_CATA_DELEGATE_SYSTEM;
1108     else if (xmlStrEqual(name, (const xmlChar *) "uri"))
1109         type = XML_CATA_URI;
1110     else if (xmlStrEqual(name, (const xmlChar *) "rewriteURI"))
1111         type = XML_CATA_REWRITE_URI;
1112     else if (xmlStrEqual(name, (const xmlChar *) "delegateURI"))
1113         type = XML_CATA_DELEGATE_URI;
1114     else if (xmlStrEqual(name, (const xmlChar *) "nextCatalog"))
1115         type = XML_CATA_NEXT_CATALOG;
1116     else if (xmlStrEqual(name, (const xmlChar *) "catalog"))
1117         type = XML_CATA_CATALOG;
1118     return(type);
1119 }
1120
1121 /**
1122  * xmlParseXMLCatalogOneNode:
1123  * @cur:  the XML node
1124  * @type:  the type of Catalog entry
1125  * @name:  the name of the node
1126  * @attrName:  the attribute holding the value
1127  * @uriAttrName:  the attribute holding the URI-Reference
1128  * @prefer:  the PUBLIC vs. SYSTEM current preference value
1129  * @cgroup:  the group which includes this node
1130  *
1131  * Finishes the examination of an XML tree node of a catalog and build
1132  * a Catalog entry from it.
1133  *
1134  * Returns the new Catalog entry node or NULL in case of error.
1135  */
1136 static xmlCatalogEntryPtr
1137 xmlParseXMLCatalogOneNode(xmlNodePtr cur, xmlCatalogEntryType type,
1138                           const xmlChar *name, const xmlChar *attrName,
1139                           const xmlChar *uriAttrName, xmlCatalogPrefer prefer,
1140                           xmlCatalogEntryPtr cgroup) {
1141     int ok = 1;
1142     xmlChar *uriValue;
1143     xmlChar *nameValue = NULL;
1144     xmlChar *base = NULL;
1145     xmlChar *URL = NULL;
1146     xmlCatalogEntryPtr ret = NULL;
1147
1148     if (attrName != NULL) {
1149         nameValue = xmlGetProp(cur, attrName);
1150         if (nameValue == NULL) {
1151             xmlCatalogErr(ret, cur, XML_CATALOG_MISSING_ATTR,
1152                           "%s entry lacks '%s'\n", name, attrName, NULL);
1153             ok = 0;
1154         }
1155     }
1156     uriValue = xmlGetProp(cur, uriAttrName);
1157     if (uriValue == NULL) {
1158         xmlCatalogErr(ret, cur, XML_CATALOG_MISSING_ATTR,
1159                 "%s entry lacks '%s'\n", name, uriAttrName, NULL);
1160         ok = 0;
1161     }
1162     if (!ok) {
1163         if (nameValue != NULL)
1164             xmlFree(nameValue);
1165         if (uriValue != NULL)
1166             xmlFree(uriValue);
1167         return(NULL);
1168     }
1169
1170     base = xmlNodeGetBase(cur->doc, cur);
1171     URL = xmlBuildURI(uriValue, base);
1172     if (URL != NULL) {
1173         if (xmlDebugCatalogs > 1) {
1174             if (nameValue != NULL)
1175                 xmlGenericError(xmlGenericErrorContext,
1176                         "Found %s: '%s' '%s'\n", name, nameValue, URL);
1177             else
1178                 xmlGenericError(xmlGenericErrorContext,
1179                         "Found %s: '%s'\n", name, URL);
1180         }
1181         ret = xmlNewCatalogEntry(type, nameValue, uriValue, URL, prefer, cgroup);
1182     } else {
1183         xmlCatalogErr(ret, cur, XML_CATALOG_ENTRY_BROKEN,
1184                 "%s entry '%s' broken ?: %s\n", name, uriAttrName, uriValue);
1185     }
1186     if (nameValue != NULL)
1187         xmlFree(nameValue);
1188     if (uriValue != NULL)
1189         xmlFree(uriValue);
1190     if (base != NULL)
1191         xmlFree(base);
1192     if (URL != NULL)
1193         xmlFree(URL);
1194     return(ret);
1195 }
1196
1197 /**
1198  * xmlParseXMLCatalogNode:
1199  * @cur:  the XML node
1200  * @prefer:  the PUBLIC vs. SYSTEM current preference value
1201  * @parent:  the parent Catalog entry
1202  * @cgroup:  the group which includes this node
1203  *
1204  * Examines an XML tree node of a catalog and build
1205  * a Catalog entry from it adding it to its parent. The examination can
1206  * be recursive.
1207  */
1208 static void
1209 xmlParseXMLCatalogNode(xmlNodePtr cur, xmlCatalogPrefer prefer,
1210                        xmlCatalogEntryPtr parent, xmlCatalogEntryPtr cgroup)
1211 {
1212     xmlChar *base = NULL;
1213     xmlCatalogEntryPtr entry = NULL;
1214
1215     if (cur == NULL)
1216         return;
1217     if (xmlStrEqual(cur->name, BAD_CAST "group")) {
1218         xmlChar *prop;
1219         xmlCatalogPrefer pref = XML_CATA_PREFER_NONE;
1220
1221         prop = xmlGetProp(cur, BAD_CAST "prefer");
1222         if (prop != NULL) {
1223             if (xmlStrEqual(prop, BAD_CAST "system")) {
1224                 prefer = XML_CATA_PREFER_SYSTEM;
1225             } else if (xmlStrEqual(prop, BAD_CAST "public")) {
1226                 prefer = XML_CATA_PREFER_PUBLIC;
1227             } else {
1228                 xmlCatalogErr(parent, cur, XML_CATALOG_PREFER_VALUE,
1229                               "Invalid value for prefer: '%s'\n",
1230                               prop, NULL, NULL);
1231             }
1232             xmlFree(prop);
1233             pref = prefer;
1234         }
1235         prop = xmlGetProp(cur, BAD_CAST "id");
1236         base = xmlGetNsProp(cur, BAD_CAST "base", XML_XML_NAMESPACE);
1237         entry = xmlNewCatalogEntry(XML_CATA_GROUP, prop, base, NULL, pref, cgroup);
1238         xmlFree(prop);
1239     } else if (xmlStrEqual(cur->name, BAD_CAST "public")) {
1240         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_PUBLIC,
1241                 BAD_CAST "public", BAD_CAST "publicId", BAD_CAST "uri", prefer, cgroup);
1242     } else if (xmlStrEqual(cur->name, BAD_CAST "system")) {
1243         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_SYSTEM,
1244                 BAD_CAST "system", BAD_CAST "systemId", BAD_CAST "uri", prefer, cgroup);
1245     } else if (xmlStrEqual(cur->name, BAD_CAST "rewriteSystem")) {
1246         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_REWRITE_SYSTEM,
1247                 BAD_CAST "rewriteSystem", BAD_CAST "systemIdStartString",
1248                 BAD_CAST "rewritePrefix", prefer, cgroup);
1249     } else if (xmlStrEqual(cur->name, BAD_CAST "delegatePublic")) {
1250         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_PUBLIC,
1251                 BAD_CAST "delegatePublic", BAD_CAST "publicIdStartString",
1252                 BAD_CAST "catalog", prefer, cgroup);
1253     } else if (xmlStrEqual(cur->name, BAD_CAST "delegateSystem")) {
1254         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_SYSTEM,
1255                 BAD_CAST "delegateSystem", BAD_CAST "systemIdStartString",
1256                 BAD_CAST "catalog", prefer, cgroup);
1257     } else if (xmlStrEqual(cur->name, BAD_CAST "uri")) {
1258         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_URI,
1259                 BAD_CAST "uri", BAD_CAST "name",
1260                 BAD_CAST "uri", prefer, cgroup);
1261     } else if (xmlStrEqual(cur->name, BAD_CAST "rewriteURI")) {
1262         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_REWRITE_URI,
1263                 BAD_CAST "rewriteURI", BAD_CAST "uriStartString",
1264                 BAD_CAST "rewritePrefix", prefer, cgroup);
1265     } else if (xmlStrEqual(cur->name, BAD_CAST "delegateURI")) {
1266         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_URI,
1267                 BAD_CAST "delegateURI", BAD_CAST "uriStartString",
1268                 BAD_CAST "catalog", prefer, cgroup);
1269     } else if (xmlStrEqual(cur->name, BAD_CAST "nextCatalog")) {
1270         entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_NEXT_CATALOG,
1271                 BAD_CAST "nextCatalog", NULL,
1272                 BAD_CAST "catalog", prefer, cgroup);
1273     }
1274     if (entry != NULL) {
1275         if (parent != NULL) {
1276             entry->parent = parent;
1277             if (parent->children == NULL)
1278                 parent->children = entry;
1279             else {
1280                 xmlCatalogEntryPtr prev;
1281
1282                 prev = parent->children;
1283                 while (prev->next != NULL)
1284                     prev = prev->next;
1285                 prev->next = entry;
1286             }
1287         }
1288         if (entry->type == XML_CATA_GROUP) {
1289             /*
1290              * Recurse to propagate prefer to the subtree
1291              * (xml:base handling is automated)
1292              */
1293             xmlParseXMLCatalogNodeList(cur->children, prefer, parent, entry);
1294         }
1295     }
1296     if (base != NULL)
1297         xmlFree(base);
1298 }
1299
1300 /**
1301  * xmlParseXMLCatalogNodeList:
1302  * @cur:  the XML node list of siblings
1303  * @prefer:  the PUBLIC vs. SYSTEM current preference value
1304  * @parent:  the parent Catalog entry
1305  * @cgroup:  the group which includes this list
1306  *
1307  * Examines a list of XML sibling nodes of a catalog and build
1308  * a list of Catalog entry from it adding it to the parent.
1309  * The examination will recurse to examine node subtrees.
1310  */
1311 static void
1312 xmlParseXMLCatalogNodeList(xmlNodePtr cur, xmlCatalogPrefer prefer,
1313                            xmlCatalogEntryPtr parent, xmlCatalogEntryPtr cgroup) {
1314     while (cur != NULL) {
1315         if ((cur->ns != NULL) && (cur->ns->href != NULL) &&
1316             (xmlStrEqual(cur->ns->href, XML_CATALOGS_NAMESPACE))) {
1317             xmlParseXMLCatalogNode(cur, prefer, parent, cgroup);
1318         }
1319         cur = cur->next;
1320     }
1321     /* TODO: sort the list according to REWRITE lengths and prefer value */
1322 }
1323
1324 /**
1325  * xmlParseXMLCatalogFile:
1326  * @prefer:  the PUBLIC vs. SYSTEM current preference value
1327  * @filename:  the filename for the catalog
1328  *
1329  * Parses the catalog file to extract the XML tree and then analyze the
1330  * tree to build a list of Catalog entries corresponding to this catalog
1331  *
1332  * Returns the resulting Catalog entries list
1333  */
1334 static xmlCatalogEntryPtr
1335 xmlParseXMLCatalogFile(xmlCatalogPrefer prefer, const xmlChar *filename) {
1336     xmlDocPtr doc;
1337     xmlNodePtr cur;
1338     xmlChar *prop;
1339     xmlCatalogEntryPtr parent = NULL;
1340
1341     if (filename == NULL)
1342         return(NULL);
1343
1344     doc = xmlParseCatalogFile((const char *) filename);
1345     if (doc == NULL) {
1346         if (xmlDebugCatalogs)
1347             xmlGenericError(xmlGenericErrorContext,
1348                     "Failed to parse catalog %s\n", filename);
1349         return(NULL);
1350     }
1351
1352     if (xmlDebugCatalogs)
1353         xmlGenericError(xmlGenericErrorContext,
1354                 "%d Parsing catalog %s\n", xmlGetThreadId(), filename);
1355
1356     cur = xmlDocGetRootElement(doc);
1357     if ((cur != NULL) && (xmlStrEqual(cur->name, BAD_CAST "catalog")) &&
1358         (cur->ns != NULL) && (cur->ns->href != NULL) &&
1359         (xmlStrEqual(cur->ns->href, XML_CATALOGS_NAMESPACE))) {
1360
1361         parent = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
1362                                     (const xmlChar *)filename, NULL, prefer, NULL);
1363         if (parent == NULL) {
1364             xmlFreeDoc(doc);
1365             return(NULL);
1366         }
1367
1368         prop = xmlGetProp(cur, BAD_CAST "prefer");
1369         if (prop != NULL) {
1370             if (xmlStrEqual(prop, BAD_CAST "system")) {
1371                 prefer = XML_CATA_PREFER_SYSTEM;
1372             } else if (xmlStrEqual(prop, BAD_CAST "public")) {
1373                 prefer = XML_CATA_PREFER_PUBLIC;
1374             } else {
1375                 xmlCatalogErr(NULL, cur, XML_CATALOG_PREFER_VALUE,
1376                               "Invalid value for prefer: '%s'\n",
1377                               prop, NULL, NULL);
1378             }
1379             xmlFree(prop);
1380         }
1381         cur = cur->children;
1382         xmlParseXMLCatalogNodeList(cur, prefer, parent, NULL);
1383     } else {
1384         xmlCatalogErr(NULL, (xmlNodePtr) doc, XML_CATALOG_NOT_CATALOG,
1385                       "File %s is not an XML Catalog\n",
1386                       filename, NULL, NULL);
1387         xmlFreeDoc(doc);
1388         return(NULL);
1389     }
1390     xmlFreeDoc(doc);
1391     return(parent);
1392 }
1393
1394 /**
1395  * xmlFetchXMLCatalogFile:
1396  * @catal:  an existing but incomplete catalog entry
1397  *
1398  * Fetch and parse the subcatalog referenced by an entry
1399  *
1400  * Returns 0 in case of success, -1 otherwise
1401  */
1402 static int
1403 xmlFetchXMLCatalogFile(xmlCatalogEntryPtr catal) {
1404     xmlCatalogEntryPtr doc;
1405
1406     if (catal == NULL)
1407         return(-1);
1408     if (catal->URL == NULL)
1409         return(-1);
1410     if (catal->children != NULL)
1411         return(-1);
1412
1413     /*
1414      * lock the whole catalog for modification
1415      */
1416     xmlRMutexLock(xmlCatalogMutex);
1417     if (catal->children != NULL) {
1418         /* Okay someone else did it in the meantime */
1419         xmlRMutexUnlock(xmlCatalogMutex);
1420         return(0);
1421     }
1422
1423     if (xmlCatalogXMLFiles != NULL) {
1424         doc = (xmlCatalogEntryPtr)
1425             xmlHashLookup(xmlCatalogXMLFiles, catal->URL);
1426         if (doc != NULL) {
1427             if (xmlDebugCatalogs)
1428                 xmlGenericError(xmlGenericErrorContext,
1429                     "Found %s in file hash\n", catal->URL);
1430
1431             if (catal->type == XML_CATA_CATALOG)
1432                 catal->children = doc->children;
1433             else
1434                 catal->children = doc;
1435             catal->dealloc = 0;
1436             xmlRMutexUnlock(xmlCatalogMutex);
1437             return(0);
1438         }
1439         if (xmlDebugCatalogs)
1440             xmlGenericError(xmlGenericErrorContext,
1441                 "%s not found in file hash\n", catal->URL);
1442     }
1443
1444     /*
1445      * Fetch and parse. Note that xmlParseXMLCatalogFile does not
1446      * use the existing catalog, there is no recursion allowed at
1447      * that level.
1448      */
1449     doc = xmlParseXMLCatalogFile(catal->prefer, catal->URL);
1450     if (doc == NULL) {
1451         catal->type = XML_CATA_BROKEN_CATALOG;
1452         xmlRMutexUnlock(xmlCatalogMutex);
1453         return(-1);
1454     }
1455
1456     if (catal->type == XML_CATA_CATALOG)
1457         catal->children = doc->children;
1458     else
1459         catal->children = doc;
1460
1461     doc->dealloc = 1;
1462
1463     if (xmlCatalogXMLFiles == NULL)
1464         xmlCatalogXMLFiles = xmlHashCreate(10);
1465     if (xmlCatalogXMLFiles != NULL) {
1466         if (xmlDebugCatalogs)
1467             xmlGenericError(xmlGenericErrorContext,
1468                 "%s added to file hash\n", catal->URL);
1469         xmlHashAddEntry(xmlCatalogXMLFiles, catal->URL, doc);
1470     }
1471     xmlRMutexUnlock(xmlCatalogMutex);
1472     return(0);
1473 }
1474
1475 /************************************************************************
1476  *                                                                      *
1477  *                      XML Catalog handling                            *
1478  *                                                                      *
1479  ************************************************************************/
1480
1481 /**
1482  * xmlAddXMLCatalog:
1483  * @catal:  top of an XML catalog
1484  * @type:  the type of record to add to the catalog
1485  * @orig:  the system, public or prefix to match (or NULL)
1486  * @replace:  the replacement value for the match
1487  *
1488  * Add an entry in the XML catalog, it may overwrite existing but
1489  * different entries.
1490  *
1491  * Returns 0 if successful, -1 otherwise
1492  */
1493 static int
1494 xmlAddXMLCatalog(xmlCatalogEntryPtr catal, const xmlChar *type,
1495               const xmlChar *orig, const xmlChar *replace) {
1496     xmlCatalogEntryPtr cur;
1497     xmlCatalogEntryType typ;
1498     int doregister = 0;
1499
1500     if ((catal == NULL) ||
1501         ((catal->type != XML_CATA_CATALOG) &&
1502          (catal->type != XML_CATA_BROKEN_CATALOG)))
1503         return(-1);
1504     if (catal->children == NULL) {
1505         xmlFetchXMLCatalogFile(catal);
1506     }
1507     if (catal->children == NULL)
1508         doregister = 1;
1509
1510     typ = xmlGetXMLCatalogEntryType(type);
1511     if (typ == XML_CATA_NONE) {
1512         if (xmlDebugCatalogs)
1513             xmlGenericError(xmlGenericErrorContext,
1514                     "Failed to add unknown element %s to catalog\n", type);
1515         return(-1);
1516     }
1517
1518     cur = catal->children;
1519     /*
1520      * Might be a simple "update in place"
1521      */
1522     if (cur != NULL) {
1523         while (cur != NULL) {
1524             if ((orig != NULL) && (cur->type == typ) &&
1525                 (xmlStrEqual(orig, cur->name))) {
1526                 if (xmlDebugCatalogs)
1527                     xmlGenericError(xmlGenericErrorContext,
1528                             "Updating element %s to catalog\n", type);
1529                 if (cur->value != NULL)
1530                     xmlFree(cur->value);
1531                 if (cur->URL != NULL)
1532                     xmlFree(cur->URL);
1533                 cur->value = xmlStrdup(replace);
1534                 cur->URL = xmlStrdup(replace);
1535                 return(0);
1536             }
1537             if (cur->next == NULL)
1538                 break;
1539             cur = cur->next;
1540         }
1541     }
1542     if (xmlDebugCatalogs)
1543         xmlGenericError(xmlGenericErrorContext,
1544                 "Adding element %s to catalog\n", type);
1545     if (cur == NULL)
1546         catal->children = xmlNewCatalogEntry(typ, orig, replace,
1547                                              NULL, catal->prefer, NULL);
1548     else
1549         cur->next = xmlNewCatalogEntry(typ, orig, replace,
1550                                        NULL, catal->prefer, NULL);
1551     if (doregister) {
1552         catal->type = XML_CATA_CATALOG;
1553         cur = xmlHashLookup(xmlCatalogXMLFiles, catal->URL);
1554         if (cur != NULL)
1555             cur->children = catal->children;
1556     }
1557
1558     return(0);
1559 }
1560
1561 /**
1562  * xmlDelXMLCatalog:
1563  * @catal:  top of an XML catalog
1564  * @value:  the value to remove from the catalog
1565  *
1566  * Remove entries in the XML catalog where the value or the URI
1567  * is equal to @value
1568  *
1569  * Returns the number of entries removed if successful, -1 otherwise
1570  */
1571 static int
1572 xmlDelXMLCatalog(xmlCatalogEntryPtr catal, const xmlChar *value) {
1573     xmlCatalogEntryPtr cur;
1574     int ret = 0;
1575
1576     if ((catal == NULL) ||
1577         ((catal->type != XML_CATA_CATALOG) &&
1578          (catal->type != XML_CATA_BROKEN_CATALOG)))
1579         return(-1);
1580     if (value == NULL)
1581         return(-1);
1582     if (catal->children == NULL) {
1583         xmlFetchXMLCatalogFile(catal);
1584     }
1585
1586     /*
1587      * Scan the children
1588      */
1589     cur = catal->children;
1590     while (cur != NULL) {
1591         if (((cur->name != NULL) && (xmlStrEqual(value, cur->name))) ||
1592             (xmlStrEqual(value, cur->value))) {
1593             if (xmlDebugCatalogs) {
1594                 if (cur->name != NULL)
1595                     xmlGenericError(xmlGenericErrorContext,
1596                             "Removing element %s from catalog\n", cur->name);
1597                 else
1598                     xmlGenericError(xmlGenericErrorContext,
1599                             "Removing element %s from catalog\n", cur->value);
1600             }
1601             cur->type = XML_CATA_REMOVED;
1602         }
1603         cur = cur->next;
1604     }
1605     return(ret);
1606 }
1607
1608 /**
1609  * xmlCatalogXMLResolve:
1610  * @catal:  a catalog list
1611  * @pubID:  the public ID string
1612  * @sysID:  the system ID string
1613  *
1614  * Do a complete resolution lookup of an External Identifier for a
1615  * list of catalog entries.
1616  *
1617  * Implements (or tries to) 7.1. External Identifier Resolution
1618  * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
1619  *
1620  * Returns the URI of the resource or NULL if not found
1621  */
1622 static xmlChar *
1623 xmlCatalogXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
1624                       const xmlChar *sysID) {
1625     xmlChar *ret = NULL;
1626     xmlCatalogEntryPtr cur;
1627     int haveDelegate = 0;
1628     int haveNext = 0;
1629
1630     /*
1631      * protection against loops
1632      */
1633     if (catal->depth > MAX_CATAL_DEPTH) {
1634         xmlCatalogErr(catal, NULL, XML_CATALOG_RECURSION,
1635                       "Detected recursion in catalog %s\n",
1636                       catal->name, NULL, NULL);
1637         return(NULL);
1638     }
1639     catal->depth++;
1640
1641     /*
1642      * First tries steps 2/ 3/ 4/ if a system ID is provided.
1643      */
1644     if (sysID != NULL) {
1645         xmlCatalogEntryPtr rewrite = NULL;
1646         int lenrewrite = 0, len;
1647         cur = catal;
1648         haveDelegate = 0;
1649         while (cur != NULL) {
1650             switch (cur->type) {
1651                 case XML_CATA_SYSTEM:
1652                     if (xmlStrEqual(sysID, cur->name)) {
1653                         if (xmlDebugCatalogs)
1654                             xmlGenericError(xmlGenericErrorContext,
1655                                     "Found system match %s, using %s\n",
1656                                             cur->name, cur->URL);
1657                         catal->depth--;
1658                         return(xmlStrdup(cur->URL));
1659                     }
1660                     break;
1661                 case XML_CATA_REWRITE_SYSTEM:
1662                     len = xmlStrlen(cur->name);
1663                     if ((len > lenrewrite) &&
1664                         (!xmlStrncmp(sysID, cur->name, len))) {
1665                         lenrewrite = len;
1666                         rewrite = cur;
1667                     }
1668                     break;
1669                 case XML_CATA_DELEGATE_SYSTEM:
1670                     if (!xmlStrncmp(sysID, cur->name, xmlStrlen(cur->name)))
1671                         haveDelegate++;
1672                     break;
1673                 case XML_CATA_NEXT_CATALOG:
1674                     haveNext++;
1675                     break;
1676                 default:
1677                     break;
1678             }
1679             cur = cur->next;
1680         }
1681         if (rewrite != NULL) {
1682             if (xmlDebugCatalogs)
1683                 xmlGenericError(xmlGenericErrorContext,
1684                         "Using rewriting rule %s\n", rewrite->name);
1685             ret = xmlStrdup(rewrite->URL);
1686             if (ret != NULL)
1687                 ret = xmlStrcat(ret, &sysID[lenrewrite]);
1688             catal->depth--;
1689             return(ret);
1690         }
1691         if (haveDelegate) {
1692             const xmlChar *delegates[MAX_DELEGATE];
1693             int nbList = 0, i;
1694
1695             /*
1696              * Assume the entries have been sorted by decreasing substring
1697              * matches when the list was produced.
1698              */
1699             cur = catal;
1700             while (cur != NULL) {
1701                 if ((cur->type == XML_CATA_DELEGATE_SYSTEM) &&
1702                     (!xmlStrncmp(sysID, cur->name, xmlStrlen(cur->name)))) {
1703                     for (i = 0;i < nbList;i++)
1704                         if (xmlStrEqual(cur->URL, delegates[i]))
1705                             break;
1706                     if (i < nbList) {
1707                         cur = cur->next;
1708                         continue;
1709                     }
1710                     if (nbList < MAX_DELEGATE)
1711                         delegates[nbList++] = cur->URL;
1712
1713                     if (cur->children == NULL) {
1714                         xmlFetchXMLCatalogFile(cur);
1715                     }
1716                     if (cur->children != NULL) {
1717                         if (xmlDebugCatalogs)
1718                             xmlGenericError(xmlGenericErrorContext,
1719                                     "Trying system delegate %s\n", cur->URL);
1720                         ret = xmlCatalogListXMLResolve(
1721                                 cur->children, NULL, sysID);
1722                         if (ret != NULL) {
1723                             catal->depth--;
1724                             return(ret);
1725                         }
1726                     }
1727                 }
1728                 cur = cur->next;
1729             }
1730             /*
1731              * Apply the cut algorithm explained in 4/
1732              */
1733             catal->depth--;
1734             return(XML_CATAL_BREAK);
1735         }
1736     }
1737     /*
1738      * Then tries 5/ 6/ if a public ID is provided
1739      */
1740     if (pubID != NULL) {
1741         cur = catal;
1742         haveDelegate = 0;
1743         while (cur != NULL) {
1744             switch (cur->type) {
1745                 case XML_CATA_PUBLIC:
1746                     if (xmlStrEqual(pubID, cur->name)) {
1747                         if (xmlDebugCatalogs)
1748                             xmlGenericError(xmlGenericErrorContext,
1749                                     "Found public match %s\n", cur->name);
1750                         catal->depth--;
1751                         return(xmlStrdup(cur->URL));
1752                     }
1753                     break;
1754                 case XML_CATA_DELEGATE_PUBLIC:
1755                     if (!xmlStrncmp(pubID, cur->name, xmlStrlen(cur->name)) &&
1756                         (cur->prefer == XML_CATA_PREFER_PUBLIC))
1757                         haveDelegate++;
1758                     break;
1759                 case XML_CATA_NEXT_CATALOG:
1760                     if (sysID == NULL)
1761                         haveNext++;
1762                     break;
1763                 default:
1764                     break;
1765             }
1766             cur = cur->next;
1767         }
1768         if (haveDelegate) {
1769             const xmlChar *delegates[MAX_DELEGATE];
1770             int nbList = 0, i;
1771
1772             /*
1773              * Assume the entries have been sorted by decreasing substring
1774              * matches when the list was produced.
1775              */
1776             cur = catal;
1777             while (cur != NULL) {
1778                 if ((cur->type == XML_CATA_DELEGATE_PUBLIC) &&
1779                     (cur->prefer == XML_CATA_PREFER_PUBLIC) &&
1780                     (!xmlStrncmp(pubID, cur->name, xmlStrlen(cur->name)))) {
1781
1782                     for (i = 0;i < nbList;i++)
1783                         if (xmlStrEqual(cur->URL, delegates[i]))
1784                             break;
1785                     if (i < nbList) {
1786                         cur = cur->next;
1787                         continue;
1788                     }
1789                     if (nbList < MAX_DELEGATE)
1790                         delegates[nbList++] = cur->URL;
1791
1792                     if (cur->children == NULL) {
1793                         xmlFetchXMLCatalogFile(cur);
1794                     }
1795                     if (cur->children != NULL) {
1796                         if (xmlDebugCatalogs)
1797                             xmlGenericError(xmlGenericErrorContext,
1798                                     "Trying public delegate %s\n", cur->URL);
1799                         ret = xmlCatalogListXMLResolve(
1800                                 cur->children, pubID, NULL);
1801                         if (ret != NULL) {
1802                             catal->depth--;
1803                             return(ret);
1804                         }
1805                     }
1806                 }
1807                 cur = cur->next;
1808             }
1809             /*
1810              * Apply the cut algorithm explained in 4/
1811              */
1812             catal->depth--;
1813             return(XML_CATAL_BREAK);
1814         }
1815     }
1816     if (haveNext) {
1817         cur = catal;
1818         while (cur != NULL) {
1819             if (cur->type == XML_CATA_NEXT_CATALOG) {
1820                 if (cur->children == NULL) {
1821                     xmlFetchXMLCatalogFile(cur);
1822                 }
1823                 if (cur->children != NULL) {
1824                     ret = xmlCatalogListXMLResolve(cur->children, pubID, sysID);
1825                     if (ret != NULL) {
1826                         catal->depth--;
1827                         return(ret);
1828                     } else if (catal->depth > MAX_CATAL_DEPTH) {
1829                         return(NULL);
1830                     }
1831                 }
1832             }
1833             cur = cur->next;
1834         }
1835     }
1836
1837     catal->depth--;
1838     return(NULL);
1839 }
1840
1841 /**
1842  * xmlCatalogXMLResolveURI:
1843  * @catal:  a catalog list
1844  * @URI:  the URI
1845  * @sysID:  the system ID string
1846  *
1847  * Do a complete resolution lookup of an External Identifier for a
1848  * list of catalog entries.
1849  *
1850  * Implements (or tries to) 7.2.2. URI Resolution
1851  * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
1852  *
1853  * Returns the URI of the resource or NULL if not found
1854  */
1855 static xmlChar *
1856 xmlCatalogXMLResolveURI(xmlCatalogEntryPtr catal, const xmlChar *URI) {
1857     xmlChar *ret = NULL;
1858     xmlCatalogEntryPtr cur;
1859     int haveDelegate = 0;
1860     int haveNext = 0;
1861     xmlCatalogEntryPtr rewrite = NULL;
1862     int lenrewrite = 0, len;
1863
1864     if (catal == NULL)
1865         return(NULL);
1866
1867     if (URI == NULL)
1868         return(NULL);
1869
1870     if (catal->depth > MAX_CATAL_DEPTH) {
1871         xmlCatalogErr(catal, NULL, XML_CATALOG_RECURSION,
1872                       "Detected recursion in catalog %s\n",
1873                       catal->name, NULL, NULL);
1874         return(NULL);
1875     }
1876
1877     /*
1878      * First tries steps 2/ 3/ 4/ if a system ID is provided.
1879      */
1880     cur = catal;
1881     haveDelegate = 0;
1882     while (cur != NULL) {
1883         switch (cur->type) {
1884             case XML_CATA_URI:
1885                 if (xmlStrEqual(URI, cur->name)) {
1886                     if (xmlDebugCatalogs)
1887                         xmlGenericError(xmlGenericErrorContext,
1888                                 "Found URI match %s\n", cur->name);
1889                     return(xmlStrdup(cur->URL));
1890                 }
1891                 break;
1892             case XML_CATA_REWRITE_URI:
1893                 len = xmlStrlen(cur->name);
1894                 if ((len > lenrewrite) &&
1895                     (!xmlStrncmp(URI, cur->name, len))) {
1896                     lenrewrite = len;
1897                     rewrite = cur;
1898                 }
1899                 break;
1900             case XML_CATA_DELEGATE_URI:
1901                 if (!xmlStrncmp(URI, cur->name, xmlStrlen(cur->name)))
1902                     haveDelegate++;
1903                 break;
1904             case XML_CATA_NEXT_CATALOG:
1905                 haveNext++;
1906                 break;
1907             default:
1908                 break;
1909         }
1910         cur = cur->next;
1911     }
1912     if (rewrite != NULL) {
1913         if (xmlDebugCatalogs)
1914             xmlGenericError(xmlGenericErrorContext,
1915                     "Using rewriting rule %s\n", rewrite->name);
1916         ret = xmlStrdup(rewrite->URL);
1917         if (ret != NULL)
1918             ret = xmlStrcat(ret, &URI[lenrewrite]);
1919         return(ret);
1920     }
1921     if (haveDelegate) {
1922         const xmlChar *delegates[MAX_DELEGATE];
1923         int nbList = 0, i;
1924
1925         /*
1926          * Assume the entries have been sorted by decreasing substring
1927          * matches when the list was produced.
1928          */
1929         cur = catal;
1930         while (cur != NULL) {
1931             if (((cur->type == XML_CATA_DELEGATE_SYSTEM) ||
1932                  (cur->type == XML_CATA_DELEGATE_URI)) &&
1933                 (!xmlStrncmp(URI, cur->name, xmlStrlen(cur->name)))) {
1934                 for (i = 0;i < nbList;i++)
1935                     if (xmlStrEqual(cur->URL, delegates[i]))
1936                         break;
1937                 if (i < nbList) {
1938                     cur = cur->next;
1939                     continue;
1940                 }
1941                 if (nbList < MAX_DELEGATE)
1942                     delegates[nbList++] = cur->URL;
1943
1944                 if (cur->children == NULL) {
1945                     xmlFetchXMLCatalogFile(cur);
1946                 }
1947                 if (cur->children != NULL) {
1948                     if (xmlDebugCatalogs)
1949                         xmlGenericError(xmlGenericErrorContext,
1950                                 "Trying URI delegate %s\n", cur->URL);
1951                     ret = xmlCatalogListXMLResolveURI(
1952                             cur->children, URI);
1953                     if (ret != NULL)
1954                         return(ret);
1955                 }
1956             }
1957             cur = cur->next;
1958         }
1959         /*
1960          * Apply the cut algorithm explained in 4/
1961          */
1962         return(XML_CATAL_BREAK);
1963     }
1964     if (haveNext) {
1965         cur = catal;
1966         while (cur != NULL) {
1967             if (cur->type == XML_CATA_NEXT_CATALOG) {
1968                 if (cur->children == NULL) {
1969                     xmlFetchXMLCatalogFile(cur);
1970                 }
1971                 if (cur->children != NULL) {
1972                     ret = xmlCatalogListXMLResolveURI(cur->children, URI);
1973                     if (ret != NULL)
1974                         return(ret);
1975                 }
1976             }
1977             cur = cur->next;
1978         }
1979     }
1980
1981     return(NULL);
1982 }
1983
1984 /**
1985  * xmlCatalogListXMLResolve:
1986  * @catal:  a catalog list
1987  * @pubID:  the public ID string
1988  * @sysID:  the system ID string
1989  *
1990  * Do a complete resolution lookup of an External Identifier for a
1991  * list of catalogs
1992  *
1993  * Implements (or tries to) 7.1. External Identifier Resolution
1994  * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
1995  *
1996  * Returns the URI of the resource or NULL if not found
1997  */
1998 static xmlChar *
1999 xmlCatalogListXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
2000                       const xmlChar *sysID) {
2001     xmlChar *ret = NULL;
2002     xmlChar *urnID = NULL;
2003     xmlChar *normid;
2004
2005     if (catal == NULL)
2006         return(NULL);
2007     if ((pubID == NULL) && (sysID == NULL))
2008         return(NULL);
2009
2010     normid = xmlCatalogNormalizePublic(pubID);
2011     if (normid != NULL)
2012         pubID = (*normid != 0 ? normid : NULL);
2013
2014     if (!xmlStrncmp(pubID, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
2015         urnID = xmlCatalogUnWrapURN(pubID);
2016         if (xmlDebugCatalogs) {
2017             if (urnID == NULL)
2018                 xmlGenericError(xmlGenericErrorContext,
2019                         "Public URN ID %s expanded to NULL\n", pubID);
2020             else
2021                 xmlGenericError(xmlGenericErrorContext,
2022                         "Public URN ID expanded to %s\n", urnID);
2023         }
2024         ret = xmlCatalogListXMLResolve(catal, urnID, sysID);
2025         if (urnID != NULL)
2026             xmlFree(urnID);
2027         if (normid != NULL)
2028             xmlFree(normid);
2029         return(ret);
2030     }
2031     if (!xmlStrncmp(sysID, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
2032         urnID = xmlCatalogUnWrapURN(sysID);
2033         if (xmlDebugCatalogs) {
2034             if (urnID == NULL)
2035                 xmlGenericError(xmlGenericErrorContext,
2036                         "System URN ID %s expanded to NULL\n", sysID);
2037             else
2038                 xmlGenericError(xmlGenericErrorContext,
2039                         "System URN ID expanded to %s\n", urnID);
2040         }
2041         if (pubID == NULL)
2042             ret = xmlCatalogListXMLResolve(catal, urnID, NULL);
2043         else if (xmlStrEqual(pubID, urnID))
2044             ret = xmlCatalogListXMLResolve(catal, pubID, NULL);
2045         else {
2046             ret = xmlCatalogListXMLResolve(catal, pubID, urnID);
2047         }
2048         if (urnID != NULL)
2049             xmlFree(urnID);
2050         if (normid != NULL)
2051             xmlFree(normid);
2052         return(ret);
2053     }
2054     while (catal != NULL) {
2055         if (catal->type == XML_CATA_CATALOG) {
2056             if (catal->children == NULL) {
2057                 xmlFetchXMLCatalogFile(catal);
2058             }
2059             if (catal->children != NULL) {
2060                 ret = xmlCatalogXMLResolve(catal->children, pubID, sysID);
2061                 if (ret != NULL) {
2062                     break;
2063                 } else if ((catal->children != NULL) &&
2064                            (catal->children->depth > MAX_CATAL_DEPTH)) {
2065                     ret = NULL;
2066                     break;
2067                 }
2068             }
2069         }
2070         catal = catal->next;
2071     }
2072     if (normid != NULL)
2073         xmlFree(normid);
2074     return(ret);
2075 }
2076
2077 /**
2078  * xmlCatalogListXMLResolveURI:
2079  * @catal:  a catalog list
2080  * @URI:  the URI
2081  *
2082  * Do a complete resolution lookup of an URI for a list of catalogs
2083  *
2084  * Implements (or tries to) 7.2. URI Resolution
2085  * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
2086  *
2087  * Returns the URI of the resource or NULL if not found
2088  */
2089 static xmlChar *
2090 xmlCatalogListXMLResolveURI(xmlCatalogEntryPtr catal, const xmlChar *URI) {
2091     xmlChar *ret = NULL;
2092     xmlChar *urnID = NULL;
2093
2094     if (catal == NULL)
2095         return(NULL);
2096     if (URI == NULL)
2097         return(NULL);
2098
2099     if (!xmlStrncmp(URI, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
2100         urnID = xmlCatalogUnWrapURN(URI);
2101         if (xmlDebugCatalogs) {
2102             if (urnID == NULL)
2103                 xmlGenericError(xmlGenericErrorContext,
2104                         "URN ID %s expanded to NULL\n", URI);
2105             else
2106                 xmlGenericError(xmlGenericErrorContext,
2107                         "URN ID expanded to %s\n", urnID);
2108         }
2109         ret = xmlCatalogListXMLResolve(catal, urnID, NULL);
2110         if (urnID != NULL)
2111             xmlFree(urnID);
2112         return(ret);
2113     }
2114     while (catal != NULL) {
2115         if (catal->type == XML_CATA_CATALOG) {
2116             if (catal->children == NULL) {
2117                 xmlFetchXMLCatalogFile(catal);
2118             }
2119             if (catal->children != NULL) {
2120                 ret = xmlCatalogXMLResolveURI(catal->children, URI);
2121                 if (ret != NULL)
2122                     return(ret);
2123             }
2124         }
2125         catal = catal->next;
2126     }
2127     return(ret);
2128 }
2129
2130 /************************************************************************
2131  *                                                                      *
2132  *                      The SGML Catalog parser                         *
2133  *                                                                      *
2134  ************************************************************************/
2135
2136
2137 #define RAW *cur
2138 #define NEXT cur++;
2139 #define SKIP(x) cur += x;
2140
2141 #define SKIP_BLANKS while (IS_BLANK_CH(*cur)) NEXT;
2142
2143 /**
2144  * xmlParseSGMLCatalogComment:
2145  * @cur:  the current character
2146  *
2147  * Skip a comment in an SGML catalog
2148  *
2149  * Returns new current character
2150  */
2151 static const xmlChar *
2152 xmlParseSGMLCatalogComment(const xmlChar *cur) {
2153     if ((cur[0] != '-') || (cur[1] != '-'))
2154         return(cur);
2155     SKIP(2);
2156     while ((cur[0] != 0) && ((cur[0] != '-') || ((cur[1] != '-'))))
2157         NEXT;
2158     if (cur[0] == 0) {
2159         return(NULL);
2160     }
2161     return(cur + 2);
2162 }
2163
2164 /**
2165  * xmlParseSGMLCatalogPubid:
2166  * @cur:  the current character
2167  * @id:  the return location
2168  *
2169  * Parse an SGML catalog ID
2170  *
2171  * Returns new current character and store the value in @id
2172  */
2173 static const xmlChar *
2174 xmlParseSGMLCatalogPubid(const xmlChar *cur, xmlChar **id) {
2175     xmlChar *buf = NULL, *tmp;
2176     int len = 0;
2177     int size = 50;
2178     xmlChar stop;
2179     int count = 0;
2180
2181     *id = NULL;
2182
2183     if (RAW == '"') {
2184         NEXT;
2185         stop = '"';
2186     } else if (RAW == '\'') {
2187         NEXT;
2188         stop = '\'';
2189     } else {
2190         stop = ' ';
2191     }
2192     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
2193     if (buf == NULL) {
2194         xmlCatalogErrMemory("allocating public ID");
2195         return(NULL);
2196     }
2197     while (IS_PUBIDCHAR_CH(*cur) || (*cur == '?')) {
2198         if ((*cur == stop) && (stop != ' '))
2199             break;
2200         if ((stop == ' ') && (IS_BLANK_CH(*cur)))
2201             break;
2202         if (len + 1 >= size) {
2203             size *= 2;
2204             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
2205             if (tmp == NULL) {
2206                 xmlCatalogErrMemory("allocating public ID");
2207                 xmlFree(buf);
2208                 return(NULL);
2209             }
2210             buf = tmp;
2211         }
2212         buf[len++] = *cur;
2213         count++;
2214         NEXT;
2215     }
2216     buf[len] = 0;
2217     if (stop == ' ') {
2218         if (!IS_BLANK_CH(*cur)) {
2219             xmlFree(buf);
2220             return(NULL);
2221         }
2222     } else {
2223         if (*cur != stop) {
2224             xmlFree(buf);
2225             return(NULL);
2226         }
2227         NEXT;
2228     }
2229     *id = buf;
2230     return(cur);
2231 }
2232
2233 /**
2234  * xmlParseSGMLCatalogName:
2235  * @cur:  the current character
2236  * @name:  the return location
2237  *
2238  * Parse an SGML catalog name
2239  *
2240  * Returns new current character and store the value in @name
2241  */
2242 static const xmlChar *
2243 xmlParseSGMLCatalogName(const xmlChar *cur, xmlChar **name) {
2244     xmlChar buf[XML_MAX_NAMELEN + 5];
2245     int len = 0;
2246     int c;
2247
2248     *name = NULL;
2249
2250     /*
2251      * Handler for more complex cases
2252      */
2253     c = *cur;
2254     if ((!IS_LETTER(c) && (c != '_') && (c != ':'))) {
2255         return(NULL);
2256     }
2257
2258     while (((IS_LETTER(c)) || (IS_DIGIT(c)) ||
2259             (c == '.') || (c == '-') ||
2260             (c == '_') || (c == ':'))) {
2261         buf[len++] = c;
2262         cur++;
2263         c = *cur;
2264         if (len >= XML_MAX_NAMELEN)
2265             return(NULL);
2266     }
2267     *name = xmlStrndup(buf, len);
2268     return(cur);
2269 }
2270
2271 /**
2272  * xmlGetSGMLCatalogEntryType:
2273  * @name:  the entry name
2274  *
2275  * Get the Catalog entry type for a given SGML Catalog name
2276  *
2277  * Returns Catalog entry type
2278  */
2279 static xmlCatalogEntryType
2280 xmlGetSGMLCatalogEntryType(const xmlChar *name) {
2281     xmlCatalogEntryType type = XML_CATA_NONE;
2282     if (xmlStrEqual(name, (const xmlChar *) "SYSTEM"))
2283         type = SGML_CATA_SYSTEM;
2284     else if (xmlStrEqual(name, (const xmlChar *) "PUBLIC"))
2285         type = SGML_CATA_PUBLIC;
2286     else if (xmlStrEqual(name, (const xmlChar *) "DELEGATE"))
2287         type = SGML_CATA_DELEGATE;
2288     else if (xmlStrEqual(name, (const xmlChar *) "ENTITY"))
2289         type = SGML_CATA_ENTITY;
2290     else if (xmlStrEqual(name, (const xmlChar *) "DOCTYPE"))
2291         type = SGML_CATA_DOCTYPE;
2292     else if (xmlStrEqual(name, (const xmlChar *) "LINKTYPE"))
2293         type = SGML_CATA_LINKTYPE;
2294     else if (xmlStrEqual(name, (const xmlChar *) "NOTATION"))
2295         type = SGML_CATA_NOTATION;
2296     else if (xmlStrEqual(name, (const xmlChar *) "SGMLDECL"))
2297         type = SGML_CATA_SGMLDECL;
2298     else if (xmlStrEqual(name, (const xmlChar *) "DOCUMENT"))
2299         type = SGML_CATA_DOCUMENT;
2300     else if (xmlStrEqual(name, (const xmlChar *) "CATALOG"))
2301         type = SGML_CATA_CATALOG;
2302     else if (xmlStrEqual(name, (const xmlChar *) "BASE"))
2303         type = SGML_CATA_BASE;
2304     return(type);
2305 }
2306
2307 /**
2308  * xmlParseSGMLCatalog:
2309  * @catal:  the SGML Catalog
2310  * @value:  the content of the SGML Catalog serialization
2311  * @file:  the filepath for the catalog
2312  * @super:  should this be handled as a Super Catalog in which case
2313  *          parsing is not recursive
2314  *
2315  * Parse an SGML catalog content and fill up the @catal hash table with
2316  * the new entries found.
2317  *
2318  * Returns 0 in case of success, -1 in case of error.
2319  */
2320 static int
2321 xmlParseSGMLCatalog(xmlCatalogPtr catal, const xmlChar *value,
2322                     const char *file, int super) {
2323     const xmlChar *cur = value;
2324     xmlChar *base = NULL;
2325     int res;
2326
2327     if ((cur == NULL) || (file == NULL))
2328         return(-1);
2329     base = xmlStrdup((const xmlChar *) file);
2330
2331     while ((cur != NULL) && (cur[0] != 0)) {
2332         SKIP_BLANKS;
2333         if (cur[0] == 0)
2334             break;
2335         if ((cur[0] == '-') && (cur[1] == '-')) {
2336             cur = xmlParseSGMLCatalogComment(cur);
2337             if (cur == NULL) {
2338                 /* error */
2339                 break;
2340             }
2341         } else {
2342             xmlChar *sysid = NULL;
2343             xmlChar *name = NULL;
2344             xmlCatalogEntryType type = XML_CATA_NONE;
2345
2346             cur = xmlParseSGMLCatalogName(cur, &name);
2347             if (name == NULL) {
2348                 /* error */
2349                 break;
2350             }
2351             if (!IS_BLANK_CH(*cur)) {
2352                 /* error */
2353                 break;
2354             }
2355             SKIP_BLANKS;
2356             if (xmlStrEqual(name, (const xmlChar *) "SYSTEM"))
2357                 type = SGML_CATA_SYSTEM;
2358             else if (xmlStrEqual(name, (const xmlChar *) "PUBLIC"))
2359                 type = SGML_CATA_PUBLIC;
2360             else if (xmlStrEqual(name, (const xmlChar *) "DELEGATE"))
2361                 type = SGML_CATA_DELEGATE;
2362             else if (xmlStrEqual(name, (const xmlChar *) "ENTITY"))
2363                 type = SGML_CATA_ENTITY;
2364             else if (xmlStrEqual(name, (const xmlChar *) "DOCTYPE"))
2365                 type = SGML_CATA_DOCTYPE;
2366             else if (xmlStrEqual(name, (const xmlChar *) "LINKTYPE"))
2367                 type = SGML_CATA_LINKTYPE;
2368             else if (xmlStrEqual(name, (const xmlChar *) "NOTATION"))
2369                 type = SGML_CATA_NOTATION;
2370             else if (xmlStrEqual(name, (const xmlChar *) "SGMLDECL"))
2371                 type = SGML_CATA_SGMLDECL;
2372             else if (xmlStrEqual(name, (const xmlChar *) "DOCUMENT"))
2373                 type = SGML_CATA_DOCUMENT;
2374             else if (xmlStrEqual(name, (const xmlChar *) "CATALOG"))
2375                 type = SGML_CATA_CATALOG;
2376             else if (xmlStrEqual(name, (const xmlChar *) "BASE"))
2377                 type = SGML_CATA_BASE;
2378             else if (xmlStrEqual(name, (const xmlChar *) "OVERRIDE")) {
2379                 xmlFree(name);
2380                 cur = xmlParseSGMLCatalogName(cur, &name);
2381                 if (name == NULL) {
2382                     /* error */
2383                     break;
2384                 }
2385                 xmlFree(name);
2386                 continue;
2387             }
2388             xmlFree(name);
2389             name = NULL;
2390
2391             switch(type) {
2392                 case SGML_CATA_ENTITY:
2393                     if (*cur == '%')
2394                         type = SGML_CATA_PENTITY;
2395                 case SGML_CATA_PENTITY:
2396                 case SGML_CATA_DOCTYPE:
2397                 case SGML_CATA_LINKTYPE:
2398                 case SGML_CATA_NOTATION:
2399                     cur = xmlParseSGMLCatalogName(cur, &name);
2400                     if (cur == NULL) {
2401                         /* error */
2402                         break;
2403                     }
2404                     if (!IS_BLANK_CH(*cur)) {
2405                         /* error */
2406                         break;
2407                     }
2408                     SKIP_BLANKS;
2409                     cur = xmlParseSGMLCatalogPubid(cur, &sysid);
2410                     if (cur == NULL) {
2411                         /* error */
2412                         break;
2413                     }
2414                     break;
2415                 case SGML_CATA_PUBLIC:
2416                 case SGML_CATA_SYSTEM:
2417                 case SGML_CATA_DELEGATE:
2418                     cur = xmlParseSGMLCatalogPubid(cur, &name);
2419                     if (cur == NULL) {
2420                         /* error */
2421                         break;
2422                     }
2423                     if (type != SGML_CATA_SYSTEM) {
2424                         xmlChar *normid;
2425
2426                         normid = xmlCatalogNormalizePublic(name);
2427                         if (normid != NULL) {
2428                             if (name != NULL)
2429                                 xmlFree(name);
2430                             if (*normid != 0)
2431                                 name = normid;
2432                             else {
2433                                 xmlFree(normid);
2434                                 name = NULL;
2435                             }
2436                         }
2437                     }
2438                     if (!IS_BLANK_CH(*cur)) {
2439                         /* error */
2440                         break;
2441                     }
2442                     SKIP_BLANKS;
2443                     cur = xmlParseSGMLCatalogPubid(cur, &sysid);
2444                     if (cur == NULL) {
2445                         /* error */
2446                         break;
2447                     }
2448                     break;
2449                 case SGML_CATA_BASE:
2450                 case SGML_CATA_CATALOG:
2451                 case SGML_CATA_DOCUMENT:
2452                 case SGML_CATA_SGMLDECL:
2453                     cur = xmlParseSGMLCatalogPubid(cur, &sysid);
2454                     if (cur == NULL) {
2455                         /* error */
2456                         break;
2457                     }
2458                     break;
2459                 default:
2460                     break;
2461             }
2462             if (cur == NULL) {
2463                 if (name != NULL)
2464                     xmlFree(name);
2465                 if (sysid != NULL)
2466                     xmlFree(sysid);
2467                 break;
2468             } else if (type == SGML_CATA_BASE) {
2469                 if (base != NULL)
2470                     xmlFree(base);
2471                 base = xmlStrdup(sysid);
2472             } else if ((type == SGML_CATA_PUBLIC) ||
2473                        (type == SGML_CATA_SYSTEM)) {
2474                 xmlChar *filename;
2475
2476                 filename = xmlBuildURI(sysid, base);
2477                 if (filename != NULL) {
2478                     xmlCatalogEntryPtr entry;
2479
2480                     entry = xmlNewCatalogEntry(type, name, filename,
2481                                                NULL, XML_CATA_PREFER_NONE, NULL);
2482                     res = xmlHashAddEntry(catal->sgml, name, entry);
2483                     if (res < 0) {
2484                         xmlFreeCatalogEntry(entry);
2485                     }
2486                     xmlFree(filename);
2487                 }
2488
2489             } else if (type == SGML_CATA_CATALOG) {
2490                 if (super) {
2491                     xmlCatalogEntryPtr entry;
2492
2493                     entry = xmlNewCatalogEntry(type, sysid, NULL, NULL,
2494                                                XML_CATA_PREFER_NONE, NULL);
2495                     res = xmlHashAddEntry(catal->sgml, sysid, entry);
2496                     if (res < 0) {
2497                         xmlFreeCatalogEntry(entry);
2498                     }
2499                 } else {
2500                     xmlChar *filename;
2501
2502                     filename = xmlBuildURI(sysid, base);
2503                     if (filename != NULL) {
2504                         xmlExpandCatalog(catal, (const char *)filename);
2505                         xmlFree(filename);
2506                     }
2507                 }
2508             }
2509             /*
2510              * drop anything else we won't handle it
2511              */
2512             if (name != NULL)
2513                 xmlFree(name);
2514             if (sysid != NULL)
2515                 xmlFree(sysid);
2516         }
2517     }
2518     if (base != NULL)
2519         xmlFree(base);
2520     if (cur == NULL)
2521         return(-1);
2522     return(0);
2523 }
2524
2525 /************************************************************************
2526  *                                                                      *
2527  *                      SGML Catalog handling                           *
2528  *                                                                      *
2529  ************************************************************************/
2530
2531 /**
2532  * xmlCatalogGetSGMLPublic:
2533  * @catal:  an SGML catalog hash
2534  * @pubID:  the public ID string
2535  *
2536  * Try to lookup the catalog local reference associated to a public ID
2537  *
2538  * Returns the local resource if found or NULL otherwise.
2539  */
2540 static const xmlChar *
2541 xmlCatalogGetSGMLPublic(xmlHashTablePtr catal, const xmlChar *pubID) {
2542     xmlCatalogEntryPtr entry;
2543     xmlChar *normid;
2544
2545     if (catal == NULL)
2546         return(NULL);
2547
2548     normid = xmlCatalogNormalizePublic(pubID);
2549     if (normid != NULL)
2550         pubID = (*normid != 0 ? normid : NULL);
2551
2552     entry = (xmlCatalogEntryPtr) xmlHashLookup(catal, pubID);
2553     if (entry == NULL) {
2554         if (normid != NULL)
2555             xmlFree(normid);
2556         return(NULL);
2557     }
2558     if (entry->type == SGML_CATA_PUBLIC) {
2559         if (normid != NULL)
2560             xmlFree(normid);
2561         return(entry->URL);
2562     }
2563     if (normid != NULL)
2564         xmlFree(normid);
2565     return(NULL);
2566 }
2567
2568 /**
2569  * xmlCatalogGetSGMLSystem:
2570  * @catal:  an SGML catalog hash
2571  * @sysID:  the system ID string
2572  *
2573  * Try to lookup the catalog local reference for a system ID
2574  *
2575  * Returns the local resource if found or NULL otherwise.
2576  */
2577 static const xmlChar *
2578 xmlCatalogGetSGMLSystem(xmlHashTablePtr catal, const xmlChar *sysID) {
2579     xmlCatalogEntryPtr entry;
2580
2581     if (catal == NULL)
2582         return(NULL);
2583
2584     entry = (xmlCatalogEntryPtr) xmlHashLookup(catal, sysID);
2585     if (entry == NULL)
2586         return(NULL);
2587     if (entry->type == SGML_CATA_SYSTEM)
2588         return(entry->URL);
2589     return(NULL);
2590 }
2591
2592 /**
2593  * xmlCatalogSGMLResolve:
2594  * @catal:  the SGML catalog
2595  * @pubID:  the public ID string
2596  * @sysID:  the system ID string
2597  *
2598  * Do a complete resolution lookup of an External Identifier
2599  *
2600  * Returns the URI of the resource or NULL if not found
2601  */
2602 static const xmlChar *
2603 xmlCatalogSGMLResolve(xmlCatalogPtr catal, const xmlChar *pubID,
2604                       const xmlChar *sysID) {
2605     const xmlChar *ret = NULL;
2606
2607     if (catal->sgml == NULL)
2608         return(NULL);
2609
2610     if (pubID != NULL)
2611         ret = xmlCatalogGetSGMLPublic(catal->sgml, pubID);
2612     if (ret != NULL)
2613         return(ret);
2614     if (sysID != NULL)
2615         ret = xmlCatalogGetSGMLSystem(catal->sgml, sysID);
2616     if (ret != NULL)
2617         return(ret);
2618     return(NULL);
2619 }
2620
2621 /************************************************************************
2622  *                                                                      *
2623  *                      Specific Public interfaces                      *
2624  *                                                                      *
2625  ************************************************************************/
2626
2627 /**
2628  * xmlLoadSGMLSuperCatalog:
2629  * @filename:  a file path
2630  *
2631  * Load an SGML super catalog. It won't expand CATALOG or DELEGATE
2632  * references. This is only needed for manipulating SGML Super Catalogs
2633  * like adding and removing CATALOG or DELEGATE entries.
2634  *
2635  * Returns the catalog parsed or NULL in case of error
2636  */
2637 xmlCatalogPtr
2638 xmlLoadSGMLSuperCatalog(const char *filename)
2639 {
2640     xmlChar *content;
2641     xmlCatalogPtr catal;
2642     int ret;
2643
2644     content = xmlLoadFileContent(filename);
2645     if (content == NULL)
2646         return(NULL);
2647
2648     catal = xmlCreateNewCatalog(XML_SGML_CATALOG_TYPE, xmlCatalogDefaultPrefer);
2649     if (catal == NULL) {
2650         xmlFree(content);
2651         return(NULL);
2652     }
2653
2654     ret = xmlParseSGMLCatalog(catal, content, filename, 1);
2655     xmlFree(content);
2656     if (ret < 0) {
2657         xmlFreeCatalog(catal);
2658         return(NULL);
2659     }
2660     return (catal);
2661 }
2662
2663 /**
2664  * xmlLoadACatalog:
2665  * @filename:  a file path
2666  *
2667  * Load the catalog and build the associated data structures.
2668  * This can be either an XML Catalog or an SGML Catalog
2669  * It will recurse in SGML CATALOG entries. On the other hand XML
2670  * Catalogs are not handled recursively.
2671  *
2672  * Returns the catalog parsed or NULL in case of error
2673  */
2674 xmlCatalogPtr
2675 xmlLoadACatalog(const char *filename)
2676 {
2677     xmlChar *content;
2678     xmlChar *first;
2679     xmlCatalogPtr catal;
2680     int ret;
2681
2682     content = xmlLoadFileContent(filename);
2683     if (content == NULL)
2684         return(NULL);
2685
2686
2687     first = content;
2688
2689     while ((*first != 0) && (*first != '-') && (*first != '<') &&
2690            (!(((*first >= 'A') && (*first <= 'Z')) ||
2691               ((*first >= 'a') && (*first <= 'z')))))
2692         first++;
2693
2694     if (*first != '<') {
2695         catal = xmlCreateNewCatalog(XML_SGML_CATALOG_TYPE, xmlCatalogDefaultPrefer);
2696         if (catal == NULL) {
2697             xmlFree(content);
2698             return(NULL);
2699         }
2700         ret = xmlParseSGMLCatalog(catal, content, filename, 0);
2701         if (ret < 0) {
2702             xmlFreeCatalog(catal);
2703             xmlFree(content);
2704             return(NULL);
2705         }
2706     } else {
2707         catal = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE, xmlCatalogDefaultPrefer);
2708         if (catal == NULL) {
2709             xmlFree(content);
2710             return(NULL);
2711         }
2712         catal->xml = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
2713                        NULL, BAD_CAST filename, xmlCatalogDefaultPrefer, NULL);
2714     }
2715     xmlFree(content);
2716     return (catal);
2717 }
2718
2719 /**
2720  * xmlExpandCatalog:
2721  * @catal:  a catalog
2722  * @filename:  a file path
2723  *
2724  * Load the catalog and expand the existing catal structure.
2725  * This can be either an XML Catalog or an SGML Catalog
2726  *
2727  * Returns 0 in case of success, -1 in case of error
2728  */
2729 static int
2730 xmlExpandCatalog(xmlCatalogPtr catal, const char *filename)
2731 {
2732     int ret;
2733
2734     if ((catal == NULL) || (filename == NULL))
2735         return(-1);
2736
2737
2738     if (catal->type == XML_SGML_CATALOG_TYPE) {
2739         xmlChar *content;
2740
2741         content = xmlLoadFileContent(filename);
2742         if (content == NULL)
2743             return(-1);
2744
2745         ret = xmlParseSGMLCatalog(catal, content, filename, 0);
2746         if (ret < 0) {
2747             xmlFree(content);
2748             return(-1);
2749         }
2750         xmlFree(content);
2751     } else {
2752         xmlCatalogEntryPtr tmp, cur;
2753         tmp = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
2754                        NULL, BAD_CAST filename, xmlCatalogDefaultPrefer, NULL);
2755
2756         cur = catal->xml;
2757         if (cur == NULL) {
2758             catal->xml = tmp;
2759         } else {
2760             while (cur->next != NULL) cur = cur->next;
2761             cur->next = tmp;
2762         }
2763     }
2764     return (0);
2765 }
2766
2767 /**
2768  * xmlACatalogResolveSystem:
2769  * @catal:  a Catalog
2770  * @sysID:  the system ID string
2771  *
2772  * Try to lookup the catalog resource for a system ID
2773  *
2774  * Returns the resource if found or NULL otherwise, the value returned
2775  *      must be freed by the caller.
2776  */
2777 xmlChar *
2778 xmlACatalogResolveSystem(xmlCatalogPtr catal, const xmlChar *sysID) {
2779     xmlChar *ret = NULL;
2780
2781     if ((sysID == NULL) || (catal == NULL))
2782         return(NULL);
2783
2784     if (xmlDebugCatalogs)
2785         xmlGenericError(xmlGenericErrorContext,
2786                 "Resolve sysID %s\n", sysID);
2787
2788     if (catal->type == XML_XML_CATALOG_TYPE) {
2789         ret = xmlCatalogListXMLResolve(catal->xml, NULL, sysID);
2790         if (ret == XML_CATAL_BREAK)
2791             ret = NULL;
2792     } else {
2793         const xmlChar *sgml;
2794
2795         sgml = xmlCatalogGetSGMLSystem(catal->sgml, sysID);
2796         if (sgml != NULL)
2797             ret = xmlStrdup(sgml);
2798     }
2799     return(ret);
2800 }
2801
2802 /**
2803  * xmlACatalogResolvePublic:
2804  * @catal:  a Catalog
2805  * @pubID:  the public ID string
2806  *
2807  * Try to lookup the catalog local reference associated to a public ID in that catalog
2808  *
2809  * Returns the local resource if found or NULL otherwise, the value returned
2810  *      must be freed by the caller.
2811  */
2812 xmlChar *
2813 xmlACatalogResolvePublic(xmlCatalogPtr catal, const xmlChar *pubID) {
2814     xmlChar *ret = NULL;
2815
2816     if ((pubID == NULL) || (catal == NULL))
2817         return(NULL);
2818
2819     if (xmlDebugCatalogs)
2820         xmlGenericError(xmlGenericErrorContext,
2821                 "Resolve pubID %s\n", pubID);
2822
2823     if (catal->type == XML_XML_CATALOG_TYPE) {
2824         ret = xmlCatalogListXMLResolve(catal->xml, pubID, NULL);
2825         if (ret == XML_CATAL_BREAK)
2826             ret = NULL;
2827     } else {
2828         const xmlChar *sgml;
2829
2830         sgml = xmlCatalogGetSGMLPublic(catal->sgml, pubID);
2831         if (sgml != NULL)
2832             ret = xmlStrdup(sgml);
2833     }
2834     return(ret);
2835 }
2836
2837 /**
2838  * xmlACatalogResolve:
2839  * @catal:  a Catalog
2840  * @pubID:  the public ID string
2841  * @sysID:  the system ID string
2842  *
2843  * Do a complete resolution lookup of an External Identifier
2844  *
2845  * Returns the URI of the resource or NULL if not found, it must be freed
2846  *      by the caller.
2847  */
2848 xmlChar *
2849 xmlACatalogResolve(xmlCatalogPtr catal, const xmlChar * pubID,
2850                    const xmlChar * sysID)
2851 {
2852     xmlChar *ret = NULL;
2853
2854     if (((pubID == NULL) && (sysID == NULL)) || (catal == NULL))
2855         return (NULL);
2856
2857     if (xmlDebugCatalogs) {
2858          if ((pubID != NULL) && (sysID != NULL)) {
2859              xmlGenericError(xmlGenericErrorContext,
2860                              "Resolve: pubID %s sysID %s\n", pubID, sysID);
2861          } else if (pubID != NULL) {
2862              xmlGenericError(xmlGenericErrorContext,
2863                              "Resolve: pubID %s\n", pubID);
2864          } else {
2865              xmlGenericError(xmlGenericErrorContext,
2866                              "Resolve: sysID %s\n", sysID);
2867          }
2868     }
2869
2870     if (catal->type == XML_XML_CATALOG_TYPE) {
2871         ret = xmlCatalogListXMLResolve(catal->xml, pubID, sysID);
2872         if (ret == XML_CATAL_BREAK)
2873             ret = NULL;
2874     } else {
2875         const xmlChar *sgml;
2876
2877         sgml = xmlCatalogSGMLResolve(catal, pubID, sysID);
2878         if (sgml != NULL)
2879             ret = xmlStrdup(sgml);
2880     }
2881     return (ret);
2882 }
2883
2884 /**
2885  * xmlACatalogResolveURI:
2886  * @catal:  a Catalog
2887  * @URI:  the URI
2888  *
2889  * Do a complete resolution lookup of an URI
2890  *
2891  * Returns the URI of the resource or NULL if not found, it must be freed
2892  *      by the caller.
2893  */
2894 xmlChar *
2895 xmlACatalogResolveURI(xmlCatalogPtr catal, const xmlChar *URI) {
2896     xmlChar *ret = NULL;
2897
2898     if ((URI == NULL) || (catal == NULL))
2899         return(NULL);
2900
2901     if (xmlDebugCatalogs)
2902         xmlGenericError(xmlGenericErrorContext,
2903                 "Resolve URI %s\n", URI);
2904
2905     if (catal->type == XML_XML_CATALOG_TYPE) {
2906         ret = xmlCatalogListXMLResolveURI(catal->xml, URI);
2907         if (ret == XML_CATAL_BREAK)
2908             ret = NULL;
2909     } else {
2910         const xmlChar *sgml;
2911
2912         sgml = xmlCatalogSGMLResolve(catal, NULL, URI);
2913         if (sgml != NULL)
2914             ret = xmlStrdup(sgml);
2915     }
2916     return(ret);
2917 }
2918
2919 #ifdef LIBXML_OUTPUT_ENABLED
2920 /**
2921  * xmlACatalogDump:
2922  * @catal:  a Catalog
2923  * @out:  the file.
2924  *
2925  * Dump the given catalog to the given file.
2926  */
2927 void
2928 xmlACatalogDump(xmlCatalogPtr catal, FILE *out) {
2929     if ((out == NULL) || (catal == NULL))
2930         return;
2931
2932     if (catal->type == XML_XML_CATALOG_TYPE) {
2933         xmlDumpXMLCatalog(out, catal->xml);
2934     } else {
2935         xmlHashScan(catal->sgml,
2936                     (xmlHashScanner) xmlCatalogDumpEntry, out);
2937     }
2938 }
2939 #endif /* LIBXML_OUTPUT_ENABLED */
2940
2941 /**
2942  * xmlACatalogAdd:
2943  * @catal:  a Catalog
2944  * @type:  the type of record to add to the catalog
2945  * @orig:  the system, public or prefix to match
2946  * @replace:  the replacement value for the match
2947  *
2948  * Add an entry in the catalog, it may overwrite existing but
2949  * different entries.
2950  *
2951  * Returns 0 if successful, -1 otherwise
2952  */
2953 int
2954 xmlACatalogAdd(xmlCatalogPtr catal, const xmlChar * type,
2955               const xmlChar * orig, const xmlChar * replace)
2956 {
2957     int res = -1;
2958
2959     if (catal == NULL)
2960         return(-1);
2961
2962     if (catal->type == XML_XML_CATALOG_TYPE) {
2963         res = xmlAddXMLCatalog(catal->xml, type, orig, replace);
2964     } else {
2965         xmlCatalogEntryType cattype;
2966
2967         cattype = xmlGetSGMLCatalogEntryType(type);
2968         if (cattype != XML_CATA_NONE) {
2969             xmlCatalogEntryPtr entry;
2970
2971             entry = xmlNewCatalogEntry(cattype, orig, replace, NULL,
2972                                        XML_CATA_PREFER_NONE, NULL);
2973             if (catal->sgml == NULL)
2974                 catal->sgml = xmlHashCreate(10);
2975             res = xmlHashAddEntry(catal->sgml, orig, entry);
2976         }
2977     }
2978     return (res);
2979 }
2980
2981 /**
2982  * xmlACatalogRemove:
2983  * @catal:  a Catalog
2984  * @value:  the value to remove
2985  *
2986  * Remove an entry from the catalog
2987  *
2988  * Returns the number of entries removed if successful, -1 otherwise
2989  */
2990 int
2991 xmlACatalogRemove(xmlCatalogPtr catal, const xmlChar *value) {
2992     int res = -1;
2993
2994     if ((catal == NULL) || (value == NULL))
2995         return(-1);
2996
2997     if (catal->type == XML_XML_CATALOG_TYPE) {
2998         res = xmlDelXMLCatalog(catal->xml, value);
2999     } else {
3000         res = xmlHashRemoveEntry(catal->sgml, value,
3001                 (xmlHashDeallocator) xmlFreeCatalogEntry);
3002         if (res == 0)
3003             res = 1;
3004     }
3005     return(res);
3006 }
3007
3008 /**
3009  * xmlNewCatalog:
3010  * @sgml:  should this create an SGML catalog
3011  *
3012  * create a new Catalog.
3013  *
3014  * Returns the xmlCatalogPtr or NULL in case of error
3015  */
3016 xmlCatalogPtr
3017 xmlNewCatalog(int sgml) {
3018     xmlCatalogPtr catal = NULL;
3019
3020     if (sgml) {
3021         catal = xmlCreateNewCatalog(XML_SGML_CATALOG_TYPE,
3022                                     xmlCatalogDefaultPrefer);
3023         if ((catal != NULL) && (catal->sgml == NULL))
3024             catal->sgml = xmlHashCreate(10);
3025     } else
3026         catal = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE,
3027                                     xmlCatalogDefaultPrefer);
3028     return(catal);
3029 }
3030
3031 /**
3032  * xmlCatalogIsEmpty:
3033  * @catal:  should this create an SGML catalog
3034  *
3035  * Check is a catalog is empty
3036  *
3037  * Returns 1 if the catalog is empty, 0 if not, amd -1 in case of error.
3038  */
3039 int
3040 xmlCatalogIsEmpty(xmlCatalogPtr catal) {
3041     if (catal == NULL)
3042         return(-1);
3043
3044     if (catal->type == XML_XML_CATALOG_TYPE) {
3045         if (catal->xml == NULL)
3046             return(1);
3047         if ((catal->xml->type != XML_CATA_CATALOG) &&
3048             (catal->xml->type != XML_CATA_BROKEN_CATALOG))
3049             return(-1);
3050         if (catal->xml->children == NULL)
3051             return(1);
3052         return(0);
3053     } else {
3054         int res;
3055
3056         if (catal->sgml == NULL)
3057             return(1);
3058         res = xmlHashSize(catal->sgml);
3059         if (res == 0)
3060             return(1);
3061         if (res < 0)
3062             return(-1);
3063     }
3064     return(0);
3065 }
3066
3067 /************************************************************************
3068  *                                                                      *
3069  *   Public interfaces manipulating the global shared default catalog   *
3070  *                                                                      *
3071  ************************************************************************/
3072
3073 /**
3074  * xmlInitializeCatalogData:
3075  *
3076  * Do the catalog initialization only of global data, doesn't try to load
3077  * any catalog actually.
3078  * this function is not thread safe, catalog initialization should
3079  * preferably be done once at startup
3080  */
3081 static void
3082 xmlInitializeCatalogData(void) {
3083     if (xmlCatalogInitialized != 0)
3084         return;
3085
3086     if (getenv("XML_DEBUG_CATALOG"))
3087         xmlDebugCatalogs = 1;
3088     xmlCatalogMutex = xmlNewRMutex();
3089
3090     xmlCatalogInitialized = 1;
3091 }
3092 /**
3093  * xmlInitializeCatalog:
3094  *
3095  * Do the catalog initialization.
3096  * this function is not thread safe, catalog initialization should
3097  * preferably be done once at startup
3098  */
3099 void
3100 xmlInitializeCatalog(void) {
3101     if (xmlCatalogInitialized != 0)
3102         return;
3103
3104     xmlInitializeCatalogData();
3105     xmlRMutexLock(xmlCatalogMutex);
3106
3107     if (getenv("XML_DEBUG_CATALOG"))
3108         xmlDebugCatalogs = 1;
3109
3110     if (xmlDefaultCatalog == NULL) {
3111         const char *catalogs;
3112         char *path;
3113         const char *cur, *paths;
3114         xmlCatalogPtr catal;
3115         xmlCatalogEntryPtr *nextent;
3116
3117         catalogs = (const char *) getenv("XML_CATALOG_FILES");
3118         if (catalogs == NULL)
3119 #if defined(_WIN32) && defined(_MSC_VER)
3120     {
3121                 void* hmodule;
3122                 hmodule = GetModuleHandleA("libxml2.dll");
3123                 if (hmodule == NULL)
3124                         hmodule = GetModuleHandleA(NULL);
3125                 if (hmodule != NULL) {
3126                         char buf[256];
3127                         unsigned long len = GetModuleFileNameA(hmodule, buf, 255);
3128                         if (len != 0) {
3129                                 char* p = &(buf[len]);
3130                                 while (*p != '\\' && p > buf)
3131                                         p--;
3132                                 if (p != buf) {
3133                                         xmlChar* uri;
3134                                         strncpy(p, "\\..\\etc\\catalog", 255 - (p - buf));
3135                                         uri = xmlCanonicPath(buf);
3136                                         if (uri != NULL) {
3137                                                 strncpy(XML_XML_DEFAULT_CATALOG, uri, 255);
3138                                                 xmlFree(uri);
3139                                         }
3140                                 }
3141                         }
3142                 }
3143                 catalogs = XML_XML_DEFAULT_CATALOG;
3144     }
3145 #else
3146             catalogs = XML_XML_DEFAULT_CATALOG;
3147 #endif
3148
3149         catal = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE,
3150                 xmlCatalogDefaultPrefer);
3151         if (catal != NULL) {
3152             /* the XML_CATALOG_FILES envvar is allowed to contain a
3153                space-separated list of entries. */
3154             cur = catalogs;
3155             nextent = &catal->xml;
3156             while (*cur != '\0') {
3157                 while (xmlIsBlank_ch(*cur))
3158                     cur++;
3159                 if (*cur != 0) {
3160                     paths = cur;
3161                     while ((*cur != 0) && (!xmlIsBlank_ch(*cur)))
3162                         cur++;
3163                     path = (char *) xmlStrndup((const xmlChar *)paths, cur - paths);
3164                     if (path != NULL) {
3165                         *nextent = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
3166                                 NULL, BAD_CAST path, xmlCatalogDefaultPrefer, NULL);
3167                         if (*nextent != NULL)
3168                             nextent = &((*nextent)->next);
3169                         xmlFree(path);
3170                     }
3171                 }
3172             }
3173             xmlDefaultCatalog = catal;
3174         }
3175     }
3176
3177     xmlRMutexUnlock(xmlCatalogMutex);
3178 }
3179
3180
3181 /**
3182  * xmlLoadCatalog:
3183  * @filename:  a file path
3184  *
3185  * Load the catalog and makes its definitions effective for the default
3186  * external entity loader. It will recurse in SGML CATALOG entries.
3187  * this function is not thread safe, catalog initialization should
3188  * preferably be done once at startup
3189  *
3190  * Returns 0 in case of success -1 in case of error
3191  */
3192 int
3193 xmlLoadCatalog(const char *filename)
3194 {
3195     int ret;
3196     xmlCatalogPtr catal;
3197
3198     if (!xmlCatalogInitialized)
3199         xmlInitializeCatalogData();
3200
3201     xmlRMutexLock(xmlCatalogMutex);
3202
3203     if (xmlDefaultCatalog == NULL) {
3204         catal = xmlLoadACatalog(filename);
3205         if (catal == NULL) {
3206             xmlRMutexUnlock(xmlCatalogMutex);
3207             return(-1);
3208         }
3209
3210         xmlDefaultCatalog = catal;
3211         xmlRMutexUnlock(xmlCatalogMutex);
3212         return(0);
3213     }
3214
3215     ret = xmlExpandCatalog(xmlDefaultCatalog, filename);
3216     xmlRMutexUnlock(xmlCatalogMutex);
3217     return(ret);
3218 }
3219
3220 /**
3221  * xmlLoadCatalogs:
3222  * @pathss:  a list of directories separated by a colon or a space.
3223  *
3224  * Load the catalogs and makes their definitions effective for the default
3225  * external entity loader.
3226  * this function is not thread safe, catalog initialization should
3227  * preferably be done once at startup
3228  */
3229 void
3230 xmlLoadCatalogs(const char *pathss) {
3231     const char *cur;
3232     const char *paths;
3233     xmlChar *path;
3234 #ifdef _WIN32
3235     int i, iLen;
3236 #endif
3237
3238     if (pathss == NULL)
3239         return;
3240
3241     cur = pathss;
3242     while (*cur != 0) {
3243         while (xmlIsBlank_ch(*cur)) cur++;
3244         if (*cur != 0) {
3245             paths = cur;
3246             while ((*cur != 0) && (*cur != PATH_SEAPARATOR) && (!xmlIsBlank_ch(*cur)))
3247                 cur++;
3248             path = xmlStrndup((const xmlChar *)paths, cur - paths);
3249 #ifdef _WIN32
3250         iLen = strlen(path);
3251         for(i = 0; i < iLen; i++) {
3252             if(path[i] == '\\') {
3253                 path[i] = '/';
3254             }
3255         }
3256 #endif
3257             if (path != NULL) {
3258                 xmlLoadCatalog((const char *) path);
3259                 xmlFree(path);
3260             }
3261         }
3262         while (*cur == PATH_SEAPARATOR)
3263             cur++;
3264     }
3265 }
3266
3267 /**
3268  * xmlCatalogCleanup:
3269  *
3270  * Free up all the memory associated with catalogs
3271  */
3272 void
3273 xmlCatalogCleanup(void) {
3274     if (xmlCatalogInitialized == 0)
3275         return;
3276
3277     xmlRMutexLock(xmlCatalogMutex);
3278     if (xmlDebugCatalogs)
3279         xmlGenericError(xmlGenericErrorContext,
3280                 "Catalogs cleanup\n");
3281     if (xmlCatalogXMLFiles != NULL)
3282         xmlHashFree(xmlCatalogXMLFiles,
3283                     (xmlHashDeallocator)xmlFreeCatalogHashEntryList);
3284     xmlCatalogXMLFiles = NULL;
3285     if (xmlDefaultCatalog != NULL)
3286         xmlFreeCatalog(xmlDefaultCatalog);
3287     xmlDefaultCatalog = NULL;
3288     xmlDebugCatalogs = 0;
3289     xmlCatalogInitialized = 0;
3290     xmlRMutexUnlock(xmlCatalogMutex);
3291     xmlFreeRMutex(xmlCatalogMutex);
3292 }
3293
3294 /**
3295  * xmlCatalogResolveSystem:
3296  * @sysID:  the system ID string
3297  *
3298  * Try to lookup the catalog resource for a system ID
3299  *
3300  * Returns the resource if found or NULL otherwise, the value returned
3301  *      must be freed by the caller.
3302  */
3303 xmlChar *
3304 xmlCatalogResolveSystem(const xmlChar *sysID) {
3305     xmlChar *ret;
3306
3307     if (!xmlCatalogInitialized)
3308         xmlInitializeCatalog();
3309
3310     ret = xmlACatalogResolveSystem(xmlDefaultCatalog, sysID);
3311     return(ret);
3312 }
3313
3314 /**
3315  * xmlCatalogResolvePublic:
3316  * @pubID:  the public ID string
3317  *
3318  * Try to lookup the catalog reference associated to a public ID
3319  *
3320  * Returns the resource if found or NULL otherwise, the value returned
3321  *      must be freed by the caller.
3322  */
3323 xmlChar *
3324 xmlCatalogResolvePublic(const xmlChar *pubID) {
3325     xmlChar *ret;
3326
3327     if (!xmlCatalogInitialized)
3328         xmlInitializeCatalog();
3329
3330     ret = xmlACatalogResolvePublic(xmlDefaultCatalog, pubID);
3331     return(ret);
3332 }
3333
3334 /**
3335  * xmlCatalogResolve:
3336  * @pubID:  the public ID string
3337  * @sysID:  the system ID string
3338  *
3339  * Do a complete resolution lookup of an External Identifier
3340  *
3341  * Returns the URI of the resource or NULL if not found, it must be freed
3342  *      by the caller.
3343  */
3344 xmlChar *
3345 xmlCatalogResolve(const xmlChar *pubID, const xmlChar *sysID) {
3346     xmlChar *ret;
3347
3348     if (!xmlCatalogInitialized)
3349         xmlInitializeCatalog();
3350
3351     ret = xmlACatalogResolve(xmlDefaultCatalog, pubID, sysID);
3352     return(ret);
3353 }
3354
3355 /**
3356  * xmlCatalogResolveURI:
3357  * @URI:  the URI
3358  *
3359  * Do a complete resolution lookup of an URI
3360  *
3361  * Returns the URI of the resource or NULL if not found, it must be freed
3362  *      by the caller.
3363  */
3364 xmlChar *
3365 xmlCatalogResolveURI(const xmlChar *URI) {
3366     xmlChar *ret;
3367
3368     if (!xmlCatalogInitialized)
3369         xmlInitializeCatalog();
3370
3371     ret = xmlACatalogResolveURI(xmlDefaultCatalog, URI);
3372     return(ret);
3373 }
3374
3375 #ifdef LIBXML_OUTPUT_ENABLED
3376 /**
3377  * xmlCatalogDump:
3378  * @out:  the file.
3379  *
3380  * Dump all the global catalog content to the given file.
3381  */
3382 void
3383 xmlCatalogDump(FILE *out) {
3384     if (out == NULL)
3385         return;
3386
3387     if (!xmlCatalogInitialized)
3388         xmlInitializeCatalog();
3389
3390     xmlACatalogDump(xmlDefaultCatalog, out);
3391 }
3392 #endif /* LIBXML_OUTPUT_ENABLED */
3393
3394 /**
3395  * xmlCatalogAdd:
3396  * @type:  the type of record to add to the catalog
3397  * @orig:  the system, public or prefix to match
3398  * @replace:  the replacement value for the match
3399  *
3400  * Add an entry in the catalog, it may overwrite existing but
3401  * different entries.
3402  * If called before any other catalog routine, allows to override the
3403  * default shared catalog put in place by xmlInitializeCatalog();
3404  *
3405  * Returns 0 if successful, -1 otherwise
3406  */
3407 int
3408 xmlCatalogAdd(const xmlChar *type, const xmlChar *orig, const xmlChar *replace) {
3409     int res = -1;
3410
3411     if (!xmlCatalogInitialized)
3412         xmlInitializeCatalogData();
3413
3414     xmlRMutexLock(xmlCatalogMutex);
3415     /*
3416      * Specific case where one want to override the default catalog
3417      * put in place by xmlInitializeCatalog();
3418      */
3419     if ((xmlDefaultCatalog == NULL) &&
3420         (xmlStrEqual(type, BAD_CAST "catalog"))) {
3421         xmlDefaultCatalog = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE,
3422                                           xmlCatalogDefaultPrefer);
3423         xmlDefaultCatalog->xml = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
3424                                     orig, NULL,  xmlCatalogDefaultPrefer, NULL);
3425
3426         xmlRMutexUnlock(xmlCatalogMutex);
3427         return(0);
3428     }
3429
3430     res = xmlACatalogAdd(xmlDefaultCatalog, type, orig, replace);
3431     xmlRMutexUnlock(xmlCatalogMutex);
3432     return(res);
3433 }
3434
3435 /**
3436  * xmlCatalogRemove:
3437  * @value:  the value to remove
3438  *
3439  * Remove an entry from the catalog
3440  *
3441  * Returns the number of entries removed if successful, -1 otherwise
3442  */
3443 int
3444 xmlCatalogRemove(const xmlChar *value) {
3445     int res;
3446
3447     if (!xmlCatalogInitialized)
3448         xmlInitializeCatalog();
3449
3450     xmlRMutexLock(xmlCatalogMutex);
3451     res = xmlACatalogRemove(xmlDefaultCatalog, value);
3452     xmlRMutexUnlock(xmlCatalogMutex);
3453     return(res);
3454 }
3455
3456 /**
3457  * xmlCatalogConvert:
3458  *
3459  * Convert all the SGML catalog entries as XML ones
3460  *
3461  * Returns the number of entries converted if successful, -1 otherwise
3462  */
3463 int
3464 xmlCatalogConvert(void) {
3465     int res = -1;
3466
3467     if (!xmlCatalogInitialized)
3468         xmlInitializeCatalog();
3469
3470     xmlRMutexLock(xmlCatalogMutex);
3471     res = xmlConvertSGMLCatalog(xmlDefaultCatalog);
3472     xmlRMutexUnlock(xmlCatalogMutex);
3473     return(res);
3474 }
3475
3476 /************************************************************************
3477  *                                                                      *
3478  *      Public interface manipulating the common preferences            *
3479  *                                                                      *
3480  ************************************************************************/
3481
3482 /**
3483  * xmlCatalogGetDefaults:
3484  *
3485  * Used to get the user preference w.r.t. to what catalogs should
3486  * be accepted
3487  *
3488  * Returns the current xmlCatalogAllow value
3489  */
3490 xmlCatalogAllow
3491 xmlCatalogGetDefaults(void) {
3492     return(xmlCatalogDefaultAllow);
3493 }
3494
3495 /**
3496  * xmlCatalogSetDefaults:
3497  * @allow:  what catalogs should be accepted
3498  *
3499  * Used to set the user preference w.r.t. to what catalogs should
3500  * be accepted
3501  */
3502 void
3503 xmlCatalogSetDefaults(xmlCatalogAllow allow) {
3504     if (xmlDebugCatalogs) {
3505         switch (allow) {
3506             case XML_CATA_ALLOW_NONE:
3507                 xmlGenericError(xmlGenericErrorContext,
3508                         "Disabling catalog usage\n");
3509                 break;
3510             case XML_CATA_ALLOW_GLOBAL:
3511                 xmlGenericError(xmlGenericErrorContext,
3512                         "Allowing only global catalogs\n");
3513                 break;
3514             case XML_CATA_ALLOW_DOCUMENT:
3515                 xmlGenericError(xmlGenericErrorContext,
3516                         "Allowing only catalogs from the document\n");
3517                 break;
3518             case XML_CATA_ALLOW_ALL:
3519                 xmlGenericError(xmlGenericErrorContext,
3520                         "Allowing all catalogs\n");
3521                 break;
3522         }
3523     }
3524     xmlCatalogDefaultAllow = allow;
3525 }
3526
3527 /**
3528  * xmlCatalogSetDefaultPrefer:
3529  * @prefer:  the default preference for delegation
3530  *
3531  * Allows to set the preference between public and system for deletion
3532  * in XML Catalog resolution. C.f. section 4.1.1 of the spec
3533  * Values accepted are XML_CATA_PREFER_PUBLIC or XML_CATA_PREFER_SYSTEM
3534  *
3535  * Returns the previous value of the default preference for delegation
3536  */
3537 xmlCatalogPrefer
3538 xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer) {
3539     xmlCatalogPrefer ret = xmlCatalogDefaultPrefer;
3540
3541     if (prefer == XML_CATA_PREFER_NONE)
3542         return(ret);
3543
3544     if (xmlDebugCatalogs) {
3545         switch (prefer) {
3546             case XML_CATA_PREFER_PUBLIC:
3547                 xmlGenericError(xmlGenericErrorContext,
3548                         "Setting catalog preference to PUBLIC\n");
3549                 break;
3550             case XML_CATA_PREFER_SYSTEM:
3551                 xmlGenericError(xmlGenericErrorContext,
3552                         "Setting catalog preference to SYSTEM\n");
3553                 break;
3554             case XML_CATA_PREFER_NONE:
3555                 break;
3556         }
3557     }
3558     xmlCatalogDefaultPrefer = prefer;
3559     return(ret);
3560 }
3561
3562 /**
3563  * xmlCatalogSetDebug:
3564  * @level:  the debug level of catalogs required
3565  *
3566  * Used to set the debug level for catalog operation, 0 disable
3567  * debugging, 1 enable it
3568  *
3569  * Returns the previous value of the catalog debugging level
3570  */
3571 int
3572 xmlCatalogSetDebug(int level) {
3573     int ret = xmlDebugCatalogs;
3574
3575     if (level <= 0)
3576         xmlDebugCatalogs = 0;
3577     else
3578         xmlDebugCatalogs = level;
3579     return(ret);
3580 }
3581
3582 /************************************************************************
3583  *                                                                      *
3584  *   Minimal interfaces used for per-document catalogs by the parser    *
3585  *                                                                      *
3586  ************************************************************************/
3587
3588 /**
3589  * xmlCatalogFreeLocal:
3590  * @catalogs:  a document's list of catalogs
3591  *
3592  * Free up the memory associated to the catalog list
3593  */
3594 void
3595 xmlCatalogFreeLocal(void *catalogs) {
3596     xmlCatalogEntryPtr catal;
3597
3598     if (!xmlCatalogInitialized)
3599         xmlInitializeCatalog();
3600
3601     catal = (xmlCatalogEntryPtr) catalogs;
3602     if (catal != NULL)
3603         xmlFreeCatalogEntryList(catal);
3604 }
3605
3606
3607 /**
3608  * xmlCatalogAddLocal:
3609  * @catalogs:  a document's list of catalogs
3610  * @URL:  the URL to a new local catalog
3611  *
3612  * Add the new entry to the catalog list
3613  *
3614  * Returns the updated list
3615  */
3616 void *
3617 xmlCatalogAddLocal(void *catalogs, const xmlChar *URL) {
3618     xmlCatalogEntryPtr catal, add;
3619
3620     if (!xmlCatalogInitialized)
3621         xmlInitializeCatalog();
3622
3623     if (URL == NULL)
3624         return(catalogs);
3625
3626     if (xmlDebugCatalogs)
3627         xmlGenericError(xmlGenericErrorContext,
3628                 "Adding document catalog %s\n", URL);
3629
3630     add = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL, URL, NULL,
3631                              xmlCatalogDefaultPrefer, NULL);
3632     if (add == NULL)
3633         return(catalogs);
3634
3635     catal = (xmlCatalogEntryPtr) catalogs;
3636     if (catal == NULL)
3637         return((void *) add);
3638
3639     while (catal->next != NULL)
3640         catal = catal->next;
3641     catal->next = add;
3642     return(catalogs);
3643 }
3644
3645 /**
3646  * xmlCatalogLocalResolve:
3647  * @catalogs:  a document's list of catalogs
3648  * @pubID:  the public ID string
3649  * @sysID:  the system ID string
3650  *
3651  * Do a complete resolution lookup of an External Identifier using a
3652  * document's private catalog list
3653  *
3654  * Returns the URI of the resource or NULL if not found, it must be freed
3655  *      by the caller.
3656  */
3657 xmlChar *
3658 xmlCatalogLocalResolve(void *catalogs, const xmlChar *pubID,
3659                        const xmlChar *sysID) {
3660     xmlCatalogEntryPtr catal;
3661     xmlChar *ret;
3662
3663     if (!xmlCatalogInitialized)
3664         xmlInitializeCatalog();
3665
3666     if ((pubID == NULL) && (sysID == NULL))
3667         return(NULL);
3668
3669     if (xmlDebugCatalogs) {
3670         if ((pubID != NULL) && (sysID != NULL)) {
3671             xmlGenericError(xmlGenericErrorContext,
3672                             "Local Resolve: pubID %s sysID %s\n", pubID, sysID);
3673         } else if (pubID != NULL) {
3674             xmlGenericError(xmlGenericErrorContext,
3675                             "Local Resolve: pubID %s\n", pubID);
3676         } else {
3677             xmlGenericError(xmlGenericErrorContext,
3678                             "Local Resolve: sysID %s\n", sysID);
3679         }
3680     }
3681
3682     catal = (xmlCatalogEntryPtr) catalogs;
3683     if (catal == NULL)
3684         return(NULL);
3685     ret = xmlCatalogListXMLResolve(catal, pubID, sysID);
3686     if ((ret != NULL) && (ret != XML_CATAL_BREAK))
3687         return(ret);
3688     return(NULL);
3689 }
3690
3691 /**
3692  * xmlCatalogLocalResolveURI:
3693  * @catalogs:  a document's list of catalogs
3694  * @URI:  the URI
3695  *
3696  * Do a complete resolution lookup of an URI using a
3697  * document's private catalog list
3698  *
3699  * Returns the URI of the resource or NULL if not found, it must be freed
3700  *      by the caller.
3701  */
3702 xmlChar *
3703 xmlCatalogLocalResolveURI(void *catalogs, const xmlChar *URI) {
3704     xmlCatalogEntryPtr catal;
3705     xmlChar *ret;
3706
3707     if (!xmlCatalogInitialized)
3708         xmlInitializeCatalog();
3709
3710     if (URI == NULL)
3711         return(NULL);
3712
3713     if (xmlDebugCatalogs)
3714         xmlGenericError(xmlGenericErrorContext,
3715                 "Resolve URI %s\n", URI);
3716
3717     catal = (xmlCatalogEntryPtr) catalogs;
3718     if (catal == NULL)
3719         return(NULL);
3720     ret = xmlCatalogListXMLResolveURI(catal, URI);
3721     if ((ret != NULL) && (ret != XML_CATAL_BREAK))
3722         return(ret);
3723     return(NULL);
3724 }
3725
3726 /************************************************************************
3727  *                                                                      *
3728  *                      Deprecated interfaces                           *
3729  *                                                                      *
3730  ************************************************************************/
3731 /**
3732  * xmlCatalogGetSystem:
3733  * @sysID:  the system ID string
3734  *
3735  * Try to lookup the catalog reference associated to a system ID
3736  * DEPRECATED, use xmlCatalogResolveSystem()
3737  *
3738  * Returns the resource if found or NULL otherwise.
3739  */
3740 const xmlChar *
3741 xmlCatalogGetSystem(const xmlChar *sysID) {
3742     xmlChar *ret;
3743     static xmlChar result[1000];
3744     static int msg = 0;
3745
3746     if (!xmlCatalogInitialized)
3747         xmlInitializeCatalog();
3748
3749     if (msg == 0) {
3750         xmlGenericError(xmlGenericErrorContext,
3751                 "Use of deprecated xmlCatalogGetSystem() call\n");
3752         msg++;
3753     }
3754
3755     if (sysID == NULL)
3756         return(NULL);
3757
3758     /*
3759      * Check first the XML catalogs
3760      */
3761     if (xmlDefaultCatalog != NULL) {
3762         ret = xmlCatalogListXMLResolve(xmlDefaultCatalog->xml, NULL, sysID);
3763         if ((ret != NULL) && (ret != XML_CATAL_BREAK)) {
3764             snprintf((char *) result, sizeof(result) - 1, "%s", (char *) ret);
3765             result[sizeof(result) - 1] = 0;
3766             return(result);
3767         }
3768     }
3769
3770     if (xmlDefaultCatalog != NULL)
3771         return(xmlCatalogGetSGMLSystem(xmlDefaultCatalog->sgml, sysID));
3772     return(NULL);
3773 }
3774
3775 /**
3776  * xmlCatalogGetPublic:
3777  * @pubID:  the public ID string
3778  *
3779  * Try to lookup the catalog reference associated to a public ID
3780  * DEPRECATED, use xmlCatalogResolvePublic()
3781  *
3782  * Returns the resource if found or NULL otherwise.
3783  */
3784 const xmlChar *
3785 xmlCatalogGetPublic(const xmlChar *pubID) {
3786     xmlChar *ret;
3787     static xmlChar result[1000];
3788     static int msg = 0;
3789
3790     if (!xmlCatalogInitialized)
3791         xmlInitializeCatalog();
3792
3793     if (msg == 0) {
3794         xmlGenericError(xmlGenericErrorContext,
3795                 "Use of deprecated xmlCatalogGetPublic() call\n");
3796         msg++;
3797     }
3798
3799     if (pubID == NULL)
3800         return(NULL);
3801
3802     /*
3803      * Check first the XML catalogs
3804      */
3805     if (xmlDefaultCatalog != NULL) {
3806         ret = xmlCatalogListXMLResolve(xmlDefaultCatalog->xml, pubID, NULL);
3807         if ((ret != NULL) && (ret != XML_CATAL_BREAK)) {
3808             snprintf((char *) result, sizeof(result) - 1, "%s", (char *) ret);
3809             result[sizeof(result) - 1] = 0;
3810             return(result);
3811         }
3812     }
3813
3814     if (xmlDefaultCatalog != NULL)
3815         return(xmlCatalogGetSGMLPublic(xmlDefaultCatalog->sgml, pubID));
3816     return(NULL);
3817 }
3818
3819 #define bottom_catalog
3820 #include "elfgcchack.h"
3821 #endif /* LIBXML_CATALOG_ENABLED */