Merge branch 'master' into master

CHANGELOG.md

@@ -5,12 +5,31 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 ### Added
-
+- Add IP_RECVIF & IP_RECVDSTADDR. Enable IP_PKTINFO and IP6_PKTINFO on netbsd/openbsd.
+  ([#1002](https://github.com/nix-rust/nix/pull/1002))
 - Added `inotify_init1`, `inotify_add_watch` and `inotify_rm_watch` wrappers for
   Android and Linux. ([#1016](https://github.com/nix-rust/nix/pull/1016))
-
 ### Changed
+- `PollFd` event flags renamed to `PollFlags` ([#1024](https://github.com/nix-rust/nix/pull/1024/))
+- `recvmsg` now returns an Iterator over `ControlMessageOwned` objects rather
+  than `ControlMessage` objects.  This is sadly not backwards-compatible.  Fix
+  code like this:
+  ```rust
+  if let ControlMessage::ScmRights(&fds) = cmsg {
+  ```
+
+  By replacing it with code like this:
+  ```rust
+  if let ControlMessageOwned::ScmRights(fds) = cmsg {
+  ```
+  ([#1020](https://github.com/nix-rust/nix/pull/1020))
+- Replaced `CmsgSpace` with the `cmsg_space` macro.
+  ([#1020](https://github.com/nix-rust/nix/pull/1020))
+
 ### Fixed
+- Fixed multiple bugs when using `sendmsg` and `recvmsg` with ancillary control messages
+  ([#1020](https://github.com/nix-rust/nix/pull/1020))
+
 ### Removed
 
 ## [0.13.0] - 2019-01-15
@@ -27,6 +46,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
   ([#1010](https://github.com/nix-rust/nix/pull/1010))
 - Added `nix::sys::signal::signal`.
   ([#817](https://github.com/nix-rust/nix/pull/817))
+- Added an `mprotect` wrapper.
+  ([#991](https://github.com/nix-rust/nix/pull/991))
 
 ### Changed
 ### Fixed

Cargo.toml

@@ -27,8 +27,8 @@ cc = "1"
 [dev-dependencies]
 bytes = "0.4.8"
 lazy_static = "1.2"
-rand = "0.5"
-tempfile = "3"
+rand = "0.6"
+tempfile = "3.0.5"
 
 [target.'cfg(target_os = "freebsd")'.dev-dependencies]
 sysctl = "0.1"

src/poll.rs

@@ -27,19 +27,19 @@ pub struct PollFd {
 impl PollFd {
     /// Creates a new `PollFd` specifying the events of interest
     /// for a given file descriptor.
-    pub fn new(fd: RawFd, events: EventFlags) -> PollFd {
+    pub fn new(fd: RawFd, events: PollFlags) -> PollFd {
         PollFd {
             pollfd: libc::pollfd {
                 fd: fd,
                 events: events.bits(),
-                revents: EventFlags::empty().bits(),
+                revents: PollFlags::empty().bits(),
             },
         }
     }
 
     /// Returns the events that occured in the last call to `poll` or `ppoll`.
-    pub fn revents(&self) -> Option<EventFlags> {
-        EventFlags::from_bits(self.pollfd.revents)
+    pub fn revents(&self) -> Option<PollFlags> {
+        PollFlags::from_bits(self.pollfd.revents)
     }
 }
 
@@ -48,11 +48,11 @@ impl fmt::Debug for PollFd {
         let pfd = self.pollfd;
         let mut ds = f.debug_struct("PollFd");
         ds.field("fd", &pfd.fd);
-        match EventFlags::from_bits(pfd.events) {
+        match PollFlags::from_bits(pfd.events) {
             None => ds.field("events", &pfd.events),
             Some(ef) => ds.field("events", &ef),
         };
-        match EventFlags::from_bits(pfd.revents) {
+        match PollFlags::from_bits(pfd.revents) {
             None => ds.field("revents", &pfd.revents),
             Some(ef) => ds.field("revents", &ef),
         };
@@ -62,7 +62,7 @@ impl fmt::Debug for PollFd {
 
 libc_bitflags! {
     /// These flags define the different events that can be monitored by `poll` and `ppoll`
-    pub struct EventFlags: libc::c_short {
+    pub struct PollFlags: libc::c_short {
         /// There is data to read.
         POLLIN;
         /// There is some exceptional condition on the file descriptor.

src/sys/mman.rs

@@ -258,6 +258,35 @@ pub unsafe fn madvise(addr: *mut c_void, length: size_t, advise: MmapAdvise) ->
     Errno::result(libc::madvise(addr, length, advise as i32)).map(drop)
 }
 
+/// Set protection of memory mapping.
+///
+/// See [`mprotect(3)`](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mprotect.html) for
+/// details.
+///
+/// # Safety
+///
+/// Calls to `mprotect` are inherently unsafe, as changes to memory protections can lead to
+/// SIGSEGVs.
+///
+/// ```
+/// # use nix::libc::size_t;
+/// # use nix::sys::mman::{mmap, mprotect, MapFlags, ProtFlags};
+/// # use std::ptr;
+/// const ONE_K: size_t = 1024;
+/// let mut slice: &mut [u8] = unsafe {
+///     let mem = mmap(ptr::null_mut(), ONE_K, ProtFlags::PROT_NONE,
+///                    MapFlags::MAP_ANON | MapFlags::MAP_PRIVATE, -1, 0).unwrap();
+///     mprotect(mem, ONE_K, ProtFlags::PROT_READ | ProtFlags::PROT_WRITE).unwrap();
+///     std::slice::from_raw_parts_mut(mem as *mut u8, ONE_K)
+/// };
+/// assert_eq!(slice[0], 0x00);
+/// slice[0] = 0xFF;
+/// assert_eq!(slice[0], 0xFF);
+/// ```
+pub unsafe fn mprotect(addr: *mut c_void, length: size_t, prot: ProtFlags) -> Result<()> {
+    Errno::result(libc::mprotect(addr, length, prot.bits())).map(drop)
+}
+
 pub unsafe fn msync(addr: *mut c_void, length: size_t, flags: MsFlags) -> Result<()> {
     Errno::result(libc::msync(addr, length, flags.bits())).map(drop)
 }