accounts are now real

src/bin/server/main.rs

@@ -2,14 +2,20 @@
 mod db;
 mod net;
 
-use crate::db::{DbUtil, open_db};
+use crate::db::{Db, Msg, User, open_db};
 use clap::Parser;
 use net::{ClientSender, ConAccepter, listen};
 use openworm::{
-    net::{ClientMsg, DisconnectReason, RecvHandler, ServerMsg, install_crypto_provider},
+    net::{
+        ClientMsg, DisconnectReason, NetServerMsg, RecvHandler, ServerError, ServerMsg,
+        install_crypto_provider,
+    },
     rsc::DataDir,
 };
-use sled::{Db, Tree};
+use scrypt::{
+    Scrypt,
+    password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString, rand_core::OsRng},
+};
 use std::{
     collections::HashMap,
     sync::{
@@ -39,7 +45,6 @@ pub async fn run_server(port: u16) {
     let path = dir.get();
     let db: Db = open_db(path.join("server.db"));
     let handler = ServerListener {
-        msgs: db.open_tree("msgs").unwrap(),
         senders: Default::default(),
         count: 0.into(),
         db: db.clone(),
@@ -60,19 +65,24 @@ type ClientId = u64;
 
 struct ServerListener {
     db: Db,
-    msgs: Tree,
     senders: Arc<RwLock<HashMap<ClientId, ClientSender>>>,
     count: AtomicU64,
 }
 
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub enum ClientState {
+    Login,
+    Authed(u64),
+}
+
 impl ConAccepter for ServerListener {
     async fn accept(&self, send: ClientSender) -> impl RecvHandler<ClientMsg> {
         let id = self.count.fetch_add(1, Ordering::Release);
         self.senders.write().await.insert(id, send.clone());
         ClientHandler {
             db: self.db.clone(),
-            msgs: self.msgs.clone(),
             senders: self.senders.clone(),
+            state: Arc::new(RwLock::new(ClientState::Login)),
             send,
             id,
         }
@@ -81,22 +91,35 @@ impl ConAccepter for ServerListener {
 
 struct ClientHandler {
     db: Db,
-    msgs: Tree,
     send: ClientSender,
     senders: Arc<RwLock<HashMap<ClientId, ClientSender>>>,
     id: ClientId,
+    state: Arc<RwLock<ClientState>>,
 }
 
 impl RecvHandler<ClientMsg> for ClientHandler {
     async fn connect(&self) -> () {
-        println!("connected: {:?}", self.send.remote());
+        println!("connected: {:?}", self.send.remote().ip());
     }
     async fn msg(&self, msg: ClientMsg) {
         match msg {
             ClientMsg::SendMsg(msg) => {
+                let ClientState::Authed(uid) = &*self.state.read().await else {
+                    let _ = self.send.send(ServerError::NotLoggedIn).await;
+                    return;
+                };
+                let msg = Msg {
+                    user: *uid,
+                    content: msg.content,
+                };
                 let id = self.db.generate_id().unwrap();
-                self.msgs.insert_(id.to_be_bytes(), &msg);
+                self.db.msgs.insert(&id, &msg);
                 let mut handles = Vec::new();
+                let user: User = self.db.users.get(uid).unwrap();
+                let msg = NetServerMsg {
+                    content: msg.content,
+                    user: user.username,
+                };
                 for (&id, send) in self.senders.read().await.iter() {
                     if id == self.id {
                         continue;
@@ -104,7 +127,7 @@ impl RecvHandler<ClientMsg> for ClientHandler {
                     let send = send.clone();
                     let msg = msg.clone();
                     let fut = async move {
-                        let _ = send.send(ServerMsg::SendMsg(msg)).await;
+                        let _ = send.send(msg).await;
                     };
                     handles.push(tokio::spawn(fut));
                 }
@@ -113,17 +136,85 @@ impl RecvHandler<ClientMsg> for ClientHandler {
                 }
             }
             ClientMsg::RequestMsgs => {
-                let msgs = self.msgs.iter_all().collect();
+                let ClientState::Authed(_uid) = &*self.state.read().await else {
+                    let _ = self.send.send(ServerError::NotLoggedIn).await;
+                    return;
+                };
+                let msgs = self
+                    .db
+                    .msgs
+                    .iter_all()
+                    .map(|msg| {
+                        let user = self
+                            .db
+                            .users
+                            .get(&msg.user)
+                            .map(|user| user.username.to_string())
+                            .unwrap_or("deleted user".to_string());
+                        NetServerMsg {
+                            content: msg.content,
+                            user,
+                        }
+                    })
+                    .collect();
                 let _ = self.send.send(ServerMsg::LoadMsgs(msgs)).await;
             }
+            ClientMsg::CreateAccount { username, password } => {
+                if !self.db.usernames.init_unique(&username) {
+                    let _ = self.send.send(ServerError::UsernameTaken).await;
+                    return;
+                }
+                let id = self.db.generate_id().unwrap();
+                let salt = SaltString::generate(&mut OsRng);
+                let params = scrypt::Params::new(11, 8, 1, 32).unwrap();
+                let hash = Scrypt
+                    .hash_password_customized(password.as_bytes(), None, None, params, &salt)
+                    .unwrap()
+                    .to_string();
+                self.db.users.insert(
+                    &id,
+                    &User {
+                        username: username.clone(),
+                        password_hash: hash,
+                    },
+                );
+                println!("account created: \"{username}\"");
+                self.db.usernames.insert(&username, &id);
+                *self.state.write().await = ClientState::Authed(id);
+                let _ = self.send.send(ServerMsg::Login { username }).await;
+            }
+            ClientMsg::Login { username, password } => {
+                let Some(id) = self.db.usernames.get(&username) else {
+                    let _ = self.send.send(ServerError::UnknownUsername).await;
+                    return;
+                };
+                let Some(user) = self.db.users.get(&id) else {
+                    panic!("invalid state! (should be a user)");
+                };
+                let hash = PasswordHash::new(&user.password_hash).unwrap();
+                if Scrypt.verify_password(password.as_bytes(), &hash).is_err() {
+                    println!("invalid password: \"{username}\"");
+                    let _ = self.send.send(ServerError::InvalidPassword).await;
+                    return;
+                }
+                println!("login: \"{username}\"");
+                *self.state.write().await = ClientState::Authed(id);
+                let _ = self.send.send(ServerMsg::Login { username }).await;
+            }
         }
     }
 
     async fn disconnect(&self, reason: DisconnectReason) -> () {
-        println!("disconnected: {:?}", self.send.remote());
+        println!("disconnected: {:?}", self.send.remote().ip());
         match reason {
             DisconnectReason::Closed | DisconnectReason::Timeout => (),
             DisconnectReason::Other(e) => println!("connection issue: {e}"),
         }
     }
 }
+
+impl ClientState {
+    pub fn is_authed(&self) -> bool {
+        matches!(self, Self::Authed(_))
+    }
+}