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