@Override
public DynamicFileAttributeView getFileAttributeView(
Path obj, String name, LinkOption... options) {
if (name.equals("dos")) {
return new LinuxDosFileAttributeView(UnixPath.toUnixPath(obj), Util.followLinks(options));
}
if (name.equals("user")) {
return new LinuxUserDefinedFileAttributeView(
UnixPath.toUnixPath(obj), Util.followLinks(options));
}
return super.getFileAttributeView(obj, name, options);
}
@Override
@SuppressWarnings("unchecked")
public <V extends FileAttributeView> V getFileAttributeView(
Path obj, Class<V> type, LinkOption... options) {
if (type == DosFileAttributeView.class) {
return (V) new LinuxDosFileAttributeView(UnixPath.toUnixPath(obj), Util.followLinks(options));
}
if (type == UserDefinedFileAttributeView.class) {
return (V)
new LinuxUserDefinedFileAttributeView(
UnixPath.toUnixPath(obj), Util.followLinks(options));
}
return super.getFileAttributeView(obj, type, options);
}
private static class Unix extends Posix {
private static final String MODE_NAME = "mode";
private static final String INO_NAME = "ino";
private static final String DEV_NAME = "dev";
private static final String RDEV_NAME = "rdev";
private static final String NLINK_NAME = "nlink";
private static final String UID_NAME = "uid";
private static final String GID_NAME = "gid";
private static final String CTIME_NAME = "ctime";
// the names of the unix attributes (including posix)
static final Set<String> unixAttributeNames =
Util.newSet(
posixAttributeNames,
MODE_NAME,
INO_NAME,
DEV_NAME,
RDEV_NAME,
NLINK_NAME,
UID_NAME,
GID_NAME,
CTIME_NAME);
Unix(UnixPath file, boolean followLinks) {
super(file, followLinks);
}
@Override
public String name() {
return "unix";
}
@Override
public void setAttribute(String attribute, Object value) throws IOException {
if (attribute.equals(MODE_NAME)) {
setMode((Integer) value);
return;
}
if (attribute.equals(UID_NAME)) {
setOwners((Integer) value, -1);
return;
}
if (attribute.equals(GID_NAME)) {
setOwners(-1, (Integer) value);
return;
}
super.setAttribute(attribute, value);
}
@Override
public Map<String, Object> readAttributes(String[] requested) throws IOException {
AttributesBuilder builder = AttributesBuilder.create(unixAttributeNames, requested);
UnixFileAttributes attrs = readAttributes();
addRequestedPosixAttributes(attrs, builder);
if (builder.match(MODE_NAME)) builder.add(MODE_NAME, attrs.mode());
if (builder.match(INO_NAME)) builder.add(INO_NAME, attrs.ino());
if (builder.match(DEV_NAME)) builder.add(DEV_NAME, attrs.dev());
if (builder.match(RDEV_NAME)) builder.add(RDEV_NAME, attrs.rdev());
if (builder.match(NLINK_NAME)) builder.add(NLINK_NAME, attrs.nlink());
if (builder.match(UID_NAME)) builder.add(UID_NAME, attrs.uid());
if (builder.match(GID_NAME)) builder.add(GID_NAME, attrs.gid());
if (builder.match(CTIME_NAME)) builder.add(CTIME_NAME, attrs.ctime());
return builder.unmodifiableMap();
}
}
private static class Posix extends Basic implements PosixFileAttributeView {
private static final String PERMISSIONS_NAME = "permissions";
private static final String OWNER_NAME = "owner";
private static final String GROUP_NAME = "group";
// the names of the posix attributes (incudes basic)
static final Set<String> posixAttributeNames =
Util.newSet(basicAttributeNames, PERMISSIONS_NAME, OWNER_NAME, GROUP_NAME);
Posix(UnixPath file, boolean followLinks) {
super(file, followLinks);
}
final void checkReadExtended() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
file.checkRead();
sm.checkPermission(new RuntimePermission("accessUserInformation"));
}
}
final void checkWriteExtended() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
file.checkWrite();
sm.checkPermission(new RuntimePermission("accessUserInformation"));
}
}
@Override
public String name() {
return "posix";
}
@Override
@SuppressWarnings("unchecked")
public void setAttribute(String attribute, Object value) throws IOException {
if (attribute.equals(PERMISSIONS_NAME)) {
setPermissions((Set<PosixFilePermission>) value);
return;
}
if (attribute.equals(OWNER_NAME)) {
setOwner((UserPrincipal) value);
return;
}
if (attribute.equals(GROUP_NAME)) {
setGroup((GroupPrincipal) value);
return;
}
super.setAttribute(attribute, value);
}
/**
* Invoked by readAttributes or sub-classes to add all matching posix attributes to the builder
*/
final void addRequestedPosixAttributes(PosixFileAttributes attrs, AttributesBuilder builder) {
addRequestedBasicAttributes(attrs, builder);
if (builder.match(PERMISSIONS_NAME)) builder.add(PERMISSIONS_NAME, attrs.permissions());
if (builder.match(OWNER_NAME)) builder.add(OWNER_NAME, attrs.owner());
if (builder.match(GROUP_NAME)) builder.add(GROUP_NAME, attrs.group());
}
@Override
public Map<String, Object> readAttributes(String[] requested) throws IOException {
AttributesBuilder builder = AttributesBuilder.create(posixAttributeNames, requested);
PosixFileAttributes attrs = readAttributes();
addRequestedPosixAttributes(attrs, builder);
return builder.unmodifiableMap();
}
@Override
public UnixFileAttributes readAttributes() throws IOException {
checkReadExtended();
try {
return UnixFileAttributes.get(file, followLinks);
} catch (UnixException x) {
x.rethrowAsIOException(file);
return null; // keep compiler happy
}
}
// chmod
final void setMode(int mode) throws IOException {
checkWriteExtended();
try {
if (followLinks) {
chmod(file, mode);
} else {
int fd = file.openForAttributeAccess(false);
try {
fchmod(fd, mode);
} finally {
close(fd);
}
}
} catch (UnixException x) {
x.rethrowAsIOException(file);
}
}
// chown
final void setOwners(int uid, int gid) throws IOException {
checkWriteExtended();
try {
if (followLinks) {
chown(file, uid, gid);
} else {
lchown(file, uid, gid);
}
} catch (UnixException x) {
x.rethrowAsIOException(file);
}
}
@Override
public void setPermissions(Set<PosixFilePermission> perms) throws IOException {
setMode(UnixFileModeAttribute.toUnixMode(perms));
}
@Override
public void setOwner(UserPrincipal owner) throws IOException {
if (owner == null) throw new NullPointerException("'owner' is null");
if (!(owner instanceof UnixUserPrincipals.User)) throw new ProviderMismatchException();
if (owner instanceof UnixUserPrincipals.Group)
throw new IOException("'owner' parameter can't be a group");
int uid = ((UnixUserPrincipals.User) owner).uid();
setOwners(uid, -1);
}
@Override
public UserPrincipal getOwner() throws IOException {
return readAttributes().owner();
}
@Override
public void setGroup(GroupPrincipal group) throws IOException {
if (group == null) throw new NullPointerException("'owner' is null");
if (!(group instanceof UnixUserPrincipals.Group)) throw new ProviderMismatchException();
int gid = ((UnixUserPrincipals.Group) group).gid();
setOwners(-1, gid);
}
}