Merge branch 'master' into support-getifaddrs

Author: Markus Wanner (mwa)

CHANGELOG.md

@@ -30,6 +30,17 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 - Added socket option variant that enables the timestamp socket
   control message: `nix::sys::socket::sockopt::ReceiveTimestamp`
   ([#663](https://github.com/nix-rust/nix/pull/663))
+- Added more accessor methods for `AioCb`
+  ([#773](https://github.com/nix-rust/nix/pull/773))
+- Add nix::sys::fallocate
+  ([#768](https:://github.com/nix-rust/nix/pull/768))
+- Added `nix::unistd::mkfifo`.
+  ([#602](https://github.com/nix-rust/nix/pull/774))
+- Added `ptrace::Options::PTRACE_O_EXITKILL` on Linux and Android.
+  ([#771](https://github.com/nix-rust/nix/pull/771))
+- Added `nix::sys::uio::{process_vm_readv, process_vm_writev}` on Linux
+  ([#568](https://github.com/nix-rust/nix/pull/568))
+- Added `nix::unistd::{getgroups, setgroups, getgrouplist, initgroups}`. ([#733](https://github.com/nix-rust/nix/pull/733))
 
 ### Changed
 - Renamed existing `ptrace` wrappers to encourage namespacing ([#692](https://github.com/nix-rust/nix/pull/692))
@@ -59,14 +70,14 @@ This project adheres to [Semantic Versioning](http://semver.org/).
   ([#749](https://github.com/nix-rust/nix/pull/749))
 - `AioCb::Drop` will now panic if the `AioCb` is still in-progress ([#715](https://github.com/nix-rust/nix/pull/715))
 
-# Fixed
+### Fixed
 - Fix compilation and tests for OpenBSD targets
   ([#688](https://github.com/nix-rust/nix/pull/688))
 - Fixed error handling in `AioCb::fsync`, `AioCb::read`, and `AioCb::write`.
   It is no longer an error to drop an `AioCb` that failed to enqueue in the OS.
   ([#715](https://github.com/nix-rust/nix/pull/715))
 
-# Removed
+### Removed
 - The syscall module has been removed. This only exposed enough functionality for
   `memfd_create()` and `pivot_root()`, which are still exposed as separate functions.
   ([#747](https://github.com/nix-rust/nix/pull/747))

Cargo.toml

@@ -1,5 +1,4 @@
 [package]
-
 name        = "nix"
 description = "Rust friendly bindings to *nix APIs"
 version     = "0.10.0-pre"
@@ -10,7 +9,6 @@ categories  = ["os::unix-apis"]
 exclude     = [
   ".gitignore",
   ".travis.yml",
-  "deploy.sh",
   "test/**/*"
 ]
 

README.md

@@ -54,6 +54,7 @@ Tier 1:
   * arm-unknown-linux-gnueabi
   * armv7-unknown-linux-gnueabihf
   * i686-apple-darwin
+  * i686-unknown-freebsd
   * i686-unknown-linux-gnu
   * i686-unknown-linux-musl
   * mips-unknown-linux-gnu
@@ -77,7 +78,6 @@ Tier 2:
   * armv7s-apple-ios
   * i386-apple-ios
   * i686-linux-android (requires Rust >= 1.18)
-  * i686-unknown-freebsd
   * powerpc-unknown-linux-gnu
   * s390x-unknown-linux-gnu
   * x86_64-apple-ios

deploy.sh

@@ -13,7 +13,7 @@ pub fn main() {
         "UNKNOWN"
     };
 
-    gcc::Config::new()
+    gcc::Build::new()
         .file("src/const.c")
         .file("src/sizes.c")
         .define(os, None)

nix-test/build.rs

@@ -341,3 +341,43 @@ pub fn vmsplice(fd: RawFd, iov: &[IoVec<&[u8]>], flags: SpliceFFlags) -> Result<
     Errno::result(ret).map(|r| r as usize)
 }
 
+#[cfg(any(target_os = "linux"))]
+libc_bitflags!(
+    /// Mode argument flags for fallocate determining operation performed on a given range.
+    pub struct FallocateFlags: libc::c_int {
+        /// File size is not changed.
+        ///
+        /// offset + len can be greater than file size.
+        FALLOC_FL_KEEP_SIZE;
+        /// Deallocates space by creating a hole.
+        ///
+        /// Must be ORed with FALLOC_FL_KEEP_SIZE. Byte range starts at offset and continues for len bytes.
+        FALLOC_FL_PUNCH_HOLE;
+        /// Removes byte range from a file without leaving a hole.
+        ///
+        /// Byte range to collapse starts at offset and continues for len bytes.
+        FALLOC_FL_COLLAPSE_RANGE;
+        /// Zeroes space in specified byte range.
+        ///
+        /// Byte range starts at offset and continues for len bytes.
+        FALLOC_FL_ZERO_RANGE;
+        /// Increases file space by inserting a hole within the file size.
+        ///
+        /// Does not overwrite existing data. Hole starts at offset and continues for len bytes.
+        FALLOC_FL_INSERT_RANGE;
+        /// Shared file data extants are made private to the file.
+        ///
+        /// Gaurantees that a subsequent write will not fail due to lack of space.
+        FALLOC_FL_UNSHARE_RANGE;
+    }
+);
+
+/// Manipulates file space.
+///
+/// Allows the caller to directly manipulate the allocated disk space for the
+/// file referred to by fd.
+#[cfg(any(target_os = "linux"))]
+pub fn fallocate(fd: RawFd, mode: FallocateFlags, offset: libc::off_t, len: libc::off_t) -> Result<c_int> {
+    let res = unsafe { libc::fallocate(fd, mode.bits(), offset, len) };
+    Errno::result(res)
+}

src/fcntl.rs

@@ -63,6 +63,9 @@ impl MqAttr {
 }
 
 
+/// Open a message queue
+///
+/// See also [mq_open(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_open.html)
 pub fn mq_open(name: &CString,
                oflag: MQ_OFlag,
                mode: Mode,
@@ -80,16 +83,25 @@ pub fn mq_open(name: &CString,
     Errno::result(res)
 }
 
+/// Remove a message queue
+///
+/// See also [mq_unlink(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_unlink.html)
 pub fn mq_unlink(name: &CString) -> Result<()> {
     let res = unsafe { libc::mq_unlink(name.as_ptr()) };
     Errno::result(res).map(drop)
 }
 
+/// Close a message queue
+///
+/// See also [mq_close(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_close.html)
 pub fn mq_close(mqdes: mqd_t) -> Result<()> {
     let res = unsafe { libc::mq_close(mqdes) };
     Errno::result(res).map(drop)
 }
 
+/// Receive a message from a message queue
+///
+/// See also [mq_receive(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_receive.html)
 pub fn mq_receive(mqdes: mqd_t, message: &mut [u8], msg_prio: &mut u32) -> Result<usize> {
     let len = message.len() as size_t;
     let res = unsafe {
@@ -101,6 +113,9 @@ pub fn mq_receive(mqdes: mqd_t, message: &mut [u8], msg_prio: &mut u32) -> Resul
     Errno::result(res).map(|r| r as usize)
 }
 
+/// Send a message to a message queue
+///
+/// See also [mq_send(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_send.html)
 pub fn mq_send(mqdes: mqd_t, message: &[u8], msq_prio: u32) -> Result<()> {
     let res = unsafe {
         libc::mq_send(mqdes,
@@ -111,6 +126,9 @@ pub fn mq_send(mqdes: mqd_t, message: &[u8], msq_prio: u32) -> Result<()> {
     Errno::result(res).map(drop)
 }
 
+/// Get message queue attributes
+///
+/// See also [mq_getattr(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_getattr.html)
 pub fn mq_getattr(mqd: mqd_t) -> Result<MqAttr> {
     let mut attr = unsafe { mem::uninitialized::<libc::mq_attr>() };
     let res = unsafe { libc::mq_getattr(mqd, &mut attr) };
@@ -121,7 +139,7 @@ pub fn mq_getattr(mqd: mqd_t) -> Result<MqAttr> {
 /// Returns the old attributes
 /// It is recommend to use the `mq_set_nonblock()` and `mq_remove_nonblock()` convenience functions as they are easier to use
 ///
-/// [Further reading](http://man7.org/linux/man-pages/man3/mq_setattr.3.html)
+/// [Further reading](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_setattr.html)
 pub fn mq_setattr(mqd: mqd_t, newattr: &MqAttr) -> Result<MqAttr> {
     let mut attr = unsafe { mem::uninitialized::<libc::mq_attr>() };
     let res = unsafe { libc::mq_setattr(mqd, &newattr.mq_attr as *const libc::mq_attr, &mut attr) };

src/mqueue.rs

@@ -91,7 +91,7 @@ libc_bitflags! {
 }
 
 /// `poll` waits for one of a set of file descriptors to become ready to perform I/O.
-/// ([`poll(2)`](http://man7.org/linux/man-pages/man2/poll.2.html))
+/// ([`poll(2)`](http://pubs.opengroup.org/onlinepubs/9699919799/functions/poll.html))
 ///
 /// `fds` contains all [`PollFd`](struct.PollFd.html) to poll.
 /// The function will return as soon as any event occur for any of these `PollFd`s.

src/poll.rs

@@ -61,7 +61,7 @@ impl Drop for PtyMaster {
 }
 
 /// Grant access to a slave pseudoterminal (see
-/// [grantpt(3)](http://man7.org/linux/man-pages/man3/grantpt.3.html))
+/// [grantpt(3)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/grantpt.html))
 ///
 /// `grantpt()` changes the mode and owner of the slave pseudoterminal device corresponding to the
 /// master pseudoterminal referred to by `fd`. This is a necessary step towards opening the slave.
@@ -75,7 +75,7 @@ pub fn grantpt(fd: &PtyMaster) -> Result<()> {
 }
 
 /// Open a pseudoterminal device (see
-/// [posix_openpt(3)](http://man7.org/linux/man-pages/man3/posix_openpt.3.html))
+/// [posix_openpt(3)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_openpt.html))
 ///
 /// `posix_openpt()` returns a file descriptor to an existing unused pseuterminal master device.
 ///
@@ -176,7 +176,7 @@ pub fn ptsname_r(fd: &PtyMaster) -> Result<String> {
 }
 
 /// Unlock a pseudoterminal master/slave pseudoterminal pair (see
-/// [unlockpt(3)](http://man7.org/linux/man-pages/man3/unlockpt.3.html))
+/// [unlockpt(3)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/unlockpt.html))
 ///
 /// `unlockpt()` unlocks the slave pseudoterminal device corresponding to the master pseudoterminal
 /// referred to by `fd`. This must be called before trying to open the slave side of a

src/pty.rs

@@ -13,38 +13,44 @@ use sys::time::TimeSpec;
 
 /// Mode for `AioCb::fsync`.  Controls whether only data or both data and
 /// metadata are synced.
-#[repr(i32)]
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum AioFsyncMode {
-    /// do it like `fsync`
-    O_SYNC = libc::O_SYNC,
-    /// on supported operating systems only, do it like `fdatasync`
-    #[cfg(any(target_os = "openbsd", target_os = "bitrig",
-              target_os = "netbsd", target_os = "macos", target_os = "ios",
-              target_os = "linux"))]
-    O_DSYNC = libc::O_DSYNC
+libc_enum! {
+    #[repr(i32)]
+    pub enum AioFsyncMode {
+        /// do it like `fsync`
+        O_SYNC,
+        /// on supported operating systems only, do it like `fdatasync`
+        #[cfg(any(target_os = "bitrig",
+                  target_os = "ios",
+                  target_os = "linux",
+                  target_os = "macos",
+                  target_os = "netbsd",
+                  target_os = "openbsd"))]
+        O_DSYNC
+    }
 }
 
-/// When used with `lio_listio`, determines whether a given `aiocb` should be
-/// used for a read operation, a write operation, or ignored.  Has no effect for
-/// any other aio functions.
-#[repr(i32)]
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum LioOpcode {
-    LIO_NOP = libc::LIO_NOP,
-    LIO_WRITE = libc::LIO_WRITE,
-    LIO_READ = libc::LIO_READ
+libc_enum! {
+    /// When used with `lio_listio`, determines whether a given `aiocb` should be
+    /// used for a read operation, a write operation, or ignored.  Has no effect for
+    /// any other aio functions.
+    #[repr(i32)]
+    pub enum LioOpcode {
+        LIO_NOP,
+        LIO_WRITE,
+        LIO_READ,
+    }
 }
 
-/// Mode for `lio_listio`.
-#[repr(i32)]
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum LioMode {
-    /// Requests that `lio_listio` block until all requested operations have
-    /// been completed
-    LIO_WAIT = libc::LIO_WAIT,
-    /// Requests that `lio_listio` return immediately
-    LIO_NOWAIT = libc::LIO_NOWAIT,
+libc_enum! {
+    /// Mode for `lio_listio`.
+    #[repr(i32)]
+    pub enum LioMode {
+        /// Requests that `lio_listio` block until all requested operations have
+        /// been completed
+        LIO_WAIT,
+        /// Requests that `lio_listio` return immediately
+        LIO_NOWAIT,
+    }
 }
 
 /// Return values for `AioCb::cancel and aio_cancel_all`
@@ -84,6 +90,11 @@ pub struct AioCb<'a> {
 }
 
 impl<'a> AioCb<'a> {
+    /// Returns the underlying file descriptor associated with the `AioCb`
+    pub fn fd(&self) -> RawFd {
+        self.aiocb.aio_fildes
+    }
+
     /// Constructs a new `AioCb` with no associated buffer.
     ///
     /// The resulting `AioCb` structure is suitable for use with `AioCb::fsync`.
@@ -239,6 +250,38 @@ impl<'a> AioCb<'a> {
         })
     }
 
+    /// Returns the `aiocb`'s `LioOpcode` field
+    ///
+    /// If the value cannot be represented as an `LioOpcode`, returns `None`
+    /// instead.
+    pub fn lio_opcode(&self) -> Option<LioOpcode> {
+        match self.aiocb.aio_lio_opcode {
+            libc::LIO_READ => Some(LioOpcode::LIO_READ),
+            libc::LIO_WRITE => Some(LioOpcode::LIO_WRITE),
+            libc::LIO_NOP => Some(LioOpcode::LIO_NOP),
+            _ => None
+        }
+    }
+
+    /// Returns the requested length of the aio operation in bytes
+    ///
+    /// This method returns the *requested* length of the operation.  To get the
+    /// number of bytes actually read or written by a completed operation, use
+    /// `aio_return` instead.
+    pub fn nbytes(&self) -> usize {
+        self.aiocb.aio_nbytes
+    }
+
+    /// Returns the file offset stored in the `AioCb`
+    pub fn offset(&self) -> off_t {
+        self.aiocb.aio_offset
+    }
+
+    /// Returns the priority of the `AioCb`
+    pub fn priority(&self) -> libc::c_int {
+        self.aiocb.aio_reqprio
+    }
+
     /// Asynchronously reads from a file descriptor into a buffer
     pub fn read(&mut self) -> Result<()> {
         assert!(self.mutable, "Can't read into an immutable buffer");
@@ -250,6 +293,11 @@ impl<'a> AioCb<'a> {
         })
     }
 
+    /// Returns the `SigEvent` stored in the `AioCb`
+    pub fn sigevent(&self) -> SigEvent {
+        SigEvent::from(&self.aiocb.aio_sigevent)
+    }
+
     /// Retrieve return status of an asynchronous operation.  Should only be
     /// called once for each `AioCb`, after `AioCb::error` indicates that it has
     /// completed.  The result is the same as for `read`, `write`, of `fsync`.