From 3d2445c94cc55cbc906b5b9d07d8bda02171939a Mon Sep 17 00:00:00 2001 From: Joshua Higgins Date: Sun, 13 Oct 2024 11:56:01 -0400 Subject: [PATCH] joining server works but... durian is POS --- auth/src/server.rs | 5 +- client/Cargo.toml | 1 - client/src/app.rs | 168 +++++++++++++++++++++++++++++++++++-------- client/src/main.rs | 6 +- client/src/types.rs | 8 +-- client/src/ui/gui.rs | 26 ++++++- server/src/main.rs | 6 +- server/src/server.rs | 79 ++++++++++++-------- server/src/types.rs | 13 +++- shared/Cargo.toml | 2 + shared/src/lib.rs | 10 ++- shared/src/types.rs | 1 + 12 files changed, 243 insertions(+), 82 deletions(-) diff --git a/auth/src/server.rs b/auth/src/server.rs index 1564a69..8b04e41 100644 --- a/auth/src/server.rs +++ b/auth/src/server.rs @@ -189,8 +189,7 @@ impl RealmAuth for RealmAuthServer { }; for token in tokens { - let hash = Sha3_256::new().chain(format!("{}{}{}{}", token, server_id, domain, tarpc_port)).finalize(); - if hex::encode(hash) == server_token { + if realm_shared::stoken(token, &server_id, &domain, tarpc_port) == server_token { return true; } } @@ -533,7 +532,7 @@ impl RealmAuth for RealmAuthServer { vec_servers.push(&address); let new_servers = vec_servers.join("|"); - let result = query!("UPDATE user SET servers = ? WHERE username = ?", new_servers, username).fetch_one(&self.db_pool).await; + let result = query!("UPDATE user SET servers = ? WHERE username = ?", new_servers, username).execute(&self.db_pool).await; match result { Ok(_) => Ok(()), Err(_) => Err(Error) diff --git a/client/Cargo.toml b/client/Cargo.toml index 70d8bc8..a255df4 100644 --- a/client/Cargo.toml +++ b/client/Cargo.toml @@ -14,7 +14,6 @@ eframe = { version = "0.29", default-features = false, features = [ "persistence", # Enable restoring app state when restarting the app. ] } serde = { version = "1", features = ["derive"] } -env_logger = "0.11.5" tokio = "1.40.0" tarpc = { version = "0.34.0", features = ["full"] } tracing = "0.1.40" diff --git a/client/src/app.rs b/client/src/app.rs index d8acede..318594a 100644 --- a/client/src/app.rs +++ b/client/src/app.rs @@ -4,9 +4,11 @@ use tokio::sync::broadcast; use tokio::sync::broadcast::{Receiver, Sender}; use tracing::log::*; use realm_auth::types::RealmAuthClient; +use realm_server::types::{RealmChatClient, User}; +use realm_shared::stoken; use realm_shared::types::ErrorCode::*; use realm_shared::types::ErrorCode; -use crate::types::ClientUser; +use crate::types::{CServer, CUser}; use crate::ui::gui; /// We derive Deserialize/Serialize so we can persist app state on shutdown. @@ -16,15 +18,20 @@ pub struct RealmApp { // Example stuff: pub label: String, pub selected: bool, - pub selected_serverid: Option, - pub selected_roomid: Option, + #[serde(skip)] + pub selected_serverid: String, + #[serde(skip)] + pub selected_roomid: String, #[serde(skip)] - pub current_user: Option, + pub current_user: Option, pub saved_username: Option, pub saved_token: Option, pub saved_auth_address: Option, + + #[serde(skip)] + pub active_servers: Option>, #[serde(skip)] pub value: f32, @@ -58,10 +65,15 @@ pub struct RealmApp { pub login_ending_channel: (Sender>, Receiver>), #[serde(skip)] - pub fetching_user_data_channel: (Sender>, Receiver>), + pub fetching_user_data_channel: (Sender>, Receiver>), #[serde(skip)] - pub added_server_channel: (Sender>, Receiver>), + pub add_server_channel: (Sender>, Receiver>), + #[serde(skip)] + pub join_server_channel: (Sender>, Receiver>), + + #[serde(skip)] + pub fetching_servers_channel: (Sender>, Receiver>), } impl Default for RealmApp { @@ -70,12 +82,13 @@ impl Default for RealmApp { // Example stuff: label: "Hello World!".to_owned(), selected: false, - selected_serverid: None, - selected_roomid: None, + selected_serverid: String::new(), + selected_roomid: String::new(), current_user: None, saved_username: None, saved_token: None, saved_auth_address: None, + active_servers: None, value: 2.7, login_window_open: false, @@ -94,8 +107,9 @@ impl Default for RealmApp { server_window_port: "5051".to_string(), fetching_user_data_channel: broadcast::channel(10), - - added_server_channel: broadcast::channel(10), + add_server_channel: broadcast::channel(10), + join_server_channel: broadcast::channel(10), + fetching_servers_channel: broadcast::channel(10), } } } @@ -116,21 +130,21 @@ impl RealmApp { } } -pub fn fetch_user_data(send_channel: Sender>, server_address: String, username: String, token: String) { +pub fn fetch_user_data(send_channel: Sender>, server_address: String, username: String, token: String) { let _handle = tokio::spawn(async move { let mut transport = tarpc::serde_transport::tcp::connect(&server_address, Json::default); transport.config_mut().max_frame_length(usize::MAX); let result = transport.await; - let connection = match result { + let auth_connection = match result { Ok(connection) => connection, - Err(e) => { - tracing::error!("Failed to connect to server: {}", e); + Err(_) => { + send_channel.send(Err(UnableToConnectToServer)).unwrap(); return; } }; - let client = RealmAuthClient::new(tarpc::client::Config::default(), connection).spawn(); + let client = RealmAuthClient::new(tarpc::client::Config::default(), auth_connection).spawn(); let result = client.get_all_data(context::current(), username, token.clone()).await; match result { @@ -139,20 +153,13 @@ pub fn fetch_user_data(send_channel: Sender>, serv send_channel.send(Err(code)).unwrap(); } else { let auth_user = r.unwrap(); - let servers: Vec = { - if auth_user.servers.eq("") { - Vec::new() - } else { - auth_user.servers.split('|').map(|s| s.to_string()).collect() - } - }; - send_channel.send(Ok(ClientUser { + send_channel.send(Ok(CUser { id: auth_user.id, - server_address, + auth_address: server_address, username: auth_user.username, email: auth_user.email, //avatar: auth_user.avatar, - servers, + server_addresses: auth_user.servers.split('|').map(|s| s.to_string()).collect(), token, })).unwrap(); } @@ -164,6 +171,38 @@ pub fn fetch_user_data(send_channel: Sender>, serv }); } +pub fn fetch_server_data(addresses: Vec, channel: Sender>) { + for server_address in addresses { + let send_channel = channel.clone(); + + let _handle = tokio::spawn(async move { + let mut transport = tarpc::serde_transport::tcp::connect(&server_address, Json::default); + transport.config_mut().max_frame_length(usize::MAX); + + let result = transport.await; + let connection = match result { + Ok(connection) => connection, + Err(_) => { + send_channel.send(Err(UnableToConnectToServer)).unwrap(); + return; + } + }; + + let client = RealmChatClient::new(tarpc::client::Config::default(), connection).spawn(); + let info = client.get_info(context::current()).await.unwrap(); + let is_admin = client.is_user_admin(context::current(), info.server_id.clone()).await.unwrap(); + let is_owner = client.is_user_owner(context::current(), info.server_id.clone()).await.unwrap(); + send_channel.send(Ok(CServer { + server_id: info.server_id, + domain: server_address.split(':').collect::>()[0].to_string(), + port: server_address.split(':').collect::>()[1].to_string().parse::().unwrap(), + is_admin, + is_owner, + })).unwrap(); + }); + } +} + impl eframe::App for RealmApp { /// Called each time the UI needs repainting, which may be many times per second. fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) { @@ -174,7 +213,7 @@ impl eframe::App for RealmApp { if self.current_user.is_none() && self.saved_token.is_some() && self.saved_auth_address.is_some() && - self.saved_username.is_some() + self.saved_username.is_some() { let send_channel = self.fetching_user_data_channel.0.clone(); let server_address = self.saved_auth_address.clone().unwrap(); @@ -183,6 +222,13 @@ impl eframe::App for RealmApp { fetch_user_data(send_channel, server_address, username, token); } + // Fetching servers + if self.active_servers.is_none() && self.current_user.is_some() { + self.active_servers = Some(Vec::new()); + fetch_server_data(self.current_user.clone().unwrap().server_addresses.clone(), self.fetching_servers_channel.0.clone()); + } + + // Starting the login flow while let Ok(result) = self.login_start_channel.1.try_recv() { match result { Ok(_) => self.login_ready_for_code_input = true, @@ -190,6 +236,7 @@ impl eframe::App for RealmApp { } } + // End of the login flow while let Ok(result) = self.login_ending_channel.1.try_recv() { match result { Ok(token) => { @@ -214,6 +261,7 @@ impl eframe::App for RealmApp { } } + // Fetching user data while let Ok(result) = self.fetching_user_data_channel.1.try_recv() { match result { Ok(client_user) => { @@ -224,21 +272,81 @@ impl eframe::App for RealmApp { } } - while let Ok(result) = self.added_server_channel.1.try_recv() { + // Adding a server + while let Ok(result) = self.add_server_channel.1.try_recv() { match result { Ok(address) => { info!("New server added at: {:?}", address); self.server_window_open = false; - let send_channel = self.fetching_user_data_channel.0.clone(); - let server_address = self.saved_auth_address.clone().unwrap(); + let send_channel = self.join_server_channel.0.clone(); + let auth_address = self.saved_auth_address.clone().unwrap(); let username = self.saved_username.clone().unwrap(); let token = self.saved_token.clone().unwrap(); - fetch_user_data(send_channel, server_address, username, token); + + let thread_username = username.clone(); + let thread_token = token.clone(); + let _handle = tokio::spawn(async move { + let mut transport = tarpc::serde_transport::tcp::connect(&address, Json::default); + transport.config_mut().max_frame_length(usize::MAX); + + let result = transport.await; + let connection = match result { + Ok(connection) => connection, + Err(_) => { + send_channel.clone().send(Err(UnableToConnectToServer)).unwrap(); + return; + } + }; + + let client = RealmChatClient::new(tarpc::client::Config::default(), connection).spawn(); + + let domain = address.split(':').collect::>()[0].to_string(); + let port = address.split(':').collect::>()[1].to_string().parse::().unwrap(); + + let info = client.get_info(context::current()).await.unwrap(); + + let result = client.join_server(context::current(), stoken(&thread_token, &info.server_id, &domain, port), thread_username).await; + + match result { + Ok(_) => { + info!("Joined server!"); + }, + Err(e) => error!("Error joining server: {:?}", e), + } + }); + + fetch_user_data(self.fetching_user_data_channel.0.clone(), auth_address, username, token); } Err(e) => error!("Error in adding a server: {:?}", e), } } + + // Joining a server + while let Ok(result) = self.join_server_channel.1.try_recv() { + match result { + Ok(_) => { + info!("Successfully joined a server"); + fetch_server_data(self.current_user.clone().unwrap().server_addresses.clone(), self.fetching_servers_channel.0.clone()); + }, + Err(code) => { + error!("Error joining server: {:?}", code); + } + } + } + + // Fetching servers + while let Ok(result) = self.fetching_servers_channel.1.try_recv() { + match result { + Ok(server) => { + info!("Got server data! Server: {:?}", server); + if let Some(active_servers) = &mut self.active_servers { + active_servers.push(server); + } + } + Err(e) => error!("Error fetching server data: {:?}", e), + } + } // File -> Quit gui::top_panel(self, ctx); diff --git a/client/src/main.rs b/client/src/main.rs index 8cf5274..ddf0040 100644 --- a/client/src/main.rs +++ b/client/src/main.rs @@ -1,15 +1,13 @@ -use tracing::subscriber; +use tracing::*; #[tokio::main] async fn main() -> eframe::Result { - env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`). - let subscriber = tracing_subscriber::fmt() .compact() .with_file(true) .with_line_number(true) .with_thread_ids(true) - .with_target(false) + .with_target(true) .finish(); subscriber::set_global_default(subscriber).unwrap(); diff --git a/client/src/types.rs b/client/src/types.rs index aee2703..6da2e26 100644 --- a/client/src/types.rs +++ b/client/src/types.rs @@ -1,16 +1,16 @@ #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)] -pub struct ClientUser { +pub struct CUser { pub id: i64, - pub server_address: String, + pub auth_address: String, pub username: String, pub email: String, //pub avatar: String, - pub servers: Vec, + pub server_addresses: Vec, pub token: String, } #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)] -pub struct ClientServer { +pub struct CServer { pub server_id: String, pub domain: String, pub port: u16, diff --git a/client/src/ui/gui.rs b/client/src/ui/gui.rs index df1d464..799d6d5 100644 --- a/client/src/ui/gui.rs +++ b/client/src/ui/gui.rs @@ -19,7 +19,7 @@ pub fn top_panel(app: &mut RealmApp, ctx: &Context) { } if app.current_user.is_some() && ui.button("Logout").clicked() { - let address = app.current_user.clone().unwrap().server_address; + let address = app.current_user.clone().unwrap().auth_address; let username = app.current_user.clone().unwrap().username; let token = app.current_user.clone().unwrap().token; @@ -75,6 +75,18 @@ pub fn servers(app: &mut RealmApp, ctx: &Context) { if ui.add(SelectableLabel::new(app.selected, "server")).clicked() { app.selected = !app.selected; } + + if let Some(active_servers) = &mut app.active_servers { + for server in active_servers { + if ui.add(SelectableLabel::new(server.server_id.eq(&app.selected_serverid), server.server_id.clone())).clicked() { + if app.selected_serverid.eq(&server.server_id) { + app.selected_serverid.clear(); + } else { + app.selected_serverid = server.server_id.clone(); + } + } + } + } }); } @@ -112,6 +124,14 @@ pub fn messages(app: &mut RealmApp, ctx: &Context) { ui.separator(); + if let Some(servers) = &app.active_servers { + for server in servers { + ui.label(format!("Active server: {:?}", server)); + } + } + + ui.separator(); + ui.label(format!("Current user: {:?}", app.current_user)); }); } @@ -282,10 +302,10 @@ pub fn modals(app: &mut RealmApp, ctx: &Context) { if app.current_user.is_some() && ui.button("Add Server").clicked() { let domain = app.server_window_domain.clone(); let port = app.server_window_port.clone(); - let auth_address = app.current_user.clone().unwrap().server_address; + let auth_address = app.current_user.clone().unwrap().auth_address; let auth_username = app.current_user.clone().unwrap().username; let auth_token = app.current_user.clone().unwrap().token; - let send_channel = app.added_server_channel.0.clone(); + let send_channel = app.add_server_channel.0.clone(); let _handle = tokio::spawn(async move { let mut transport = tarpc::serde_transport::tcp::connect(auth_address, Json::default); diff --git a/server/src/main.rs b/server/src/main.rs index c89357b..c96158a 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -59,7 +59,7 @@ async fn main() -> anyhow::Result<()> { let port = env::var("PORT").expect("PORT must be set").parse::()?; let server_addr = (IpAddr::V6(Ipv6Addr::LOCALHOST), port); - let mut inner_manager = PacketManager::new_for_async(); + let mut inner_manager = PacketManager::new(); inner_manager.register_receive_packet::(GreetPacketBuilder)?; inner_manager.register_receive_packet::(UserJoinedEventPacketBuilder)?; @@ -83,10 +83,10 @@ async fn main() -> anyhow::Result<()> { inner_manager.register_send_packet::()?; inner_manager.register_send_packet::()?; - inner_manager.async_init_server( + inner_manager.init_server( ServerConfig::new( SocketAddr::from((IpAddr::V6(Ipv6Addr::LOCALHOST), port-1)).to_string(), - 0, None, 8, 8)).await?; + 0, None, 8, 8))?; let manager = Arc::new(Mutex::new(inner_manager)); info!("Listening on port {}", port-1); diff --git a/server/src/server.rs b/server/src/server.rs index a53aae9..5b9f9b8 100644 --- a/server/src/server.rs +++ b/server/src/server.rs @@ -15,7 +15,7 @@ use realm_auth::types::RealmAuthClient; use realm_shared::types::ErrorCode::*; use realm_shared::types::ErrorCode; use crate::events::*; -use crate::types::{Attachment, Edit, FromRows, Message, MessageData, Reaction, RealmChat, Redaction, Reply, ReplyChain, Room, User}; +use crate::types::{Attachment, Edit, FromRows, Message, MessageData, Reaction, RealmChat, Redaction, Reply, ReplyChain, Room, ServerInfo, User}; #[derive(Clone)] pub struct RealmChatServer { @@ -55,9 +55,9 @@ impl RealmChatServer { async fn is_stoken_valid(&self, userid: &str, stoken: &str) -> bool { match self.cache.get(stoken).await { None => { - if !self.is_user_in_server(userid).await { - return false; - } + // if !self.is_user_in_server(userid).await { + // return false; + // } let user_domain = &userid[userid.find(':').unwrap()+1..]; @@ -94,7 +94,7 @@ impl RealmChatServer { } } - async fn is_user_admin(&self, stoken: &str) -> bool { + pub async fn internal_is_user_admin(&self, stoken: &str) -> bool { if let Some(userid) = self.cache.get(stoken).await { let result = query!("SELECT admin FROM user WHERE userid = ?", userid).fetch_one(&self.db_pool).await; return match result { @@ -110,7 +110,7 @@ impl RealmChatServer { false } - async fn is_user_owner(&self, stoken: &str) -> bool { + pub async fn internal_is_user_owner(&self, stoken: &str) -> bool { if let Some(userid) = self.cache.get(stoken).await { let result = query!("SELECT owner FROM user WHERE userid = ?", userid).fetch_one(&self.db_pool).await; return match result { @@ -136,7 +136,7 @@ impl RealmChatServer { } async fn inner_get_all_direct_replies(&self, stoken: &str, head: i64) -> Result, ErrorCode> { - let is_admin = self.is_user_admin(stoken).await; + let is_admin = self.internal_is_user_admin(stoken).await; let result = sqlx::query(&format!("{}{}", FETCH_MESSAGE, "AND message.referencing_id = ?")) .bind(is_admin) .bind(head) @@ -175,7 +175,7 @@ impl RealmChatServer { } async fn inner_get_room(&self, stoken: &str, roomid: &str) -> Result { - let is_admin = self.is_user_admin(&stoken).await; + let is_admin = self.internal_is_user_admin(&stoken).await; let result = query_as!( Room, "SELECT * FROM room WHERE roomid = ? AND admin_only_view = ? OR false", is_admin, roomid).fetch_one(&self.db_pool).await; @@ -204,7 +204,7 @@ impl RealmChatServer { } async fn inner_get_message(&self, stoken: &str, id: i64) -> Result { - let is_admin = self.is_user_admin(&stoken).await; + let is_admin = self.internal_is_user_admin(&stoken).await; let result = sqlx::query(&format!("{}{}", FETCH_MESSAGE, "AND message.id = ?")) .bind(is_admin) .bind(id) @@ -221,13 +221,27 @@ impl RealmChat for RealmChatServer { async fn test(self, _: Context, name: String) -> String { format!("Hello, {name}!") } + + async fn get_info(self, _: Context) -> ServerInfo { + ServerInfo { + server_id: self.server_id.clone(), + } + } - async fn join_server(self, _: Context, stoken: String, user: User) -> Result { - if !self.is_stoken_valid(&user.userid, &stoken).await { + async fn is_user_admin(self, _: Context, stoken: String) -> bool { + self.internal_is_user_admin(&stoken).await + } + + async fn is_user_owner(self, _: Context, stoken: String) -> bool { + self.internal_is_user_owner(&stoken).await + } + + async fn join_server(self, _: Context, stoken: String, userid: String) -> Result { + if !self.is_stoken_valid(&userid, &stoken).await { return Err(Unauthorized) } - if self.is_user_in_server(&user.userid).await { + if self.is_user_in_server(&userid).await { return Err(AlreadyJoinedServer) } @@ -236,12 +250,13 @@ impl RealmChat for RealmChatServer { all_users.is_empty() }; - let result = query!("INSERT INTO user (userid, name, owner, admin) VALUES (?,?,?,?)", user.userid, user.name, is_owner, is_owner).execute(&self.db_pool).await; + //TOOD: name support + let result = query!("INSERT INTO user (userid, name, owner, admin) VALUES (?,?,?,?)", userid, "userid", is_owner, is_owner).execute(&self.db_pool).await; match result { Ok(_) => { - let new_user = self.inner_get_user(&user.userid).await?; + let new_user = self.inner_get_user(&userid).await?; let result = self.packet_manager.lock().await.broadcast(UserJoinedEvent { user: new_user.clone(), @@ -256,21 +271,23 @@ impl RealmChat for RealmChatServer { } } - async fn leave_server(self, _: Context, stoken: String, user: User) -> Result<(), ErrorCode> { - if !self.is_stoken_valid(&user.userid, &stoken).await { + async fn leave_server(self, _: Context, stoken: String, userid: String) -> Result<(), ErrorCode> { + if !self.is_stoken_valid(&userid, &stoken).await { return Err(Unauthorized) } - if !self.is_user_in_server(&user.userid).await { + if !self.is_user_in_server(&userid).await { return Err(NotInServer) } + + let user = self.inner_get_user(&userid).await?; - let result = query!("DELETE FROM user WHERE userid = ?",user.userid).execute(&self.db_pool).await; + let result = query!("DELETE FROM user WHERE userid = ?", userid).execute(&self.db_pool).await; match result { Ok(_) => { let result = self.packet_manager.lock().await.broadcast(UserLeftEvent { - user: user.clone(), + user, }); if result.is_err() { @@ -300,14 +317,14 @@ impl RealmChat for RealmChatServer { } MessageData::Redaction(r)=> { let ref_msg = self.inner_get_message(&stoken, r.referencing_id).await?; - if !ref_msg.user.userid.eq(&message.user.userid) || !self.is_user_admin(&stoken).await { + if !ref_msg.user.userid.eq(&message.user.userid) || !self.internal_is_user_admin(&stoken).await { return Err(Unauthorized) } } _ => {} } - let is_admin = self.is_user_admin(&stoken).await; + let is_admin = self.internal_is_user_admin(&stoken).await; let admin_only_send = query!( "SELECT admin_only_send FROM room WHERE roomid = ?", message.room.roomid).fetch_one(&self.db_pool).await; @@ -379,7 +396,7 @@ impl RealmChat for RealmChatServer { } async fn get_message(self, _: Context, stoken: String, id: i64) -> Result { - let is_admin = self.is_user_admin(&stoken).await; + let is_admin = self.internal_is_user_admin(&stoken).await; let result = sqlx::query(&format!("{}{}", FETCH_MESSAGE, "AND message.id = ?")) .bind(is_admin) .bind(id) @@ -396,7 +413,7 @@ impl RealmChat for RealmChatServer { } async fn get_messages_since(self, _: Context, stoken: String, time: DateTime) -> Result, ErrorCode> { - let is_admin = self.is_user_admin(&stoken).await; + let is_admin = self.internal_is_user_admin(&stoken).await; let result = sqlx::query(&format!("{}{}", FETCH_MESSAGE, "AND message.timestamp >= ?")) .bind(is_admin) .bind(time) @@ -417,7 +434,7 @@ impl RealmChat for RealmChatServer { } async fn get_rooms(self, _: Context, stoken: String) -> Result, ErrorCode> { - let is_admin = self.is_user_admin(&stoken).await; + let is_admin = self.internal_is_user_admin(&stoken).await; let result = query_as!( Room, "SELECT * FROM room WHERE admin_only_view = ? OR false", is_admin).fetch_all(&self.db_pool).await; @@ -440,7 +457,7 @@ impl RealmChat for RealmChatServer { } async fn create_room(self, _: Context, stoken: String, room: Room) -> Result { - if !self.is_user_admin(&stoken).await { + if !self.internal_is_user_admin(&stoken).await { return Err(Unauthorized) } @@ -465,7 +482,7 @@ impl RealmChat for RealmChatServer { } async fn delete_room(self, _: Context, stoken: String, roomid: String) -> Result<(), ErrorCode> { - if !self.is_user_admin(&stoken).await { + if !self.internal_is_user_admin(&stoken).await { return Err(Unauthorized) } @@ -488,7 +505,7 @@ impl RealmChat for RealmChatServer { } async fn promote_user(self, _: Context, stoken: String, userid: String) -> Result<(), ErrorCode> { - if !self.is_user_owner(&stoken).await { + if !self.internal_is_user_owner(&stoken).await { return Err(Unauthorized) } @@ -511,7 +528,7 @@ impl RealmChat for RealmChatServer { } async fn demote_user(self, _: Context, stoken: String, userid: String) -> Result<(), ErrorCode> { - if !self.is_user_owner(&stoken).await { + if !self.internal_is_user_owner(&stoken).await { return Err(Unauthorized) } @@ -534,7 +551,7 @@ impl RealmChat for RealmChatServer { } async fn kick_user(self, _: Context, stoken: String, userid: String) -> Result<(), ErrorCode> { - if !self.is_user_admin(&stoken).await { + if !self.internal_is_user_admin(&stoken).await { return Err(Unauthorized) } @@ -557,7 +574,7 @@ impl RealmChat for RealmChatServer { } async fn ban_user(self, _: Context, stoken: String, userid: String) -> Result<(), ErrorCode> { - if !self.is_user_admin(&stoken).await { + if !self.internal_is_user_admin(&stoken).await { return Err(Unauthorized) } @@ -581,7 +598,7 @@ impl RealmChat for RealmChatServer { } async fn pardon_user(self, _: Context, stoken: String, userid: String) -> Result<(), ErrorCode> { - if !self.is_user_admin(&stoken).await { + if !self.internal_is_user_admin(&stoken).await { return Err(Unauthorized) } diff --git a/server/src/types.rs b/server/src/types.rs index f4411ff..5efcec2 100644 --- a/server/src/types.rs +++ b/server/src/types.rs @@ -11,8 +11,12 @@ use crate::types::MessageData::*; pub trait RealmChat { async fn test(name: String) -> String; - async fn join_server(stoken: String, user: User) -> Result; - async fn leave_server(stoken: String, user: User) -> Result<(), ErrorCode>; + async fn get_info() -> ServerInfo; + async fn is_user_admin(stoken: String) -> bool; + async fn is_user_owner(stoken: String) -> bool; + + async fn join_server(stoken: String, userid: String) -> Result; + async fn leave_server(stoken: String, userid: String) -> Result<(), ErrorCode>; //NOTE: Any user authorized as themselves async fn send_message(stoken: String, message: Message) -> Result; @@ -38,6 +42,11 @@ pub trait RealmChat { async fn pardon_user(stoken: String, userid: String) -> Result<(), ErrorCode>; } +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ServerInfo { + pub server_id: String, +} + #[derive(Debug, Clone, Serialize, Deserialize, FromRow)] pub struct Message { pub id: i64, diff --git a/shared/Cargo.toml b/shared/Cargo.toml index 1282f0e..195813f 100644 --- a/shared/Cargo.toml +++ b/shared/Cargo.toml @@ -5,3 +5,5 @@ edition = "2021" [dependencies] serde = { version = "1.0.203", features = ["derive"] } +sha3 = "0.10.8" +hex = "0.4.3" diff --git a/shared/src/lib.rs b/shared/src/lib.rs index dd198c6..25d2340 100644 --- a/shared/src/lib.rs +++ b/shared/src/lib.rs @@ -1 +1,9 @@ -pub mod types; \ No newline at end of file +use sha3::digest::Update; +use sha3::{Digest, Sha3_256}; + +pub mod types; + +pub fn stoken(token: &str, serverid: &str, domain: &str, port: u16) -> String { + let hash = Sha3_256::new().chain(format!("{}{}{}{}", token, serverid, domain, port)).finalize(); + hex::encode(hash) +} \ No newline at end of file diff --git a/shared/src/types.rs b/shared/src/types.rs index d6c2d89..98cafc2 100644 --- a/shared/src/types.rs +++ b/shared/src/types.rs @@ -23,4 +23,5 @@ pub enum ErrorCode { MalformedDBResponse, RPCError, + UnableToConnectToServer, } \ No newline at end of file