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