Update some stuff for upstream bitflags changes

5 files changed, 5 insertions, 268 deletions

diff --git a/Cargo.toml b/Cargo.toml
index ca2ff138..7978dac5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,7 +20,7 @@ execvpe = []
 
 [dependencies]
 libc     = "0.1.8"
-bitflags = "0.1.1"
+bitflags = "0.3.2"
 
 [dev-dependencies]
 rand = "0.3.8"
diff --git a/src/lib.rs b/src/lib.rs
index b63920bd..f3285762 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,6 +5,9 @@
 #![crate_name = "nix"]
 #![cfg(unix)]
 #![allow(non_camel_case_types)]
+// latest bitflags triggers a rustc bug with cross-crate macro expansions causing dead_code
+// warnings even though the macro expands into something with allow(dead_code)
+#![allow(dead_code)]
 #![deny(warnings)]
 
 #[macro_use]
diff --git a/src/sys/epoll.rs b/src/sys/epoll.rs
index d510faf3..0e9c5536 100644
--- a/src/sys/epoll.rs
+++ b/src/sys/epoll.rs
@@ -1,7 +1,6 @@
 use {Error, Result, from_ffi};
 use errno::Errno;
 use libc::c_int;
-use std::fmt;
 use std::os::unix::io::RawFd;
 
 mod ffi {
@@ -35,41 +34,6 @@ bitflags!(
     }
 );
 
-impl fmt::Debug for EpollEventKind {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let variants = [
-            (EPOLLIN,       "EPOLLIN"),
-            (EPOLLPRI,      "EPOLLPRI"),
-            (EPOLLOUT,      "EPOLLOUT"),
-            (EPOLLRDNORM,   "EPOLLRDNORM"),
-            (EPOLLRDBAND,   "EPOLLRDBAND"),
-            (EPOLLWRNORM,   "EPOLLWRNORM"),
-            (EPOLLWRBAND,   "EPOLLWRBAND"),
-            (EPOLLMSG,      "EPOLLMSG"),
-            (EPOLLERR,      "EPOLLERR"),
-            (EPOLLHUP,      "EPOLLHUP"),
-            (EPOLLRDHUP,    "EPOLLRDHUP"),
-            (EPOLLWAKEUP,   "EPOLLWAKEUP"),
-            (EPOLLONESHOT,  "EPOLLONESHOT"),
-            (EPOLLET,       "EPOLLET")];
-
-        let mut first = true;
-
-        for &(val, name) in variants.iter() {
-            if self.contains(val) {
-                if first {
-                    first = false;
-                    try!(write!(fmt, "{}", name));
-                } else {
-                    try!(write!(fmt, "|{}", name));
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
 #[derive(Clone, Copy)]
 #[repr(C)]
 pub enum EpollOp {
diff --git a/src/sys/ioctl.rs b/src/sys/ioctl.rs
deleted file mode 100644
index 0a2a3451..00000000
--- a/src/sys/ioctl.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-//! Provide helpers for making ioctl system calls
-//!
-//! # Overview of IOCTLs
-//!
-//! The `ioctl` system call is a widely support system
-//! call on *nix systems providing access to functions
-//! and data that do not fit nicely into the standard
-//! read and write operations on a file itself.  It is
-//! common to see ioctls used for the following purposes:
-//!
-//! * Provide read/write access to out-of-band data related
-//!   to a device such as configuration (for instance, setting
-//!   serial port options)
-//! * Provide a mechanism for performing full-duplex data
-//!   transfers (for instance, xfer on SPI devices).
-//! * Provide access to control functions on a device (for example,
-//!   on Linux you can send commands like pause, resume, and eject
-//!   to the CDROM device.
-//! * Do whatever else the device driver creator thought made most sense.
-//!
-//! Ioctls are synchronous system calls and are similar to read and
-//! write calls in that regard.
-//!
-//! The prototype for the ioctl system call in libc is as follows:
-//!
-//! ```c
-//! int ioctl(int fd, unsigned long request, ...);
-//! ```
-//!
-//! Typically, an ioctl takes 3 parameters as arguments:
-//!
-//! 1. An open file descriptor, `fd`.
-//! 2. An device-dependennt request code or operation.  This request
-//!    code is referred to as `op` in this module.
-//! 3. Either a pointer to a location in memory or an integer.  This
-//!    number of pointer may either be used by the kernel or written
-//!    to by the kernel depending on how the operation is documented
-//!    to work.
-//!
-//! The `op` request code is essentially an arbitrary integer having
-//! a device-driver specific meaning.  Over time, it proved difficult
-//! for various driver implementors to use this field sanely, so a
-//! convention with macros was introduced to the Linux Kernel that
-//! is used by most newer drivers.  See
-//! https://github.com/torvalds/linux/blob/master/Documentation/ioctl/ioctl-number.txt
-//! for additional details.  The macros exposed by the kernel for
-//! consumers are implemented in this module and may be used to
-//! instead of calls like `_IOC`, `_IO`, `_IOR`, and `_IOW`.
-//!
-//! # Interface Overview
-//!
-//! This ioctl module seeks to tame the ioctl beast by providing
-//! a set of safer (although not safe) functions
-//! implementing the most common ioctl access patterns.
-//!
-//! The most common access patterns for ioctls are as follows:
-//!
-//! 1. `read`: A pointer is provided to the kernel which is populated
-//!    with a value containing the "result" of the operation.  The
-//!    result may be an integer or structure.  The kernel may also
-//!    read values from the provided pointer (usually a structure).
-//! 2. `write`: A pointer is provided to the kernel containing values
-//!    that the kernel will read in order to perform the operation.
-//! 3. `execute`: The operation is passed to the kernel but no
-//!    additional pointer is passed.  The operation is enough
-//!    and it either succeeds or results in an error.
-//!
-//! Where appropriate, versions of these interface function are provided
-//! taking either refernces or pointers.  The pointer versions are
-//! necessary for cases (notably slices) where a reference cannot
-//! be generically cast to a pointer.
-
-use {Error, Result, errno};
-use libc::{c_int, c_ulong};
-use libc::funcs::bsd44::ioctl as libc_ioctl;
-use std::mem;
-use std::os::unix::io::RawFd;
-
-pub type ioctl_op_t = c_ulong;
-
-// the libc definiton of the 'op' type is platform dependent
-#[cfg(any(target_os = "macos",
-          target_os = "ios",
-          target_os = "freebsd",
-          target_os = "openbsd",
-          target_os = "dragonfly"))]
-type os_ioctl_op_t = c_ulong;
-
-#[cfg(any(target_os = "linux", target_os = "android"))]
-type os_ioctl_op_t = c_int;
-
-// low-level ioctl functions and definitions matching the
-// macros provided in ioctl.h from the kernel
-const IOC_NRBITS: u32 = 8;
-const IOC_TYPEBITS: u32 = 8;
-const IOC_SIZEBITS: u32 = 14;
-// const IOC_DIRBITS: u32 = 2;
-
-const IOC_NRSHIFT: u32 = 0;
-const IOC_TYPESHIFT: u32 = IOC_NRSHIFT + IOC_NRBITS;
-const IOC_SIZESHIFT: u32 = IOC_TYPESHIFT + IOC_TYPEBITS;
-const IOC_DIRSHIFT: u32 = IOC_SIZESHIFT + IOC_SIZEBITS;
-
-/// Flags indicating the direction of the ioctl operation
-/// for ioctls using modern operation conventions
-bitflags! {
-    flags IoctlDirFlags: u8 {
-        /// Indicates that the ioctl data pointer is not used
-        const IOC_NONE  = 0x00,
-        /// Indicates that the ioctl data pointer contains data that
-        /// will be consumed by the operating system
-        const IOC_WRITE = 0x01,
-        /// Indicates tha the ioctl data pointer contains data that
-        /// will be populated by the operating system to be consumed
-        /// by userspace
-        const IOC_READ  = 0x02,
-    }
-}
-
-/// Build an ioctl op with the provide parameters.  This is a helper
-/// function for IOCTLs in the Linux kernel using the newer conventions
-/// for IOCTLs operations.  Many ioctls do not use this newer convention
-/// and the constants for those should just be used as-is.
-///
-/// This provides the same functionality as the Linux `_IOC` macro.
-pub fn op(dir: IoctlDirFlags, ioctl_type: u8, nr: u8, size: usize) -> ioctl_op_t {
-    // actual number will always fit in 32 bits, but ioctl() expects
-    // an unsigned long for the op
-    let size_to_use: u32 = if size < (1 << IOC_SIZEBITS) { size as u32 } else { 0 };
-    (((dir.bits as u32) << IOC_DIRSHIFT) |
-     ((ioctl_type as u32) << IOC_TYPESHIFT) |
-     ((nr as u32) << IOC_NRSHIFT) |
-     ((size_to_use) << IOC_SIZESHIFT)) as ioctl_op_t
-}
-
-/// Build an op indicating that the data pointer is not used.
-/// That is, the command itself is sufficient.
-///
-/// This provides the same functionality the Linux `_IO` macro.
-pub fn op_none(ioctl_type: u8, nr: u8) -> ioctl_op_t {
-    op(IOC_NONE, ioctl_type, nr, 0)
-}
-
-/// Build an op indicating that the data pointer will be populated
-/// with data from the kernel
-///
-/// This provides the same functionality as the Linux `_IOR` macro.
-pub fn op_read(ioctl_type: u8, nr: u8, size: usize) -> ioctl_op_t {
-    op(IOC_READ, ioctl_type, nr, size)
-}
-
-/// Build an op indicating that the data pointer contains data
-/// to be consumed by the kernel (and not written to).
-///
-/// This provides the same functionality as the Linux `_IOW` macro.
-pub fn op_write(ioctl_type: u8, nr: u8, size: usize) -> ioctl_op_t {
-    op(IOC_WRITE, ioctl_type, nr, size)
-}
-
-/// Build an op indicating that the data pointer both contains
-/// data to be consumed by the kernel and contains fields that
-/// will be populated by the kernel.
-///
-/// This provides the same functionality as the Linux `_IOWR` macro.
-pub fn op_read_write(ioctl_type: u8, nr: u8, size: usize) -> ioctl_op_t {
-    op(IOC_WRITE | IOC_READ, ioctl_type, nr, size)
-}
-
-fn convert_ioctl_res(res: c_int) -> Result<c_int> {
-    if res < 0 {
-        return Err(Error::Sys(errno::Errno::last()))
-    }
-    Ok(res) // res may length or similar useful to caller
-}
-
-/// Ioctl call that is expected to return a result
-/// but which does not take any additional arguments on the input side
-///
-/// This function will allocate allocate space for and returned an owned
-/// reference to the result.
-pub unsafe fn read<T>(fd: RawFd, op: ioctl_op_t) -> Result<T> {
-    // allocate memory for the result (should get a value from kernel)
-    let mut dst: T = mem::zeroed();
-    let dst_ptr: *mut T = &mut dst;
-    try!(read_into_ptr(fd, op, dst_ptr));
-    Ok(dst)
-}
-
-/// Ioctl where the result from the kernel will be written to the
-/// provided reference
-///
-/// The refernced data may also contain information that will be consumed
-/// by the kernel.
-pub unsafe fn read_into<T>(fd: RawFd, op: ioctl_op_t, data: &mut T) -> Result<c_int> {
-    read_into_ptr(fd, op, data as *mut T)
-}
-
-/// Ioctl where the result from the kernel will be written to the
-/// provided pointer
-///
-/// The refernced data may also contain information that will be consumed
-/// by the kernel.
-pub unsafe fn read_into_ptr<T>(fd: RawFd, op: ioctl_op_t, data_ptr: *mut T) -> Result<c_int> {
-    convert_ioctl_res(libc_ioctl(fd, op as os_ioctl_op_t, data_ptr))
-}
-
-/// Ioctl call that sends a value to the kernel but
-/// does not return anything (pure side effect).
-pub unsafe fn write<T>(fd: RawFd, op: ioctl_op_t, data: &T) -> Result<c_int> {
-    write_ptr(fd, op, data as *const T)
-}
-
-/// Ioctl call that sends a value to the kernel but
-/// does not return anything (pure side effect).
-pub unsafe fn write_ptr<T>(fd: RawFd, op: ioctl_op_t, data: *const T) -> Result<c_int> {
-    convert_ioctl_res(libc_ioctl(fd, op as os_ioctl_op_t, data as *const T))
-}
-
-/// Ioctl call for which no data pointer is provided to the kernel.
-/// That is, the kernel has sufficient information about what to
-/// do based on the op alone.
-pub fn execute(fd: RawFd, op: ioctl_op_t) -> Result<c_int> {
-    convert_ioctl_res(unsafe { libc_ioctl(fd, op as os_ioctl_op_t) })
-}
diff --git a/src/sys/stat.rs b/src/sys/stat.rs
index aee47a67..2a34d282 100644
--- a/src/sys/stat.rs
+++ b/src/sys/stat.rs
@@ -4,7 +4,7 @@ pub use libc::stat as FileStat;
 use {Error, Result, NixPath, from_ffi};
 use errno::Errno;
 use libc::mode_t;
-use std::{fmt, mem};
+use std::mem;
 use std::os::unix::io::RawFd;
 
 mod ffi {
@@ -50,12 +50,6 @@ bitflags! {
     }
 }
 
-impl fmt::Debug for SFlag {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "SFlag {{ bits: {} }}", self.bits())
-    }
-}
-
 pub fn mknod<P: ?Sized + NixPath>(path: &P, kind: SFlag, perm: Mode, dev: dev_t) -> Result<()> {
     let res = try!(path.with_nix_path(|cstr| {
         unsafe {