private Class<?> findClassInComponents(final String name) throws ClassNotFoundException {
final String classFilename = this.getClassFilename(name);
final Enumeration<File> e = this.pathComponents.elements();
while (e.hasMoreElements()) {
final File pathComponent = e.nextElement();
InputStream stream = null;
try {
stream = this.getResourceStream(pathComponent, classFilename);
if (stream != null) {
this.log("Loaded from " + pathComponent + " " + classFilename, 4);
return this.getClassFromStream(stream, name, pathComponent);
}
continue;
} catch (SecurityException se) {
throw se;
} catch (IOException ioe) {
this.log(
"Exception reading component " + pathComponent + " (reason: " + ioe.getMessage() + ")",
3);
} finally {
FileUtils.close(stream);
}
}
throw new ClassNotFoundException(name);
}
/**
* Loads the keystore from the Keychain.
*
* @param stream Ignored - here for API compatibility.
* @param password Ignored - if user needs to unlock keychain Security framework will post any
* dialogs.
* @exception IOException if there is an I/O or format problem with the keystore data
* @exception NoSuchAlgorithmException if the algorithm used to check the integrity of the
* keystore cannot be found
* @exception CertificateException if any of the certificates in the keystore could not be loaded
*/
public void engineLoad(InputStream stream, char[] password)
throws IOException, NoSuchAlgorithmException, CertificateException {
permissionCheck();
// Release any stray keychain references before clearing out the entries.
synchronized (entries) {
for (Enumeration<String> e = entries.keys(); e.hasMoreElements(); ) {
String alias = e.nextElement();
Object entry = entries.get(alias);
if (entry instanceof TrustedCertEntry) {
if (((TrustedCertEntry) entry).certRef != 0) {
_releaseKeychainItemRef(((TrustedCertEntry) entry).certRef);
}
} else {
KeyEntry keyEntry = (KeyEntry) entry;
if (keyEntry.chain != null) {
for (int i = 0; i < keyEntry.chain.length; i++) {
if (keyEntry.chainRefs[i] != 0) {
_releaseKeychainItemRef(keyEntry.chainRefs[i]);
}
}
if (keyEntry.keyRef != 0) {
_releaseKeychainItemRef(keyEntry.keyRef);
}
}
}
}
entries.clear();
_scanKeychain();
}
}
public URL getResource(final String name) {
URL url = null;
if (this.isParentFirst(name)) {
url = ((this.parent == null) ? super.getResource(name) : this.parent.getResource(name));
}
if (url != null) {
this.log("Resource " + name + " loaded from parent loader", 4);
} else {
final Enumeration<File> e = this.pathComponents.elements();
while (e.hasMoreElements() && url == null) {
final File pathComponent = e.nextElement();
url = this.getResourceURL(pathComponent, name);
if (url != null) {
this.log("Resource " + name + " loaded from ant loader", 4);
}
}
}
if (url == null && !this.isParentFirst(name)) {
if (this.ignoreBase) {
url = ((this.getRootLoader() == null) ? null : this.getRootLoader().getResource(name));
} else {
url = ((this.parent == null) ? super.getResource(name) : this.parent.getResource(name));
}
if (url != null) {
this.log("Resource " + name + " loaded from parent loader", 4);
}
}
if (url == null) {
this.log("Couldn't load Resource " + name, 4);
}
return url;
}
public void addJavaLibraries() {
final Vector<String> packages = JavaEnvUtils.getJrePackages();
final Enumeration<String> e = packages.elements();
while (e.hasMoreElements()) {
final String packageName = e.nextElement();
this.addSystemPackageRoot(packageName);
}
}
private InputStream loadResource(final String name) {
InputStream stream = null;
File pathComponent;
for (Enumeration<File> e = this.pathComponents.elements();
e.hasMoreElements() && stream == null;
stream = this.getResourceStream(pathComponent, name)) {
pathComponent = e.nextElement();
}
return stream;
}
public String getClasspath() {
final StringBuilder sb = new StringBuilder();
boolean firstPass = true;
final Enumeration<File> componentEnum = this.pathComponents.elements();
while (componentEnum.hasMoreElements()) {
if (!firstPass) {
sb.append(System.getProperty("path.separator"));
} else {
firstPass = false;
}
sb.append(componentEnum.nextElement().getAbsolutePath());
}
return sb.toString();
}
public synchronized void cleanup() {
final Enumeration<JarFile> e = this.jarFiles.elements();
while (e.hasMoreElements()) {
final JarFile jarFile = e.nextElement();
try {
jarFile.close();
} catch (IOException ex) {
}
}
this.jarFiles = new Hashtable<File, JarFile>();
if (this.project != null) {
this.project.removeBuildListener(this);
}
this.project = null;
}
private boolean isParentFirst(final String resourceName) {
boolean useParentFirst = this.parentFirst;
Enumeration<String> e = this.systemPackages.elements();
while (e.hasMoreElements()) {
final String packageName = e.nextElement();
if (resourceName.startsWith(packageName)) {
useParentFirst = true;
break;
}
}
e = this.loaderPackages.elements();
while (e.hasMoreElements()) {
final String packageName = e.nextElement();
if (resourceName.startsWith(packageName)) {
useParentFirst = false;
break;
}
}
return useParentFirst;
}
/**
* Returns the (alias) name of the first keystore entry whose certificate matches the given
* certificate.
*
* <p>This method attempts to match the given certificate with each keystore entry. If the entry
* being considered is a <i>trusted certificate entry</i>, the given certificate is compared to
* that entry's certificate. If the entry being considered is a <i>key entry</i>, the given
* certificate is compared to the first element of that entry's certificate chain (if a chain
* exists).
*
* @param cert the certificate to match with.
* @return the (alias) name of the first entry with matching certificate, or null if no such entry
* exists in this keystore.
*/
public String engineGetCertificateAlias(Certificate cert) {
permissionCheck();
Certificate certElem;
for (Enumeration<String> e = entries.keys(); e.hasMoreElements(); ) {
String alias = e.nextElement();
Object entry = entries.get(alias);
if (entry instanceof TrustedCertEntry) {
certElem = ((TrustedCertEntry) entry).cert;
} else {
KeyEntry ke = (KeyEntry) entry;
if (ke.chain == null || ke.chain.length == 0) {
continue;
}
certElem = ke.chain[0];
}
if (certElem.equals(cert)) {
return alias;
}
}
return null;
}
/**
* Stores this keystore to the given output stream, and protects its integrity with the given
* password.
*
* @param stream Ignored. the output stream to which this keystore is written.
* @param password the password to generate the keystore integrity check
* @exception IOException if there was an I/O problem with data
* @exception NoSuchAlgorithmException if the appropriate data integrity algorithm could not be
* found
* @exception CertificateException if any of the certificates included in the keystore data could
* not be stored
*/
public void engineStore(OutputStream stream, char[] password)
throws IOException, NoSuchAlgorithmException, CertificateException {
permissionCheck();
// Delete items that do have a keychain item ref.
for (Enumeration<String> e = deletedEntries.keys(); e.hasMoreElements(); ) {
String alias = e.nextElement();
Object entry = deletedEntries.get(alias);
if (entry instanceof TrustedCertEntry) {
if (((TrustedCertEntry) entry).certRef != 0) {
_removeItemFromKeychain(((TrustedCertEntry) entry).certRef);
_releaseKeychainItemRef(((TrustedCertEntry) entry).certRef);
}
} else {
Certificate certElem;
KeyEntry keyEntry = (KeyEntry) entry;
if (keyEntry.chain != null) {
for (int i = 0; i < keyEntry.chain.length; i++) {
if (keyEntry.chainRefs[i] != 0) {
_removeItemFromKeychain(keyEntry.chainRefs[i]);
_releaseKeychainItemRef(keyEntry.chainRefs[i]);
}
}
if (keyEntry.keyRef != 0) {
_removeItemFromKeychain(keyEntry.keyRef);
_releaseKeychainItemRef(keyEntry.keyRef);
}
}
}
}
// Add all of the certs or keys in the added entries.
// No need to check for 0 refs, as they are in the added list.
for (Enumeration<String> e = addedEntries.keys(); e.hasMoreElements(); ) {
String alias = e.nextElement();
Object entry = addedEntries.get(alias);
if (entry instanceof TrustedCertEntry) {
TrustedCertEntry tce = (TrustedCertEntry) entry;
Certificate certElem;
certElem = tce.cert;
tce.certRef = addCertificateToKeychain(alias, certElem);
} else {
KeyEntry keyEntry = (KeyEntry) entry;
if (keyEntry.chain != null) {
for (int i = 0; i < keyEntry.chain.length; i++) {
keyEntry.chainRefs[i] = addCertificateToKeychain(alias, keyEntry.chain[i]);
}
keyEntry.keyRef =
_addItemToKeychain(alias, false, keyEntry.protectedPrivKey, keyEntry.password);
}
}
}
// Clear the added and deletedEntries hashtables here, now that we're done with the updates.
// For the deleted entries, we freed up the native references above.
deletedEntries.clear();
addedEntries.clear();
}
