Make NetConnection local and remote address failable

src/connection.rs

@@ -59,8 +59,8 @@ pub trait NetConnection: NetStream + AsRawFd + Debug {
 
     fn shutdown(&mut self, how: Shutdown) -> io::Result<()>;
 
-    fn remote_addr(&self) -> Self::Addr;
-    fn local_addr(&self) -> Self::Addr;
+    fn remote_addr(&self) -> io::Result<Self::Addr>;
+    fn local_addr(&self) -> io::Result<Self::Addr>;
 
     fn set_read_timeout(&mut self, dur: Option<Duration>) -> io::Result<()>;
     fn set_write_timeout(&mut self, dur: Option<Duration>) -> io::Result<()>;
@@ -104,13 +104,9 @@ impl NetConnection for TcpStream {
 
     fn shutdown(&mut self, how: Shutdown) -> io::Result<()> { TcpStream::shutdown(self, how) }
 
-    fn remote_addr(&self) -> Self::Addr {
-        TcpStream::peer_addr(self).expect("TCP stream doesn't know remote peer address").into()
-    }
+    fn remote_addr(&self) -> io::Result<Self::Addr> { Ok(TcpStream::peer_addr(self)?.into()) }
 
-    fn local_addr(&self) -> Self::Addr {
-        TcpStream::local_addr(self).expect("TCP stream doesn't has local address").into()
-    }
+    fn local_addr(&self) -> io::Result<Self::Addr> { Ok(TcpStream::local_addr(self)?.into()) }
 
     fn set_read_timeout(&mut self, dur: Option<Duration>) -> io::Result<()> {
         TcpStream::set_read_timeout(self, dur)
@@ -229,20 +225,18 @@ impl NetConnection for socket2::Socket {
 
     fn shutdown(&mut self, how: Shutdown) -> io::Result<()> { socket2::Socket::shutdown(self, how) }
 
-    fn remote_addr(&self) -> Self::Addr {
-        socket2::Socket::peer_addr(self)
-            .expect("net stream must use only connections")
+    fn remote_addr(&self) -> io::Result<Self::Addr> {
+        Ok(socket2::Socket::peer_addr(self)?
             .as_socket()
-            .expect("net stream must use only connections")
-            .into()
+            .ok_or::<io::Error>(io::ErrorKind::NotFound.into())?
+            .into())
     }
 
-    fn local_addr(&self) -> Self::Addr {
-        socket2::Socket::local_addr(self)
-            .expect("net stream doesn't has local socket")
+    fn local_addr(&self) -> io::Result<Self::Addr> {
+        Ok(socket2::Socket::local_addr(self)?
             .as_socket()
-            .expect("net stream doesn't has local socket")
-            .into()
+            .ok_or::<io::Error>(io::ErrorKind::NotFound.into())?
+            .into())
     }
 
     fn set_read_timeout(&mut self, dur: Option<Duration>) -> io::Result<()> {

src/resource.rs

@@ -312,7 +312,7 @@ impl<S: NetSession> NetTransport<S> {
     pub fn is_outbound(&self) -> bool { self.link_direction() == Direction::Outbound }
     pub fn link_direction(&self) -> Direction { self.link_direction }
 
-    pub fn local_addr(&self) -> <S::Connection as NetConnection>::Addr {
+    pub fn local_addr(&self) -> io::Result<<S::Connection as NetConnection>::Addr> {
         self.session.as_connection().local_addr()
     }
 
@@ -497,7 +497,7 @@ impl<S: NetSession> Write for NetTransport<S> {
 
     fn flush(&mut self) -> io::Result<()> {
         let res = self.flush_buffer();
-        self.session.flush().and_then(|_| res)
+        self.session.flush().and(res)
     }
 }
 

src/session.rs

@@ -150,16 +150,16 @@ impl<I: EcSign, D: Digest> CypherSession<I, D> {
         cert: Cert<I::Sig>,
         allowed_ids: Vec<I::Pk>,
         signer: I,
-    ) -> Self {
-        Self::with_config::<HASHLEN>(
-            connection.remote_addr().into(),
+    ) -> io::Result<Self> {
+        Ok(Self::with_config::<HASHLEN>(
+            connection.remote_addr()?.into(),
             connection,
             Direction::Inbound,
             cert,
             allowed_ids,
             signer,
             false,
-        )
+        ))
     }
 
     fn with_config<const HASHLEN: usize>(
@@ -610,9 +610,9 @@ mod impl_noise {
         pub fn to_vec(&self) -> Vec<u8> {
             let mut vec = Vec::<u8>::with_capacity(D::OUTPUT_LEN + E::Pk::COMPRESSED_LEN);
             vec.extend_from_slice(self.handshake_hash.as_ref());
-            self.remote_static_key
-                .as_ref()
-                .map(|pk| vec.extend_from_slice(pk.to_pk_compressed().as_ref()));
+            if let Some(pk) = self.remote_static_key.as_ref() {
+                vec.extend_from_slice(pk.to_pk_compressed().as_ref())
+            }
             vec
         }
     }