refactor

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

@@ -0,0 +1,47 @@
+use rnex_core::rmc::response::ErrorCode;
+use rnex_core::rmc::structures::any::Any;
+use crate::rmc::structures::connection_data::ConnectionData;
+use rnex_core::rmc::structures::qresult::QResult;
+use macros::{method_id, rmc_proto};
+
+
+/// This is the representation for `Ticket Granting`(for details see the 
+/// [kinnay wiki entry](https://github.com/kinnay/NintendoClients/wiki/Authentication-Protocol))
+#[rmc_proto(10)]
+pub trait Auth {
+    /// representation of the `Login` method(for details see the
+    /// [kinnay wiki entry](https://github.com/kinnay/NintendoClients/wiki/Authentication-Protocol))
+    #[method_id(1)]
+    async fn login(&self, name: String) -> Result<(), ErrorCode>;
+
+    /// representation of the `LoginEx` method(for details see the
+    /// [kinnay wiki entry](https://github.com/kinnay/NintendoClients/wiki/Authentication-Protocol))
+    #[method_id(2)]
+    async fn login_ex(
+        &self,
+        name: String,
+        extra_data: Any,
+    ) -> Result<(QResult, u32, Vec<u8>, ConnectionData, String), ErrorCode>;
+
+    /// representation of the `RequestTicket` method(for details see the
+    /// [kinnay wiki entry](https://github.com/kinnay/NintendoClients/wiki/Authentication-Protocol))
+    #[method_id(3)]
+    async fn request_ticket(
+        &self,
+        source_pid: u32,
+        destination_pid: u32,
+    ) -> Result<(QResult, Vec<u8>), ErrorCode>;
+
+    /// representation of the `GetPID` method(for details see the
+    /// [kinnay wiki entry](https://github.com/kinnay/NintendoClients/wiki/Authentication-Protocol))
+    #[method_id(4)]
+    async fn get_pid(&self, username: String) -> Result<u32, ErrorCode>;
+
+    /// representation of the `LoginWithContext` method(for details see the
+    /// [kinnay wiki entry](https://github.com/kinnay/NintendoClients/wiki/Authentication-Protocol))
+    #[method_id(5)]
+    async fn get_name(&self, pid: u32) -> Result<String, ErrorCode>;
+
+    // `LoginWithContext` is left out here because we don't need it right now and versioning still
+    // needs to be figured out
+}

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

@@ -0,0 +1,17 @@
+use macros::{method_id, rmc_proto};
+use rnex_core::prudp::station_url::StationUrl;
+use rnex_core::rmc::response::ErrorCode;
+
+#[rmc_proto(21)]
+pub trait Matchmake{
+    #[method_id(2)]
+    async fn unregister_gathering(&self, gid: u32) -> Result<bool, ErrorCode>;
+    #[method_id(41)]
+    async fn get_session_urls(&self, gid: u32) -> Result<Vec<StationUrl>, ErrorCode>;
+
+    #[method_id(42)]
+    async fn update_session_host(&self, gid: u32, change_owner: bool) -> Result<(), ErrorCode>;
+
+    #[method_id(44)]
+    async fn migrate_gathering_ownership(&self, gid: u32, candidates: Vec<u32>, participants_only: bool) -> Result<(), ErrorCode>;
+}

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

@@ -0,0 +1,8 @@
+use macros::{method_id, rmc_proto};
+use rnex_core::rmc::response::ErrorCode;
+
+#[rmc_proto(50)]
+pub trait MatchmakeExt{
+    #[method_id(1)]
+    async fn end_participation(&self, gid: u32, message: String) -> Result<bool, ErrorCode>;
+}

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

@@ -0,0 +1,32 @@
+use macros::{method_id, rmc_proto};
+use rnex_core::rmc::response::ErrorCode;
+use rnex_core::rmc::structures::matchmake::{AutoMatchmakeParam, CreateMatchmakeSessionParam, JoinMatchmakeSessionParam, MatchmakeSession};
+
+#[rmc_proto(109)]
+pub trait MatchmakeExtension{
+    #[method_id(1)]
+    async fn close_participation(&self, gid: u32) -> Result<(), ErrorCode>;
+
+    #[method_id(2)]
+    async fn open_participation(&self, gid: u32) -> Result<(), ErrorCode>;
+
+    #[method_id(8)]
+    async fn modify_current_game_attribute(&self, gid: u32, attrib_index: u32, attrib_val: u32) -> Result<(), ErrorCode>;
+
+    #[method_id(16)]
+    async fn get_playing_session(&self, pids: Vec<u32>) -> Result<Vec<()>, ErrorCode>;
+
+    #[method_id(34)]
+    async fn update_progress_score(&self, gid: u32, progress: u8) -> Result<(), ErrorCode>;
+    #[method_id(38)]
+    async fn create_matchmake_session_with_param(&self, session: CreateMatchmakeSessionParam) -> Result<MatchmakeSession, ErrorCode>;
+
+    #[method_id(39)]
+    async fn join_matchmake_session_with_param(&self, session: JoinMatchmakeSessionParam) -> Result<MatchmakeSession, ErrorCode>;
+
+    #[method_id(40)]
+    async fn auto_matchmake_with_param_postpone(&self, session: AutoMatchmakeParam) -> Result<MatchmakeSession, ErrorCode>;
+
+    #[method_id(41)]
+    async fn find_matchmake_session_by_gathering_id_detail(&self, gid: u32) -> Result<MatchmakeSession, ErrorCode>;
+}

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

@@ -0,0 +1,342 @@
+#![allow(async_fn_in_trait)]
+
+pub mod auth;
+pub mod secure;
+pub mod notifications;
+pub mod matchmake;
+pub mod matchmake_extension;
+pub mod nat_traversal;
+pub mod matchmake_ext;
+pub mod ranking;
+
+use crate::util::{SendingBufferConnection, SplittableBufferConnection};
+use crate::rmc::message::RMCMessage;
+use crate::rmc::protocols::RemoteCallError::ConnectionBroke;
+use crate::rmc::response::{ErrorCode, RMCResponse, RMCResponseResult};
+use crate::rmc::structures;
+use crate::rmc::structures::RmcSerialize;
+use log::{error, info};
+use std::collections::HashMap;
+use std::future::Future;
+use std::io::Cursor;
+use std::ops::Deref;
+use std::sync::Arc;
+use std::time::Duration;
+use thiserror::Error;
+use tokio::sync::{Mutex, Notify};
+use tokio::time::{sleep, sleep_until, Instant};
+use crate::result::ResultExtension;
+
+#[derive(Error, Debug)]
+pub enum RemoteCallError {
+    #[error("Call to remote timed out whilest waiting on response.")]
+    Timeout,
+    #[error("A server side rmc error occurred: {0:?}")]
+    ServerError(ErrorCode),
+    #[error("Connection broke")]
+    ConnectionBroke,
+    #[error("Error reading response data: {0}")]
+    InvalidResponse(#[from] structures::Error),
+}
+
+pub struct RmcConnection(pub SendingBufferConnection, pub RmcResponseReceiver);
+
+pub struct RmcResponseReceiver(Arc<Notify>, Arc<Mutex<HashMap<u32, RMCResponse>>>);
+
+impl RmcConnection {
+    pub async fn make_raw_call<T: RmcSerialize>(
+        &self,
+        message: &RMCMessage,
+    ) -> Result<T, RemoteCallError> {
+        self.make_raw_call_no_response(message).await?;
+
+        let data = self.1.get_response_data(message.call_id).await?;
+
+        let out = <T as RmcSerialize>::deserialize(&mut Cursor::new(data))?;
+
+        Ok(out)
+    }
+
+    pub async fn make_raw_call_no_response(
+        &self,
+        message: &RMCMessage,
+    ) -> Result<(), RemoteCallError> {
+        let message_data = message.to_data();
+
+        self.0.send(message_data).await.ok_or(ConnectionBroke)?;
+
+        Ok(())
+    }
+
+    pub async fn disconnect(&self){
+        self.0.disconnect().await;
+    }
+}
+
+impl RmcResponseReceiver {
+    // returns none if timed out
+    pub async fn get_response_data(&self, call_id: u32) -> Result<Vec<u8>, RemoteCallError> {
+        let mut end_wait_time = Instant::now();
+        end_wait_time += Duration::from_secs(5);
+
+        let sleep_fut = sleep_until(end_wait_time);
+        tokio::pin!(sleep_fut);
+
+        let mut sleep_manual_unlock_fut = Instant::now();
+        sleep_manual_unlock_fut += Duration::from_secs(4);
+
+        let sleep_manual_unlock_fut = sleep_until(sleep_manual_unlock_fut);
+        tokio::pin!(sleep_manual_unlock_fut);
+
+        loop {
+            let mut locked = self.1.lock().await;
+
+            if let Some(v) = locked.remove(&call_id) {
+                match v.response_result{
+                    RMCResponseResult::Success {
+                        data,
+                        ..
+                    } => return Ok(data),
+                    RMCResponseResult::Error {
+                        error_code,
+                        ..
+                    } => return Err(RemoteCallError::ServerError(error_code))
+                }
+            }
+
+            drop(locked);
+
+            let notif_fut = self.0.notified();
+
+            tokio::select! {
+                _ = &mut sleep_manual_unlock_fut => {
+                    continue;
+                }
+                _ = &mut sleep_fut => {
+                    return Err(RemoteCallError::Timeout);
+                }
+                _ = notif_fut => {
+                    continue;
+                }
+            }
+        }
+    }
+}
+
+pub trait HasRmcConnection {
+    fn get_connection(&self) -> &RmcConnection;
+}
+
+pub trait RemoteObject {
+    fn new(conn: RmcConnection) -> Self;
+}
+
+impl RemoteObject for () {
+    fn new(_: RmcConnection) -> Self {}
+}
+
+pub trait RmcCallable {
+    //type Remote: RemoteObject;
+    fn rmc_call(
+        &self,
+        responder: &SendingBufferConnection,
+        protocol_id: u16,
+        method_id: u32,
+        call_id: u32,
+        rest: Vec<u8>,
+    ) -> impl std::future::Future<Output = ()> + Send;
+}
+
+#[macro_export]
+macro_rules! define_rmc_proto {
+    (proto $name:ident{
+        $($protocol:path),*
+    }) => {
+        paste::paste!{
+            pub trait [<Local $name>]: std::any::Any $( + [<Raw $protocol>] + $protocol)* {
+                async fn rmc_call(&self, remote_response_connection: &rnex_core::util::SendingBufferConnection, protocol_id: u16, method_id: u32, call_id: u32, rest: Vec<u8>){
+                    match protocol_id{
+                        $(
+                            [<Raw $protocol Info>]::PROTOCOL_ID => <Self as [<Raw $protocol>]>::rmc_call_proto(self, remote_response_connection, method_id, call_id, rest).await,
+                        )*
+                        v => log::error!("invalid protocol called on rmc object {}", v)
+                    }
+                }
+            }
+
+            pub struct [<Remote $name>](rnex_core::rmc::protocols::RmcConnection);
+
+            impl rnex_core::rmc::protocols::RemoteInstantiatable for [<Remote $name>]{
+                fn new(conn: rnex_core::rmc::protocols::RmcConnection) -> Self{
+                    Self(conn)
+                }
+                async fn disconnect(&self){
+                    self.0.disconnect().await;
+                }
+            }
+
+            impl rnex_core::rmc::protocols::HasRmcConnection for [<Remote $name>]{
+                fn get_connection(&self) -> &rnex_core::rmc::protocols::RmcConnection{
+                    &self.0
+                }
+            }
+
+            $(
+            impl [<Remote $protocol>] for [<Remote $name>]{}
+            )*
+        }
+    };
+}
+
+/// This is a special case to allow unit to represent the fact that no object is represented.
+impl RmcCallable for () {
+    async fn rmc_call(
+        &self,
+        _remote_response_connection: &SendingBufferConnection,
+        _protocol_id: u16,
+        _method_id: u32,
+        _call_id: u32,
+        _rest: Vec<u8>,
+    ) {
+        //todo: maybe reply with not implemented(?)
+    }
+}
+
+pub trait RemoteInstantiatable{
+    fn new(conn: RmcConnection) -> Self;
+    async fn disconnect(&self);
+}
+
+pub struct OnlyRemote<T: RemoteInstantiatable>(T);
+
+impl<T: RemoteInstantiatable> Deref for OnlyRemote<T>{
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T: RemoteInstantiatable> OnlyRemote<T>{
+    pub fn new(conn: RmcConnection) -> Self{
+        Self(T::new(conn))
+    }
+
+    pub async fn disconnect(&self) {
+        self.0.disconnect().await;
+    }
+}
+
+impl<T: RemoteInstantiatable> RmcCallable for OnlyRemote<T>{
+    fn rmc_call(&self, _responder: &SendingBufferConnection, _protocol_id: u16, _method_id: u32, _call_id: u32, _rest: Vec<u8>) -> impl Future<Output = ()> + Send {
+        // maybe respond with not implemented or something
+        async{}
+    }
+}
+
+async fn handle_incoming<T: RmcCallable + Send + Sync + 'static>(
+    mut connection: SplittableBufferConnection,
+    remote: Arc<T>,
+    notify: Arc<Notify>,
+    incoming: Arc<Mutex<HashMap<u32, RMCResponse>>>,
+) {
+    let sending_conn = connection.duplicate_sender();
+
+    while let Some(v) = connection.recv().await{
+        let Some(proto_id) = v.get(4) else {
+            error!("received too small rmc message.");
+            error!("ending rmc gateway.");
+            return
+        };
+
+        // protocol 0 is hardcoded to be the no protocol protocol aka keepalive protocol
+        if *proto_id == 0{
+            println!("got keepalive");
+            continue;
+        }
+
+        if (proto_id & 0x80) == 0{
+            let Some(response) = RMCResponse::new(&mut Cursor::new(v)).display_err_or_some() else {
+                error!("ending rmc gateway.");
+                return
+            };
+
+            info!("got rmc response");
+
+            let mut locked = incoming.lock().await;
+
+            locked.insert(response.get_call_id(), response);
+            notify.notify_waiters();
+        } else {
+            let Some(message) = RMCMessage::new(&mut Cursor::new(v)).display_err_or_some() else {
+                error!("ending rmc gateway.");
+                return
+            };
+
+            let RMCMessage{
+                protocol_id,
+                method_id,
+                call_id,
+                rest_of_data
+            } = message;
+
+            info!("RMC REQUEST: Proto: {}; Method: {};", protocol_id, method_id);
+
+            remote.rmc_call(&sending_conn, protocol_id, method_id, call_id, rest_of_data).await; 
+
+            
+        }
+    }
+    
+    info!("rmc disconnected")
+}
+
+pub fn new_rmc_gateway_connection<T: RmcCallable + Sync + Send + 'static,F>(conn: SplittableBufferConnection, create_internal: F) -> Arc<T>
+where
+    F: FnOnce(RmcConnection) -> Arc<T>,
+{
+    let notify = Arc::new(Notify::new());
+    let incoming: Arc<Mutex<HashMap<u32, RMCResponse>>> = Default::default();
+
+    let response_recv = RmcResponseReceiver(notify.clone(), incoming.clone());
+
+    let sending_conn = conn.duplicate_sender();
+
+    let rmc_conn = RmcConnection(sending_conn, response_recv);
+
+    let sending_conn = conn.duplicate_sender();
+
+    let exposed_object = (create_internal)(rmc_conn);
+
+    {
+        let exposed_object = exposed_object.clone();
+        tokio::spawn(async move {
+            handle_incoming(
+                conn,
+                exposed_object,
+                notify,
+                incoming
+            ).await;
+        });
+
+
+        tokio::spawn(async move {
+            while sending_conn.is_alive(){
+                sending_conn.send([0,0,0,0,0].to_vec()).await;
+                sleep(Duration::from_secs(10)).await;
+            }
+        });
+    }
+
+    exposed_object
+}
+
+impl<T: RmcCallable> RmcCallable for Arc<T>{
+    fn rmc_call(&self, responder: &SendingBufferConnection, protocol_id: u16, method_id: u32, call_id: u32, rest: Vec<u8>) -> impl Future<Output=()> + Send {
+        self.as_ref().rmc_call(responder, protocol_id, method_id, call_id, rest)
+    }
+}
+
+define_rmc_proto! {
+    proto NoProto{}
+}

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

@@ -0,0 +1,23 @@
+use macros::{method_id, rmc_proto};
+use rnex_core::rmc::response::ErrorCode;
+
+#[rmc_proto(3)]
+pub trait NatTraversal{
+    #[method_id(2)]
+    async fn request_probe_initiation(&self, station_to_probe: String) -> Result<(),ErrorCode>;
+
+    #[method_id(3)]
+    async fn request_probe_initialization_ext(&self, target_list: Vec<String>, station_to_probe: String) -> Result<(),ErrorCode>;
+
+    #[method_id(4)]
+    async fn report_nat_traversal_result(&self, cid: u32, result: bool, rtt: u32) -> Result<(),ErrorCode>;
+
+    #[method_id(5)]
+    async fn report_nat_properties(&self, nat_mapping: u32, nat_filtering: u32, rtt: u32) -> Result<(),ErrorCode>;
+}
+
+#[rmc_proto(3, NoReturn)]
+pub trait NatTraversalConsole{
+    #[method_id(2)]
+    async fn request_probe_initiation(&self, station_to_probe: String);
+}

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

@@ -0,0 +1,24 @@
+use macros::{method_id, rmc_proto, rmc_struct, RmcSerialize};
+
+pub mod notification_types{
+    pub const OWNERSHIP_CHANGED: u32 = 4000;
+    pub const HOST_CHANGED: u32 = 110000;
+}
+
+#[derive(RmcSerialize, Debug, Default, Clone)]
+#[rmc_struct(0)]
+pub struct NotificationEvent{
+    pub pid_source: u32,
+    pub notif_type: u32,
+    pub param_1: u32,
+    pub param_2: u32,
+    pub str_param: String,
+    pub param_3: u32,
+}
+
+#[rmc_proto(14, NoReturn)]
+pub trait Notification {
+    #[method_id(1)]
+    async fn process_notification_event(&self, event: NotificationEvent);
+}
+

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

@@ -0,0 +1,5 @@
+use macros::rmc_proto;
+
+#[rmc_proto(112)]
+pub trait Ranking{
+}

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

@@ -0,0 +1,12 @@
+use macros::{method_id, rmc_proto};
+use rnex_core::prudp::station_url::StationUrl;
+use rnex_core::rmc::response::ErrorCode;
+use rnex_core::rmc::structures::qresult::QResult;
+
+#[rmc_proto(11)]
+pub trait Secure {
+    #[method_id(1)]
+    async fn register(&self, station_urls: Vec<StationUrl>) -> Result<(QResult, u32, StationUrl), ErrorCode>;
+    #[method_id(7)]
+    async fn replace_url(&self, target: StationUrl, dest: StationUrl) -> Result<(), ErrorCode>;
+}