Add TCP connection to server

src/main.rs

@@ -1,8 +1,14 @@
 use anyhow::Result;
+use std::net::ToSocketAddrs;
 use std::time::Duration;
 use tokio::io::AsyncReadExt;
 use tokio::net::tcp::{OwnedReadHalf, OwnedWriteHalf};
 use tokio::net::TcpStream;
+use tokio::pin;
+use tokio_rustls::rustls::client::danger::{HandshakeSignatureValid, ServerCertVerifier};
+use tokio_rustls::rustls::pki_types::{CertificateDer, ServerName, UnixTime};
+use tokio_rustls::rustls::{ClientConfig, DigitallySignedStruct};
+use tokio_rustls::{rustls, TlsConnector};
 use tracing::error;
 use tracing::info;
 use tracing::info_span;
@@ -16,7 +22,7 @@ use wtransport::ServerConfig;
 
 use lazy_static::lazy_static;
 use std::collections::HashMap;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
 type GlobalMap = Mutex<HashMap<usize, wtransport::Connection>>;
 
@@ -24,6 +30,58 @@ lazy_static! {
     static ref DATA_MAP: GlobalMap = Mutex::new(HashMap::new());
 }
 
+#[derive(Debug)]
+struct NoCertificateVerification;
+
+impl ServerCertVerifier for NoCertificateVerification {
+    fn verify_server_cert(
+        &self,
+        _end_entity: &CertificateDer<'_>,
+        _intermediates: &[CertificateDer<'_>],
+        _server_name: &ServerName<'_>,
+        _ocsp: &[u8],
+        _now: UnixTime,
+    ) -> Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
+        Ok(rustls::client::danger::ServerCertVerified::assertion())
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        _message: &[u8],
+        _cert: &CertificateDer<'_>,
+        _dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        Ok(HandshakeSignatureValid::assertion())
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        _message: &[u8],
+        _cert: &CertificateDer<'_>,
+        _dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        Ok(HandshakeSignatureValid::assertion())
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
+        vec![
+            rustls::SignatureScheme::RSA_PKCS1_SHA1,
+            rustls::SignatureScheme::ECDSA_SHA1_Legacy,
+            rustls::SignatureScheme::RSA_PKCS1_SHA256,
+            rustls::SignatureScheme::ECDSA_NISTP256_SHA256,
+            rustls::SignatureScheme::RSA_PKCS1_SHA384,
+            rustls::SignatureScheme::ECDSA_NISTP384_SHA384,
+            rustls::SignatureScheme::RSA_PKCS1_SHA512,
+            rustls::SignatureScheme::ECDSA_NISTP521_SHA512,
+            rustls::SignatureScheme::RSA_PSS_SHA256,
+            rustls::SignatureScheme::RSA_PSS_SHA384,
+            rustls::SignatureScheme::RSA_PSS_SHA512,
+            rustls::SignatureScheme::ED25519,
+            rustls::SignatureScheme::ED448,
+        ]
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     init_logging();
@@ -71,7 +129,26 @@ async fn handle_connection_impl(incoming_session: IncomingSession, id: usize) ->
 
     info!("Connecting to corresponding Mumble server...");
 
-    let server_tcp = TcpStream::connect("127.0.0.1:64738").await?.into_split();
+    let config = ClientConfig::builder()
+        .dangerous()
+        .with_custom_certificate_verifier(Arc::new(NoCertificateVerification))
+        .with_no_client_auth();
+
+    let connector = TlsConnector::from(Arc::new(config));
+
+    //let addr = "127.0.0.1:64738"
+    let addr = "ohea.xyz:64738"
+        .to_string()
+        .to_socket_addrs()?
+        .next()
+        .unwrap();
+
+    let server_tcp = TcpStream::connect(addr).await?;
+    let server_stream = connector
+        //.connect("127.0.0.1".try_into()?, server_tcp)
+        .connect("ohea.xyz".try_into()?, server_tcp)
+        .await?;
+    let (read_server, write_server) = tokio::io::split(server_stream);
 
     info!("Connected to Mumble Server!");
 
@@ -81,11 +158,11 @@ async fn handle_connection_impl(incoming_session: IncomingSession, id: usize) ->
     info!("Spawing jobs...");
     // Spawn tasks to handle transmitting data between the WebTransport client and Mumble TCP Server
     tokio::spawn(
-        handle_client_to_server(stream.1, server_tcp.1)
+        handle_client_to_server(stream.1, write_server)
             .instrument(info_span!("Handler", "Client to server")),
     );
     tokio::spawn(
-        handle_server_to_client(stream.0, server_tcp.0)
+        handle_server_to_client(stream.0, read_server)
             .instrument(info_span!("Handler", "Server to client")),
     );
 
@@ -96,7 +173,7 @@ async fn handle_connection_impl(incoming_session: IncomingSession, id: usize) ->
 
 async fn handle_client_to_server(
     client_stream: wtransport::RecvStream,
-    server_stream: OwnedWriteHalf,
+    server_stream: impl AsyncWrite,
 ) {
     let result = client_to_server_loop(client_stream, server_stream).await;
     error!("{:?}", result);
@@ -104,9 +181,10 @@ async fn handle_client_to_server(
 
 async fn client_to_server_loop(
     mut client_stream: wtransport::RecvStream,
-    server_stream: OwnedWriteHalf,
+    server_stream: impl AsyncWrite,
 ) -> Result<()> {
     let mut buffer = vec![0; 65536].into_boxed_slice();
+    pin!(server_stream);
     loop {
         info!("Reading Data");
         let bytes_read = match client_stream.read(&mut buffer).await? {
@@ -120,7 +198,7 @@ async fn client_to_server_loop(
 
 async fn handle_server_to_client(
     client_stream: wtransport::SendStream,
-    server_stream: OwnedReadHalf,
+    server_stream: impl AsyncRead,
 ) {
     let result = server_to_client_loop(client_stream, server_stream).await;
     error!("{:?}", result);
@@ -128,11 +206,14 @@ async fn handle_server_to_client(
 
 async fn server_to_client_loop(
     mut client_stream: wtransport::SendStream,
-    mut server_stream: OwnedReadHalf,
+    server_stream: impl AsyncRead,
 ) -> Result<()> {
     let mut buffer = vec![0; 65536].into_boxed_slice();
+    pin!(server_stream);
     loop {
+        info!("Reading Data from server");
         let bytes_read = server_stream.read(&mut buffer).await?;
+        info!("Writing data to client");
         client_stream.write_all(&buffer[..bytes_read]).await?;
     }
 }