toolchain/gcc/libjava/java/io/FilePermission.java

   1 /* java.lang.FilePermission
   2    Copyright (C) 1998, 2000, 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.io;
  40
  41 import java.security.Permission;
  42
  43 public final class FilePermission extends Permission implements Serializable
  44 {
  45   static final long serialVersionUID = 7930732926638008763L;
  46
  47   private static final String CURRENT_DIRECTORY =
  48     System.getProperty("user.dir");
  49   private boolean usingPerms = false;
  50   private boolean readPerm = false;
  51   private boolean writePerm = false;
  52   private boolean executePerm = false;
  53   private boolean deletePerm = false;
  54   private String actionsString;
  55
  56   private void cachePerms()
  57   {
  58     // While race conditions could occur, they don't matter at all.
  59
  60     String action;
  61     int i = actionsString.indexOf(',');
  62     int startI = 0;
  63     while(i != -1)
  64       {
  65         action = actionsString.substring(startI,i);
  66         if(action.equals("read"))
  67           readPerm = true;
  68         else if(action.equals("write"))
  69           writePerm = true;
  70         else if(action.equals("execute"))
  71           executePerm = true;
  72         else if(action.equals("delete"))
  73           deletePerm = true;
  74
  75         startI = i+1;
  76         i = actionsString.indexOf(',',startI);
  77       }
  78
  79     action = actionsString.substring(startI);
  80     if(action.equals("read"))
  81       readPerm = true;
  82     else if(action.equals("write"))
  83       writePerm = true;
  84     else if(action.equals("execute"))
  85       executePerm = true;
  86     else if(action.equals("delete"))
  87       deletePerm = true;
  88   }
  89
  90   /** Create a new FilePermission.
  91    ** @param pathExpression an expression specifying the paths this
  92    **        permission represents.
  93    ** @param actionsString a comma-separated list of the actions this
  94    **        permission represents.
  95    ** FIXME: what to do when the file string is malformed?
  96    **/
  97   public FilePermission(String pathExpression, String actionsString)
  98   {
  99     super(pathExpression);
 100     this.actionsString = actionsString;
 101   }
 102
 103   /** Get the actions this FilePermission supports.
 104    ** @return the String representing the actions this FilePermission supports.
 105    **/
 106   public String getActions()
 107   {
 108     return actionsString;
 109   }
 110
 111   /** Get the hash code for this Object.<P>
 112    ** FilePermission's hash code is calculated as the exclusive or of the
 113    ** target
 114    ** String's hash code and the action String's hash code.
 115    ** @specnote Sun did not specify how to calculate the hash code;
 116    ** I made this up.
 117    ** @return the hash code for this Object.
 118    **/
 119   public int hashCode()
 120   {
 121     return getName().hashCode() ^ actionsString.hashCode();
 122   }
 123
 124   /** Check two FilePermissions for semantic equality.
 125    ** Two FilePermissions are exactly equivalent if they have identical path
 126    ** expressions and have exactly the same access permissions.
 127    ** @param o the Object to compare to.
 128    ** @return whether the Objects are semantically equivalent.
 129    **/
 130   public boolean equals(Object o)
 131   {
 132     if(!(o instanceof FilePermission))
 133       return false;
 134     FilePermission p = (FilePermission)o;
 135     if(!usingPerms)
 136       cachePerms();
 137     if(!p.usingPerms)
 138       p.cachePerms();
 139
 140     String f1 = getName();
 141     String f2 = p.getName();
 142
 143     /* Compare names, taking into account if they refer to a
 144      * directory and one has a separator and the other does not.
 145      */
 146     if(f1.length() > 0 && f1.charAt(f1.length() - 1) == File.separatorChar)
 147       {
 148         if(f2.length() > 0
 149            && f2.charAt(f2.length() - 1) == File.separatorChar)
 150           {
 151             if(!f2.equals(f1))
 152               return false;
 153           }
 154         else
 155           {
 156             if(!f2.equals(f1.substring(0,f1.length()-1)))
 157               return false;
 158           }
 159       }
 160     else
 161       {
 162         if(f2.length() > 0
 163            && f2.charAt(f2.length() - 1) == File.separatorChar)
 164           {
 165             if(!f1.equals(f2.substring(0,f2.length()-1)))
 166               return false;
 167           }
 168         else
 169           {
 170             if(!f1.equals(f2))
 171               return false;
 172           }
 173        }
 174     return readPerm == p.readPerm && writePerm == p.writePerm && executePerm == p.executePerm && deletePerm == p.deletePerm;
 175   }
 176
 177   /** Check to see if this permission implies another.
 178    ** Permission A implies permission B if these things are all true:
 179    ** <OL>
 180    ** <LI>A and B are both FilePermissions.</LI>
 181    ** <LI>All possible files in B are included in A
 182    ** (possibly more are in A).</LI>
 183    ** <LI>All actions B supports, A also supports.</LI>
 184    ** </OL>
 185    ** @param p the Permission to compare against.
 186    ** @return whether this Permission implies p
 187    **/
 188   public boolean implies(Permission p)
 189   {
 190     FilePermission fp;
 191
 192     if(!(p instanceof FilePermission))
 193       return false;
 194
 195     fp = (FilePermission)p;
 196
 197     String f1 = getName();
 198     String f2 = fp.getName();
 199
 200     if(f1.charAt(0) != File.separatorChar)
 201       {
 202         f1 = CURRENT_DIRECTORY + f1;
 203       }
 204     if(f2.charAt(0) != File.separatorChar)
 205       {
 206         f2 = CURRENT_DIRECTORY + f2;
 207       }
 208
 209     String sub1;
 210
 211     switch(f1.charAt(f1.length() - 1))
 212       {
 213         case '*':
 214           sub1 = f1.substring(0,f1.length() - 1); // chop off "*"
 215           if(f2.length() <= sub1.length())
 216             {
 217           /* If it's smaller, there is no way it could be part of this
 218            * directory.
 219            * If it's the same (or length - 1), it could be the same
 220            * directory but
 221            * specifies access to the directory rather than the files in it.
 222            */
 223               return false;
 224             }
 225           else if(f2.charAt(sub1.length() - 1) == File.separatorChar)
 226             {
 227               /* Make sure the part before the "/" is the same */
 228               if(!f2.substring(0,sub1.length()).equals(sub1))
 229                 return false;
 230               /* Make sure there are no subdirectories specified
 231                  underneath this one */
 232               String sub2 = f2.substring(sub1.length()+1);
 233               if(f2.substring(sub1.length()+1).indexOf(File.separatorChar)
 234                  != -1)
 235                 return false;
 236             }
 237           else
 238             {
 239           /* Obviously not equal: f2 is either not a directory or is not
 240            * the same directory (its name continues further than we want)
 241            */
 242               return false;
 243             }
 244           break;
 245         case '-':
 246           sub1 = f1.substring(0,f1.length() - 2); // chop off "/-"
 247           if(f2.length() < sub1.length())
 248             {
 249              /* If it's smaller, there is no way it could be part of
 250               * this directory. */
 251               return false;
 252             }
 253           else if(f2.length() > sub1.length() && f2.charAt(sub1.length())
 254              != File.separatorChar)
 255             {
 256               return false;
 257
 258             }
 259           else if(!f2.substring(0,sub1.length()).equals(sub1))
 260             return false;
 261           break;
 262 /* Looks redundant with default case and won't compile anyway - arenn
 263     case File.separatorChar:
 264       if(f2.charAt(f2.length()) == File.separatorChar) {
 265         if(!f2.equals(f1))
 266           return false;
 267       } else {
 268         if(!f2.equals(f1.substring(0,f1.length()-1)))
 269           return false;
 270       }
 271       break;
 272 */
 273         default:
 274           if(f2.charAt(f2.length()) == File.separatorChar)
 275             {
 276               if(!f1.equals(f2.substring(0,f2.length()-1)))
 277                 return false;
 278             }
 279           else
 280             {
 281               if(!f1.equals(f2))
 282                 return false;
 283             }
 284          break;
 285       }
 286
 287     if(!usingPerms)
 288       cachePerms();
 289     if(!fp.usingPerms)
 290       fp.cachePerms();
 291
 292     if(readPerm && !fp.readPerm)
 293       return false;
 294     if(writePerm && !fp.writePerm)
 295       return false;
 296     if(executePerm && !fp.executePerm)
 297       return false;
 298     if(deletePerm && !fp.deletePerm)
 299       return false;
 300
 301     return true;
 302   }
 303 } // class FilePermission
 304