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 (at) 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 */ 2236
