View Javadoc
1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements. See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership. The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License. You may obtain a copy of the License at
9    *
10   * http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied. See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.wss4j.policy;
20  
21  import javax.xml.namespace.QName;
22  import javax.xml.stream.XMLStreamException;
23  import javax.xml.stream.XMLStreamWriter;
24  
25  import org.w3c.dom.Attr;
26  import org.w3c.dom.Document;
27  import org.w3c.dom.Element;
28  import org.w3c.dom.NamedNodeMap;
29  import org.w3c.dom.Node;
30  import org.w3c.dom.Text;
31  
32  public final class SPUtils {
33  
34      private SPUtils() {
35      }
36  
37      public static boolean hasChildElements(Element element) {
38          Node firstChild = element.getFirstChild();
39          while (firstChild != null) {
40              if (firstChild.getNodeType() == Node.ELEMENT_NODE) {
41                  return true;
42              }
43              firstChild = firstChild.getNextSibling();
44          }
45          return false;
46      }
47  
48      public static Element getFirstPolicyChildElement(Element element) {
49          Element policy = getFirstChildElement(element, SPConstants.P_LOCALNAME);
50          if (policy != null && org.apache.neethi.Constants.isPolicyNS(policy.getNamespaceURI())) {
51              return policy;
52          }
53          return null;
54      }
55  
56      public static boolean hasChildElementWithName(Element element, QName elementName) {
57          Element child = SPUtils.getFirstChildElement(element, elementName);
58          return child != null;
59      }
60  
61      public static Element getFirstChildElement(Node parent, String childNodeName) {
62          Node node = parent.getFirstChild();
63          while (node != null && (Node.ELEMENT_NODE != node.getNodeType()
64                  || !node.getLocalName().equals(childNodeName))) {
65              node = node.getNextSibling();
66          }
67          return (Element) node;
68      }
69  
70      public static Element getFirstChildElement(Node parent, QName childNodeName) {
71          Node node = parent.getFirstChild();
72          while (node != null && (Node.ELEMENT_NODE != node.getNodeType()
73                  || !isNodeEqualToQName(node, childNodeName))) {
74              node = node.getNextSibling();
75          }
76          return (Element) node;
77      }
78  
79      private static boolean isNodeEqualToQName(Node node, QName nodeName) {
80          return (node.getNamespaceURI() == null && nodeName.getNamespaceURI() == null
81              || node.getNamespaceURI() != null
82                  && node.getNamespaceURI().equals(nodeName.getNamespaceURI()))
83              && node.getLocalName().equals(nodeName.getLocalPart());
84      }
85  
86      public static String getFirstChildElementText(Node parent, QName childNodeName) {
87          Element element = getFirstChildElement(parent, childNodeName);
88          return element != null ? element.getTextContent() : null;
89      }
90  
91      public static Element getFirstChildElement(Node parent) {
92          Node node = parent.getFirstChild();
93          while (node != null && Node.ELEMENT_NODE != node.getNodeType()) {
94              node = node.getNextSibling();
95          }
96          return (Element) node;
97      }
98  
99      public static Element getNextSiblingElement(Node node) {
100         Node n = node.getNextSibling();
101         while (n != null && Node.ELEMENT_NODE != n.getNodeType()) {
102             n = n.getNextSibling();
103         }
104         return (Element) n;
105     }
106 
107     public static boolean isOptional(Element element) {
108         Attr attr = findOptionalAttribute(element);
109         if (attr != null) {
110             String v = attr.getValue();
111             return "true".equalsIgnoreCase(v) || "1".equals(v);
112         }
113         return false;
114     }
115 
116     public static Attr findOptionalAttribute(Element element) {
117         NamedNodeMap attributes = element.getAttributes();
118         for (int x = 0; x < attributes.getLength(); x++) {
119             Attr attr = (Attr) attributes.item(x);
120             QName qName = new QName(attr.getNamespaceURI(), attr.getLocalName());
121             if (org.apache.neethi.Constants.isOptionalAttribute(qName)) {
122                 return attr;
123             }
124         }
125         return null;
126     }
127 
128     public static boolean isIgnorable(Element element) throws IllegalArgumentException {
129         Attr attr = findIgnorableAttribute(element);
130         if (attr != null) {
131             String value = attr.getValue();
132             if ("true".equalsIgnoreCase(value) || "1".equals(value)) {
133                 if (SP13Constants.SP_NS.equals(element.getNamespaceURI())) {
134                     throw new IllegalArgumentException("Ignorable attribute not allowed.");
135                 }
136                 return true;
137             }
138         }
139         return false;
140     }
141 
142     public static Attr findIgnorableAttribute(Element element) {
143         NamedNodeMap attributes = element.getAttributes();
144         for (int x = 0; x < attributes.getLength(); x++) {
145             Attr attr = (Attr) attributes.item(x);
146             QName qName = new QName(attr.getNamespaceURI(), attr.getLocalName());
147             if (org.apache.neethi.Constants.isIgnorableAttribute(qName)) {
148                 return attr;
149             }
150         }
151         return null;
152     }
153 
154     public static String getAttribute(Element element, QName attName) {
155         Attr attr;
156         if (attName.getNamespaceURI() == null || attName.getNamespaceURI().length() == 0) {
157             attr = element.getAttributeNode(attName.getLocalPart());
158         } else {
159             attr = element.getAttributeNodeNS(attName.getNamespaceURI(), attName.getLocalPart());
160         }
161         return attr == null ? null : attr.getValue().trim();
162     }
163 
164     public static QName getElementQName(Element element) {
165         return new QName(element.getNamespaceURI(), element.getLocalName(), element.getPrefix());
166     }
167 
168     public static void serialize(Node node, XMLStreamWriter xmlStreamWriter) throws XMLStreamException {
169         if (node.getNodeType() == Node.DOCUMENT_NODE) {
170             Document document = (Document) node;
171             serialize(document.getDocumentElement(), xmlStreamWriter);
172         }
173         if (node.getNodeType() == Node.ELEMENT_NODE) {
174             Element element = (Element) node;
175             xmlStreamWriter.writeStartElement(element.getPrefix(), element.getLocalName(), element.getNamespaceURI());
176             NamedNodeMap namedNodeMap = element.getAttributes();
177             for (int i = 0; i < namedNodeMap.getLength(); i++) {
178                 Attr attr = (Attr) namedNodeMap.item(i);
179                 String prefix = attr.getPrefix();
180                 if (prefix != null && "xmlns".equals(prefix)) {
181                     xmlStreamWriter.writeNamespace(attr.getLocalName(), attr.getValue());
182                 } else if (prefix == null && "xmlns".equals(attr.getLocalName())) {
183                     xmlStreamWriter.writeDefaultNamespace(attr.getValue());
184                 } else {
185                     xmlStreamWriter.writeAttribute(prefix,
186                                                    attr.getNamespaceURI(),
187                                                    attr.getLocalName(),
188                                                    attr.getValue());
189                 }
190             }
191             //write ns after processing element namespaces to prevent redeclarations
192             if (element.getPrefix() != null) {
193                 String ns = xmlStreamWriter.getNamespaceContext().getNamespaceURI(element.getPrefix());
194                 if (ns == null) {
195                     xmlStreamWriter.writeNamespace(element.getPrefix(), element.getNamespaceURI());
196                 }
197             }
198             Node firstChild = element.getFirstChild();
199             while (firstChild != null) {
200                 serialize(firstChild, xmlStreamWriter);
201                 firstChild = firstChild.getNextSibling();
202             }
203             xmlStreamWriter.writeEndElement();
204         } else if (node.getNodeType() == Node.TEXT_NODE) {
205             Text text = (Text) node;
206             xmlStreamWriter.writeCharacters(text.getData());
207         }
208     }
209 }