jdk-sandbox: comparison jdk/src/share/classes/sun/security/ssl/SSLSessionImpl.java

equal deleted inserted replaced

-:49b7de969579
+:e71aa0962e70
 */
 package sun.security.ssl;
-import java.io.*;
 import java.net.*;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Vector;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.ArrayList;
 import java.security.cert.X509Certificate;
 import java.security.cert.CertificateEncodingException;
 import javax.crypto.SecretKey;
-import javax.net.ssl.SSLSession;
 import javax.net.ssl.SSLSessionContext;
 import javax.net.ssl.SSLSessionBindingListener;
 import javax.net.ssl.SSLSessionBindingEvent;
 import javax.net.ssl.SSLPeerUnverifiedException;
-import javax.net.ssl.SSLSession;
 import javax.net.ssl.SSLPermission;
-import javax.net.ssl.SSLException;
 import javax.net.ssl.ExtendedSSLSession;
 import javax.net.ssl.SNIServerName;
-import javax.security.auth.x500.X500Principal;
-import static sun.security.ssl.CipherSuite.*;
 import static sun.security.ssl.CipherSuite.KeyExchange.*;
 /**
 * Implements the SSL session interface, and exposes the session context
 * which is maintained by SSL servers.
 boolean isRejoinable() {
 return sessionId != null && sessionId.length() != 0 &&
 !invalidated && isLocalAuthenticationValid();
 }
+@Override
 public synchronized boolean isValid() {
 return isRejoinable();
 }
 /**
 /**
 * Returns the ID for this session.  The ID is fixed for the
 * duration of the session; neither it, nor its value, changes.
 */
+@Override
 public byte[] getId() {
 return sessionId.getId();
 }
 /**
 * For server sessions, this returns the set of sessions which
 * are currently valid in this process.  For client sessions,
 * this returns null.
 */
+@Override
 public SSLSessionContext getSessionContext() {
 /*
 * An interim security policy until we can do something
 * more specific in 1.2. Only allow trusted code (code which
 * can set system properties) to get an
 }
 /**
 * Returns the name of the cipher suite in use on this session
 */
+@Override
 public String getCipherSuite() {
 return getSuite().name;
 }
 ProtocolVersion getProtocolVersion() {
 }
 /**
 * Returns the standard name of the protocol in use on this session
 */
+@Override
 public String getProtocol() {
 return getProtocolVersion().name;
 }
 /**
 }
 /**
 * Returns the hashcode for this session
 */
+@Override
 public int hashCode() {
 return sessionId.hashCode();
 }
 /**
 * Returns true if sessions have same ids, false otherwise.
 */
+@Override
 public boolean equals(Object obj) {
 if (obj == this) {
 return true;
 }
 * such as Kerberos, will throw an SSLPeerUnverifiedException.
 *
 * @return array of peer X.509 certs, with the peer's own cert
 *  first in the chain, and with the "root" CA last.
 */
+@Override
 public java.security.cert.Certificate[] getPeerCertificates()
 throws SSLPeerUnverifiedException {
 //
 // clone to preserve integrity of session ... caller can't
 // change record of peer identity even by accident, much
 * cipher suites.
 *
 * @return array of peer X.509 certs, with the peer's own cert
 *  first in the chain, and with the "root" CA last.
 */
+@Override
 public java.security.cert.Certificate[] getLocalCertificates() {
 //
 // clone to preserve integrity of session ... caller can't
 // change record of peer identity even by accident, much
 // less do it intentionally.
 * such as Kerberos, will throw an SSLPeerUnverifiedException.
 *
 * @return array of peer X.509 certs, with the peer's own cert
 *  first in the chain, and with the "root" CA last.
 */
+@Override
 public javax.security.cert.X509Certificate[] getPeerCertificateChain()
 throws SSLPeerUnverifiedException {
 //
 // clone to preserve integrity of session ... caller can't
 // change record of peer identity even by accident, much
 * Principal for Kerberos cipher suites.
 *
 * @throws SSLPeerUnverifiedException if the peer's identity has not
 *          been verified
 */
+@Override
 public Principal getPeerPrincipal()
 throws SSLPeerUnverifiedException
 {
 if ((cipherSuite.keyExchange == K_KRB5) ||
 (cipherSuite.keyExchange == K_KRB5_EXPORT)) {
 * @return the principal sent to the peer. Returns an X500Principal
 * of the end-entity certificate for X509-based cipher suites, and
 * Principal for Kerberos cipher suites. If no principal was
 * sent, then null is returned.
 */
+@Override
 public Principal getLocalPrincipal() {
 if ((cipherSuite.keyExchange == K_KRB5) ||
 (cipherSuite.keyExchange == K_KRB5_EXPORT)) {
 // Eliminate dependency on KerberosPrincipal
 }
 /**
 * Returns the time this session was created.
 */
+@Override
 public long getCreationTime() {
 return creationTime;
 }
 /**
 * Returns the last time this session was used to initialize
 * a connection.
 */
+@Override
 public long getLastAccessedTime() {
 return (lastUsedTime != 0) ? lastUsedTime : creationTime;
 }
 void setLastAccessedTime(long time) {
 } catch (java.net.UnknownHostException e) {
 return null;
 }
 }
+@Override
 public String getPeerHost() {
 return host;
 }
 /**
 * Need to provide the port info for caching sessions based on
 * host and port. Accessed by SSLSessionContextImpl
 */
+@Override
 public int getPeerPort() {
 return port;
 }
 void setContext(SSLSessionContextImpl ctx) {
 /**
 * Invalidate a session.  Active connections may still exist, but
 * no connections will be able to rejoin this session.
 */
+@Override
 synchronized public void invalidate() {
 //
 // Can't invalidate the NULL session -- this would be
 // attempted when we get a handshaking error on a brand
 // new connection, with no "real" session yet.
 /**
 * Assigns a session value.  Session change events are given if
 * appropriate, to any original value as well as the new value.
 */
+@Override
 public void putValue(String key, Object value) {
 if ((key == null) || (value == null)) {
 throw new IllegalArgumentException("arguments can not be null");
 }
 /**
 * Returns the specified session value.
 */
+@Override
 public Object getValue(String key) {
 if (key == null) {
 throw new IllegalArgumentException("argument can not be null");
 }
 /**
 * Removes the specified session value, delivering a session changed
 * event as appropriate.
 */
+@Override
 public void removeValue(String key) {
 if (key == null) {
 throw new IllegalArgumentException("argument can not be null");
 }
 /**
 * Lists the names of the session values.
 */
+@Override
 public String[] getValueNames() {
 Enumeration<SecureKey> e;
 Vector<Object> v = new Vector<>();
 SecureKey key;
 Object securityCtx = SecureKey.getCurrentSecurityContext();
 /**
 * Gets the current size of the largest SSL/TLS packet that is expected
 * when using this session.
 */
+@Override
 public synchronized int getPacketBufferSize() {
 return acceptLargeFragments ?
 Record.maxLargeRecordSize : Record.maxRecordSize;
 }
 /**
 * Gets the current size of the largest application data that is
 * expected when using this session.
 */
+@Override
 public synchronized int getApplicationBufferSize() {
 return getPacketBufferSize() - Record.headerSize;
 }
 /**
 return Collections.<SNIServerName>emptyList();
 }
 /** Returns a string representation of this SSL session */
+@Override
 public String toString() {
 return "[Session-" + sessionCount
 + ", " + getCipherSuite()
 + "]";
 }
 /**
 * When SSL sessions are finalized, all values bound to
 * them are removed.
 */
+@Override
 public void finalize() {
 String[] names = getValueNames();
 for (int i = 0; i < names.length; i++) {
 removeValue(names[i]);
 }
 Object getSecurityContext() {
 return securityCtx;
 }
+@Override
 public int hashCode() {
 return appKey.hashCode() ^ securityCtx.hashCode();
 }
+@Override
 public boolean equals(Object o) {
 return o instanceof SecureKey && ((SecureKey)o).appKey.equals(appKey)
 && ((SecureKey)o).securityCtx.equals(securityCtx);
 }
 }

changeset 14664	e71aa0962e70
parent 14194	971f46db533d
child 17458	4252f06a378f