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