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 "XmlEnglibxml.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 "Libxml2_tree.h"

    23 #include "Libxml2_parser.h"

    24 #include "Libxml2_uri.h"

    25 #include "Libxml2_xmlerror.h"

    26 #include "Libxml2_globals.h"

    27 #include "Libxml2_xpathInternals.h"

    28 #include "Libxml2_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     /* exclusive canonicalization */

    65     int exclusive;

    66     xmlChar **inclusive_ns_prefixes;

    67 

    68     /* error number */

    69     int error;

    70 } xmlC14NCtx, *xmlC14NCtxPtr;

    71 

    72 static xmlC14NVisibleNsStackPtr	xmlC14NVisibleNsStackCreate	(void);

    73 static void			xmlC14NVisibleNsStackDestroy	(xmlC14NVisibleNsStackPtr cur);

    74 static void 			xmlC14NVisibleNsStackAdd	(xmlC14NVisibleNsStackPtr cur, 

    75 								 xmlNsPtr ns,

    76 								 xmlNodePtr node);

    77 static void 			xmlC14NVisibleNsStackSave	(xmlC14NVisibleNsStackPtr cur,

    78 								 xmlC14NVisibleNsStackPtr state);

    79 static void 			xmlC14NVisibleNsStackRestore	(xmlC14NVisibleNsStackPtr cur,

    80 								 xmlC14NVisibleNsStackPtr state);

    81 static void 			xmlC14NVisibleNsStackShift	(xmlC14NVisibleNsStackPtr cur);

    82 static int			xmlC14NVisibleNsStackFind	(xmlC14NVisibleNsStackPtr cur, 

    83 								 xmlNsPtr ns);

    84 static int			xmlExcC14NVisibleNsStackFind	(xmlC14NVisibleNsStackPtr cur, 

    85 								 xmlNsPtr ns,

    86 								 xmlC14NCtxPtr ctx);

    87 

    88 static int			xmlC14NIsNodeInNodeset		(xmlNodeSetPtr nodes,

    89 								 xmlNodePtr node,

    90 								 xmlNodePtr parent);

    91 

    92 

    93 

    94 static int xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur);

    95 static int xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur);

    96 typedef enum {

    97     XMLC14N_NORMALIZE_ATTR = 0,

    98     XMLC14N_NORMALIZE_COMMENT = 1,

    99     XMLC14N_NORMALIZE_PI = 2,

   100     XMLC14N_NORMALIZE_TEXT = 3

   101 } xmlC14NNormalizationMode;

   102 

   103 static xmlChar *xmlC11NNormalizeString(const xmlChar * input,

   104                                        xmlC14NNormalizationMode mode);

   105 

   106 #define 	xmlC11NNormalizeAttr( a ) \

   107     xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_ATTR)

   108 #define 	xmlC11NNormalizeComment( a ) \

   109     xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_COMMENT)

   110 #define 	xmlC11NNormalizePI( a )	\

   111     xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_PI)

   112 #define 	xmlC11NNormalizeText( a ) \

   113     xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_TEXT)

   114 

   115 #define 	xmlC14NIsVisible( ctx, node, parent ) \

   116      (((ctx)->is_visible_callback != NULL) ? \

   117 	(ctx)->is_visible_callback((ctx)->user_data, \

   118 		(xmlNodePtr)(node), (xmlNodePtr)(parent)) : 1)

   119 

   120 /************************************************************************

   121  *									*

   122  * 		Some factorized error routines				*

   123  *									*

   124  ************************************************************************/

   125 

   126 /**

   127  * xmlC14NErrMemory:

   128  * @extra:  extra informations

   129  *

   130  * Handle a redefinition of attribute error

   131  */

   132 static void

   133 xmlC14NErrMemory(const char *extra)

   134 {

   135     __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_C14N,

   136 		    XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0, extra,

   137 		    NULL, NULL, 0, 0,

   138 		    "Memory allocation failed : %s\n", extra);

   139 }

   140 

   141 /**

   142  * xmlC14NErr:

   143  * @ctxt:  a C14N evaluation context

   144  * @node:  the context node

   145  * @error:  the erorr code

   146  * @msg:  the message

   147  * @extra:  extra informations

   148  *

   149  * Handle a redefinition of attribute error

   150  */

   151 static void

   152 xmlC14NErr(xmlC14NCtxPtr ctxt, xmlNodePtr node, int error,

   153            const char * msg)

   154 {

   155     if (ctxt != NULL)

   156         ctxt->error = error;

   157     __xmlRaiseError(NULL, NULL, NULL,

   158 		    ctxt, node, XML_FROM_C14N, error,

   159 		    XML_ERR_ERROR, NULL, 0,

   160 		    NULL, NULL, NULL, 0, 0, msg);

   161 }

   162 

   163 /************************************************************************

   164  *									*

   165  *		The implementation internals				*

   166  *									*

   167  ************************************************************************/

   168 #define XML_NAMESPACES_DEFAULT		16

   169 

   170 static int			

   171 xmlC14NIsNodeInNodeset(xmlNodeSetPtr nodes, xmlNodePtr node, xmlNodePtr parent) {

   172     if((nodes != NULL) && (node != NULL)) {

   173 	if(node->type != XML_NAMESPACE_DECL) {

   174 	    return(xmlXPathNodeSetContains(nodes, node));

   175 	} else {

   176 	    xmlNs ns;

   177 	    

   178 	    memcpy(&ns, node, sizeof(ns)); 

   179 	    

   180 	    /* this is a libxml hack! check xpath.c for details */

   181 	    if((parent != NULL) && (parent->type == XML_ATTRIBUTE_NODE)) {

   182 		ns.next = (xmlNsPtr)parent->parent;

   183 	    } else {

   184 		ns.next = (xmlNsPtr)parent; 

   185 	    }

   186 

   187 	    /* 

   188 	     * If the input is an XPath node-set, then the node-set must explicitly 

   189 	     * contain every node to be rendered to the canonical form.

   190 	     */

   191 	    return(xmlXPathNodeSetContains(nodes, (xmlNodePtr)&ns));

   192 	}

   193     }

   194     return(1);

   195 }

   196 

   197 static xmlC14NVisibleNsStackPtr

   198 xmlC14NVisibleNsStackCreate(void) {

   199     xmlC14NVisibleNsStackPtr ret;

   200 

   201     ret = (xmlC14NVisibleNsStackPtr) xmlMalloc(sizeof(xmlC14NVisibleNsStack));

   202     if (ret == NULL) {

   203         xmlC14NErrMemory("creating stack");

   204 	return(NULL);

   205     }

   206     memset(ret, 0 , (size_t) sizeof(xmlC14NVisibleNsStack));

   207     return(ret);

   208 }

   209 

   210 static void

   211 xmlC14NVisibleNsStackDestroy(xmlC14NVisibleNsStackPtr cur) {

   212     if(cur == NULL) {

   213 #ifdef DEBUG_C14N

   214         xmlGenericError(xmlGenericErrorContext,

   215             "xmlC14NVisibleNsStackDestroy: cur is null.\n");

   216 #endif

   217 	return;

   218     }

   219     if(cur->nsTab != NULL) {

   220 	memset(cur->nsTab, 0, cur->nsMax * sizeof(xmlNsPtr));

   221 	xmlFree(cur->nsTab);

   222     }

   223     if(cur->nodeTab != NULL) {

   224 	memset(cur->nodeTab, 0, cur->nsMax * sizeof(xmlNodePtr));

   225 	xmlFree(cur->nodeTab);

   226     }

   227     memset(cur, 0, sizeof(xmlC14NVisibleNsStack));

   228     xmlFree(cur);

   229     

   230 }

   231 

   232 static void 

   233 xmlC14NVisibleNsStackAdd(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlNodePtr node) {

   234     if((cur == NULL) || 

   235        ((cur->nsTab == NULL) && (cur->nodeTab != NULL)) ||

   236        ((cur->nsTab != NULL) && (cur->nodeTab == NULL))) {

   237 #ifdef DEBUG_C14N

   238         xmlGenericError(xmlGenericErrorContext,

   239             "xmlC14NVisibleNsStackAdd: cur is null.\n");

   240 #endif

   241 	return;

   242     }

   243 

   244     if ((cur->nsTab == NULL) && (cur->nodeTab == NULL)) {

   245         cur->nsTab = (xmlNsPtr*) xmlMalloc(XML_NAMESPACES_DEFAULT * sizeof(xmlNsPtr));

   246         cur->nodeTab = (xmlNodePtr*) xmlMalloc(XML_NAMESPACES_DEFAULT * sizeof(xmlNodePtr));

   247 	if ((cur->nsTab == NULL) || (cur->nodeTab == NULL)) {

   248 	    xmlC14NErrMemory("adding node to stack");

   249 	    return;

   250 	}

   251 	memset(cur->nsTab, 0 , XML_NAMESPACES_DEFAULT * sizeof(xmlNsPtr));

   252 	memset(cur->nodeTab, 0 , XML_NAMESPACES_DEFAULT * sizeof(xmlNodePtr));

   253         cur->nsMax = XML_NAMESPACES_DEFAULT;

   254     } else if(cur->nsMax == cur->nsCurEnd) {

   255 	void *tmp;	

   256 	int tmpSize;

   257 	

   258 	tmpSize = 2 * cur->nsMax;

   259 	tmp = xmlRealloc(cur->nsTab, tmpSize * sizeof(xmlNsPtr));

   260 	if (tmp == NULL) {

   261 	    xmlC14NErrMemory("adding node to stack");

   262 	    return;

   263 	}

   264 	cur->nsTab = (xmlNsPtr*)tmp;

   265 

   266 	tmp = xmlRealloc(cur->nodeTab, tmpSize * sizeof(xmlNodePtr));

   267 	if (tmp == NULL) {

   268 	    xmlC14NErrMemory("adding node to stack");

   269 	    return;

   270 	}

   271 	cur->nodeTab = (xmlNodePtr*)tmp;

   272 

   273 	cur->nsMax = tmpSize;

   274     }

   275     cur->nsTab[cur->nsCurEnd] = ns;

   276     cur->nodeTab[cur->nsCurEnd] = node;

   277 

   278     ++cur->nsCurEnd;

   279 }

   280 

   281 static void

   282 xmlC14NVisibleNsStackSave(xmlC14NVisibleNsStackPtr cur, xmlC14NVisibleNsStackPtr state) {

   283     if((cur == NULL) || (state == NULL)) {

   284 #ifdef DEBUG_C14N

   285         xmlGenericError(xmlGenericErrorContext,

   286             "xmlC14NVisibleNsStackSave: cur or state is null.\n");

   287 #endif

   288 	return;

   289     }

   290     

   291     state->nsCurEnd = cur->nsCurEnd;

   292     state->nsPrevStart = cur->nsPrevStart;

   293     state->nsPrevEnd = cur->nsPrevEnd;

   294 }

   295 

   296 static void

   297 xmlC14NVisibleNsStackRestore(xmlC14NVisibleNsStackPtr cur, xmlC14NVisibleNsStackPtr state) {

   298     if((cur == NULL) || (state == NULL)) {

   299 #ifdef DEBUG_C14N

   300         xmlGenericError(xmlGenericErrorContext,

   301             "xmlC14NVisibleNsStackRestore: cur or state is null.\n");

   302 #endif

   303 	return;

   304     }

   305     cur->nsCurEnd = state->nsCurEnd;

   306     cur->nsPrevStart = state->nsPrevStart;

   307     cur->nsPrevEnd = state->nsPrevEnd;

   308 }

   309 

   310 static void 

   311 xmlC14NVisibleNsStackShift(xmlC14NVisibleNsStackPtr cur) {

   312     if(cur == NULL) {

   313 #ifdef DEBUG_C14N

   314         xmlGenericError(xmlGenericErrorContext,

   315             "xmlC14NVisibleNsStackRestore: cur is null.\n");

   316 #endif

   317 	return;

   318     }

   319     cur->nsPrevStart = cur->nsPrevEnd;

   320     cur->nsPrevEnd = cur->nsCurEnd;

   321 }

   322 

   323 static int

   324 xmlC14NStrEqual(const xmlChar *str1, const xmlChar *str2) {

   325     if (str1 == str2) return(1);

   326     if (str1 == NULL) return((*str2) == '\0');

   327     if (str2 == NULL) return((*str1) == '\0');

   328     do {

   329 	if (*str1++ != *str2) return(0);

   330     } while (*str2++);

   331     return(1);

   332 }

   333 

   334 /**

   335  * xmlC14NVisibleNsStackFind:

   336  * @ctx:		the C14N context 

   337  * @ns:			the namespace to check

   338  *

   339  * Checks whether the given namespace was already rendered or not

   340  *

   341  * Returns 1 if we already wrote this namespace or 0 otherwise

   342  */

   343 static int

   344 xmlC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns)

   345 {

   346     int i;

   347     const xmlChar *prefix;

   348     const xmlChar *href;

   349     int has_empty_ns;

   350         

   351     if(cur == NULL) {

   352 #ifdef DEBUG_C14N

   353         xmlGenericError(xmlGenericErrorContext,

   354             "xmlC14NVisibleNsStackFind: cur is null.\n");

   355 #endif

   356         return (0);

   357     }

   358 

   359     /*

   360      * if the default namespace xmlns="" is not defined yet then 

   361      * we do not want to print it out

   362      */

   363     prefix = ((ns == NULL) || (ns->prefix == NULL)) ? BAD_CAST "" : ns->prefix;

   364     href = ((ns == NULL) || (ns->href == NULL)) ? BAD_CAST "" : ns->href;

   365     has_empty_ns = (xmlC14NStrEqual(prefix, NULL) && xmlC14NStrEqual(href, NULL));

   366 

   367     if (cur->nsTab != NULL) {

   368 	int start = (has_empty_ns) ? 0 : cur->nsPrevStart;

   369         for (i = cur->nsCurEnd - 1; i >= start; --i) {

   370             xmlNsPtr ns1 = cur->nsTab[i];

   371 	    

   372 	    if(xmlC14NStrEqual(prefix, (ns1 != NULL) ? ns1->prefix : NULL)) {

   373 		return(xmlC14NStrEqual(href, (ns1 != NULL) ? ns1->href : NULL));

   374 	    }

   375         }

   376     }

   377     return(has_empty_ns);

   378 }

   379 

   380 static int			

   381 xmlExcC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlC14NCtxPtr ctx) {

   382     int i;

   383     const xmlChar *prefix;

   384     const xmlChar *href;

   385     int has_empty_ns;

   386         

   387     if(cur == NULL) {

   388 #ifdef DEBUG_C14N

   389         xmlGenericError(xmlGenericErrorContext,

   390             "xmlExcC14NVisibleNsStackFind: cur is null.\n");

   391 #endif

   392         return (0);

   393     }

   394 

   395     /*

   396      * if the default namespace xmlns="" is not defined yet then 

   397      * we do not want to print it out

   398      */

   399     prefix = ((ns == NULL) || (ns->prefix == NULL)) ? BAD_CAST "" : ns->prefix;

   400     href = ((ns == NULL) || (ns->href == NULL)) ? BAD_CAST "" : ns->href;

   401     has_empty_ns = (xmlC14NStrEqual(prefix, NULL) && xmlC14NStrEqual(href, NULL));

   402 

   403     if (cur->nsTab != NULL) {

   404 	int start = 0;

   405         for (i = cur->nsCurEnd - 1; i >= start; --i) {

   406             xmlNsPtr ns1 = cur->nsTab[i];

   407 	    

   408 	    if(xmlC14NStrEqual(prefix, (ns1 != NULL) ? ns1->prefix : NULL)) {

   409 		if(xmlC14NStrEqual(href, (ns1 != NULL) ? ns1->href : NULL)) {

   410 	    	    return(xmlC14NIsVisible(ctx, ns1, cur->nodeTab[i]));

   411 		} else {

   412 		    return(0);

   413 		}

   414 	    }

   415         }

   416     }

   417     return(has_empty_ns);

   418 }

   419 

   420 

   421 

   422 

   423 /**

   424  * xmlC14NIsXmlNs:

   425  * @ns: 		the namespace to check

   426  *  		

   427  * Checks whether the given namespace is a default "xml:" namespace

   428  * with href="http://www.w3.org/XML/1998/namespace"

   429  *

   430  * Returns 1 if the node is default or 0 otherwise

   431  */

   432 

   433 /* todo: make it a define? */

   434 static int

   435 xmlC14NIsXmlNs(xmlNsPtr ns)

   436 {

   437     return ((ns != NULL) &&

   438             (xmlStrEqual(ns->prefix, BAD_CAST "xml")) &&

   439             (xmlStrEqual(ns->href,

   440                          BAD_CAST

   441                          "http://www.w3.org/XML/1998/namespace")));

   442 }

   443 

   444 

   445 /**

   446  * xmlC14NNsCompare:

   447  * @ns1:		the pointer to first namespace

   448  * @ns2: 		the pointer to second namespace

   449  *

   450  * Compares the namespaces by names (prefixes).

   451  *

   452  * Returns -1 if ns1 < ns2, 0 if ns1 == ns2 or 1 if ns1 > ns2.

   453  */

   454 static int

   455 xmlC14NNsCompare(xmlNsPtr ns1, xmlNsPtr ns2)

   456 {

   457     if (ns1 == ns2)

   458         return (0);

   459     if (ns1 == NULL)

   460         return (-1);

   461     if (ns2 == NULL)

   462         return (1);

   463 

   464     return (xmlStrcmp(ns1->prefix, ns2->prefix));

   465 }

   466 

   467 

   468 /**

   469  * xmlC14NPrintNamespaces:

   470  * @ns:			the pointer to namespace

   471  * @ctx: 		the C14N context

   472  *

   473  * Prints the given namespace to the output buffer from C14N context.

   474  *

   475  * Returns 1 on success or 0 on fail.

   476  */

   477 static int

   478 xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx)

   479 {

   480 

   481     if ((ns == NULL) || (ctx == NULL)) {

   482 #ifdef DEBUG_C14N

   483         xmlGenericError(xmlGenericErrorContext,

   484                         "xmlC14NPrintNamespace: namespace or context pointer is null\n");

   485 #endif

   486         return 0;

   487     }

   488 

   489     if (ns->prefix != NULL) {

   490         xmlOutputBufferWriteString(ctx->buf, " xmlns:");

   491         xmlOutputBufferWriteString(ctx->buf, (const char *) ns->prefix);

   492         xmlOutputBufferWriteString(ctx->buf, "=\"");

   493     } else {

   494         xmlOutputBufferWriteString(ctx->buf, " xmlns=\"");

   495     }

   496     if(ns->href != NULL) {

   497 	xmlOutputBufferWriteString(ctx->buf, (const char *) ns->href);

   498     }

   499     xmlOutputBufferWriteString(ctx->buf, "\"");

   500     return (1);

   501 }

   502 

   503 /**

   504  * xmlC14NProcessNamespacesAxis:

   505  * @ctx: 		the C14N context

   506  * @node:		the current node

   507  *

   508  * Prints out canonical namespace axis of the current node to the

   509  * buffer from C14N context as follows 

   510  *

   511  * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)

   512  *

   513  * Namespace Axis

   514  * Consider a list L containing only namespace nodes in the 

   515  * axis and in the node-set in lexicographic order (ascending). To begin 

   516  * processing L, if the first node is not the default namespace node (a node 

   517  * with no namespace URI and no local name), then generate a space followed 

   518  * by xmlns="" if and only if the following conditions are met:

   519  *    - the element E that owns the axis is in the node-set

   520  *    - The nearest ancestor element of E in the node-set has a default 

   521  *	    namespace node in the node-set (default namespace nodes always 

   522  *      have non-empty values in XPath)

   523  * The latter condition eliminates unnecessary occurrences of xmlns="" in 

   524  * the canonical form since an element only receives an xmlns="" if its 

   525  * default namespace is empty and if it has an immediate parent in the 

   526  * canonical form that has a non-empty default namespace. To finish 

   527  * processing  L, simply process every namespace node in L, except omit 

   528  * namespace node with local name xml, which defines the xml prefix, 

   529  * if its string value is http://www.w3.org/XML/1998/namespace.

   530  *

   531  * Exclusive XML Canonicalization v 1.0 (http://www.w3.org/TR/xml-exc-c14n)

   532  * Canonical XML applied to a document subset requires the search of the 

   533  * ancestor nodes of each orphan element node for attributes in the xml 

   534  * namespace, such as xml:lang and xml:space. These are copied into the 

   535  * element node except if a declaration of the same attribute is already 

   536  * in the attribute axis of the element (whether or not it is included in 

   537  * the document subset). This search and copying are omitted from the 

   538  * Exclusive XML Canonicalization method.

   539  *

   540  * Returns 0 on success or -1 on fail.

   541  */

   542 static int

   543 xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)

   544 {

   545     xmlNodePtr n;

   546     xmlNsPtr ns, tmp;

   547     xmlListPtr list;

   548     int already_rendered;

   549     int has_empty_ns = 0;

   550     

   551     if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {

   552 #ifdef DEBUG_C14N

   553         xmlGenericError(xmlGenericErrorContext,

   554                         "xmlC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");

   555 #endif

   556         return (-1);

   557     }

   558 

   559     /*

   560      * Create a sorted list to store element namespaces

   561      */

   562     list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNsCompare);

   563     if (list == NULL) {

   564 #ifdef DEBUG_C14N

   565         xmlGenericError(xmlGenericErrorContext,

   566                         "xmlC14NProcessNamespacesAxis: list creation failed\n");

   567 #endif

   568         return (-1);

   569     }

   570 

   571     /* check all namespaces */

   572     for(n = cur; n != NULL; n = n->parent) {

   573 	for(ns = n->nsDef; ns != NULL; ns = ns->next) {

   574 	    tmp = xmlSearchNs(cur->doc, cur, ns->prefix);

   575 	    

   576 	    if((tmp == ns) && !xmlC14NIsXmlNs(ns) && xmlC14NIsVisible(ctx, ns, cur)) {

   577 		already_rendered = xmlC14NVisibleNsStackFind(ctx->ns_rendered, ns);

   578 		if(visible) {

   579         	    xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur);

   580 		}

   581 		if(!already_rendered) {

   582 		    xmlListInsert(list, ns); 

   583 		}

   584     		if(xmlStrlen(ns->prefix) == 0) {

   585 		    has_empty_ns = 1;

   586 		}

   587 	    }

   588 	}

   589     }

   590 	

   591     /**

   592      * if the first node is not the default namespace node (a node with no 

   593      * namespace URI and no local name), then generate a space followed by 

   594      * xmlns="" if and only if the following conditions are met:

   595      *  - the element E that owns the axis is in the node-set

   596      *  - the nearest ancestor element of E in the node-set has a default 

   597      *     namespace node in the node-set (default namespace nodes always 

   598      *     have non-empty values in XPath)

   599      */

   600     if(visible && !has_empty_ns) {

   601 		//FIXIT

   602         //static 

   603 			xmlNs ns_default;

   604 

   605         memset(&ns_default, 0, sizeof(ns_default));

   606         if(!xmlC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default)) {

   607     	    xmlC14NPrintNamespaces(&ns_default, ctx);

   608 	}

   609     }

   610 	

   611     

   612     /* 

   613      * print out all elements from list 

   614      */

   615     xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces, (const void *) ctx);

   616 

   617     /* 

   618      * Cleanup

   619      */

   620     xmlListDelete(list);

   621     return (0);

   622 }

   623 

   624 

   625 /**

   626  * xmlExcC14NProcessNamespacesAxis:

   627  * @ctx: 		the C14N context

   628  * @node:		the current node

   629  *

   630  * Prints out exclusive canonical namespace axis of the current node to the

   631  * buffer from C14N context as follows 

   632  *

   633  * Exclusive XML Canonicalization

   634  * http://www.w3.org/TR/xml-exc-c14n

   635  *

   636  * If the element node is in the XPath subset then output the node in 

   637  * accordance with Canonical XML except for namespace nodes which are 

   638  * rendered as follows:

   639  *

   640  * 1. Render each namespace node iff:

   641  *    * it is visibly utilized by the immediate parent element or one of 

   642  *      its attributes, or is present in InclusiveNamespaces PrefixList, and

   643  *    * its prefix and value do not appear in ns_rendered. ns_rendered is 

   644  *      obtained by popping the state stack in order to obtain a list of 

   645  *      prefixes and their values which have already been rendered by 

   646  *      an output ancestor of the namespace node's parent element.

   647  * 2. Append the rendered namespace node to the list ns_rendered of namespace 

   648  * nodes rendered by output ancestors. Push ns_rendered on state stack and 

   649  * recurse.

   650  * 3. After the recursion returns, pop thestate stack.

   651  *

   652  *

   653  * Returns 0 on success or -1 on fail.

   654  */

   655 static int

   656 xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)

   657 {

   658     xmlNsPtr ns;

   659     xmlListPtr list;

   660     xmlAttrPtr attr;

   661     int already_rendered;

   662     int has_empty_ns = 0;

   663     int has_visibly_utilized_empty_ns = 0;

   664     int has_empty_ns_in_inclusive_list = 0;

   665         

   666     if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {

   667 #ifdef DEBUG_C14N

   668         xmlGenericError(xmlGenericErrorContext,

   669                         "xmlExcC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");

   670 #endif

   671         return (-1);

   672     }

   673 

   674     if(!ctx->exclusive) {

   675 #ifdef DEBUG_C14N

   676         xmlGenericError(xmlGenericErrorContext,

   677                         "xmlExcC14NProcessNamespacesAxis: called for non-exclusive canonization or rendered stack is NULL.\n");

   678 #endif

   679         return (-1);

   680 

   681     }

   682 

   683     /*

   684      * Create a sorted list to store element namespaces

   685      */

   686     list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNsCompare);

   687     if (list == NULL) {

   688 #ifdef DEBUG_C14N

   689         xmlGenericError(xmlGenericErrorContext,

   690                         "xmlExcC14NProcessNamespacesAxis: list creation failed\n");

   691 #endif

   692         return (-1);

   693     }

   694 

   695     /* 

   696      * process inclusive namespaces:

   697      * All namespace nodes appearing on inclusive ns list are 

   698      * handled as provided in Canonical XML

   699      */

   700     if(ctx->inclusive_ns_prefixes != NULL) {

   701 	xmlChar *prefix; 

   702 	int i;

   703 	

   704 	for (i = 0; ctx->inclusive_ns_prefixes[i] != NULL; ++i) {

   705 	    prefix = ctx->inclusive_ns_prefixes[i];

   706 	    /*

   707 	     * Special values for namespace with empty prefix

   708 	     */

   709             if (xmlStrEqual(prefix, BAD_CAST "#default")

   710                 || xmlStrEqual(prefix, BAD_CAST "")) {

   711                 prefix = NULL;

   712 		has_empty_ns_in_inclusive_list = 1;

   713             }

   714 	

   715 	    ns = xmlSearchNs(cur->doc, cur, prefix);	    

   716 	    if((ns != NULL) && !xmlC14NIsXmlNs(ns) && xmlC14NIsVisible(ctx, ns, cur)) {

   717 		already_rendered = xmlC14NVisibleNsStackFind(ctx->ns_rendered, ns);

   718 		if(visible) {

   719     	    	    xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur);

   720 		}

   721 		if(!already_rendered) {

   722 	    	    xmlListInsert(list, ns); 

   723 		}

   724     		if(xmlStrlen(ns->prefix) == 0) {

   725 		    has_empty_ns = 1;

   726 		}

   727 	    }

   728 	}

   729     }

   730     

   731     /* add node namespace */

   732     if(cur->ns != NULL) {

   733 	ns = cur->ns;

   734     } else {

   735         ns = xmlSearchNs(cur->doc, cur, NULL);

   736 	has_visibly_utilized_empty_ns = 1;

   737     }

   738     if((ns != NULL) && !xmlC14NIsXmlNs(ns)) {

   739 	if(visible && xmlC14NIsVisible(ctx, ns, cur)) { 

   740 	    if(!xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, ns, ctx)) {

   741 		xmlListInsert(list, ns);

   742 	    }

   743 	}

   744 	if(visible) {

   745     	    xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur); 

   746 	}

   747 	if(xmlStrlen(ns->prefix) == 0) {

   748 	    has_empty_ns = 1;

   749 	}

   750     }

   751     

   752         

   753     /* add attributes */

   754     for(attr = cur->properties; attr != NULL; attr = attr->next) {

   755         /* 

   756          * we need to check that attribute is visible and has non

   757          * default namespace (XML Namespaces: "default namespaces 

   758     	 * do not apply directly to attributes")	 

   759          */

   760 	if((attr->ns != NULL) && xmlC14NIsVisible(ctx, attr, cur)) {

   761 	    already_rendered = xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, attr->ns, ctx);

   762 	    xmlC14NVisibleNsStackAdd(ctx->ns_rendered, attr->ns, (xmlNodePtr)attr); 

   763 	    if(!already_rendered && visible) {

   764 		xmlListInsert(list, attr->ns); 

   765 	    }

   766 	    if(xmlStrlen(attr->ns->prefix) == 0) {

   767 		has_empty_ns = 1;

   768 	    }

   769 	} else if(attr->ns == NULL) {

   770 	    has_visibly_utilized_empty_ns = 1;

   771 	}

   772     }

   773 

   774     /*

   775      * Process xmlns=""

   776      */

   777     if(visible && has_visibly_utilized_empty_ns && 

   778 	    !has_empty_ns && !has_empty_ns_in_inclusive_list) {

   779         //static //FIXIT 

   780 			xmlNs ns_default;

   781 

   782         memset(&ns_default, 0, sizeof(ns_default));

   783 	

   784         already_rendered = xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default, ctx);

   785 	if(!already_rendered) {

   786     	    xmlC14NPrintNamespaces(&ns_default, ctx);

   787 	}

   788     } else if(visible && !has_empty_ns && has_empty_ns_in_inclusive_list) {

   789         //static  FIXIT

   790 		xmlNs ns_default;

   791 

   792         memset(&ns_default, 0, sizeof(ns_default));

   793         if(!xmlC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default)) {

   794     	    xmlC14NPrintNamespaces(&ns_default, ctx);

   795 	}

   796     }

   797 

   798     

   799 

   800     /* 

   801      * print out all elements from list 

   802      */

   803     xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces, (const void *) ctx);

   804 

   805     /* 

   806      * Cleanup

   807      */

   808     xmlListDelete(list);

   809     return (0);

   810 }

   811 

   812 

   813 /**

   814  * xmlC14NAttrsCompare:

   815  * @attr1:		the pointer tls o first attr

   816  * @attr2: 		the pointer to second attr

   817  *

   818  * Prints the given attribute to the output buffer from C14N context.

   819  *

   820  * Returns -1 if attr1 < attr2, 0 if attr1 == attr2 or 1 if attr1 > attr2.

   821  */

   822 static int

   823 xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2)

   824 {

   825     int ret = 0;

   826 

   827     /*

   828      * Simple cases

   829      */

   830     if (attr1 == attr2)

   831         return (0);

   832     if (attr1 == NULL)

   833         return (-1);

   834     if (attr2 == NULL)

   835         return (1);

   836     if (attr1->ns == attr2->ns) {

   837         return (xmlStrcmp(attr1->name, attr2->name));

   838     }

   839 

   840     /* 

   841      * Attributes in the default namespace are first

   842      * because the default namespace is not applied to

   843      * unqualified attributes

   844      */

   845     if (attr1->ns == NULL)

   846         return (-1);

   847     if (attr2->ns == NULL)

   848         return (1);

   849     if (attr1->ns->prefix == NULL)

   850         return (-1);

   851     if (attr2->ns->prefix == NULL)

   852         return (1);

   853 

   854     ret = xmlStrcmp(attr1->ns->href, attr2->ns->href);

   855     if (ret == 0) {

   856         ret = xmlStrcmp(attr1->name, attr2->name);

   857     }

   858     return (ret);

   859 }

   860 

   861 

   862 /**

   863  * xmlC14NPrintAttrs:

   864  * @attr:		the pointer to attr

   865  * @ctx: 		the C14N context

   866  *

   867  * Prints out canonical attribute urrent node to the

   868  * buffer from C14N context as follows 

   869  *

   870  * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)

   871  *

   872  * Returns 1 on success or 0 on fail.

   873  */

   874 static int

   875 xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx)

   876 {

   877     xmlChar *value;

   878     xmlChar *buffer;

   879 

   880     if ((attr == NULL) || (ctx == NULL)) {

   881 #ifdef DEBUG_C14N

   882         xmlGenericError(xmlGenericErrorContext,

   883                         "xmlC14NPrintAttrs: attr == NULL or ctx == NULL\n");

   884 #endif

   885         return (0);

   886     }

   887 

   888     xmlOutputBufferWriteString(ctx->buf, " ");

   889     if (attr->ns != NULL && xmlStrlen(attr->ns->prefix) > 0) {

   890         xmlOutputBufferWriteString(ctx->buf,

   891                                    (const char *) attr->ns->prefix);

   892         xmlOutputBufferWriteString(ctx->buf, ":");

   893     }

   894     xmlOutputBufferWriteString(ctx->buf, (const char *) attr->name);

   895     xmlOutputBufferWriteString(ctx->buf, "=\"");

   896 

   897     value = xmlNodeListGetString(attr->doc, attr->children, 1);

   898     /* todo: should we log an error if value==NULL ? */

   899     if (value != NULL) {

   900         buffer = xmlC11NNormalizeAttr(value);

   901         xmlFree(value);

   902         if (buffer != NULL) {

   903             xmlOutputBufferWriteString(ctx->buf, (const char *) buffer);

   904             xmlFree(buffer);

   905         } else {

   906 #ifdef DEBUG_C14N

   907             xmlGenericError(xmlGenericErrorContext,

   908                             "xmlC14NPrintAttrs: xmlC11NNormalizeAttr failed\n");

   909 #endif

   910             return (0);

   911         }

   912     }

   913     xmlOutputBufferWriteString(ctx->buf, "\"");

   914     return (1);

   915 }

   916 

   917 /**

   918  * xmlC14NProcessAttrsAxis:

   919  * @ctx: 		the C14N context

   920  * @cur:		the current node

   921  *

   922  * Prints out canonical attribute axis of the current node to the

   923  * buffer from C14N context as follows 

   924  *

   925  * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)

   926  *

   927  * Attribute Axis 

   928  * In lexicographic order (ascending), process each node that 

   929  * is in the element's attribute axis and in the node-set.

   930  * 

   931  * The processing of an element node E MUST be modified slightly 

   932  * when an XPath node-set is given as input and the element's 

   933  * parent is omitted from the node-set.

   934  *

   935  *

   936  * Exclusive XML Canonicalization v 1.0 (http://www.w3.org/TR/xml-exc-c14n)

   937  *

   938  * Canonical XML applied to a document subset requires the search of the 

   939  * ancestor nodes of each orphan element node for attributes in the xml 

   940  * namespace, such as xml:lang and xml:space. These are copied into the 

   941  * element node except if a declaration of the same attribute is already 

   942  * in the attribute axis of the element (whether or not it is included in 

   943  * the document subset). This search and copying are omitted from the 

   944  * Exclusive XML Canonicalization method.

   945  *

   946  * Returns 0 on success or -1 on fail.

   947  */

   948 static int

   949 xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur)

   950 {

   951     xmlAttrPtr attr;

   952     xmlListPtr list;

   953 

   954     if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {

   955 #ifdef DEBUG_C14N

   956         xmlGenericError(xmlGenericErrorContext,

   957                         "xmlC14NProcessAttrsAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");

   958 #endif

   959         return (-1);

   960     }

   961 

   962     /*

   963      * Create a sorted list to store element attributes

   964      */

   965     list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NAttrsCompare);

   966     if (list == NULL) {

   967 #ifdef DEBUG_C14N

   968         xmlGenericError(xmlGenericErrorContext,

   969                         "xmlC14NProcessAttrsAxis: list creation failed\n");

   970 #endif

   971         return (-1);

   972     }

   973 

   974     /* 

   975      * Add all visible attributes from current node. 

   976      */

   977     attr = cur->properties;

   978     while (attr != NULL) {

   979         /* check that attribute is visible */

   980         if (xmlC14NIsVisible(ctx, attr, cur)) {

   981             xmlListInsert(list, attr);

   982         }

   983         attr = attr->next;

   984     }

   985 

   986     /* 

   987      * include attributes in "xml" namespace defined in ancestors

   988      * (only for non-exclusive XML Canonicalization)

   989      */

   990     if ((!ctx->exclusive) && (cur->parent != NULL)

   991         && (!xmlC14NIsVisible(ctx, cur->parent, cur->parent->parent))) {

   992         /*

   993          * If XPath node-set is not specified then the parent is always 

   994          * visible!

   995          */

   996         cur = cur->parent;

   997         while (cur != NULL) {

   998             attr = cur->properties;

   999             while (attr != NULL) {

  1000                 if ((attr->ns != NULL)

  1001                     && (xmlStrEqual(attr->ns->prefix, BAD_CAST "xml"))) {

  1002                     if (xmlListSearch(list, attr) == NULL) {

  1003                         xmlListInsert(list, attr);

  1004                     }

  1005                 }

  1006                 attr = attr->next;

  1007             }

  1008             cur = cur->parent;

  1009         }

  1010     }

  1011 

  1012     /* 

  1013      * print out all elements from list 

  1014      */

  1015     xmlListWalk(list, (xmlListWalker) xmlC14NPrintAttrs, (const void *) ctx);

  1016 

  1017     /* 

  1018      * Cleanup

  1019      */

  1020     xmlListDelete(list);

  1021     return (0);

  1022 }

  1023 

  1024 /** 

  1025  * xmlC14NCheckForRelativeNamespaces:

  1026  * @ctx:		the C14N context

  1027  * @cur:		the current element node

  1028  *

  1029  * Checks that current element node has no relative namespaces defined

  1030  *

  1031  * Returns 0 if the node has no relative namespaces or -1 otherwise.

  1032  */

  1033 static int

  1034 xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur)

  1035 {

  1036     xmlNsPtr ns;

  1037 

  1038     if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {

  1039 #ifdef DEBUG_C14N

  1040         xmlGenericError(xmlGenericErrorContext,

  1041                         "xmlC14NCheckForRelativeNamespaces: Null context or node pointer or type != XML_ELEMENT_NODE.\n");

  1042 #endif

  1043         return (-1);

  1044     }

  1045 

  1046     ns = cur->nsDef;

  1047     while (ns != NULL) {

  1048         if (xmlStrlen(ns->href) > 0) {

  1049             xmlURIPtr uri;

  1050 

  1051             uri = xmlParseURI((const char *) ns->href);

  1052             if (uri == NULL) {

  1053 #ifdef DEBUG_C14N

  1054                 xmlGenericError(xmlGenericErrorContext,

  1055                                 "xmlC14NCheckForRelativeNamespaces: unable to parse uri=\"%s\".\n",

  1056                                 ns->href);

  1057 #endif

  1058                 return (-1);

  1059             }

  1060             if (xmlStrlen((const xmlChar *) uri->scheme) == 0) {

  1061                 xmlFreeURI(uri);

  1062                 return (-1);

  1063             }

  1064             if ((!xmlStrEqual

  1065                  ((const xmlChar *) uri->scheme, BAD_CAST "urn"))

  1066                 && (xmlStrlen((const xmlChar *) uri->server) == 0)) {

  1067                 xmlFreeURI(uri);

  1068                 return (-1);

  1069             }

  1070             xmlFreeURI(uri);

  1071         }

  1072         ns = ns->next;

  1073     }

  1074     return (0);

  1075 }

  1076 

  1077 /**

  1078  * xmlC14NProcessElementNode:

  1079  * @ctx: 		the pointer to C14N context object

  1080  * @cur:		the node to process

  1081  *  		

  1082  * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)

  1083  *

  1084  * Element Nodes

  1085  * If the element is not in the node-set, then the result is obtained 

  1086  * by processing the namespace axis, then the attribute axis, then 

  1087  * processing the child nodes of the element that are in the node-set 

  1088  * (in document order). If the element is in the node-set, then the result 

  1089  * is an open angle bracket (<), the element QName, the result of 

  1090  * processing the namespace axis, the result of processing the attribute 

  1091  * axis, a close angle bracket (>), the result of processing the child 

  1092  * nodes of the element that are in the node-set (in document order), an 

  1093  * open angle bracket, a forward slash (/), the element QName, and a close 

  1094  * angle bracket.

  1095  *

  1096  * Returns non-negative value on success or negative value on fail

  1097  */

  1098 static int

  1099 xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)

  1100 {

  1101     int ret;

  1102     xmlC14NVisibleNsStack state;

  1103     int parent_is_doc = 0;

  1104 

  1105     if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {

  1106 #ifdef DEBUG_C14N

  1107         xmlGenericError(xmlGenericErrorContext,

  1108                         "xmlC14NProcessElementNode: Null context or node pointer or type != XML_ELEMENT_NODE.\n");

  1109 #endif

  1110         return (-1);

  1111     }

  1112 

  1113     /* 

  1114      * Check relative relative namespaces:

  1115      * implementations of XML canonicalization MUST report an operation

  1116      * failure on documents containing relative namespace URIs.

  1117      */

  1118     if (xmlC14NCheckForRelativeNamespaces(ctx, cur) < 0) {

  1119 #ifdef DEBUG_C14N

  1120         xmlGenericError(xmlGenericErrorContext,

  1121                         "xmlC14NProcessElementNode: xmlC14NCheckForRelativeNamespaces failed.\n");

  1122 #endif

  1123         return (-1);

  1124     }

  1125 

  1126 

  1127     /* 

  1128      * Save ns_rendered stack position

  1129      */

  1130     xmlC14NVisibleNsStackSave(ctx->ns_rendered, &state);

  1131 

  1132     if (visible) {	

  1133         if (ctx->parent_is_doc) {

  1134 	    /* save this flag into the stack */

  1135 	    parent_is_doc = ctx->parent_is_doc;