restore basic auth services

kubi-server/src/auth.rs

@@ -1,35 +1,69 @@
-use shipyard::{UniqueView, UniqueViewMut};
+use shipyard::{UniqueView, UniqueViewMut, NonSendSync};
-use kubi_shared::networking::messages::{ClientToServerMessage, ServerToClientMessage, InitData};
+use uflow::{server::Event as ServerEvent, SendMode};
-use crate::{server::{ServerEvents, UdpServer}, config::ConfigTable, util::log_error};
+use kubi_shared::networking::messages::{
+  ClientToServerMessage,
+  ServerToClientMessage,
+  InitData,
+  C_CLIENT_HELLO
+};
+use crate::{
+  server::{ServerEvents, UdpServer, IsMessageOfType}, 
+  config::ConfigTable, util::log_error
+};
 
 pub fn authenticate_players(
-  mut server: UniqueViewMut<UdpServer>,
+  mut server: NonSendSync<UniqueViewMut<UdpServer>>,
   events: UniqueView<ServerEvents>,
   config: UniqueView<ConfigTable>
 ) {
   for event in &events.0 {
-    if let ServerEvent::MessageReceived {
+    // if let ServerEvent::MessageReceived {
-      from, 
+    //   from, 
-      message: ClientToServerMessage::ClientHello {
+    //   message: ClientToServerMessage::ClientHello {
-        username,
+    //     username,
-        password
+    //     password
+    //   } 
+    // } = event {
+    
+    let ServerEvent::Receive(client_addr, data) = event else{
+      continue
+    };
+    let Some(client) = server.0.client(client_addr) else {
+      log::error!("Client doesn't exist");
+      continue
+    };
+    if !event.is_message_of_type::<C_CLIENT_HELLO>() {
+      continue
     }
-    } = event {
+    let Ok(parsed_message) = postcard::from_bytes(data) else {
-      log::info!("ClientHello from {} with username {} and password {:?}", from, username, password);
+      log::error!("Malformed message 00");
+      continue
+    };
+    let ClientToServerMessage::ClientHello { username, password } = parsed_message else {
+      unreachable!()
+    };
+
+    log::info!("ClientHello; username={} password={:?}", username, password);
 
     // Handle password auth
     if let Some(server_password) = &config.server.password {
       if let Some(user_password) = &password {
         if server_password != user_password {
-            server.0.send_message(*from, ServerToClientMessage::ServerFuckOff {
+          let res = postcard::to_allocvec(&ServerToClientMessage::ServerFuckOff {
             reason: "Passwords don't match".into()
-            }).map_err(log_error).ok();
+          }).unwrap().into_boxed_slice();
+          client.borrow_mut().send(
+            res, 0, SendMode::Reliable
+          );
           continue
         }
       } else {
-          server.0.send_message(*from, ServerToClientMessage::ServerFuckOff {
+        let res = postcard::to_allocvec(&ServerToClientMessage::ServerFuckOff {
-            reason: "This server is password-protected".into()
+          reason: "This server is password protected".into()
-          }).map_err(log_error).ok();
+        }).unwrap().into_boxed_slice();
+        client.borrow_mut().send(
+          res, 0, SendMode::Reliable
+        );
         continue
       }
     }
@@ -38,11 +72,13 @@ pub fn authenticate_players(
     //TODO Spawn the user on server side
 
     //Approve the user
-      server.0.send_message(*from, ServerToClientMessage::ServerHello {
+    let res = postcard::to_allocvec(&ServerToClientMessage::ServerHello {
       init: InitData {
         users: vec![] //TODO create init data
       }
-      }).map_err(log_error).ok();
+    }).unwrap().into_boxed_slice();
-    }
+    client.borrow_mut().send(
+      res, 0, SendMode::Reliable
+    );
   }
 }

kubi-server/src/main.rs

@@ -5,19 +5,19 @@ pub(crate) mod util;
 pub(crate) mod config;
 pub(crate) mod server;
 pub(crate) mod client;
-pub(crate) mod world;
+//pub(crate) mod world;
 pub(crate) mod auth;
 
 use config::read_config;
 use server::{bind_server, update_server, log_server_errors};
 use auth::authenticate_players;
-use world::{update_world, init_world};
+//use world::{update_world, init_world};
 
 fn initialize() -> Workload {
   (
     read_config,
     bind_server,
-    init_world,
+    //init_world,
   ).into_workload()
 }
 
@@ -27,7 +27,7 @@ fn update() -> Workload {
     (
       log_server_errors,
       authenticate_players,
-      update_world,
+      //update_world,
     ).into_workload()
   ).into_sequential_workload()
 }