Nokogiri_precompiled_aarch64_dedshit 1.14.5

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

@@ -0,0 +1,178 @@
+/**
+ * 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,43 @@
+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,106 @@
+/**
+ * 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,278 @@
+/**
+ * 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
+   */
+  @SuppressWarnings("deprecation")
+  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;
+  }
+
+}