spacebar/rust-nex
6
0
Fork 0
Code Issues Pull requests Projects Releases Packages 50 Wiki Activity Actions

clean up a bit

Browse source
This commit is contained in:
Maple Nebel 2025-11-08 13:00:23 +00:00
commit 6ea1518a9d
5 changed files with 65 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

4
prudpv1/src/prudp/socket.rs
View file

@ -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;

55
rnex-core/src/executables/backend_server_insecure.rs
View file

@ -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;
}

57
rnex-core/src/executables/backend_server_secure.rs
View file

@ -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;
}

42
rnex-core/src/executables/common.rs
View file

@ -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)
});
}
}

4
rnex-core/src/rmc/protocols/ranking.rs
View file

@ -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{