Fix: replace is_connect_failed with is_err

examples/tcp_client.rs

@@ -1,36 +1,155 @@
-use std::{io, net};
+#[cfg(target_os = "linux")]
+fn main() -> std::io::Result<()> {
+    use std::net;
+    use std::{io::Write, time::Duration};
 
-use polling::Event;
-use socket2::Type;
+    use polling::Event;
+    use socket2::Type;
 
-fn main() -> io::Result<()> {
+    std::thread::spawn(|| {
+        let listener = net::TcpListener::bind("0.0.0.0:8080").unwrap();
+        println!("Listening on {}", listener.local_addr().unwrap());
+        for stream in listener.incoming() {
+            let mut stream = stream.unwrap();
+            stream.write_all(b"Hello, world!\n").unwrap();
+        }
+    });
+    std::thread::sleep(Duration::from_millis(100));
     let socket = socket2::Socket::new(socket2::Domain::IPV4, Type::STREAM, None)?;
     let poller = polling::Poller::new()?;
     unsafe {
         poller.add(&socket, Event::new(0, true, true))?;
     }
-    let addr = net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), 8080);
+
     socket.set_nonblocking(true)?;
-    let _ = socket.connect(&addr.into());
 
     let mut events = polling::Events::new();
+    poller.wait(&mut events, Some(Duration::from_secs(3)))?;
+
+    let event = events.iter().next().expect("no event");
+
+    assert!(event.is_interrupt());
+
+    let addr = net::SocketAddr::new("127.0.0.1".parse().unwrap(), 8080);
+    let err = socket.connect(&addr.into()).unwrap_err();
+
+    // EINPROGRESS
+    assert_eq!(115, err.raw_os_error().expect("No OS error"));
 
+    poller
+        .modify(&socket, Event::writable(0))
+        .expect("modify failed");
     events.clear();
-    poller.wait(&mut events, None)?;
-
-    let event = events.iter().next();
-    let event = match event {
-        Some(event) => event,
-        None => {
-            println!("no event");
-            return Ok(());
+    poller.wait(&mut events, Some(Duration::from_secs(3)))?;
+
+    let event = events.iter().next().expect("no event");
+
+    assert!(event.writable);
+    assert!(!event.is_interrupt());
+    assert!(!event.is_err().unwrap());
+
+    println!("event: {:?}", event);
+    println!("socket is now writable");
+    // ========================================================================
+    // the below is example of a bad socket
+    println!("testing bad socket");
+    let bad_socket = socket2::Socket::new(socket2::Domain::IPV4, Type::STREAM, None)?;
+    let addr = net::SocketAddr::new("127.0.0.1".parse().unwrap(), 12345);
+    bad_socket.set_nonblocking(true)?;
+
+    unsafe {
+        poller.add(&bad_socket, Event::writable(0))?;
+    }
+
+    events.clear();
+    poller.wait(&mut events, Some(Duration::from_secs(3)))?;
+
+    let err = bad_socket.connect(&addr.into()).unwrap_err();
+    assert_eq!(115, err.raw_os_error().expect("No OS error"));
+
+    poller
+        .modify(&bad_socket, Event::writable(0))
+        .expect("modify failed");
+
+    events.clear();
+    poller.wait(&mut events, Some(Duration::from_secs(3)))?;
+
+    let event = events.iter().next().expect("no event");
+
+    assert!(event.is_err().unwrap());
+    println!("bad socket is now in error state");
+
+    Ok(())
+}
+
+#[cfg(target_os = "windows")]
+fn main() -> std::io::Result<()> {
+    use polling::Event;
+    use std::io;
+    use std::{io::Write, time::Duration};
+
+    std::thread::spawn(|| {
+        let listener = std::net::TcpListener::bind("0.0.0.0:8080").unwrap();
+        println!("Listening on {}", listener.local_addr().unwrap());
+        for stream in listener.incoming() {
+            let mut stream = match stream {
+                Ok(stream) => stream,
+                Err(_) => {
+                    continue;
+                }
+            };
+            stream.write_all(b"Hello, world!\n").unwrap();
         }
-    };
+    });
+    std::thread::sleep(Duration::from_millis(100));
+    let socket = socket2::Socket::new(socket2::Domain::IPV4, socket2::Type::STREAM, None)?;
+    let poller = polling::Poller::new()?;
+    unsafe {
+        poller.add(&socket, Event::new(0, true, true))?;
+    }
+
+    socket.set_nonblocking(true)?;
+
+    let addr = std::net::SocketAddr::new("127.0.0.1".parse().unwrap(), 8080);
+    let err = socket.connect(&addr.into()).unwrap_err();
+
+    assert_eq!(err.kind(), io::ErrorKind::WouldBlock);
+
+    let mut events = polling::Events::new();
+    poller.wait(&mut events, Some(Duration::from_secs(3)))?;
+
+    let event = events.iter().next().expect("no event");
+
+    assert!(event.writable);
+    assert!(!event.is_interrupt());
+    assert!(!event.is_err().unwrap());
 
     println!("event: {:?}", event);
-    if event.is_connect_failed().unwrap_or_default() {
-        println!("connect failed");
+    println!("socket is now writable");
+    // // ========================================================================
+    // // the below is example of a bad socket
+    println!("testing bad socket");
+    let bad_socket = socket2::Socket::new(socket2::Domain::IPV4, socket2::Type::STREAM, None)?;
+    let addr = std::net::SocketAddr::new("127.0.0.1".parse().unwrap(), 12345);
+    bad_socket.set_nonblocking(true)?;
+    bad_socket.connect(&addr.into()).unwrap_err();
+
+    unsafe {
+        poller.add(&bad_socket, Event::writable(0))?;
     }
 
+    events.clear();
+    poller.wait(&mut events, Some(Duration::from_secs(3)))?;
+
+    let event = events.iter().next().expect("no event");
+
+    assert!(event.is_err().unwrap());
+    println!("bad socket is now in error state");
+
     Ok(())
 }
+
+#[cfg(not(any(target_os = "linux", target_os = "windows")))]
+fn main() {
+    println!("This example is not yet supported on this platform.");
+}

src/epoll.rs

@@ -386,9 +386,14 @@ impl EventExtra {
     pub fn is_connect_failed(&self) -> Option<bool> {
         Some(
             self.flags.contains(epoll::EventFlags::ERR)
-                || self.flags.contains(epoll::EventFlags::HUP),
+                && self.flags.contains(epoll::EventFlags::HUP),
         )
     }
+
+    #[inline]
+    pub fn is_err(&self) -> Option<bool> {
+        Some(self.flags.contains(epoll::EventFlags::ERR))
+    }
 }
 
 /// The notifier for Linux.

src/iocp/mod.rs

@@ -682,11 +682,17 @@ impl EventExtra {
         self.flags.set(AfdPollMask::RECEIVE_EXPEDITED, active);
     }
 
-    /// Check if TCP connect failed.
+    /// Check if TCP connect failed. Deprecated.
     #[inline]
     pub fn is_connect_failed(&self) -> Option<bool> {
         Some(self.flags.intersects(AfdPollMask::CONNECT_FAIL))
     }
+
+    /// Check if TCP connect failed.
+    #[inline]
+    pub fn is_err(&self) -> Option<bool> {
+        Some(self.flags.intersects(AfdPollMask::CONNECT_FAIL))
+    }
 }
 
 /// A packet used to wake up the poller with an event.

src/kqueue.rs

@@ -376,6 +376,11 @@ impl EventExtra {
     pub fn is_connect_failed(&self) -> Option<bool> {
         None
     }
+
+    #[inline]
+    pub fn is_err(&self) -> Option<bool> {
+        None
+    }
 }
 
 pub(crate) fn mode_to_flags(mode: PollMode) -> kqueue::EventFlags {

src/lib.rs

@@ -391,10 +391,63 @@ impl Event {
     /// Returns `Some(true)` if the connection has failed, `Some(false)` if the connection has not failed,
     /// or `None` if the platform does not support detecting this condition.
     #[inline]
+    #[deprecated]
     pub fn is_connect_failed(&self) -> Option<bool> {
         self.extra.is_connect_failed()
     }
 
+    /// Tells if this event is the result of a connection failure.
+    ///
+    /// This function checks if an error exist,particularlly useful in detecting if TCP connection failed. It corresponds to the `EPOLLERR` event in Linux
+    /// and `CONNECT_FAILED` event in Windows IOCP.
+    ///
+    /// note: in epoll, a tcp connection failure is indicated by EPOLLERR + EPOLLHUP, though just EPOLLERR is enough to indicate a connection failure.
+    /// EPOLLHUP may happen when we haven't event called `connect` on the socket, but it is still a valid event to check for.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    ///   fn main() -> std::io::Result<()> {
+    ///       use std::net;
+    ///       use std::time::Duration;
+    ///   
+    ///       use polling::Event;
+    ///       use socket2::Type;
+    ///       let poller = polling::Poller::new()?;
+    ///       let bad_socket = socket2::Socket::new(socket2::Domain::IPV4, Type::STREAM, None)?;
+    ///       let addr = net::SocketAddr::new("127.0.0.1".parse().unwrap(), 12345);
+    ///       bad_socket.set_nonblocking(true)?;
+    ///       let mut events = polling::Events::new();
+    ///   
+    ///       let _ = bad_socket.connect(&addr.into()).unwrap_err();
+    ///   
+    ///       unsafe {
+    ///           poller.add(&bad_socket, Event::writable(0))?;
+    ///       }
+    ///   
+    ///       poller.wait(&mut events, Some(Duration::from_secs(3)))?;
+    ///   
+    ///       let event = events.iter().next().expect("no event");
+    ///       let is_err = match event.is_err() {
+    ///           Some(is_err) => is_err,
+    ///           None => {
+    ///               println!("not supported in this platform");
+    ///               return Ok(());
+    ///           },
+    ///       };
+    ///       assert!(is_err);
+    ///       println!("bad socket is now in error state");
+    ///   
+    ///       Ok(())
+    ///   }
+    /// ```  
+    /// Returns `Some(true)` if the connection has failed, `Some(false)` if there is an error,
+    /// or `None` if the platform does not support detecting this condition.
+    #[inline]
+    pub fn is_err(&self) -> Option<bool> {
+        self.extra.is_err()
+    }
+
     /// Remove any extra information from this event.
     #[inline]
     pub fn clear_extra(&mut self) {

src/poll.rs

@@ -431,6 +431,11 @@ impl EventExtra {
     pub fn is_connect_failed(&self) -> Option<bool> {
         Some(self.flags.contains(PollFlags::ERR) || self.flags.contains(PollFlags::HUP))
     }
+
+    #[inline]
+    pub fn is_err(&self) -> Option<bool> {
+        Some(self.flags.contains(PollFlags::ERR))
+    }
 }
 
 fn cvt_mode_as_remove(mode: PollMode) -> io::Result<bool> {

src/port.rs

@@ -253,6 +253,11 @@ impl EventExtra {
 
     #[inline]
     pub fn is_connect_failed(&self) -> Option<bool> {
-        Some(self.flags.contains(PollFlags::ERR) || self.flags.contains(PollFlags::HUP))
+        Some(self.flags.contains(PollFlags::ERR) && self.flags.contains(PollFlags::HUP))
+    }
+
+    #[inline]
+    pub fn is_err(&self) -> Option<bool> {
+        Some(self.flags.contains(PollFlags::ERR))
     }
 }