src/solaris/classes/sun/nio/fs/UnixFileAttributeViews.java

Print this page




 106                 if (retry) {
 107                     if (modValue < 0L) modValue = 0L;
 108                     if (accessValue < 0L) accessValue= 0L;
 109                     try {
 110                         futimes(fd, accessValue, modValue);
 111                     } catch (UnixException x) {
 112                         x.rethrowAsIOException(file);
 113                     }
 114                 }
 115             } finally {
 116                 close(fd);
 117             }
 118         }
 119     }
 120 
 121     private static class Posix extends Basic implements PosixFileAttributeView {
 122         private static final String PERMISSIONS_NAME = "permissions";
 123         private static final String OWNER_NAME = "owner";
 124         private static final String GROUP_NAME = "group";
 125 




 126         Posix(UnixPath file, boolean followLinks) {
 127             super(file, followLinks);
 128         }
 129 
 130         final void checkReadExtended() {
 131             SecurityManager sm = System.getSecurityManager();
 132             if (sm != null) {
 133                 file.checkRead();
 134                 sm.checkPermission(new RuntimePermission("accessUserInformation"));
 135             }
 136         }
 137 
 138         final void checkWriteExtended() {
 139             SecurityManager sm = System.getSecurityManager();
 140             if (sm != null) {
 141                 file.checkWrite();
 142                 sm.checkPermission(new RuntimePermission("accessUserInformation"));
 143             }
 144         }
 145 


 155         {
 156             if (attribute.equals(PERMISSIONS_NAME)) {
 157                 setPermissions((Set<PosixFilePermission>)value);
 158                 return;
 159             }
 160             if (attribute.equals(OWNER_NAME)) {
 161                 setOwner((UserPrincipal)value);
 162                 return;
 163             }
 164             if (attribute.equals(GROUP_NAME)) {
 165                 setGroup((GroupPrincipal)value);
 166                 return;
 167             }
 168             super.setAttribute(attribute, value);
 169         }
 170 
 171         /**
 172          * Invoked by readAttributes or sub-classes to add all matching posix
 173          * attributes to the builder
 174          */
 175         final void addPosixAttributesToBuilder(PosixFileAttributes attrs,
 176                                                AttributesBuilder builder)
 177         {

 178             if (builder.match(PERMISSIONS_NAME))
 179                 builder.add(PERMISSIONS_NAME, attrs.permissions());
 180             if (builder.match(OWNER_NAME))
 181                  builder.add(OWNER_NAME, attrs.owner());
 182             if (builder.match(GROUP_NAME))
 183                 builder.add(GROUP_NAME, attrs.group());
 184         }
 185 
 186         @Override
 187         public Map<String,Object> readAttributes(String[] attributes)
 188             throws IOException
 189         {
 190             AttributesBuilder builder = AttributesBuilder.create(attributes);

 191             PosixFileAttributes attrs = readAttributes();
 192             addBasicAttributesToBuilder(attrs, builder);
 193             addPosixAttributesToBuilder(attrs, builder);
 194             return builder.unmodifiableMap();
 195         }
 196 
 197         @Override
 198         public UnixFileAttributes readAttributes() throws IOException {
 199             checkReadExtended();
 200             try {
 201                  return UnixFileAttributes.get(file, followLinks);
 202             } catch (UnixException x) {
 203                 x.rethrowAsIOException(file);
 204                 return null;    // keep compiler happy
 205             }
 206         }
 207 
 208         // chmod
 209         final void setMode(int mode) throws IOException {
 210             checkWriteExtended();
 211             try {
 212                 if (followLinks) {
 213                     chmod(file, mode);


 270         {
 271             if (group == null)
 272                 throw new NullPointerException("'owner' is null");
 273             if (!(group instanceof UnixUserPrincipals.Group))
 274                 throw new ProviderMismatchException();
 275             int gid = ((UnixUserPrincipals.Group)group).gid();
 276             setOwners(-1, gid);
 277         }
 278     }
 279 
 280     private static class Unix extends Posix {
 281         private static final String MODE_NAME = "mode";
 282         private static final String INO_NAME = "ino";
 283         private static final String DEV_NAME = "dev";
 284         private static final String RDEV_NAME = "rdev";
 285         private static final String NLINK_NAME = "nlink";
 286         private static final String UID_NAME = "uid";
 287         private static final String GID_NAME = "gid";
 288         private static final String CTIME_NAME = "ctime";
 289 






 290         Unix(UnixPath file, boolean followLinks) {
 291             super(file, followLinks);
 292         }
 293 
 294         @Override
 295         public String name() {
 296             return "unix";
 297         }
 298 
 299         @Override
 300         public void setAttribute(String attribute, Object value)
 301             throws IOException
 302         {
 303             if (attribute.equals(MODE_NAME)) {
 304                 setMode((Integer)value);
 305                 return;
 306             }
 307             if (attribute.equals(UID_NAME)) {
 308                 setOwners((Integer)value, -1);
 309                 return;
 310             }
 311             if (attribute.equals(GID_NAME)) {
 312                 setOwners(-1, (Integer)value);
 313                 return;
 314             }
 315             super.setAttribute(attribute, value);
 316         }
 317 
 318         @Override
 319         public Map<String,Object> readAttributes(String[] attributes)
 320             throws IOException
 321         {
 322             AttributesBuilder builder = AttributesBuilder.create(attributes);

 323             UnixFileAttributes attrs = readAttributes();
 324             addBasicAttributesToBuilder(attrs, builder);
 325             addPosixAttributesToBuilder(attrs, builder);
 326             if (builder.match(MODE_NAME))
 327                 builder.add(MODE_NAME, attrs.mode());
 328             if (builder.match(INO_NAME))
 329                 builder.add(INO_NAME, attrs.ino());
 330             if (builder.match(DEV_NAME))
 331                 builder.add(DEV_NAME, attrs.dev());
 332             if (builder.match(RDEV_NAME))
 333                 builder.add(RDEV_NAME, attrs.rdev());
 334             if (builder.match(NLINK_NAME))
 335                 builder.add(NLINK_NAME, attrs.nlink());
 336             if (builder.match(UID_NAME))
 337                 builder.add(UID_NAME, attrs.uid());
 338             if (builder.match(GID_NAME))
 339                 builder.add(GID_NAME, attrs.gid());
 340             if (builder.match(CTIME_NAME))
 341                 builder.add(CTIME_NAME, attrs.ctime());
 342             return builder.unmodifiableMap();
 343         }
 344     }
 345 


 106                 if (retry) {
 107                     if (modValue < 0L) modValue = 0L;
 108                     if (accessValue < 0L) accessValue= 0L;
 109                     try {
 110                         futimes(fd, accessValue, modValue);
 111                     } catch (UnixException x) {
 112                         x.rethrowAsIOException(file);
 113                     }
 114                 }
 115             } finally {
 116                 close(fd);
 117             }
 118         }
 119     }
 120 
 121     private static class Posix extends Basic implements PosixFileAttributeView {
 122         private static final String PERMISSIONS_NAME = "permissions";
 123         private static final String OWNER_NAME = "owner";
 124         private static final String GROUP_NAME = "group";
 125         
 126         // the names of the posix attributes (incudes basic)
 127         static final Set<String> posixAttributeNames = 
 128             Util.newSet(basicAttributeNames, PERMISSIONS_NAME, OWNER_NAME, GROUP_NAME);
 129 
 130         Posix(UnixPath file, boolean followLinks) {
 131             super(file, followLinks);
 132         }
 133 
 134         final void checkReadExtended() {
 135             SecurityManager sm = System.getSecurityManager();
 136             if (sm != null) {
 137                 file.checkRead();
 138                 sm.checkPermission(new RuntimePermission("accessUserInformation"));
 139             }
 140         }
 141 
 142         final void checkWriteExtended() {
 143             SecurityManager sm = System.getSecurityManager();
 144             if (sm != null) {
 145                 file.checkWrite();
 146                 sm.checkPermission(new RuntimePermission("accessUserInformation"));
 147             }
 148         }
 149 


 159         {
 160             if (attribute.equals(PERMISSIONS_NAME)) {
 161                 setPermissions((Set<PosixFilePermission>)value);
 162                 return;
 163             }
 164             if (attribute.equals(OWNER_NAME)) {
 165                 setOwner((UserPrincipal)value);
 166                 return;
 167             }
 168             if (attribute.equals(GROUP_NAME)) {
 169                 setGroup((GroupPrincipal)value);
 170                 return;
 171             }
 172             super.setAttribute(attribute, value);
 173         }
 174 
 175         /**
 176          * Invoked by readAttributes or sub-classes to add all matching posix
 177          * attributes to the builder
 178          */
 179         final void addRequestedPosixAttributes(PosixFileAttributes attrs,
 180                                                AttributesBuilder builder)
 181         {
 182             addRequestedBasicAttributes(attrs, builder);
 183             if (builder.match(PERMISSIONS_NAME))
 184                 builder.add(PERMISSIONS_NAME, attrs.permissions());
 185             if (builder.match(OWNER_NAME))
 186                  builder.add(OWNER_NAME, attrs.owner());
 187             if (builder.match(GROUP_NAME))
 188                 builder.add(GROUP_NAME, attrs.group());
 189         }
 190 
 191         @Override
 192         public Map<String,Object> readAttributes(String[] requested)
 193             throws IOException
 194         {
 195             AttributesBuilder builder = 
 196                 AttributesBuilder.create(posixAttributeNames, requested);
 197             PosixFileAttributes attrs = readAttributes();
 198             addRequestedPosixAttributes(attrs, builder);

 199             return builder.unmodifiableMap();
 200         }
 201 
 202         @Override
 203         public UnixFileAttributes readAttributes() throws IOException {
 204             checkReadExtended();
 205             try {
 206                  return UnixFileAttributes.get(file, followLinks);
 207             } catch (UnixException x) {
 208                 x.rethrowAsIOException(file);
 209                 return null;    // keep compiler happy
 210             }
 211         }
 212 
 213         // chmod
 214         final void setMode(int mode) throws IOException {
 215             checkWriteExtended();
 216             try {
 217                 if (followLinks) {
 218                     chmod(file, mode);


 275         {
 276             if (group == null)
 277                 throw new NullPointerException("'owner' is null");
 278             if (!(group instanceof UnixUserPrincipals.Group))
 279                 throw new ProviderMismatchException();
 280             int gid = ((UnixUserPrincipals.Group)group).gid();
 281             setOwners(-1, gid);
 282         }
 283     }
 284 
 285     private static class Unix extends Posix {
 286         private static final String MODE_NAME = "mode";
 287         private static final String INO_NAME = "ino";
 288         private static final String DEV_NAME = "dev";
 289         private static final String RDEV_NAME = "rdev";
 290         private static final String NLINK_NAME = "nlink";
 291         private static final String UID_NAME = "uid";
 292         private static final String GID_NAME = "gid";
 293         private static final String CTIME_NAME = "ctime";
 294         
 295         // the names of the unix attributes (including posix)
 296         static final Set<String> unixAttributeNames = 
 297             Util.newSet(posixAttributeNames, 
 298                         MODE_NAME, INO_NAME, DEV_NAME, RDEV_NAME, 
 299                         NLINK_NAME, UID_NAME, GID_NAME, CTIME_NAME);
 300 
 301         Unix(UnixPath file, boolean followLinks) {
 302             super(file, followLinks);
 303         }
 304 
 305         @Override
 306         public String name() {
 307             return "unix";
 308         }
 309 
 310         @Override
 311         public void setAttribute(String attribute, Object value)
 312             throws IOException
 313         {
 314             if (attribute.equals(MODE_NAME)) {
 315                 setMode((Integer)value);
 316                 return;
 317             }
 318             if (attribute.equals(UID_NAME)) {
 319                 setOwners((Integer)value, -1);
 320                 return;
 321             }
 322             if (attribute.equals(GID_NAME)) {
 323                 setOwners(-1, (Integer)value);
 324                 return;
 325             }
 326             super.setAttribute(attribute, value);
 327         }
 328 
 329         @Override
 330         public Map<String,Object> readAttributes(String[] requested)
 331             throws IOException
 332         {
 333             AttributesBuilder builder = 
 334                 AttributesBuilder.create(unixAttributeNames, requested);
 335             UnixFileAttributes attrs = readAttributes();
 336             addRequestedPosixAttributes(attrs, builder);

 337             if (builder.match(MODE_NAME))
 338                 builder.add(MODE_NAME, attrs.mode());
 339             if (builder.match(INO_NAME))
 340                 builder.add(INO_NAME, attrs.ino());
 341             if (builder.match(DEV_NAME))
 342                 builder.add(DEV_NAME, attrs.dev());
 343             if (builder.match(RDEV_NAME))
 344                 builder.add(RDEV_NAME, attrs.rdev());
 345             if (builder.match(NLINK_NAME))
 346                 builder.add(NLINK_NAME, attrs.nlink());
 347             if (builder.match(UID_NAME))
 348                 builder.add(UID_NAME, attrs.uid());
 349             if (builder.match(GID_NAME))
 350                 builder.add(GID_NAME, attrs.gid());
 351             if (builder.match(CTIME_NAME))
 352                 builder.add(CTIME_NAME, attrs.ctime());
 353             return builder.unmodifiableMap();
 354         }
 355     }
 356