Re: Tunnel Profile - Again

diff -Naur beepcore-0.9.07/src/org/beepcore/beep/core/Session.java beepcore-0.9.07-tunnel/src/org/beepcore/beep/core/Session.java
--- beepcore-0.9.07/src/org/beepcore/beep/core/Session.java	Wed Apr 30 22:17:51 2003
+++ beepcore-0.9.07-tunnel/src/org/beepcore/beep/core/Session.java	Wed Apr 30 22:18:49 2003
@@ -1381,6 +1381,16 @@
                     String data = null;
                     Node dataNode = profile.getFirstChild();
 
+
+		    // added by RKF 04.14.2003 for compatibility w/RoadRunner
+		    // Essentially, the parser is turning a "\n" into a node.
+		    // The fix is to just skip over that extra node.
+		    if ((dataNode != null) && 
+			(dataNode.getNodeType() != 
+			 Node.CDATA_SECTION_NODE)) {
+			dataNode = dataNode.getNextSibling();
+		    }
+		    
                     if (dataNode != null) {
                         data = dataNode.getNodeValue();
 
@@ -1981,4 +1991,19 @@
                          "no longer active.");
         }
     }
+
+    /**
+     * Kill off all the listeners for this session.
+     * Used for preventing beepcore from processing messages on the session.
+     * This functionality is necessary for the Tunnel profile.
+     *
+     * Added by RKF (Will)
+     */
+    public void killAllListeners() {
+	channelListeners = null;
+	sessionListeners = null;
+	sessionListenerList = null;
+	channelListenerList = null;
+	channels = null;
+    }
 }
diff -Naur beepcore-0.9.07/src/org/beepcore/beep/transport/tcp/TCPSession.java beepcore-0.9.07-tunnel/src/org/beepcore/beep/transport/tcp/TCPSession.java
--- beepcore-0.9.07/src/org/beepcore/beep/transport/tcp/TCPSession.java	Wed Apr 30 22:17:51 2003
+++ beepcore-0.9.07-tunnel/src/org/beepcore/beep/transport/tcp/TCPSession.java	Wed Apr 30 22:18:49 2003
@@ -83,6 +83,27 @@
     private Thread thread;
 
     /**
+     * When Set to true, the processnext frame thread spins rather than blocks.
+     *
+     * spinIO true means use the ugly hack in processnextframe that allows
+     * a tunnel to work, since we can't kill the thread processing the
+     * next frame.
+     * ADDED by Tunnel Team 
+     */
+    private boolean spinIO = false;
+    
+    /**
+     * Whether to process the next frame.
+     *
+     * Tunnel proxies do not want to process the next frame when proxying
+     * and thus set this to false.
+     * 
+     * ADDED by Tunnel Team 
+     */
+     private boolean doProcessNextFrame = true;
+
+
+    /**
      * @param sock the Socket for this TCPConnection
      *
      * @registry the ProfileRegistry (set of profiles) to be used on
@@ -204,6 +225,35 @@
             socket = null;
         }
     }
+    /** 
+     * Terminate the session for a tunnel proxy.
+     * ADDED by Tunnel Team 
+     */
+    public void TunTerminate() {
+	// Disable IO (this should stop threads, but I don't believe it does)
+	disableIO();
+	
+	// Stop the next frame from being processed
+	doProcessNextFrame = false;
+	
+	// Kill all the message listeners
+	super.killAllListeners();
+
+	// Release the socket (it should later be garbage collected when
+	// it's not pointed to.
+	socket = null;
+    }
+
+    /** 
+     * Sets spinIO to true, causing ProcessNextFrame to spin rather than
+     * block.
+     * Set to true before using a tunnel proxy that recieved a non-piggybacked
+     * message.
+     * *ADDED by Tunnel Team *
+     */
+    public void setSpinIO(boolean spin) {
+	spinIO = spin;
+    }
 
     // Implementation of method declared in Session
     protected void disableIO()
@@ -231,7 +281,10 @@
                     }
                 };
 
-            thread.setDaemon(true);
+	    // *ADDED by Tunnel Team *
+	    // Why does this need to be a daemon, other than to keep it 
+	    // alive after the server is killed?
+	    //	    thread.setDaemon(true);
             thread.start();
         }
     }
@@ -421,7 +474,9 @@
         try {
             InputStream is = socket.getInputStream();
 
-            while (running) {
+	    // *CHANGED by Tunnel Team *
+	    // If we are set to process the next frame, and running, do so
+            while (running && doProcessNextFrame) {
                 if (Log.isLogged(Log.SEV_DEBUG_VERBOSE)) {
                     Log.logEntry(Log.SEV_DEBUG_VERBOSE, TCP_MAPPING,
                                  "Processing next frame");
@@ -430,8 +485,31 @@
                 int amountRead;
 
                 try {
-                    do {
-                        amountRead =
+		    // *CHANGED by Tunnel Team *
+		    // We need to use nonblocking reads so that the thread
+		    // can be killed before it has read the data off of the
+		    // socket. It would be annoying to use something like a
+		    // buffered inputstream, because a tunnel needs the socket
+		    // in addition to the streams, and you can't create a 
+		    // socket to use a buffered input stream by default.       
+		    do {
+			// this is quite possibly the nastiest hack ever,
+			// it is the worst way to do this, but is necessary 
+			// so that this thread can be killed before
+			// it reads data that will be passed to the tunnel.
+			if(spinIO){
+			    while(is.available() == 0) {
+				Thread.sleep(50);
+			    }
+			}
+			
+			// if we're not supposed to process the next frame
+			// then return
+			if(!doProcessNextFrame) {
+			    return;
+			}
+
+			amountRead =
                             is.read(headerBuffer, 0, MIN_SEQ_HEADER_SIZE);
 
                         if (amountRead == -1) {