clean up a bit

prudpv1/src/prudp/socket.rs

@@ -4,16 +4,14 @@ use crate::prudp::packet::PacketOption::{
     ConnectionSignature, FragmentId, MaximumSubstreamId, SupportedFunctions,
 };
 use crate::prudp::packet::{PRUDPV1Header, PRUDPV1Packet, TypesFlags};
-use md5::digest::generic_array::sequence;
 use rnex_core::prudp::virtual_port::VirtualPort;
 use rnex_core::prudp::socket_addr::PRUDPSockAddr;
 use async_trait::async_trait;
 use log::info;
 use log::error;
 use rc4::StreamCipher;
-use rnex_core::rmc::structures::qbuffer::QBuffer;
 use v_byte_helpers::ReadExtensions;
-use v_byte_helpers::little_endian::{read_u16, read_u32};
+use v_byte_helpers::little_endian::read_u16;
 use std::collections::{BTreeMap, HashMap};
 use std::io::Cursor;
 use std::marker::PhantomData;

rnex-core/src/executables/backend_server_insecure.rs

@@ -1,19 +1,15 @@
-use rnex_core::reggie::{RemoteEdgeNodeHolder, UnitPacketRead};
-use log::{error, info};
+use rnex_core::reggie::RemoteEdgeNodeHolder;
 use once_cell::sync::Lazy;
 use rnex_core::common::setup;
-use std::{env};
-use std::io::Cursor;
+use rnex_core::rmc::structures::RmcSerialize;
+use std::env;
 use std::net::SocketAddrV4;
 use std::sync::Arc;
-use tokio::net::{TcpListener, TcpStream};
-use tokio::task;
-use rnex_core::executables::common::{OWN_IP_PRIVATE, SECURE_SERVER_ACCOUNT, SERVER_PORT};
+use tokio::net::TcpStream;
+use rnex_core::executables::common::{SECURE_SERVER_ACCOUNT, new_simple_backend};
 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::structures::RmcSerialize;
-use rnex_core::rnex_proxy_common::ConnectionInitData;
 use rnex_core::util::SplittableBufferConnection;
 
 
@@ -38,39 +34,12 @@ async fn main() {
 
     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;
-            }
-        };
+    new_simple_backend(move |_, _|{
         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
-                })
-            });
-        });
-
-    }
+        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
+        })
+    }).await;
 }

rnex-core/src/executables/backend_server_secure.rs

@@ -1,26 +1,16 @@
-use std::io::Cursor;
-use rnex_core::rmc::structures::RmcSerialize;
-use rnex_core::reggie::UnitPacketRead;
-use std::net::SocketAddrV4;
 use std::sync::Arc;
 use std::sync::atomic::AtomicU32;
-use log::{error, info};
-use tokio::net::TcpListener;
-use tokio::task;
 use rnex_core::common::setup;
-use rnex_core::executables::common::{OWN_IP_PRIVATE, SERVER_PORT};
+use rnex_core::executables::common::{new_simple_backend};
 use rnex_core::nex::matchmake::MatchmakeManager;
 use rnex_core::nex::remote_console::RemoteConsole;
 use rnex_core::nex::user::User;
-use rnex_core::rmc::protocols::new_rmc_gateway_connection;
-use rnex_core::rnex_proxy_common::ConnectionInitData;
 use rnex_core::rmc::protocols::RemoteInstantiatable;
 
 #[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),
@@ -33,40 +23,15 @@ async fn main() {
 
     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;
-            }
-        };
-
-
+    new_simple_backend(move |c, r|{
         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()
-                })
-            });
-        });
-
-    }
+        Arc::new_cyclic(move |this| User{
+            this: this.clone(),
+            ip: c.prudpsock_addr,
+            pid:c.pid,
+            remote: RemoteConsole::new(r),
+            matchmake_manager: mmm,
+            station_url: Default::default()
+        })
+    }).await;
 }

rnex-core/src/executables/common.rs

@@ -1,8 +1,18 @@
 use std::env;
-use std::net::Ipv4Addr;
+use std::io::Cursor;
+use std::net::{Ipv4Addr, SocketAddrV4};
+use std::sync::Arc;
 use once_cell::sync::Lazy;
-use crate::nex::account::Account;
+use rnex_core::nex::account::Account;
+use rnex_core::rmc::protocols::{RmcCallable, RmcConnection, new_rmc_gateway_connection};
+use rnex_core::rnex_proxy_common::ConnectionInitData;
+use rnex_core::rmc::structures::RmcSerialize;
+use tokio::net::TcpListener;
+
 use std::error::Error;
+use log::error;
+
+use crate::reggie::UnitPacketRead;
 
 const IP_REQ_SERVICE_URL: &str = "https://ipinfo.io/ip";
 
@@ -48,4 +58,32 @@ pub static SECURE_SERVER_ACCOUNT: Lazy<Account> =
     Lazy::new(|| Account::new(2, "Quazal Rendez-Vous", &KERBEROS_SERVER_PASSWORD));
 
 
+pub async fn new_simple_backend<T: RmcCallable + Sync + Send + 'static,F>(mut creation_function: F)
+where
+    F: FnMut(ConnectionInitData, RmcConnection) -> Arc<T>,
+{
+    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 fun_ref = &mut creation_function;
+        new_rmc_gateway_connection(stream.into(), move |r|{
+            fun_ref(user_connection_data, r)
+        });
+    }
+}

rnex-core/src/rmc/protocols/ranking.rs

@@ -1,6 +1,4 @@
-use macros::rmc_proto;
-use crate::rmc::response::ErrorCode;
-use macros::{method_id, rmc_struct, RmcSerialize};
+use macros::{rmc_struct, rmc_proto, RmcSerialize};
 
 #[derive(RmcSerialize, Debug, Default, Clone)]
 struct ResultsRange{