nokogiri-backport 1.11.0

data/ext/java/nokogiri/internals/c14n/CanonicalizerPhysical.java

@@ -0,0 +1,173 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+package nokogiri.internals.c14n;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Comment;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.ProcessingInstruction;
+
+/**
+ * Serializes the physical representation of the subtree. All the attributes
+ * present in the subtree are emitted. The attributes are sorted within an element,
+ * with the namespace declarations appearing before the regular attributes.
+ * This algorithm is not a true canonicalization since equivalent subtrees
+ * may produce different output. It is therefore unsuitable for digital signatures.
+ * This same property makes it ideal for XML Encryption Syntax and Processing,
+ * because the decrypted XML content will share the same physical representation
+ * as the original XML content that was encrypted.
+ */
+public class CanonicalizerPhysical extends CanonicalizerBase {
+
+    private final SortedSet<Attr> result = new TreeSet<Attr>(COMPARE);
+
+    /**
+     * Constructor Canonicalizer20010315
+     */
+    public CanonicalizerPhysical() {
+        super(true);
+    }
+
+    /**
+     * Always throws a CanonicalizationException.
+     *
+     * @param xpathNodeSet
+     * @param inclusiveNamespaces
+     * @return none it always fails
+     * @throws CanonicalizationException always
+     */
+    public byte[] engineCanonicalizeXPathNodeSet(Set<Node> xpathNodeSet, String inclusiveNamespaces, CanonicalFilter filter)
+        throws CanonicalizationException {
+
+        /** $todo$ well, should we throw UnsupportedOperationException ? */
+        throw new CanonicalizationException("c14n.Canonicalizer.UnsupportedOperation");
+    }
+
+    /**
+     * Always throws a CanonicalizationException.
+     *
+     * @param rootNode
+     * @param inclusiveNamespaces
+     * @return none it always fails
+     * @throws CanonicalizationException
+     */
+    @Override
+    public byte[] engineCanonicalizeSubTree(Node rootNode, String inclusiveNamespaces, CanonicalFilter filter)
+        throws CanonicalizationException {
+
+        /** $todo$ well, should we throw UnsupportedOperationException ? */
+        throw new CanonicalizationException("c14n.Canonicalizer.UnsupportedOperation");
+    }
+
+    /**
+     * Returns the Attr[]s to be output for the given element.
+     * <br>
+     * The code of this method is a copy of {@link #handleAttributes(Element,
+     * NameSpaceSymbTable)},
+     * whereas it takes into account that subtree-c14n is -- well -- subtree-based.
+     * So if the element in question isRoot of c14n, it's parent is not in the
+     * node set, as well as all other ancestors.
+     *
+     * @param element
+     * @param ns
+     * @return the Attr[]s to be output
+     * @throws CanonicalizationException
+     */
+    @Override
+    protected Iterator<Attr> handleAttributesSubtree(Element element, NameSpaceSymbTable ns)
+        throws CanonicalizationException {
+        if (!element.hasAttributes()) {
+            return null;
+        }
+
+        // result will contain all the attrs declared directly on that element
+        final SortedSet<Attr> result = this.result;
+        result.clear();
+
+        if (element.hasAttributes()) {
+            NamedNodeMap attrs = element.getAttributes();
+            int attrsLength = attrs.getLength();
+
+            for (int i = 0; i < attrsLength; i++) {
+                Attr attribute = (Attr) attrs.item(i);
+                result.add(attribute);
+            }
+        }
+
+        return result.iterator();
+    }
+
+    /**
+     * Returns the Attr[]s to be output for the given element.
+     *
+     * @param element
+     * @param ns
+     * @return the Attr[]s to be output
+     * @throws CanonicalizationException
+     */
+    @Override
+    protected Iterator<Attr> handleAttributes(Element element, NameSpaceSymbTable ns)
+        throws CanonicalizationException {
+
+        /** $todo$ well, should we throw UnsupportedOperationException ? */
+        throw new CanonicalizationException("c14n.Canonicalizer.UnsupportedOperation");
+    }
+
+    @Override
+    protected void handleParent(Element e, NameSpaceSymbTable ns) {
+        // nothing to do
+    }
+
+    /** @inheritDoc */
+    @Override
+    public final String engineGetURI() {
+        return Canonicalizer.ALGO_ID_C14N_PHYSICAL;
+    }
+
+    /** @inheritDoc */
+    @Override
+    public final boolean engineGetIncludeComments() {
+        return true;
+    }
+
+    @Override
+    protected void outputPItoWriter(ProcessingInstruction currentPI,
+                                    OutputStream writer, int position) throws IOException {
+        // Processing Instructions before or after the document element are not treated specially
+        super.outputPItoWriter(currentPI, writer, NODE_NOT_BEFORE_OR_AFTER_DOCUMENT_ELEMENT);
+    }
+
+    @Override
+    protected void outputCommentToWriter(Comment currentComment,
+                                         OutputStream writer, int position) throws IOException {
+        // Comments before or after the document element are not treated specially
+        super.outputCommentToWriter(currentComment, writer, NODE_NOT_BEFORE_OR_AFTER_DOCUMENT_ELEMENT);
+    }
+
+}

data/ext/java/nokogiri/internals/c14n/CanonicalizerSpi.java

@@ -0,0 +1,76 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+package nokogiri.internals.c14n;
+
+import java.io.OutputStream;
+
+
+import org.w3c.dom.Node;
+
+/**
+ * Base class which all Canonicalization algorithms extend.
+ *
+ * @author Christian Geuer-Pollmann
+ */
+public abstract class CanonicalizerSpi {
+
+    /** Reset the writer after a c14n */
+    protected boolean reset = false;
+
+    /**
+     * Returns the URI of this engine.
+     * @return the URI
+     */
+    public abstract String engineGetURI();
+
+    /**
+     * Returns true if comments are included
+     * @return true if comments are included
+     */
+    public abstract boolean engineGetIncludeComments();
+
+    /**
+     * C14n a node tree.
+     *
+     * @param rootNode
+     * @return the c14n bytes
+     * @throws CanonicalizationException
+     */
+    public abstract byte[] engineCanonicalizeSubTree(Node rootNode, CanonicalFilter filter)
+        throws CanonicalizationException;
+
+    /**
+     * C14n a node tree.
+     *
+     * @param rootNode
+     * @param inclusiveNamespaces
+     * @return the c14n bytes
+     * @throws CanonicalizationException
+     */
+    public abstract byte[] engineCanonicalizeSubTree(Node rootNode, String inclusiveNamespaces, CanonicalFilter filter)
+        throws CanonicalizationException;
+
+    /**
+     * Sets the writer where the canonicalization ends. ByteArrayOutputStream if
+     * none is set.
+     * @param os
+     */
+    public abstract void setWriter(OutputStream os);
+
+}

data/ext/java/nokogiri/internals/c14n/Constants.java

@@ -0,0 +1,42 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+package nokogiri.internals.c14n;
+
+/**
+ * Provides all constants and some translation functions for i18n.
+ *
+ * For the used Algorithm identifiers and Namespaces, look at the
+ * <A HREF="http://www.w3.org/TR/xmldsig-core/#sec-TransformAlg">XML
+ * Signature specification</A>.
+ *
+ * @author $Author: coheigea $
+ */
+public class Constants {
+    
+    /** The URI for XML spec*/
+    public static final String XML_LANG_SPACE_SpecNS = "http://www.w3.org/XML/1998/namespace";
+    
+    /** The URI for XMLNS spec*/
+    public static final String NamespaceSpecNS = "http://www.w3.org/2000/xmlns/";
+
+    private Constants() {
+        // we don't allow instantiation
+    }
+
+}

data/ext/java/nokogiri/internals/c14n/ElementProxy.java

@@ -0,0 +1,293 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+package nokogiri.internals.c14n;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Text;
+
+/**
+ * This is the base class to all Objects which have a direct 1:1 mapping to an
+ * Element in a particular namespace.
+ */
+public abstract class ElementProxy {
+
+    /** Field constructionElement */
+    protected Element constructionElement = null;
+
+    /** Field baseURI */
+    protected String baseURI = null;
+
+    /** Field doc */
+    protected Document doc = null;
+    
+    /** Field prefixMappings */
+    private static Map<String, String> prefixMappings = new ConcurrentHashMap<String, String>();
+
+    /**
+     * Constructor ElementProxy
+     *
+     */
+    public ElementProxy() {	   
+    }
+
+    /**
+     * Constructor ElementProxy
+     *
+     * @param doc
+     */
+    public ElementProxy(Document doc) {
+        if (doc == null) {
+            throw new RuntimeException("Document is null");
+        }
+
+        this.doc = doc;
+        this.constructionElement = 
+            createElementForFamilyLocal(this.doc, this.getBaseNamespace(), this.getBaseLocalName());      
+    }
+    
+    /**
+     * Constructor ElementProxy
+     *
+     * @param element
+     * @param BaseURI
+     * @throws XMLSecurityException
+     */
+    public ElementProxy(Element element, String BaseURI) throws CanonicalizationException {
+        if (element == null) {
+            throw new CanonicalizationException("ElementProxy.nullElement");
+        }
+
+        //if (System.getProperty("nokogiri.c14.debug") == "on") {
+        //    System.out.println("setElement(\"" + element.getTagName() + "\", \"" + BaseURI + "\")");
+        //}
+
+        this.doc = element.getOwnerDocument();
+        this.constructionElement = element;
+        this.baseURI = BaseURI;
+
+        this.guaranteeThatElementInCorrectSpace();
+    }
+    
+    /**
+     * Returns the namespace of the Elements of the sub-class.
+     *
+     * @return the namespace of the Elements of the sub-class.
+     */
+    public abstract String getBaseNamespace();
+
+    /**
+     * Returns the localname of the Elements of the sub-class.
+     *
+     * @return the localname of the Elements of the sub-class.
+     */
+    public abstract String getBaseLocalName();
+    
+    
+    protected Element createElementForFamilyLocal(
+        Document doc, String namespace, String localName
+    ) {	   	  
+        Element result;
+        if (namespace == null) {
+            result = doc.createElementNS(null, localName);
+        } else {
+            String baseName = this.getBaseNamespace();
+            String prefix = ElementProxy.getDefaultPrefix(baseName);
+            if ((prefix == null) || (prefix.length() == 0)) {
+                result = doc.createElementNS(namespace, localName);
+                result.setAttributeNS(Constants.NamespaceSpecNS, "xmlns", namespace);
+            } else {
+                result = doc.createElementNS(namespace, prefix + ":" + localName);
+                result.setAttributeNS(Constants.NamespaceSpecNS, "xmlns:" + prefix, namespace);
+            }
+        }	      
+        return result;
+    }
+
+
+    /**
+     * This method creates an Element in a given namespace with a given localname.
+     * It uses the {@link ElementProxy#getDefaultPrefix} method to decide whether
+     * a particular prefix is bound to that namespace.
+     * <BR />
+     * This method was refactored out of the constructor.
+     *
+     * @param doc
+     * @param namespace
+     * @param localName
+     * @return The element created.
+     */
+    public static Element createElementForFamily(Document doc, String namespace, String localName) {
+        Element result;
+        String prefix = ElementProxy.getDefaultPrefix(namespace);
+
+        if (namespace == null) {
+            result = doc.createElementNS(null, localName);
+        } else {
+            if ((prefix == null) || (prefix.length() == 0)) {
+                result = doc.createElementNS(namespace, localName);
+                result.setAttributeNS(Constants.NamespaceSpecNS, "xmlns", namespace);
+            } else {
+                result = doc.createElementNS(namespace, prefix + ":" + localName);
+                result.setAttributeNS(Constants.NamespaceSpecNS, "xmlns:" + prefix, namespace);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Returns the Element which was constructed by the Object.
+     *
+     * @return the Element which was constructed by the Object.
+     */
+    public final Element getElement() {
+        return this.constructionElement;
+    }
+
+    /**
+     * Returns the Element plus a leading and a trailing CarriageReturn Text node.
+     *
+     * @return the Element which was constructed by the Object.
+     */
+    public final NodeList getElementPlusReturns() {
+
+        HelperNodeList nl = new HelperNodeList();
+
+        nl.appendChild(this.doc.createTextNode("\n"));
+        nl.appendChild(this.getElement());
+        nl.appendChild(this.doc.createTextNode("\n"));
+
+        return nl;
+    }
+
+    /**
+     * Method getDocument
+     *
+     * @return the Document where this element is contained.
+     */
+    public Document getDocument() {
+        return this.doc;
+    }
+
+    /**
+     * Method getBaseURI
+     *
+     * @return the base uri of the namespace of this element
+     */
+    public String getBaseURI() {
+        return this.baseURI;
+    }
+
+    /**
+     * Method guaranteeThatElementInCorrectSpace
+     *
+     * @throws XMLSecurityException
+     */
+    void guaranteeThatElementInCorrectSpace() throws CanonicalizationException {
+
+        String expectedLocalName = this.getBaseLocalName();
+        String expectedNamespaceUri = this.getBaseNamespace();
+
+        String actualLocalName = this.constructionElement.getLocalName();
+        String actualNamespaceUri = this.constructionElement.getNamespaceURI();
+
+        if(!expectedNamespaceUri.equals(actualNamespaceUri) 
+            && !expectedLocalName.equals(actualLocalName)) {      
+            Object exArgs[] = { actualNamespaceUri + ":" + actualLocalName, 
+                                expectedNamespaceUri + ":" + expectedLocalName};
+            throw new CanonicalizationException("xml.WrongElement", exArgs);
+        }
+    }
+
+    /**
+     * Method addText
+     *
+     * @param text
+     */
+    public void addText(String text) {
+        if (text != null) {
+            Text t = this.doc.createTextNode(text);
+
+            this.constructionElement.appendChild(t);
+        }
+    }
+
+    /**
+     * Method getTextFromChildElement
+     *
+     * @param localname
+     * @param namespace
+     * @return the Text of the textNode
+     */
+    public String getTextFromChildElement(String localname, String namespace) {
+        return XMLUtils.selectNode(
+                this.constructionElement.getFirstChild(),
+                namespace,
+                localname,
+                0).getTextContent();
+    }
+
+    /**
+     * Method getTextFromTextChild
+     *
+     * @return the Text obtained by concatenating all the text nodes of this 
+     *    element
+     */
+    public String getTextFromTextChild() {
+        return XMLUtils.getFullTextChildrenFromElement(this.constructionElement);
+    }
+
+    /**
+     * Method length
+     *
+     * @param namespace
+     * @param localname
+     * @return the number of elements {namespace}:localname under this element
+     */
+    public int length(String namespace, String localname) {
+        int number = 0;
+        Node sibling = this.constructionElement.getFirstChild();
+        while (sibling != null) {        
+            if (localname.equals(sibling.getLocalName())
+                && namespace.equals(sibling.getNamespaceURI())) {
+                number++;
+            }
+            sibling = sibling.getNextSibling();
+        }
+        return number;
+    }
+
+    /**
+     * Method getDefaultPrefix
+     *
+     * @param namespace
+     * @return the default prefix bind to this element.
+     */
+    public static String getDefaultPrefix(String namespace) {
+        return prefixMappings.get(namespace);
+    }
+
+}

data/ext/java/nokogiri/internals/c14n/HelperNodeList.java

@@ -0,0 +1,93 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+package nokogiri.internals.c14n;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * @author Christian Geuer-Pollmann
+ */
+public class HelperNodeList implements NodeList {
+
+    /** Field nodes */
+    List<Node> nodes = new ArrayList<Node>();
+    boolean allNodesMustHaveSameParent = false;
+
+    /**
+     * 
+     */
+    public HelperNodeList() {
+        this(false);
+    }
+
+
+    /**
+     * @param allNodesMustHaveSameParent
+     */
+    public HelperNodeList(boolean allNodesMustHaveSameParent) {
+        this.allNodesMustHaveSameParent = allNodesMustHaveSameParent;
+    }
+
+    /**
+     * Method item
+     *
+     * @param index
+     * @return node with index i
+     */
+    public Node item(int index) {
+        return nodes.get(index);
+    }
+
+    /**
+     * Method getLength
+     *
+     *  @return length of the list
+     */
+    public int getLength() {
+        return nodes.size();
+    }
+
+    /**
+     * Method appendChild
+     *
+     * @param node
+     * @throws IllegalArgumentException
+     */
+    public void appendChild(Node node) throws IllegalArgumentException {
+        if (this.allNodesMustHaveSameParent && this.getLength() > 0
+            && this.item(0).getParentNode() != node.getParentNode()) {
+            throw new IllegalArgumentException("Nodes have not the same Parent");
+        }
+        nodes.add(node);
+    }
+
+    /**
+     * @return the document that contains this nodelist
+     */
+    public Document getOwnerDocument() {
+        if (this.getLength() == 0) {
+            return null;
+        }
+        return XMLUtils.getOwnerDocument(this.item(0));
+    }
+}