Nokogiri_precompiled_aarch64_dedshit 1.14.5

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

@@ -0,0 +1,194 @@
+/**
+ * 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,77 @@
+/**
+ * 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,45 @@
+/**
+ * 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,325 @@
+/**
+ * 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);
+  }
+
+}