jdk-sandbox: comparison jdk/src/share/classes/sun/security/pkcs11/P11KeyStore.java

equal deleted inserted replaced

-:3c7eda3ab2f5
+:0bb1999251f8
 /*
-* Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2011, 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
 import java.io.IOException;
 import java.io.ByteArrayInputStream;
 import java.io.UnsupportedEncodingException;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.Enumeration;
-import java.util.Iterator;
-import java.util.List;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.HashMap;
 import java.util.Set;
 import java.security.*;
 import java.security.KeyStore.*;
-import java.security.cert.CertPath;
 import java.security.cert.Certificate;
 import java.security.cert.X509Certificate;
 import java.security.cert.CertificateFactory;
 import java.security.cert.CertificateException;
 import java.security.spec.*;
 import javax.crypto.SecretKey;
 import javax.crypto.interfaces.*;
-import javax.security.auth.Subject;
 import javax.security.auth.x500.X500Principal;
 import javax.security.auth.login.LoginException;
 import javax.security.auth.callback.Callback;
 import javax.security.auth.callback.PasswordCallback;
 import javax.security.auth.callback.CallbackHandler;
 import javax.security.auth.callback.UnsupportedCallbackException;
 import sun.security.util.Debug;
-import sun.security.x509.SerialNumber;
 import sun.security.util.DerValue;
 import sun.security.ec.ECParameters;
 import sun.security.pkcs11.Secmod.*;
 private char[] password;
 private PasswordCallbackHandler(char[] password) {
 if (password != null) {
-this.password = (char[])password.clone();
+this.password = password.clone();
 }
 }
 public void handle(Callback[] callbacks)
 throws IOException, UnsupportedCallbackException {
 }
 }
 // did not find anything
 return null;
-} catch (PKCS11Exception pe) {
+} catch (PKCS11Exception | KeyStoreException e) {
-throw new ProviderException(pe);
+throw new ProviderException(e);
-} catch (KeyStoreException ke) {
-throw new ProviderException(ke);
 } finally {
 token.releaseSession(session);
 }
 }
 if (key instanceof PrivateKey) {
 entry = new KeyStore.PrivateKeyEntry((PrivateKey)key, chain);
 } else if (key instanceof SecretKey) {
 entry = new KeyStore.SecretKeyEntry((SecretKey)key);
 }
-} catch (NullPointerException npe) {
+} catch (NullPointerException | IllegalArgumentException e) {
-throw new KeyStoreException(npe);
+throw new KeyStoreException(e);
-} catch (IllegalArgumentException iae) {
-throw new KeyStoreException(iae);
 }
 engineSetEntry(alias, entry, new KeyStore.PasswordProtection(password));
 }
 /**
 // secret key entry
 return destroySkey(alias);
 } else {
 throw new KeyStoreException("unexpected entry type");
 }
-} catch (PKCS11Exception pe) {
+} catch (PKCS11Exception | CertificateException e) {
-throw new KeyStoreException(pe);
+throw new KeyStoreException(e);
-} catch (CertificateException ce) {
-throw new KeyStoreException(ce);
 }
 }
 return false;
 }
 writeDisabled = true;
 }
 if (debug != null) {
 dumpTokenMap();
 }
-} catch (LoginException le) {
+} catch (LoginException | KeyStoreException | PKCS11Exception e) {
-IOException ioe = new IOException("load failed");
+throw new IOException("load failed", e);
-ioe.initCause(le);
-throw ioe;
-} catch (KeyStoreException kse) {
-IOException ioe = new IOException("load failed");
-ioe.initCause(kse);
-throw ioe;
-} catch (PKCS11Exception pe) {
-IOException ioe = new IOException("load failed");
-ioe.initCause(pe);
-throw ioe;
 }
 }
 /**
 * Loads the keystore using the given
 writeDisabled = true;
 }
 if (debug != null) {
 dumpTokenMap();
 }
-} catch (LoginException e) {
+} catch (LoginException | KeyStoreException | PKCS11Exception e) {
-throw new IOException("load failed", e);
-} catch (KeyStoreException e) {
-throw new IOException("load failed", e);
-} catch (PKCS11Exception e) {
 throw new IOException("load failed", e);
 }
 }
 private void login(CallbackHandler handler) throws LoginException {
 }
 try {
 storeCert(alias, xcert);
 module.setTrust(token, xcert);
 mapLabels();
-} catch (PKCS11Exception e) {
+} catch (PKCS11Exception | CertificateException e) {
-throw new KeyStoreException(e);
-} catch (CertificateException e) {
 throw new KeyStoreException(e);
 }
 } else {
 // caller adding new entry
 engineDeleteEntry(alias);
 storePkey(alias, (KeyStore.PrivateKeyEntry)entry);
 }
-} catch (PKCS11Exception pe) {
+} catch (PKCS11Exception | CertificateException pe) {
 throw new KeyStoreException(pe);
-} catch (CertificateException ce) {
-throw new KeyStoreException(ce);
 }
 } else if (entry instanceof KeyStore.SecretKeyEntry) {
 KeyStore.SecretKeyEntry ske = (KeyStore.SecretKeyEntry)entry;
 mapLabels();
 if (debug != null) {
 dumpTokenMap();
 }
-} catch (PKCS11Exception pe) {
+} catch (PKCS11Exception | CertificateException pe) {
 throw new KeyStoreException(pe);
-} catch (CertificateException ce) {
-throw new KeyStoreException(ce);
 }
 }
 if (debug != null) {
 debug.println
 if (debug != null) {
 debug.println("creating RSAPrivateKey attrs");
 }
-RSAPrivateKey rsaKey = (RSAPrivateKey)key;
+RSAPrivateKey rsaKey = key;
 attrs = new CK_ATTRIBUTE[] {
 ATTR_TOKEN_TRUE,
 ATTR_CLASS_PKEY,
 ATTR_PRIVATE_TRUE,
 }
 private void dumpTokenMap() {
 Set<String> aliases = aliasMap.keySet();
 System.out.println("Token Alias Map:");
-if (aliases.size() == 0) {
+if (aliases.isEmpty()) {
 System.out.println("  [empty]");
 } else {
 for (String s : aliases) {
 System.out.println("  " + s + aliasMap.get(s));
 }

changeset 10336	0bb1999251f8
parent 5506	202f599c92aa
child 17491	7a33824ec8c5