| /* |
| * Copyright (c) 1998, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.tools.extcheck; |
| |
| import java.util.*; |
| import java.net.MalformedURLException; |
| import java.util.Vector; |
| import java.io.*; |
| import java.util.StringTokenizer; |
| import java.net.URL; |
| import java.util.jar.JarFile; |
| import java.util.jar.JarEntry; |
| import java.util.jar.Manifest; |
| import java.util.jar.Attributes; |
| import java.util.jar.Attributes.Name; |
| import java.net.URLConnection; |
| import java.security.Permission; |
| import java.util.jar.*; |
| import java.net.JarURLConnection; |
| import sun.net.www.ParseUtil; |
| |
| /** |
| * ExtCheck reports on clashes between a specified (target) |
| * jar file and jar files already installed in the extensions |
| * directory. |
| * |
| * @author Benedict Gomes |
| * @since 1.2 |
| */ |
| |
| public class ExtCheck { |
| |
| private static final boolean DEBUG = false; |
| |
| // The following strings hold the values of the version variables |
| // for the target jar file |
| private String targetSpecTitle; |
| private String targetSpecVersion; |
| private String targetSpecVendor; |
| private String targetImplTitle; |
| private String targetImplVersion; |
| private String targetImplVendor; |
| private String targetsealed; |
| |
| /* Flag to indicate whether extra information should be dumped to stdout */ |
| private boolean verboseFlag; |
| |
| /* |
| * Create a new instance of the jar reporting tool for a particular |
| * targetFile. |
| * @param targetFile is the file to compare against. |
| * @param verbose indicates whether to dump filenames and manifest |
| * information (on conflict) to the standard output. |
| */ |
| static ExtCheck create(File targetFile, boolean verbose) { |
| return new ExtCheck(targetFile, verbose); |
| } |
| |
| private ExtCheck(File targetFile, boolean verbose) { |
| verboseFlag = verbose; |
| investigateTarget(targetFile); |
| } |
| |
| |
| private void investigateTarget(File targetFile) { |
| verboseMessage("Target file:" + targetFile); |
| Manifest targetManifest = null; |
| try { |
| File canon = new File(targetFile.getCanonicalPath()); |
| URL url = ParseUtil.fileToEncodedURL(canon); |
| if (url != null){ |
| JarLoader loader = new JarLoader(url); |
| JarFile jarFile = loader.getJarFile(); |
| targetManifest = jarFile.getManifest(); |
| } |
| } catch (MalformedURLException e){ |
| error("Malformed URL "); |
| } catch (IOException e) { |
| error("IO Exception "); |
| } |
| if (targetManifest == null) |
| error("No manifest available in "+targetFile); |
| Attributes attr = targetManifest.getMainAttributes(); |
| if (attr != null) { |
| targetSpecTitle = attr.getValue(Name.SPECIFICATION_TITLE); |
| targetSpecVersion = attr.getValue(Name.SPECIFICATION_VERSION); |
| targetSpecVendor = attr.getValue(Name.SPECIFICATION_VENDOR); |
| targetImplTitle = attr.getValue(Name.IMPLEMENTATION_TITLE); |
| targetImplVersion = attr.getValue(Name.IMPLEMENTATION_VERSION); |
| targetImplVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR); |
| targetsealed = attr.getValue(Name.SEALED); |
| } else { |
| error("No attributes available in the manifest"); |
| } |
| if (targetSpecTitle == null) |
| error("The target file does not have a specification title"); |
| if (targetSpecVersion == null) |
| error("The target file does not have a specification version"); |
| verboseMessage("Specification title:" + targetSpecTitle); |
| verboseMessage("Specification version:" + targetSpecVersion); |
| if (targetSpecVendor != null) |
| verboseMessage("Specification vendor:" + targetSpecVendor); |
| if (targetImplVersion != null) |
| verboseMessage("Implementation version:" + targetImplVersion); |
| if (targetImplVendor != null) |
| verboseMessage("Implementation vendor:" + targetImplVendor); |
| verboseMessage(""); |
| } |
| |
| /** |
| * Verify that none of the jar files in the install directory |
| * has the same specification-title and the same or a newer |
| * specification-version. |
| * |
| * @return Return true if the target jar file is newer |
| * than any installed jar file with the same specification-title, |
| * otherwise return false |
| */ |
| boolean checkInstalledAgainstTarget(){ |
| String s = System.getProperty("java.ext.dirs"); |
| File [] dirs; |
| if (s != null) { |
| StringTokenizer st = |
| new StringTokenizer(s, File.pathSeparator); |
| int count = st.countTokens(); |
| dirs = new File[count]; |
| for (int i = 0; i < count; i++) { |
| dirs[i] = new File(st.nextToken()); |
| } |
| } else { |
| dirs = new File[0]; |
| } |
| |
| boolean result = true; |
| for (int i = 0; i < dirs.length; i++) { |
| String[] files = dirs[i].list(); |
| if (files != null) { |
| for (int j = 0; j < files.length; j++) { |
| try { |
| File f = new File(dirs[i],files[j]); |
| File canon = new File(f.getCanonicalPath()); |
| URL url = ParseUtil.fileToEncodedURL(canon); |
| if (url != null){ |
| result = result && checkURLRecursively(1,url); |
| } |
| } catch (MalformedURLException e){ |
| error("Malformed URL"); |
| } catch (IOException e) { |
| error("IO Exception"); |
| } |
| } |
| } |
| } |
| if (result) { |
| generalMessage("No conflicting installed jar found."); |
| } else { |
| generalMessage("Conflicting installed jar found. " |
| + " Use -verbose for more information."); |
| } |
| return result; |
| } |
| |
| /** |
| * Recursively verify that a jar file, and any urls mentioned |
| * in its class path, do not conflict with the target jar file. |
| * |
| * @param indent is the current nesting level |
| * @param url is the path to the jar file being checked. |
| * @return true if there is no newer URL, otherwise false |
| */ |
| private boolean checkURLRecursively(int indent, URL url) |
| throws IOException |
| { |
| verboseMessage("Comparing with " + url); |
| JarLoader jarloader = new JarLoader(url); |
| JarFile j = jarloader.getJarFile(); |
| Manifest man = j.getManifest(); |
| if (man != null) { |
| Attributes attr = man.getMainAttributes(); |
| if (attr != null){ |
| String title = attr.getValue(Name.SPECIFICATION_TITLE); |
| String version = attr.getValue(Name.SPECIFICATION_VERSION); |
| String vendor = attr.getValue(Name.SPECIFICATION_VENDOR); |
| String implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE); |
| String implVersion |
| = attr.getValue(Name.IMPLEMENTATION_VERSION); |
| String implVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR); |
| String sealed = attr.getValue(Name.SEALED); |
| if (title != null){ |
| if (title.equals(targetSpecTitle)){ |
| if (version != null){ |
| if (version.equals(targetSpecVersion) || |
| isNotOlderThan(version,targetSpecVersion)){ |
| verboseMessage(""); |
| verboseMessage("CONFLICT DETECTED "); |
| verboseMessage("Conflicting file:"+ url); |
| verboseMessage("Installed Version:" + |
| version); |
| if (implTitle != null) |
| verboseMessage("Implementation Title:"+ |
| implTitle); |
| if (implVersion != null) |
| verboseMessage("Implementation Version:"+ |
| implVersion); |
| if (implVendor != null) |
| verboseMessage("Implementation Vendor:"+ |
| implVendor); |
| return false; |
| } |
| } |
| } |
| } |
| } |
| } |
| boolean result = true; |
| URL[] loaderList = jarloader.getClassPath(); |
| if (loaderList != null) { |
| for(int i=0; i < loaderList.length; i++){ |
| if (url != null){ |
| boolean res = checkURLRecursively(indent+1,loaderList[i]); |
| result = res && result; |
| } |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * See comment in method java.lang.Package.isCompatibleWith. |
| * Return true if already is not older than target. i.e. the |
| * target file may be superseded by a file already installed |
| */ |
| private boolean isNotOlderThan(String already,String target) |
| throws NumberFormatException |
| { |
| if (already == null || already.length() < 1) { |
| throw new NumberFormatException("Empty version string"); |
| } |
| |
| // Until it matches scan and compare numbers |
| StringTokenizer dtok = new StringTokenizer(target, ".", true); |
| StringTokenizer stok = new StringTokenizer(already, ".", true); |
| while (dtok.hasMoreTokens() || stok.hasMoreTokens()) { |
| int dver; |
| int sver; |
| if (dtok.hasMoreTokens()) { |
| dver = Integer.parseInt(dtok.nextToken()); |
| } else |
| dver = 0; |
| |
| if (stok.hasMoreTokens()) { |
| sver = Integer.parseInt(stok.nextToken()); |
| } else |
| sver = 0; |
| |
| if (sver < dver) |
| return false; // Known to be incompatible |
| if (sver > dver) |
| return true; // Known to be compatible |
| |
| // Check for and absorb separators |
| if (dtok.hasMoreTokens()) |
| dtok.nextToken(); |
| if (stok.hasMoreTokens()) |
| stok.nextToken(); |
| // Compare next component |
| } |
| // All components numerically equal |
| return true; |
| } |
| |
| |
| /** |
| * Prints out message if the verboseFlag is set |
| */ |
| void verboseMessage(String message){ |
| if (verboseFlag) { |
| System.err.println(message); |
| } |
| } |
| |
| void generalMessage(String message){ |
| System.err.println(message); |
| } |
| |
| /** |
| * Throws a RuntimeException with a message describing the error. |
| */ |
| static void error(String message) throws RuntimeException { |
| throw new RuntimeException(message); |
| } |
| |
| |
| /** |
| * Inner class used to represent a loader of resources and classes |
| * from a base URL. Somewhat modified version of code in |
| * sun.misc.URLClassPath.JarLoader |
| */ |
| private static class JarLoader { |
| private final URL base; |
| private JarFile jar; |
| private URL csu; |
| |
| /* |
| * Creates a new Loader for the specified URL. |
| */ |
| JarLoader(URL url) { |
| String urlName = url + "!/"; |
| URL tmpBaseURL = null; |
| try { |
| tmpBaseURL = new URL("jar","",urlName); |
| jar = findJarFile(url); |
| csu = url; |
| } catch (MalformedURLException e) { |
| ExtCheck.error("Malformed url "+urlName); |
| } catch (IOException e) { |
| ExtCheck.error("IO Exception occurred"); |
| } |
| base = tmpBaseURL; |
| |
| } |
| |
| /* |
| * Returns the base URL for this Loader. |
| */ |
| URL getBaseURL() { |
| return base; |
| } |
| |
| JarFile getJarFile() { |
| return jar; |
| } |
| |
| private JarFile findJarFile(URL url) throws IOException { |
| // Optimize case where url refers to a local jar file |
| if ("file".equals(url.getProtocol())) { |
| String path = url.getFile().replace('/', File.separatorChar); |
| File file = new File(path); |
| if (!file.exists()) { |
| throw new FileNotFoundException(path); |
| } |
| return new JarFile(path); |
| } |
| URLConnection uc = getBaseURL().openConnection(); |
| //uc.setRequestProperty(USER_AGENT_JAVA_VERSION, JAVA_VERSION); |
| return ((JarURLConnection)uc).getJarFile(); |
| } |
| |
| |
| /* |
| * Returns the JAR file local class path, or null if none. |
| */ |
| URL[] getClassPath() throws IOException { |
| Manifest man = jar.getManifest(); |
| if (man != null) { |
| Attributes attr = man.getMainAttributes(); |
| if (attr != null) { |
| String value = attr.getValue(Name.CLASS_PATH); |
| if (value != null) { |
| return parseClassPath(csu, value); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * Parses value of the Class-Path manifest attribute and returns |
| * an array of URLs relative to the specified base URL. |
| */ |
| private URL[] parseClassPath(URL base, String value) |
| throws MalformedURLException |
| { |
| StringTokenizer st = new StringTokenizer(value); |
| URL[] urls = new URL[st.countTokens()]; |
| int i = 0; |
| while (st.hasMoreTokens()) { |
| String path = st.nextToken(); |
| urls[i] = new URL(base, path); |
| i++; |
| } |
| return urls; |
| } |
| } |
| |
| |
| } |
