home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1998 September / PCO_0998.ISO / browser / ns405lyc / nav40.z / java40.jar / netscape / secfile / SecureFile.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-03-24  |  7.3 KB  |  399 lines
  1. package netscape.secfile;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.File;
  6. import java.io.FileReader;
  7. import java.io.FileWriter;
  8. import java.io.FilenameFilter;
  9. import java.io.IOException;
  10. import java.io.Writer;
  11. import java.util.Hashtable;
  12. import java.util.Vector;
  13. import netscape.security.Principal;
  14. import netscape.security.PrivilegeManager;
  15.  
  16. public class SecureFile extends File {
  17.    private static String indexDir = null;
  18.    private static String indexDirSep;
  19.    private static Hashtable prinToReldirHashtable = new Hashtable();
  20.    private String prepend;
  21.    private Principal prin;
  22.    private String path;
  23.    private String canonicalPath;
  24.    public static final String separator;
  25.    public static final char separatorChar;
  26.    public static final String pathSeparator;
  27.    public static final char pathSeparatorChar;
  28.  
  29.    private static long random() {
  30.       PrivilegeManager.enableTarget("UniversalPropertyRead");
  31.       PrivilegeManager.enableTarget("UniversalFileRead");
  32.       File var0 = new File(System.getProperty("user.home"));
  33.       long var1 = 0L;
  34.       if (var0.list() != null) {
  35.          for(int var3 = 0; var3 < var0.list().length; ++var3) {
  36.             File var4 = new File(System.getProperty("user.home") + File.separator + var0.list()[var3]);
  37.             var1 += var4.length();
  38.          }
  39.       }
  40.  
  41.       long var5 = System.currentTimeMillis();
  42.       return (var1 & 65535L) << 16 | var5 & 65535L;
  43.    }
  44.  
  45.    private static synchronized void getIndexDir() {
  46.       if (indexDir == null) {
  47.          PrivilegeManager.enableTarget("UniversalPropertyRead");
  48.          indexDir = System.getProperty("user.home") + separator + "secfile";
  49.          indexDirSep = indexDir + separator;
  50.          File var0 = new File(indexDir);
  51.          PrivilegeManager.enableTarget("UniversalFileRead");
  52.          if (!var0.exists()) {
  53.             PrivilegeManager.enableTarget("UniversalFileWrite");
  54.             if (!var0.mkdir()) {
  55.                throw new SecureFileException("Error creating secfile directory");
  56.             }
  57.          }
  58.       }
  59.  
  60.    }
  61.  
  62.    private static void putIndexfileIntoHashtable() {
  63.       Hashtable var0 = prinToReldirHashtable;
  64.       synchronized(var0){}
  65.  
  66.       try {
  67.          if (prinToReldirHashtable.size() == 0) {
  68.             File var2 = new File(indexDirSep + "index.txt");
  69.             PrivilegeManager.enableTarget("UniversalFileRead");
  70.             if (var2.exists()) {
  71.                try {
  72.                   BufferedReader var3 = new BufferedReader(new FileReader(indexDirSep + "index.txt"));
  73.  
  74.                   while(true) {
  75.                      String var4 = var3.readLine();
  76.                      if (var4 == null) {
  77.                         break;
  78.                      }
  79.  
  80.                      int var5 = var4.indexOf(" ");
  81.                      if (var5 <= 0 || var5 >= var4.length() - 1) {
  82.                         var3.close();
  83.                         var2.renameTo(new File(indexDirSep + "index.bad"));
  84.                         throw new SecureFileException("Syntax error in index file");
  85.                      }
  86.  
  87.                      prinToReldirHashtable.put(var4.substring(var5 + 1), var4.substring(0, var5));
  88.                   }
  89.                } catch (IOException var8) {
  90.                   var2.renameTo(new File(indexDirSep + "index.bad"));
  91.                   throw new SecureFileException("Error reading index file" + var8);
  92.                }
  93.             }
  94.          }
  95.       } catch (Throwable var9) {
  96.          throw var9;
  97.       }
  98.  
  99.    }
  100.  
  101.    private static void addNewPrincipal(String var0) {
  102.       Hashtable var2 = prinToReldirHashtable;
  103.       synchronized(var2){}
  104.  
  105.       try {
  106.          if (prinToReldirHashtable.get(var0) == null) {
  107.             PrivilegeManager.enableTarget("UniversalFileRead");
  108.  
  109.             String var1;
  110.             String var4;
  111.             do {
  112.                var4 = Long.toString(random(), 16);
  113.                var1 = indexDirSep + var4;
  114.             } while((new File(var1)).exists());
  115.  
  116.             PrivilegeManager.enableTarget("UniversalFileWrite");
  117.             if (!(new File(var1)).mkdir()) {
  118.                throw new SecureFileException("Error creating directory for " + var0);
  119.             }
  120.  
  121.             try {
  122.                BufferedWriter var5 = new BufferedWriter(new FileWriter(indexDirSep + "index.txt", true));
  123.                ((Writer)var5).write(var4 + ' ' + var0);
  124.                var5.newLine();
  125.                var5.flush();
  126.             } catch (IOException var8) {
  127.                throw new SecureFileException("Error writing index file");
  128.             }
  129.  
  130.             prinToReldirHashtable.put(var0, var4);
  131.          }
  132.       } catch (Throwable var9) {
  133.          throw var9;
  134.       }
  135.  
  136.    }
  137.  
  138.    static String getPrepend(Principal var0, int var1) {
  139.       String var2 = var0.toString();
  140.       if (!checkPrincipal(var0, var1 + 1)) {
  141.          throw new SecureFileException("Unauthorized principal:" + var2);
  142.       } else {
  143.          if (indexDir == null) {
  144.             getIndexDir();
  145.          }
  146.  
  147.          if (prinToReldirHashtable.size() == 0) {
  148.             putIndexfileIntoHashtable();
  149.          }
  150.  
  151.          if (prinToReldirHashtable.get(var2) == null) {
  152.             addNewPrincipal(var2);
  153.          }
  154.  
  155.          return indexDirSep + prinToReldirHashtable.get(var2);
  156.       }
  157.    }
  158.  
  159.    static String getPrependedPath(String var0, String var1) {
  160.       if (var1 != null && var1 != "") {
  161.          return var1.startsWith(separator) ? var0 + var1 : var0 + separator + var1;
  162.       } else {
  163.          return var0;
  164.       }
  165.    }
  166.  
  167.    private static boolean checkPrincipal(Principal var0, int var1) {
  168.       if (var0.isCodebaseExact() && var0.toString().equals("Common")) {
  169.          return true;
  170.       } else {
  171.          PrivilegeManager var2 = PrivilegeManager.getPrivilegeManager();
  172.          return var2 == null ? false : var2.isCalledByPrincipal(var0, var1 + 1);
  173.       }
  174.    }
  175.  
  176.    static String checkCanonicalPath(String var0, String var1) {
  177.       PrivilegeManager.enableTarget("UniversalFileRead");
  178.  
  179.       String var2;
  180.       try {
  181.          if (var0.startsWith(separator)) {
  182.             var2 = (new File(var1 + var0)).getCanonicalPath();
  183.          } else {
  184.             var2 = (new File(var1 + separator + var0)).getCanonicalPath();
  185.          }
  186.       } catch (IOException var3) {
  187.          throw new SecureFileException("Unable to verify canonical path");
  188.       }
  189.  
  190.       if (!var2.startsWith(var1)) {
  191.          throw new SecureFileException("Canonical path is outside of principal's subdirectory");
  192.       } else {
  193.          return var2.substring(var1.length());
  194.       }
  195.    }
  196.  
  197.    static Principal getClassPrincipal(int var0) {
  198.       PrivilegeManager var1 = PrivilegeManager.getPrivilegeManager();
  199.       return var1 == null ? null : var1.getClassPrincipalsFromStack(var0 + 1)[0];
  200.    }
  201.  
  202.    public SecureFile(String var1) {
  203.       this(var1, getClassPrincipal(1), 1);
  204.    }
  205.  
  206.    public SecureFile(String var1, String var2) {
  207.       this(var1, var2, getClassPrincipal(1), 1);
  208.    }
  209.  
  210.    public SecureFile(SecureFile var1, String var2) {
  211.       this(var1.getPath(), var2, var1.getPrincipal(), 1);
  212.    }
  213.  
  214.    public SecureFile(String var1, Principal var2) {
  215.       this(var1, var2, 1);
  216.    }
  217.  
  218.    private SecureFile(String var1, Principal var2, int var3) {
  219.       super(getPrependedPath(getPrepend(var2, var3 + 1), var1));
  220.       this.prepend = getPrepend(var2, var3 + 1);
  221.       if (var1 != null) {
  222.          this.path = var1;
  223.       } else {
  224.          this.path = "";
  225.       }
  226.  
  227.       this.prin = var2;
  228.       this.canonicalPath = checkCanonicalPath(this.path, this.prepend);
  229.    }
  230.  
  231.    public SecureFile(String var1, String var2, Principal var3) {
  232.       this(var1, var2, var3, 1);
  233.    }
  234.  
  235.    private SecureFile(String var1, String var2, Principal var3, int var4) {
  236.       super(getPrependedPath(getPrepend(var3, var4 + 1), var1), var2);
  237.       this.prepend = getPrepend(var3, var4 + 1);
  238.       if (var1 != null) {
  239.          if (var1.endsWith(separator)) {
  240.             this.path = var1 + var2;
  241.          } else {
  242.             this.path = var1 + separator + var2;
  243.          }
  244.       } else {
  245.          this.path = var2;
  246.       }
  247.  
  248.       this.prin = var3;
  249.       this.canonicalPath = checkCanonicalPath(this.path, this.prepend);
  250.    }
  251.  
  252.    public Principal getPrincipal() {
  253.       return this.prin;
  254.    }
  255.  
  256.    public String getPath() {
  257.       return this.path;
  258.    }
  259.  
  260.    public String getAbsolutePath() {
  261.       return this.path.startsWith(separator) ? this.path : separator + this.path;
  262.    }
  263.  
  264.    public String getCanonicalPath() throws IOException {
  265.       return this.canonicalPath;
  266.    }
  267.  
  268.    public String getParent() {
  269.       int var1 = this.path.lastIndexOf(separatorChar);
  270.       if (var1 < 0) {
  271.          return null;
  272.       } else if (var1 > 0) {
  273.          return this.path.substring(0, var1);
  274.       } else {
  275.          return this.path.length() > 1 ? this.path.substring(0, 1) : null;
  276.       }
  277.    }
  278.  
  279.    public boolean exists() {
  280.       PrivilegeManager.enableTarget("UniversalFileRead");
  281.       return super.exists();
  282.    }
  283.  
  284.    public boolean canWrite() {
  285.       PrivilegeManager.enableTarget("UniversalFileWrite");
  286.       return super.canWrite();
  287.    }
  288.  
  289.    public boolean canRead() {
  290.       PrivilegeManager.enableTarget("UniversalFileRead");
  291.       return super.canRead();
  292.    }
  293.  
  294.    public boolean isFile() {
  295.       PrivilegeManager.enableTarget("UniversalFileRead");
  296.       return super.isFile();
  297.    }
  298.  
  299.    public boolean isDirectory() {
  300.       PrivilegeManager.enableTarget("UniversalFileRead");
  301.       return super.isDirectory();
  302.    }
  303.  
  304.    public long lastModified() {
  305.       PrivilegeManager.enableTarget("UniversalFileRead");
  306.       return super.lastModified();
  307.    }
  308.  
  309.    public long length() {
  310.       PrivilegeManager.enableTarget("UniversalFileRead");
  311.       return super.length();
  312.    }
  313.  
  314.    public boolean mkdir() {
  315.       PrivilegeManager.enableTarget("UniversalFileWrite");
  316.       return super.mkdir();
  317.    }
  318.  
  319.    public boolean renameTo(SecureFile var1) {
  320.       PrivilegeManager.enableTarget("UniversalFileWrite");
  321.       return super.renameTo(new File(getPrepend(var1.getPrincipal(), 1) + var1.getAbsolutePath()));
  322.    }
  323.  
  324.    public boolean mkdirs() {
  325.       PrivilegeManager.enableTarget("UniversalFileWrite");
  326.       if (this.exists()) {
  327.          return false;
  328.       } else if (this.mkdir()) {
  329.          return true;
  330.       } else {
  331.          String var1 = this.getParent();
  332.          return var1 != null && (new SecureFile(var1, getClassPrincipal(1), 1)).mkdirs() && this.mkdir();
  333.       }
  334.    }
  335.  
  336.    public String[] list() {
  337.       PrivilegeManager.enableTarget("UniversalFileRead");
  338.       return super.list();
  339.    }
  340.  
  341.    public String[] list(FilenameFilter var1) {
  342.       String[] var2 = this.list();
  343.       if (var2 == null) {
  344.          return null;
  345.       } else {
  346.          Vector var3 = new Vector();
  347.  
  348.          for(int var4 = 0; var4 < var2.length; ++var4) {
  349.             if (var1 == null || var1.accept(this, var2[var4])) {
  350.                var3.addElement(var2[var4]);
  351.             }
  352.          }
  353.  
  354.          String[] var5 = new String[var3.size()];
  355.          var3.copyInto(var5);
  356.          return var5;
  357.       }
  358.    }
  359.  
  360.    public boolean delete() {
  361.       PrivilegeManager.enableTarget("UniversalFileDelete");
  362.       return super.delete();
  363.    }
  364.  
  365.    public int hashCode() {
  366.       return this.path.hashCode() ^ 1234321;
  367.    }
  368.  
  369.    public boolean equals(Object var1) {
  370.       return var1 != null && var1 instanceof SecureFile ? this.path.equals(((SecureFile)var1).getPath()) : false;
  371.    }
  372.  
  373.    public String toString() {
  374.       return this.getPath();
  375.    }
  376.  
  377.    public long lastAccessed() {
  378.       PrivilegeManager.enableTarget("UniversalFileRead");
  379.       return super.lastAccessed();
  380.    }
  381.  
  382.    public long lastStatusChange() {
  383.       PrivilegeManager.enableTarget("UniversalFileRead");
  384.       return super.lastStatusChange();
  385.    }
  386.  
  387.    public boolean isLink() {
  388.       PrivilegeManager.enableTarget("UniversalFileRead");
  389.       return super.isLink();
  390.    }
  391.  
  392.    static {
  393.       separator = File.separator;
  394.       separatorChar = File.separatorChar;
  395.       pathSeparator = File.pathSeparator;
  396.       pathSeparatorChar = File.pathSeparatorChar;
  397.    }
  398. }
  399.