1 /*

     2  * Copyright (c) 2006, 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 package jnlp.converter.parser;

    25 

    26 import java.net.URL;

    27 import java.net.MalformedURLException;

    28 

    29 import jnlp.converter.parser.exception.BadFieldException;

    30 import jnlp.converter.parser.exception.MissingFieldException;

    31 import jnlp.converter.parser.xml.XMLNode;

    32 

    33 /** Contains handy methods for looking up information

    34  *  stored in XMLNodes.

    35  */

    36 public class XMLUtils {

    37 

    38     /** Returns the value of an integer attribute */

    39     public static int getIntAttribute(String source, XMLNode root, String path, String name, int defaultvalue)

    40             throws BadFieldException {

    41         String value = getAttribute(root, path, name);

    42         if (value == null) {

    43             return defaultvalue;

    44         }

    45 

    46         try {

    47             return Integer.parseInt(value);

    48         } catch (NumberFormatException nfe) {

    49             throw new BadFieldException(source, getPathString(root) + path + name, value);

    50         }

    51     }

    52 

    53     /** Returns the value of a given attribute, or null if not set */

    54     public static String getAttribute(XMLNode root, String path, String name)

    55                                                       throws BadFieldException {

    56         return getAttribute(root, path, name, null);

    57     }

    58 

    59     /** Returns the value of a given attribute */

    60     public static String getRequiredAttributeEmptyOK(String source,

    61         XMLNode root, String path, String name) throws MissingFieldException {

    62         String value = null;

    63         XMLNode elem = findElementPath(root, path);

    64         if (elem != null) {

    65             value = elem.getAttribute(name);

    66         }

    67         if (value == null) {

    68             throw new MissingFieldException(source,

    69                                             getPathString(root)+ path + name);

    70         }

    71         return value;

    72     }

    73 

    74     /*** Returns the value of an attribute, which must be a valid class name */

    75     public static String getClassName(String source, XMLNode root,

    76         String path, String name, boolean required)

    77             throws BadFieldException, MissingFieldException {

    78 

    79         String className;

    80         if (required) {

    81             className = getRequiredAttribute(source, root, path, name);

    82         } else {

    83             className = getAttribute(root, path, name);

    84         }

    85         if (className != null && className.endsWith(".class")) {

    86             int i = className.lastIndexOf(".class");

    87             String cname = className.substring(0, i);

    88             return cname;

    89         }

    90         return className;

    91     }

    92 

    93     /** Returns the value of a given attribute, or null if not set */

    94     public static String getRequiredAttribute(String source, XMLNode root,

    95             String path, String name) throws MissingFieldException, BadFieldException {

    96         String s = getAttribute(root, path, name, null);

    97         if (s == null) {

    98             throw new MissingFieldException(source, getPathString(root) + path + name);

    99         }

   100         s = s.trim();

   101         return (s.length() == 0) ? null : s;

   102     }

   103 

   104     /** Returns the value of a given attribute, or the default value 'def' if not set */

   105     public static String getAttribute(XMLNode root, String path, String name,

   106             String def) throws BadFieldException {

   107         XMLNode elem = findElementPath(root, path);

   108         if (elem == null) {

   109             return def;

   110         }

   111         String value = elem.getAttribute(name);

   112         return (value == null || value.length() == 0) ? def : value;

   113     }

   114 

   115     /** Expands a URL into an absolute URL from a relative URL */

   116     public static URL getAttributeURL(String source, URL base, XMLNode root, String path, String name) throws BadFieldException {

   117         String value = getAttribute(root, path, name);

   118         if (value == null) return null;

   119         try {

   120             if (value.startsWith("jar:")) {

   121                 int bang = value.indexOf("!/");

   122                 if (bang > 0) {

   123                     String entry = value.substring(bang);

   124                     String urlString = value.substring(4, bang);

   125                     URL url = (base == null) ?

   126                         new URL(urlString) : new URL(base, urlString);

   127                     return new URL("jar:" + url.toString() + entry);

   128                 }

   129             }

   130             return (base == null) ? new URL(value) : new URL(base, value);

   131         } catch(MalformedURLException mue) {

   132             if (mue.getMessage().contains("https")) {

   133                 throw new BadFieldException(source, "<jnlp>", "https");

   134             }

   135             throw new BadFieldException(source, getPathString(root) + path + name, value);

   136         }

   137     }

   138 

   139     /** Returns the value of an attribute as a URL or null if not set */

   140     public static URL getAttributeURL(String source, XMLNode root, String path, String name) throws BadFieldException {

   141         return getAttributeURL(source, null, root, path, name);

   142     }

   143 

   144     public static URL getRequiredURL(String source, URL base, XMLNode root, String path, String name) throws BadFieldException, MissingFieldException {

   145         URL url = getAttributeURL(source, base, root, path, name);

   146         if (url == null) {

   147             throw new MissingFieldException(source, getPathString(root) + path + name);

   148         }

   149         return url;

   150     }

   151 

   152     /** Returns the value of an attribute as a URL. Throws a MissingFieldException if the

   153      *  attribute is not defined

   154      */

   155     public static URL getRequiredURL(String source, XMLNode root, String path, String name) throws BadFieldException, MissingFieldException {

   156         return getRequiredURL(source, null, root, path, name);

   157     }

   158 

   159     /** Returns true if the path exists in the document, otherwise false */

   160     public static boolean isElementPath(XMLNode root, String path) {

   161         return findElementPath(root, path) != null;

   162     }

   163 

   164     public static URL getElementURL(String source, XMLNode root, String path) throws BadFieldException {

   165         String value = getElementContents(root, path);

   166         try {

   167             return new URL(value);

   168         } catch(MalformedURLException mue) {

   169             throw new BadFieldException(source, getPathString(root) + path, value);

   170         }

   171     }

   172 

   173     /** Returns a string describing the current location in the DOM */

   174     public static String getPathString(XMLNode e) {

   175         return (e == null || !(e.isElement())) ? "" : getPathString(e.getParent()) + "<" + e.getName() + ">";

   176     }

   177 

   178     /** Returns the contents of an element with the given path and an attribute matching a specific value. Returns

   179      *  NULL if not found

   180      */

   181     public static String getElementContentsWithAttribute(XMLNode root, String path, String attr, String val, String defaultvalue)

   182             throws BadFieldException, MissingFieldException {

   183         XMLNode e = getElementWithAttribute(root, path, attr, val);

   184         if (e == null) {

   185             return defaultvalue;

   186         }

   187         return getElementContents(e, "", defaultvalue);

   188     }

   189 

   190     public static URL getAttributeURLWithAttribute(String source, XMLNode root, String path, String attrcond, String val,

   191             String name, URL defaultvalue)

   192             throws BadFieldException, MissingFieldException {

   193         XMLNode e = getElementWithAttribute(root, path, attrcond, val);

   194         if (e == null) {

   195             return defaultvalue;

   196         }

   197         URL url = getAttributeURL(source, e, "", name);

   198         if (url == null) {

   199             return defaultvalue;

   200         }

   201         return url;

   202     }

   203 

   204     /** Returns an element with the given path and an attribute matching a specific value. Returns

   205      *  NULL if not found

   206      */

   207     public static XMLNode getElementWithAttribute(XMLNode root, String path, final String attr, final String val)

   208             throws BadFieldException, MissingFieldException {

   209         final XMLNode[] result = {null};

   210         visitElements(root, path, new ElementVisitor() {

   211             public void visitElement(XMLNode e) throws BadFieldException, MissingFieldException {

   212                 if (result[0] == null && e.getAttribute(attr).equals(val)) {

   213                     result[0] = e;

   214                 }

   215             }

   216         });

   217         return result[0];

   218     }

   219 

   220     /** Like getElementContents(...) but with a defaultValue of null */

   221     public static String getElementContents(XMLNode root, String path) {

   222         return getElementContents(root, path, null);

   223     }

   224 

   225     /** Returns the value of the last element tag in the path, e.g.,  <..><tag>value</tag>. The DOM is assumes

   226      *  to be normalized. If no value is found, the defaultvalue is returned

   227      */

   228     public static String getElementContents(XMLNode root, String path, String defaultvalue) {

   229         XMLNode e = findElementPath(root, path);

   230         if (e == null) {

   231             return defaultvalue;

   232         }

   233         XMLNode n = e.getNested();

   234         if (n != null && !n.isElement()) {

   235             return n.getName();

   236         }

   237         return defaultvalue;

   238     }

   239 

   240     /** Parses a path string of the form <tag1><tag2><tag3> and returns the specific Element

   241      *  node for that tag, or null if it does not exist. If multiple elements exists with same

   242      *  path the first is returned

   243      */

   244     public static XMLNode findElementPath(XMLNode elem, String path) {

   245         // End condition. Root null -> path does not exist

   246         if (elem == null) {

   247             return null;

   248         }

   249 

   250         // End condition. String empty, return current root

   251         if (path == null || path.length() == 0) {

   252             return elem;

   253         }

   254 

   255         // Strip of first tag

   256         int idx = path.indexOf('>');

   257         if (!(path.charAt(0) == '<')) {

   258             throw new IllegalArgumentException("bad path. Missing begin tag");

   259         }

   260         if (idx == -1) {

   261             throw new IllegalArgumentException("bad path. Missing end tag");

   262         }

   263         String head = path.substring(1, idx);

   264         String tail = path.substring(idx + 1);

   265         return findElementPath(findChildElement(elem, head), tail);

   266     }

   267 

   268     /** Returns an child element with the current tag name or null. */

   269     public static XMLNode findChildElement(XMLNode elem, String tag) {

   270         XMLNode n = elem.getNested();

   271         while (n != null) {

   272             if (n.isElement() && n.getName().equals(tag)) {

   273                 return n;

   274             }

   275             n = n.getNext();

   276         }

   277         return null;

   278     }

   279 

   280     /** Iterator class */

   281     public abstract static class ElementVisitor {

   282         abstract public void visitElement(XMLNode e) throws BadFieldException, MissingFieldException;

   283     }

   284 

   285     /** Visits all elements which matches the <path>. The iteration is only

   286      *  done on the last element in the path.

   287      */

   288     public static void visitElements(XMLNode root, String path, ElementVisitor ev)

   289             throws BadFieldException, MissingFieldException {

   290         // Get last element in path

   291         int idx = path.lastIndexOf('<');

   292         if (idx == -1) {

   293             throw new IllegalArgumentException(

   294                     "bad path. Must contain atleast one tag");

   295         }

   296         if (path.length() == 0 || path.charAt(path.length() - 1) != '>') {

   297             throw new IllegalArgumentException("bad path. Must end with a >");

   298         }

   299         String head = path.substring(0, idx);

   300         String tag = path.substring(idx + 1, path.length() - 1);

   301 

   302         XMLNode elem = findElementPath(root, head);

   303         if (elem == null) {

   304             return;

   305         }

   306 

   307         // Iterate through all child nodes

   308         XMLNode n = elem.getNested();

   309         while (n != null) {

   310             if (n.isElement() && n.getName().equals(tag)) {

   311                 ev.visitElement(n);

   312             }

   313             n = n.getNext();

   314         }

   315     }

   316 

   317     public static void visitChildrenElements(XMLNode elem, ElementVisitor ev)

   318             throws BadFieldException, MissingFieldException {

   319         // Iterate through all child nodes

   320         XMLNode n = elem.getNested();

   321         while (n != null) {

   322             if (n.isElement()) {

   323                 ev.visitElement(n);

   324             }

   325             n = n.getNext();

   326         }

   327     }

   328 }