1 files changed, 231 insertions, 0 deletions
diff --git a/libjava/classpath/gnu/java/rmi/server/UnicastConnection.java b/libjava/classpath/gnu/java/rmi/server/UnicastConnection.java
new file mode 100644
index 000000000..8245e0469
--- /dev/null
+++ b/libjava/classpath/gnu/java/rmi/server/UnicastConnection.java
@@ -0,0 +1,231 @@
+/* UnicastConnection.java --
+   Copyright (c) 1996, 1997, 1998, 1999, 2002, 2004
+   Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.rmi.server;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.rmi.RemoteException;
+
+public class UnicastConnection
+        implements Runnable, ProtocolConstants {
+
+UnicastConnectionManager manager;
+Socket sock;
+DataInputStream din;
+DataOutputStream dout;
+ObjectInputStream oin;
+ObjectOutputStream oout;
+
+// reviveTime and expireTime make UnicastConnection pool-able
+long reviveTime = 0;
+long expireTime = Long.MAX_VALUE;
+
+UnicastConnection(UnicastConnectionManager man, Socket sock) {
+        this.manager = man;
+        this.sock = sock;
+}
+
+void acceptConnection() throws IOException {
+//System.out.println("Accepting connection on " + sock);
+    //Use BufferedXXXStream would be more efficient
+        din = new DataInputStream(new BufferedInputStream(sock.getInputStream()));
+        dout = new DataOutputStream(new BufferedOutputStream(sock.getOutputStream()));
+
+        int sig = din.readInt();
+        if (sig != PROTOCOL_HEADER) {
+                throw new IOException("bad protocol header");
+        }
+        short ver = din.readShort();
+        if (ver != PROTOCOL_VERSION) {
+                throw new IOException("bad protocol version");
+        }
+        int protocol = din.readUnsignedByte();
+        if (protocol != SINGLE_OP_PROTOCOL) {
+                // Send an ACK
+                dout.writeByte(PROTOCOL_ACK);
+
+                // Send my hostname and port
+                dout.writeUTF(manager.serverName);
+                dout.writeInt(manager.serverPort);
+                dout.flush();
+
+                // Read their hostname and port
+                String rhost = din.readUTF();
+                int rport = din.readInt();
+        }
+        // Okay, ready to roll ...
+}
+
+void makeConnection(int protocol) throws IOException {
+    //Use BufferedXXXStream would be more efficient
+        din = new DataInputStream(new BufferedInputStream(sock.getInputStream()));
+
+        dout = new DataOutputStream(new BufferedOutputStream(sock.getOutputStream()));
+
+        // Send header
+        dout.writeInt(PROTOCOL_HEADER);
+        dout.writeShort(PROTOCOL_VERSION);
+        dout.writeByte(protocol);
+    dout.flush();
+
+        if (protocol != SINGLE_OP_PROTOCOL) {
+                // Get back ack.
+                int ack = din.readUnsignedByte();
+                if (ack != PROTOCOL_ACK) {
+                        throw new RemoteException("Unsupported protocol");
+                }
+
+                // Read in host and port
+                String dicard_rhost = din.readUTF();
+                int discard_rport = din.readInt();
+
+                // Send them my endpoint
+                dout.writeUTF(manager.serverName);
+                dout.writeInt(manager.serverPort);
+                dout.flush();
+        }
+        // Okay, ready to roll ...
+}
+
+DataInputStream getDataInputStream() throws IOException {
+        return (din);
+}
+
+DataOutputStream getDataOutputStream() throws IOException {
+        return (dout);
+}
+
+/*
+*
+* get ObjectInputStream for reading more objects
+*
+*/
+ObjectInputStream getObjectInputStream() throws IOException {
+        if (oin == null) {
+                throw new IOException("no ObjectInputtream for reading more objects");
+        }
+        return (oin);
+}
+
+/**
+*
+* starts ObjectInputStream.
+*
+*/
+ObjectInputStream startObjectInputStream() throws IOException {
+        return (oin = new RMIObjectInputStream(din));
+}
+
+/**
+*
+* get ObjectOutputStream for sending more objects
+*
+*/
+ObjectOutputStream getObjectOutputStream() throws IOException {
+        if (oout == null) {
+                throw new IOException("no ObjectOutputStream for sending more objects");
+        }
+        return (oout);
+}
+
+/**
+*
+* starts ObjectOutputStream.
+*
+*/
+ObjectOutputStream startObjectOutputStream() throws IOException {
+        return (oout = new RMIObjectOutputStream(dout));
+}
+
+void disconnect() {
+        try {
+            if(oout != null)
+                oout.close();
+        sock.close();
+        }
+        catch (IOException _) {
+    }
+
+        oin = null;
+    oout = null;
+        din = null;
+        dout = null;
+        sock = null;
+}
+
+public static final long CONNECTION_TIMEOUT = 10000L;
+
+static boolean isExpired(UnicastConnection conn, long l){
+    if (l <= conn.expireTime )
+        return false;
+    return true;
+}
+
+static void resetTime(UnicastConnection conn){
+    long l = System.currentTimeMillis();
+    conn.reviveTime = l;
+    conn.expireTime = l + CONNECTION_TIMEOUT;
+}
+
+/**
+ * We run connects on the server. Dispatch it then discard it.
+ */
+public void run() {
+    do{
+        try {
+                UnicastServer.dispatch(this);
+            //don't discardConnection explicitly, only when
+            //  exception happens or the connection's expireTime
+            //  comes
+        } catch (Exception e ){
+                manager.discardConnection(this);
+            break;
+        }
+    }while(true);
+}
+
+
+}