| /* 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); |
| } |
| |
| |
| } |