xmlsig 0.0.1

data/ext/xmlsig/XmlDoc.cpp

@@ -0,0 +1,278 @@
+/*
+ * (C) Copyright 2006 VeriSign, Inc.
+ * Developed by Sxip Identity
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <iostream>
+#include <string>
+#include <vector>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+#include <xmlsec/xmltree.h>
+#include "XmlDoc.h"
+#include "XmlCharBuf.h"
+using namespace std;
+
+
+XmlDoc::XmlDoc ()
+    : doc (0)
+{}
+
+
+XmlDoc::XmlDoc (const XmlDoc& xmlDoc)
+    : doc (0)
+{
+    this->operator=(xmlDoc);
+}
+
+
+XmlDoc::~XmlDoc ()
+{
+    freeDoc();
+}
+
+
+const XmlDoc& XmlDoc::operator= (const XmlDoc& xmlDoc)
+{
+    if (this != &xmlDoc)
+    {
+        freeDoc();
+        if (xmlDoc.doc)
+        {
+            // recursive copy of original doc
+            doc = xmlCopyDoc(xmlDoc.doc, 1);
+            // copy over ID attributes too
+            if (doc)
+            {
+                idAttrs = xmlDoc.idAttrs;
+                for (unsigned i = 0; i < xmlDoc.idAttrs.size(); i += 3)
+                {
+                    addIdAttr(xmlDoc.idAttrs[i],
+                              xmlDoc.idAttrs[i + 1],
+                              xmlDoc.idAttrs[i + 2]);
+                }
+            }
+        }
+    }
+    return *this;
+}
+
+
+void XmlDoc::freeDoc ()
+{
+    if (doc)
+    {
+        xmlFreeDoc(doc);
+        doc = NULL;
+        idAttrs.clear();
+    }
+}
+
+
+xmlDocPtr XmlDoc::getDoc ()
+{
+    return doc;
+}
+
+
+int XmlDoc::loadFromXmlDocPtr (xmlDocPtr newdoc)
+{
+    if (!newdoc)
+    {
+        THROW(ValueError, "Invalid document to copy", -1);
+    }
+    freeDoc();
+    doc = xmlCopyDoc(newdoc, 1);
+    if ((doc == NULL) || (xmlDocGetRootElement(doc) == NULL))
+    {
+        THROW(LibError, "Error parsing XML document", -1);
+    }
+    return 0;
+}
+
+
+int XmlDoc::loadFromString (string xmlData)
+{
+    freeDoc();
+    doc = xmlReadDoc((xmlChar*) xmlData.c_str(), "", NULL, 0);
+    if ((doc == NULL) || (xmlDocGetRootElement(doc) == NULL))
+    {
+        THROW(LibError, "Error parsing XML document", -1);
+    }
+    return 0;
+}
+
+
+int XmlDoc::loadFromFile (string fileName)
+{
+    freeDoc();
+    doc = xmlReadFile(fileName.c_str(), NULL, 0);
+    if (doc == NULL)
+    {
+        THROW(IOError, "Failure loading XML document", -1);
+    }
+    if (xmlDocGetRootElement(doc) == NULL)
+    {
+        THROW(LibError, "Error parsing XML document", -1);
+    }
+    return 0;
+}
+
+
+void XmlDoc::dump ()
+{
+    if (doc)
+    {
+        xmlDocDump(stdout, doc);
+    }
+}
+
+
+string XmlDoc::toString ()
+{
+    string str = "";
+    if (doc)
+    {
+        XmlCharBuf buf;
+        int len = 0;
+        xmlDocDumpMemory(doc, (xmlChar**)buf, &len);
+        str = string((const char*)buf, len);
+    }
+    return str;
+}
+
+
+int XmlDoc::toFile (string fileName)
+{
+    if (doc)
+    {
+        int res = xmlSaveFile(fileName.c_str(), doc);
+        if (res < 0)
+        {
+            THROW(LibError, "Document dump failure", res);
+        }
+    }
+    return 0;
+}
+
+
+int XmlDoc::addIdAttr (string attrName, string nodeName, string nsHref)
+{
+    assert(doc);
+    assert(attrName.length());
+    assert(nodeName.length());
+    const char* nsHrefChr = NULL;
+    int added = 0;
+    if (nsHref.length())
+    {
+        nsHrefChr = nsHref.c_str();
+    }
+    xmlNodePtr cur = xmlSecGetNextElementNode(doc->children);
+    while (cur != NULL)
+    {
+        if (addIdAttrToNode(cur, 
+                            (xmlChar*)attrName.c_str(), 
+                            (xmlChar*)nodeName.c_str(), 
+                            (xmlChar*)nsHrefChr) < 0)
+        {
+            return -1;
+        }
+        cur = xmlSecGetNextElementNode(cur->next);
+        added++;
+    }
+    if (added)
+    {
+        idAttrs.push_back(attrName);
+        idAttrs.push_back(nodeName);
+        idAttrs.push_back(nsHref);
+    }
+    return 0;
+}
+
+
+int XmlDoc::addIdAttrToNode (xmlNodePtr node, 
+                             const xmlChar* attrName, 
+                             const xmlChar* nodeName, 
+                             const xmlChar* nsHref)
+{
+    xmlAttrPtr attr, tmpAttr;
+    xmlNodePtr cur;
+
+    if ((node == NULL) || (attrName == NULL) || (nodeName == NULL))
+    {
+        THROW(ValueError, "Bad parameters", -1);
+    }
+
+    /* process children first because it does not matter much but does simplify code */
+    cur = xmlSecGetNextElementNode(node->children);
+    while (cur != NULL)
+    {
+        int ret = addIdAttrToNode(cur, attrName, nodeName, nsHref);
+        if (ret < 0)
+        {
+            return (ret);
+        }
+        cur = xmlSecGetNextElementNode(cur->next);
+    }
+
+
+    /* node name must match */
+    if (!xmlStrEqual(node->name, nodeName))
+    {
+        return (0);
+    }
+
+    /* if nsHref is set then it also should match */
+    if ((nsHref != NULL) && (node->ns != NULL) && 
+        (!xmlStrEqual(nsHref, node->ns->href)))
+    {
+        return (0);
+    }
+
+    /* the attribute with name equal to attrName should exist */
+    for (attr = node->properties; attr != NULL; attr = attr->next)
+    {
+        if (xmlStrEqual(attr->name, attrName))
+        {
+            break;
+        }
+    }
+    if (attr == NULL)
+    {
+        return (0);
+    }
+
+    /* and this attr should have a value */
+    XmlCharBuf id (xmlNodeListGetString(node->doc, attr->children, 1));
+    if (!(int)id)
+    {
+        return (0);
+    }
+
+    /* check that we don't have same ID already */
+    tmpAttr = xmlGetID(node->doc, id);
+    if (tmpAttr == NULL)
+    {
+        xmlAddID(NULL, node->doc, id, attr);
+    }
+    else if (tmpAttr != attr)
+    {
+        THROW(XMLError, "Duplicate ID attribute", -1);
+    }
+    return (0);
+}
+

data/ext/xmlsig/XmlDoc.h

@@ -0,0 +1,157 @@
+/*
+ * (C) Copyright 2006 VeriSign, Inc.
+ * Developed by Sxip Identity
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef _XMLDOC_H
+#define _XMLDOC_H
+#include <string>
+#include <vector>
+#include <libxml/parser.h>
+#include "Exceptions.h"
+using namespace std;
+
+/**
+ * An XML document.
+ * Encapsulates a LibXML2 XML Document object.  Provides methods
+ * to load and save to other formats.  For now it just loads/saves the
+ * document to a file or a string, but more methods could be added to load/save
+ * to/from other XML representations/objects.
+ */
+class XmlDoc
+{
+public:
+    /**
+     * Construct an empty document.
+     */
+    XmlDoc();
+    /**
+     * Destroy document object.
+     * Frees document object if one was created.
+     */
+    ~XmlDoc();
+
+    /**
+     * Load directly from an LibXML2 xmlDocPtr.
+     * @return 0 on success, -1 on error
+     */
+    int loadFromXmlDocPtr(xmlDocPtr newdoc);
+    /**
+     * Get the internal representation of the XML document.
+     * @return Pointer to the XML document structure
+     */
+    xmlDocPtr getDoc();
+    /**
+     * Load an XML document from a string.
+     * @param xmlData A string containing an XML document
+     * @return 0 on success, -1 on error
+     */
+    int loadFromString(string xmlData);
+    /**
+     * Load an XML document from a file.
+     * @param fileName The filename
+     * @return 0 on success, -1 on error
+     */
+    int loadFromFile(string fileName);
+    /**
+     * Emits the XML document as a string.
+     * Caller is responsible for freeing/deleting the string.
+     * @return The XML Document as a string.  If none was loaded, returns empty string.
+     */
+    string toString();
+    /**
+     * Emits the XML document to a file.
+     * @param fileName The filename
+     * @return 0 on success, -1 on error
+     */
+    int toFile(string fileName);
+    /**
+     * @internal
+     * Dump the XML document to stdout.
+     * Handy when debugging.
+     */
+    void dump();
+    /**
+     * Declare an ID attribute for nodes of a given name
+     * of why this may be necessary.
+     * @param attrName The attribute name
+     * @param nodeName The node name
+     * @param nsHref The namespace href (optional)
+     * @return 0 on success, -1 on error
+     */
+    int addIdAttr(string attrName, string nodeName, string nsHref);
+
+    /// @cond NO_INTERFACE
+    /**
+     * Copy an existing document object.
+     * @param doc XmlDoc class to be copied
+     */
+    XmlDoc(const XmlDoc& doc);
+    /**
+     * Assignment operator creates duplicate document.
+     * @param doc XmlDoc class to be copied
+     * @return Copied document
+     */
+    const XmlDoc& operator= (const XmlDoc& doc);
+    /**
+     * @return true if valid, false if no document
+     */
+    operator int ()
+    {
+        return doc != NULL;
+    }
+    /**
+     * @return false if valid, true if no document
+     */
+    int operator! ()
+    {
+        return doc == NULL;
+    }
+    /**
+     * Cast the document object to the xmlDocPtr.
+     * @return Pointer to the XML document structure
+     */
+    operator xmlDocPtr ()
+    {
+        return getDoc();
+    }
+    /**
+     *  List of ID attributes that have been added to the document.
+     *  Required by copy constructor, since these don't move with the
+     *  document normally.
+     */
+    vector<string> idAttrs;
+
+protected:
+    /**
+     * The internal representation of the XML document.
+     */
+    xmlDocPtr doc;
+
+    /**
+     * Free the internal representation of the XML document.
+     */
+    void freeDoc();
+
+    /**
+     * Add an ID attribute to a node
+     */
+    static int addIdAttrToNode(xmlNodePtr node, const xmlChar* attrName, const xmlChar* nodeName, const xmlChar* nsHref);
+/// @endcond
+};
+
+#include "countptr.h"
+typedef CountPtrTo<XmlDoc> XmlDocClassPtr;
+
+#endif

data/ext/xmlsig/XmlElement.cpp

@@ -0,0 +1,151 @@
+/*
+ * (C) Copyright 2006 VeriSign, Inc.
+ * Developed by Sxip Identity
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <iostream>
+#include <string>
+#include <vector>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+#include <xmlsec/xmltree.h>
+#include "XmlElement.h"
+#include "XmlCharBuf.h"
+using namespace std;
+
+
+XmlElement::XmlElement ()
+    : node (0)
+{}
+
+
+XmlElement::XmlElement (xmlNodePtr copyNode)
+    : node (0)
+{
+    assert(copyNode);
+    if (!copyNode)
+    {
+        THROW_NORET(MemoryError, "Bad pointer passed to XmlElement");
+    }
+    if (copyNode->type != XML_ELEMENT_NODE)
+    {
+        THROW_NORET(XMLError, "Not an element node");
+    }
+    // recursive copy of original node
+    node = xmlCopyNode(copyNode, 
+                       2); // 2=copy attr but no children
+    if (!node)
+    {
+        THROW_NORET(LibError, "Failed to copy node");
+    }
+}
+
+
+XmlElement::XmlElement (const XmlElement& xmlNode)
+    : node (0)
+{
+    this->operator=(xmlNode);
+}
+
+
+XmlElement::~XmlElement ()
+{
+    freeNode();
+}
+
+
+const XmlElement& XmlElement::operator= (const XmlElement& xmlNode)
+{
+    if (this != &xmlNode)
+    {
+        freeNode();
+        if (xmlNode.node)
+        {
+            // recursive copy of original node
+            node = xmlCopyNode(xmlNode.node, 
+                               2); // 2=copy attr but no children
+            if (!node)
+            {
+                THROW(LibError, "Failed to copy node", *this);
+            }
+        }
+    }
+    return *this;
+}
+
+
+void XmlElement::freeNode ()
+{
+    if (node)
+    {
+        xmlFreeNode(node);
+        node = NULL;
+    }
+}
+
+
+xmlNodePtr XmlElement::getNode ()
+{
+    return node;
+}
+
+
+string XmlElement::getTagName ()
+{
+    if (!*this)
+    {
+        THROW(XMLError, "Invalid element node", "");
+    }
+    if (!node->name)
+    {
+        return "";
+    }
+    return string((const char*)node->name);
+}
+
+
+string XmlElement::getAttribute (string name)
+{
+    if (!*this)
+    {
+        THROW(XMLError, "Invalid element node", "");
+    }
+    XmlCharBuf buf(xmlGetProp(node, BAD_CAST name.c_str()));
+    return string(buf);
+}
+
+
+string XmlElement::getAttribute (string name, string nameSpace)
+{
+    if (!*this)
+    {
+        THROW(XMLError, "Invalid element node", "");
+    }
+    XmlCharBuf buf(xmlGetNsProp(node, BAD_CAST name.c_str(), BAD_CAST nameSpace.c_str()));
+    return string(buf);
+}
+
+
+string XmlElement::getNodePath ()
+{
+    if (!*this)
+    {
+        THROW(XMLError, "Invalid element node", "");
+    }
+    XmlCharBuf buf(xmlGetNodePath(node));
+    return string(buf);
+}

data/ext/xmlsig/XmlElement.h

@@ -0,0 +1,134 @@
+/*
+ * (C) Copyright 2006 VeriSign, Inc.
+ * Developed by Sxip Identity
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef _XMLELEMENT_H
+#define _XMLELEMENT_H
+#include <string>
+#include <vector>
+#include <libxml/parser.h>
+#include "Exceptions.h"
+using namespace std;
+
+/**
+ * An XML element.
+ * Encapsulates a LibXML2 XML node object.  
+ */
+class XmlElement
+{
+public:
+    /**
+     * Construct an empty element object.
+     */
+    XmlElement ();
+    /**
+     * Copy an existing raw element.
+     */
+    XmlElement (xmlNodePtr copyNode);
+    /**
+     * Destroy element object.
+     * Frees element object if one was created.
+     */
+    ~XmlElement ();
+
+    /**
+     * Get the internal representation of the XML element.
+     * @return Pointer to the XML node structure
+     */
+    xmlNodePtr getNode ();
+    /**
+     * Get the name of the element.
+     * @return the name of the element node
+     * @throws XMLError if the node is invalid
+     */
+    string getTagName ();
+    /**
+     * Search and get the value of an attribute associated to a node. 
+     * This does the entity substitution.
+     * @param name the attribute name
+     * @return the attribute value or null if not found
+     * @throws XMLError if the node is invalid
+     */
+    string getAttribute (string name);
+    /**
+     * Search and get the value of an attribute associated to a node.
+     * This attribute has to be anchored in the namespace
+     * specified. This does the entity substitution.
+     * @param name the attribute name
+     * @param nameSpace the URI of the namespace
+     * @return the attribute value or null if not found
+     * @throws XMLError if the node is invalid
+     */
+    string getAttribute (string name, string nameSpace);
+    /**
+     * Build a structure based Path for the node.
+     * @return a path in string form
+     * @throws XMLError if the node is invalid
+     */
+    string getNodePath ();
+
+    /// @cond NO_INTERFACE
+    /**
+     * Copy an existing element object.
+     * @param element XmlElement class to be copied
+     */
+    XmlElement(const XmlElement& element);
+    /**
+     * Assignment operator creates duplicate element.
+     * @param element XmlElement class to be copied
+     * @return Copied element
+     */
+    const XmlElement& operator= (const XmlElement& element);
+    /**
+     * @return true if valid, false if no element
+     */
+    operator int ()
+    {
+        return (node != NULL) && (node->type == XML_ELEMENT_NODE);
+    }
+    /**
+     * @return false if valid, true if no element
+     */
+    int operator! ()
+    {
+        return (node == NULL) || (node->type != XML_ELEMENT_NODE);
+    }
+    /**
+     * Cast the element object to the xmlNodePtr.
+     * @return Pointer to the XML element structure
+     */
+    operator xmlNodePtr ()
+    {
+        return getNode();
+    }
+
+protected:
+    /**
+     * The internal representation of the XML node.
+     */
+    xmlNodePtr node;
+
+    /**
+     * Free the internal representation of the XML node.
+     */
+    void freeNode();
+
+/// @endcond
+};
+
+#include "countptr.h"
+typedef CountPtrTo<XmlElement> XmlElementPtr;
+
+#endif