Symantec Visual Cafe for Java 2.5/symantec-visual-cafe-2.5-database-dev-edition.iso/VPage/Java.bin/CLASSES.ZIP/sun/rmi/transport/tcp/ConnectionMultiplexer.class

Java Class File | 1997-07-08 | 7.8 KB | 399 lines

package sun.rmi.transport.tcp;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.rmi.server.LogStream;
import java.util.Enumeration;
import java.util.Hashtable;
import sun.rmi.transport.Utils;

final class ConnectionMultiplexer {
   static int logLevel = LogStream.parseLevel(Utils.getProperty("sun.rmi.transport.tcp.multiplex.logLevel"));
   private static final int OPEN = 225;
   private static final int CLOSE = 226;
   private static final int CLOSEACK = 227;
   private static final int REQUEST = 228;
   private static final int TRANSMIT = 229;
   private TCPChannel channel;
   // $FF: renamed from: in java.io.InputStream
   private InputStream field_0;
   private OutputStream out;
   private boolean orig;
   private DataInputStream dataIn;
   private DataOutputStream dataOut;
   private Hashtable connectionTable = new Hashtable(7);
   private int numConnections;
   private static final int maxConnections = 256;
   private int lastID = 4097;
   private boolean alive = true;

   public ConnectionMultiplexer(TCPChannel var1, InputStream var2, OutputStream var3, boolean var4) {
      this.channel = var1;
      this.field_0 = var2;
      this.out = var3;
      this.orig = var4;
      this.dataIn = new DataInputStream(var2);
      this.dataOut = new DataOutputStream(var3);
   }

   public void run() throws IOException {
      try {
         while(true) {
            int var3 = this.dataIn.readUnsignedByte();
            switch (var3) {
               case 225:
                  int var33 = this.dataIn.readUnsignedShort();
                  if (logLevel >= 20) {
                     LogStream.log("multiplex").println("ConnectionMultiplexer.run: operation  OPEN " + var33);
                  }

                  Integer var38 = new Integer(var33);
                  MultiplexConnectionInfo var42 = (MultiplexConnectionInfo)this.connectionTable.get(var38);
                  if (var42 != null) {
                     throw new IOException("OPEN: Connection ID already exists");
                  }

                  var42 = new MultiplexConnectionInfo(var33);
                  var42.in = new MultiplexInputStream(this, var42, 2048);
                  var42.out = new MultiplexOutputStream(this, var42, 2048);
                  Hashtable var8 = this.connectionTable;
                  synchronized(var8){}

                  try {
                     this.connectionTable.put(var38, var42);
                     ++this.numConnections;
                  } catch (Throwable var28) {
                     throw var28;
                  }

                  TCPConnection var44 = new TCPConnection(this.channel, var42.in, var42.out);
                  this.channel.acceptMultiplexConnection(var44);
                  break;
               case 226:
                  int var32 = this.dataIn.readUnsignedShort();
                  if (logLevel >= 20) {
                     LogStream.log("multiplex").println("ConnectionMultiplexer.run: operation  CLOSE " + var32);
                  }

                  Integer var37 = new Integer(var32);
                  MultiplexConnectionInfo var41 = (MultiplexConnectionInfo)this.connectionTable.get(var37);
                  if (var41 == null) {
                     throw new IOException("CLOSE: Invalid connection ID");
                  }

                  var41.in.disconnect();
                  var41.out.disconnect();
                  if (!var41.closed) {
                     this.sendCloseAck(var41);
                  }

                  Hashtable var45 = this.connectionTable;
                  synchronized(var45){}

                  try {
                     this.connectionTable.remove(var37);
                     --this.numConnections;
                     break;
                  } catch (Throwable var27) {
                     throw var27;
                  }
               case 227:
                  int var31 = this.dataIn.readUnsignedShort();
                  if (logLevel >= 20) {
                     LogStream.log("multiplex").println("ConnectionMultiplexer.run: operation  CLOSEACK " + var31);
                  }

                  Integer var36 = new Integer(var31);
                  MultiplexConnectionInfo var40 = (MultiplexConnectionInfo)this.connectionTable.get(var36);
                  if (var40 == null) {
                     throw new IOException("CLOSEACK: Invalid connection ID");
                  }

                  if (!var40.closed) {
                     throw new IOException("CLOSEACK: Connection not closed");
                  }

                  var40.in.disconnect();
                  var40.out.disconnect();
                  Hashtable var9 = this.connectionTable;
                  synchronized(var9){}

                  try {
                     this.connectionTable.remove(var36);
                     --this.numConnections;
                     break;
                  } catch (Throwable var26) {
                     throw var26;
                  }
               case 228:
                  int var30 = this.dataIn.readUnsignedShort();
                  Integer var35 = new Integer(var30);
                  MultiplexConnectionInfo var39 = (MultiplexConnectionInfo)this.connectionTable.get(var35);
                  if (var39 == null) {
                     throw new IOException("REQUEST: Invalid connection ID");
                  }

                  int var34 = this.dataIn.readInt();
                  if (logLevel >= 20) {
                     LogStream.log("multiplex").println("ConnectionMultiplexer.run: operation  REQUEST " + var30 + ": " + var34);
                  }

                  var39.out.request(var34);
                  break;
               case 229:
                  int var4 = this.dataIn.readUnsignedShort();
                  Integer var6 = new Integer(var4);
                  MultiplexConnectionInfo var7 = (MultiplexConnectionInfo)this.connectionTable.get(var6);
                  if (var7 == null) {
                     throw new IOException("SEND: Invalid connection ID");
                  }

                  int var5 = this.dataIn.readInt();
                  if (logLevel >= 20) {
                     LogStream.log("multiplex").println("ConnectionMultiplexer.run: operation  TRANSMIT " + var4 + ": " + var5);
                  }

                  var7.in.receive(var5, this.dataIn);
                  break;
               default:
                  throw new IOException("Invalid operation: " + Integer.toHexString(var3));
            }
         }
      } finally {
         this.shutDown();
      }
   }

   public synchronized TCPConnection openConnection() throws IOException {
      int var1;
      Integer var2;
      do {
         this.lastID = ++this.lastID & 32767;
         var1 = this.lastID;
         if (this.orig) {
            var1 |= 32768;
         }

         var2 = new Integer(var1);
      } while(this.connectionTable.get(var2) != null);

      MultiplexConnectionInfo var3 = new MultiplexConnectionInfo(var1);
      var3.in = new MultiplexInputStream(this, var3, 2048);
      var3.out = new MultiplexOutputStream(this, var3, 2048);
      Hashtable var4 = this.connectionTable;
      synchronized(var4){}

      try {
         if (!this.alive) {
            throw new IOException("Multiplexer connection dead");
         }

         if (this.numConnections >= 256) {
            throw new IOException("Cannot exceed " + 256 + " simultaneous multiplexed connections");
         }

         this.connectionTable.put(var2, var3);
         ++this.numConnections;
      } catch (Throwable var20) {
         throw var20;
      }

      DataOutputStream var21 = this.dataOut;
      synchronized(var21) {
         try {
            this.dataOut.writeByte(225);
            this.dataOut.writeShort(var1);
            this.dataOut.flush();
         } catch (IOException var18) {
            IOException var6 = var18;
            if (logLevel >= 10) {
               LogStream var7 = LogStream.log("multiplex");
               synchronized(var7){}

               try {
                  ((PrintStream)var7).println("ConnectionMultiplexer.openConnection: exception: ");
                  ((Throwable)var6).printStackTrace(var7);
               } catch (Throwable var17) {
                  throw var17;
               }
            }

            this.shutDown();
            throw var18;
         }
      }

      return new TCPConnection(this.channel, var3.in, var3.out);
   }

   public void shutDown() {
      Hashtable var1 = this.connectionTable;
      synchronized(var1){}

      try {
         if (!this.alive) {
            return;
         }

         this.alive = false;
         Enumeration var3 = this.connectionTable.elements();

         while(var3.hasMoreElements()) {
            MultiplexConnectionInfo var4 = (MultiplexConnectionInfo)var3.nextElement();
            var4.in.disconnect();
            var4.out.disconnect();
         }

         this.connectionTable.clear();
         this.numConnections = 0;
      } catch (Throwable var10) {
         throw var10;
      }

      try {
         this.field_0.close();
      } catch (IOException var9) {
      }

      try {
         this.out.close();
      } catch (IOException var8) {
      }
   }

   void sendRequest(MultiplexConnectionInfo var1, int var2) throws IOException {
      DataOutputStream var3 = this.dataOut;
      synchronized(var3) {
         if (this.alive && !var1.closed) {
            try {
               this.dataOut.writeByte(228);
               this.dataOut.writeShort(var1.id);
               this.dataOut.writeInt(var2);
               this.dataOut.flush();
            } catch (IOException var12) {
               IOException var5 = var12;
               if (logLevel >= 10) {
                  LogStream var6 = LogStream.log("multiplex");
                  synchronized(var6){}

                  try {
                     ((PrintStream)var6).println("ConnectionMultiplexer.sendRequest: exception: ");
                     ((Throwable)var5).printStackTrace(var6);
                  } catch (Throwable var11) {
                     throw var11;
                  }
               }

               this.shutDown();
               throw var12;
            }
         }
      }

   }

   void sendTransmit(MultiplexConnectionInfo var1, byte[] var2, int var3, int var4) throws IOException {
      DataOutputStream var5 = this.dataOut;
      synchronized(var5) {
         if (this.alive && !var1.closed) {
            try {
               this.dataOut.writeByte(229);
               this.dataOut.writeShort(var1.id);
               this.dataOut.writeInt(var4);
               this.dataOut.write(var2, var3, var4);
               this.dataOut.flush();
            } catch (IOException var14) {
               IOException var7 = var14;
               if (logLevel >= 10) {
                  LogStream var8 = LogStream.log("multiplex");
                  synchronized(var8){}

                  try {
                     ((PrintStream)var8).println("ConnectionMultiplexer.sendTransmit: exception: ");
                     ((Throwable)var7).printStackTrace(var8);
                  } catch (Throwable var13) {
                     throw var13;
                  }
               }

               this.shutDown();
               throw var14;
            }
         }
      }

   }

   void sendClose(MultiplexConnectionInfo var1) throws IOException {
      var1.out.disconnect();
      DataOutputStream var2 = this.dataOut;
      synchronized(var2) {
         if (this.alive && !var1.closed) {
            try {
               this.dataOut.writeByte(226);
               this.dataOut.writeShort(var1.id);
               this.dataOut.flush();
               var1.closed = true;
            } catch (IOException var11) {
               IOException var4 = var11;
               if (logLevel >= 10) {
                  LogStream var5 = LogStream.log("multiplex");
                  synchronized(var5){}

                  try {
                     ((PrintStream)var5).println("ConnectionMultiplexer.sendClose: exception: ");
                     ((Throwable)var4).printStackTrace(var5);
                  } catch (Throwable var10) {
                     throw var10;
                  }
               }

               this.shutDown();
               throw var11;
            }
         }
      }

   }

   void sendCloseAck(MultiplexConnectionInfo var1) throws IOException {
      DataOutputStream var2 = this.dataOut;
      synchronized(var2) {
         if (this.alive && !var1.closed) {
            try {
               this.dataOut.writeByte(227);
               this.dataOut.writeShort(var1.id);
               this.dataOut.flush();
               var1.closed = true;
            } catch (IOException var11) {
               IOException var4 = var11;
               if (logLevel >= 10) {
                  LogStream var5 = LogStream.log("multiplex");
                  synchronized(var5){}

                  try {
                     ((PrintStream)var5).println("ConnectionMultiplexer.sendCloseAck: exception: ");
                     ((Throwable)var4).printStackTrace(var5);
                  } catch (Throwable var10) {
                     throw var10;
                  }
               }

               this.shutDown();
               throw var11;
            }
         }
      }

   }

   protected void finalize() throws Throwable {
      super.finalize();
      this.shutDown();
   }
}