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/TCPTransport.class

Java Class File | 1997-07-08 | 10.5 KB | 454 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.net.BindException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.rmi.RemoteException;
import java.rmi.server.ExportException;
import java.rmi.server.LogStream;
import java.rmi.server.ObjID;
import java.rmi.server.RMIFailureHandler;
import java.rmi.server.RMISocketFactory;
import java.rmi.server.SocketSecurityException;
import java.rmi.server.UID;
import java.util.Enumeration;
import java.util.Hashtable;
import sun.applet.AppletSecurityException;
import sun.rmi.transport.Channel;
import sun.rmi.transport.Connection;
import sun.rmi.transport.DGCAckHandler;
import sun.rmi.transport.Endpoint;
import sun.rmi.transport.RMIThread;
import sun.rmi.transport.StreamRemoteCall;
import sun.rmi.transport.Target;
import sun.rmi.transport.Transport;
import sun.rmi.transport.Utils;
import sun.rmi.transport.proxy.RMIMasterSocketFactory;

public class TCPTransport extends Transport implements Runnable {
   static int logLevel = LogStream.parseLevel(Utils.getProperty("sun.rmi.transport.tcp.logLevel"));
   static int DefaultPort;
   private boolean listenNotAllowed;
   private boolean exportNotAllowed;
   private static int threadNum;
   private static Hashtable clientConnections = new Hashtable(37);
   private TCPEndpoint endpoint;
   private ServerSocket server;
   private Hashtable channelTable;
   static RMISocketFactory defaultSocketFactory = new RMIMasterSocketFactory();

   TCPTransport() {
      this(0);
   }

   TCPTransport(int var1) {
      this.listenNotAllowed = false;
      this.exportNotAllowed = false;
      this.channelTable = new Hashtable();
      if (logLevel >= 10) {
         LogStream.log("tcp").println("TCPTransport.<init>: Version = " + 2 + ", port = " + var1);
      }

      this.endpoint = TCPEndpoint.getLocalEndpoint(var1);
   }

   public Channel getChannel(Endpoint var1) {
      Object var2 = null;
      if (var1 instanceof TCPEndpoint) {
         Hashtable var3 = this.channelTable;
         synchronized(var3) {
            var2 = (Channel)this.channelTable.get(var1);
            if (var2 == null) {
               var2 = new TCPChannel(this, (TCPEndpoint)var1);
               if (this.listenNotAllowed && !this.exportNotAllowed) {
                  try {
                     ((TCPChannel)var2).haveMultiplexer();
                  } catch (RemoteException var12) {
                     RemoteException var5 = var12;
                     if (logLevel >= 10) {
                        LogStream var6 = LogStream.log("tcp");
                        synchronized(var6){}

                        try {
                           ((PrintStream)var6).print("TCPTransport(" + this.endpoint.getPort() + ").getChannel: " + "failed to have multiplexed connection " + "on channel, exception: ");
                           ((Throwable)var5).printStackTrace(var6);
                        } catch (Throwable var11) {
                           throw var11;
                        }
                     }

                     this.exportNotAllowed = true;
                  }
               }

               this.channelTable.put(var1, var2);
            }
         }
      }

      return (Channel)var2;
   }

   public Endpoint thisEndpoint() {
      return this.endpoint;
   }

   public void exportObject(ObjID var1, Target var2) throws RemoteException {
      if (this.exportNotAllowed) {
         throw new ExportException("Cannot export to server outside firewall");
      } else {
         super.exportObject(var1, var2);
         if (!this.listenNotAllowed || !this.endpoint.equals(TCPEndpoint.getLocalEndpoint(0))) {
            try {
               this.listen();
            } catch (SocketSecurityException var17) {
               SocketSecurityException var3 = var17;
               if (logLevel >= 10) {
                  LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").exportObject: " + "listen failed with exception " + ((Throwable)var17).toString());
               }

               if (this.endpoint.getPort() != 0) {
                  throw var17;
               } else {
                  Hashtable var4 = this.channelTable;
                  synchronized(var4) {
                     this.listenNotAllowed = true;
                     Enumeration var6 = this.channelTable.elements();

                     while(var6.hasMoreElements()) {
                        TCPChannel var7 = (TCPChannel)var6.nextElement();

                        try {
                           var7.haveMultiplexer();
                        } catch (RemoteException var15) {
                           if (logLevel >= 10) {
                              LogStream var8 = LogStream.log("tcp");
                              synchronized(var8){}

                              try {
                                 ((PrintStream)var8).print("TCPTransport(" + this.endpoint.getPort() + ").exportObject: " + "failed to have multiplexed connection " + "on channel, exception: ");
                                 ((Throwable)var3).printStackTrace(var8);
                              } catch (Throwable var14) {
                                 throw var14;
                              }
                           }

                           this.exportNotAllowed = true;
                           throw new ExportException("Cannot export to server outside firewall");
                        }
                     }

                     System.out.println("\n*** RMI unable to listen on socket: using multiplexed connections instead ***\n");
                  }

               }
            }
         }
      }
   }

   private synchronized void listen() throws RemoteException {
      if (this.server == null) {
         int var1 = this.endpoint.getPort();
         if (logLevel >= 10) {
            LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").listen: " + "create socket, port = " + var1);
         }

         try {
            try {
               RMISocketFactory var2 = RMISocketFactory.getSocketFactory();
               if (Utils.getLong("sun.rmi.transport.tcp.simulateApplet", 0L).intValue() >= 2) {
                  throw new AppletSecurityException("socket.listen");
               }

               this.server = (var2 != null ? var2 : defaultSocketFactory).createServerSocket(var1);
            } catch (IOException var3) {
               if (!this.retryServerSocket()) {
                  throw var3;
               }
            }

            if (DefaultPort == 0 && var1 == 0) {
               DefaultPort = this.server.getLocalPort();
               if (logLevel >= 10) {
                  LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").listen: " + "default port set to " + DefaultPort);
               }

               TCPEndpoint.setDefaultPort(DefaultPort);
            }

            this.newListener();
         } catch (SecurityException var4) {
            throw new SocketSecurityException("Listen disallowed on port: " + var1, var4);
         } catch (BindException var5) {
            throw new ExportException("Port already in use: " + var1, var5);
         } catch (IOException var6) {
            throw new ExportException("Listen failed on port: " + var1, var6);
         }
      }
   }

   private void newListener() {
      Thread var1 = RMIThread.newThread(this, "TCP Accept-" + ++threadNum, true);
      var1.start();
   }

   private synchronized boolean retryServerSocket() {
      int var1 = this.endpoint.getPort();

      while(true) {
         try {
            RMISocketFactory var2 = RMISocketFactory.getSocketFactory();
            this.server = (var2 != null ? var2 : defaultSocketFactory).createServerSocket(var1);
            return true;
         } catch (IOException var4) {
            RMIFailureHandler var3 = RMISocketFactory.getFailureHandler();
            if (var3 == null || !var3.failure(var4)) {
               this.server = null;
               return false;
            }
         }
      }
   }

   public void run() {
      if (logLevel >= 10) {
         LogStream.log("tcp").println("TCPTransport.run: listening on port " + this.endpoint.getPort());
      }

      while(true) {
         ServerSocket var2 = this.server;
         if (var2 == null) {
            return;
         }

         Object var3 = null;

         Socket var1;
         try {
            var1 = var2.accept();
         } catch (IOException var56) {
            var3 = var56;
            continue;
         } catch (RuntimeException var57) {
            var3 = var57;
            continue;
         } catch (Error var58) {
            var3 = var58;
            continue;
         } finally {
            if (var3 != null) {
               try {
                  this.server.close();
               } catch (IOException var51) {
               }

               if (!(var3 instanceof IOException) && !(var3 instanceof NoClassDefFoundError)) {
                  if (var3 instanceof RuntimeException) {
                     throw (RuntimeException)var3;
                  }

                  throw (Error)var3;
               }

               if (!this.retryServerSocket()) {
                  return;
               }
            }

         }

         try {
            var1.setTcpNoDelay(true);
         } catch (Exception var53) {
         }

         this.newListener();

         try {
            InputStream var4 = var1.getInputStream();
            DataInputStream var60 = new DataInputStream(var4);
            OutputStream var6 = var1.getOutputStream();
            DataOutputStream var7 = new DataOutputStream(var6);
            int var8 = var60.readInt();
            short var9 = var60.readShort();
            if (var8 == 1246907721 && var9 == 2) {
               InetAddress var10 = var1.getInetAddress();
               String var11 = var10 != null ? var10.getHostName() : "";
               if (logLevel >= 10) {
                  LogStream.log("tcp").println("TCPTransport.run: accepted socket from [" + var11 + ":" + var1.getPort() + "]");
               }

               byte var15 = var60.readByte();
               switch (var15) {
                  case 75:
                     var7.writeByte(78);
                     var7.flush();
                     TCPEndpoint var63 = new TCPEndpoint(var11, var1.getPort());
                     if (logLevel >= 20) {
                        LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").run: " + "suggesting endpoint " + var63);
                     }

                     var63.write(var7);
                     var7.flush();
                     var63 = TCPEndpoint.read(var60);
                     if (logLevel >= 20) {
                        LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").run: " + "using endpoint " + var63);
                     }

                     var63 = new TCPEndpoint(var11, var1.getLocalPort());
                     TCPChannel var67 = new TCPChannel(this, var63);
                     TCPConnection var68 = new TCPConnection(var67, var1);
                     this.handleMessages(var68, true);
                     return;
                  case 76:
                     TCPEndpoint var62 = new TCPEndpoint(var11, var1.getLocalPort());
                     TCPChannel var66 = new TCPChannel(this, var62);
                     TCPConnection var14 = new TCPConnection(var66, var1);
                     this.handleMessages(var14, false);
                     return;
                  case 77:
                     if (logLevel >= 20) {
                        LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").run: " + "accepting multiplex protocol");
                     }

                     var7.writeByte(78);
                     TCPEndpoint var12 = new TCPEndpoint(var11, var1.getPort());
                     if (logLevel >= 20) {
                        LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").run: " + "suggesting endpoint " + var12);
                     }

                     var12.write(var7);
                     var7.flush();
                     var12 = TCPEndpoint.read(var60);
                     if (logLevel >= 20) {
                        LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").run: " + "using endpoint " + var12);
                     }

                     Hashtable var17 = this.channelTable;
                     synchronized(var17){}

                     ConnectionMultiplexer var16;
                     try {
                        TCPChannel var13 = (TCPChannel)this.getChannel(var12);
                        var16 = new ConnectionMultiplexer(var13, var4, var6, false);
                        var13.useMultiplexer(var16);
                     } catch (Throwable var52) {
                        throw var52;
                     }

                     var16.run();
                     return;
                  default:
                     var7.writeByte(79);
                     var7.flush();
                     return;
               }
            }

            closeSocket(var1);
         } catch (IOException var54) {
            if (logLevel >= 10) {
               LogStream var5 = LogStream.log("tcp");
               ((PrintStream)var5).println("TCPTransport.run: terminated with exception: ");
               ((Throwable)var54).printStackTrace(var5);
            }

            return;
         } finally {
            closeSocket(var1);
         }

         return;
      }
   }

   private static void closeSocket(Socket var0) {
      try {
         var0.close();
      } catch (IOException var1) {
      }
   }

   void handleMessages(Connection var1, boolean var2) {
      Thread var3 = Thread.currentThread();
      clientConnections.put(var3, var1);

      try {
         do {
            DataInputStream var6 = new DataInputStream(var1.getInputStream());
            byte var18 = var6.readByte();
            if (logLevel >= 10) {
               LogStream.log("tcp").println("TCPTransport(" + this.endpoint.getPort() + ").handleMessages: op = " + var18);
            }

            switch (var18) {
               case 80:
                  StreamRemoteCall var8 = new StreamRemoteCall(var1);
                  if (!((Transport)this).serviceCall(var8)) {
                     return;
                  }
                  break;
               case 82:
                  DataOutputStream var9 = new DataOutputStream(var1.getOutputStream());
                  var9.writeByte(83);
                  var1.releaseOutputStream();
                  break;
               case 84:
                  DGCAckHandler.received(UID.read(var6));
                  break;
               default:
                  throw new IOException("unknown transport op " + var18);
            }
         } while(var2);

      } catch (IOException var16) {
         if (logLevel >= 10) {
            LogStream var7 = LogStream.log("tcp");
            ((PrintStream)var7).println("TCPTransport(" + this.endpoint.getPort() + ").handleMessages: exception: ");
            ((Throwable)var16).printStackTrace(var7);
         }

      } finally {
         clientConnections.remove(var3);

         try {
            var1.close();
         } catch (IOException var15) {
         }

      }
   }

   public static Channel getCurrentChannel() {
      Thread var0 = Thread.currentThread();
      Object var1 = clientConnections.get(var0);
      if (var1 != null && var1 instanceof Connection) {
         Channel var2 = ((Connection)var1).getChannel();
         return var2;
      } else {
         return null;
      }
   }

   void ping() {
      Enumeration var1 = this.channelTable.elements();

      while(var1.hasMoreElements()) {
         TCPChannel var2 = (TCPChannel)var1.nextElement();
         if (var2.ping() == 1) {
            Endpoint var3 = var2.getEndpoint();
            this.channelTable.remove(var3);
         }
      }

   }
}