src/vendor/nix/src/sys/stat.rs

   1 pub use libc::dev_t;
   2 pub use libc::stat as FileStat;
   3
   4 use {Errno, Result, NixPath};
   5 use libc::{self, mode_t};
   6 use std::mem;
   7 use std::os::unix::io::RawFd;
   8
   9 mod ffi {
  10     use libc::{c_char, c_int, mode_t, dev_t};
  11     pub use libc::{stat, fstat, lstat};
  12
  13     extern {
  14         pub fn mknod(pathname: *const c_char, mode: mode_t, dev: dev_t) -> c_int;
  15         pub fn umask(mask: mode_t) -> mode_t;
  16     }
  17 }
  18
  19 libc_bitflags!(
  20     pub flags SFlag: mode_t {
  21         S_IFIFO,
  22         S_IFCHR,
  23         S_IFDIR,
  24         S_IFBLK,
  25         S_IFREG,
  26         S_IFLNK,
  27         S_IFSOCK,
  28         S_IFMT,
  29     }
  30 );
  31
  32 bitflags! {
  33     pub flags Mode: mode_t {
  34         const S_IRWXU = libc::S_IRWXU,
  35         const S_IRUSR = libc::S_IRUSR,
  36         const S_IWUSR = libc::S_IWUSR,
  37         const S_IXUSR = libc::S_IXUSR,
  38
  39         const S_IRWXG = libc::S_IRWXG,
  40         const S_IRGRP = libc::S_IRGRP,
  41         const S_IWGRP = libc::S_IWGRP,
  42         const S_IXGRP = libc::S_IXGRP,
  43
  44         const S_IRWXO = libc::S_IRWXO,
  45         const S_IROTH = libc::S_IROTH,
  46         const S_IWOTH = libc::S_IWOTH,
  47         const S_IXOTH = libc::S_IXOTH,
  48
  49         const S_ISUID = libc::S_ISUID as mode_t,
  50         const S_ISGID = libc::S_ISGID as mode_t,
  51         const S_ISVTX = libc::S_ISVTX as mode_t,
  52     }
  53 }
  54
  55 pub fn mknod<P: ?Sized + NixPath>(path: &P, kind: SFlag, perm: Mode, dev: dev_t) -> Result<()> {
  56     let res = try!(path.with_nix_path(|cstr| {
  57         unsafe {
  58             ffi::mknod(cstr.as_ptr(), kind.bits | perm.bits() as mode_t, dev)
  59         }
  60     }));
  61
  62     Errno::result(res).map(drop)
  63 }
  64
  65 #[cfg(target_os = "linux")]
  66 pub fn major(dev: dev_t) -> u64 {
  67     ((dev >> 32) & 0xfffff000) |
  68     ((dev >>  8) & 0x00000fff)
  69 }
  70
  71 #[cfg(target_os = "linux")]
  72 pub fn minor(dev: dev_t) -> u64 {
  73     ((dev >> 12) & 0xffffff00) |
  74     ((dev      ) & 0x000000ff)
  75 }
  76
  77 #[cfg(target_os = "linux")]
  78 pub fn makedev(major: u64, minor: u64) -> dev_t {
  79     ((major & 0xfffff000) << 32) |
  80     ((major & 0x00000fff) <<  8) |
  81     ((minor & 0xffffff00) << 12) |
  82     ((minor & 0x000000ff)      )
  83 }
  84
  85 pub fn umask(mode: Mode) -> Mode {
  86     let prev = unsafe { ffi::umask(mode.bits() as mode_t) };
  87     Mode::from_bits(prev).expect("[BUG] umask returned invalid Mode")
  88 }
  89
  90 pub fn stat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> {
  91     let mut dst = unsafe { mem::uninitialized() };
  92     let res = try!(path.with_nix_path(|cstr| {
  93         unsafe {
  94             ffi::stat(cstr.as_ptr(), &mut dst as *mut FileStat)
  95         }
  96     }));
  97
  98     try!(Errno::result(res));
  99
 100     Ok(dst)
 101 }
 102
 103 pub fn lstat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> {
 104     let mut dst = unsafe { mem::uninitialized() };
 105     let res = try!(path.with_nix_path(|cstr| {
 106         unsafe {
 107             ffi::lstat(cstr.as_ptr(), &mut dst as *mut FileStat)
 108         }
 109     }));
 110
 111     try!(Errno::result(res));
 112
 113     Ok(dst)
 114 }
 115
 116 pub fn fstat(fd: RawFd) -> Result<FileStat> {
 117     let mut dst = unsafe { mem::uninitialized() };
 118     let res = unsafe { ffi::fstat(fd, &mut dst as *mut FileStat) };
 119
 120     try!(Errno::result(res));
 121
 122     Ok(dst)
 123 }