home *** CD-ROM | disk | FTP | other *** search
/ Popular Software (Premium Edition) / mycd.iso / INTERNET / NETSCAP4.06 / CP32E406.EXE / nav40.z / java40.jar / netscape / security / PrivilegeManager.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-08-13  |  25.5 KB  |  1,538 lines
  1. package netscape.security;
  2.  
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.OutputStream;
  9. import netscape.util.Archive;
  10. import netscape.util.Archiver;
  11. import netscape.util.CodingException;
  12. import netscape.util.Enumeration;
  13. import netscape.util.Hashtable;
  14. import netscape.util.Unarchiver;
  15.  
  16. public final class PrivilegeManager {
  17.    public static final int PROPER_SUBSET = -1;
  18.    public static final int EQUAL = 0;
  19.    public static final int NO_SUBSET = 1;
  20.    public static final int SIGNED_APPLET_DBNAME = 1;
  21.    public static final int TEMP_FILENAME = 2;
  22.    public static int theDebugLevel;
  23.    private Hashtable itsPrinToPrivTable = new Hashtable();
  24.    private Hashtable itsPrinToMacroTargetPrivTable = new Hashtable();
  25.    private static Principal theSystemPrincipal;
  26.    private static Principal[] theSystemPrincipalAry;
  27.    private static Target theSystemTarget;
  28.    private static boolean theSecurityInited;
  29.    private static Principal theUnsignedPrincipal;
  30.    private static Principal[] theUnsignedPrincipalAry;
  31.    private static Principal theUnknownPrincipal;
  32.    private static Principal[] theUnknownPrincipalAry;
  33.    static Object UpdateLock = new Object();
  34.    private static String SignedAppletDBName = null;
  35.  
  36.    private static native void initClass();
  37.  
  38.    private static void init() {
  39.       try {
  40.          theSystemPrincipal = Principal.createSystemPrincipal();
  41.       } catch (IllegalArgumentException var0) {
  42.          theSystemPrincipal = new Principal(12, "52:54:45:4e:4e:45:54:49");
  43.       }
  44.  
  45.       theSystemPrincipalAry = new Principal[1];
  46.       theSystemPrincipalAry[0] = theSystemPrincipal;
  47.       theSystemTarget = Target.findTarget("SuperUser", theSystemPrincipal);
  48.       theUnsignedPrincipal = new Principal(12, "4a:52:4f:53:4b:49:4e:44");
  49.       theUnsignedPrincipalAry = new Principal[1];
  50.       theUnsignedPrincipalAry[0] = theUnsignedPrincipal;
  51.       theUnknownPrincipal = new Principal(12, "52:4f:53:4b:49:4e:44:4a");
  52.       theUnknownPrincipalAry = new Principal[1];
  53.       theUnknownPrincipalAry[0] = theUnknownPrincipal;
  54.    }
  55.  
  56.    public PrivilegeManager() {
  57.       this.itsPrinToPrivTable.put(getSystemPrincipal(), new SystemPrivilegeTable());
  58.       this.itsPrinToMacroTargetPrivTable.put(getSystemPrincipal(), new SystemPrivilegeTable());
  59.       initClass();
  60.       this.load();
  61.       if (this.isJavaSecurityDefaultTo30Enabled()) {
  62.          Target var1 = Target.findTarget("30Capabilities", getSystemPrincipal());
  63.          Privilege var2 = Privilege.findPrivilege(1, 1);
  64.          this.registerPrincipalAndSetPrivileges(theUnsignedPrincipal, var1, var2);
  65.       }
  66.  
  67.    }
  68.  
  69.    private void registerPrincipal(Principal var1) {
  70.       Hashtable var2 = this.itsPrinToPrivTable;
  71.       synchronized(var2){}
  72.  
  73.       try {
  74.          if (this.itsPrinToPrivTable.get(var1) == null) {
  75.             this.itsPrinToPrivTable.put(var1, new PrivilegeTable());
  76.          }
  77.       } catch (Throwable var8) {
  78.          throw var8;
  79.       }
  80.  
  81.       var2 = this.itsPrinToMacroTargetPrivTable;
  82.       synchronized(var2){}
  83.  
  84.       try {
  85.          if (this.itsPrinToMacroTargetPrivTable.get(var1) == null) {
  86.             this.itsPrinToMacroTargetPrivTable.put(var1, new PrivilegeTable());
  87.          }
  88.       } catch (Throwable var7) {
  89.          throw var7;
  90.       }
  91.  
  92.    }
  93.  
  94.    private void unregisterPrincipal(Principal var1) {
  95.       if (getSystemPrincipal().equals(var1)) {
  96.          throw new ForbiddenTargetException("Can not delete system principal");
  97.       } else {
  98.          Hashtable var3 = this.itsPrinToPrivTable;
  99.          synchronized(var3){}
  100.  
  101.          try {
  102.             Object var2 = this.itsPrinToPrivTable.remove(var1);
  103.             if (var2 == null) {
  104.                throw new ForbiddenTargetException("Couldn't delete principal");
  105.             }
  106.          } catch (Throwable var9) {
  107.             throw var9;
  108.          }
  109.  
  110.          var3 = this.itsPrinToMacroTargetPrivTable;
  111.          synchronized(var3){}
  112.  
  113.          try {
  114.             Object var10 = this.itsPrinToMacroTargetPrivTable.remove(var1);
  115.             if (var10 == null) {
  116.                throw new ForbiddenTargetException("Couldn't delete principal");
  117.             }
  118.          } catch (Throwable var8) {
  119.             throw var8;
  120.          }
  121.  
  122.       }
  123.    }
  124.  
  125.    private native boolean checkPrivilegeEnabled(Target[] var1, int var2, Object var3, boolean var4);
  126.  
  127.    public void checkPrivilegeEnabled(Target var1) {
  128.       Target[] var2 = new Target[1];
  129.       Target var3 = Target.findTarget(var1);
  130.       if (var3 != var1) {
  131.          throw new ForbiddenTargetException(var1 + " is not a registered target");
  132.       } else {
  133.          var2[0] = var3;
  134.          this.checkPrivilegeEnabled(var2, 1, (Object)null, true);
  135.       }
  136.    }
  137.  
  138.    public void checkPrivilegeEnabled(Target var1, Object var2) {
  139.       Target[] var3 = new Target[1];
  140.       Target var4 = Target.findTarget(var1);
  141.       if (var4 != var1) {
  142.          throw new ForbiddenTargetException(var1 + " is not a registered target");
  143.       } else {
  144.          var3[0] = var4;
  145.          this.checkPrivilegeEnabled(var3, 1, var2, true);
  146.       }
  147.    }
  148.  
  149.    public static void checkPrivilegeEnabled(String var0) {
  150.       PrivilegeManager var1 = getPrivilegeManager();
  151.       if (var1 == null) {
  152.          throw new ForbiddenTargetException("access to target denied");
  153.       } else {
  154.          Target[] var2 = new Target[]{Target.findTarget(var0)};
  155.          if (var2[0] == null) {
  156.             throw new ForbiddenTargetException(var0 + " target not found");
  157.          } else {
  158.             var1.checkPrivilegeEnabled(var2, 1, (Object)null, true);
  159.          }
  160.       }
  161.    }
  162.  
  163.    boolean isPrivilegeEnabled(Target var1, int var2) {
  164.       Target[] var3 = new Target[]{var1};
  165.       return this.isPrivilegeEnabled(var3, var2 + 1, (Object)null);
  166.    }
  167.  
  168.    boolean isPrivilegeEnabled(Target[] var1, int var2, Object var3) {
  169.       int var4 = var1.length;
  170.  
  171.       while(var4-- > 0) {
  172.          if (var1[var4] == null) {
  173.             throw new ForbiddenTargetException("Null target is passed.");
  174.          }
  175.       }
  176.  
  177.       return this.checkPrivilegeEnabled(var1, var2 + 1, var3, false);
  178.    }
  179.  
  180.    private static void enablePrivilegePrivate(String var0, int var1) {
  181.       PrivilegeManager var2 = getPrivilegeManager();
  182.       if (var2 == null) {
  183.          throw new ForbiddenTargetException("access to target denied");
  184.       } else {
  185.          Target var3 = Target.findTarget(var0);
  186.          if (var3 == null) {
  187.             throw new ForbiddenTargetException(var0 + " target not found");
  188.          } else {
  189.             var2.enablePrincipalPrivilegeHelper(var3, var1 + 1, (Principal)null, (Object)null);
  190.             var2.enableScopePrivilegeHelper(var3, var1 + 1, (Object)null, false, (Principal)null);
  191.          }
  192.       }
  193.    }
  194.  
  195.    public static void enablePrivilege(String var0) {
  196.       enablePrivilegePrivate((String)var0, 1);
  197.    }
  198.  
  199.    public static Object enableTarget(String var0) {
  200.       enablePrivilegePrivate((String)var0, 1);
  201.       return null;
  202.    }
  203.  
  204.    private void enablePrivilegePrivate(Target var1, int var2) {
  205.       this.enablePrincipalPrivilegeHelper(var1, var2 + 1, (Principal)null, (Object)null);
  206.       this.enableScopePrivilegeHelper(var1, var2 + 1, (Object)null, false, (Principal)null);
  207.    }
  208.  
  209.    public void enablePrivilege(Target var1) {
  210.       this.enablePrivilegePrivate((Target)var1, 1);
  211.    }
  212.  
  213.    public Object enableTarget(Target var1) {
  214.       this.enablePrivilegePrivate((Target)var1, 1);
  215.       return null;
  216.    }
  217.  
  218.    private void enablePrivilegePrivate(Target var1, Principal var2, int var3) {
  219.       this.enablePrincipalPrivilegeHelper(var1, var3 + 1, var2, (Object)null);
  220.       this.enableScopePrivilegeHelper(var1, var3 + 1, (Object)null, false, var2);
  221.    }
  222.  
  223.    public void enablePrivilege(Target var1, Principal var2) {
  224.       this.enablePrivilegePrivate(var1, var2, 1);
  225.    }
  226.  
  227.    public Object enableTarget(Target var1, Principal var2) {
  228.       this.enablePrivilegePrivate(var1, var2, 1);
  229.       return null;
  230.    }
  231.  
  232.    private void enablePrivilegePrivate(Target var1, Principal var2, Object var3, int var4) {
  233.       this.enablePrincipalPrivilegeHelper(var1, var4 + 1, var2, var3);
  234.       this.enableScopePrivilegeHelper(var1, var4 + 1, var3, false, var2);
  235.    }
  236.  
  237.    public void enablePrivilege(Target var1, Principal var2, Object var3) {
  238.       this.enablePrivilegePrivate(var1, var2, var3, 1);
  239.    }
  240.  
  241.    public Object enableTarget(Target var1, Principal var2, Object var3) {
  242.       this.enablePrivilegePrivate(var1, var2, var3, 1);
  243.       return null;
  244.    }
  245.  
  246.    void enablePrivilege(String var1, int var2) {
  247.       Target var3 = Target.findTarget(var1);
  248.       if (var3 == null) {
  249.          throw new ForbiddenTargetException(var1 + " target not found");
  250.       } else {
  251.          this.enablePrincipalPrivilegeHelper(var3, var2 + 1, (Principal)null, (Object)null);
  252.          this.enableScopePrivilegeHelper(var3, var2 + 1, (Object)null, false, (Principal)null);
  253.       }
  254.    }
  255.  
  256.    Object setScopePrivilegeAssistant(int var1) {
  257.       return this.enableScopePrivilegeHelper(theSystemTarget, var1 + 1, (Object)null, true, (Principal)null);
  258.    }
  259.  
  260.    Object setScopePrivilegeAssistant(int var1, String var2) {
  261.       Target var3 = Target.findTarget(var2);
  262.       if (var3 == null) {
  263.          throw new ForbiddenTargetException(var2 + " target not found");
  264.       } else {
  265.          this.enablePrincipalPrivilegeHelper(var3, var1 + 1, (Principal)null, (Object)null);
  266.          return this.enableScopePrivilegeHelper(var3, var1 + 1, (Object)null, true, (Principal)null);
  267.       }
  268.    }
  269.  
  270.    private void enablePrincipalPrivilegeHelper(Target var1, int var2, Principal var3, Object var4) {
  271.       Principal var6 = null;
  272.       Target var7 = Target.findTarget(var1);
  273.       if (var7 != var1) {
  274.          throw new ForbiddenTargetException(var1 + " is not a registered target");
  275.       } else {
  276.          Principal[] var5 = this.getClassPrincipalsFromStackUnsafeJava(var2 + 1);
  277.          if (var3 != null) {
  278.             int var8 = var5.length;
  279.  
  280.             while(var8-- > 0) {
  281.                if (var5[var8].equals(var3) && (var5[var8].isCert() || var5[var8].isCertFingerprint())) {
  282.                   var6 = var5[var8];
  283.                   break;
  284.                }
  285.             }
  286.  
  287.             if (var6 == null) {
  288.                Target var9 = Target.findTarget("Impersonator");
  289.                this.checkPrivilegeEnabled(var9);
  290.                var6 = var3;
  291.                var5 = new Principal[]{var3};
  292.             }
  293.          }
  294.  
  295.          if (!this.isPermissionGranted(var1, var5, var4)) {
  296.             if (var6 == null) {
  297.                if (var5.length == 0) {
  298.                   throw new ForbiddenTargetException("request's caller has no principal!");
  299.                }
  300.  
  301.                var6 = var5[0];
  302.             }
  303.  
  304.             Object var14 = UpdateLock;
  305.             synchronized(var14){}
  306.  
  307.             try {
  308.                if (!this.isPermissionGranted(var1, var5, var4)) {
  309.                   Privilege var13 = var1.enablePrivilege(var6, var4);
  310.                   if (!var13.isAllowed() && var13.getDuration() == 1) {
  311.                      throw new ForbiddenTargetException("User didn't grant the " + var1.getName() + " privilege.");
  312.                   }
  313.  
  314.                   this.registerPrincipalAndSetPrivileges(var6, var1, var13);
  315.                   if (theDebugLevel > 0) {
  316.                      System.out.println("Privilege table modified for: " + var6.toVerboseString() + " for target " + var1 + " Privilege " + var13);
  317.                   }
  318.  
  319.                   if (var6.savePrincipalPermanently() && var13.getDuration() == 2 && !var6.equals(theUnsignedPrincipal)) {
  320.                      this.save();
  321.                   }
  322.  
  323.                   if (!var13.isForbidden()) {
  324.                      return;
  325.                   }
  326.  
  327.                   throw new ForbiddenTargetException("User didn't grant the " + var1.getName() + " privilege.");
  328.                }
  329.             } catch (Throwable var12) {
  330.                throw var12;
  331.             }
  332.  
  333.          }
  334.       }
  335.    }
  336.  
  337.    private boolean isPermissionGranted(Target var1, Principal[] var2, Object var3) {
  338.       int var4 = this.getPrincipalPrivilege(var1, var2, var3);
  339.       switch (var4) {
  340.          case 0:
  341.          default:
  342.             throw new ForbiddenTargetException("access to target denied");
  343.          case 1:
  344.             return true;
  345.          case 2:
  346.             return false;
  347.       }
  348.    }
  349.  
  350.    private Object enableScopePrivilegeHelper(Target var1, int var2, Object var3, boolean var4, Principal var5) {
  351.       Target var8 = Target.findTarget(var1);
  352.       if (var8 != var1) {
  353.          throw new ForbiddenTargetException(var1 + " is not a registered target");
  354.       } else {
  355.          if (var5 != null) {
  356.             this.checkPrivilegeGranted(var1, var5, var3);
  357.          } else {
  358.             this.checkPrivilegeGranted(var1, var2 + 1, var3);
  359.          }
  360.  
  361.          PrivilegeTable var6 = this.getPrivilegeTableFromStackUnsafe(var2 + 1, !var4);
  362.          if (var4) {
  363.             if (var6 != null) {
  364.                var6 = (PrivilegeTable)var6.clone();
  365.             } else {
  366.                var6 = new PrivilegeTable();
  367.             }
  368.          }
  369.  
  370.          Privilege var7 = Privilege.findPrivilege(1, 0);
  371.          this.updatePrivilegeTable(var1, var6, var7);
  372.          return var6;
  373.       }
  374.    }
  375.  
  376.    private void registerPrincipalAndSetPrivileges(Principal var1, Target var2, Privilege var3) {
  377.       this.registerPrincipal(var1);
  378.       PrivilegeTable var4 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var1);
  379.       var4.put(var2, var3);
  380.       var4 = (PrivilegeTable)this.itsPrinToPrivTable.get(var1);
  381.       this.updatePrivilegeTable(var2, var4, var3);
  382.    }
  383.  
  384.    private void updatePrivilegeTable(Target var1, PrivilegeTable var2, Privilege var3) {
  385.       Target[] var4 = var1.getFlattenedTargetAryUnsafe();
  386.       synchronized(var2){}
  387.  
  388.       try {
  389.          for(int var8 = var4.length; var8-- > 0; var2.put(var4[var8], var3)) {
  390.             Privilege var5 = var2.get(var4[var8]);
  391.             if (var5 != null) {
  392.                var3 = Privilege.add(var5, var3);
  393.             }
  394.          }
  395.       } catch (Throwable var10) {
  396.          throw var10;
  397.       }
  398.  
  399.    }
  400.  
  401.    public void revertPrivilege(Target var1) {
  402.       this.revertPrivilege(var1, 1);
  403.    }
  404.  
  405.    public static void revertPrivilege(String var0) {
  406.       PrivilegeManager var1 = getPrivilegeManager();
  407.       if (var1 == null) {
  408.          throw new ForbiddenTargetException("access to target denied");
  409.       } else {
  410.          Target var2 = Target.findTarget(var0);
  411.          if (var2 == null) {
  412.             throw new ForbiddenTargetException(var0 + " target not found");
  413.          } else {
  414.             var1.revertPrivilege(var2, 1);
  415.          }
  416.       }
  417.    }
  418.  
  419.    void revertPrivilege() {
  420.       PrivilegeTable var1 = this.getPrivilegeTableFromStackUnsafe(1, true);
  421.       synchronized(var1){}
  422.  
  423.       try {
  424.          var1.clear();
  425.       } catch (Throwable var4) {
  426.          throw var4;
  427.       }
  428.  
  429.    }
  430.  
  431.    private void revertPrivilege(Target var1, int var2) {
  432.       Target var3 = Target.findTarget(var1);
  433.       if (var3 != var1) {
  434.          throw new ForbiddenTargetException(var1 + " is not a registered target");
  435.       } else {
  436.          PrivilegeTable var4 = this.getPrivilegeTableFromStackUnsafe(var2 + 1, true);
  437.          synchronized(var4){}
  438.  
  439.          try {
  440.             var4.put(var1, Privilege.findPrivilege(2, 0));
  441.          } catch (Throwable var7) {
  442.             throw var7;
  443.          }
  444.  
  445.       }
  446.    }
  447.  
  448.    public void disablePrivilege(Target var1) {
  449.       this.disablePrivilege(var1, 1);
  450.    }
  451.  
  452.    public static void disablePrivilege(String var0) {
  453.       PrivilegeManager var1 = getPrivilegeManager();
  454.       if (var1 == null) {
  455.          throw new ForbiddenTargetException("access to target denied");
  456.       } else {
  457.          Target var2 = Target.findTarget(var0);
  458.          if (var2 == null) {
  459.             throw new ForbiddenTargetException(var0 + " target not found");
  460.          } else {
  461.             var1.disablePrivilege(var2, 1);
  462.          }
  463.       }
  464.    }
  465.  
  466.    private void disablePrivilege(Target var1, int var2) {
  467.       Target var3 = Target.findTarget(var1);
  468.       if (var3 != var1) {
  469.          throw new ForbiddenTargetException(var1 + " is not a registered target");
  470.       } else {
  471.          PrivilegeTable var4 = this.getPrivilegeTableFromStackUnsafe(var2 + 1, true);
  472.          var4.put(var1, Privilege.findPrivilege(0, 0));
  473.       }
  474.    }
  475.  
  476.    private int getPrincipalPrivilege(Target var1, int var2) {
  477.       return this.getPrincipalPrivilege(var1, var2 + 1, (Object)null);
  478.    }
  479.  
  480.    private int getPrincipalPrivilege(Target var1, Principal[] var2) {
  481.       return this.getPrincipalPrivilege(var1, (Principal[])var2, (Object)null);
  482.    }
  483.  
  484.    private int getPrincipalPrivilege(Target var1, int var2, Object var3) {
  485.       Principal[] var4 = this.getClassPrincipalsFromStackUnsafeJava(var2 + 1);
  486.       return this.getPrincipalPrivilege(var1, var4, var3);
  487.    }
  488.  
  489.    private int getPrincipalPrivilege(Target var1, Principal[] var2, Object var3) {
  490.       boolean var5 = false;
  491.       int var6 = var2.length;
  492.  
  493.       while(var6-- > 0) {
  494.          Privilege var4 = this.getPrincipalPrivilege(var1, var2[var6], var3);
  495.          if (var4 != null) {
  496.             switch (var4.getPermission()) {
  497.                case 0:
  498.                default:
  499.                   return 0;
  500.                case 1:
  501.                   var5 = true;
  502.                case 2:
  503.             }
  504.          }
  505.       }
  506.  
  507.       if (var5) {
  508.          return 1;
  509.       } else {
  510.          return 2;
  511.       }
  512.    }
  513.  
  514.    Privilege getPrincipalPrivilege(Target var1, Principal var2, Object var3) {
  515.       PrivilegeTable var4 = (PrivilegeTable)this.itsPrinToPrivTable.get(var2);
  516.       if (var4 == null) {
  517.          return null;
  518.       } else {
  519.          Target var6 = Target.findTarget(var1);
  520.          if (var6 != var1) {
  521.             return null;
  522.          } else {
  523.             Privilege var5;
  524.             if (var1 instanceof ParameterizedTarget) {
  525.                ParameterizedTarget var7 = (ParameterizedTarget)var1;
  526.                var5 = var7.getPrincipalPrivilege(var2, var3);
  527.             } else {
  528.                var5 = var4.get(var1);
  529.             }
  530.  
  531.             return var5;
  532.          }
  533.       }
  534.    }
  535.  
  536.    public static void checkPrivilegeGranted(String var0) {
  537.       PrivilegeManager var1 = getPrivilegeManager();
  538.       if (var1 == null) {
  539.          throw new ForbiddenTargetException("access to target denied");
  540.       } else {
  541.          Target var2 = Target.findTarget(var0);
  542.          if (var2 == null) {
  543.             throw new ForbiddenTargetException(var0 + " target not found");
  544.          } else {
  545.             var1.checkPrivilegeGranted(var2, 1, (Object)null);
  546.          }
  547.       }
  548.    }
  549.  
  550.    public void checkPrivilegeGranted(Target var1) {
  551.       this.checkPrivilegeGranted(var1, 1, (Object)null);
  552.    }
  553.  
  554.    private void checkPrivilegeGranted(Target var1, int var2) {
  555.       this.checkPrivilegeGranted(var1, var2 + 1, (Object)null);
  556.    }
  557.  
  558.    public void checkPrivilegeGranted(Target var1, Object var2) {
  559.       this.checkPrivilegeGranted(var1, 1, var2);
  560.    }
  561.  
  562.    private void checkPrivilegeGranted(Target var1, int var2, Object var3) {
  563.       int var4 = this.getPrincipalPrivilege(var1, var2 + 1, var3);
  564.       if (var4 != 1) {
  565.          throw new ForbiddenTargetException("access to target denied");
  566.       }
  567.    }
  568.  
  569.    public void checkPrivilegeGranted(Target var1, Principal var2, Object var3) {
  570.       Principal[] var4 = new Principal[]{var2};
  571.       int var5 = this.getPrincipalPrivilege(var1, var4, var3);
  572.       if (var5 != 1) {
  573.          throw new ForbiddenTargetException("access to target denied");
  574.       }
  575.    }
  576.  
  577.    private boolean matchPrincipal(Principal var1, Principal[] var2) {
  578.       int var3 = var2.length;
  579.  
  580.       while(var3-- > 0) {
  581.          if (var1.equals(var2[var3])) {
  582.             return true;
  583.          }
  584.       }
  585.  
  586.       return false;
  587.    }
  588.  
  589.    public boolean isCalledByPrincipal(Principal var1, int var2) {
  590.       Principal[] var3 = this.getClassPrincipalsFromStackUnsafeJava(var2 + 1);
  591.       return var3 == null ? false : this.matchPrincipal(var1, var3);
  592.    }
  593.  
  594.    public boolean isCalledByPrincipal(Principal var1) {
  595.       return this.isCalledByPrincipal(var1, 2);
  596.    }
  597.  
  598.    public static Principal getSystemPrincipal() {
  599.       if (theSystemPrincipal == null) {
  600.          init();
  601.       }
  602.  
  603.       return theSystemPrincipal;
  604.    }
  605.  
  606.    public static PrivilegeManager getPrivilegeManager() {
  607.       return AppletSecurity.getPrivilegeManager();
  608.    }
  609.  
  610.    private static Principal[] getSystemPrincipals() {
  611.       try {
  612.          return (Principal[])theSystemPrincipalAry.clone();
  613.       } catch (CloneNotSupportedException var0) {
  614.          throw new ForbiddenTargetException("internal error: unable to clone System Principal");
  615.       }
  616.    }
  617.  
  618.    private static Principal[] getSystemPrincipalsUnsafe() {
  619.       return theSystemPrincipalAry;
  620.    }
  621.  
  622.    private static Principal[] getUnsignedPrincipalArray() {
  623.       try {
  624.          return (Principal[])theUnsignedPrincipalAry.clone();
  625.       } catch (CloneNotSupportedException var0) {
  626.          throw new ForbiddenTargetException("internal error: unable to clone Unsigned Principal");
  627.       }
  628.    }
  629.  
  630.    private static Principal[] getUnsignedPrincipalsUnsafe() {
  631.       return theUnsignedPrincipalAry;
  632.    }
  633.  
  634.    static Principal getUnsignedPrincipal() {
  635.       return theUnsignedPrincipal;
  636.    }
  637.  
  638.    private static Principal[] getUnknownPrincipalArrayUnsafe() {
  639.       return theUnknownPrincipalAry;
  640.    }
  641.  
  642.    static Principal[] getUnknownPrincipalArray() {
  643.       try {
  644.          return (Principal[])theUnknownPrincipalAry.clone();
  645.       } catch (CloneNotSupportedException var0) {
  646.          throw new ForbiddenTargetException("internal error: unable to clone Unknown Principal");
  647.       }
  648.    }
  649.  
  650.    static Principal getUnknownPrincipal() {
  651.       return theUnknownPrincipal;
  652.    }
  653.  
  654.    public static Principal[] getMyPrincipals() {
  655.       PrivilegeManager var0 = getPrivilegeManager();
  656.       return var0 == null ? null : var0.getClassPrincipalsFromStack(1);
  657.    }
  658.  
  659.    public Principal[] getClassPrincipals(Class var1) {
  660.       Principal[] var2 = this.getClassPrincipalsUnsafeJava(var1);
  661.  
  662.       try {
  663.          return (Principal[])var2.clone();
  664.       } catch (CloneNotSupportedException var3) {
  665.          throw new ForbiddenTargetException("internal error: unable to clone Principal");
  666.       }
  667.    }
  668.  
  669.    public boolean hasPrincipal(Class var1, Principal var2) {
  670.       Principal[] var3 = this.getClassPrincipalsUnsafeJava(var1);
  671.       int var4 = var3.length;
  672.  
  673.       while(var4-- > 0) {
  674.          if (var3[var4].equals(var2)) {
  675.             return true;
  676.          }
  677.       }
  678.  
  679.       return false;
  680.    }
  681.  
  682.    public int comparePrincipalArray(Principal[] var1, Principal[] var2) {
  683.       Hashtable var3 = new Hashtable();
  684.       Integer var4 = new Integer(1);
  685.       Integer var5 = new Integer(0);
  686.       int var8 = var2.length;
  687.  
  688.       while(var8-- > 0) {
  689.          var3.put(var2[var8], var4);
  690.       }
  691.  
  692.       int var9 = var1.length;
  693.  
  694.       while(var9-- > 0) {
  695.          Principal var7 = var1[var9];
  696.          Integer var6 = (Integer)var3.get(var7);
  697.          if (var6 == null) {
  698.             return 1;
  699.          }
  700.  
  701.          if (var6 == var4) {
  702.             var3.put(var7, var5);
  703.          }
  704.       }
  705.  
  706.       Enumeration var10 = var3.keys();
  707.  
  708.       while(var10.hasMoreElements()) {
  709.          Object var12 = var10.nextElement();
  710.          Integer var11 = (Integer)var3.get(var12);
  711.          if (var11 == var4) {
  712.             return -1;
  713.          }
  714.       }
  715.  
  716.       return 0;
  717.    }
  718.  
  719.    public Principal[] intersectPrincipalArray(Principal[] var1, Principal[] var2) {
  720.       boolean[] var3 = new boolean[var1.length];
  721.       int var4 = 0;
  722.  
  723.       for(int var5 = 0; var5 < var1.length; ++var5) {
  724.          for(int var6 = 0; var6 < var2.length; ++var6) {
  725.             if (var1[var5].equals(var2[var6])) {
  726.                var3[var5] = true;
  727.                ++var4;
  728.                break;
  729.             }
  730.          }
  731.       }
  732.  
  733.       Principal[] var9 = new Principal[var4];
  734.       int var7 = 0;
  735.  
  736.       for(int var8 = 0; var8 < var3.length; ++var8) {
  737.          if (var3[var8]) {
  738.             var9[var7++] = var1[var8];
  739.          }
  740.       }
  741.  
  742.       return var9;
  743.    }
  744.  
  745.    public boolean canExtendTrust(Principal[] var1, Principal[] var2) {
  746.       Principal[] var3 = this.intersectPrincipalArray(var1, var2);
  747.       if (var3.length == var1.length) {
  748.          return true;
  749.       } else if (var3.length != 0 && var3.length == var1.length - 1) {
  750.          for(int var4 = 0; var4 < var3.length; ++var4) {
  751.             if (var3[var4].isCodebase()) {
  752.                return false;
  753.             }
  754.          }
  755.  
  756.          int var5 = 0;
  757.  
  758.          for(int var6 = 0; var6 < var1.length; ++var6) {
  759.             if (var1[var6].isCodebase()) {
  760.                ++var5;
  761.             }
  762.          }
  763.  
  764.          if (var5 != 1) {
  765.             return false;
  766.          } else {
  767.             return true;
  768.          }
  769.       } else {
  770.          return false;
  771.       }
  772.    }
  773.  
  774.    public boolean checkMatchPrincipal(Class var1, int var2) {
  775.       return this.comparePrincipalArray(this.getClassPrincipalsFromStack(var2 + 1), this.getClassPrincipalsUnsafeJava(var1)) != 1;
  776.    }
  777.  
  778.    public boolean checkMatchPrincipal(Principal var1, int var2) {
  779.       Principal[] var3 = new Principal[]{var1};
  780.       return this.comparePrincipalArray(var3, this.getClassPrincipalsFromStack(var2 + 1)) != 1;
  781.    }
  782.  
  783.    public boolean checkMatchPrincipal(Class var1) {
  784.       return this.checkMatchPrincipal((Class)var1, 1);
  785.    }
  786.  
  787.    public boolean checkMatchPrincipalAlways() {
  788.       return SecurityManager.checksMatchPrincipalAlways(1);
  789.    }
  790.  
  791.    public Principal[] getClassPrincipalsFromStack(int var1) {
  792.       Principal[] var2 = this.getClassPrincipalsFromStackUnsafeJava(var1 + 1);
  793.  
  794.       try {
  795.          return (Principal[])var2.clone();
  796.       } catch (CloneNotSupportedException var3) {
  797.          throw new ForbiddenTargetException("internal error: unable to clone Principal");
  798.       }
  799.    }
  800.  
  801.    private Principal[] getClassPrincipalsFromStackUnsafeJava(int var1) {
  802.       Principal[] var2 = this.getClassPrincipalsFromStackUnsafe(var1 + 1);
  803.       if (var2 == null) {
  804.          if (!this.getJavaSecurityEnabled()) {
  805.             System.out.println("Java Navigator Beta internal error message: Defaulting to system principal");
  806.             return getSystemPrincipalsUnsafe();
  807.          } else {
  808.             return getUnknownPrincipalArray();
  809.          }
  810.       } else {
  811.          return var2;
  812.       }
  813.    }
  814.  
  815.    private Principal[] getClassPrincipalsUnsafeJava(Class var1) {
  816.       Principal[] var2 = this.getClassPrincipalsUnsafe(var1);
  817.       if (var2 == null) {
  818.          if (!this.getJavaSecurityEnabled()) {
  819.             System.out.println("Java Navigator Beta internal error message: Defaulting to system principal");
  820.             return getSystemPrincipalsUnsafe();
  821.          } else {
  822.             return getUnknownPrincipalArray();
  823.          }
  824.       } else {
  825.          return var2;
  826.       }
  827.    }
  828.  
  829.    boolean isSecurePrincipalFromStack(Class[] var1) {
  830.       for(int var3 = 0; var3 < var1.length; ++var3) {
  831.          Principal[] var2 = this.getClassPrincipalsUnsafe(var1[var3]);
  832.          if (var2 == null) {
  833.             return false;
  834.          }
  835.  
  836.          if (!theSystemPrincipal.equals(var2[0])) {
  837.             if (var2[0].isCodebase()) {
  838.                return false;
  839.             }
  840.  
  841.             return true;
  842.          }
  843.       }
  844.  
  845.       return true;
  846.    }
  847.  
  848.    String getNonSystemPrincipalFromStack(Class[] var1) {
  849.       for(int var3 = 0; var3 < var1.length; ++var3) {
  850.          Principal[] var2 = this.getClassPrincipalsUnsafe(var1[var3]);
  851.          if (var2 == null) {
  852.             return UserDialogHelper.getUnsignedAppletStr();
  853.          }
  854.  
  855.          if (!theSystemPrincipal.equals(var2[0])) {
  856.             if (var2[0].isCodebase()) {
  857.                return UserDialogHelper.getUnsignedAppletStr();
  858.             }
  859.  
  860.             return UserDialogHelper.getSignedAppletStr(var2[0].getVendor());
  861.          }
  862.       }
  863.  
  864.       return null;
  865.    }
  866.  
  867.    PrivilegeTable getPrivilegeTableFromStack(int var1) {
  868.       PrivilegeTable var2 = this.getPrivilegeTableFromStackUnsafe(var1 + 1, false);
  869.       return var2 == null ? null : (PrivilegeTable)var2.clone();
  870.    }
  871.  
  872.    public PrivilegeTable getPrivilegeTableFromStack() {
  873.       return this.getPrivilegeTableFromStack(2);
  874.    }
  875.  
  876.    private native Principal[] getClassPrincipalsFromStackUnsafe(int var1);
  877.  
  878.    private native Principal[] getClassPrincipalsUnsafe(Class var1);
  879.  
  880.    private native PrivilegeTable getPrivilegeTableFromStackUnsafe(int var1, boolean var2);
  881.  
  882.    native boolean getJavaSecurityEnabled();
  883.  
  884.    synchronized native int getPrivilegeFromUser(String var1, String var2, String var3, boolean var4);
  885.  
  886.    native boolean showDocument(String var1, String var2);
  887.  
  888.    native boolean isJavaSecurityDefaultTo30Enabled();
  889.  
  890.    native boolean getBoolPref(String var1);
  891.  
  892.    private native String getWHFileName(String var1, int var2);
  893.  
  894.    native boolean picsCanUserEnableAdditionalJavaCapabilities();
  895.  
  896.    private native void reloadCookiesIntoBrowser0();
  897.  
  898.    public void reloadCookiesIntoBrowser() {
  899.       checkPrivilegeEnabled("CookieAccess");
  900.       this.reloadCookiesIntoBrowser0();
  901.    }
  902.  
  903.    private native void reloadSignonsIntoBrowser0();
  904.  
  905.    public void reloadSignonsIntoBrowser() {
  906.       checkPrivilegeEnabled("SignonAccess");
  907.       this.reloadSignonsIntoBrowser0();
  908.    }
  909.  
  910.    private native void flushCookiesFromBrowser0();
  911.  
  912.    public void flushCookiesFromBrowser() {
  913.       checkPrivilegeEnabled("CookieAccess");
  914.       this.flushCookiesFromBrowser0();
  915.    }
  916.  
  917.    private native void flushSignonsFromBrowser0();
  918.  
  919.    public void flushSignonsFromBrowser() {
  920.       checkPrivilegeEnabled("SignonAccess");
  921.       this.flushSignonsFromBrowser0();
  922.    }
  923.  
  924.    public Principal[] getAllPrincipals() {
  925.       int var1 = 0;
  926.       Hashtable var6 = this.itsPrinToMacroTargetPrivTable;
  927.       synchronized(var6){}
  928.  
  929.       Object var5;
  930.       try {
  931.          int var8 = this.itsPrinToMacroTargetPrivTable.size();
  932.          if (var8 != 0) {
  933.             Principal[] var2 = new Principal[var8];
  934.  
  935.             Principal var4;
  936.             for(Enumeration var3 = this.itsPrinToMacroTargetPrivTable.keys(); var3.hasMoreElements(); var2[var1++] = var4) {
  937.                var4 = (Principal)var3.nextElement();
  938.             }
  939.  
  940.             return var2;
  941.          }
  942.  
  943.          var5 = null;
  944.       } catch (Throwable var10) {
  945.          throw var10;
  946.       }
  947.  
  948.       return (Principal[])var5;
  949.    }
  950.  
  951.    static String getAllPrincipalsString() {
  952.       PrivilegeManager var0 = getPrivilegeManager();
  953.       if (var0 == null) {
  954.          return null;
  955.       } else {
  956.          Principal[] var1 = var0.getAllPrincipals();
  957.          if (var1 == null) {
  958.             return null;
  959.          } else {
  960.             boolean var2 = true;
  961.             StringBuffer var3 = new StringBuffer();
  962.             int var4 = var1.length;
  963.  
  964.             while(var4-- > 0) {
  965.                if (var0.principalHasPrivileges(var1[var4])) {
  966.                   if (var2) {
  967.                      var3.append("\"" + var1[var4].toString() + "\"");
  968.                      var2 = false;
  969.                   } else {
  970.                      var3.append(",\"" + var1[var4].toString() + "\"");
  971.                   }
  972.                }
  973.             }
  974.  
  975.             if (var2) {
  976.                return null;
  977.             } else {
  978.                return var3.toString();
  979.             }
  980.          }
  981.       }
  982.    }
  983.  
  984.    private Principal getPrincipalFromString(String var1) {
  985.       Principal[] var2 = this.getAllPrincipals();
  986.       if (var2 == null) {
  987.          return null;
  988.       } else {
  989.          int var3 = var2.length;
  990.  
  991.          while(var3-- > 0) {
  992.             if (var1.equals(var2[var3].toString())) {
  993.                return var2[var3];
  994.             }
  995.          }
  996.  
  997.          return null;
  998.       }
  999.    }
  1000.  
  1001.    boolean principalHasPrivileges(Principal var1) {
  1002.       Hashtable var3 = this.itsPrinToMacroTargetPrivTable;
  1003.       synchronized(var3){}
  1004.  
  1005.       PrivilegeTable var2;
  1006.       try {
  1007.          var2 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var1);
  1008.       } catch (Throwable var5) {
  1009.          throw var5;
  1010.       }
  1011.  
  1012.       return var2 != null && var2.size() != 0;
  1013.    }
  1014.  
  1015.    static String[] getTargetsWithPrivileges(String var0) {
  1016.       PrivilegeManager var1 = getPrivilegeManager();
  1017.       if (var1 == null) {
  1018.          return null;
  1019.       } else {
  1020.          Principal var2 = var1.getPrincipalFromString(var0);
  1021.          if (var2 == null) {
  1022.             return null;
  1023.          } else {
  1024.             StringBuffer var8 = new StringBuffer();
  1025.             StringBuffer var9 = new StringBuffer();
  1026.             StringBuffer var10 = new StringBuffer();
  1027.             String[] var11 = new String[3];
  1028.             Hashtable var12 = var1.itsPrinToMacroTargetPrivTable;
  1029.             synchronized(var12){}
  1030.  
  1031.             PrivilegeTable var3;
  1032.             try {
  1033.                var3 = (PrivilegeTable)var1.itsPrinToMacroTargetPrivTable.get(var2);
  1034.             } catch (Throwable var14) {
  1035.                throw var14;
  1036.             }
  1037.  
  1038.             Enumeration var6 = var3.keys();
  1039.  
  1040.             while(var6.hasMoreElements()) {
  1041.                Target var4 = (Target)var6.nextElement();
  1042.                Privilege var5 = var3.get(var4);
  1043.                String var7 = var4.getDescription();
  1044.                if (var5.isAllowed()) {
  1045.                   if (var5.getDuration() == 2) {
  1046.                      var8.append("<option>" + var7);
  1047.                   } else {
  1048.                      var9.append("<option>" + var7);
  1049.                   }
  1050.                } else if (var5.isForbidden()) {
  1051.                   var10.append("<option>" + var7);
  1052.                }
  1053.             }
  1054.  
  1055.             var11[0] = var8.toString();
  1056.             var11[1] = var9.toString();
  1057.             var11[2] = var10.toString();
  1058.             return var11;
  1059.          }
  1060.       }
  1061.    }
  1062.  
  1063.    private Target getTargetFromString(Principal var1, String var2) {
  1064.       PrivilegeTable var3 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var1);
  1065.       Enumeration var5 = var3.keys();
  1066.  
  1067.       while(var5.hasMoreElements()) {
  1068.          Target var4 = (Target)var5.nextElement();
  1069.          if (var2.equals(var4.getDescription())) {
  1070.             return var4;
  1071.          }
  1072.       }
  1073.  
  1074.       return null;
  1075.    }
  1076.  
  1077.    static String[] getTargetDetails(String var0) {
  1078.       PrivilegeManager var1 = getPrivilegeManager();
  1079.       if (var1 == null) {
  1080.          return null;
  1081.       } else {
  1082.          Target var2 = Target.getTargetFromDescription(var0);
  1083.          if (var2 == null) {
  1084.             return null;
  1085.          } else {
  1086.             StringBuffer var3 = new StringBuffer();
  1087.             Target[] var4 = var2.getFlattenedTargetAryUnsafe();
  1088.             int var5 = var4.length;
  1089.  
  1090.             while(var5-- > 0) {
  1091.                var3.append("<option>" + var4[var5].getDescription() + " (" + var4[var5].getRisk() + ")");
  1092.             }
  1093.  
  1094.             String[] var6 = new String[]{var3.toString(), var2.getRisk()};
  1095.             return var6;
  1096.          }
  1097.       }
  1098.    }
  1099.  
  1100.    static boolean removePrincipal(String var0) {
  1101.       PrivilegeManager var1 = getPrivilegeManager();
  1102.       if (var1 == null) {
  1103.          return false;
  1104.       } else {
  1105.          Principal var2 = var1.getPrincipalFromString(var0);
  1106.          if (var2 == null) {
  1107.             return false;
  1108.          } else {
  1109.             try {
  1110.                var1.removeAllParameterizedTargets(var2);
  1111.                var1.unregisterPrincipal(var2);
  1112.             } catch (Exception var4) {
  1113.                System.out.println("Unable to delete principal " + var2 + " " + var4);
  1114.                ((Throwable)var4).printStackTrace(System.out);
  1115.                return false;
  1116.             }
  1117.  
  1118.             var1.save();
  1119.             return true;
  1120.          }
  1121.       }
  1122.    }
  1123.  
  1124.    static boolean removePrincipalsPrivilege(String var0, String var1) {
  1125.       PrivilegeManager var2 = getPrivilegeManager();
  1126.       if (var2 == null) {
  1127.          return false;
  1128.       } else {
  1129.          Principal var3 = var2.getPrincipalFromString(var0);
  1130.          if (var3 == null) {
  1131.             return false;
  1132.          } else {
  1133.             Target var4 = var2.getTargetFromString(var3, var1);
  1134.             if (var4 == null) {
  1135.                return false;
  1136.             } else {
  1137.                var2.remove(var3, var4);
  1138.                var2.save();
  1139.                return true;
  1140.             }
  1141.          }
  1142.       }
  1143.    }
  1144.  
  1145.    private void remove(Principal var1, Target var2) {
  1146.       if (this.itsPrinToMacroTargetPrivTable == null) {
  1147.          if (theDebugLevel > 0) {
  1148.             System.out.println("itsPrinToMacroTargetPrivTable is null " + var1);
  1149.          }
  1150.  
  1151.       } else {
  1152.          Hashtable var7 = this.itsPrinToMacroTargetPrivTable;
  1153.          synchronized(var7){}
  1154.  
  1155.          PrivilegeTable var4;
  1156.          try {
  1157.             var4 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var1);
  1158.             if (var4 == null) {
  1159.                if (theDebugLevel > 0) {
  1160.                   System.out.println("Principal doesn't have privileges " + var1);
  1161.                }
  1162.  
  1163.                return;
  1164.             }
  1165.  
  1166.             if (var2 instanceof ParameterizedTarget) {
  1167.                ParameterizedTarget var9 = (ParameterizedTarget)var2;
  1168.                var9.unregisterPrincipal(var1);
  1169.             }
  1170.  
  1171.             var4.remove(var2);
  1172.          } catch (Throwable var15) {
  1173.             throw var15;
  1174.          }
  1175.  
  1176.          var7 = this.itsPrinToPrivTable;
  1177.          synchronized(var7){}
  1178.  
  1179.          try {
  1180.             PrivilegeTable var17 = new PrivilegeTable();
  1181.             this.itsPrinToPrivTable.put(var1, var17);
  1182.             Enumeration var3 = var4.keys();
  1183.  
  1184.             while(var3.hasMoreElements()) {
  1185.                Target var6 = (Target)var3.nextElement();
  1186.                Privilege var5 = var4.get(var6);
  1187.                this.updatePrivilegeTable(var6, var17, var5);
  1188.             }
  1189.          } catch (Throwable var14) {
  1190.             throw var14;
  1191.          }
  1192.  
  1193.       }
  1194.    }
  1195.  
  1196.    void removeAllParameterizedTargets(Principal var1) {
  1197.       Hashtable var5 = this.itsPrinToPrivTable;
  1198.       synchronized(var5){}
  1199.  
  1200.       try {
  1201.          PrivilegeTable var3 = (PrivilegeTable)this.itsPrinToPrivTable.get(var1);
  1202.          Enumeration var2 = var3.keys();
  1203.  
  1204.          while(var2.hasMoreElements()) {
  1205.             Target var4 = (Target)var2.nextElement();
  1206.             if (var4 instanceof ParameterizedTarget) {
  1207.                ParameterizedTarget var7 = (ParameterizedTarget)var4;
  1208.                var7.unregisterPrincipal(var1);
  1209.             }
  1210.          }
  1211.       } catch (Throwable var9) {
  1212.          throw var9;
  1213.       }
  1214.  
  1215.    }
  1216.  
  1217.    String getArchiveFileName() {
  1218.       if (SignedAppletDBName == null) {
  1219.          SignedAppletDBName = this.getWHFileName("", 1);
  1220.       }
  1221.  
  1222.       return SignedAppletDBName;
  1223.    }
  1224.  
  1225.    String getArchiveFileName(String var1) {
  1226.       return this.getWHFileName(var1, 1);
  1227.    }
  1228.  
  1229.    private synchronized void save() {
  1230.       SecurityManager.enablePrivilege("UniversalFileWrite");
  1231.       String var2 = this.getArchiveFileName();
  1232.  
  1233.       FileOutputStream var1;
  1234.       try {
  1235.          var1 = new FileOutputStream(var2);
  1236.       } catch (FileNotFoundException var6) {
  1237.          System.err.println("Error1: can't open <" + var2 + "> to save java capabilities list");
  1238.          return;
  1239.       } catch (IOException var7) {
  1240.          System.err.println("Error2: can't open <" + var2 + "> to save java capabilities list");
  1241.          return;
  1242.       }
  1243.  
  1244.       try {
  1245.          this.save(var1);
  1246.       } catch (Exception var5) {
  1247.          System.err.println("Error: unable to save java capabilities list into <" + var2 + "> " + var5);
  1248.       }
  1249.  
  1250.       try {
  1251.          var1.close();
  1252.       } catch (IOException var4) {
  1253.          System.err.println("Error while saving java capabilities list into <" + var2 + ">");
  1254.       }
  1255.    }
  1256.  
  1257.    private void save(OutputStream var1) {
  1258.       Hashtable var10 = new Hashtable();
  1259.       Enumeration var4 = this.itsPrinToMacroTargetPrivTable.keys();
  1260.  
  1261.       while(var4.hasMoreElements()) {
  1262.          Principal var7 = (Principal)var4.nextElement();
  1263.          PrivilegeTable var6 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var7);
  1264.          synchronized(var6){}
  1265.  
  1266.          try {
  1267.             PrivilegeTable var11 = new PrivilegeTable();
  1268.             Enumeration var5 = var6.keys();
  1269.  
  1270.             while(var5.hasMoreElements()) {
  1271.                Target var9 = (Target)var5.nextElement();
  1272.                Privilege var8 = var6.get(var9);
  1273.                switch (var8.getDuration()) {
  1274.                   case 2:
  1275.                      if (theDebugLevel > 0) {
  1276.                         System.out.println("saving target: " + var9 + " privilege: " + var8);
  1277.                      }
  1278.  
  1279.                      var11.put(var9, var8);
  1280.                }
  1281.             }
  1282.  
  1283.             if (var11.size() > 0) {
  1284.                var10.put(var7, var11);
  1285.                if (theDebugLevel > 0) {
  1286.                   System.out.println("saving principal: " + var7);
  1287.                }
  1288.             }
  1289.          } catch (Throwable var18) {
  1290.             throw var18;
  1291.          }
  1292.       }
  1293.  
  1294.       Archive var2 = new Archive();
  1295.       Archiver var3 = new Archiver(var2);
  1296.  
  1297.       try {
  1298.          var3.archiveRootObject(var10);
  1299.       } catch (CodingException var17) {
  1300.          System.err.println("Internal error during archiving of Capabilities");
  1301.          ((Throwable)var17).printStackTrace(System.out);
  1302.          return;
  1303.       }
  1304.  
  1305.       try {
  1306.          var2.write(var1);
  1307.       } catch (Exception var16) {
  1308.          System.err.println("Error during serializing java Capabilities " + var16);
  1309.       }
  1310.    }
  1311.  
  1312.    boolean isSecurityInited() {
  1313.       return theSecurityInited;
  1314.    }
  1315.  
  1316.    private synchronized void load() {
  1317.       if (!theSecurityInited) {
  1318.          Object var1 = null;
  1319.          String var2 = this.getArchiveFileName();
  1320.          SecurityManager.enablePrivilege("UniversalFileRead");
  1321.  
  1322.          try {
  1323.             var6 = new FileInputStream(var2);
  1324.          } catch (Exception var5) {
  1325.             var6 = null;
  1326.          }
  1327.  
  1328.          if (var6 == null) {
  1329.             var2 = this.getArchiveFileName("0");
  1330.  
  1331.             try {
  1332.                var6 = new FileInputStream(var2);
  1333.             } catch (Exception var4) {
  1334.                return;
  1335.             }
  1336.          }
  1337.  
  1338.          this.load(var6, (Principal[])null);
  1339.  
  1340.          try {
  1341.             var6.close();
  1342.          } catch (IOException var3) {
  1343.             System.err.println("Error while reading java Capabilities file <" + var2 + ">");
  1344.             return;
  1345.          }
  1346.  
  1347.          theSecurityInited = true;
  1348.       }
  1349.    }
  1350.  
  1351.    private void load(InputStream var1, Principal[] var2) {
  1352.       Object var6 = null;
  1353.       Archive var3 = new Archive();
  1354.  
  1355.       try {
  1356.          var3.read(var1);
  1357.       } catch (Exception var18) {
  1358.          System.err.println("Error: unable to read java Capabilities from archive " + var18);
  1359.          return;
  1360.       }
  1361.  
  1362.       int[] var19 = var3.rootIdentifiers();
  1363.       Unarchiver var4 = new Unarchiver(var3);
  1364.  
  1365.       Object var5;
  1366.       try {
  1367.          var5 = var4.unarchiveIdentifier(var19[0]);
  1368.       } catch (Exception var17) {
  1369.          System.err.println("Error: old java capabilites list was lost " + var17);
  1370.          return;
  1371.       }
  1372.  
  1373.       if (var5 != null) {
  1374.          Hashtable var13 = (Hashtable)var5;
  1375.          Enumeration var7 = var13.keys();
  1376.  
  1377.          while(var7.hasMoreElements()) {
  1378.             Principal var15 = (Principal)var7.nextElement();
  1379.             PrivilegeTable var14 = (PrivilegeTable)var13.get(var15);
  1380.             if (theDebugLevel > 0) {
  1381.                System.out.println("loading principal " + var15);
  1382.             }
  1383.  
  1384.             this.registerPrincipal(var15);
  1385.             PrivilegeTable var9 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var15);
  1386.             Enumeration var8 = var14.keys();
  1387.  
  1388.             while(var8.hasMoreElements()) {
  1389.                Target var11 = (Target)var8.nextElement();
  1390.                Privilege var10 = var14.get(var11);
  1391.                if (theDebugLevel > 0) {
  1392.                   System.out.println("addng target: " + var11 + " with privilege: " + var10);
  1393.                }
  1394.  
  1395.                Target var12 = Target.findTarget(var11);
  1396.                if (var12 == null) {
  1397.                   if (theDebugLevel > 0) {
  1398.                      System.out.println("registering non-system target " + var11);
  1399.                   }
  1400.  
  1401.                   var12 = var11.registerTarget();
  1402.                }
  1403.  
  1404.                var10 = Privilege.findPrivilege(var10.getPermission(), var10.getDuration());
  1405.                if (var2 != null && !this.matchPrincipal(var12.getPrincipal(), var2)) {
  1406.                   throw new ForbiddenTargetException("None of principals in " + var2[0].toString() + " can modify privileges of Target: " + var12);
  1407.                }
  1408.  
  1409.                var9.put(var12, var10);
  1410.             }
  1411.          }
  1412.  
  1413.          this.explodePrivilege();
  1414.       }
  1415.    }
  1416.  
  1417.    private void explodePrivilege() {
  1418.       Enumeration var1 = this.itsPrinToMacroTargetPrivTable.keys();
  1419.  
  1420.       while(var1.hasMoreElements()) {
  1421.          Principal var4 = (Principal)var1.nextElement();
  1422.          PrivilegeTable var3 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var4);
  1423.          PrivilegeTable var7 = (PrivilegeTable)this.itsPrinToPrivTable.get(var4);
  1424.          Enumeration var2 = var3.keys();
  1425.  
  1426.          while(var2.hasMoreElements()) {
  1427.             Target var6 = (Target)var2.nextElement();
  1428.             Privilege var5 = var3.get(var6);
  1429.             this.updatePrivilegeTable(var6, var7, var5);
  1430.          }
  1431.       }
  1432.  
  1433.    }
  1434.  
  1435.    public synchronized boolean read(InputStream var1) {
  1436.       if (var1 == null) {
  1437.          return false;
  1438.       } else {
  1439.          PrivilegeManager var2 = getPrivilegeManager();
  1440.          if (var2 == null) {
  1441.             return false;
  1442.          } else {
  1443.             Principal[] var3 = var2.getClassPrincipalsFromStack(1);
  1444.             if (var3 == null) {
  1445.                return false;
  1446.             } else {
  1447.                this.load(var1, var3);
  1448.                return true;
  1449.             }
  1450.          }
  1451.       }
  1452.    }
  1453.  
  1454.    public synchronized boolean write(OutputStream var1) {
  1455.       this.save(var1);
  1456.       return true;
  1457.    }
  1458.  
  1459.    private boolean doesCallerHavePrivilegeToModifyPermission(Target var1, int var2) {
  1460.       PrivilegeManager var3 = getPrivilegeManager();
  1461.       return var3 == null ? false : var3.isCalledByPrincipal(var1.getPrincipal(), var2 + 1);
  1462.    }
  1463.  
  1464.    public void addPrivilege(Principal var1, Target var2, Privilege var3) {
  1465.       Target var4 = Target.findTarget(var2);
  1466.       if (var4 == null) {
  1467.          throw new ForbiddenTargetException(var2 + " is not a registered target");
  1468.       } else {
  1469.          var2 = var4;
  1470.          if (!this.doesCallerHavePrivilegeToModifyPermission(var4, 1)) {
  1471.             throw new ForbiddenTargetException("Principal " + var1 + " is not allowed to modify privileges of Target: " + var4);
  1472.          } else {
  1473.             Principal[] var5 = new Principal[]{var1};
  1474.             if (this.getPrincipalPrivilege(var4, var5) != 2) {
  1475.                throw new ForbiddenTargetException("Principal " + var1 + " already has privileges set for Target: " + var4);
  1476.             } else {
  1477.                Object var6 = UpdateLock;
  1478.                synchronized(var6){}
  1479.  
  1480.                try {
  1481.                   this.registerPrincipalAndSetPrivileges(var1, var2, var3);
  1482.                } catch (Throwable var8) {
  1483.                   throw var8;
  1484.                }
  1485.  
  1486.             }
  1487.          }
  1488.       }
  1489.    }
  1490.  
  1491.    public void modifyPrivilege(Principal var1, Target var2, Privilege var3) {
  1492.       Target var4 = Target.findTarget(var2);
  1493.       if (var4 == null) {
  1494.          throw new ForbiddenTargetException(var2 + " is not a registered target");
  1495.       } else {
  1496.          var2 = var4;
  1497.          if (!this.doesCallerHavePrivilegeToModifyPermission(var4, 1)) {
  1498.             throw new ForbiddenTargetException("Principal " + var1 + " is not allowed to modify privileges of Target: " + var4);
  1499.          } else {
  1500.             Object var5 = UpdateLock;
  1501.             synchronized(var5){}
  1502.  
  1503.             try {
  1504.                this.registerPrincipalAndSetPrivileges(var1, var2, var3);
  1505.             } catch (Throwable var7) {
  1506.                throw var7;
  1507.             }
  1508.  
  1509.          }
  1510.       }
  1511.    }
  1512.  
  1513.    public void removePrivilege(Principal var1, Target var2) {
  1514.       Target var3 = Target.findTarget(var2);
  1515.       if (var3 == null) {
  1516.          throw new ForbiddenTargetException(var2 + " is not a registered target");
  1517.       } else if (!this.doesCallerHavePrivilegeToModifyPermission(var3, 1)) {
  1518.          throw new ForbiddenTargetException("Principal " + var1 + " is not allowed to modify privileges of Target: " + var3);
  1519.       } else {
  1520.          this.remove(var1, var3);
  1521.       }
  1522.    }
  1523.  
  1524.    public PrivilegeTable getPrivilegeTable(Principal var1) {
  1525.       Hashtable var3 = this.itsPrinToMacroTargetPrivTable;
  1526.       synchronized(var3){}
  1527.  
  1528.       PrivilegeTable var2;
  1529.       try {
  1530.          var2 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var1);
  1531.       } catch (Throwable var5) {
  1532.          throw var5;
  1533.       }
  1534.  
  1535.       return var2 != null && var2.size() != 0 ? (PrivilegeTable)var2.clone() : null;
  1536.    }
  1537. }
  1538.