1 /*

     2  * Copyright (c) 1999, 2013, 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.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

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

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

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

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

    15  * accompanied this code).

    16  *

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

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

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

    20  *

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

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

    23  * questions.

    24  */

    25 

    26 package sun.misc;

    27 

    28 import java.io.File;

    29 import java.io.FilenameFilter;

    30 import java.io.IOException;

    31 import java.io.FileNotFoundException;

    32 import java.util.StringTokenizer;

    33 import java.util.Vector;

    34 import java.util.Enumeration;

    35 import java.util.jar.JarFile;

    36 import java.util.jar.Manifest;

    37 import java.util.jar.Attributes;

    38 import java.util.jar.Attributes.Name;

    39 import java.security.AccessController;

    40 import java.security.PrivilegedAction;

    41 import java.security.PrivilegedExceptionAction;

    42 import java.security.PrivilegedActionException;

    43 import java.net.URL;

    44 import java.net.MalformedURLException;

    45 import sun.net.www.ParseUtil;

    46 

    47 /**

    48  * This class checks dependent extensions a particular jar file may have

    49  * declared through its manifest attributes.

    50  * <p>

    51  * Jar file declared dependent extensions through the extension-list

    52  * attribute. The extension-list contains a list of keys used to

    53  * fetch the other attributes describing the required extension.

    54  * If key is the extension key declared in the extension-list

    55  * attribute, the following describing attribute can be found in

    56  * the manifest:

    57  * <ul>

    58  * <li>key-Extension-Name:  (Specification package name)</li>

    59  * <li>key-Specification-Version: (Specification-Version)</li>

    60  * <li>key-Implementation-Version: (Implementation-Version)</li>

    61  * <li>key-Implementation-Vendor-Id: (Imlementation-Vendor-Id)</li>

    62  * <li>key-Implementation-Version: (Implementation version)</li>

    63  * <li>key-Implementation-URL: (URL to download the requested extension)</li>

    64  * </ul>

    65  * <p>

    66  * This class also maintain versioning consistency of installed

    67  * extensions dependencies declared in jar file manifest.

    68  *

    69  * @deprecated this class will be removed in a future release.

    70  * @author  Jerome Dochez

    71  */

    72 @Deprecated

    73 public class ExtensionDependency {

    74 

    75     /* Callbak interfaces to delegate installation of missing extensions */

    76     private static Vector<ExtensionInstallationProvider> providers;

    77 

    78     /**

    79      * Register an ExtensionInstallationProvider. The provider is responsible

    80      * for handling the installation (upgrade) of any missing extensions.

    81      *

    82      * @param eip ExtensionInstallationProvider implementation

    83      */

    84     public synchronized static void addExtensionInstallationProvider

    85         (ExtensionInstallationProvider eip)

    86     {

    87         if (providers == null) {

    88             providers = new Vector<>();

    89         }

    90         providers.add(eip);

    91     }

    92 

    93     /**

    94      * Unregister a previously installed installation provider

    95      */

    96     public synchronized static void removeExtensionInstallationProvider

    97         (ExtensionInstallationProvider eip)

    98     {

    99         providers.remove(eip);

   100     }

   101 

   102     /**

   103      * Checks the dependencies of the jar file on installed extension.

   104      *

   105      * @param jar containing the attributes declaring the dependencies

   106      */

   107     public static boolean checkExtensionsDependencies(JarFile jar)

   108     {

   109         if (providers == null) {

   110             // no need to bother, nobody is registered to install missing

   111             // extensions

   112             return true;

   113         }

   114 

   115         try {

   116             ExtensionDependency extDep = new ExtensionDependency();

   117             return extDep.checkExtensions(jar);

   118         } catch (ExtensionInstallationException e) {

   119             debug(e.getMessage());

   120         }

   121         return false;

   122     }

   123 

   124     /*

   125      * Check for all declared required extensions in the jar file

   126      * manifest.

   127      */

   128     protected boolean checkExtensions(JarFile jar)

   129         throws ExtensionInstallationException

   130     {

   131         Manifest man;

   132         try {

   133             man = jar.getManifest();

   134         } catch (IOException e) {

   135             return false;

   136         }

   137 

   138         if (man == null) {

   139             // The applet does not define a manifest file, so

   140             // we just assume all dependencies are satisfied.

   141             return true;

   142         }

   143 

   144         boolean result = true;

   145         Attributes attr = man.getMainAttributes();

   146         if (attr != null) {

   147             // Let's get the list of declared dependencies

   148             String value = attr.getValue(Name.EXTENSION_LIST);

   149             if (value != null) {

   150                 StringTokenizer st = new StringTokenizer(value);

   151                 // Iterate over all declared dependencies

   152                 while (st.hasMoreTokens()) {

   153                     String extensionName = st.nextToken();

   154                     debug("The file " + jar.getName() +

   155                           " appears to depend on " + extensionName);

   156                     // Sanity Check

   157                     String extName = extensionName + "-" +

   158                         Name.EXTENSION_NAME.toString();

   159                     if (attr.getValue(extName) == null) {

   160                         debug("The jar file " + jar.getName() +

   161                               " appers to depend on "

   162                               + extensionName + " but does not define the " +

   163                               extName + " attribute in its manifest ");

   164 

   165                     } else {

   166                         if (!checkExtension(extensionName, attr)) {

   167                             debug("Failed installing " + extensionName);

   168                             result = false;

   169                         }

   170                     }

   171                 }

   172             } else {

   173                 debug("No dependencies for " + jar.getName());

   174             }

   175         }

   176         return result;

   177     }

   178 

   179 

   180     /*

   181      * Check that a particular dependency on an extension is satisfied.

   182      *

   183      * @param extensionName is the key used for the attributes in the manifest

   184      * @param attr is the attributes of the manifest file

   185      *

   186      * @return true if the dependency is satisfied by the installed extensions

   187      */

   188     protected synchronized boolean checkExtension(final String extensionName,

   189                                      final Attributes attr)

   190         throws ExtensionInstallationException

   191     {

   192         debug("Checking extension " + extensionName);

   193         if (checkExtensionAgainstInstalled(extensionName, attr))

   194             return true;

   195 

   196         debug("Extension not currently installed ");

   197         ExtensionInfo reqInfo = new ExtensionInfo(extensionName, attr);

   198         return installExtension(reqInfo, null);

   199     }

   200 

   201     /*

   202      * Check if a particular extension is part of the currently installed

   203      * extensions.

   204      *

   205      * @param extensionName is the key for the attributes in the manifest

   206      * @param attr is the attributes of the manifest

   207      *

   208      * @return true if the requested extension is already installed

   209      */

   210     boolean checkExtensionAgainstInstalled(String extensionName,

   211                                            Attributes attr)

   212         throws ExtensionInstallationException

   213     {

   214         File fExtension = checkExtensionExists(extensionName);

   215 

   216         if (fExtension != null) {

   217         // Extension already installed, just check against this one

   218             try {

   219                 if (checkExtensionAgainst(extensionName, attr, fExtension))

   220                     return true;

   221             } catch (FileNotFoundException e) {

   222                 debugException(e);

   223             } catch (IOException e) {

   224                 debugException(e);

   225             }

   226             return false;

   227 

   228         } else {

   229         // Not sure if extension is already installed, so check all the

   230         // installed extension jar files to see if we get a match

   231 

   232             File[] installedExts;

   233 

   234             try {

   235             // Get the list of installed extension jar files so we can

   236             // compare the installed versus the requested extension

   237                 installedExts = getInstalledExtensions();

   238             } catch(IOException e) {

   239                 debugException(e);

   240                 return false;

   241             }

   242 

   243             for (int i=0;i<installedExts.length;i++) {

   244                 try {

   245                     if (checkExtensionAgainst(extensionName, attr, installedExts[i]))

   246                         return true;

   247                 } catch (FileNotFoundException e) {

   248                     debugException(e);

   249                 } catch (IOException e) {

   250                     debugException(e);

   251                     // let's continue with the next installed extension

   252                 }

   253             }

   254         }

   255         return false;

   256     }

   257 

   258     /*

   259      * Check if the requested extension described by the attributes

   260      * in the manifest under the key extensionName is compatible with

   261      * the jar file.

   262      *

   263      * @param extensionName key in the attribute list

   264      * @param attr manifest file attributes

   265      * @param file installed extension jar file to compare the requested

   266      * extension against.

   267      */

   268     protected boolean checkExtensionAgainst(String extensionName,

   269                                             Attributes attr,

   270                                             final File file)

   271         throws IOException,

   272                FileNotFoundException,

   273                ExtensionInstallationException

   274     {

   275 

   276         debug("Checking extension " + extensionName +

   277               " against " + file.getName());

   278 

   279         // Load the jar file ...

   280         Manifest man;

   281         try {

   282             man = AccessController.doPrivileged(

   283                 new PrivilegedExceptionAction<Manifest>() {

   284                     public Manifest run()

   285                             throws IOException, FileNotFoundException {

   286                          if (!file.exists())

   287                              throw new FileNotFoundException(file.getName());

   288                          JarFile jarFile =  new JarFile(file);

   289                          return jarFile.getManifest();

   290                      }

   291                  });

   292         } catch(PrivilegedActionException e) {

   293             if (e.getException() instanceof FileNotFoundException)

   294                 throw (FileNotFoundException) e.getException();

   295             throw (IOException) e.getException();

   296         }

   297 

   298         // Construct the extension information object

   299         ExtensionInfo reqInfo = new ExtensionInfo(extensionName, attr);

   300         debug("Requested Extension : " + reqInfo);

   301 

   302         int isCompatible = ExtensionInfo.INCOMPATIBLE;

   303         ExtensionInfo instInfo = null;

   304 

   305         if (man != null) {

   306             Attributes instAttr = man.getMainAttributes();

   307             if (instAttr != null) {

   308                 instInfo = new ExtensionInfo(null, instAttr);

   309                 debug("Extension Installed " + instInfo);

   310                 isCompatible = instInfo.isCompatibleWith(reqInfo);

   311                 switch(isCompatible) {

   312                 case ExtensionInfo.COMPATIBLE:

   313                     debug("Extensions are compatible");

   314                     return true;

   315 

   316                 case ExtensionInfo.INCOMPATIBLE:

   317                     debug("Extensions are incompatible");

   318                     return false;

   319 

   320                 default:

   321                     // everything else

   322                     debug("Extensions require an upgrade or vendor switch");

   323                     return installExtension(reqInfo, instInfo);

   324 

   325                 }

   326             }

   327         }

   328         return false;

   329     }

   330 

   331     /*

   332      * An required extension is missing, if an ExtensionInstallationProvider is

   333      * registered, delegate the installation of that particular extension to it.

   334      *

   335      * @param reqInfo Missing extension information

   336      * @param instInfo Older installed version information

   337      *

   338      * @return true if the installation is successful

   339      */

   340     protected boolean installExtension(ExtensionInfo reqInfo,

   341                                        ExtensionInfo instInfo)

   342         throws ExtensionInstallationException

   343     {

   344         Vector<ExtensionInstallationProvider> currentProviders;

   345         synchronized(providers) {

   346             @SuppressWarnings("unchecked")

   347             Vector<ExtensionInstallationProvider> tmp =

   348                 (Vector<ExtensionInstallationProvider>) providers.clone();

   349             currentProviders = tmp;

   350         }

   351         for (Enumeration<ExtensionInstallationProvider> e = currentProviders.elements();

   352                 e.hasMoreElements();) {

   353             ExtensionInstallationProvider eip = e.nextElement();

   354 

   355             if (eip!=null) {

   356                 // delegate the installation to the provider

   357                 if (eip.installExtension(reqInfo, instInfo)) {

   358                     debug(reqInfo.name + " installation successful");

   359                     Launcher.ExtClassLoader cl = (Launcher.ExtClassLoader)

   360                         Launcher.getLauncher().getClassLoader().getParent();

   361                     addNewExtensionsToClassLoader(cl);

   362                     return true;

   363                 }

   364             }

   365         }

   366         // We have tried all of our providers, noone could install this

   367         // extension, we just return failure at this point

   368         debug(reqInfo.name + " installation failed");

   369         return false;

   370     }

   371 

   372     /**

   373      * Checks if the extension, that is specified in the extension-list in

   374      * the applet jar manifest, is already installed (i.e. exists in the

   375      * extension directory).

   376      *

   377      * @param extensionName extension name in the extension-list

   378      *

   379      * @return the extension if it exists in the extension directory

   380      */

   381     private File checkExtensionExists(String extensionName) {

   382         // Function added to fix bug 4504166

   383         final String extName = extensionName;

   384         final String[] fileExt = {".jar", ".zip"};

   385 

   386         return AccessController.doPrivileged(

   387             new PrivilegedAction<File>() {

   388                 public File run() {

   389                     try {

   390                         File fExtension;

   391                         File[] dirs = getExtDirs();

   392 

   393                         // Search the extension directories for the extension that is specified

   394                         // in the attribute extension-list in the applet jar manifest

   395                         for (int i=0;i<dirs.length;i++) {

   396                             for (int j=0;j<fileExt.length;j++) {

   397                                 if (extName.toLowerCase().endsWith(fileExt[j])) {

   398                                     fExtension = new File(dirs[i], extName);

   399                                 } else {

   400                                     fExtension = new File(dirs[i], extName+fileExt[j]);

   401                                 }

   402                                 debug("checkExtensionExists:fileName " + fExtension.getName());

   403                                 if (fExtension.exists()) {

   404                                     return fExtension;

   405                                 }

   406                             }

   407                         }

   408                         return null;

   409 

   410                     } catch(Exception e) {

   411                          debugException(e);

   412                          return null;

   413                     }

   414                 }

   415             });

   416     }

   417 

   418     /**

   419      * @return the java.ext.dirs property as a list of directory

   420      */

   421     private static File[] getExtDirs() {

   422         String s = java.security.AccessController.doPrivileged(

   423                 new sun.security.action.GetPropertyAction("java.ext.dirs"));

   424 

   425         File[] dirs;

   426         if (s != null) {

   427             StringTokenizer st =

   428                 new StringTokenizer(s, File.pathSeparator);

   429             int count = st.countTokens();

   430             debug("getExtDirs count " + count);

   431             dirs = new File[count];

   432             for (int i = 0; i < count; i++) {

   433                 dirs[i] = new File(st.nextToken());

   434                 debug("getExtDirs dirs["+i+"] "+ dirs[i]);

   435             }

   436         } else {

   437             dirs = new File[0];

   438             debug("getExtDirs dirs " + dirs);

   439         }

   440         debug("getExtDirs dirs.length " + dirs.length);

   441         return dirs;

   442     }

   443 

   444     /*

   445      * Scan the directories and return all files installed in those

   446      *

   447      * @param dirs list of directories to scan

   448      *

   449      * @return the list of files installed in all the directories

   450      */

   451     private static File[] getExtFiles(File[] dirs) throws IOException {

   452         Vector<File> urls = new Vector<File>();

   453         for (int i = 0; i < dirs.length; i++) {

   454             String[] files = dirs[i].list(new JarFilter());

   455             if (files != null) {

   456                 debug("getExtFiles files.length " + files.length);

   457                 for (int j = 0; j < files.length; j++) {

   458                     File f = new File(dirs[i], files[j]);

   459                     urls.add(f);

   460                     debug("getExtFiles f["+j+"] "+ f);

   461                 }

   462             }

   463         }

   464         File[] ua = new File[urls.size()];

   465         urls.copyInto(ua);

   466         debug("getExtFiles ua.length " + ua.length);

   467         return ua;

   468     }

   469 

   470     /*

   471      * @return the list of installed extensions jar files

   472      */

   473     private File[] getInstalledExtensions() throws IOException {

   474         return AccessController.doPrivileged(

   475             new PrivilegedAction<File[]>() {

   476                 public File[] run() {

   477                      try {

   478                          return getExtFiles(getExtDirs());

   479                      } catch(IOException e) {

   480                          debug("Cannot get list of installed extensions");

   481                          debugException(e);

   482                         return new File[0];

   483                      }

   484                  }

   485             });

   486     }

   487 

   488     /*

   489      * Add the newly installed jar file to the extension class loader.

   490      *

   491      * @param cl the current installed extension class loader

   492      *

   493      * @return true if successful

   494      */

   495     private Boolean addNewExtensionsToClassLoader(Launcher.ExtClassLoader cl) {

   496         try {

   497             File[] installedExts = getInstalledExtensions();

   498             for (int i=0;i<installedExts.length;i++) {

   499                 final File instFile = installedExts[i];

   500                 URL instURL = AccessController.doPrivileged(

   501                     new PrivilegedAction<URL>() {

   502                         public URL run() {

   503                             try {

   504                                 return ParseUtil.fileToEncodedURL(instFile);

   505                             } catch (MalformedURLException e) {

   506                                 debugException(e);

   507                                 return null;

   508                             }

   509                         }

   510                     });

   511                 if (instURL != null) {

   512                     URL[] urls = cl.getURLs();

   513                     boolean found=false;

   514                     for (int j = 0; j<urls.length; j++) {

   515                         debug("URL["+j+"] is " + urls[j] + " looking for "+

   516                                            instURL);

   517                         if (urls[j].toString().compareToIgnoreCase(

   518                                     instURL.toString())==0) {

   519                             found=true;

   520                             debug("Found !");

   521                         }

   522                     }

   523                     if (!found) {

   524                         debug("Not Found ! adding to the classloader " +

   525                               instURL);

   526                         cl.addExtURL(instURL);

   527                     }

   528                 }

   529             }

   530         } catch (MalformedURLException e) {

   531             e.printStackTrace();

   532         } catch (IOException e) {

   533             e.printStackTrace();

   534             // let's continue with the next installed extension

   535         }

   536         return Boolean.TRUE;

   537     }

   538 

   539     // True to display all debug and trace messages

   540     static final boolean DEBUG = false;

   541 

   542     private static void debug(String s) {

   543         if (DEBUG) {

   544             System.err.println(s);

   545         }

   546     }

   547 

   548     private void debugException(Throwable e) {

   549         if (DEBUG) {

   550             e.printStackTrace();

   551         }

   552     }

   553 

   554 }