Back to index...

	/*
	* 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;
	}
	}


	}

Back to index...