fix clippy warn

yngrtc · yngrtc · commit bb3b8a19a97a · 2025-05-25T16:28:45.000-07:00
diff --git a/data/src/error.rs b/data/src/error.rs
@@ -48,7 +48,7 @@ impl From<Error> for io::Error {
             e @ Error::ErrStreamClosed => {
                 io::Error::new(io::ErrorKind::ConnectionAborted, e.to_string())
             }
-            e => io::Error::new(io::ErrorKind::Other, e.to_string()),
+            e => io::Error::other(e.to_string()),
         }
     }
 }
diff --git a/dtls/src/cipher_suite/cipher_suite_chacha20_poly1305_sha256.rs b/dtls/src/cipher_suite/cipher_suite_chacha20_poly1305_sha256.rs
@@ -14,10 +14,7 @@ impl CipherSuiteChaCha20Poly1305Sha256 {
     const PRF_IV_LEN: usize = 12;
 
     pub fn new(rsa: bool) -> Self {
-        CipherSuiteChaCha20Poly1305Sha256 {
-            rsa: rsa,
-            cipher: None,
-        }
+        CipherSuiteChaCha20Poly1305Sha256 { rsa, cipher: None }
     }
 }
 
diff --git a/ice/src/agent/agent_transport.rs b/ice/src/agent/agent_transport.rs
@@ -166,17 +166,17 @@ impl AgentConn {
 #[async_trait]
 impl Conn for AgentConn {
     async fn connect(&self, _addr: SocketAddr) -> std::result::Result<(), util::Error> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn recv(&self, buf: &mut [u8]) -> std::result::Result<usize, util::Error> {
         if self.done.load(Ordering::SeqCst) {
-            return Err(io::Error::new(io::ErrorKind::Other, "Conn is closed").into());
+            return Err(io::Error::other("Conn is closed").into());
         }
 
         let n = match self.buffer.read(buf, None).await {
             Ok(n) => n,
-            Err(err) => return Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),
+            Err(err) => return Err(io::Error::other(err.to_string()).into()),
         };
         self.bytes_received.fetch_add(n, Ordering::SeqCst);
 
@@ -191,13 +191,13 @@ impl Conn for AgentConn {
             let n = self.recv(buf).await?;
             Ok((n, raddr))
         } else {
-            Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+            Err(io::Error::other("Not applicable").into())
         }
     }
 
     async fn send(&self, buf: &[u8]) -> std::result::Result<usize, util::Error> {
         if self.done.load(Ordering::SeqCst) {
-            return Err(io::Error::new(io::ErrorKind::Other, "Conn is closed").into());
+            return Err(io::Error::other("Conn is closed").into());
         }
 
         if is_message(buf) {
@@ -217,7 +217,7 @@ impl Conn for AgentConn {
                 self.bytes_sent.fetch_add(buf.len(), Ordering::SeqCst);
                 Ok(n)
             }
-            Err(err) => Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),
+            Err(err) => Err(io::Error::other(err.to_string()).into()),
         }
     }
 
@@ -226,7 +226,7 @@ impl Conn for AgentConn {
         _buf: &[u8],
         _target: SocketAddr,
     ) -> std::result::Result<usize, util::Error> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     fn local_addr(&self) -> std::result::Result<SocketAddr, util::Error> {
diff --git a/ice/src/udp_mux/udp_mux_conn.rs b/ice/src/udp_mux/udp_mux_conn.rs
@@ -267,19 +267,19 @@ impl UDPMuxConnInner {
 #[async_trait]
 impl Conn for UDPMuxConn {
     async fn connect(&self, _addr: SocketAddr) -> ConnResult<()> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn recv(&self, _buf: &mut [u8]) -> ConnResult<usize> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn recv_from(&self, buf: &mut [u8]) -> ConnResult<(usize, SocketAddr)> {
         self.inner.recv_from(buf).await
     }
 
     async fn send(&self, _buf: &[u8]) -> ConnResult<usize> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn send_to(&self, buf: &[u8], target: SocketAddr) -> ConnResult<usize> {
diff --git a/sctp/src/association/association_internal.rs b/sctp/src/association/association_internal.rs
@@ -1040,11 +1040,7 @@ impl AssociationInternal {
             bytes_queued += s.get_num_bytes_in_reassembly_queue().await as u32;
         }
 
-        if bytes_queued >= self.max_receive_buffer_size {
-            0
-        } else {
-            self.max_receive_buffer_size - bytes_queued
-        }
+        self.max_receive_buffer_size.saturating_sub(bytes_queued)
     }
 
     pub(crate) fn open_stream(
diff --git a/sctp/src/association/association_internal/association_internal_test.rs b/sctp/src/association/association_internal/association_internal_test.rs
@@ -16,23 +16,23 @@ struct DumbConn;
 #[async_trait]
 impl Conn for DumbConn {
     async fn connect(&self, _addr: SocketAddr) -> Result<()> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn recv(&self, _b: &mut [u8]) -> Result<usize> {
         Ok(0)
     }
 
     async fn recv_from(&self, _buf: &mut [u8]) -> Result<(usize, SocketAddr)> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn send(&self, _b: &[u8]) -> Result<usize> {
         Ok(0)
     }
 
     async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> Result<usize> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     fn local_addr(&self) -> Result<SocketAddr> {
diff --git a/sctp/src/association/association_test.rs b/sctp/src/association/association_test.rs
@@ -2097,7 +2097,7 @@ type UResult<T> = std::result::Result<T, util::Error>;
 #[async_trait]
 impl Conn for FakeEchoConn {
     async fn connect(&self, _addr: SocketAddr) -> UResult<()> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn recv(&self, b: &mut [u8]) -> UResult<usize> {
@@ -2115,25 +2115,25 @@ impl Conn for FakeEchoConn {
     }
 
     async fn recv_from(&self, _buf: &mut [u8]) -> UResult<(usize, SocketAddr)> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn send(&self, b: &[u8]) -> UResult<usize> {
         let wr_tx = self.wr_tx.lock().await;
         match wr_tx.send(b.to_vec()).await {
             Ok(_) => {}
-            Err(err) => return Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),
+            Err(err) => return Err(io::Error::other(err.to_string()).into()),
         };
         self.bytes_sent.fetch_add(b.len(), Ordering::SeqCst);
         Ok(b.len())
     }
 
     async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> UResult<usize> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     fn local_addr(&self) -> UResult<SocketAddr> {
-        Err(io::Error::new(io::ErrorKind::AddrNotAvailable, "Addr Not Available").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     fn remote_addr(&self) -> Option<SocketAddr> {
diff --git a/sctp/src/error.rs b/sctp/src/error.rs
@@ -232,7 +232,7 @@ impl From<Error> for io::Error {
             e @ Error::ErrStreamClosed => {
                 io::Error::new(io::ErrorKind::ConnectionAborted, e.to_string())
             }
-            e => io::Error::new(io::ErrorKind::Other, e.to_string()),
+            e => io::Error::other(e.to_string()),
         }
     }
 }
diff --git a/turn/src/client/relay_conn.rs b/turn/src/client/relay_conn.rs
@@ -106,11 +106,11 @@ impl<T: 'static + RelayConnObserver + Send + Sync> RelayConn<T> {
 #[async_trait]
 impl<T: RelayConnObserver + Send + Sync> Conn for RelayConn<T> {
     async fn connect(&self, _addr: SocketAddr) -> Result<(), util::Error> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn recv(&self, _buf: &mut [u8]) -> Result<usize, util::Error> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     /// Reads a packet from the connection,
@@ -147,7 +147,7 @@ impl<T: RelayConnObserver + Send + Sync> Conn for RelayConn<T> {
     }
 
     async fn send(&self, _buf: &[u8]) -> Result<usize, util::Error> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     /// Writes a packet with payload `p` to `addr`.
@@ -159,7 +159,7 @@ impl<T: RelayConnObserver + Send + Sync> Conn for RelayConn<T> {
         let mut relay_conn = self.relay_conn.lock().await;
         match relay_conn.send_to(p, addr).await {
             Ok(n) => Ok(n),
-            Err(err) => Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),
+            Err(err) => Err(io::Error::other(err.to_string()).into()),
         }
     }
 
diff --git a/util/src/conn/conn_bridge.rs b/util/src/conn/conn_bridge.rs
@@ -24,7 +24,7 @@ struct BridgeConn {
 #[async_trait]
 impl Conn for BridgeConn {
     async fn connect(&self, _addr: SocketAddr) -> Result<()> {
-        Err(Error::new(ErrorKind::Other, "Not applicable").into())
+        Err(Error::other("Not applicable").into())
     }
 
     async fn recv(&self, b: &mut [u8]) -> Result<usize> {
@@ -52,7 +52,7 @@ impl Conn for BridgeConn {
     }
 
     async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> Result<usize> {
-        Err(Error::new(ErrorKind::Other, "Not applicable").into())
+        Err(Error::other("Not applicable").into())
     }
 
     fn local_addr(&self) -> Result<SocketAddr> {
diff --git a/util/src/conn/conn_pipe.rs b/util/src/conn/conn_pipe.rs
@@ -30,7 +30,7 @@ pub fn pipe() -> (impl Conn, impl Conn) {
 #[async_trait]
 impl Conn for Pipe {
     async fn connect(&self, _addr: SocketAddr) -> Result<()> {
-        Err(Error::new(ErrorKind::Other, "Not applicable").into())
+        Err(Error::other("Not applicable").into())
     }
 
     async fn recv(&self, b: &mut [u8]) -> Result<usize> {
@@ -53,13 +53,13 @@ impl Conn for Pipe {
         let wr_tx = self.wr_tx.lock().await;
         match wr_tx.send(b.to_vec()).await {
             Ok(_) => {}
-            Err(err) => return Err(Error::new(ErrorKind::Other, err.to_string()).into()),
+            Err(err) => return Err(Error::other(err.to_string()).into()),
         };
         Ok(b.len())
     }
 
     async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> Result<usize> {
-        Err(Error::new(ErrorKind::Other, "Not applicable").into())
+        Err(Error::other("Not applicable").into())
     }
 
     fn local_addr(&self) -> Result<SocketAddr> {
diff --git a/util/src/conn/mod.rs b/util/src/conn/mod.rs
@@ -62,12 +62,9 @@ where
         }
     }
 
-    Err(std::io::Error::new(
-        std::io::ErrorKind::Other,
-        format!(
-            "No available {} IP address found!",
-            if use_ipv4 { "ipv4" } else { "ipv6" },
-        ),
-    )
+    Err(std::io::Error::other(format!(
+        "No available {} IP address found!",
+        if use_ipv4 { "ipv4" } else { "ipv6" },
+    ))
     .into())
 }
diff --git a/webrtc/src/mux/endpoint.rs b/webrtc/src/mux/endpoint.rs
@@ -35,19 +35,19 @@ type Result<T> = std::result::Result<T, util::Error>;
 #[async_trait]
 impl Conn for Endpoint {
     async fn connect(&self, _addr: SocketAddr) -> Result<()> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     /// reads a packet of len(p) bytes from the underlying conn
     /// that are matched by the associated MuxFunc
     async fn recv(&self, buf: &mut [u8]) -> Result<usize> {
         match self.buffer.read(buf, None).await {
             Ok(n) => Ok(n),
-            Err(err) => Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),
+            Err(err) => Err(io::Error::other(err.to_string()).into()),
         }
     }
     async fn recv_from(&self, _buf: &mut [u8]) -> Result<(usize, SocketAddr)> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     /// writes bytes to the underlying conn
@@ -56,7 +56,7 @@ impl Conn for Endpoint {
     }
 
     async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> Result<usize> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     fn local_addr(&self) -> Result<SocketAddr> {
diff --git a/webrtc/src/mux/mux_test.rs b/webrtc/src/mux/mux_test.rs
@@ -37,7 +37,7 @@ type Result<T> = std::result::Result<T, util::Error>;
 #[async_trait]
 impl Conn for MuxErrorConn {
     async fn connect(&self, _addr: SocketAddr) -> Result<()> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn recv(&self, buf: &mut [u8]) -> Result<usize> {
@@ -47,28 +47,24 @@ impl Conn for MuxErrorConn {
             buf[..n].copy_from_slice(&self.data[idx][..n]);
             Ok(n)
         } else {
-            Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("idx {} >= data.len {}", idx, self.data.len()),
-            )
-            .into())
+            Err(io::Error::other(format!("idx {} >= data.len {}", idx, self.data.len())).into())
         }
     }
 
     async fn recv_from(&self, _buf: &mut [u8]) -> Result<(usize, SocketAddr)> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn send(&self, _buf: &[u8]) -> Result<usize> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> Result<usize> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     fn local_addr(&self) -> Result<SocketAddr> {
-        Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())
+        Err(io::Error::other("Not applicable").into())
     }
 
     fn remote_addr(&self) -> Option<SocketAddr> {

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ impl From<Error> for io::Error {`
`48`	`48`	`e @ Error::ErrStreamClosed => {`
`49`	`49`	`io::Error::new(io::ErrorKind::ConnectionAborted, e.to_string())`
`50`	`50`	`}`
`51`		`- e => io::Error::new(io::ErrorKind::Other, e.to_string()),`
	`51`	`+ e => io::Error::other(e.to_string()),`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,10 +14,7 @@ impl CipherSuiteChaCha20Poly1305Sha256 {`
`14`	`14`	`const PRF_IV_LEN: usize = 12;`
`15`	`15`
`16`	`16`	`pub fn new(rsa: bool) -> Self {`
`17`		`- CipherSuiteChaCha20Poly1305Sha256 {`
`18`		`- rsa: rsa,`
`19`		`- cipher: None,`
`20`		`- }`
	`17`	`+ CipherSuiteChaCha20Poly1305Sha256 { rsa, cipher: None }`
`21`	`18`	`}`
`22`	`19`	`}`
`23`	`20`
Original file line number	Diff line number	Diff line change
`@@ -166,17 +166,17 @@ impl AgentConn {`
`166`	`166`	`#[async_trait]`
`167`	`167`	`impl Conn for AgentConn {`
`168`	`168`	`async fn connect(&self, _addr: SocketAddr) -> std::result::Result<(), util::Error> {`
`169`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`169`	`+ Err(io::Error::other("Not applicable").into())`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`async fn recv(&self, buf: &mut [u8]) -> std::result::Result<usize, util::Error> {`
`173`	`173`	`if self.done.load(Ordering::SeqCst) {`
`174`		`- return Err(io::Error::new(io::ErrorKind::Other, "Conn is closed").into());`
	`174`	`+ return Err(io::Error::other("Conn is closed").into());`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`let n = match self.buffer.read(buf, None).await {`
`178`	`178`	`Ok(n) => n,`
`179`		`- Err(err) => return Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),`
	`179`	`+ Err(err) => return Err(io::Error::other(err.to_string()).into()),`
`180`	`180`	`};`
`181`	`181`	`self.bytes_received.fetch_add(n, Ordering::SeqCst);`
`182`	`182`
`@@ -191,13 +191,13 @@ impl Conn for AgentConn {`
`191`	`191`	`let n = self.recv(buf).await?;`
`192`	`192`	`Ok((n, raddr))`
`193`	`193`	`} else {`
`194`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`194`	`+ Err(io::Error::other("Not applicable").into())`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`async fn send(&self, buf: &[u8]) -> std::result::Result<usize, util::Error> {`
`199`	`199`	`if self.done.load(Ordering::SeqCst) {`
`200`		`- return Err(io::Error::new(io::ErrorKind::Other, "Conn is closed").into());`
	`200`	`+ return Err(io::Error::other("Conn is closed").into());`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`if is_message(buf) {`
`@@ -217,7 +217,7 @@ impl Conn for AgentConn {`
`217`	`217`	`self.bytes_sent.fetch_add(buf.len(), Ordering::SeqCst);`
`218`	`218`	`Ok(n)`
`219`	`219`	`}`
`220`		`- Err(err) => Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),`
	`220`	`+ Err(err) => Err(io::Error::other(err.to_string()).into()),`
`221`	`221`	`}`
`222`	`222`	`}`
`223`	`223`
`@@ -226,7 +226,7 @@ impl Conn for AgentConn {`
`226`	`226`	`_buf: &[u8],`
`227`	`227`	`_target: SocketAddr,`
`228`	`228`	`) -> std::result::Result<usize, util::Error> {`
`229`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`229`	`+ Err(io::Error::other("Not applicable").into())`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`fn local_addr(&self) -> std::result::Result<SocketAddr, util::Error> {`
Original file line number	Diff line number	Diff line change
`@@ -267,19 +267,19 @@ impl UDPMuxConnInner {`
`267`	`267`	`#[async_trait]`
`268`	`268`	`impl Conn for UDPMuxConn {`
`269`	`269`	`async fn connect(&self, _addr: SocketAddr) -> ConnResult<()> {`
`270`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`270`	`+ Err(io::Error::other("Not applicable").into())`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`async fn recv(&self, _buf: &mut [u8]) -> ConnResult<usize> {`
`274`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`274`	`+ Err(io::Error::other("Not applicable").into())`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`async fn recv_from(&self, buf: &mut [u8]) -> ConnResult<(usize, SocketAddr)> {`
`278`	`278`	`self.inner.recv_from(buf).await`
`279`	`279`	`}`
`280`	`280`
`281`	`281`	`async fn send(&self, _buf: &[u8]) -> ConnResult<usize> {`
`282`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`282`	`+ Err(io::Error::other("Not applicable").into())`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`async fn send_to(&self, buf: &[u8], target: SocketAddr) -> ConnResult<usize> {`
Original file line number	Diff line number	Diff line change
`@@ -1040,11 +1040,7 @@ impl AssociationInternal {`
`1040`	`1040`	`bytes_queued += s.get_num_bytes_in_reassembly_queue().await as u32;`
`1041`	`1041`	`}`
`1042`	`1042`
`1043`		`- if bytes_queued >= self.max_receive_buffer_size {`
`1044`		`- 0`
`1045`		`- } else {`
`1046`		`- self.max_receive_buffer_size - bytes_queued`
`1047`		`- }`
	`1043`	`+ self.max_receive_buffer_size.saturating_sub(bytes_queued)`
`1048`	`1044`	`}`
`1049`	`1045`
`1050`	`1046`	`pub(crate) fn open_stream(`
Original file line number	Diff line number	Diff line change
`@@ -16,23 +16,23 @@ struct DumbConn;`
`16`	`16`	`#[async_trait]`
`17`	`17`	`impl Conn for DumbConn {`
`18`	`18`	`async fn connect(&self, _addr: SocketAddr) -> Result<()> {`
`19`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`19`	`+ Err(io::Error::other("Not applicable").into())`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`async fn recv(&self, _b: &mut [u8]) -> Result<usize> {`
`23`	`23`	`Ok(0)`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`async fn recv_from(&self, _buf: &mut [u8]) -> Result<(usize, SocketAddr)> {`
`27`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`27`	`+ Err(io::Error::other("Not applicable").into())`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`async fn send(&self, _b: &[u8]) -> Result<usize> {`
`31`	`31`	`Ok(0)`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> Result<usize> {`
`35`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`35`	`+ Err(io::Error::other("Not applicable").into())`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`fn local_addr(&self) -> Result<SocketAddr> {`
Original file line number	Diff line number	Diff line change
`@@ -2097,7 +2097,7 @@ type UResult<T> = std::result::Result<T, util::Error>;`
`2097`	`2097`	`#[async_trait]`
`2098`	`2098`	`impl Conn for FakeEchoConn {`
`2099`	`2099`	`async fn connect(&self, _addr: SocketAddr) -> UResult<()> {`
`2100`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`2100`	`+ Err(io::Error::other("Not applicable").into())`
`2101`	`2101`	`}`
`2102`	`2102`
`2103`	`2103`	`async fn recv(&self, b: &mut [u8]) -> UResult<usize> {`
`@@ -2115,25 +2115,25 @@ impl Conn for FakeEchoConn {`
`2115`	`2115`	`}`
`2116`	`2116`
`2117`	`2117`	`async fn recv_from(&self, _buf: &mut [u8]) -> UResult<(usize, SocketAddr)> {`
`2118`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`2118`	`+ Err(io::Error::other("Not applicable").into())`
`2119`	`2119`	`}`
`2120`	`2120`
`2121`	`2121`	`async fn send(&self, b: &[u8]) -> UResult<usize> {`
`2122`	`2122`	`let wr_tx = self.wr_tx.lock().await;`
`2123`	`2123`	`match wr_tx.send(b.to_vec()).await {`
`2124`	`2124`	`Ok(_) => {}`
`2125`		`- Err(err) => return Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),`
	`2125`	`+ Err(err) => return Err(io::Error::other(err.to_string()).into()),`
`2126`	`2126`	`};`
`2127`	`2127`	`self.bytes_sent.fetch_add(b.len(), Ordering::SeqCst);`
`2128`	`2128`	`Ok(b.len())`
`2129`	`2129`	`}`
`2130`	`2130`
`2131`	`2131`	`async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> UResult<usize> {`
`2132`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`2132`	`+ Err(io::Error::other("Not applicable").into())`
`2133`	`2133`	`}`
`2134`	`2134`
`2135`	`2135`	`fn local_addr(&self) -> UResult<SocketAddr> {`
`2136`		`- Err(io::Error::new(io::ErrorKind::AddrNotAvailable, "Addr Not Available").into())`
	`2136`	`+ Err(io::Error::other("Not applicable").into())`
`2137`	`2137`	`}`
`2138`	`2138`
`2139`	`2139`	`fn remote_addr(&self) -> Option<SocketAddr> {`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ impl From<Error> for io::Error {`
`232`	`232`	`e @ Error::ErrStreamClosed => {`
`233`	`233`	`io::Error::new(io::ErrorKind::ConnectionAborted, e.to_string())`
`234`	`234`	`}`
`235`		`- e => io::Error::new(io::ErrorKind::Other, e.to_string()),`
	`235`	`+ e => io::Error::other(e.to_string()),`
`236`	`236`	`}`
`237`	`237`	`}`
`238`	`238`	`}`
Original file line number	Diff line number	Diff line change
`@@ -106,11 +106,11 @@ impl<T: 'static + RelayConnObserver + Send + Sync> RelayConn<T> {`
`106`	`106`	`#[async_trait]`
`107`	`107`	`impl<T: RelayConnObserver + Send + Sync> Conn for RelayConn<T> {`
`108`	`108`	`async fn connect(&self, _addr: SocketAddr) -> Result<(), util::Error> {`
`109`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`109`	`+ Err(io::Error::other("Not applicable").into())`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`async fn recv(&self, _buf: &mut [u8]) -> Result<usize, util::Error> {`
`113`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`113`	`+ Err(io::Error::other("Not applicable").into())`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`/// Reads a packet from the connection,`
`@@ -147,7 +147,7 @@ impl<T: RelayConnObserver + Send + Sync> Conn for RelayConn<T> {`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`async fn send(&self, _buf: &[u8]) -> Result<usize, util::Error> {`
`150`		`- Err(io::Error::new(io::ErrorKind::Other, "Not applicable").into())`
	`150`	`+ Err(io::Error::other("Not applicable").into())`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	/// Writes a packet with payload `p` to `addr`.
`@@ -159,7 +159,7 @@ impl<T: RelayConnObserver + Send + Sync> Conn for RelayConn<T> {`
`159`	`159`	`let mut relay_conn = self.relay_conn.lock().await;`
`160`	`160`	`match relay_conn.send_to(p, addr).await {`
`161`	`161`	`Ok(n) => Ok(n),`
`162`		`- Err(err) => Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),`
	`162`	`+ Err(err) => Err(io::Error::other(err.to_string()).into()),`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ struct BridgeConn {`
`24`	`24`	`#[async_trait]`
`25`	`25`	`impl Conn for BridgeConn {`
`26`	`26`	`async fn connect(&self, _addr: SocketAddr) -> Result<()> {`
`27`		`- Err(Error::new(ErrorKind::Other, "Not applicable").into())`
	`27`	`+ Err(Error::other("Not applicable").into())`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`async fn recv(&self, b: &mut [u8]) -> Result<usize> {`
`@@ -52,7 +52,7 @@ impl Conn for BridgeConn {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`async fn send_to(&self, _buf: &[u8], _target: SocketAddr) -> Result<usize> {`
`55`		`- Err(Error::new(ErrorKind::Other, "Not applicable").into())`
	`55`	`+ Err(Error::other("Not applicable").into())`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`fn local_addr(&self) -> Result<SocketAddr> {`