FEAT: Test client

Author: BryanFRD

certificats.bat

@@ -21,7 +21,7 @@ if %ERRORLEVEL% neq 0 (
   exit /b 1
 )
 
-openssl req -new -x509 -key "%PRIVATE_KEY_FILE%" -out "%CERTIFICATE_FILE%" -days 365 -subj "/CN=localhost"
+openssl req -x509 -new -key %PRIVATE_KEY_FILE% -out %CERTIFICATE_FILE% -days 365 -subj "/CN=MyLocalCA"
 if %ERRORLEVEL% neq 0 (
   echo Error generating certificate.
   exit /b 1

src/main.rs

@@ -32,6 +32,13 @@ async fn main() {
         };
     });
 
+    tokio::spawn(async move {
+        match webtransport::start_client().await {
+            Ok(_) => log::info!("WebTransport client stopped"),
+            Err(e) => log::error!("WebTransport client failed: {:?}", e)
+        };
+    });
+    
     let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
     log::info!("Listening on {}", listener.local_addr().unwrap());
 

src/webtransport/mod.rs

@@ -1,5 +1,5 @@
 use std::error::Error;
-use wtransport::{endpoint::IncomingSession, Endpoint, Identity, ServerConfig};
+use wtransport::{config::TlsClientConfig, endpoint::IncomingSession, ClientConfig, Endpoint, Identity, ServerConfig};
 
 pub async fn start_webtransport() -> Result<(), Box<dyn Error>> {
     let identity = match Identity::load_pemfiles("certs/localhost.crt", "certs/localhost.key").await {
@@ -56,11 +56,66 @@ async fn handle_connection(incoming_session: IncomingSession) -> Result<(), Box<
 
     log::info!("Accepted connection from {:?}", connection.remote_address());
 
-    while let Ok((mut recv_stream, mut send_stream)) = connection.accept_bi().await {
+    while let Ok((mut send_stream, mut recv_stream)) = connection.accept_bi().await {
         log::trace!("Accepted bidirectional stream");
 
         let mut buffer = vec![0; 1024];
+        let bytes_read = match recv_stream.read(&mut buffer).await {
+            Ok(Some(bytes_read)) => bytes_read,
+            Ok(None) => {
+                log::info!("Stream closed");
+                break;
+            }
+            Err(e) => {
+                log::error!("Failed to read from stream: {:?}", e);
+                break;
+            }
+        };
+        
+        log::info!("Received data! {:?}", &buffer[..bytes_read]);
+        
+        match send_stream.write_all(&buffer[..bytes_read]).await {
+            Ok(_) => {},
+            Err(e) => {
+                log::error!("Failed to write to stream: {:?}", e);
+                break;
+            }
+        };
+    };
+    
+    Ok(())
+}
+
+pub async fn start_client() -> Result<(), Box<dyn Error>> {
+    let config = ClientConfig::default();
+    
+    let client = match Endpoint::client(config) {
+        Ok(client) => client,
+        Err(e) => {
+            log::error!("Failed to create client: {:?}", e);
+            return Err(Box::new(e));
+        }
+    };
+    
+    let connection = match client.connect("https://localhost:4433").await {
+        Ok(connection) => connection,
+        Err(e) => {
+            log::error!("Failed to connect to server: {:?}", e);
+            return Err(Box::new(e));
+        }
     };
 
+    log::info!("Connected to server at {:?}", connection.remote_address());
+    
+    let (mut send_stream, mut recv_stream) = connection.open_bi().await.unwrap().await.unwrap();
+    
+    let message = b"Hello, world!";
+    send_stream.write_all(message).await?;
+    log::info!("Sent message: {:?}", message);
+    
+    let mut buffer = vec![0; 1024];
+    let bytes_read = recv_stream.read(&mut buffer).await.unwrap().unwrap();
+    log::info!("Received data: {:?}", &buffer[..bytes_read]);
+    
     Ok(())
 }