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.util.Locale;

    27 import java.util.ArrayList;

    28 import java.util.StringTokenizer;

    29 import java.io.BufferedInputStream;

    30 import java.io.IOException;

    31 import java.io.InputStream;

    32 import java.net.MalformedURLException;

    33 import java.net.URL;

    34 

    35 /**

    36  * Handy class to add some utility methods for dealing with property matching

    37  * etc.

    38  */

    39 public class GeneralUtil {

    40 

    41     public static boolean prefixMatchStringList(String[] prefixList, String target) {

    42         // No prefixes matches everything

    43         if (prefixList == null) {

    44             return true;

    45         }

    46         // No target, but a prefix list does not match anything

    47         if (target == null) {

    48             return false;

    49         }

    50         for (String prefix : prefixList) {

    51             if (target.startsWith(prefix)) {

    52                 return true;

    53             }

    54         }

    55         return false;

    56     }

    57 

    58     private static String getOSArch() {

    59         return System.getProperty("os.arch");

    60     }

    61 

    62     public static boolean prefixMatchArch(String[] prefixList) {

    63         // No prefixes matches everything

    64         if (prefixList == null) {

    65             return true;

    66         }

    67 

    68         // check for the current arch

    69         String arch = getOSArch();

    70         for (String prefix : prefixList) {

    71             if (arch.startsWith(prefix)) {

    72                 return true;

    73             }

    74         }

    75 

    76         return false;

    77     }

    78 

    79     /**

    80      * Converts a space delimited string to a list of strings

    81      */

    82     public static String[] getStringList(String str) {

    83         if (str == null) {

    84             return null;

    85         }

    86         ArrayList<String> list = new ArrayList<>();

    87         int i = 0;

    88         int length = str.length();

    89         StringBuffer sb = null;

    90         while (i < length) {

    91             char ch = str.charAt(i);

    92             switch (ch) {

    93                 case ' ':

    94                     // A space was hit. Add string to list

    95                     if (sb != null) {

    96                         list.add(sb.toString());

    97                         sb = null;

    98                     }

    99                     break;

   100                 case '\\':

   101                     // It is a delimiter. Add next character

   102                     if (i + 1 < length) {

   103                         ch = str.charAt(++i);

   104                         if (sb == null) {

   105                             sb = new StringBuffer();

   106                         }

   107                         sb.append(ch);

   108                     }

   109                     break;

   110                 default:

   111                     if (sb == null) {

   112                         sb = new StringBuffer();

   113                     }   sb.append(ch);

   114                     break;

   115             }

   116             i++; // Next character

   117         }

   118         // Make sure to add the last part to the list too

   119         if (sb != null) {

   120             list.add(sb.toString());

   121         }

   122         if (list.isEmpty()) {

   123             return null;

   124         }

   125         String[] results = new String[list.size()];

   126         return list.toArray(results);

   127     }

   128 

   129     /**

   130      * Checks if string list matches default locale

   131      */

   132     public static boolean matchLocale(String[] localeList, Locale locale) {

   133         // No locale specified matches everything

   134         if (localeList == null) {

   135             return true;

   136         }

   137         for (String localeList1 : localeList) {

   138             if (matchLocale(localeList1, locale)) {

   139                 return true;

   140             }

   141         }

   142         return false;

   143     }

   144 

   145     /**

   146      * Checks if string matches default locale

   147      */

   148     public static boolean matchLocale(String localeStr, Locale locale) {

   149         if (localeStr == null || localeStr.length() == 0) {

   150             return true;

   151         }

   152 

   153         // Compare against default locale

   154         String language;

   155         String country;

   156         String variant;

   157 

   158         // The locale string is of the form language_country_variant

   159         StringTokenizer st = new StringTokenizer(localeStr, "_", false);

   160         if (st.hasMoreElements() && locale.getLanguage().length() > 0) {

   161             language = st.nextToken();

   162             if (!language.equalsIgnoreCase(locale.getLanguage())) {

   163                 return false;

   164             }

   165         }

   166         if (st.hasMoreElements() && locale.getCountry().length() > 0) {

   167             country = st.nextToken();

   168             if (!country.equalsIgnoreCase(locale.getCountry())) {

   169                 return false;

   170             }

   171         }

   172         if (st.hasMoreElements() && locale.getVariant().length() > 0) {

   173             variant = st.nextToken();

   174             if (!variant.equalsIgnoreCase(locale.getVariant())) {

   175                 return false;

   176             }

   177         }

   178 

   179         return true;

   180     }

   181 

   182     public static long heapValToLong(String heapValue) {

   183         if (heapValue == null) {

   184             return -1;

   185         }

   186         long multiplier = 1;

   187         if (heapValue.toLowerCase().lastIndexOf('m') != -1) {

   188             // units are megabytes, 1 megabyte = 1024 * 1024 bytes

   189             multiplier = 1024 * 1024;

   190             heapValue = heapValue.substring(0, heapValue.length() - 1);

   191         } else if (heapValue.toLowerCase().lastIndexOf('k') != -1) {

   192             // units are kilobytes, 1 kilobyte = 1024 bytes

   193             multiplier = 1024;

   194             heapValue = heapValue.substring(0, heapValue.length() - 1);

   195         }

   196         long theValue;

   197         try {

   198             theValue = Long.parseLong(heapValue);

   199             theValue = theValue * multiplier;

   200         } catch (NumberFormatException e) {

   201             theValue = -1;

   202         }

   203         return theValue;

   204     }

   205 

   206     public static byte[] readBytes(InputStream is, long size) throws IOException {

   207         // Sanity on file size (restrict to 1M)

   208         if (size > 1024 * 1024) {

   209             throw new IOException("File too large");

   210         }

   211 

   212         BufferedInputStream bis;

   213         if (is instanceof BufferedInputStream) {

   214             bis = (BufferedInputStream) is;

   215         } else {

   216             bis = new BufferedInputStream(is);

   217         }

   218 

   219         if (size <= 0) {

   220             size = 10 * 1024; // Default to 10K

   221         }

   222         byte[] b = new byte[(int) size];

   223         int n;

   224         int bytesRead = 0;

   225         n = bis.read(b, bytesRead, b.length - bytesRead);

   226         while (n != -1) {

   227             bytesRead += n;

   228             // Still room in array

   229             if (b.length == bytesRead) {

   230                 byte[] bb = new byte[b.length * 2];

   231                 System.arraycopy(b, 0, bb, 0, b.length);

   232                 b = bb;

   233             }

   234             // Read next line

   235             n = bis.read(b, bytesRead, b.length - bytesRead);

   236         }

   237         bis.close();

   238         is.close();

   239 

   240         if (bytesRead != b.length) {

   241             byte[] bb = new byte[bytesRead];

   242             System.arraycopy(b, 0, bb, 0, bytesRead);

   243             b = bb;

   244         }

   245         return b;

   246     }

   247 

   248     public static String getOSFullName() {

   249         return System.getProperty("os.name");

   250     }

   251 

   252     /**

   253      * Makes sure a URL is a path URL, i.e., ends with '/'

   254      */

   255     public static URL asPathURL(URL url) {

   256         if (url == null) {

   257             return null;

   258         }

   259 

   260         String path = url.getFile();

   261         if (path != null && !path.endsWith("/")) {

   262             try {

   263                 return new URL(url.getProtocol(),

   264                         url.getHost(),

   265                         url.getPort(),

   266                         url.getFile() + "/");

   267             } catch (MalformedURLException mue) {

   268                 // Should not happen

   269             }

   270         }

   271         // Just return same URl

   272         return url;

   273     }

   274 

   275     public static Locale getDefaultLocale() {

   276         return Locale.getDefault();

   277     }

   278 

   279     public static String toNormalizedString(URL u) {

   280         if (u == null) {

   281             return "";

   282         }

   283 

   284         try {

   285             if (u.getPort() == u.getDefaultPort()) {

   286                 u = new URL(u.getProtocol().toLowerCase(),

   287                         u.getHost().toLowerCase(), -1, u.getFile());

   288             } else {

   289                 u = new URL(u.getProtocol().toLowerCase(),

   290                         u.getHost().toLowerCase(), u.getPort(), u.getFile());

   291             }

   292         } catch (MalformedURLException ex) {

   293         }

   294         return u.toExternalForm();

   295     }

   296 

   297     public static boolean sameURLs(URL u1, URL u2) {

   298         if (u1 == null || u2 == null || (u1 == u2)) {

   299             return (u1 == u2);

   300         }

   301         //NB: do not use URL.sameFile() as it will do DNS lookup

   302         // Also, do quick check before slow string comparisons

   303         String f1 = u1.getFile();

   304         String f2 = u2.getFile();

   305         return (f1.length() == f2.length()) && sameBase(u1, u2)

   306                 && f1.equalsIgnoreCase(f2);

   307     }

   308 

   309     public static boolean sameBase(URL u1, URL u2) {

   310         return u1 != null && u2 != null &&

   311                 sameHost(u1, u2) && samePort(u1, u2) && sameProtocol(u1, u2);

   312     }

   313 

   314     private static boolean sameProtocol(URL u1, URL u2) {

   315         //protocols are known to be lowercase

   316         return u1.getProtocol().equals(u2.getProtocol());

   317     }

   318 

   319     private static boolean sameHost(URL u1, URL u2) {

   320         String host = u1.getHost();

   321         String otherHost = u2.getHost();

   322         if (host == null || otherHost == null) {

   323             return (host == null && otherHost == null);

   324         } else {

   325             //avoid slow comparison for strings of different length

   326             return ((host.length() == otherHost.length())

   327                        && host.equalsIgnoreCase(otherHost));

   328         }

   329     }

   330 

   331     private static boolean samePort(URL u1, URL u2) {

   332         return getPort(u1) == getPort(u2);

   333     }

   334 

   335     public static int getPort(URL u) {

   336         if (u.getPort() != -1) {

   337             return u.getPort();

   338         } else {

   339             return u.getDefaultPort();

   340         }

   341     }

   342 

   343     public static URL getBase(URL url) {

   344         if (url == null) return null;

   345         String file = url.getFile();

   346         if (file != null) {

   347             int idx = file.lastIndexOf('/');

   348             if (idx != -1 ) {

   349                 file = file.substring(0, idx + 1);

   350             }

   351             try {

   352                 return new URL(

   353                     url.getProtocol(),

   354                     url.getHost(),

   355                     url.getPort(),

   356                     file);

   357             } catch(MalformedURLException mue) {

   358                 System.err.println(mue.getMessage());

   359             }

   360         }

   361         // Just return same URL

   362         return url;

   363     }

   364 

   365     private static String getEmbeddedVersionPath(String path, String version) {

   366         int index = path.lastIndexOf("/");

   367         String filename = path.substring(index + 1);

   368         path = path.substring(0, index + 1);

   369 

   370         String ext = null;

   371         index = filename.lastIndexOf(".");

   372         if (index != -1) {

   373             ext = filename.substring(index + 1);

   374             filename = filename.substring(0, index);

   375         }

   376 

   377         StringBuilder filenameSB = new StringBuilder(filename);

   378         if (version != null) {

   379             filenameSB.append("__V");

   380             filenameSB.append(version);

   381         }

   382         if (ext != null) {

   383             filenameSB.append(".");

   384             filenameSB.append(ext);

   385         }

   386 

   387         path += filenameSB.toString();

   388         return path;

   389     }

   390 

   391     public static URL getEmbeddedVersionURL(URL u, String version) throws Exception {

   392         if (u == null) {

   393             return null;

   394         }

   395 

   396         if (version == null || version.indexOf("*") != -1

   397                 || version.indexOf("+") != -1) {

   398             // Do not support * or + in version string

   399             return u;

   400         }

   401 

   402         URL versionURL = null;

   403 

   404         String protocol = u.getProtocol();

   405         String host = u.getHost();

   406         int port = u.getPort();

   407         String path = u.getPath();

   408 

   409         path = getEmbeddedVersionPath(path, version);

   410 

   411         versionURL = new URL(protocol, host, port, path);

   412 

   413         return versionURL;

   414     }

   415 }