Adding base TCP error types for connection failure detection

Author: ryan-summers

src/lib.rs

@@ -22,5 +22,6 @@ pub use no_std_net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, Socke
 
 pub use dns::{AddrType, Dns};
 pub use stack::{
-	SharableStack, SharedStack, TcpClientStack, TcpFullStack, UdpClientStack, UdpFullStack,
+	SharableStack, SharedStack, TcpClientStack, TcpError, TcpErrorKind, TcpFullStack,
+	UdpClientStack, UdpFullStack,
 };

src/stack/mod.rs

@@ -3,5 +3,5 @@ mod tcp;
 mod udp;
 
 pub use share::{SharableStack, SharedStack};
-pub use tcp::{TcpClientStack, TcpFullStack};
+pub use tcp::{TcpClientStack, TcpError, TcpErrorKind, TcpFullStack};
 pub use udp::{UdpClientStack, UdpFullStack};

src/stack/share.rs

@@ -128,9 +128,6 @@ where
 	forward! {connect(socket: &mut Self::TcpSocket, address: SocketAddr) -> Result<(), nb::Error<<T as TcpClientStack>::Error>>}
 	forward! {send(socket: &mut Self::TcpSocket, data: &[u8]) -> Result<usize, nb::Error<<T as TcpClientStack>::Error>>}
 	forward! {receive(socket: &mut Self::TcpSocket, data: &mut [u8]) -> Result<usize, nb::Error<<T as TcpClientStack>::Error>>}
-	forward! {is_open(socket: &Self::TcpSocket) -> Result<bool, Self::Error>}
-	forward! {may_send(socket: &Self::TcpSocket) -> Result<bool, Self::Error>}
-	forward! {may_receive(socket: &Self::TcpSocket) -> Result<bool, Self::Error>}
 	forward! {close(socket: Self::TcpSocket) -> Result<(), Self::Error>}
 }
 

src/stack/tcp.rs

@@ -1,5 +1,22 @@
 use crate::SocketAddr;
 
+/// Represents specific errors encountered during TCP operations.
+#[non_exhaustive]
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum TcpErrorKind {
+	/// The peer has closed one or both directions and the connection is broken.
+	PipeClosed,
+
+	/// Some other error has occurred.
+	Other,
+}
+
+/// Methods to resolve errors into identifiable, actionable codes on the client side.
+pub trait TcpError: core::fmt::Debug {
+	/// Determines the kind of error that occurred.
+	fn kind(&self) -> TcpErrorKind;
+}
+
 /// This trait is implemented by TCP/IP stacks. You could, for example, have an implementation
 /// which knows how to send AT commands to an ESP8266 WiFi module. You could have another implementation
 /// which knows how to driver the Rust Standard Library's `std::net` module. Given this trait, you can
@@ -8,7 +25,7 @@ pub trait TcpClientStack {
 	/// The type returned when we create a new TCP socket
 	type TcpSocket;
 	/// The type returned when we have an error
-	type Error: core::fmt::Debug;
+	type Error: TcpError;
 
 	/// Open a socket for usage as a TCP client.
 	///
@@ -27,22 +44,6 @@ pub trait TcpClientStack {
 		remote: SocketAddr,
 	) -> nb::Result<(), Self::Error>;
 
-	/// Determine if a socket is opened.
-	///
-	/// Returns `Ok(true)` if the TCP socket is actively ingressing and egressing packets. This
-	/// corresponds to any TCP state that is not `CLOSED` or `TIME-WAIT`.
-	fn is_open(&mut self, socket: &Self::TcpSocket) -> Result<bool, Self::Error>;
-
-	/// Check if the TCP socket can transmit data.
-	///
-	/// Returns `Ok(true)` if the TCP transmit half is open and connected.
-	fn may_send(&mut self, socket: &Self::TcpSocket) -> Result<bool, Self::Error>;
-
-	/// Check if the TCP socket can receive data.
-	///
-	/// Returns `Ok(true)` if the TCP receive half is open and connected.
-	fn may_receive(&mut self, socket: &Self::TcpSocket) -> Result<bool, Self::Error>;
-
 	/// Write to the stream.
 	///
 	/// Returns the number of bytes written (which may be less than `buffer.len()`) or an error.
@@ -111,18 +112,6 @@ impl<T: TcpClientStack> TcpClientStack for &mut T {
 		T::connect(self, socket, remote)
 	}
 
-	fn is_open(&mut self, socket: &Self::TcpSocket) -> Result<bool, Self::Error> {
-		T::is_open(self, socket)
-	}
-
-	fn may_send(&mut self, socket: &Self::TcpSocket) -> Result<bool, Self::Error> {
-		T::may_send(self, socket)
-	}
-
-	fn may_receive(&mut self, socket: &Self::TcpSocket) -> Result<bool, Self::Error> {
-		T::may_receive(self, socket)
-	}
-
 	fn send(
 		&mut self,
 		socket: &mut Self::TcpSocket,