libjava/gnu/java/rmi/server/UnicastRemoteCall.java

   1 /* UnicastRemoteCall.java
   2   Copyright (c) 1996, 1997, 1998, 1999, 2002 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package gnu.java.rmi.server;
  39
  40 import java.lang.Exception;
  41 import java.io.DataInputStream;
  42 import java.io.DataOutputStream;
  43 import java.io.IOException;
  44 import java.io.ObjectOutput;
  45 import java.io.ObjectInput;
  46 import java.io.StreamCorruptedException;
  47 import java.rmi.server.RemoteCall;
  48 import java.rmi.RemoteException;
  49 import java.rmi.MarshalException;
  50 import java.rmi.UnmarshalException;
  51 import java.rmi.server.UID;
  52 import java.rmi.server.ObjID;
  53 import java.rmi.server.RemoteObject;
  54
  55 import java.util.Vector;
  56
  57 public class UnicastRemoteCall
  58         implements RemoteCall, ProtocolConstants
  59 {
  60
  61   private UnicastConnection conn;
  62   private Object result;
  63   private Object object;
  64   private int opnum;
  65   private long hash;
  66   private Vector vec;
  67   private int ptr;
  68   private ObjID objid;
  69
  70   private ObjectOutput oout;
  71   private ObjectInput oin;
  72
  73   /**
  74    * Incoming call.
  75    */
  76   UnicastRemoteCall(UnicastConnection conn)
  77   {
  78     this.conn = conn;
  79   }
  80
  81   /**
  82    * Outgoing call.
  83    */
  84   UnicastRemoteCall(UnicastConnection conn, ObjID objid, int opnum, long hash)
  85     throws RemoteException
  86   {
  87     this.conn = conn;
  88     this.opnum = opnum;
  89     this.hash = hash;
  90     this.objid = objid;
  91   }
  92
  93   UnicastConnection getConnection()
  94   {
  95     return conn;
  96   }
  97
  98   public ObjectOutput getOutputStream() throws IOException
  99   {
 100     if (vec == null)
 101       vec = new Vector();
 102     return (new DummyObjectOutputStream());
 103   }
 104
 105   public void releaseOutputStream() throws IOException
 106   {
 107     if (vec != null)
 108       {
 109         oout = conn.getObjectOutputStream();
 110
 111         for (int i = 0; i < vec.size(); i += 2)
 112           {
 113             boolean primitive = ((Boolean)vec.elementAt(i)).booleanValue();
 114             Object data = vec.elementAt(i+1);
 115
 116             // No type, this is
 117             if (!primitive)
 118               oout.writeObject(data);
 119             else
 120               {
 121                 if (data instanceof Boolean)
 122                   oout.writeBoolean(((Boolean)data).booleanValue());
 123                 else if (data instanceof Character)
 124                   oout.writeChar(((Character)data).charValue());
 125                 else if (data instanceof Byte)
 126                   oout.writeByte(((Byte)data).byteValue());
 127                 else if (data instanceof Short)
 128                   oout.writeShort(((Short)data).shortValue());
 129                 else if (data instanceof Integer)
 130                   oout.writeInt(((Integer)data).intValue());
 131                 else if (data instanceof Long)
 132                   oout.writeLong(((Long)data).longValue());
 133               }
 134           }
 135         vec = null;
 136       }
 137     if(oout != null)
 138       oout.flush();
 139   }
 140
 141   public ObjectInput getInputStream() throws IOException
 142   {
 143     if (conn != null)
 144       {
 145         if(oin == null)
 146           return (oin = conn.getObjectInputStream());
 147         else
 148           return oin;
 149       }
 150     else
 151       {
 152         ptr = 0;
 153         return (new DummyObjectInputStream());
 154       }
 155   }
 156
 157   public void releaseInputStream() throws IOException
 158   {
 159     // Does nothing.
 160   }
 161
 162   public ObjectOutput getResultStream(boolean success)
 163     throws IOException, StreamCorruptedException
 164   {
 165     vec = new Vector();
 166     return new DummyObjectOutputStream();
 167   }
 168
 169   public void executeCall() throws Exception
 170   {
 171     byte returncode;
 172     ObjectInput oin;
 173
 174     // signal the call when constructing
 175     try
 176       {
 177         DataOutputStream dout = conn.getDataOutputStream();
 178         dout.write(MESSAGE_CALL);
 179
 180         oout = conn.getObjectOutputStream();
 181         objid.write(oout);
 182         oout.writeInt(opnum);
 183         oout.writeLong(hash);
 184       }
 185     catch(IOException ex)
 186       {
 187         throw new MarshalException("Try to write header but failed.", ex);
 188       }
 189
 190     try
 191       {
 192         releaseOutputStream();
 193         DataInputStream din = conn.getDataInputStream();
 194         if (din.readByte() != MESSAGE_CALL_ACK)
 195             throw new RemoteException("Call not acked");
 196
 197         oin = getInputStream();
 198         returncode = oin.readByte();
 199         UID.read(oin);
 200       }
 201     catch(IOException ex)
 202       {
 203         throw new UnmarshalException("Try to read header but failed:", ex);
 204       }
 205
 206     //check return code
 207     switch(returncode)
 208       {
 209       case RETURN_ACK: //it's ok
 210         return;
 211       case RETURN_NACK:
 212         Object returnobj;
 213         try
 214           {
 215             returnobj = oin.readObject();
 216           }
 217         catch(Exception ex2)
 218           {
 219             throw new UnmarshalException
 220               ("Try to read exception object but failed", ex2);
 221           }
 222
 223         if(!(returnobj instanceof Exception))
 224           throw new UnmarshalException("Should be Exception type here: "
 225                                        + returnobj);
 226         throw (Exception)returnobj;
 227
 228       default:
 229         throw new UnmarshalException("Invalid return code");
 230       }
 231   }
 232
 233   public void done() throws IOException
 234   {
 235     // conn.disconnect();
 236   }
 237
 238   boolean isReturnValue()
 239   {
 240     return vec.size() > 0;
 241   }
 242
 243   Object returnValue()
 244   {
 245     // This is not the first one (Boolean) but the second.
 246     return vec.elementAt(1);
 247   }
 248
 249   Object[] getArguments()
 250   {
 251     return vec.toArray();
 252   }
 253
 254   Object getObject()
 255   {
 256     return object;
 257   }
 258
 259   int getOpnum()
 260   {
 261     return opnum;
 262   }
 263
 264   long getHash()
 265   {
 266     return hash;
 267   }
 268
 269   void setReturnValue(Object obj)
 270   {
 271     vec.removeAllElements();
 272     vec.addElement(obj);
 273   }
 274
 275   /**
 276    * Dummy object output class.
 277    */
 278   private class DummyObjectOutputStream implements ObjectOutput
 279   {
 280     /**
 281      * Non-private constructor to reduce bytecode emitted.
 282      */
 283     DummyObjectOutputStream()
 284     {
 285     }
 286
 287     public void writeBoolean(boolean v) throws IOException
 288     {
 289       vec.addElement(Boolean.TRUE);
 290       vec.addElement(Boolean.valueOf(v));
 291     }
 292
 293     public void writeByte(int v) throws IOException
 294     {
 295       vec.addElement(Boolean.TRUE);
 296       vec.addElement(new Byte((byte) v));
 297     }
 298
 299     public void writeChar(int v) throws IOException
 300     {
 301       vec.addElement(Boolean.TRUE);
 302       vec.addElement(new Character((char) v));
 303     }
 304
 305     public void writeDouble(double v) throws IOException
 306     {
 307       vec.addElement(Boolean.TRUE);
 308       vec.addElement(new Double(v));
 309     }
 310
 311     public void writeFloat(float v) throws IOException
 312     {
 313       vec.addElement(Boolean.TRUE);
 314       vec.addElement(new Float(v));
 315     }
 316
 317     public void writeInt(int v) throws IOException
 318     {
 319       vec.addElement(Boolean.TRUE);
 320       vec.addElement(new Integer(v));
 321     }
 322
 323     public void writeLong(long v) throws IOException
 324     {
 325       vec.addElement(Boolean.TRUE);
 326       vec.addElement(new Long(v));
 327     }
 328
 329     public void writeShort(int v) throws IOException
 330     {
 331       vec.addElement(Boolean.TRUE);
 332       vec.addElement(new Short((short) v));
 333     }
 334
 335     public void writeObject(Object obj) throws IOException
 336     {
 337       vec.addElement(Boolean.FALSE);
 338       vec.addElement(obj);
 339     }
 340
 341     public void write(byte b[]) throws IOException
 342     {
 343       throw new IOException("not required");
 344     }
 345
 346     public void write(byte b[], int off, int len) throws IOException
 347     {
 348       throw new IOException("not required");
 349     }
 350
 351     public void write(int b) throws IOException
 352     {
 353       throw new IOException("not required");
 354     }
 355
 356     public void writeBytes(String s) throws IOException
 357     {
 358       throw new IOException("not required");
 359     }
 360
 361     public void writeChars(String s) throws IOException
 362     {
 363       throw new IOException("not required");
 364     }
 365
 366     public void writeUTF(String str) throws IOException
 367     {
 368       throw new IOException("not required");
 369     }
 370
 371     public void flush() throws IOException
 372     {
 373     }
 374
 375     public void close() throws IOException
 376     {
 377     }
 378   } // class DummyObjectOutputStream
 379
 380   /**
 381    * Dummy object input class.
 382    */
 383   private class DummyObjectInputStream implements ObjectInput
 384   {
 385     /**
 386      * Non-private constructor to reduce bytecode emitted.
 387      */
 388     DummyObjectInputStream()
 389     {
 390     }
 391
 392     public boolean readBoolean() throws IOException
 393     {
 394       Object obj = vec.elementAt(ptr++);
 395       return ((Boolean) obj).booleanValue();
 396     }
 397
 398     public byte readByte() throws IOException
 399     {
 400       Object obj = vec.elementAt(ptr++);
 401       return ((Byte) obj).byteValue();
 402     }
 403
 404     public char readChar() throws IOException
 405     {
 406       Object obj = vec.elementAt(ptr++);
 407       return ((Character) obj).charValue();
 408     }
 409
 410     public double readDouble() throws IOException
 411     {
 412       Object obj = vec.elementAt(ptr++);
 413       return ((Double) obj).doubleValue();
 414     }
 415
 416     public float readFloat() throws IOException
 417     {
 418       Object obj = vec.elementAt(ptr++);
 419       return ((Float) obj).floatValue();
 420     }
 421
 422     public int readInt() throws IOException
 423     {
 424       Object obj = vec.elementAt(ptr++);
 425       return ((Integer) obj).intValue();
 426     }
 427
 428     public long readLong() throws IOException
 429     {
 430       Object obj = vec.elementAt(ptr++);
 431       return ((Long) obj).longValue();
 432     }
 433
 434     public short readShort() throws IOException
 435     {
 436       Object obj = vec.elementAt(ptr++);
 437       return ((Short) obj).shortValue();
 438     }
 439
 440     public Object readObject() throws IOException
 441     {
 442       return vec.elementAt(ptr++);
 443     }
 444
 445     public int read(byte b[]) throws IOException
 446     {
 447       throw new IOException("not required");
 448     }
 449
 450     public int read(byte b[], int off, int len) throws IOException
 451     {
 452       throw new IOException("not required");
 453     }
 454
 455     public int read() throws IOException
 456     {
 457       throw new IOException("not required");
 458     }
 459
 460     public long skip(long n) throws IOException
 461     {
 462       throw new IOException("not required");
 463     }
 464
 465     public int available() throws IOException
 466     {
 467       throw new IOException("not required");
 468     }
 469
 470     public void readFully(byte b[]) throws IOException
 471     {
 472       throw new IOException("not required");
 473     }
 474
 475     public void readFully(byte b[], int off, int len) throws IOException
 476     {
 477       throw new IOException("not required");
 478     }
 479
 480     public String readLine() throws IOException
 481     {
 482       throw new IOException("not required");
 483     }
 484
 485     public String readUTF() throws IOException
 486     {
 487       throw new IOException("not required");
 488     }
 489
 490     public int readUnsignedByte() throws IOException
 491     {
 492       throw new IOException("not required");
 493     }
 494
 495     public int readUnsignedShort() throws IOException
 496     {
 497       throw new IOException("not required");
 498     }
 499
 500     public int skipBytes(int n) throws IOException
 501     {
 502       throw new IOException("not required");
 503     }
 504
 505     public void close() throws IOException
 506     {
 507     }
 508   } // class DummyObjectInputStream
 509
 510 }