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