refactor

rnex-core/src/executables/backend_server_insecure.rs

@@ -0,0 +1,91 @@
+use rnex_core::reggie::{RemoteEdgeNodeHolder, UnitPacketRead};
+use log::{error, info};
+use once_cell::sync::Lazy;
+use rustls::client::danger::HandshakeSignatureValid;
+use rustls::pki_types::{CertificateDer, TrustAnchor, UnixTime};
+use rustls::server::danger::{ClientCertVerified, ClientCertVerifier};
+use rustls::server::{ClientCertVerifierBuilder, WebPkiClientVerifier};
+use rustls::{
+    DigitallySignedStruct, DistinguishedName, Error, RootCertStore, ServerConfig, ServerConnection,
+    SignatureScheme,
+};
+use rustls_pki_types::PrivateKeyDer;
+use rnex_core::common::setup;
+use std::borrow::ToOwned;
+use std::{env, fs};
+use std::io::Cursor;
+use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
+use std::sync::Arc;
+use macros::{method_id, rmc_proto, rmc_struct};
+use tokio::io::AsyncReadExt;
+use tokio::net::{TcpListener, TcpSocket, TcpStream};
+use tokio::task;
+use tokio_rustls::TlsAcceptor;
+use rnex_core::define_rmc_proto;
+use rnex_core::executables::common::{OWN_IP_PRIVATE, SECURE_SERVER_ACCOUNT, SERVER_PORT};
+use rnex_core::nex::auth_handler::AuthHandler;
+use rnex_core::reggie::EdgeNodeHolderConnectOption::DontRegister;
+use rnex_core::rmc::protocols::{new_rmc_gateway_connection, OnlyRemote};
+use rnex_core::rmc::response::ErrorCode;
+use rnex_core::rmc::structures::RmcSerialize;
+use rnex_core::rnex_proxy_common::ConnectionInitData;
+use rnex_core::util::SplittableBufferConnection;
+
+
+pub static FORWARD_EDGE_NODE_HOLDER: Lazy<SocketAddrV4> = Lazy::new(||{
+    env::var("FORWARD_EDGE_NODE_HOLDER")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .expect("SECURE_EDGE_NODE_HOLDER not set")
+});
+
+
+
+#[tokio::main]
+async fn main() {
+    setup();
+
+    let conn = TcpStream::connect(&*FORWARD_EDGE_NODE_HOLDER).await.unwrap();
+
+    let conn: SplittableBufferConnection = conn.into();
+
+    conn.send(DontRegister.to_data()).await;
+
+    let conn = new_rmc_gateway_connection(conn, |r| Arc::new(OnlyRemote::<RemoteEdgeNodeHolder>::new(r)));
+
+    let listen = TcpListener::bind(SocketAddrV4::new(*OWN_IP_PRIVATE, *SERVER_PORT)).await.unwrap();
+
+
+
+    while let Ok((mut stream, addr)) = listen.accept().await {
+        let buffer = match stream.read_buffer().await{
+            Ok(v) => v,
+            Err(e) => {
+                error!("an error ocurred whilest reading connection data buffer: {:?}", e);
+                continue;
+            }
+        };
+
+        let user_connection_data = ConnectionInitData::deserialize(&mut Cursor::new(buffer));
+
+        let user_connection_data = match user_connection_data{
+            Ok(v) => v,
+            Err(e) => {
+                error!("an error ocurred whilest reading connection data: {:?}", e);
+                continue;
+            }
+        };
+        let controller = conn.clone();
+        task::spawn(async move {
+            info!("connection to secure backend established");
+            new_rmc_gateway_connection(stream.into(), |_| {
+                Arc::new(AuthHandler {
+                    destination_server_acct: &SECURE_SERVER_ACCOUNT,
+                    build_name: "branch:origin/project/wup-agmj build:3_8_15_2004_0",
+                    control_server: controller
+                })
+            });
+        });
+
+    }
+}

rnex-core/src/executables/backend_server_secure.rs

@@ -0,0 +1,74 @@
+use std::io::Cursor;
+use rnex_core::rmc::structures::RmcSerialize;
+use rnex_core::reggie::{RemoteEdgeNodeHolder, UnitPacketRead};
+use std::net::SocketAddrV4;
+use std::sync::Arc;
+use std::sync::atomic::AtomicU32;
+use log::{error, info};
+use tokio::net::{TcpListener, TcpStream};
+use tokio::task;
+use rnex_core::common::setup;
+use rnex_core::executables::common::{OWN_IP_PRIVATE, SERVER_PORT};
+use rnex_core::nex::matchmake::MatchmakeManager;
+use rnex_core::nex::remote_console::RemoteConsole;
+use rnex_core::nex::user::User;
+use rnex_core::reggie::EdgeNodeHolderConnectOption::DontRegister;
+use rnex_core::rmc::protocols::{new_rmc_gateway_connection, OnlyRemote};
+use rnex_core::rnex_proxy_common::ConnectionInitData;
+use rnex_core::rmc::protocols::RemoteInstantiatable;
+use rnex_core::util::SplittableBufferConnection;
+
+#[tokio::main]
+async fn main() {
+    setup();
+
+    let listen = TcpListener::bind(SocketAddrV4::new(*OWN_IP_PRIVATE, *SERVER_PORT)).await.unwrap();
+
+    let mmm = Arc::new(MatchmakeManager{
+        gid_counter: AtomicU32::new(1),
+        sessions: Default::default(),
+        users: Default::default(),
+        rv_cid_counter: AtomicU32::new(1),
+    });
+
+    let weak_mmm = Arc::downgrade(&mmm);
+
+    MatchmakeManager::initialize_garbage_collect_thread(weak_mmm).await;
+
+    while let Ok((mut stream, addr)) = listen.accept().await {
+        let buffer = match stream.read_buffer().await{
+            Ok(v) => v,
+            Err(e) => {
+                error!("an error ocurred whilest reading connection data buffer: {:?}", e);
+                continue;
+            }
+        };
+
+        let user_connection_data = ConnectionInitData::deserialize(&mut Cursor::new(buffer));
+
+        let user_connection_data = match user_connection_data{
+            Ok(v) => v,
+            Err(e) => {
+                error!("an error ocurred whilest reading connection data: {:?}", e);
+                continue;
+            }
+        };
+
+
+        let mmm = mmm.clone();
+        task::spawn(async move {
+            info!("connection to secure backend established");
+            new_rmc_gateway_connection(stream.into(), |r| {
+                Arc::new_cyclic(|this| User{
+                    this: this.clone(),
+                    ip: user_connection_data.prudpsock_addr,
+                    pid: user_connection_data.pid,
+                    remote: RemoteConsole::new(r),
+                    matchmake_manager: mmm,
+                    station_url: Default::default()
+                })
+            });
+        });
+
+    }
+}

rnex-core/src/executables/common.rs

@@ -0,0 +1,44 @@
+use std::env;
+use std::net::{Ipv4Addr, SocketAddrV4};
+use macros::{method_id, rmc_proto, RmcSerialize};
+use once_cell::sync::Lazy;
+use tonic::transport::Server;
+use crate::define_rmc_proto;
+use crate::prudp::station_url::StationUrl;
+use crate::nex::account::Account;
+use crate::rmc::response::ErrorCode;
+
+pub static OWN_IP_PRIVATE: Lazy<Ipv4Addr> = Lazy::new(|| {
+    env::var("SERVER_IP")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .expect("SERVER_IP not specified")
+});
+
+pub static OWN_IP_PUBLIC: Lazy<Ipv4Addr> = Lazy::new(|| {
+    env::var("SERVER_IP_PUBLIC")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .expect("SERVER_IP_PUBLIC not specified")
+});
+
+pub static SERVER_PORT: Lazy<u16> = Lazy::new(|| {
+    env::var("SERVER_PORT")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(10000)
+});
+
+pub static KERBEROS_SERVER_PASSWORD: Lazy<String> = Lazy::new(|| {
+    env::var("AUTH_SERVER_PASSWORD")
+        .ok()
+        .unwrap_or("password".to_owned())
+});
+
+pub static AUTH_SERVER_ACCOUNT: Lazy<Account> =
+    Lazy::new(|| Account::new(1, "Quazal Authentication", &KERBEROS_SERVER_PASSWORD));
+pub static SECURE_SERVER_ACCOUNT: Lazy<Account> =
+    Lazy::new(|| Account::new(2, "Quazal Rendez-Vous", &KERBEROS_SERVER_PASSWORD));
+
+
+

rnex-core/src/executables/edge_node_holder_server.rs

@@ -0,0 +1,92 @@
+use std::io::Cursor;
+use std::net::SocketAddrV4;
+use std::sync::{Arc, Weak};
+use log::error;
+use macros::rmc_struct;
+use tokio::net::TcpListener;
+use tokio::sync::RwLock;
+use rnex_core::common::setup;
+use rnex_core::executables::common::{OWN_IP_PRIVATE, SERVER_PORT};
+use rnex_core::reggie::{EdgeNodeHolderConnectOption, EdgeNodeManagement, LocalEdgeNodeHolder};
+use rnex_core::rmc::protocols::new_rmc_gateway_connection;
+use rnex_core::rmc::response::ErrorCode;
+use rnex_core::util::SplittableBufferConnection;
+use rnex_core::rmc::structures::RmcSerialize;
+
+#[rmc_struct(EdgeNodeHolder)]
+struct EdgeNode{
+    data_holder: Arc<DataHolder>,
+    address: SocketAddrV4
+}
+
+impl EdgeNodeManagement for EdgeNode{
+    async fn get_url(&self, seed: u64) -> Result<SocketAddrV4, ErrorCode> {
+        self.data_holder.get_url(seed).await
+    }
+}
+
+#[rmc_struct(EdgeNodeHolder)]
+#[derive(Default)]
+struct DataHolder{
+    edge_nodes: RwLock<Vec<Weak<EdgeNode>>>
+}
+
+impl EdgeNodeManagement for DataHolder{
+    async fn get_url(&self, seed: u64) -> Result<SocketAddrV4, ErrorCode> {
+        let nodes = self.edge_nodes.read().await;
+
+        let nodes: Vec<_> = nodes.iter().filter_map(|n| n.upgrade()).collect();
+
+        // avoid a devide by zero
+        if nodes.len() == 0{
+            return Err(ErrorCode::Core_InvalidIndex);
+        };
+
+        let node = &nodes[seed as usize % nodes.len()];
+
+        Ok(node.address)
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    setup();
+
+    let listen = TcpListener::bind(SocketAddrV4::new(*OWN_IP_PRIVATE, *SERVER_PORT)).await.unwrap();
+
+    let holder: Arc<DataHolder> = Default::default();
+
+    while let Ok((mut stream, addr)) = listen.accept().await {
+        let mut conn: SplittableBufferConnection = stream.into();
+
+        let Some(data) = conn.recv().await else {
+            continue;
+        };
+
+        let Ok(data) = EdgeNodeHolderConnectOption::deserialize(&mut Cursor::new(data)) else {
+            continue;
+        };
+
+        let holder = holder.clone();
+
+        match data{
+            EdgeNodeHolderConnectOption::DontRegister => {
+
+                new_rmc_gateway_connection(conn, |_| holder);
+            },
+            EdgeNodeHolderConnectOption::Register(address) => {
+                let edge_node = EdgeNode{
+                    address,
+                    data_holder: holder.clone()
+                };
+
+                let node = new_rmc_gateway_connection(conn, move |_| Arc::new(edge_node));
+
+                let mut nodes = holder.edge_nodes.write().await;
+                nodes.push(Arc::downgrade(&node));
+            }
+        }
+
+
+    }
+}

rnex-core/src/executables/mod.rs

@@ -0,0 +1 @@
+pub mod common;