[Beepcore-java-commits] CVS: beepcore-java/tls/org/beepcore/beep/profile/tls/jsse TLSProfileJSSE.jav

Update of /cvsroot/beepcore-java/beepcore-java/tls/org/beepcore/beep/profile/tls/jsse
In directory sc8-pr-cvs1:/tmp/cvs-serv2246/tls/org/beepcore/beep/profile/tls/jsse

Modified Files:
      Tag: PIGGYBACKED
	TLSProfileJSSE.java 
Log Message:
Initial piggybacked changes

Index: TLSProfileJSSE.java
===================================================================
RCS file: /cvsroot/beepcore-java/beepcore-java/tls/org/beepcore/beep/profile/tls/jsse/TLSProfileJSSE.java,v
retrieving revision 1.8
retrieving revision 1.8.2.1
diff -C2 -r1.8 -r1.8.2.1
*** TLSProfileJSSE.java	3 Jun 2003 02:43:43 -0000	1.8
--- TLSProfileJSSE.java	13 Jul 2003 14:27:46 -0000	1.8.2.1
***************
*** 33,37 ****
--- 33,40 ----
  import java.security.KeyStore;
  
+ import java.io.BufferedReader;
  import java.io.FileInputStream;
+ import java.io.InputStreamReader;
+ import java.io.IOException;
  
  import org.apache.commons.logging.Log;
***************
*** 52,56 ****
   */
  public class TLSProfileJSSE extends TLSProfile
!         implements Profile, StartChannelListener {
  
      // Constants
--- 55,59 ----
   */
  public class TLSProfileJSSE extends TLSProfile
!         implements Profile, StartChannelListener, RequestHandler {
  
      // Constants
***************
*** 178,181 ****
--- 181,255 ----
      }
  
+     class BeepListenerHCL implements HandshakeCompletedListener {
+ 
+         Channel channel;
+         boolean notifiedHandshake = false;
+         boolean waitingForHandshake = false;
+         
+         BeepListenerHCL(Channel tuningChannel)
+         {
+             this.channel = tuningChannel;
+         }
+ 
+         public void handshakeCompleted(HandshakeCompletedEvent event)
+         {
+             Session oldSession = channel.getSession();
+             
+             log.debug("HandshakeCompleted");
+             synchronized (handshakeListeners) {
+                 Iterator i = TLSProfileJSSE.handshakeListeners.iterator();
+ 
+                 while (i.hasNext()) {
+                     TLSProfileJSSEHandshakeCompletedListener l =
+                         (TLSProfileJSSEHandshakeCompletedListener) i.next();
+ 
+                     if (l.handshakeCompleted(oldSession, event) == false) {
+                         BEEPError e =
+                             new BEEPError(BEEPError.CODE_REQUESTED_ACTION_ABORTED,
+                                           ERR_TLS_NO_AUTHENTICATION);
+                         TLSProfileJSSE.this.abort(e, channel);
+ 
+                         return;
+                     }
+                 }
+             }
+ 
+             Hashtable h = new Hashtable();
+ 
+             try {
+                 h.put(SessionCredential.AUTHENTICATOR,
+                       event.getPeerCertificateChain()[0].getSubjectDN().getName());
+                 h.put(SessionCredential.REMOTE_CERTIFICATE,
+                       event.getPeerCertificateChain());
+             } catch (SSLPeerUnverifiedException e) {
+                 h.put(SessionCredential.AUTHENTICATOR, "");
+                 h.put(SessionCredential.REMOTE_CERTIFICATE, "");
+             }
+ 
+             ProfileRegistry preg = oldSession.getProfileRegistry();
+ 
+             preg.removeStartChannelListener(uri);
+ 
+             Hashtable hash = new Hashtable();
+ 
+             hash.put(SessionTuningProperties.ENCRYPTION, "true");
+ 
+             SessionTuningProperties tuning =
+                 new SessionTuningProperties(hash);
+ 
+             // Cause the session to be recreated and reset
+             try {
+                 TLSProfileJSSE.this.complete(channel, generateCredential(),
+                                              new SessionCredential(h), tuning,
+                                              preg, event.getSocket());
+             } catch (BEEPException e) {
+                 BEEPError error =
+                     new BEEPError(BEEPError.CODE_REQUESTED_ACTION_ABORTED,
+                                   ERR_TLS_NO_AUTHENTICATION);
+                 TLSProfileJSSE.this.abort(error, channel);
+             }
+         }
+     }
+ 
      /**
       * TLS provides encryption and optionally authentication for a session
***************
*** 459,462 ****
--- 533,538 ----
              throws StartChannelException
      {
+         channel.setRequestHandler(this, true);
+ /*
          try {
              TCPSession oldSession = (TCPSession) channel.getSession();
***************
*** 533,538 ****
--- 609,670 ----
  
          throw new TuningResetException(uri);
+ */
      }
  
+     public void receiveMSG(MessageMSG msg)
+     {
+         Channel channel = msg.getChannel();
+ 
+         InputDataStreamAdapter is = msg.getDataStream().getInputStream();
+ 
+         BufferedReader reader = new BufferedReader(new InputStreamReader(is));
+ 
+         String data;
+ 
+         try {
+             try {
+                 data = reader.readLine();
+             } catch (IOException e) {
+                 msg.sendERR(BEEPError.CODE_PARAMETER_ERROR,
+                             "Error reading data");
+                 return;
+             }
+ 
+             if (data.equals(READY1) == false && data.equals(READY2) == false) {
+                 msg.sendERR(BEEPError.CODE_PARAMETER_INVALID,
+                             "Expected READY element");
+             }
+ 
+             this.begin(channel);
+ 
+             msg.sendRPY(new StringOutputDataStream(PROCEED2));
+         } catch (BEEPException e1) {
+             channel.getSession().terminate("unable to send ERR");
+             return;
+         }
+ 
+         try {
+             Socket oldSocket = ((TCPSession) channel.getSession()).getSocket();
+             /** @TODO add support for serverName */
+             SSLSocket newSocket =
+                 (SSLSocket) socketFactory.createSocket(oldSocket,
+                                                        oldSocket.getInetAddress().getHostName(),
+                                                        oldSocket.getPort(),
+                                                        true);
+ 
+             BeepListenerHCL l = new BeepListenerHCL(channel);
+ 
+             newSocket.addHandshakeCompletedListener(l);
+             newSocket.setUseClientMode(false);
+             newSocket.setNeedClientAuth(needClientAuth);
+             newSocket.setEnabledCipherSuites(newSocket.getSupportedCipherSuites());
+ 
+             newSocket.startHandshake();
+         } catch (IOException e) {
+             channel.getSession().terminate("TLS error: " + e.getMessage());
+             return;
+         }
+     }
+     
      /**
       * Called when the underlying BEEP framework receives