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