native refactor done

veilid-core/src/intf/native/network/network_udp.rs

@@ -54,7 +54,7 @@ impl Network {
                             log_net!("UDP packet: {:?}", descriptor);
 
                             if let Err(e) = network_manager
-                                .on_recv_envelope(&data[..size], &descriptor)
+                                .on_recv_envelope(&data[..size], descriptor)
                                 .await
                             {
                                 log_net!(error "failed to process received udp envelope: {}", e);

veilid-core/src/intf/native/network/protocol/mod.rs

@@ -56,6 +56,16 @@ impl ProtocolNetworkConnection {
         }
     }
 
+    pub async fn close(&mut self) -> Result<(), String> {
+        match self {
+            Self::Dummy(d) => d.close(),
+            Self::RawTcp(t) => t.close().await,
+            Self::WsAccepted(w) => w.close().await,
+            Self::Ws(w) => w.close().await,
+            Self::Wss(w) => w.close().await,
+        }
+    }
+
     pub async fn send(&mut self, message: Vec<u8>) -> Result<(), String> {
         match self {
             Self::Dummy(d) => d.send(message),

veilid-core/src/intf/native/network/protocol/tcp.rs

@@ -3,9 +3,9 @@ use crate::intf::native::utils::async_peek_stream::*;
 use crate::intf::*;
 use crate::network_manager::MAX_MESSAGE_SIZE;
 use crate::*;
-use async_std::net::*;
-use async_std::prelude::*;
-use std::fmt;
+use async_std::net::TcpStream;
+use core::fmt;
+use futures_util::{AsyncReadExt, AsyncWriteExt};
 
 pub struct RawTcpNetworkConnection {
     stream: AsyncPeekStream,
@@ -22,6 +22,14 @@ impl RawTcpNetworkConnection {
         Self { stream }
     }
 
+    pub async fn close(&mut self) -> Result<(), String> {
+        self.stream
+            .close()
+            .await
+            .map_err(map_to_string)
+            .map_err(logthru_net!())
+    }
+
     pub async fn send(&mut self, message: Vec<u8>) -> Result<(), String> {
         if message.len() > MAX_MESSAGE_SIZE {
             return Err("sending too large TCP message".to_owned());
@@ -183,7 +191,7 @@ impl ProtocolAcceptHandler for RawTcpProtocolHandler {
         &self,
         stream: AsyncPeekStream,
         peer_addr: SocketAddr,
-    ) -> SystemPinBoxFuture<Result<Option<NetworkConnection>, String>> {
+    ) -> SystemPinBoxFuture<core::result::Result<Option<NetworkConnection>, String>> {
         Box::pin(self.clone().on_accept_async(stream, peer_addr))
     }
 }

veilid-core/src/intf/native/network/protocol/ws.rs

@@ -3,16 +3,16 @@ use crate::intf::native::utils::async_peek_stream::*;
 use crate::intf::*;
 use crate::network_manager::MAX_MESSAGE_SIZE;
 use crate::*;
+use alloc::sync::Arc;
 use async_std::io;
 use async_std::net::*;
 use async_tls::TlsConnector;
 use async_tungstenite::tungstenite::protocol::Message;
 use async_tungstenite::{accept_async, client_async, WebSocketStream};
+use core::fmt;
+use core::time::Duration;
 use futures_util::sink::SinkExt;
 use futures_util::stream::StreamExt;
-use std::fmt;
-use std::sync::Arc;
-use std::time::Duration;
 
 pub type WebSocketNetworkConnectionAccepted = WebsocketNetworkConnection<AsyncPeekStream>;
 pub type WebsocketNetworkConnectionWSS =
@@ -68,6 +68,16 @@ where
         }
     }
 
+    pub async fn close(&self) -> Result<(), String> {
+        let mut inner = self.inner.lock().await;
+        inner
+            .ws_stream
+            .close(None)
+            .await
+            .map_err(map_to_string)
+            .map_err(logthru_net!(error "failed to close websocket"))
+    }
+
     pub async fn send(&self, message: Vec<u8>) -> Result<(), String> {
         if message.len() > MAX_MESSAGE_SIZE {
             return Err("received too large WS message".to_owned());