Fix: replace is_connect_failed with is_err

examples/tcp_client.rs

@@ -28,7 +28,7 @@ fn main() -> io::Result<()> {
     };
 
     println!("event: {:?}", event);
-    if event.is_connect_failed().unwrap_or_default() {
+    if event.is_err().unwrap_or(false) {
         println!("connect failed");
     }
 

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,66 @@ 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(
+        since = "3.4.0",
+        note = "use `is_err` in combination of is_hub instead, see documentation for `is_err`"
+    )]
     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))
     }
 }