nokogiri-backport 1.11.0

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

@@ -0,0 +1,119 @@
+/**
+ * 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.Serializable;
+import java.util.Comparator;
+
+
+import org.w3c.dom.Attr;
+
+/**
+ * Compares two attributes based on the C14n specification.
+ *
+ * <UL>
+ * <LI>Namespace nodes have a lesser document order position than attribute 
+ *   nodes.
+ * <LI> An element's namespace nodes are sorted lexicographically by
+ *   local name (the default namespace node, if one exists, has no
+ *   local name and is therefore lexicographically least).
+ * <LI> An element's attribute nodes are sorted lexicographically with
+ *   namespace URI as the primary key and local name as the secondary
+ *   key (an empty namespace URI is lexicographically least).
+ * </UL>
+ *
+ * @author Christian Geuer-Pollmann
+ */
+public class AttrCompare implements Comparator<Attr>, Serializable {
+
+    private static final long serialVersionUID = -7113259629930576230L;
+    private static final int ATTR0_BEFORE_ATTR1 = -1;
+    private static final int ATTR1_BEFORE_ATTR0 = 1;
+    private static final String XMLNS = Constants.NamespaceSpecNS;
+
+    /**
+     * Compares two attributes based on the C14n specification.
+     *
+     * <UL>
+     * <LI>Namespace nodes have a lesser document order position than 
+     *   attribute nodes.
+     * <LI> An element's namespace nodes are sorted lexicographically by
+     *   local name (the default namespace node, if one exists, has no
+     *   local name and is therefore lexicographically least).
+     * <LI> An element's attribute nodes are sorted lexicographically with
+     *   namespace URI as the primary key and local name as the secondary
+     *   key (an empty namespace URI is lexicographically least).
+     * </UL>
+     *
+     * @param attr0
+     * @param attr1
+     * @return returns a negative integer, zero, or a positive integer as 
+     *   obj0 is less than, equal to, or greater than obj1
+     *
+     */
+    public int compare(Attr attr0, Attr attr1) {
+        String namespaceURI0 = attr0.getNamespaceURI();      
+        String namespaceURI1 = attr1.getNamespaceURI();
+      
+        boolean isNamespaceAttr0 = XMLNS.equals(namespaceURI0);
+        boolean isNamespaceAttr1 = XMLNS.equals(namespaceURI1);
+
+        if (isNamespaceAttr0) {
+            if (isNamespaceAttr1) {
+                // both are namespaces
+                String localname0 = attr0.getLocalName();
+                String localname1 = attr1.getLocalName();
+
+                if ("xmlns".equals(localname0)) {
+                    localname0 = "";
+                }
+
+                if ("xmlns".equals(localname1)) {
+                    localname1 = "";
+                }
+
+                return localname0.compareTo(localname1);
+            }
+            // attr0 is a namespace, attr1 is not
+            return ATTR0_BEFORE_ATTR1;
+        } else if (isNamespaceAttr1) {
+            // attr1 is a namespace, attr0 is not
+            return ATTR1_BEFORE_ATTR0;
+        } 
+
+        // none is a namespace
+        if (namespaceURI0 == null) {
+            if (namespaceURI1 == null) {
+                String name0 = attr0.getName();
+                String name1 = attr1.getName();
+                return name0.compareTo(name1);
+            }
+            return ATTR0_BEFORE_ATTR1;
+        } else if (namespaceURI1 == null) {
+            return ATTR1_BEFORE_ATTR0;
+        } 
+
+        int a = namespaceURI0.compareTo(namespaceURI1);
+        if (a != 0) {
+            return a;
+        }
+      
+        return (attr0.getLocalName()).compareTo(attr1.getLocalName());
+    }
+}

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

@@ -0,0 +1,159 @@
+/**
+ * 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 org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+
+/**
+ * Temporary swapped static functions from the normalizer Section
+ *
+ * @author Christian Geuer-Pollmann
+ */
+public class C14nHelper {
+
+    /**
+     * Constructor C14nHelper
+     *
+     */
+    private C14nHelper() {
+        // don't allow instantiation
+    }
+
+    /**
+     * Method namespaceIsRelative
+     *
+     * @param namespace
+     * @return true if the given namespace is relative. 
+     */
+    public static boolean namespaceIsRelative(Attr namespace) {
+        return !namespaceIsAbsolute(namespace);
+    }
+
+    /**
+     * Method namespaceIsRelative
+     *
+     * @param namespaceValue
+     * @return true if the given namespace is relative.
+     */
+    public static boolean namespaceIsRelative(String namespaceValue) {
+        return !namespaceIsAbsolute(namespaceValue);
+    }
+
+    /**
+     * Method namespaceIsAbsolute
+     *
+     * @param namespace
+     * @return true if the given namespace is absolute.
+     */
+    public static boolean namespaceIsAbsolute(Attr namespace) {
+        return namespaceIsAbsolute(namespace.getValue());
+    }
+
+    /**
+     * Method namespaceIsAbsolute
+     *
+     * @param namespaceValue
+     * @return true if the given namespace is absolute.
+     */
+    public static boolean namespaceIsAbsolute(String namespaceValue) {
+        // assume empty namespaces are absolute
+        if (namespaceValue.length() == 0) {
+            return true;
+        }
+        return namespaceValue.indexOf(':') > 0;
+    }
+
+    /**
+     * This method throws an exception if the Attribute value contains
+     * a relative URI.
+     *
+     * @param attr
+     * @throws CanonicalizationException
+     */
+    public static void assertNotRelativeNS(Attr attr) throws CanonicalizationException {
+        if (attr == null) {
+            return;
+        }
+
+        String nodeAttrName = attr.getNodeName();
+        boolean definesDefaultNS = nodeAttrName.equals("xmlns");
+        boolean definesNonDefaultNS = nodeAttrName.startsWith("xmlns:");
+
+        if ((definesDefaultNS || definesNonDefaultNS) && namespaceIsRelative(attr)) {
+            String parentName = attr.getOwnerElement().getTagName();
+            String attrValue = attr.getValue();
+            Object exArgs[] = { parentName, nodeAttrName, attrValue };
+
+            throw new CanonicalizationException(
+                "c14n.Canonicalizer.RelativeNamespace", exArgs
+            );
+        }
+    }
+
+    /**
+     * This method throws a CanonicalizationException if the supplied Document
+     * is not able to be traversed using a TreeWalker.
+     *
+     * @param document
+     * @throws CanonicalizationException
+     */
+    public static void checkTraversability(Document document)
+        throws CanonicalizationException {
+        if (!document.isSupported("Traversal", "2.0")) {
+            Object exArgs[] = {document.getImplementation().getClass().getName() };
+
+            throw new CanonicalizationException(
+                "c14n.Canonicalizer.TraversalNotSupported", exArgs
+            );
+        }
+    }
+
+    /**
+     * This method throws a CanonicalizationException if the supplied Element
+     * contains any relative namespaces.
+     *
+     * @param ctxNode
+     * @throws CanonicalizationException
+     * @see C14nHelper#assertNotRelativeNS(Attr)
+     */
+    public static void checkForRelativeNamespace(Element ctxNode)
+        throws CanonicalizationException {
+        if (ctxNode != null) {
+            NamedNodeMap attributes = ctxNode.getAttributes();
+
+            for (int i = 0; i < attributes.getLength(); i++) {
+                C14nHelper.assertNotRelativeNS((Attr) attributes.item(i));
+            }
+        } else {
+            throw new CanonicalizationException("Called checkForRelativeNamespace() on null");
+        }
+    }
+    
+    public static String getErrorMessage(String message, Object... exArgs) {
+        StringBuffer sb = new StringBuffer(message);
+        for (Object arg : exArgs) {
+            sb.append(", ").append(arg.toString());
+        }
+        return new String(sb);
+    }
+}

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

@@ -0,0 +1,37 @@
+package nokogiri.internals.c14n;
+
+import nokogiri.XmlNode;
+import nokogiri.internals.NokogiriHelpers;
+
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Node;
+
+public class CanonicalFilter {
+    private final Block block;
+    private final ThreadContext context;
+
+    public CanonicalFilter(ThreadContext context, Block block) {
+        this.context = context;
+        this.block = block;
+    }
+
+    public boolean includeNodes(Node currentNode, Node parentNode) {
+        if (block == null || !block.isGiven())
+            return true;
+
+        IRubyObject current = NokogiriHelpers.getCachedNodeOrCreate(context.getRuntime(), currentNode);
+        IRubyObject parent = NokogiriHelpers.getCachedNodeOrCreate(context.getRuntime(), parentNode);
+
+        if (parent.isNil()) {
+            IRubyObject doc = ((XmlNode) current).document(context);
+            boolean returnValue = block.call(context, current, doc).isTrue();
+            block.call(context, doc, context.nil);
+            return returnValue;
+        }
+
+        return block.call(context, current, parent).isTrue();
+    }
+
+}

data/ext/java/nokogiri/internals/c14n/CanonicalizationException.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;
+
+
+/**
+ * Class CanonicalizationException
+ *
+ * @author Christian Geuer-Pollmann
+ */
+public class CanonicalizationException extends Exception {
+
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Constructor CanonicalizationException
+     *
+     */
+    public CanonicalizationException() {
+        super();
+    }
+
+    /**
+     * Constructor CanonicalizationException
+     *
+     * @param message
+     */
+    public CanonicalizationException(String message) {
+        super(message);
+    }
+    
+    /**
+     * Constructor CanonicalizationException
+     *
+     * @param message
+     * @param rootCause
+     */
+    public CanonicalizationException(Exception rootCause) {
+        super(rootCause);
+    }
+
+    /**
+     * Constructor CanonicalizationException
+     *
+     * @param msgID
+     * @param exArgs
+     */
+    public CanonicalizationException(String message, Object... exArgs) {     
+        super(C14nHelper.getErrorMessage(message, exArgs));
+    }
+    
+    /**
+     * Constructor CanonicalizationException
+     *
+     * @param message
+     * @param rootCause
+     */
+    public CanonicalizationException(String message, Exception rootCause) {
+        super(message, rootCause);
+    }
+
+    /**
+     * Constructor CanonicalizationException
+     *
+     * @param msgID
+     * @param exArgs
+     * @param originalException
+     */
+    public CanonicalizationException(String message, Exception rootCause, Object... exArgs) {
+        super(C14nHelper.getErrorMessage(message, exArgs), rootCause);
+    }
+    
+    
+}

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

@@ -0,0 +1,252 @@
+/**
+ * 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 java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.w3c.dom.Node;
+
+/**
+ *
+ * @author Christian Geuer-Pollmann
+ */
+public class Canonicalizer {
+
+    /** The output encoding of canonicalized data */
+    public static final String ENCODING = "UTF8";
+
+    /**
+     * XPath Expression for selecting every node and continuous comments joined
+     * in only one node
+     */
+    public static final String XPATH_C14N_WITH_COMMENTS_SINGLE_NODE =
+        "(.//. | .//@* | .//namespace::*)";
+
+    /**
+     * The URL defined in XML-SEC Rec for inclusive c14n <b>without</b> comments.
+     */
+    public static final String ALGO_ID_C14N_OMIT_COMMENTS =
+        "http://www.w3.org/TR/2001/REC-xml-c14n-20010315";
+    /**
+     * The URL defined in XML-SEC Rec for inclusive c14n <b>with</b> comments.
+     */
+    public static final String ALGO_ID_C14N_WITH_COMMENTS =
+        ALGO_ID_C14N_OMIT_COMMENTS + "#WithComments";
+    /**
+     * The URL defined in XML-SEC Rec for exclusive c14n <b>without</b> comments.
+     */
+    public static final String ALGO_ID_C14N_EXCL_OMIT_COMMENTS =
+        "http://www.w3.org/2001/10/xml-exc-c14n#";
+    /**
+     * The URL defined in XML-SEC Rec for exclusive c14n <b>with</b> comments.
+     */
+    public static final String ALGO_ID_C14N_EXCL_WITH_COMMENTS =
+        ALGO_ID_C14N_EXCL_OMIT_COMMENTS + "WithComments";
+    /**
+     * The URI for inclusive c14n 1.1 <b>without</b> comments.
+     */
+    public static final String ALGO_ID_C14N11_OMIT_COMMENTS =
+        "http://www.w3.org/2006/12/xml-c14n11";
+    /**
+     * The URI for inclusive c14n 1.1 <b>with</b> comments.
+     */
+    public static final String ALGO_ID_C14N11_WITH_COMMENTS =
+        ALGO_ID_C14N11_OMIT_COMMENTS + "#WithComments";
+    /**
+     * Non-standard algorithm to serialize the physical representation for XML Encryption
+     */
+    public static final String ALGO_ID_C14N_PHYSICAL =
+        "http://santuario.apache.org/c14n/physical";
+
+    private static Map<String, Class<? extends CanonicalizerSpi>> canonicalizerHash = null;
+
+    private final CanonicalizerSpi canonicalizerSpi;
+
+    /**
+     * Constructor Canonicalizer
+     *
+     * @param algorithmURI
+     * @throws InvalidCanonicalizerException
+     */
+    private Canonicalizer(String algorithmURI) throws CanonicalizationException {
+        try {
+            Class<? extends CanonicalizerSpi> implementingClass =
+                canonicalizerHash.get(algorithmURI);
+
+            canonicalizerSpi = implementingClass.newInstance();
+            canonicalizerSpi.reset = true;
+        } catch (Exception e) {
+            Object exArgs[] = { algorithmURI };
+            throw new CanonicalizationException(
+                "signature.Canonicalizer.UnknownCanonicalizer", exArgs, e
+            );
+        }
+    }
+
+    /**
+     * Method getInstance
+     *
+     * @param algorithmURI
+     * @return a Canonicalizer instance ready for the job
+     * @throws InvalidCanonicalizerException
+     */
+    public static final Canonicalizer getInstance(String algorithmURI)
+        throws CanonicalizationException {
+        if (canonicalizerHash == null) {
+            canonicalizerHash = new ConcurrentHashMap<String, Class<? extends CanonicalizerSpi>>();
+            Canonicalizer.registerDefaultAlgorithms();
+        }
+        return new Canonicalizer(algorithmURI);
+    }
+
+    /**
+     * Method register
+     *
+     * @param algorithmURI
+     * @param implementingClass
+     * @throws CanonicalizationException
+     */
+    @SuppressWarnings("unchecked")
+    public static void register(String algorithmURI, String implementingClass)
+        throws CanonicalizationException, ClassNotFoundException {
+        // check whether URI is already registered
+        Class<? extends CanonicalizerSpi> registeredClass =
+            canonicalizerHash.get(algorithmURI);
+
+        if (registeredClass != null)  {
+            Object exArgs[] = { algorithmURI, registeredClass };
+            throw new CanonicalizationException("algorithm.alreadyRegistered", exArgs);
+        }
+
+        canonicalizerHash.put(
+            algorithmURI, (Class<? extends CanonicalizerSpi>)Class.forName(implementingClass)
+        );
+    }
+
+    /**
+     * Method register
+     *
+     * @param algorithmURI
+     * @param implementingClass
+     * @throws CanonicalizationException
+     */
+    public static void register(String algorithmURI, Class<? extends CanonicalizerSpi> implementingClass)
+        throws CanonicalizationException {
+        // check whether URI is already registered
+        Class<? extends CanonicalizerSpi> registeredClass = canonicalizerHash.get(algorithmURI);
+
+        if (registeredClass != null)  {
+            Object exArgs[] = { algorithmURI, registeredClass };
+            throw new CanonicalizationException("algorithm.alreadyRegistered", exArgs);
+        }
+
+        canonicalizerHash.put(algorithmURI, implementingClass);
+    }
+
+    /**
+     * This method registers the default algorithms.
+     */
+    private static void registerDefaultAlgorithms() {
+        canonicalizerHash.put(Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS,
+                Canonicalizer20010315OmitComments.class);
+        canonicalizerHash.put(Canonicalizer.ALGO_ID_C14N_WITH_COMMENTS,
+                Canonicalizer20010315WithComments.class);
+        canonicalizerHash.put(Canonicalizer.ALGO_ID_C14N_EXCL_OMIT_COMMENTS,
+                Canonicalizer20010315ExclOmitComments.class);
+        canonicalizerHash.put(Canonicalizer.ALGO_ID_C14N_EXCL_WITH_COMMENTS,
+                Canonicalizer20010315ExclWithComments.class);
+        canonicalizerHash.put(Canonicalizer.ALGO_ID_C14N11_OMIT_COMMENTS,
+                Canonicalizer11_OmitComments.class);
+        canonicalizerHash.put(Canonicalizer.ALGO_ID_C14N11_WITH_COMMENTS,
+                Canonicalizer11_WithComments.class);
+        canonicalizerHash.put(Canonicalizer.ALGO_ID_C14N_PHYSICAL,
+                CanonicalizerPhysical.class);
+    }
+
+    /**
+     * Method getURI
+     *
+     * @return the URI defined for this c14n instance.
+     */
+    public final String getURI() {
+        return canonicalizerSpi.engineGetURI();
+    }
+
+    /**
+     * Method getIncludeComments
+     *
+     * @return true if the c14n respect the comments.
+     */
+    public boolean getIncludeComments() {
+        return canonicalizerSpi.engineGetIncludeComments();
+    }
+
+    /**
+     * Canonicalizes the subtree rooted by <CODE>node</CODE>.
+     *
+     * @param node The node to canonicalize
+     * @return the result of the c14n.
+     *
+     * @throws CanonicalizationException
+     */
+    public byte[] canonicalizeSubtree(Node node, CanonicalFilter filter) throws CanonicalizationException {
+        return canonicalizerSpi.engineCanonicalizeSubTree(node, filter);
+    }
+
+    /**
+     * Canonicalizes the subtree rooted by <CODE>node</CODE>.
+     *
+     * @param node
+     * @param inclusiveNamespaces
+     * @return the result of the c14n.
+     * @throws CanonicalizationException
+     */
+    public byte[] canonicalizeSubtree(Node node, String inclusiveNamespaces, CanonicalFilter filter)
+        throws CanonicalizationException {
+        return canonicalizerSpi.engineCanonicalizeSubTree(node, inclusiveNamespaces, filter);
+    }
+
+    /**
+     * Sets the writer where the canonicalization ends.  ByteArrayOutputStream
+     * if none is set.
+     * @param os
+     */
+    public void setWriter(OutputStream os) {
+        canonicalizerSpi.setWriter(os);
+    }
+
+    /**
+     * Returns the name of the implementing {@link CanonicalizerSpi} class
+     *
+     * @return the name of the implementing {@link CanonicalizerSpi} class
+     */
+    public String getImplementingCanonicalizerClass() {
+        return canonicalizerSpi.getClass().getName();
+    }
+
+    /**
+     * Set the canonicalizer behaviour to not reset.
+     */
+    public void notReset() {
+        canonicalizerSpi.reset = false;
+    }
+
+}