feat: client context, udp tunnel

Author: jacobtread

Cargo.toml

@@ -9,6 +9,9 @@ license = "MIT"
 repository = "https://github.com/PocketRelay/PocketArkClientShared"
 
 [dependencies]
+# Shared UDP tunnel protocol
+pocket-relay-udp-tunnel = { version = "0" }
+
 # Logging
 log = "0.4"
 

cspell.json

@@ -0,0 +1,12 @@
+{
+  "userWords": [
+    "reqwest",
+    "serverinstanceinfo",
+    "valu",
+    "trialservicename",
+    "defaultdnsaddress",
+    "redirector",
+    "gosredirector",
+    "seqno"
+  ]
+}

src/api.rs

@@ -92,6 +92,8 @@ struct ServerDetails {
     ident: Option<String>,
     /// Association token if the server supports providing one
     association: Option<String>,
+    /// Tunnel port if the server provides one
+    tunnel_port: Option<u16>,
 }
 
 /// Data from completing a lookup contains the resolved address
@@ -100,11 +102,13 @@ struct ServerDetails {
 #[derive(Debug, Clone)]
 pub struct LookupData {
     /// Server url
-    pub url: Arc<Url>,
+    pub url: Url,
     /// The server version
     pub version: Version,
     /// Association token if the server supports providing one
-    pub association: Arc<Option<String>>,
+    pub association: Option<String>,
+    /// Tunnel port if the server provides one
+    pub tunnel_port: Option<u16>,
 }
 
 /// Errors that can occur while looking up a server
@@ -223,9 +227,10 @@ pub async fn lookup_server(
     }
 
     Ok(LookupData {
-        url: Arc::new(url),
+        url,
         version: details.version,
-        association: Arc::new(details.association),
+        association: details.association,
+        tunnel_port: details.tunnel_port,
     })
 }
 
@@ -476,11 +481,11 @@ pub async fn proxy_http_request(
 /// ## Arguments
 /// * `http_client` - The HTTP client to connect with
 /// * `base_url`    - The server base URL (Connection URL)
-/// * `association` - Optional association token
+/// * `association` - Association token
 pub async fn create_server_tunnel(
-    http_client: reqwest::Client,
+    http_client: &reqwest::Client,
     base_url: &Url,
-    association: Option<&String>,
+    association: &str,
 ) -> Result<Upgraded, ServerStreamError> {
     // Create the upgrade endpoint URL
     let endpoint_url: Url = base_url
@@ -496,12 +501,10 @@ pub async fn create_server_tunnel(
     .collect();
 
     // Include association token
-    if let Some(association) = association {
-        headers.insert(
-            HeaderName::from_static(headers::ASSOCIATION),
-            HeaderValue::from_str(association).expect("Invalid association token"),
-        );
-    }
+    headers.insert(
+        HeaderName::from_static(headers::ASSOCIATION),
+        HeaderValue::from_str(association).expect("Invalid association token"),
+    );
 
     // Send the HTTP request and get its response
     let response = http_client

src/ctx.rs

@@ -0,0 +1,20 @@
+//! Shared context state that the app should store and pass to the
+//! various servers when they are started
+
+use url::Url;
+
+use crate::api::AuthToken;
+
+/// Shared context
+pub struct ClientContext {
+    /// HTTP client for the client to make requests with
+    pub http_client: reqwest::Client,
+    /// Base URL of the connected server
+    pub base_url: Url,
+    /// Optional association token
+    pub association: Option<String>,
+    /// Optional tunnel port for tunnel V2 if available
+    pub tunnel_port: Option<u16>,
+    /// Authentication token
+    pub token: AuthToken,
+}

src/lib.rs

@@ -14,6 +14,7 @@ pub use semver::Version;
 pub use url::Url;
 
 pub mod api;
+pub mod ctx;
 pub mod servers;
 pub mod ssl;
 pub mod update;

src/servers/blaze.rs

@@ -1,72 +1,53 @@
 //! Server connected to by BlazeSDK clients (Majority of the game traffic)
 
 use super::{spawn_server_task, BLAZE_PORT};
-use crate::api::{create_server_stream, AuthToken};
+use crate::{api::create_server_stream, ctx::ClientContext};
 use log::{debug, error};
 use std::{net::Ipv4Addr, sync::Arc};
 use tokio::{
     io::copy_bidirectional,
     net::{TcpListener, TcpStream},
 };
-use url::Url;
 
 /// Starts the blaze server
 ///
 /// ## Arguments
-/// * `http_client` - The HTTP client passed around for connection upgrades
-/// * `base_url`    - The server base URL to connect clients to
-/// * `association` - Optional client association
-pub async fn start_blaze_server(
-    http_client: reqwest::Client,
-    base_url: Arc<Url>,
-    association: Arc<Option<String>>,
-    token: AuthToken,
-) -> std::io::Result<()> {
+/// * `ctx` - The client context
+pub async fn start_blaze_server(ctx: Arc<ClientContext>) -> std::io::Result<()> {
     // Bind the local socket for accepting connections
     let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, BLAZE_PORT)).await?;
 
     // Accept connections
     loop {
         let (client_stream, _) = listener.accept().await?;
 
-        spawn_server_task(handle(
-            client_stream,
-            http_client.clone(),
-            base_url.clone(),
-            association.clone(),
-            token.clone(),
-        ));
+        spawn_server_task(handle(client_stream, ctx.clone()));
     }
 }
 
 /// Handler for processing BlazeSDK client connections
 ///
 /// ## Arguments
 /// * `client_stream` - The client stream to read and write from
-/// * `http_client`   - The HTTP client passed around for connection upgrades
-/// * `base_url`      - The server base URL to connect clients to
-/// * `association`   - Client association token if supported
-/// * `token`         - Client authentication token
-async fn handle(
-    mut client_stream: TcpStream,
-    http_client: reqwest::Client,
-    base_url: Arc<Url>,
-    association: Arc<Option<String>>,
-    token: AuthToken,
-) {
+/// * `ctx`           - The client context
+async fn handle(mut client_stream: TcpStream, ctx: Arc<ClientContext>) {
     debug!("Starting blaze connection");
 
     // Create a stream to the Pocket Relay server
-    let mut server_stream =
-        match create_server_stream(http_client, &base_url, Option::as_ref(&association), token)
-            .await
-        {
-            Ok(stream) => stream,
-            Err(err) => {
-                error!("Failed to create server stream: {}", err);
-                return;
-            }
-        };
+    let mut server_stream = match create_server_stream(
+        ctx.http_client.clone(),
+        &ctx.base_url,
+        Option::as_ref(&ctx.association),
+        ctx.token.clone(),
+    )
+    .await
+    {
+        Ok(stream) => stream,
+        Err(err) => {
+            error!("Failed to create server stream: {}", err);
+            return;
+        }
+    };
 
     debug!("Blaze connection linked");
 

src/servers/http.rs

@@ -3,7 +3,10 @@
 //! is only capable of communicating over SSLv3
 
 use super::{spawn_server_task, HTTP_PORT};
-use crate::api::{headers::X_TOKEN, proxy_http_request, AuthToken};
+use crate::{
+    api::{headers::X_TOKEN, proxy_http_request},
+    ctx::ClientContext,
+};
 use anyhow::Context;
 use hyper::{
     body::HttpBody, header::HeaderValue, http::uri::PathAndQuery, server::conn::Http,
@@ -14,7 +17,6 @@ use openssl::ssl::{Ssl, SslContext};
 use std::{convert::Infallible, net::Ipv4Addr, pin::Pin, sync::Arc};
 use tokio::net::{TcpListener, TcpStream};
 use tokio_openssl::SslStream;
-use url::Url;
 
 /// Starts the HTTP proxy server
 ///
@@ -24,29 +26,23 @@ use url::Url;
 /// * `context`     - The SSL context to use when accepting clients
 /// * `token`       - The authentication token
 pub async fn start_http_server(
-    http_client: reqwest::Client,
-    base_url: Arc<Url>,
+    ctx: Arc<ClientContext>,
     ssl_context: SslContext,
-    token: AuthToken,
-) -> anyhow::Result<()> {
+) -> std::io::Result<()> {
     // Bind the local tcp socket for accepting connections
-    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, HTTP_PORT))
-        .await
-        .context("Failed to bind listener")?;
+    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, HTTP_PORT)).await?;
 
     // Accept connections
     loop {
         let (stream, _) = listener.accept().await?;
 
-        let ssl = Ssl::new(&ssl_context).context("Failed to get ssl instance")?;
-        let stream = SslStream::new(ssl, stream).context("Failed to create ssl stream")?;
+        let ssl = Ssl::new(&ssl_context).map_err(std::io::Error::other)?;
+        let stream = SslStream::new(ssl, stream).map_err(std::io::Error::other)?;
 
-        let http_client = http_client.clone();
-        let base_url = base_url.clone();
-        let token = token.clone();
+        let ctx = ctx.clone();
 
         spawn_server_task(async move {
-            if let Err(err) = serve_connection(stream, http_client, base_url, token).await {
+            if let Err(err) = serve_connection(stream, ctx).await {
                 error!("Error while redirecting: {}", err);
             }
         });
@@ -57,23 +53,14 @@ pub async fn start_http_server(
 /// completes the accept stream process
 pub async fn serve_connection(
     mut stream: SslStream<TcpStream>,
-    http_client: reqwest::Client,
-    base_url: Arc<Url>,
-    token: AuthToken,
+    ctx: Arc<ClientContext>,
 ) -> anyhow::Result<()> {
     Pin::new(&mut stream).accept().await?;
 
     Http::new()
         .serve_connection(
             stream,
-            service_fn(move |request| {
-                handle(
-                    request,
-                    http_client.clone(),
-                    base_url.clone(),
-                    token.clone(),
-                )
-            }),
+            service_fn(move |request| handle(request, ctx.clone())),
         )
         .await
         .context("Serve error")?;
@@ -90,9 +77,7 @@ pub async fn serve_connection(
 /// * `base_url`    - The server base URL (Connection URL)
 async fn handle(
     mut request: Request<Body>,
-    http_client: reqwest::Client,
-    base_url: Arc<Url>,
-    token: AuthToken,
+    ctx: Arc<ClientContext>,
 ) -> Result<Response<Body>, Infallible> {
     let path_and_query = request
         .uri()
@@ -107,7 +92,7 @@ async fn handle(
     let path_and_query = path_and_query.strip_prefix('/').unwrap_or(path_and_query);
 
     // Create the new url from the path
-    let url = match base_url.join(path_and_query) {
+    let url = match ctx.base_url.join(path_and_query) {
         Ok(value) => value,
         Err(err) => {
             error!("Failed to create HTTP proxy URL: {}", err);
@@ -134,11 +119,11 @@ async fn handle(
     let mut headers = request.headers().clone();
     headers.insert(
         X_TOKEN,
-        HeaderValue::from_str(&token).expect("Invalid token"),
+        HeaderValue::from_str(&ctx.token).expect("Invalid token"),
     );
 
     // Proxy the request to the server
-    let response = match proxy_http_request(&http_client, url, method, body, headers).await {
+    let response = match proxy_http_request(&ctx.http_client, url, method, body, headers).await {
         Ok(value) => value,
         Err(err) => {
             error!("Failed to proxy HTTP request: {}", err);

src/servers/mod.rs

@@ -9,6 +9,7 @@ pub mod http;
 pub mod qos;
 pub mod redirector;
 pub mod tunnel;
+pub mod udp_tunnel;
 
 /// The port the Redirector server will bind to
 pub const REDIRECTOR_PORT: u16 = 42230;
@@ -18,7 +19,6 @@ pub const BLAZE_PORT: u16 = 42128;
 pub const QOS_PORT: u16 = 42130;
 /// The port the HTTP server will bind to
 pub const HTTP_PORT: u16 = 443;
-
 /// The port used for the host socket
 pub const TUNNEL_HOST_PORT: u16 = 42132;
 /// Port that the OS may choose

src/servers/redirector.rs

@@ -20,18 +20,16 @@ use tokio_openssl::SslStream;
 ///
 /// ## Arguments
 /// * `context` - The SSL context to use when accepting clients
-pub async fn start_redirector_server(ssl_context: SslContext) -> anyhow::Result<()> {
+pub async fn start_redirector_server(ssl_context: SslContext) -> std::io::Result<()> {
     // Bind the local tcp socket for accepting connections
-    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, REDIRECTOR_PORT))
-        .await
-        .context("Failed to bind listener")?;
+    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, REDIRECTOR_PORT)).await?;
 
     // Accept connections
     loop {
         let (stream, _) = listener.accept().await?;
 
-        let ssl = Ssl::new(&ssl_context).context("Failed to get ssl instance")?;
-        let stream = SslStream::new(ssl, stream).context("Failed to create ssl stream")?;
+        let ssl = Ssl::new(&ssl_context).map_err(std::io::Error::other)?;
+        let stream = SslStream::new(ssl, stream).map_err(std::io::Error::other)?;
 
         spawn_server_task(async move {
             if let Err(err) = serve_connection(stream).await {