pub fn mkdir(p: &CString, mode: io::FilePermission) -> IoResult<()> {
super::mkerr_libc(retry(|| unsafe {
- libc::mkdir(p.with_ref(|p| p), mode as libc::mode_t)
+ libc::mkdir(p.with_ref(|p| p), mode.bits() as libc::mode_t)
}))
}
pub fn chmod(p: &CString, mode: io::FilePermission) -> IoResult<()> {
super::mkerr_libc(retry(|| unsafe {
- libc::chmod(p.with_ref(|p| p), mode as libc::mode_t)
+ libc::chmod(p.with_ref(|p| p), mode.bits() as libc::mode_t)
}))
}
path: Path::new(path),
size: stat.st_size as u64,
kind: kind,
- perm: (stat.st_mode) as io::FilePermission & io::AllPermissions,
+ perm: unsafe {
+ io::FilePermission::from_bits(stat.st_mode as u32) & io::AllPermissions
+ },
created: mktime(stat.st_ctime as u64, stat.st_ctime_nsec as u64),
modified: mktime(stat.st_mtime as u64, stat.st_mtime_nsec as u64),
accessed: mktime(stat.st_atime as u64, stat.st_atime_nsec as u64),
pub fn chmod(p: &CString, mode: io::FilePermission) -> IoResult<()> {
super::mkerr_libc(as_utf16_p(p.as_str().unwrap(), |p| unsafe {
- libc::wchmod(p, mode as libc::c_int)
+ libc::wchmod(p, mode.bits() as libc::c_int)
}))
}
path: Path::new(path),
size: stat.st_size as u64,
kind: kind,
- perm: (stat.st_mode) as io::FilePermission & io::AllPermissions,
+ perm: unsafe {
+ io::FilePermission::from_bits(stat.st_mode as u32) & io::AllPermissions
+ },
created: stat.st_ctime as u64,
modified: stat.st_mtime as u64,
accessed: stat.st_atime as u64,
path: path,
size: stat.st_size as u64,
kind: kind,
- perm: (stat.st_mode as io::FilePermission) & io::AllPermissions,
+ perm: unsafe {
+ io::FilePermission::from_bits(stat.st_mode as u32) & io::AllPermissions
+ },
created: to_msec(stat.st_birthtim),
modified: to_msec(stat.st_mtim),
accessed: to_msec(stat.st_atim),
}
fn fs_mkdir(&mut self, path: &CString,
perm: io::FilePermission) -> Result<(), IoError> {
- let r = FsRequest::mkdir(&self.loop_, path, perm as c_int);
+ let r = FsRequest::mkdir(&self.loop_, path, perm.bits() as c_int);
r.map_err(uv_error_to_io_error)
}
fn fs_rmdir(&mut self, path: &CString) -> Result<(), IoError> {
}
fn fs_chmod(&mut self, path: &CString,
perm: io::FilePermission) -> Result<(), IoError> {
- let r = FsRequest::chmod(&self.loop_, path, perm as c_int);
+ let r = FsRequest::chmod(&self.loop_, path, perm.bits() as c_int);
r.map_err(uv_error_to_io_error)
}
fn fs_readdir(&mut self, path: &CString, flags: c_int)
check!(File::create(&input));
check!(chmod(&input, io::UserRead));
check!(copy(&input, &out));
- assert!(check!(out.stat()).perm & io::UserWrite == 0);
+ assert!(!check!(out.stat()).perm.intersects(io::UserWrite));
check!(chmod(&input, io::UserFile));
check!(chmod(&out, io::UserFile));
let file = tmpdir.join("in.txt");
check!(File::create(&file));
- assert!(check!(stat(&file)).perm & io::UserWrite == io::UserWrite);
+ assert!(check!(stat(&file)).perm.contains(io::UserWrite));
check!(chmod(&file, io::UserRead));
- assert!(check!(stat(&file)).perm & io::UserWrite == 0);
+ assert!(!check!(stat(&file)).perm.contains(io::UserWrite));
match chmod(&tmpdir.join("foo"), io::UserRWX) {
Ok(..) => fail!("wanted a failure"),
use int;
use iter::Iterator;
use libc;
+use ops::{BitOr, BitAnd, Sub};
use os;
use option::{Option, Some, None};
use path::Path;
pub gen: u64,
}
-/// A set of permissions for a file or directory is represented by a set of
-/// flags which are or'd together.
-pub type FilePermission = u32;
-
-// Each permission bit
-pub static UserRead: FilePermission = 0x100;
-pub static UserWrite: FilePermission = 0x080;
-pub static UserExecute: FilePermission = 0x040;
-pub static GroupRead: FilePermission = 0x020;
-pub static GroupWrite: FilePermission = 0x010;
-pub static GroupExecute: FilePermission = 0x008;
-pub static OtherRead: FilePermission = 0x004;
-pub static OtherWrite: FilePermission = 0x002;
-pub static OtherExecute: FilePermission = 0x001;
-
-// Common combinations of these bits
-pub static UserRWX: FilePermission = UserRead | UserWrite | UserExecute;
-pub static GroupRWX: FilePermission = GroupRead | GroupWrite | GroupExecute;
-pub static OtherRWX: FilePermission = OtherRead | OtherWrite | OtherExecute;
-
-/// A set of permissions for user owned files, this is equivalent to 0644 on
-/// unix-like systems.
-pub static UserFile: FilePermission = UserRead | UserWrite | GroupRead | OtherRead;
-/// A set of permissions for user owned directories, this is equivalent to 0755
-/// on unix-like systems.
-pub static UserDir: FilePermission = UserRWX | GroupRead | GroupExecute |
- OtherRead | OtherExecute;
-/// A set of permissions for user owned executables, this is equivalent to 0755
-/// on unix-like systems.
-pub static UserExec: FilePermission = UserDir;
-
-/// A mask for all possible permission bits
-pub static AllPermissions: FilePermission = 0x1ff;
+bitflags!(
+ #[doc="A set of permissions for a file or directory is represented
+by a set of flags which are or'd together."]
+ #[deriving(Hash)]
+ #[deriving(Show)]
+ flags FilePermission: u32 {
+ static UserRead = 0o400,
+ static UserWrite = 0o200,
+ static UserExecute = 0o100,
+ static GroupRead = 0o040,
+ static GroupWrite = 0o020,
+ static GroupExecute = 0o010,
+ static OtherRead = 0o004,
+ static OtherWrite = 0o002,
+ static OtherExecute = 0o001,
+
+ static UserRWX = UserRead.bits | UserWrite.bits | UserExecute.bits,
+ static GroupRWX = GroupRead.bits | GroupWrite.bits | GroupExecute.bits,
+ static OtherRWX = OtherRead.bits | OtherWrite.bits | OtherExecute.bits,
+
+ #[doc="Permissions for user owned files, equivalent to 0644 on
+unix-like systems."]
+ static UserFile = UserRead.bits | UserWrite.bits | GroupRead.bits | OtherRead.bits,
+
+ #[doc="Permissions for user owned directories, equivalent to 0755 on
+unix-like systems."]
+ static UserDir = UserRWX.bits | GroupRead.bits | GroupExecute.bits |
+ OtherRead.bits | OtherExecute.bits,
+
+ #[doc="Permissions for user owned executables, equivalent to 0755
+on unix-like systems."]
+ static UserExec = UserDir.bits,
+
+ #[doc="All possible permissions enabled."]
+ static AllPermissions = UserRWX.bits | GroupRWX.bits | OtherRWX.bits
+ }
+)