Merge remote-tracking branch 'core/master' into new-crate

src/net/tcp.rs

@@ -344,6 +344,27 @@ impl TcpStream {
         self.io.get_ref().peer_addr()
     }
 
+    /// Receives data on the socket from the remote address to which it is
+    /// connected, without removing that data from the queue. On success,
+    /// returns the number of bytes peeked.
+    ///
+    /// Successive calls return the same data. This is accomplished by passing
+    /// `MSG_PEEK` as a flag to the underlying recv system call.
+    pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+        if let Async::NotReady = self.poll_read() {
+            return Err(io::ErrorKind::WouldBlock.into())
+        }
+
+        match self.io.get_ref().peek(buf) {
+            Ok(v) => Ok(v),
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                self.io.need_read()?;
+                Err(io::ErrorKind::WouldBlock.into())
+            }
+            Err(e) => Err(e),
+        }
+    }
+
     /// Shuts down the read, write, or both halves of this connection.
     ///
     /// This function will cause all pending and future I/O on the specified
@@ -616,12 +637,7 @@ impl<'a> AsyncWrite for &'a TcpStream {
             // `bytes_vec` method.
             static DUMMY: &[u8] = &[0];
             let iovec = <&IoVec>::from(DUMMY);
-            let mut bufs = [
-                iovec, iovec, iovec, iovec,
-                iovec, iovec, iovec, iovec,
-                iovec, iovec, iovec, iovec,
-                iovec, iovec, iovec, iovec,
-            ];
+            let mut bufs = [iovec; 64];
             let n = buf.bytes_vec(&mut bufs);
             self.io.get_ref().write_bufs(&bufs[..n])
         };

src/reactor/mod.rs

@@ -455,12 +455,14 @@ mod platform {
     use mio::Ready;
     use mio::unix::UnixReady;
 
-    pub fn aio() -> Ready {
-        UnixReady::aio().into()
+    #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+    pub fn all() -> Ready {
+        hup() | UnixReady::aio().into()
     }
 
+    #[cfg(not(any(target_os = "dragonfly", target_os = "freebsd")))]
     pub fn all() -> Ready {
-        hup() | aio()
+        hup()
     }
 
     pub fn hup() -> Ready {
@@ -471,10 +473,20 @@ mod platform {
     const ERROR: usize = 1 << 3;
     const AIO: usize = 1 << 4;
 
+    #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+    fn is_aio(ready: &Ready) -> bool {
+        ready.is_aio()
+    }
+
+    #[cfg(not(any(target_os = "dragonfly", target_os = "freebsd")))]
+    fn is_aio(_ready: &Ready) -> bool {
+        false
+    }
+
     pub fn ready2usize(ready: Ready) -> usize {
         let ready = UnixReady::from(ready);
         let mut bits = 0;
-        if ready.is_aio() {
+        if is_aio(&ready) {
             bits |= AIO;
         }
         if ready.is_error() {
@@ -486,10 +498,22 @@ mod platform {
         bits
     }
 
+    #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "ios",
+              target_os = "macos"))]
+    fn usize2ready_aio(ready: &mut UnixReady) {
+        ready.insert(UnixReady::aio());
+    }
+
+    #[cfg(not(any(target_os = "dragonfly",
+        target_os = "freebsd", target_os = "ios", target_os = "macos")))]
+    fn usize2ready_aio(_ready: &mut UnixReady) {
+        // aio not available here → empty
+    }
+
     pub fn usize2ready(bits: usize) -> Ready {
         let mut ready = UnixReady::from(Ready::empty());
         if bits & AIO != 0 {
-            ready.insert(UnixReady::aio());
+            usize2ready_aio(&mut ready);
         }
         if bits & HUP != 0 {
             ready.insert(UnixReady::hup());