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

equal deleted inserted replaced

-:1fa861caf840
+:2ee9017c7597
 * @see javax.net.ssl.SSLSocket
 * @see SSLServerSocket
 *
 * @author David Brownell
 */
-final public class SSLSocketImpl extends BaseSSLSocketImpl {
+public final class SSLSocketImpl extends BaseSSLSocketImpl {
 /*
 * ERROR HANDLING GUIDELINES
 * (which exceptions to throw and catch and which not to throw and catch)
 *
 * The readLock ensures that these three steps are done atomically
 * and that once started, no other thread can block on SSLInputRecord.read.
 * This is necessary so that processing of close_notify alerts
 * from the peer are handled properly.
 */
-final private Object        handshakeLock = new Object();
+private final Object        handshakeLock = new Object();
 final ReentrantLock         writeLock = new ReentrantLock();
-final private Object        readLock = new Object();
+private final Object        readLock = new Object();
 InputRecord                 inputRecord;
 OutputRecord                outputRecord;
 /*
 * to defaults and the appropriate kind of handshaker set up.
 */
 initHandshaker();
 }
-synchronized private int getConnectionState() {
+private synchronized int getConnectionState() {
 return connectionState;
 }
-synchronized private void setConnectionState(int state) {
+private synchronized void setConnectionState(int state) {
 connectionState = state;
 }
 AccessControlContext getAcc() {
 return acc;
 * @param resumable indicates the caller process is resumable from the
 *          exception. If <code>resumable</code>, the socket will be
 *          reserved for exceptions like timeout; otherwise, the socket
 *          will be closed, no further communications could be done.
 */
-synchronized private void handleException(Exception e, boolean resumable)
+private synchronized void handleException(Exception e, boolean resumable)
 throws IOException {
 if ((debug != null) && Debug.isOn("ssl")) {
 System.out.println(Thread.currentThread().getName() +
 ", handling exception: " + e.toString());
 }
 // ONLY used by HttpsClient to setup the URI specified hostname
 //
 // Please NOTE that this method MUST be called before calling to
 // SSLSocket.setSSLParameters(). Otherwise, the {@code host} parameter
 // may override SNIHostName in the customized server name indication.
-synchronized public void setHost(String host) {
+public synchronized void setHost(String host) {
 this.host = host;
 this.serverNames =
 Utilities.addToSNIServerNameList(this.serverNames, this.host);
 }
 * Gets an input stream to read from the peer on the other side.
 * Data read from this stream was always integrity protected in
 * transit, and will usually have been confidentiality protected.
 */
 @Override
-synchronized public InputStream getInputStream() throws IOException {
+public synchronized InputStream getInputStream() throws IOException {
 if (isClosed()) {
 throw new SocketException("Socket is closed");
 }
 /*
 * Gets an output stream to write to the peer on the other side.
 * Data written on this stream is always integrity protected, and
 * will usually be confidentiality protected.
 */
 @Override
-synchronized public OutputStream getOutputStream() throws IOException {
+public synchronized OutputStream getOutputStream() throws IOException {
 if (isClosed()) {
 throw new SocketException("Socket is closed");
 }
 /*
 return sess;
 }
 }
 @Override
-synchronized public SSLSession getHandshakeSession() {
+public synchronized SSLSession getHandshakeSession() {
 return handshakeSession;
 }
 synchronized void setHandshakeSession(SSLSessionImpl session) {
 // update the fragment size, which may be negotiated during handshaking
 * As long as handshaking has not started, we can change
 * whether we enable session creations.  Otherwise,
 * we will need to wait for the next handshake.
 */
 @Override
-synchronized public void setEnableSessionCreation(boolean flag) {
+public synchronized void setEnableSessionCreation(boolean flag) {
 enableSessionCreation = flag;
 if ((handshaker != null) && !handshaker.activated()) {
 handshaker.setEnableSessionCreation(enableSessionCreation);
 }
 /**
 * Returns true if new connections may cause creation of new SSL
 * sessions.
 */
 @Override
-synchronized public boolean getEnableSessionCreation() {
+public synchronized boolean getEnableSessionCreation() {
 return enableSessionCreation;
 }
 /**
 * As long as handshaking has not started, we can change
 * whether client authentication is needed.  Otherwise,
 * we will need to wait for the next handshake.
 */
 @Override
-synchronized public void setNeedClientAuth(boolean flag) {
+public synchronized void setNeedClientAuth(boolean flag) {
 doClientAuth = (flag ? ClientAuthType.CLIENT_AUTH_REQUIRED :
 ClientAuthType.CLIENT_AUTH_NONE);
 if ((handshaker != null) &&
 (handshaker instanceof ServerHandshaker) &&
 ((ServerHandshaker) handshaker).setClientAuth(doClientAuth);
 }
 }
 @Override
-synchronized public boolean getNeedClientAuth() {
+public synchronized boolean getNeedClientAuth() {
 return (doClientAuth == ClientAuthType.CLIENT_AUTH_REQUIRED);
 }
 /**
 * Sets the flag controlling whether a server mode socket
 * As long as handshaking has not started, we can change
 * whether client authentication is requested.  Otherwise,
 * we will need to wait for the next handshake.
 */
 @Override
-synchronized public void setWantClientAuth(boolean flag) {
+public synchronized void setWantClientAuth(boolean flag) {
 doClientAuth = (flag ? ClientAuthType.CLIENT_AUTH_REQUESTED :
 ClientAuthType.CLIENT_AUTH_NONE);
 if ((handshaker != null) &&
 (handshaker instanceof ServerHandshaker) &&
 ((ServerHandshaker) handshaker).setClientAuth(doClientAuth);
 }
 }
 @Override
-synchronized public boolean getWantClientAuth() {
+public synchronized boolean getWantClientAuth() {
 return (doClientAuth == ClientAuthType.CLIENT_AUTH_REQUESTED);
 }
 /**
 * client or server mode.  Must be called before any SSL
 * traffic has started.
 */
 @Override
 @SuppressWarnings("fallthrough")
-synchronized public void setUseClientMode(boolean flag) {
+public synchronized void setUseClientMode(boolean flag) {
 switch (connectionState) {
 case cs_START:
 /*
 * If we need to change the socket mode and the enabled
 "Cannot change mode after SSL traffic has started");
 }
 }
 @Override
-synchronized public boolean getUseClientMode() {
+public synchronized boolean getUseClientMode() {
 return !roleIsServer;
 }
 /**
 * requisite certificates (and private keys) are not available.
 *
 * @param suites Names of all the cipher suites to enable.
 */
 @Override
-synchronized public void setEnabledCipherSuites(String[] suites) {
+public synchronized void setEnabledCipherSuites(String[] suites) {
 enabledCipherSuites = new CipherSuiteList(suites);
 if ((handshaker != null) && !handshaker.activated()) {
 handshaker.setEnabledCipherSuites(enabledCipherSuites);
 }
 }
 * might be empty.
 *
 * @return an array of cipher suite names
 */
 @Override
-synchronized public String[] getEnabledCipherSuites() {
+public synchronized String[] getEnabledCipherSuites() {
 return enabledCipherSuites.toStringArray();
 }
 /**
 * @param protocols protocols to enable.
 * @exception IllegalArgumentException when one of the protocols
 *  named by the parameter is not supported.
 */
 @Override
-synchronized public void setEnabledProtocols(String[] protocols) {
+public synchronized void setEnabledProtocols(String[] protocols) {
 enabledProtocols = new ProtocolList(protocols);
 if ((handshaker != null) && !handshaker.activated()) {
 handshaker.setEnabledProtocols(enabledProtocols);
 }
 }
 @Override
-synchronized public String[] getEnabledProtocols() {
+public synchronized String[] getEnabledProtocols() {
 return enabledProtocols.toStringArray();
 }
 /**
 * Assigns the socket timeout.
 /**
 * Returns the SSLParameters in effect for this SSLSocket.
 */
 @Override
-synchronized public SSLParameters getSSLParameters() {
+public synchronized SSLParameters getSSLParameters() {
 SSLParameters params = super.getSSLParameters();
 // the super implementation does not handle the following parameters
 params.setEndpointIdentificationAlgorithm(identificationProtocol);
 params.setAlgorithmConstraints(algorithmConstraints);
 /**
 * Applies SSLParameters to this socket.
 */
 @Override
-synchronized public void setSSLParameters(SSLParameters params) {
+public synchronized void setSSLParameters(SSLParameters params) {
 super.setSSLParameters(params);
 // the super implementation does not handle the following parameters
 identificationProtocol = params.getEndpointIdentificationAlgorithm();
 algorithmConstraints = params.getAlgorithmConstraints();

changeset 32649	2ee9017c7597
parent 31918	1f13aceb00d7
child 32834	e1dca5fe4de3