1: /*
2: * "Canonical XML" implementation
3: * http://www.w3.org/TR/xml-c14n
4: *
5: * "Exclusive XML Canonicalization" implementation
6: * http://www.w3.org/TR/xml-exc-c14n
7: *
8: * See Copyright for the status of this software.
9: *
10: * Author: Aleksey Sanin <aleksey@aleksey.com>
11: */
12: #define IN_LIBXML
13: #include "libxml.h"
14: #ifdef LIBXML_C14N_ENABLED
15: #ifdef LIBXML_OUTPUT_ENABLED
16:
17: #ifdef HAVE_STDLIB_H
18: #include <stdlib.h>
19: #endif
20: #include <string.h>
21:
22: #include <libxml/tree.h>
23: #include <libxml/parser.h>
24: #include <libxml/uri.h>
25: #include <libxml/xmlerror.h>
26: #include <libxml/globals.h>
27: #include <libxml/xpathInternals.h>
28: #include <libxml/c14n.h>
29:
30: #include "buf.h"
31:
32: /************************************************************************
33: * *
34: * Some declaration better left private ATM *
35: * *
36: ************************************************************************/
37:
38: typedef enum {
39: XMLC14N_BEFORE_DOCUMENT_ELEMENT = 0,
40: XMLC14N_INSIDE_DOCUMENT_ELEMENT = 1,
41: XMLC14N_AFTER_DOCUMENT_ELEMENT = 2
42: } xmlC14NPosition;
43:
44: typedef struct _xmlC14NVisibleNsStack {
45: int nsCurEnd; /* number of nodes in the set */
46: int nsPrevStart; /* the begginning of the stack for previous visible node */
47: int nsPrevEnd; /* the end of the stack for previous visible node */
48: int nsMax; /* size of the array as allocated */
49: xmlNsPtr *nsTab; /* array of ns in no particular order */
50: xmlNodePtr *nodeTab; /* array of nodes in no particular order */
51: } xmlC14NVisibleNsStack, *xmlC14NVisibleNsStackPtr;
52:
53: typedef struct _xmlC14NCtx {
54: /* input parameters */
55: xmlDocPtr doc;
56: xmlC14NIsVisibleCallback is_visible_callback;
57: void* user_data;
58: int with_comments;
59: xmlOutputBufferPtr buf;
60:
61: /* position in the XML document */
62: xmlC14NPosition pos;
63: int parent_is_doc;
64: xmlC14NVisibleNsStackPtr ns_rendered;
65:
66: /* C14N mode */
67: xmlC14NMode mode;
68:
69: /* exclusive canonicalization */
70: xmlChar **inclusive_ns_prefixes;
71:
72: /* error number */
73: int error;
74: } xmlC14NCtx, *xmlC14NCtxPtr;
75:
76: static xmlC14NVisibleNsStackPtr xmlC14NVisibleNsStackCreate (void);
77: static void xmlC14NVisibleNsStackDestroy (xmlC14NVisibleNsStackPtr cur);
78: static void xmlC14NVisibleNsStackAdd (xmlC14NVisibleNsStackPtr cur,
79: xmlNsPtr ns,
80: xmlNodePtr node);
81: static void xmlC14NVisibleNsStackSave (xmlC14NVisibleNsStackPtr cur,
82: xmlC14NVisibleNsStackPtr state);
83: static void xmlC14NVisibleNsStackRestore (xmlC14NVisibleNsStackPtr cur,
84: xmlC14NVisibleNsStackPtr state);
85: static void xmlC14NVisibleNsStackShift (xmlC14NVisibleNsStackPtr cur);
86: static int xmlC14NVisibleNsStackFind (xmlC14NVisibleNsStackPtr cur,
87: xmlNsPtr ns);
88: static int xmlExcC14NVisibleNsStackFind (xmlC14NVisibleNsStackPtr cur,
89: xmlNsPtr ns,
90: xmlC14NCtxPtr ctx);
91:
92: static int xmlC14NIsNodeInNodeset (xmlNodeSetPtr nodes,
93: xmlNodePtr node,
94: xmlNodePtr parent);
95:
96:
97:
98: static int xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur);
99: static int xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur);
100: typedef enum {
101: XMLC14N_NORMALIZE_ATTR = 0,
102: XMLC14N_NORMALIZE_COMMENT = 1,
103: XMLC14N_NORMALIZE_PI = 2,
104: XMLC14N_NORMALIZE_TEXT = 3
105: } xmlC14NNormalizationMode;
106:
107: static xmlChar *xmlC11NNormalizeString(const xmlChar * input,
108: xmlC14NNormalizationMode mode);
109:
110: #define xmlC11NNormalizeAttr( a ) \
111: xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_ATTR)
112: #define xmlC11NNormalizeComment( a ) \
113: xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_COMMENT)
114: #define xmlC11NNormalizePI( a ) \
115: xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_PI)
116: #define xmlC11NNormalizeText( a ) \
117: xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_TEXT)
118:
119: #define xmlC14NIsVisible( ctx, node, parent ) \
120: (((ctx)->is_visible_callback != NULL) ? \
121: (ctx)->is_visible_callback((ctx)->user_data, \
122: (xmlNodePtr)(node), (xmlNodePtr)(parent)) : 1)
123:
124: #define xmlC14NIsExclusive( ctx ) \
125: ( (ctx)->mode == XML_C14N_EXCLUSIVE_1_0 )
126:
127: /************************************************************************
128: * *
129: * Some factorized error routines *
130: * *
131: ************************************************************************/
132:
133: /**
134: * xmlC14NErrMemory:
135: * @extra: extra informations
136: *
137: * Handle a redefinition of memory error
138: */
139: static void
140: xmlC14NErrMemory(const char *extra)
141: {
142: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_C14N,
143: XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0, extra,
144: NULL, NULL, 0, 0,
145: "Memory allocation failed : %s\n", extra);
146: }
147:
148: /**
149: * xmlC14NErrParam:
150: * @extra: extra informations
151: *
152: * Handle a redefinition of param error
153: */
154: static void
155: xmlC14NErrParam(const char *extra)
156: {
157: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_C14N,
158: XML_ERR_INTERNAL_ERROR, XML_ERR_ERROR, NULL, 0, extra,
159: NULL, NULL, 0, 0,
160: "Invalid parameter : %s\n", extra);
161: }
162:
163: /**
164: * xmlC14NErrInternal:
165: * @extra: extra informations
166: *
167: * Handle a redefinition of internal error
168: */
169: static void
170: xmlC14NErrInternal(const char *extra)
171: {
172: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_C14N,
173: XML_ERR_INTERNAL_ERROR, XML_ERR_ERROR, NULL, 0, extra,
174: NULL, NULL, 0, 0,
175: "Internal error : %s\n", extra);
176: }
177:
178: /**
179: * xmlC14NErrInvalidNode:
180: * @extra: extra informations
181: *
182: * Handle a redefinition of invalid node error
183: */
184: static void
185: xmlC14NErrInvalidNode(const char *node_type, const char *extra)
186: {
187: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_C14N,
188: XML_C14N_INVALID_NODE, XML_ERR_ERROR, NULL, 0, extra,
189: NULL, NULL, 0, 0,
190: "Node %s is invalid here : %s\n", node_type, extra);
191: }
192:
193: /**
194: * xmlC14NErrUnknownNode:
195: * @extra: extra informations
196: *
197: * Handle a redefinition of unknown node error
198: */
199: static void
200: xmlC14NErrUnknownNode(int node_type, const char *extra)
201: {
202: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_C14N,
203: XML_C14N_UNKNOW_NODE, XML_ERR_ERROR, NULL, 0, extra,
204: NULL, NULL, 0, 0,
205: "Unknown node type %d found : %s\n", node_type, extra);
206: }
207:
208: /**
209: * xmlC14NErrRelativeNamespace:
210: * @extra: extra informations
211: *
212: * Handle a redefinition of relative namespace error
213: */
214: static void
215: xmlC14NErrRelativeNamespace(const char *ns_uri)
216: {
217: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_C14N,
218: XML_C14N_RELATIVE_NAMESPACE, XML_ERR_ERROR, NULL, 0, NULL,
219: NULL, NULL, 0, 0,
220: "Relative namespace UR is invalid here : %s\n", ns_uri);
221: }
222:
223:
224:
225: /**
226: * xmlC14NErr:
227: * @ctxt: a C14N evaluation context
228: * @node: the context node
229: * @error: the erorr code
230: * @msg: the message
231: * @extra: extra informations
232: *
233: * Handle a redefinition of attribute error
234: */
235: static void
236: xmlC14NErr(xmlC14NCtxPtr ctxt, xmlNodePtr node, int error,
237: const char * msg)
238: {
239: if (ctxt != NULL)
240: ctxt->error = error;
241: __xmlRaiseError(NULL, NULL, NULL,
242: ctxt, node, XML_FROM_C14N, error,
243: XML_ERR_ERROR, NULL, 0,
244: NULL, NULL, NULL, 0, 0, "%s", msg);
245: }
246:
247: /************************************************************************
248: * *
249: * The implementation internals *
250: * *
251: ************************************************************************/
252: #define XML_NAMESPACES_DEFAULT 16
253:
254: static int
255: xmlC14NIsNodeInNodeset(xmlNodeSetPtr nodes, xmlNodePtr node, xmlNodePtr parent) {
256: if((nodes != NULL) && (node != NULL)) {
257: if(node->type != XML_NAMESPACE_DECL) {
258: return(xmlXPathNodeSetContains(nodes, node));
259: } else {
260: xmlNs ns;
261:
262: memcpy(&ns, node, sizeof(ns));
263:
264: /* this is a libxml hack! check xpath.c for details */
265: if((parent != NULL) && (parent->type == XML_ATTRIBUTE_NODE)) {
266: ns.next = (xmlNsPtr)parent->parent;
267: } else {
268: ns.next = (xmlNsPtr)parent;
269: }
270:
271: /*
272: * If the input is an XPath node-set, then the node-set must explicitly
273: * contain every node to be rendered to the canonical form.
274: */
275: return(xmlXPathNodeSetContains(nodes, (xmlNodePtr)&ns));
276: }
277: }
278: return(1);
279: }
280:
281: static xmlC14NVisibleNsStackPtr
282: xmlC14NVisibleNsStackCreate(void) {
283: xmlC14NVisibleNsStackPtr ret;
284:
285: ret = (xmlC14NVisibleNsStackPtr) xmlMalloc(sizeof(xmlC14NVisibleNsStack));
286: if (ret == NULL) {
287: xmlC14NErrMemory("creating namespaces stack");
288: return(NULL);
289: }
290: memset(ret, 0 , (size_t) sizeof(xmlC14NVisibleNsStack));
291: return(ret);
292: }
293:
294: static void
295: xmlC14NVisibleNsStackDestroy(xmlC14NVisibleNsStackPtr cur) {
296: if(cur == NULL) {
297: xmlC14NErrParam("destroying namespaces stack");
298: return;
299: }
300: if(cur->nsTab != NULL) {
301: memset(cur->nsTab, 0, cur->nsMax * sizeof(xmlNsPtr));
302: xmlFree(cur->nsTab);
303: }
304: if(cur->nodeTab != NULL) {
305: memset(cur->nodeTab, 0, cur->nsMax * sizeof(xmlNodePtr));
306: xmlFree(cur->nodeTab);
307: }
308: memset(cur, 0, sizeof(xmlC14NVisibleNsStack));
309: xmlFree(cur);
310:
311: }
312:
313: static void
314: xmlC14NVisibleNsStackAdd(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlNodePtr node) {
315: if((cur == NULL) ||
316: ((cur->nsTab == NULL) && (cur->nodeTab != NULL)) ||
317: ((cur->nsTab != NULL) && (cur->nodeTab == NULL))) {
318: xmlC14NErrParam("adding namespace to stack");
319: return;
320: }
321:
322: if ((cur->nsTab == NULL) && (cur->nodeTab == NULL)) {
323: cur->nsTab = (xmlNsPtr*) xmlMalloc(XML_NAMESPACES_DEFAULT * sizeof(xmlNsPtr));
324: cur->nodeTab = (xmlNodePtr*) xmlMalloc(XML_NAMESPACES_DEFAULT * sizeof(xmlNodePtr));
325: if ((cur->nsTab == NULL) || (cur->nodeTab == NULL)) {
326: xmlC14NErrMemory("adding node to stack");
327: return;
328: }
329: memset(cur->nsTab, 0 , XML_NAMESPACES_DEFAULT * sizeof(xmlNsPtr));
330: memset(cur->nodeTab, 0 , XML_NAMESPACES_DEFAULT * sizeof(xmlNodePtr));
331: cur->nsMax = XML_NAMESPACES_DEFAULT;
332: } else if(cur->nsMax == cur->nsCurEnd) {
333: void *tmp;
334: int tmpSize;
335:
336: tmpSize = 2 * cur->nsMax;
337: tmp = xmlRealloc(cur->nsTab, tmpSize * sizeof(xmlNsPtr));
338: if (tmp == NULL) {
339: xmlC14NErrMemory("adding node to stack");
340: return;
341: }
342: cur->nsTab = (xmlNsPtr*)tmp;
343:
344: tmp = xmlRealloc(cur->nodeTab, tmpSize * sizeof(xmlNodePtr));
345: if (tmp == NULL) {
346: xmlC14NErrMemory("adding node to stack");
347: return;
348: }
349: cur->nodeTab = (xmlNodePtr*)tmp;
350:
351: cur->nsMax = tmpSize;
352: }
353: cur->nsTab[cur->nsCurEnd] = ns;
354: cur->nodeTab[cur->nsCurEnd] = node;
355:
356: ++cur->nsCurEnd;
357: }
358:
359: static void
360: xmlC14NVisibleNsStackSave(xmlC14NVisibleNsStackPtr cur, xmlC14NVisibleNsStackPtr state) {
361: if((cur == NULL) || (state == NULL)) {
362: xmlC14NErrParam("saving namespaces stack");
363: return;
364: }
365:
366: state->nsCurEnd = cur->nsCurEnd;
367: state->nsPrevStart = cur->nsPrevStart;
368: state->nsPrevEnd = cur->nsPrevEnd;
369: }
370:
371: static void
372: xmlC14NVisibleNsStackRestore(xmlC14NVisibleNsStackPtr cur, xmlC14NVisibleNsStackPtr state) {
373: if((cur == NULL) || (state == NULL)) {
374: xmlC14NErrParam("restoring namespaces stack");
375: return;
376: }
377: cur->nsCurEnd = state->nsCurEnd;
378: cur->nsPrevStart = state->nsPrevStart;
379: cur->nsPrevEnd = state->nsPrevEnd;
380: }
381:
382: static void
383: xmlC14NVisibleNsStackShift(xmlC14NVisibleNsStackPtr cur) {
384: if(cur == NULL) {
385: xmlC14NErrParam("shifting namespaces stack");
386: return;
387: }
388: cur->nsPrevStart = cur->nsPrevEnd;
389: cur->nsPrevEnd = cur->nsCurEnd;
390: }
391:
392: static int
393: xmlC14NStrEqual(const xmlChar *str1, const xmlChar *str2) {
394: if (str1 == str2) return(1);
395: if (str1 == NULL) return((*str2) == '\0');
396: if (str2 == NULL) return((*str1) == '\0');
397: do {
398: if (*str1++ != *str2) return(0);
399: } while (*str2++);
400: return(1);
401: }
402:
403: /**
404: * xmlC14NVisibleNsStackFind:
405: * @ctx: the C14N context
406: * @ns: the namespace to check
407: *
408: * Checks whether the given namespace was already rendered or not
409: *
410: * Returns 1 if we already wrote this namespace or 0 otherwise
411: */
412: static int
413: xmlC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns)
414: {
415: int i;
416: const xmlChar *prefix;
417: const xmlChar *href;
418: int has_empty_ns;
419:
420: if(cur == NULL) {
421: xmlC14NErrParam("searching namespaces stack (c14n)");
422: return (0);
423: }
424:
425: /*
426: * if the default namespace xmlns="" is not defined yet then
427: * we do not want to print it out
428: */
429: prefix = ((ns == NULL) || (ns->prefix == NULL)) ? BAD_CAST "" : ns->prefix;
430: href = ((ns == NULL) || (ns->href == NULL)) ? BAD_CAST "" : ns->href;
431: has_empty_ns = (xmlC14NStrEqual(prefix, NULL) && xmlC14NStrEqual(href, NULL));
432:
433: if (cur->nsTab != NULL) {
434: int start = (has_empty_ns) ? 0 : cur->nsPrevStart;
435: for (i = cur->nsCurEnd - 1; i >= start; --i) {
436: xmlNsPtr ns1 = cur->nsTab[i];
437:
438: if(xmlC14NStrEqual(prefix, (ns1 != NULL) ? ns1->prefix : NULL)) {
439: return(xmlC14NStrEqual(href, (ns1 != NULL) ? ns1->href : NULL));
440: }
441: }
442: }
443: return(has_empty_ns);
444: }
445:
446: static int
447: xmlExcC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlC14NCtxPtr ctx) {
448: int i;
449: const xmlChar *prefix;
450: const xmlChar *href;
451: int has_empty_ns;
452:
453: if(cur == NULL) {
454: xmlC14NErrParam("searching namespaces stack (exc c14n)");
455: return (0);
456: }
457:
458: /*
459: * if the default namespace xmlns="" is not defined yet then
460: * we do not want to print it out
461: */
462: prefix = ((ns == NULL) || (ns->prefix == NULL)) ? BAD_CAST "" : ns->prefix;
463: href = ((ns == NULL) || (ns->href == NULL)) ? BAD_CAST "" : ns->href;
464: has_empty_ns = (xmlC14NStrEqual(prefix, NULL) && xmlC14NStrEqual(href, NULL));
465:
466: if (cur->nsTab != NULL) {
467: int start = 0;
468: for (i = cur->nsCurEnd - 1; i >= start; --i) {
469: xmlNsPtr ns1 = cur->nsTab[i];
470:
471: if(xmlC14NStrEqual(prefix, (ns1 != NULL) ? ns1->prefix : NULL)) {
472: if(xmlC14NStrEqual(href, (ns1 != NULL) ? ns1->href : NULL)) {
473: return(xmlC14NIsVisible(ctx, ns1, cur->nodeTab[i]));
474: } else {
475: return(0);
476: }
477: }
478: }
479: }
480: return(has_empty_ns);
481: }
482:
483:
484:
485:
486: /**
487: * xmlC14NIsXmlNs:
488: * @ns: the namespace to check
489: *
490: * Checks whether the given namespace is a default "xml:" namespace
491: * with href="http://www.w3.org/XML/1998/namespace"
492: *
493: * Returns 1 if the node is default or 0 otherwise
494: */
495:
496: /* todo: make it a define? */
497: static int
498: xmlC14NIsXmlNs(xmlNsPtr ns)
499: {
500: return ((ns != NULL) &&
501: (xmlStrEqual(ns->prefix, BAD_CAST "xml")) &&
502: (xmlStrEqual(ns->href, XML_XML_NAMESPACE)));
503: }
504:
505:
506: /**
507: * xmlC14NNsCompare:
508: * @ns1: the pointer to first namespace
509: * @ns2: the pointer to second namespace
510: *
511: * Compares the namespaces by names (prefixes).
512: *
513: * Returns -1 if ns1 < ns2, 0 if ns1 == ns2 or 1 if ns1 > ns2.
514: */
515: static int
516: xmlC14NNsCompare(xmlNsPtr ns1, xmlNsPtr ns2)
517: {
518: if (ns1 == ns2)
519: return (0);
520: if (ns1 == NULL)
521: return (-1);
522: if (ns2 == NULL)
523: return (1);
524:
525: return (xmlStrcmp(ns1->prefix, ns2->prefix));
526: }
527:
528:
529: /**
530: * xmlC14NPrintNamespaces:
531: * @ns: the pointer to namespace
532: * @ctx: the C14N context
533: *
534: * Prints the given namespace to the output buffer from C14N context.
535: *
536: * Returns 1 on success or 0 on fail.
537: */
538: static int
539: xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx)
540: {
541:
542: if ((ns == NULL) || (ctx == NULL)) {
543: xmlC14NErrParam("writing namespaces");
544: return 0;
545: }
546:
547: if (ns->prefix != NULL) {
548: xmlOutputBufferWriteString(ctx->buf, " xmlns:");
549: xmlOutputBufferWriteString(ctx->buf, (const char *) ns->prefix);
550: xmlOutputBufferWriteString(ctx->buf, "=\"");
551: } else {
552: xmlOutputBufferWriteString(ctx->buf, " xmlns=\"");
553: }
554: if(ns->href != NULL) {
555: xmlOutputBufferWriteString(ctx->buf, (const char *) ns->href);
556: }
557: xmlOutputBufferWriteString(ctx->buf, "\"");
558: return (1);
559: }
560:
561: /**
562: * xmlC14NProcessNamespacesAxis:
563: * @ctx: the C14N context
564: * @node: the current node
565: *
566: * Prints out canonical namespace axis of the current node to the
567: * buffer from C14N context as follows
568: *
569: * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
570: *
571: * Namespace Axis
572: * Consider a list L containing only namespace nodes in the
573: * axis and in the node-set in lexicographic order (ascending). To begin
574: * processing L, if the first node is not the default namespace node (a node
575: * with no namespace URI and no local name), then generate a space followed
576: * by xmlns="" if and only if the following conditions are met:
577: * - the element E that owns the axis is in the node-set
578: * - The nearest ancestor element of E in the node-set has a default
579: * namespace node in the node-set (default namespace nodes always
580: * have non-empty values in XPath)
581: * The latter condition eliminates unnecessary occurrences of xmlns="" in
582: * the canonical form since an element only receives an xmlns="" if its
583: * default namespace is empty and if it has an immediate parent in the
584: * canonical form that has a non-empty default namespace. To finish
585: * processing L, simply process every namespace node in L, except omit
586: * namespace node with local name xml, which defines the xml prefix,
587: * if its string value is http://www.w3.org/XML/1998/namespace.
588: *
589: * Exclusive XML Canonicalization v 1.0 (http://www.w3.org/TR/xml-exc-c14n)
590: * Canonical XML applied to a document subset requires the search of the
591: * ancestor nodes of each orphan element node for attributes in the xml
592: * namespace, such as xml:lang and xml:space. These are copied into the
593: * element node except if a declaration of the same attribute is already
594: * in the attribute axis of the element (whether or not it is included in
595: * the document subset). This search and copying are omitted from the
596: * Exclusive XML Canonicalization method.
597: *
598: * Returns 0 on success or -1 on fail.
599: */
600: static int
601: xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
602: {
603: xmlNodePtr n;
604: xmlNsPtr ns, tmp;
605: xmlListPtr list;
606: int already_rendered;
607: int has_empty_ns = 0;
608:
609: if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
610: xmlC14NErrParam("processing namespaces axis (c14n)");
611: return (-1);
612: }
613:
614: /*
615: * Create a sorted list to store element namespaces
616: */
617: list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNsCompare);
618: if (list == NULL) {
619: xmlC14NErrInternal("creating namespaces list (c14n)");
620: return (-1);
621: }
622:
623: /* check all namespaces */
624: for(n = cur; n != NULL; n = n->parent) {
625: for(ns = n->nsDef; ns != NULL; ns = ns->next) {
626: tmp = xmlSearchNs(cur->doc, cur, ns->prefix);
627:
628: if((tmp == ns) && !xmlC14NIsXmlNs(ns) && xmlC14NIsVisible(ctx, ns, cur)) {
629: already_rendered = xmlC14NVisibleNsStackFind(ctx->ns_rendered, ns);
630: if(visible) {
631: xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur);
632: }
633: if(!already_rendered) {
634: xmlListInsert(list, ns);
635: }
636: if(xmlStrlen(ns->prefix) == 0) {
637: has_empty_ns = 1;
638: }
639: }
640: }
641: }
642:
643: /**
644: * if the first node is not the default namespace node (a node with no
645: * namespace URI and no local name), then generate a space followed by
646: * xmlns="" if and only if the following conditions are met:
647: * - the element E that owns the axis is in the node-set
648: * - the nearest ancestor element of E in the node-set has a default
649: * namespace node in the node-set (default namespace nodes always
650: * have non-empty values in XPath)
651: */
652: if(visible && !has_empty_ns) {
653: static xmlNs ns_default;
654:
655: memset(&ns_default, 0, sizeof(ns_default));
656: if(!xmlC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default)) {
657: xmlC14NPrintNamespaces(&ns_default, ctx);
658: }
659: }
660:
661:
662: /*
663: * print out all elements from list
664: */
665: xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces, (const void *) ctx);
666:
667: /*
668: * Cleanup
669: */
670: xmlListDelete(list);
671: return (0);
672: }
673:
674:
675: /**
676: * xmlExcC14NProcessNamespacesAxis:
677: * @ctx: the C14N context
678: * @node: the current node
679: *
680: * Prints out exclusive canonical namespace axis of the current node to the
681: * buffer from C14N context as follows
682: *
683: * Exclusive XML Canonicalization
684: * http://www.w3.org/TR/xml-exc-c14n
685: *
686: * If the element node is in the XPath subset then output the node in
687: * accordance with Canonical XML except for namespace nodes which are
688: * rendered as follows:
689: *
690: * 1. Render each namespace node iff:
691: * * it is visibly utilized by the immediate parent element or one of
692: * its attributes, or is present in InclusiveNamespaces PrefixList, and
693: * * its prefix and value do not appear in ns_rendered. ns_rendered is
694: * obtained by popping the state stack in order to obtain a list of
695: * prefixes and their values which have already been rendered by
696: * an output ancestor of the namespace node's parent element.
697: * 2. Append the rendered namespace node to the list ns_rendered of namespace
698: * nodes rendered by output ancestors. Push ns_rendered on state stack and
699: * recurse.
700: * 3. After the recursion returns, pop thestate stack.
701: *
702: *
703: * Returns 0 on success or -1 on fail.
704: */
705: static int
706: xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
707: {
708: xmlNsPtr ns;
709: xmlListPtr list;
710: xmlAttrPtr attr;
711: int already_rendered;
712: int has_empty_ns = 0;
713: int has_visibly_utilized_empty_ns = 0;
714: int has_empty_ns_in_inclusive_list = 0;
715:
716: if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
717: xmlC14NErrParam("processing namespaces axis (exc c14n)");
718: return (-1);
719: }
720:
721: if(!xmlC14NIsExclusive(ctx)) {
722: xmlC14NErrParam("processing namespaces axis (exc c14n)");
723: return (-1);
724:
725: }
726:
727: /*
728: * Create a sorted list to store element namespaces
729: */
730: list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNsCompare);
731: if (list == NULL) {
732: xmlC14NErrInternal("creating namespaces list (exc c14n)");
733: return (-1);
734: }
735:
736: /*
737: * process inclusive namespaces:
738: * All namespace nodes appearing on inclusive ns list are
739: * handled as provided in Canonical XML
740: */
741: if(ctx->inclusive_ns_prefixes != NULL) {
742: xmlChar *prefix;
743: int i;
744:
745: for (i = 0; ctx->inclusive_ns_prefixes[i] != NULL; ++i) {
746: prefix = ctx->inclusive_ns_prefixes[i];
747: /*
748: * Special values for namespace with empty prefix
749: */
750: if (xmlStrEqual(prefix, BAD_CAST "#default")
751: || xmlStrEqual(prefix, BAD_CAST "")) {
752: prefix = NULL;
753: has_empty_ns_in_inclusive_list = 1;
754: }
755:
756: ns = xmlSearchNs(cur->doc, cur, prefix);
757: if((ns != NULL) && !xmlC14NIsXmlNs(ns) && xmlC14NIsVisible(ctx, ns, cur)) {
758: already_rendered = xmlC14NVisibleNsStackFind(ctx->ns_rendered, ns);
759: if(visible) {
760: xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur);
761: }
762: if(!already_rendered) {
763: xmlListInsert(list, ns);
764: }
765: if(xmlStrlen(ns->prefix) == 0) {
766: has_empty_ns = 1;
767: }
768: }
769: }
770: }
771:
772: /* add node namespace */
773: if(cur->ns != NULL) {
774: ns = cur->ns;
775: } else {
776: ns = xmlSearchNs(cur->doc, cur, NULL);
777: has_visibly_utilized_empty_ns = 1;
778: }
779: if((ns != NULL) && !xmlC14NIsXmlNs(ns)) {
780: if(visible && xmlC14NIsVisible(ctx, ns, cur)) {
781: if(!xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, ns, ctx)) {
782: xmlListInsert(list, ns);
783: }
784: }
785: if(visible) {
786: xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur);
787: }
788: if(xmlStrlen(ns->prefix) == 0) {
789: has_empty_ns = 1;
790: }
791: }
792:
793:
794: /* add attributes */
795: for(attr = cur->properties; attr != NULL; attr = attr->next) {
796: /*
797: * we need to check that attribute is visible and has non
798: * default namespace (XML Namespaces: "default namespaces
799: * do not apply directly to attributes")
800: */
801: if((attr->ns != NULL) && !xmlC14NIsXmlNs(attr->ns) && xmlC14NIsVisible(ctx, attr, cur)) {
802: already_rendered = xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, attr->ns, ctx);
803: xmlC14NVisibleNsStackAdd(ctx->ns_rendered, attr->ns, cur);
804: if(!already_rendered && visible) {
805: xmlListInsert(list, attr->ns);
806: }
807: if(xmlStrlen(attr->ns->prefix) == 0) {
808: has_empty_ns = 1;
809: }
810: } else if((attr->ns != NULL) && (xmlStrlen(attr->ns->prefix) == 0) && (xmlStrlen(attr->ns->href) == 0)) {
811: has_visibly_utilized_empty_ns = 1;
812: }
813: }
814:
815: /*
816: * Process xmlns=""
817: */
818: if(visible && has_visibly_utilized_empty_ns &&
819: !has_empty_ns && !has_empty_ns_in_inclusive_list) {
820: static xmlNs ns_default;
821:
822: memset(&ns_default, 0, sizeof(ns_default));
823:
824: already_rendered = xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default, ctx);
825: if(!already_rendered) {
826: xmlC14NPrintNamespaces(&ns_default, ctx);
827: }
828: } else if(visible && !has_empty_ns && has_empty_ns_in_inclusive_list) {
829: static xmlNs ns_default;
830:
831: memset(&ns_default, 0, sizeof(ns_default));
832: if(!xmlC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default)) {
833: xmlC14NPrintNamespaces(&ns_default, ctx);
834: }
835: }
836:
837:
838:
839: /*
840: * print out all elements from list
841: */
842: xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces, (const void *) ctx);
843:
844: /*
845: * Cleanup
846: */
847: xmlListDelete(list);
848: return (0);
849: }
850:
851:
852: /**
853: * xmlC14NIsXmlAttr:
854: * @attr: the attr to check
855: *
856: * Checks whether the given attribute is a default "xml:" namespace
857: * with href="http://www.w3.org/XML/1998/namespace"
858: *
859: * Returns 1 if the node is default or 0 otherwise
860: */
861:
862: /* todo: make it a define? */
863: static int
864: xmlC14NIsXmlAttr(xmlAttrPtr attr)
865: {
866: return ((attr->ns != NULL) &&
867: (xmlC14NIsXmlNs(attr->ns) != 0));
868: }
869:
870:
871: /**
872: * xmlC14NAttrsCompare:
873: * @attr1: the pointer tls o first attr
874: * @attr2: the pointer to second attr
875: *
876: * Prints the given attribute to the output buffer from C14N context.
877: *
878: * Returns -1 if attr1 < attr2, 0 if attr1 == attr2 or 1 if attr1 > attr2.
879: */
880: static int
881: xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2)
882: {
883: int ret = 0;
884:
885: /*
886: * Simple cases
887: */
888: if (attr1 == attr2)
889: return (0);
890: if (attr1 == NULL)
891: return (-1);
892: if (attr2 == NULL)
893: return (1);
894: if (attr1->ns == attr2->ns) {
895: return (xmlStrcmp(attr1->name, attr2->name));
896: }
897:
898: /*
899: * Attributes in the default namespace are first
900: * because the default namespace is not applied to
901: * unqualified attributes
902: */
903: if (attr1->ns == NULL)
904: return (-1);
905: if (attr2->ns == NULL)
906: return (1);
907: if (attr1->ns->prefix == NULL)
908: return (-1);
909: if (attr2->ns->prefix == NULL)
910: return (1);
911:
912: ret = xmlStrcmp(attr1->ns->href, attr2->ns->href);
913: if (ret == 0) {
914: ret = xmlStrcmp(attr1->name, attr2->name);
915: }
916: return (ret);
917: }
918:
919:
920: /**
921: * xmlC14NPrintAttrs:
922: * @attr: the pointer to attr
923: * @ctx: the C14N context
924: *
925: * Prints out canonical attribute urrent node to the
926: * buffer from C14N context as follows
927: *
928: * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
929: *
930: * Returns 1 on success or 0 on fail.
931: */
932: static int
933: xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx)
934: {
935: xmlChar *value;
936: xmlChar *buffer;
937:
938: if ((attr == NULL) || (ctx == NULL)) {
939: xmlC14NErrParam("writing attributes");
940: return (0);
941: }
942:
943: xmlOutputBufferWriteString(ctx->buf, " ");
944: if (attr->ns != NULL && xmlStrlen(attr->ns->prefix) > 0) {
945: xmlOutputBufferWriteString(ctx->buf,
946: (const char *) attr->ns->prefix);
947: xmlOutputBufferWriteString(ctx->buf, ":");
948: }
949: xmlOutputBufferWriteString(ctx->buf, (const char *) attr->name);
950: xmlOutputBufferWriteString(ctx->buf, "=\"");
951:
952: value = xmlNodeListGetString(ctx->doc, attr->children, 1);
953: /* todo: should we log an error if value==NULL ? */
954: if (value != NULL) {
955: buffer = xmlC11NNormalizeAttr(value);
956: xmlFree(value);
957: if (buffer != NULL) {
958: xmlOutputBufferWriteString(ctx->buf, (const char *) buffer);
959: xmlFree(buffer);
960: } else {
961: xmlC14NErrInternal("normalizing attributes axis");
962: return (0);
963: }
964: }
965: xmlOutputBufferWriteString(ctx->buf, "\"");
966: return (1);
967: }
968:
969: /**
970: * xmlC14NFindHiddenParentAttr:
971: *
972: * Finds an attribute in a hidden parent node.
973: *
974: * Returns a pointer to the attribute node (if found) or NULL otherwise.
975: */
976: static xmlAttrPtr
977: xmlC14NFindHiddenParentAttr(xmlC14NCtxPtr ctx, xmlNodePtr cur, const xmlChar * name, const xmlChar * ns)
978: {
979: xmlAttrPtr res;
980: while((cur != NULL) && (!xmlC14NIsVisible(ctx, cur, cur->parent))) {
981: res = xmlHasNsProp(cur, name, ns);
982: if(res != NULL) {
983: return res;
984: }
985:
986: cur = cur->parent;
987: }
988:
989: return NULL;
990: }
991:
992: /**
993: * xmlC14NFixupBaseAttr:
994: *
995: * Fixes up the xml:base attribute
996: *
997: * Returns the newly created attribute or NULL
998: */
999: static xmlAttrPtr
1000: xmlC14NFixupBaseAttr(xmlC14NCtxPtr ctx, xmlAttrPtr xml_base_attr)
1001: {
1002: xmlChar * res = NULL;
1003: xmlNodePtr cur;
1004: xmlAttrPtr attr;
1005: xmlChar * tmp_str;
1006: xmlChar * tmp_str2;
1007: int tmp_str_len;
1008:
1009: if ((ctx == NULL) || (xml_base_attr == NULL) || (xml_base_attr->parent == NULL)) {
1010: xmlC14NErrParam("processing xml:base attribute");
1011: return (NULL);
1012: }
1013:
1014: /* start from current value */
1015: res = xmlNodeListGetString(ctx->doc, xml_base_attr->children, 1);
1016: if(res == NULL) {
1017: xmlC14NErrInternal("processing xml:base attribute - can't get attr value");
1018: return (NULL);
1019: }
1020:
1021: /* go up the stack until we find a node that we rendered already */
1022: cur = xml_base_attr->parent->parent;
1023: while((cur != NULL) && (!xmlC14NIsVisible(ctx, cur, cur->parent))) {
1024: attr = xmlHasNsProp(cur, BAD_CAST "base", XML_XML_NAMESPACE);
1025: if(attr != NULL) {
1026: /* get attr value */
1027: tmp_str = xmlNodeListGetString(ctx->doc, attr->children, 1);
1028: if(tmp_str == NULL) {
1029: xmlFree(res);
1030:
1031: xmlC14NErrInternal("processing xml:base attribute - can't get attr value");
1032: return (NULL);
1033: }
1034:
1035: /* we need to add '/' if our current base uri ends with '..' or '.'
1036: to ensure that we are forced to go "up" all the time */
1037: tmp_str_len = xmlStrlen(tmp_str);
1038: if(tmp_str_len > 1 && tmp_str[tmp_str_len - 2] == '.') {
1039: tmp_str2 = xmlStrcat(tmp_str, BAD_CAST "/");
1040: if(tmp_str2 == NULL) {
1041: xmlFree(tmp_str);
1042: xmlFree(res);
1043:
1044: xmlC14NErrInternal("processing xml:base attribute - can't modify uri");
1045: return (NULL);
1046: }
1047:
1048: tmp_str = tmp_str2;
1049: }
1050:
1051: /* build uri */
1052: tmp_str2 = xmlBuildURI(res, tmp_str);
1053: if(tmp_str2 == NULL) {
1054: xmlFree(tmp_str);
1055: xmlFree(res);
1056:
1057: xmlC14NErrInternal("processing xml:base attribute - can't construct uri");
1058: return (NULL);
1059: }
1060:
1061: /* cleanup and set the new res */
1062: xmlFree(tmp_str);
1063: xmlFree(res);
1064: res = tmp_str2;
1065: }
1066:
1067: /* next */
1068: cur = cur->parent;
1069: }
1070:
1071: /* check if result uri is empty or not */
1072: if((res == NULL) || xmlStrEqual(res, BAD_CAST "")) {
1073: xmlFree(res);
1074: return (NULL);
1075: }
1076:
1077: /* create and return the new attribute node */
1078: attr = xmlNewNsProp(NULL, xml_base_attr->ns, BAD_CAST "base", res);
1079: if(attr == NULL) {
1080: xmlFree(res);
1081:
1082: xmlC14NErrInternal("processing xml:base attribute - can't construct attribute");
1083: return (NULL);
1084: }
1085:
1086: /* done */
1087: xmlFree(res);
1088: return (attr);
1089: }
1090:
1091: /**
1092: * xmlC14NProcessAttrsAxis:
1093: * @ctx: the C14N context
1094: * @cur: the current node
1095: * @parent_visible: the visibility of parent node
1096: * @all_parents_visible: the visibility of all parent nodes
1097: *
1098: * Prints out canonical attribute axis of the current node to the
1099: * buffer from C14N context as follows
1100: *
1101: * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
1102: *
1103: * Attribute Axis
1104: * In lexicographic order (ascending), process each node that
1105: * is in the element's attribute axis and in the node-set.
1106: *
1107: * The processing of an element node E MUST be modified slightly
1108: * when an XPath node-set is given as input and the element's
1109: * parent is omitted from the node-set.
1110: *
1111: *
1112: * Exclusive XML Canonicalization v 1.0 (http://www.w3.org/TR/xml-exc-c14n)
1113: *
1114: * Canonical XML applied to a document subset requires the search of the
1115: * ancestor nodes of each orphan element node for attributes in the xml
1116: * namespace, such as xml:lang and xml:space. These are copied into the
1117: * element node except if a declaration of the same attribute is already
1118: * in the attribute axis of the element (whether or not it is included in
1119: * the document subset). This search and copying are omitted from the
1120: * Exclusive XML Canonicalization method.
1121: *
1122: * Returns 0 on success or -1 on fail.
1123: */
1124: static int
1125: xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int parent_visible)
1126: {
1127: xmlAttrPtr attr;
1128: xmlListPtr list;
1129: xmlAttrPtr attrs_to_delete = NULL;
1130:
1131: /* special processing for 1.1 spec */
1132: xmlAttrPtr xml_base_attr = NULL;
1133: xmlAttrPtr xml_lang_attr = NULL;
1134: xmlAttrPtr xml_space_attr = NULL;
1135:
1136: if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
1137: xmlC14NErrParam("processing attributes axis");
1138: return (-1);
1139: }
1140:
1141: /*
1142: * Create a sorted list to store element attributes
1143: */
1144: list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NAttrsCompare);
1145: if (list == NULL) {
1146: xmlC14NErrInternal("creating attributes list");
1147: return (-1);
1148: }
1149:
1150: switch(ctx->mode) {
1151: case XML_C14N_1_0:
1152: /* The processing of an element node E MUST be modified slightly when an XPath node-set is
1153: * given as input and the element's parent is omitted from the node-set. The method for processing
1154: * the attribute axis of an element E in the node-set is enhanced. All element nodes along E's
1155: * ancestor axis are examined for nearest occurrences of attributes in the xml namespace, such
1156: * as xml:lang and xml:space (whether or not they are in the node-set). From this list of attributes,
1157: * remove any that are in E's attribute axis (whether or not they are in the node-set). Then,
1158: * lexicographically merge this attribute list with the nodes of E's attribute axis that are in
1159: * the node-set. The result of visiting the attribute axis is computed by processing the attribute
1160: * nodes in this merged attribute list.
1161: */
1162:
1163: /*
1164: * Add all visible attributes from current node.
1165: */
1166: attr = cur->properties;
1167: while (attr != NULL) {
1168: /* check that attribute is visible */
1169: if (xmlC14NIsVisible(ctx, attr, cur)) {
1170: xmlListInsert(list, attr);
1171: }
1172: attr = attr->next;
1173: }
1174:
1175: /*
1176: * Handle xml attributes
1177: */
1178: if (parent_visible && (cur->parent != NULL) &&
1179: (!xmlC14NIsVisible(ctx, cur->parent, cur->parent->parent)))
1180: {
1181: xmlNodePtr tmp;
1182:
1183: /*
1184: * If XPath node-set is not specified then the parent is always
1185: * visible!
1186: */
1187: tmp = cur->parent;
1188: while (tmp != NULL) {
1189: attr = tmp->properties;
1190: while (attr != NULL) {
1191: if (xmlC14NIsXmlAttr(attr) != 0) {
1192: if (xmlListSearch(list, attr) == NULL) {
1193: xmlListInsert(list, attr);
1194: }
1195: }
1196: attr = attr->next;
1197: }
1198: tmp = tmp->parent;
1199: }
1200: }
1201:
1202: /* done */
1203: break;
1204: case XML_C14N_EXCLUSIVE_1_0:
1205: /* attributes in the XML namespace, such as xml:lang and xml:space
1206: * are not imported into orphan nodes of the document subset
1207: */
1208:
1209: /*
1210: * Add all visible attributes from current node.
1211: */
1212: attr = cur->properties;
1213: while (attr != NULL) {
1214: /* check that attribute is visible */
1215: if (xmlC14NIsVisible(ctx, attr, cur)) {
1216: xmlListInsert(list, attr);
1217: }
1218: attr = attr->next;
1219: }
1220:
1221: /* do nothing special for xml attributes */
1222: break;
1223: case XML_C14N_1_1:
1224: /* The processing of an element node E MUST be modified slightly when an XPath node-set is
1225: * given as input and some of the element's ancestors are omitted from the node-set.
1226: *
1227: * Simple inheritable attributes are attributes that have a value that requires at most a simple
1228: * redeclaration. This redeclaration is done by supplying a new value in the child axis. The
1229: * redeclaration of a simple inheritable attribute A contained in one of E's ancestors is done
1230: * by supplying a value to an attribute Ae inside E with the same name. Simple inheritable attributes
1231: * are xml:lang and xml:space.
1232: *
1233: * The method for processing the attribute axis of an element E in the node-set is hence enhanced.
1234: * All element nodes along E's ancestor axis are examined for the nearest occurrences of simple
1235: * inheritable attributes in the xml namespace, such as xml:lang and xml:space (whether or not they
1236: * are in the node-set). From this list of attributes, any simple inheritable attributes that are
1237: * already in E's attribute axis (whether or not they are in the node-set) are removed. Then,
1238: * lexicographically merge this attribute list with the nodes of E's attribute axis that are in
1239: * the node-set. The result of visiting the attribute axis is computed by processing the attribute
1240: * nodes in this merged attribute list.
1241: *
1242: * The xml:id attribute is not a simple inheritable attribute and no processing of these attributes is
1243: * performed.
1244: *
1245: * The xml:base attribute is not a simple inheritable attribute and requires special processing beyond
1246: * a simple redeclaration.
1247: *
1248: * Attributes in the XML namespace other than xml:base, xml:id, xml:lang, and xml:space MUST be processed
1249: * as ordinary attributes.
1250: */
1251:
1252: /*
1253: * Add all visible attributes from current node.
1254: */
1255: attr = cur->properties;
1256: while (attr != NULL) {
1257: /* special processing for XML attribute kiks in only when we have invisible parents */
1258: if ((!parent_visible) || (xmlC14NIsXmlAttr(attr) == 0)) {
1259: /* check that attribute is visible */
1260: if (xmlC14NIsVisible(ctx, attr, cur)) {
1261: xmlListInsert(list, attr);
1262: }
1263: } else {
1264: int matched = 0;
1265:
1266: /* check for simple inheritance attributes */
1267: if((!matched) && (xml_lang_attr == NULL) && xmlStrEqual(attr->name, BAD_CAST "lang")) {
1268: xml_lang_attr = attr;
1269: matched = 1;
1270: }
1271: if((!matched) && (xml_space_attr == NULL) && xmlStrEqual(attr->name, BAD_CAST "space")) {
1272: xml_space_attr = attr;
1273: matched = 1;
1274: }
1275:
1276: /* check for base attr */
1277: if((!matched) && (xml_base_attr == NULL) && xmlStrEqual(attr->name, BAD_CAST "base")) {
1278: xml_base_attr = attr;
1279: matched = 1;
1280: }
1281:
1282: /* otherwise, it is a normal attribute, so just check if it is visible */
1283: if((!matched) && xmlC14NIsVisible(ctx, attr, cur)) {
1284: xmlListInsert(list, attr);
1285: }
1286: }
1287:
1288: /* move to the next one */
1289: attr = attr->next;
1290: }
1291:
1292: /* special processing for XML attribute kiks in only when we have invisible parents */
1293: if ((parent_visible)) {
1294:
1295: /* simple inheritance attributes - copy */
1296: if(xml_lang_attr == NULL) {
1297: xml_lang_attr = xmlC14NFindHiddenParentAttr(ctx, cur->parent, BAD_CAST "lang", XML_XML_NAMESPACE);
1298: }
1299: if(xml_lang_attr != NULL) {
1300: xmlListInsert(list, xml_lang_attr);
1301: }
1302: if(xml_space_attr == NULL) {
1303: xml_space_attr = xmlC14NFindHiddenParentAttr(ctx, cur->parent, BAD_CAST "space", XML_XML_NAMESPACE);
1304: }
1305: if(xml_space_attr != NULL) {
1306: xmlListInsert(list, xml_space_attr);
1307: }
1308:
1309: /* base uri attribute - fix up */
1310: if(xml_base_attr == NULL) {
1311: /* if we don't have base uri attribute, check if we have a "hidden" one above */
1312: xml_base_attr = xmlC14NFindHiddenParentAttr(ctx, cur->parent, BAD_CAST "base", XML_XML_NAMESPACE);
1313: }
1314: if(xml_base_attr != NULL) {
1315: xml_base_attr = xmlC14NFixupBaseAttr(ctx, xml_base_attr);
1316: if(xml_base_attr != NULL) {
1317: xmlListInsert(list, xml_base_attr);
1318:
1319: /* note that we MUST delete returned attr node ourselves! */
1320: xml_base_attr->next = attrs_to_delete;
1321: attrs_to_delete = xml_base_attr;
1322: }
1323: }
1324: }
1325:
1326: /* done */
1327: break;
1328: }
1329:
1330: /*
1331: * print out all elements from list
1332: */
1333: xmlListWalk(list, (xmlListWalker) xmlC14NPrintAttrs, (const void *) ctx);
1334:
1335: /*
1336: * Cleanup
1337: */
1338: xmlFreePropList(attrs_to_delete);
1339: xmlListDelete(list);
1340: return (0);
1341: }
1342:
1343: /**
1344: * xmlC14NCheckForRelativeNamespaces:
1345: * @ctx: the C14N context
1346: * @cur: the current element node
1347: *
1348: * Checks that current element node has no relative namespaces defined
1349: *
1350: * Returns 0 if the node has no relative namespaces or -1 otherwise.
1351: */
1352: static int
1353: xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur)
1354: {
1355: xmlNsPtr ns;
1356:
1357: if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
1358: xmlC14NErrParam("checking for relative namespaces");
1359: return (-1);
1360: }
1361:
1362: ns = cur->nsDef;
1363: while (ns != NULL) {
1364: if (xmlStrlen(ns->href) > 0) {
1365: xmlURIPtr uri;
1366:
1367: uri = xmlParseURI((const char *) ns->href);
1368: if (uri == NULL) {
1369: xmlC14NErrInternal("parsing namespace uri");
1370: return (-1);
1371: }
1372: if (xmlStrlen((const xmlChar *) uri->scheme) == 0) {
1373: xmlC14NErrRelativeNamespace(uri->scheme);
1374: xmlFreeURI(uri);
1375: return (-1);
1376: }
1377: if ((xmlStrcasecmp((const xmlChar *) uri->scheme, BAD_CAST "urn") != 0)
1378: && (xmlStrcasecmp((const xmlChar *) uri->scheme, BAD_CAST "dav") !=0)
1379: && (xmlStrlen((const xmlChar *) uri->server) == 0)) {
1380: xmlC14NErrRelativeNamespace(uri->scheme);
1381: xmlFreeURI(uri);
1382: return (-1);
1383: }
1384: xmlFreeURI(uri);
1385: }
1386: ns = ns->next;
1387: }
1388: return (0);
1389: }
1390:
1391: /**
1392: * xmlC14NProcessElementNode:
1393: * @ctx: the pointer to C14N context object
1394: * @cur: the node to process
1395: * @visible: this node is visible
1396: * @all_parents_visible: whether all the parents of this node are visible
1397: *
1398: * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
1399: *
1400: * Element Nodes
1401: * If the element is not in the node-set, then the result is obtained
1402: * by processing the namespace axis, then the attribute axis, then
1403: * processing the child nodes of the element that are in the node-set
1404: * (in document order). If the element is in the node-set, then the result
1405: * is an open angle bracket (<), the element QName, the result of
1406: * processing the namespace axis, the result of processing the attribute
1407: * axis, a close angle bracket (>), the result of processing the child
1408: * nodes of the element that are in the node-set (in document order), an
1409: * open angle bracket, a forward slash (/), the element QName, and a close
1410: * angle bracket.
1411: *
1412: * Returns non-negative value on success or negative value on fail
1413: */
1414: static int
1415: xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
1416: {
1417: int ret;
1418: xmlC14NVisibleNsStack state;
1419: int parent_is_doc = 0;
1420:
1421: if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
1422: xmlC14NErrParam("processing element node");
1423: return (-1);
1424: }
1425:
1426: /*
1427: * Check relative relative namespaces:
1428: * implementations of XML canonicalization MUST report an operation
1429: * failure on documents containing relative namespace URIs.
1430: */
1431: if (xmlC14NCheckForRelativeNamespaces(ctx, cur) < 0) {
1432: xmlC14NErrInternal("checking for relative namespaces");
1433: return (-1);
1434: }
1435:
1436:
1437: /*
1438: * Save ns_rendered stack position
1439: */
1440: memset(&state, 0, sizeof(state));
1441: xmlC14NVisibleNsStackSave(ctx->ns_rendered, &state);
1442:
1443: if (visible) {
1444: if (ctx->parent_is_doc) {
1445: /* save this flag into the stack */
1446: parent_is_doc = ctx->parent_is_doc;
1447: ctx->parent_is_doc = 0;
1448: ctx->pos = XMLC14N_INSIDE_DOCUMENT_ELEMENT;
1449: }
1450: xmlOutputBufferWriteString(ctx->buf, "<");
1451:
1452: if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
1453: xmlOutputBufferWriteString(ctx->buf,
1454: (const char *) cur->ns->prefix);
1455: xmlOutputBufferWriteString(ctx->buf, ":");
1456: }
1457: xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
1458: }
1459:
1460: if (!xmlC14NIsExclusive(ctx)) {
1461: ret = xmlC14NProcessNamespacesAxis(ctx, cur, visible);
1462: } else {
1463: ret = xmlExcC14NProcessNamespacesAxis(ctx, cur, visible);
1464: }
1465: if (ret < 0) {
1466: xmlC14NErrInternal("processing namespaces axis");
1467: return (-1);
1468: }
1469: /* todo: shouldn't this go to "visible only"? */
1470: if(visible) {
1471: xmlC14NVisibleNsStackShift(ctx->ns_rendered);
1472: }
1473:
1474: ret = xmlC14NProcessAttrsAxis(ctx, cur, visible);
1475: if (ret < 0) {
1476: xmlC14NErrInternal("processing attributes axis");
1477: return (-1);
1478: }
1479:
1480: if (visible) {
1481: xmlOutputBufferWriteString(ctx->buf, ">");
1482: }
1483: if (cur->children != NULL) {
1484: ret = xmlC14NProcessNodeList(ctx, cur->children);
1485: if (ret < 0) {
1486: xmlC14NErrInternal("processing childrens list");
1487: return (-1);
1488: }
1489: }
1490: if (visible) {
1491: xmlOutputBufferWriteString(ctx->buf, "</");
1492: if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
1493: xmlOutputBufferWriteString(ctx->buf,
1494: (const char *) cur->ns->prefix);
1495: xmlOutputBufferWriteString(ctx->buf, ":");
1496: }
1497: xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
1498: xmlOutputBufferWriteString(ctx->buf, ">");
1499: if (parent_is_doc) {
1500: /* restore this flag from the stack for next node */
1501: ctx->parent_is_doc = parent_is_doc;
1502: ctx->pos = XMLC14N_AFTER_DOCUMENT_ELEMENT;
1503: }
1504: }
1505:
1506: /*
1507: * Restore ns_rendered stack position
1508: */
1509: xmlC14NVisibleNsStackRestore(ctx->ns_rendered, &state);
1510: return (0);
1511: }
1512:
1513: /**
1514: * xmlC14NProcessNode:
1515: * @ctx: the pointer to C14N context object
1516: * @cur: the node to process
1517: *
1518: * Processes the given node
1519: *
1520: * Returns non-negative value on success or negative value on fail
1521: */
1522: static int
1523: xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur)
1524: {
1525: int ret = 0;
1526: int visible;
1527:
1528: if ((ctx == NULL) || (cur == NULL)) {
1529: xmlC14NErrParam("processing node");
1530: return (-1);
1531: }
1532:
1533: visible = xmlC14NIsVisible(ctx, cur, cur->parent);
1534: switch (cur->type) {
1535: case XML_ELEMENT_NODE:
1536: ret = xmlC14NProcessElementNode(ctx, cur, visible);
1537: break;
1538: case XML_CDATA_SECTION_NODE:
1539: case XML_TEXT_NODE:
1540: /*
1541: * Text Nodes
1542: * the string value, except all ampersands are replaced
1543: * by &, all open angle brackets (<) are replaced by <, all closing
1544: * angle brackets (>) are replaced by >, and all #xD characters are
1545: * replaced by 
.
1546: */
1547: /* cdata sections are processed as text nodes */
1548: /* todo: verify that cdata sections are included in XPath nodes set */
1549: if ((visible) && (cur->content != NULL)) {
1550: xmlChar *buffer;
1551:
1552: buffer = xmlC11NNormalizeText(cur->content);
1553: if (buffer != NULL) {
1554: xmlOutputBufferWriteString(ctx->buf,
1555: (const char *) buffer);
1556: xmlFree(buffer);
1557: } else {
1558: xmlC14NErrInternal("normalizing text node");
1559: return (-1);
1560: }
1561: }
1562: break;
1563: case XML_PI_NODE:
1564: /*
1565: * Processing Instruction (PI) Nodes-
1566: * The opening PI symbol (<?), the PI target name of the node,
1567: * a leading space and the string value if it is not empty, and
1568: * the closing PI symbol (?>). If the string value is empty,
1569: * then the leading space is not added. Also, a trailing #xA is
1570: * rendered after the closing PI symbol for PI children of the
1571: * root node with a lesser document order than the document
1572: * element, and a leading #xA is rendered before the opening PI
1573: * symbol of PI children of the root node with a greater document
1574: * order than the document element.
1575: */
1576: if (visible) {
1577: if (ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
1578: xmlOutputBufferWriteString(ctx->buf, "\x0A<?");
1579: } else {
1580: xmlOutputBufferWriteString(ctx->buf, "<?");
1581: }
1582:
1583: xmlOutputBufferWriteString(ctx->buf,
1584: (const char *) cur->name);
1585: if ((cur->content != NULL) && (*(cur->content) != '\0')) {
1586: xmlChar *buffer;
1587:
1588: xmlOutputBufferWriteString(ctx->buf, " ");
1589:
1590: /* todo: do we need to normalize pi? */
1591: buffer = xmlC11NNormalizePI(cur->content);
1592: if (buffer != NULL) {
1593: xmlOutputBufferWriteString(ctx->buf,
1594: (const char *) buffer);
1595: xmlFree(buffer);
1596: } else {
1597: xmlC14NErrInternal("normalizing pi node");
1598: return (-1);
1599: }
1600: }
1601:
1602: if (ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
1603: xmlOutputBufferWriteString(ctx->buf, "?>\x0A");
1604: } else {
1605: xmlOutputBufferWriteString(ctx->buf, "?>");
1606: }
1607: }
1608: break;
1609: case XML_COMMENT_NODE:
1610: /*
1611: * Comment Nodes
1612: * Nothing if generating canonical XML without comments. For
1613: * canonical XML with comments, generate the opening comment
1614: * symbol (<!--), the string value of the node, and the
1615: * closing comment symbol (-->). Also, a trailing #xA is rendered
1616: * after the closing comment symbol for comment children of the
1617: * root node with a lesser document order than the document
1618: * element, and a leading #xA is rendered before the opening
1619: * comment symbol of comment children of the root node with a
1620: * greater document order than the document element. (Comment
1621: * children of the root node represent comments outside of the
1622: * top-level document element and outside of the document type
1623: * declaration).
1624: */
1625: if (visible && ctx->with_comments) {
1626: if (ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
1627: xmlOutputBufferWriteString(ctx->buf, "\x0A<!--");
1628: } else {
1629: xmlOutputBufferWriteString(ctx->buf, "<!--");
1630: }
1631:
1632: if (cur->content != NULL) {
1633: xmlChar *buffer;
1634:
1635: /* todo: do we need to normalize comment? */
1636: buffer = xmlC11NNormalizeComment(cur->content);
1637: if (buffer != NULL) {
1638: xmlOutputBufferWriteString(ctx->buf,
1639: (const char *) buffer);
1640: xmlFree(buffer);
1641: } else {
1642: xmlC14NErrInternal("normalizing comment node");
1643: return (-1);
1644: }
1645: }
1646:
1647: if (ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
1648: xmlOutputBufferWriteString(ctx->buf, "-->\x0A");
1649: } else {
1650: xmlOutputBufferWriteString(ctx->buf, "-->");
1651: }
1652: }
1653: break;
1654: case XML_DOCUMENT_NODE:
1655: case XML_DOCUMENT_FRAG_NODE: /* should be processed as document? */
1656: #ifdef LIBXML_DOCB_ENABLED
1657: case XML_DOCB_DOCUMENT_NODE: /* should be processed as document? */
1658: #endif
1659: #ifdef LIBXML_HTML_ENABLED
1660: case XML_HTML_DOCUMENT_NODE: /* should be processed as document? */
1661: #endif
1662: if (cur->children != NULL) {
1663: ctx->pos = XMLC14N_BEFORE_DOCUMENT_ELEMENT;
1664: ctx->parent_is_doc = 1;
1665: ret = xmlC14NProcessNodeList(ctx, cur->children);
1666: }
1667: break;
1668:
1669: case XML_ATTRIBUTE_NODE:
1670: xmlC14NErrInvalidNode("XML_ATTRIBUTE_NODE", "processing node");
1671: return (-1);
1672: case XML_NAMESPACE_DECL:
1673: xmlC14NErrInvalidNode("XML_NAMESPACE_DECL", "processing node");
1674: return (-1);
1675: case XML_ENTITY_REF_NODE:
1676: xmlC14NErrInvalidNode("XML_ENTITY_REF_NODE", "processing node");
1677: return (-1);
1678: case XML_ENTITY_NODE:
1679: xmlC14NErrInvalidNode("XML_ENTITY_NODE", "processing node");
1680: return (-1);
1681:
1682: case XML_DOCUMENT_TYPE_NODE:
1683: case XML_NOTATION_NODE:
1684: case XML_DTD_NODE:
1685: case XML_ELEMENT_DECL:
1686: case XML_ATTRIBUTE_DECL:
1687: case XML_ENTITY_DECL:
1688: #ifdef LIBXML_XINCLUDE_ENABLED
1689: case XML_XINCLUDE_START:
1690: case XML_XINCLUDE_END:
1691: #endif
1692: /*
1693: * should be ignored according to "W3C Canonical XML"
1694: */
1695: break;
1696: default:
1697: xmlC14NErrUnknownNode(cur->type, "processing node");
1698: return (-1);
1699: }
1700:
1701: return (ret);
1702: }
1703:
1704: /**
1705: * xmlC14NProcessNodeList:
1706: * @ctx: the pointer to C14N context object
1707: * @cur: the node to start from
1708: *
1709: * Processes all nodes in the row starting from cur.
1710: *
1711: * Returns non-negative value on success or negative value on fail
1712: */
1713: static int
1714: xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur)
1715: {
1716: int ret;
1717:
1718: if (ctx == NULL) {
1719: xmlC14NErrParam("processing node list");
1720: return (-1);
1721: }
1722:
1723: for (ret = 0; cur != NULL && ret >= 0; cur = cur->next) {
1724: ret = xmlC14NProcessNode(ctx, cur);
1725: }
1726: return (ret);
1727: }
1728:
1729:
1730: /**
1731: * xmlC14NFreeCtx:
1732: * @ctx: the pointer to C14N context object
1733: *
1734: * Cleanups the C14N context object.
1735: */
1736:
1737: static void
1738: xmlC14NFreeCtx(xmlC14NCtxPtr ctx)
1739: {
1740: if (ctx == NULL) {
1741: xmlC14NErrParam("freeing context");
1742: return;
1743: }
1744:
1745: if (ctx->ns_rendered != NULL) {
1746: xmlC14NVisibleNsStackDestroy(ctx->ns_rendered);
1747: }
1748: xmlFree(ctx);
1749: }
1750:
1751: /**
1752: * xmlC14NNewCtx:
1753: * @doc: the XML document for canonization
1754: * @is_visible_callback:the function to use to determine is node visible
1755: * or not
1756: * @user_data: the first parameter for @is_visible_callback function
1757: * (in most cases, it is nodes set)
1758: * @mode: the c14n mode (see @xmlC14NMode)
1759: * @inclusive_ns_prefixe the list of inclusive namespace prefixes
1760: * ended with a NULL or NULL if there is no
1761: * inclusive namespaces (only for `
1762: * canonicalization)
1763: * @with_comments: include comments in the result (!=0) or not (==0)
1764: * @buf: the output buffer to store canonical XML; this
1765: * buffer MUST have encoder==NULL because C14N requires
1766: * UTF-8 output
1767: *
1768: * Creates new C14N context object to store C14N parameters.
1769: *
1770: * Returns pointer to newly created object (success) or NULL (fail)
1771: */
1772: static xmlC14NCtxPtr
1773: xmlC14NNewCtx(xmlDocPtr doc,
1774: xmlC14NIsVisibleCallback is_visible_callback, void* user_data,
1775: xmlC14NMode mode, xmlChar ** inclusive_ns_prefixes,
1776: int with_comments, xmlOutputBufferPtr buf)
1777: {
1778: xmlC14NCtxPtr ctx = NULL;
1779:
1780: if ((doc == NULL) || (buf == NULL)) {
1781: xmlC14NErrParam("creating new context");
1782: return (NULL);
1783: }
1784:
1785: /*
1786: * Validate the encoding output buffer encoding
1787: */
1788: if (buf->encoder != NULL) {
1789: xmlC14NErr(ctx, (xmlNodePtr) doc, XML_C14N_REQUIRES_UTF8,
1790: "xmlC14NNewCtx: output buffer encoder != NULL but C14N requires UTF8 output\n");
1791: return (NULL);
1792: }
1793:
1794: /*
1795: * Validate the XML document encoding value, if provided.
1796: */
1797: if (doc->charset != XML_CHAR_ENCODING_UTF8) {
1798: xmlC14NErr(ctx, (xmlNodePtr) doc, XML_C14N_REQUIRES_UTF8,
1799: "xmlC14NNewCtx: source document not in UTF8\n");
1800: return (NULL);
1801: }
1802:
1803: /*
1804: * Allocate a new xmlC14NCtxPtr and fill the fields.
1805: */
1806: ctx = (xmlC14NCtxPtr) xmlMalloc(sizeof(xmlC14NCtx));
1807: if (ctx == NULL) {
1808: xmlC14NErrMemory("creating context");
1809: return (NULL);
1810: }
1811: memset(ctx, 0, sizeof(xmlC14NCtx));
1812:
1813: /*
1814: * initialize C14N context
1815: */
1816: ctx->doc = doc;
1817: ctx->with_comments = with_comments;
1818: ctx->is_visible_callback = is_visible_callback;
1819: ctx->user_data = user_data;
1820: ctx->buf = buf;
1821: ctx->parent_is_doc = 1;
1822: ctx->pos = XMLC14N_BEFORE_DOCUMENT_ELEMENT;
1823: ctx->ns_rendered = xmlC14NVisibleNsStackCreate();
1824:
1825: if(ctx->ns_rendered == NULL) {
1826: xmlC14NErr(ctx, (xmlNodePtr) doc, XML_C14N_CREATE_STACK,
1827: "xmlC14NNewCtx: xmlC14NVisibleNsStackCreate failed\n");
1828: xmlC14NFreeCtx(ctx);
1829: return (NULL);
1830: }
1831:
1832: /*
1833: * Set "mode" flag and remember list of incluseve prefixes
1834: * for exclusive c14n
1835: */
1836: ctx->mode = mode;
1837: if(xmlC14NIsExclusive(ctx)) {
1838: ctx->inclusive_ns_prefixes = inclusive_ns_prefixes;
1839: }
1840: return (ctx);
1841: }
1842:
1843: /**
1844: * xmlC14NExecute:
1845: * @doc: the XML document for canonization
1846: * @is_visible_callback:the function to use to determine is node visible
1847: * or not
1848: * @user_data: the first parameter for @is_visible_callback function
1849: * (in most cases, it is nodes set)
1850: * @mode: the c14n mode (see @xmlC14NMode)
1851: * @inclusive_ns_prefixes: the list of inclusive namespace prefixes
1852: * ended with a NULL or NULL if there is no
1853: * inclusive namespaces (only for exclusive
1854: * canonicalization, ignored otherwise)
1855: * @with_comments: include comments in the result (!=0) or not (==0)
1856: * @buf: the output buffer to store canonical XML; this
1857: * buffer MUST have encoder==NULL because C14N requires
1858: * UTF-8 output
1859: *
1860: * Dumps the canonized image of given XML document into the provided buffer.
1861: * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
1862: * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
1863: *
1864: * Returns non-negative value on success or a negative value on fail
1865: */
1866: int
1867: xmlC14NExecute(xmlDocPtr doc, xmlC14NIsVisibleCallback is_visible_callback,
1868: void* user_data, int mode, xmlChar **inclusive_ns_prefixes,
1869: int with_comments, xmlOutputBufferPtr buf) {
1870:
1871: xmlC14NCtxPtr ctx;
1872: xmlC14NMode c14n_mode = XML_C14N_1_0;
1873: int ret;
1874:
1875: if ((buf == NULL) || (doc == NULL)) {
1876: xmlC14NErrParam("executing c14n");
1877: return (-1);
1878: }
1879:
1880: /* for backward compatibility, we have to have "mode" as "int"
1881: and here we check that user gives valid value */
1882: switch(mode) {
1883: case XML_C14N_1_0:
1884: case XML_C14N_EXCLUSIVE_1_0:
1885: case XML_C14N_1_1:
1886: c14n_mode = (xmlC14NMode)mode;
1887: break;
1888: default:
1889: xmlC14NErrParam("invalid mode for executing c14n");
1890: return (-1);
1891: }
1892:
1893: /*
1894: * Validate the encoding output buffer encoding
1895: */
1896: if (buf->encoder != NULL) {
1897: xmlC14NErr(NULL, (xmlNodePtr) doc, XML_C14N_REQUIRES_UTF8,
1898: "xmlC14NExecute: output buffer encoder != NULL but C14N requires UTF8 output\n");
1899: return (-1);
1900: }
1901:
1902: ctx = xmlC14NNewCtx(doc, is_visible_callback, user_data,
1903: c14n_mode, inclusive_ns_prefixes,
1904: with_comments, buf);
1905: if (ctx == NULL) {
1906: xmlC14NErr(NULL, (xmlNodePtr) doc, XML_C14N_CREATE_CTXT,
1907: "xmlC14NExecute: unable to create C14N context\n");
1908: return (-1);
1909: }
1910:
1911:
1912:
1913: /*
1914: * Root Node
1915: * The root node is the parent of the top-level document element. The
1916: * result of processing each of its child nodes that is in the node-set
1917: * in document order. The root node does not generate a byte order mark,
1918: * XML declaration, nor anything from within the document type
1919: * declaration.
1920: */
1921: if (doc->children != NULL) {
1922: ret = xmlC14NProcessNodeList(ctx, doc->children);
1923: if (ret < 0) {
1924: xmlC14NErrInternal("processing docs children list");
1925: xmlC14NFreeCtx(ctx);
1926: return (-1);
1927: }
1928: }
1929:
1930: /*
1931: * Flush buffer to get number of bytes written
1932: */
1933: ret = xmlOutputBufferFlush(buf);
1934: if (ret < 0) {
1935: xmlC14NErrInternal("flushing output buffer");
1936: xmlC14NFreeCtx(ctx);
1937: return (-1);
1938: }
1939:
1940: /*
1941: * Cleanup
1942: */
1943: xmlC14NFreeCtx(ctx);
1944: return (ret);
1945: }
1946:
1947: /**
1948: * xmlC14NDocSaveTo:
1949: * @doc: the XML document for canonization
1950: * @nodes: the nodes set to be included in the canonized image
1951: * or NULL if all document nodes should be included
1952: * @mode: the c14n mode (see @xmlC14NMode)
1953: * @inclusive_ns_prefixes: the list of inclusive namespace prefixes
1954: * ended with a NULL or NULL if there is no
1955: * inclusive namespaces (only for exclusive
1956: * canonicalization, ignored otherwise)
1957: * @with_comments: include comments in the result (!=0) or not (==0)
1958: * @buf: the output buffer to store canonical XML; this
1959: * buffer MUST have encoder==NULL because C14N requires
1960: * UTF-8 output
1961: *
1962: * Dumps the canonized image of given XML document into the provided buffer.
1963: * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
1964: * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
1965: *
1966: * Returns non-negative value on success or a negative value on fail
1967: */
1968: int
1969: xmlC14NDocSaveTo(xmlDocPtr doc, xmlNodeSetPtr nodes,
1970: int mode, xmlChar ** inclusive_ns_prefixes,
1971: int with_comments, xmlOutputBufferPtr buf) {
1972: return(xmlC14NExecute(doc,
1973: (xmlC14NIsVisibleCallback)xmlC14NIsNodeInNodeset,
1974: nodes,
1975: mode,
1976: inclusive_ns_prefixes,
1977: with_comments,
1978: buf));
1979: }
1980:
1981:
1982: /**
1983: * xmlC14NDocDumpMemory:
1984: * @doc: the XML document for canonization
1985: * @nodes: the nodes set to be included in the canonized image
1986: * or NULL if all document nodes should be included
1987: * @mode: the c14n mode (see @xmlC14NMode)
1988: * @inclusive_ns_prefixes: the list of inclusive namespace prefixes
1989: * ended with a NULL or NULL if there is no
1990: * inclusive namespaces (only for exclusive
1991: * canonicalization, ignored otherwise)
1992: * @with_comments: include comments in the result (!=0) or not (==0)
1993: * @doc_txt_ptr: the memory pointer for allocated canonical XML text;
1994: * the caller of this functions is responsible for calling
1995: * xmlFree() to free allocated memory
1996: *
1997: * Dumps the canonized image of given XML document into memory.
1998: * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
1999: * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
2000: *
2001: * Returns the number of bytes written on success or a negative value on fail
2002: */
2003: int
2004: xmlC14NDocDumpMemory(xmlDocPtr doc, xmlNodeSetPtr nodes,
2005: int mode, xmlChar ** inclusive_ns_prefixes,
2006: int with_comments, xmlChar ** doc_txt_ptr)
2007: {
2008: int ret;
2009: xmlOutputBufferPtr buf;
2010:
2011: if (doc_txt_ptr == NULL) {
2012: xmlC14NErrParam("dumping doc to memory");
2013: return (-1);
2014: }
2015:
2016: *doc_txt_ptr = NULL;
2017:
2018: /*
2019: * create memory buffer with UTF8 (default) encoding
2020: */
2021: buf = xmlAllocOutputBuffer(NULL);
2022: if (buf == NULL) {
2023: xmlC14NErrMemory("creating output buffer");
2024: return (-1);
2025: }
2026:
2027: /*
2028: * canonize document and write to buffer
2029: */
2030: ret = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes,
2031: with_comments, buf);
2032: if (ret < 0) {
2033: xmlC14NErrInternal("saving doc to output buffer");
2034: (void) xmlOutputBufferClose(buf);
2035: return (-1);
2036: }
2037:
2038: ret = xmlBufUse(buf->buffer);
2039: if (ret > 0) {
2040: *doc_txt_ptr = xmlStrndup(xmlBufContent(buf->buffer), ret);
2041: }
2042: (void) xmlOutputBufferClose(buf);
2043:
2044: if ((*doc_txt_ptr == NULL) && (ret > 0)) {
2045: xmlC14NErrMemory("coping canonicanized document");
2046: return (-1);
2047: }
2048: return (ret);
2049: }
2050:
2051: /**
2052: * xmlC14NDocSave:
2053: * @doc: the XML document for canonization
2054: * @nodes: the nodes set to be included in the canonized image
2055: * or NULL if all document nodes should be included
2056: * @mode: the c14n mode (see @xmlC14NMode)
2057: * @inclusive_ns_prefixes: the list of inclusive namespace prefixes
2058: * ended with a NULL or NULL if there is no
2059: * inclusive namespaces (only for exclusive
2060: * canonicalization, ignored otherwise)
2061: * @with_comments: include comments in the result (!=0) or not (==0)
2062: * @filename: the filename to store canonical XML image
2063: * @compression: the compression level (zlib requred):
2064: * -1 - libxml default,
2065: * 0 - uncompressed,
2066: * >0 - compression level
2067: *
2068: * Dumps the canonized image of given XML document into the file.
2069: * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
2070: * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
2071: *
2072: * Returns the number of bytes written success or a negative value on fail
2073: */
2074: int
2075: xmlC14NDocSave(xmlDocPtr doc, xmlNodeSetPtr nodes,
2076: int mode, xmlChar ** inclusive_ns_prefixes,
2077: int with_comments, const char *filename, int compression)
2078: {
2079: xmlOutputBufferPtr buf;
2080: int ret;
2081:
2082: if (filename == NULL) {
2083: xmlC14NErrParam("saving doc");
2084: return (-1);
2085: }
2086: #ifdef HAVE_ZLIB_H
2087: if (compression < 0)
2088: compression = xmlGetCompressMode();
2089: #endif
2090:
2091: /*
2092: * save the content to a temp buffer, use default UTF8 encoding.
2093: */
2094: buf = xmlOutputBufferCreateFilename(filename, NULL, compression);
2095: if (buf == NULL) {
2096: xmlC14NErrInternal("creating temporary filename");
2097: return (-1);
2098: }
2099:
2100: /*
2101: * canonize document and write to buffer
2102: */
2103: ret = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes,
2104: with_comments, buf);
2105: if (ret < 0) {
2106: xmlC14NErrInternal("cannicanize document to buffer");
2107: (void) xmlOutputBufferClose(buf);
2108: return (-1);
2109: }
2110:
2111: /*
2112: * get the numbers of bytes written
2113: */
2114: ret = xmlOutputBufferClose(buf);
2115: return (ret);
2116: }
2117:
2118:
2119:
2120: /*
2121: * Macro used to grow the current buffer.
2122: */
2123: #define growBufferReentrant() { \
2124: buffer_size *= 2; \
2125: buffer = (xmlChar *) \
2126: xmlRealloc(buffer, buffer_size * sizeof(xmlChar)); \
2127: if (buffer == NULL) { \
2128: xmlC14NErrMemory("growing buffer"); \
2129: return(NULL); \
2130: } \
2131: }
2132:
2133: /**
2134: * xmlC11NNormalizeString:
2135: * @input: the input string
2136: * @mode: the normalization mode (attribute, comment, PI or text)
2137: *
2138: * Converts a string to a canonical (normalized) format. The code is stolen
2139: * from xmlEncodeEntitiesReentrant(). Added normalization of \x09, \x0a, \x0A
2140: * and the @mode parameter
2141: *
2142: * Returns a normalized string (caller is responsible for calling xmlFree())
2143: * or NULL if an error occurs
2144: */
2145: static xmlChar *
2146: xmlC11NNormalizeString(const xmlChar * input,
2147: xmlC14NNormalizationMode mode)
2148: {
2149: const xmlChar *cur = input;
2150: xmlChar *buffer = NULL;
2151: xmlChar *out = NULL;
2152: int buffer_size = 0;
2153:
2154: if (input == NULL)
2155: return (NULL);
2156:
2157: /*
2158: * allocate an translation buffer.
2159: */
2160: buffer_size = 1000;
2161: buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar));
2162: if (buffer == NULL) {
2163: xmlC14NErrMemory("allocating buffer");
2164: return (NULL);
2165: }
2166: out = buffer;
2167:
2168: while (*cur != '\0') {
2169: if ((out - buffer) > (buffer_size - 10)) {
2170: int indx = out - buffer;
2171:
2172: growBufferReentrant();
2173: out = &buffer[indx];
2174: }
2175:
2176: if ((*cur == '<') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
2177: (mode == XMLC14N_NORMALIZE_TEXT))) {
2178: *out++ = '&';
2179: *out++ = 'l';
2180: *out++ = 't';
2181: *out++ = ';';
2182: } else if ((*cur == '>') && (mode == XMLC14N_NORMALIZE_TEXT)) {
2183: *out++ = '&';
2184: *out++ = 'g';
2185: *out++ = 't';
2186: *out++ = ';';
2187: } else if ((*cur == '&') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
2188: (mode == XMLC14N_NORMALIZE_TEXT))) {
2189: *out++ = '&';
2190: *out++ = 'a';
2191: *out++ = 'm';
2192: *out++ = 'p';
2193: *out++ = ';';
2194: } else if ((*cur == '"') && (mode == XMLC14N_NORMALIZE_ATTR)) {
2195: *out++ = '&';
2196: *out++ = 'q';
2197: *out++ = 'u';
2198: *out++ = 'o';
2199: *out++ = 't';
2200: *out++ = ';';
2201: } else if ((*cur == '\x09') && (mode == XMLC14N_NORMALIZE_ATTR)) {
2202: *out++ = '&';
2203: *out++ = '#';
2204: *out++ = 'x';
2205: *out++ = '9';
2206: *out++ = ';';
2207: } else if ((*cur == '\x0A') && (mode == XMLC14N_NORMALIZE_ATTR)) {
2208: *out++ = '&';
2209: *out++ = '#';
2210: *out++ = 'x';
2211: *out++ = 'A';
2212: *out++ = ';';
2213: } else if ((*cur == '\x0D') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
2214: (mode == XMLC14N_NORMALIZE_TEXT) ||
2215: (mode == XMLC14N_NORMALIZE_COMMENT) ||
2216: (mode == XMLC14N_NORMALIZE_PI))) {
2217: *out++ = '&';
2218: *out++ = '#';
2219: *out++ = 'x';
2220: *out++ = 'D';
2221: *out++ = ';';
2222: } else {
2223: /*
2224: * Works because on UTF-8, all extended sequences cannot
2225: * result in bytes in the ASCII range.
2226: */
2227: *out++ = *cur;
2228: }
2229: cur++;
2230: }
2231: *out = 0;
2232: return (buffer);
2233: }
2234: #endif /* LIBXML_OUTPUT_ENABLED */
2235: #define bottom_c14n
2236: #include "elfgcchack.h"
2237: #endif /* LIBXML_C14N_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to c14n.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2