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

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

    49      * The resolution follows the following rules determined by the prefer setting:

    60      * The resolution follows the following rules determined by the prefer

    50      *

    61      * setting:

    51      * prefer "system": attempts to resolve with a system entry;

    62      *

    52      *                  attempts to resolve with a public entry when only

    63      * prefer "system": attempts to resolve with a system entry; attempts to

    53      *                  publicId is specified.

    64      * resolve with a public entry when only publicId is specified.

    54      *

    65      *

    55      * prefer "public": attempts to resolve with a system entry;

    66      * prefer "public": attempts to resolve with a system entry; attempts to

    56      *                  attempts to resolve with a public entry if no matching

    67      * resolve with a public entry if no matching system entry is found.

    57      *                  system entry is found.

    73                If a system identifier is specified, it is used no matter how

    83              If a system identifier is specified, it is used no matter how

    74             prefer is set.

    84              prefer is set.

    75             */

    85              */

    94                 resolvedSystemId = resolve((CatalogImpl)iter.next(), publicId, systemId);

   104                 resolvedSystemId = resolve((CatalogImpl) iter.next(), publicId, systemId);

   105     /**

   115     static void validateUrisSyntax(URI... uris) {

   106      * Resolves the specified file path to an absolute systemId. If it is

   116         for (URI uri : uris) {

   107      * relative, it shall be resolved using the base or user.dir property if

   117             validateUriSyntax(uri);

   108      * base is not specified.

   118         }

   109      *

   119     }

   110      * @param file The specified file path

   120 

   111      * @param baseURI the base URI

   121     static void validateUrisSyntax(String... uris) {

   112      * @return The URI

   122         for (String uri : uris) {

   113      * @throws CatalogException if the specified file path can not be converted

   123             validateUriSyntax(URI.create(uri));

   114      * to a system id

   124         }

   115      */

   125     }

   116     static URI verifyAndGetURI(String file, URL baseURI)

   126 

   117             throws MalformedURLException, URISyntaxException, IllegalArgumentException {

   127     /**

   118         URL filepath;

   128      * Validate that the URI must be absolute and a valid URL.

   119         URI temp;

   129      *

   120         if (file != null && file.length() > 0) {

   130      * Note that this method does not verify the existence of the resource. The

   121             File f = new File(file);

   131      * Catalog standard requires that such resources be ignored.

   122 

   132      *

   123             if (baseURI != null && !f.isAbsolute()) {

   133      * @param uri

   124                 filepath = new URL(baseURI, fixSlashes(file));

   134      * @throws IllegalArgumentException if the uri is not absolute and a valid

   125                 temp = filepath.toURI();

   135      * URL

   126             } else {

   136      */

   127                 temp = resolveURI(file);

   137     static void validateUriSyntax(URI uri) {

   128             }

   138         CatalogMessages.reportNPEOnNull("URI input", uri);

   129             //Paths.get may throw IllegalArgumentException

   139 

   130             Path path = Paths.get(temp);

   140         if (!uri.isAbsolute()) {

   131             if (path.toFile().isFile()) {

   141             CatalogMessages.reportIAE(CatalogMessages.ERR_URI_NOTABSOLUTE,

   132                 return temp;

   142                     new Object[]{uri}, null);

   133             }

   143         }

   134         }

   144 

   135         return null;

   136     }

   137 

   138     /**

   139      * Resolves the specified uri. If the uri is relative, makes it absolute by

   140      * the user.dir directory.

   141      *

   142      * @param uri The specified URI.

   143      * @return The resolved URI

   144      */

   145     static URI resolveURI(String uri) throws MalformedURLException {

   146         if (uri == null) {

   147             uri = "";

   148         }

   149 

   150         URI temp = null;

   152             URL url = new URL(uri);

   146             // check if the scheme was valid

   153             temp = url.toURI();

   147             uri.toURL();

   154         } catch (MalformedURLException | URISyntaxException mue) {

   148         } catch (MalformedURLException ex) {

   155             File file = new File(uri);

   149             CatalogMessages.reportIAE(CatalogMessages.ERR_URI_NOTVALIDURL,

   156             temp = file.toURI();

   150                     new Object[]{uri}, null);

   157         }

   151         }

   158 

   152 

   159         return temp;

   153         // verify the resource exists where possible

   160     }

   154         if (isFileUri(uri)) {

   161 

   155             if (!isFileUriExist(uri, false)) {

   162     /**

   156                 CatalogMessages.reportIAE(CatalogMessages.ERR_URI_NOTVALIDURL,

   163      * Replace backslashes with forward slashes. (URLs always use forward

   157                         new Object[]{uri}, null);

   164      * slashes.)

   158             }

   165      *

   159         }

   166      * @param sysid The input system identifier.

   160     }

   167      * @return The same system identifier with backslashes turned into forward

   161 

   168      * slashes.

   162     /**

   169      */

   163      * Checks whether the URI is a file URI, including JAR file.

   170     static String fixSlashes(String sysid) {

   164      *

   171         return sysid.replace('\\', '/');

   165      * @param uri the specified URI.

   166      * @return true if it is a file or JAR file URI, false otherwise

   167      */

   168     static boolean isFileUri(URI uri) {

   169         if (SCHEME_FILE.equals(uri.getScheme())

   170                 || SCHEME_JAR.equals(uri.getScheme())) {

   171             return true;

   172         }

   173         return false;

   174     }

   175 

   176     /**

   177      * Verifies whether the file resource exists.

   178      *

   179      * @param uri the URI to locate the resource

   180      * @param openJarFile a flag to indicate whether a JAR file should be

   181      * opened. This operation may be expensive.

   182      * @return true if the resource exists, false otherwise.

   183      */

   184     static boolean isFileUriExist(URI uri, boolean openJarFile) {

   185         if (uri != null && uri.isAbsolute()) {

   186             if (null != uri.getScheme()) {

   187                 switch (uri.getScheme()) {

   188                     case SCHEME_FILE:

   189                         String path = uri.getPath();

   190                         File f1 = new File(path);

   191                         if (f1.isFile()) {

   192                             return true;

   193                         }

   194                         break;

   195                     case SCHEME_JAR:

   196                         String tempUri = uri.toString();

   197                         int pos = tempUri.indexOf("!");

   198                         if (pos < 0) {

   199                             return false;

   200                         }

   201                         if (openJarFile) {

   202                             String jarFile = tempUri.substring(SCHEME_JARFILE.length(), pos);

   203                             String entryName = tempUri.substring(pos + 2);

   204                             try {

   205                                 JarFile jf = new JarFile(jarFile);

   206                                 JarEntry je = jf.getJarEntry(entryName);

   207                                 if (je != null) {

   208                                     return true;

   209                                 }

   210                             } catch (IOException ex) {

   211                                 return false;

   212                             }

   213                         } else {

   214                             return true;

   215                         }

   216                         break;

   217                 }

   218             }

   219         }

   220         return false;

   190      * Checks whether the specified string is null or empty, returns the original

   239      * Checks whether the specified string is null or empty, returns the

   191      * string with leading and trailing spaces removed if not.

   240      * original string with leading and trailing spaces removed if not.

   241      *

   193      * @return the original string with leading and trailing spaces removed,

   243      * @return the original string with leading and trailing spaces removed, or

   194      * or null if it is null or empty

   244      * null if it is null or empty