home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / sun / rmi / server / UnicastServerRef.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  10.2 KB  |  408 lines
  1. package sun.rmi.server;
  2.  
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.io.ObjectInput;
  7. import java.io.ObjectOutput;
  8. import java.io.PrintStream;
  9. import java.lang.ref.SoftReference;
  10. import java.lang.reflect.InvocationTargetException;
  11. import java.lang.reflect.Method;
  12. import java.rmi.MarshalException;
  13. import java.rmi.Remote;
  14. import java.rmi.RemoteException;
  15. import java.rmi.ServerError;
  16. import java.rmi.ServerException;
  17. import java.rmi.UnmarshalException;
  18. import java.rmi.server.LogStream;
  19. import java.rmi.server.RemoteCall;
  20. import java.rmi.server.RemoteRef;
  21. import java.rmi.server.RemoteServer;
  22. import java.rmi.server.RemoteStub;
  23. import java.rmi.server.ServerNotActiveException;
  24. import java.rmi.server.ServerRef;
  25. import java.rmi.server.Skeleton;
  26. import java.rmi.server.SkeletonNotFoundException;
  27. import java.security.AccessController;
  28. import java.security.DigestOutputStream;
  29. import java.security.MessageDigest;
  30. import java.security.NoSuchAlgorithmException;
  31. import java.util.Collections;
  32. import java.util.Date;
  33. import java.util.HashMap;
  34. import java.util.Map;
  35. import java.util.WeakHashMap;
  36. import sun.rmi.transport.LiveRef;
  37. import sun.rmi.transport.Target;
  38. import sun.rmi.transport.tcp.TCPTransport;
  39. import sun.security.action.GetBooleanAction;
  40.  
  41. public class UnicastServerRef extends UnicastRef implements ServerRef, Dispatcher {
  42.    private static final long serialVersionUID = -7384275867073752268L;
  43.    private static final boolean wantExceptionLog = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.rmi.server.exceptionTrace"));
  44.    private transient Skeleton skel;
  45.    private transient Map methodTable = null;
  46.    private static Map methodTableCache = new WeakHashMap(11);
  47.    private static Map withoutSkeletons = Collections.synchronizedMap(new WeakHashMap(11));
  48.    // $FF: synthetic field
  49.    static Class class$java$rmi$Remote;
  50.  
  51.    public UnicastServerRef() {
  52.    }
  53.  
  54.    public UnicastServerRef(LiveRef var1) {
  55.       super(var1);
  56.    }
  57.  
  58.    public UnicastServerRef(int var1) {
  59.       super(new LiveRef(var1));
  60.    }
  61.  
  62.    public RemoteStub exportObject(Remote var1, Object var2) throws RemoteException {
  63.       return this.exportObject(var1, var2, false);
  64.    }
  65.  
  66.    public RemoteStub exportObject(Remote var1, Object var2, boolean var3) throws RemoteException {
  67.       RemoteStub var4 = this.setSkeleton(var1);
  68.       Target var5 = new Target(var1, this, var4, super.ref.getObjID(), var3);
  69.       super.ref.exportObject(var5);
  70.       this.methodTable = getMethodTable(var1.getClass());
  71.       return var4;
  72.    }
  73.  
  74.    public String getClientHost() throws ServerNotActiveException {
  75.       return TCPTransport.getClientHost();
  76.    }
  77.  
  78.    public RemoteStub setSkeleton(Remote var1) throws RemoteException {
  79.       if (!withoutSkeletons.containsKey(var1.getClass())) {
  80.          try {
  81.             this.skel = RemoteProxy.getSkeleton(var1);
  82.          } catch (SkeletonNotFoundException var3) {
  83.             withoutSkeletons.put(var1.getClass(), (Object)null);
  84.          }
  85.       }
  86.  
  87.       return RemoteProxy.getStub(var1, this.getClientRef());
  88.    }
  89.  
  90.    public void dispatch(Remote var1, RemoteCall var2) throws IOException {
  91.       try {
  92.          long var4;
  93.          ObjectInput var41;
  94.          try {
  95.             var41 = var2.getInputStream();
  96.             int var3 = var41.readInt();
  97.             if (var3 >= 0) {
  98.                if (this.skel != null) {
  99.                   this.oldDispatch(var1, var2, var3);
  100.                   return;
  101.                }
  102.  
  103.                throw new UnmarshalException("skeleton class not found but required for client version");
  104.             }
  105.  
  106.             var4 = var41.readLong();
  107.          } catch (Exception var38) {
  108.             throw new UnmarshalException("error unmarshalling call header", var38);
  109.          }
  110.  
  111.          MarshalInputStream var42 = (MarshalInputStream)var41;
  112.          var42.skipDefaultResolveClass();
  113.          Method var8 = (Method)this.methodTable.get(new Long(var4));
  114.          if (var8 == null) {
  115.             throw new UnmarshalException("invalid method hash");
  116.          } else {
  117.             this.logCall(var1, var8);
  118.             Class[] var9 = var8.getParameterTypes();
  119.             Object[] var10 = new Object[var9.length];
  120.  
  121.             try {
  122.                this.unmarshalCustomCallData(var41);
  123.  
  124.                for(int var11 = 0; var11 < var9.length; ++var11) {
  125.                   var10[var11] = UnicastRef.unmarshalValue(var9[var11], var41);
  126.                }
  127.             } catch (IOException var35) {
  128.                throw new UnmarshalException("error unmarshalling arguments", var35);
  129.             } catch (ClassNotFoundException var36) {
  130.                throw new UnmarshalException("error unmarshalling arguments", var36);
  131.             } finally {
  132.                var2.releaseInputStream();
  133.             }
  134.  
  135.             Object var43;
  136.             try {
  137.                var43 = var8.invoke(var1, var10);
  138.             } catch (InvocationTargetException var34) {
  139.                throw var34.getTargetException();
  140.             }
  141.  
  142.             try {
  143.                ObjectOutput var12 = var2.getResultStream(true);
  144.                Class var13 = var8.getReturnType();
  145.                if (var13 != Void.TYPE) {
  146.                   UnicastRef.marshalValue(var13, var43, var12);
  147.                }
  148.  
  149.             } catch (IOException var33) {
  150.                throw new MarshalException("error marshalling return", var33);
  151.             }
  152.          }
  153.       } catch (Throwable var39) {
  154.          Object var6 = var39;
  155.          this.logCallException(var39);
  156.          ObjectOutput var7 = var2.getResultStream(false);
  157.          if (var39 instanceof Error) {
  158.             var6 = new ServerError("Error occurred in server thread", (Error)var39);
  159.          } else if (var39 instanceof RemoteException) {
  160.             var6 = new ServerException("RemoteException occurred in server thread", (Exception)var39);
  161.          }
  162.  
  163.          var7.writeObject(var6);
  164.       } finally {
  165.          var2.releaseInputStream();
  166.          var2.releaseOutputStream();
  167.       }
  168.    }
  169.  
  170.    protected void unmarshalCustomCallData(ObjectInput var1) throws IOException, ClassNotFoundException {
  171.    }
  172.  
  173.    public void oldDispatch(Remote var1, RemoteCall var2, int var3) throws IOException {
  174.       try {
  175.          long var4;
  176.          ObjectInput var16;
  177.          try {
  178.             var16 = var2.getInputStream();
  179.             var4 = var16.readLong();
  180.          } catch (Exception var13) {
  181.             throw new UnmarshalException("error unmarshalling call header", var13);
  182.          }
  183.  
  184.          this.logCall(var1, this.skel.getOperations()[var3]);
  185.          this.unmarshalCustomCallData(var16);
  186.          this.skel.dispatch(var1, var2, var3, var4);
  187.       } catch (Throwable var14) {
  188.          Object var6 = var14;
  189.          this.logCallException(var14);
  190.          ObjectOutput var7 = var2.getResultStream(false);
  191.          if (var14 instanceof Error) {
  192.             var6 = new ServerError("Error occurred in server thread", (Error)var14);
  193.          } else if (var14 instanceof RemoteException) {
  194.             var6 = new ServerException("RemoteException occurred in server thread", (Exception)var14);
  195.          }
  196.  
  197.          var7.writeObject(var6);
  198.       } finally {
  199.          var2.releaseInputStream();
  200.          var2.releaseOutputStream();
  201.       }
  202.  
  203.    }
  204.  
  205.    private void logCall(Remote var1, Object var2) {
  206.       PrintStream var3 = RemoteServer.getLog();
  207.       if (var3 != null) {
  208.          String var4;
  209.          try {
  210.             var4 = this.getClientHost();
  211.          } catch (ServerNotActiveException var6) {
  212.             var4 = "(local)";
  213.          }
  214.  
  215.          var3.println("[" + var4 + ": " + var1.getClass().getName() + super.ref.getObjID().toString() + ": " + var2 + "]");
  216.       }
  217.    }
  218.  
  219.    private void logCallException(Throwable var1) {
  220.       PrintStream var2 = RemoteServer.getLog();
  221.       if (var2 != null) {
  222.          synchronized(var2) {
  223.             try {
  224.                var2.print("[" + this.getClientHost() + "] ");
  225.             } catch (ServerNotActiveException var10) {
  226.             }
  227.  
  228.             var2.print("exception: ");
  229.             var1.printStackTrace(var2);
  230.          }
  231.       }
  232.  
  233.       if (wantExceptionLog) {
  234.          PrintStream var3 = System.err;
  235.          synchronized(var3) {
  236.             var3.println();
  237.  
  238.             try {
  239.                String var12 = this.getClientHost();
  240.             } catch (ServerNotActiveException var8) {
  241.                String var5 = "(local)";
  242.             }
  243.  
  244.             var3.println("Exception dispatching call to " + super.ref.getObjID() + " in thread \"" + Thread.currentThread().getName() + "\" at " + new Date() + ":");
  245.             var1.printStackTrace(var3);
  246.          }
  247.       }
  248.  
  249.    }
  250.  
  251.    public String getRefClass(ObjectOutput var1) {
  252.       if (var1 instanceof MarshalOutputStream) {
  253.          throw new InternalError("UnicastServerRef.writeExternal: server reference written to MarshalOutputStream");
  254.       } else {
  255.          return "UnicastServerRef";
  256.       }
  257.    }
  258.  
  259.    protected RemoteRef getClientRef() {
  260.       return new UnicastRef(super.ref);
  261.    }
  262.  
  263.    public void writeExternal(ObjectOutput var1) throws IOException {
  264.       if (var1 instanceof MarshalOutputStream) {
  265.          throw new InternalError("UnicastServerRef.writeExternal: server reference written to MarshalOutputStream");
  266.       }
  267.    }
  268.  
  269.    public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
  270.       super.ref = null;
  271.       this.skel = null;
  272.    }
  273.  
  274.    private static Map getMethodTable(Class var0) {
  275.       Map var2 = methodTableCache;
  276.       SoftReference[] var1;
  277.       synchronized(var2) {
  278.          var1 = (SoftReference[])methodTableCache.get(var0);
  279.          if (var1 == null) {
  280.             var1 = new SoftReference[]{null};
  281.             methodTableCache.put(var0, var1);
  282.          }
  283.       }
  284.  
  285.       synchronized(var1) {
  286.          Map var4 = null;
  287.          if (var1[0] != null) {
  288.             var4 = (Map)var1[0].get();
  289.          }
  290.  
  291.          if (var4 == null) {
  292.             var4 = createMethodTable(var0);
  293.             var1[0] = new SoftReference(var4);
  294.          }
  295.  
  296.          return var4;
  297.       }
  298.    }
  299.  
  300.    private static Map createMethodTable(Class var0) {
  301.       HashMap var1 = new HashMap(11);
  302.  
  303.       for(Class var2 = var0; var2 != null; var2 = var2.getSuperclass()) {
  304.          Class[] var3 = var2.getInterfaces();
  305.  
  306.          for(int var4 = 0; var4 < var3.length; ++var4) {
  307.             if ((class$java$rmi$Remote == null ? (class$java$rmi$Remote = class$("java.rmi.Remote")) : class$java$rmi$Remote).isAssignableFrom(var3[var4])) {
  308.                Method[] var5 = var3[var4].getMethods();
  309.  
  310.                for(int var6 = 0; var6 < var5.length; ++var6) {
  311.                   Method var7 = var5[var6];
  312.                   AccessController.doPrivileged(new 1(var7));
  313.                   long var8 = computeMethodHash(var7);
  314.                   var1.put(new Long(var8), var7);
  315.                }
  316.             }
  317.          }
  318.       }
  319.  
  320.       return var1;
  321.    }
  322.  
  323.    private static long computeMethodHash(Method var0) {
  324.       long var1 = 0L;
  325.       ByteArrayOutputStream var3 = new ByteArrayOutputStream(127);
  326.  
  327.       try {
  328.          MessageDigest var4 = MessageDigest.getInstance("SHA");
  329.          DataOutputStream var5 = new DataOutputStream(new DigestOutputStream(var3, var4));
  330.          String var6 = getMethodNameAndDescriptor(var0);
  331.          if (RemoteProxy.logLevel >= 20) {
  332.             LogStream.log("transport").println("UnicastServerRef.computeMethodHash: string used for method hash: \"" + var6 + "\"");
  333.          }
  334.  
  335.          var5.writeUTF(var6);
  336.          var5.flush();
  337.          byte[] var7 = var4.digest();
  338.  
  339.          for(int var8 = 0; var8 < Math.min(8, var7.length); ++var8) {
  340.             var1 += (long)(var7[var8] & 255) << var8 * 8;
  341.          }
  342.       } catch (IOException var9) {
  343.          var1 = -1L;
  344.       } catch (NoSuchAlgorithmException var10) {
  345.          throw new SecurityException(((Throwable)var10).getMessage());
  346.       }
  347.  
  348.       return var1;
  349.    }
  350.  
  351.    private static String getMethodNameAndDescriptor(Method var0) {
  352.       StringBuffer var1 = new StringBuffer(var0.getName());
  353.       var1.append('(');
  354.       Class[] var2 = var0.getParameterTypes();
  355.  
  356.       for(int var3 = 0; var3 < var2.length; ++var3) {
  357.          var1.append(getTypeDescriptor(var2[var3]));
  358.       }
  359.  
  360.       var1.append(')');
  361.       Class var4 = var0.getReturnType();
  362.       if (var4 == Void.TYPE) {
  363.          var1.append('V');
  364.       } else {
  365.          var1.append(getTypeDescriptor(var4));
  366.       }
  367.  
  368.       return var1.toString();
  369.    }
  370.  
  371.    private static String getTypeDescriptor(Class var0) {
  372.       if (var0.isPrimitive()) {
  373.          if (var0 == Integer.TYPE) {
  374.             return "I";
  375.          } else if (var0 == Boolean.TYPE) {
  376.             return "Z";
  377.          } else if (var0 == Byte.TYPE) {
  378.             return "B";
  379.          } else if (var0 == Character.TYPE) {
  380.             return "C";
  381.          } else if (var0 == Short.TYPE) {
  382.             return "S";
  383.          } else if (var0 == Long.TYPE) {
  384.             return "J";
  385.          } else if (var0 == Float.TYPE) {
  386.             return "F";
  387.          } else if (var0 == Double.TYPE) {
  388.             return "D";
  389.          } else if (var0 == Void.TYPE) {
  390.             return "V";
  391.          } else {
  392.             throw new Error("unrecognized primitive type: " + var0);
  393.          }
  394.       } else {
  395.          return var0.isArray() ? var0.getName().replace('.', '/') : "L" + var0.getName().replace('.', '/') + ";";
  396.       }
  397.    }
  398.  
  399.    // $FF: synthetic method
  400.    static Class class$(String var0) {
  401.       try {
  402.          return Class.forName(var0);
  403.       } catch (ClassNotFoundException var2) {
  404.          throw new NoClassDefFoundError(((Throwable)var2).getMessage());
  405.       }
  406.    }
  407. }
  408.