shadowcat/openworm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

accounts are now real

Browse Source
This commit is contained in:
shadow cat
2025-12-03 22:51:57 -05:00
parent 4aa22de61b
commit 24bb65bf7b
15 changed files with 679 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
src/bin/client/main.rs
View File

@@ -2,8 +2,9 @@
use crate::{
app::App,
net::{NetCtrlMsg, NetHandle, NetSender, NetState},
net::{NetHandle, NetSender},
rsc::{CLIENT_DATA, ClientData},
state::{ClientState, LoggedIn, Login},
ui::*,
};
pub use app::AppHandle;
@@ -11,7 +12,7 @@ use arboard::Clipboard;
use input::Input;
use iris::prelude::*;
use openworm::{
net::{ClientMsg, NetMsg, ServerMsg, install_crypto_provider},
net::{ClientMsg, ServerMsg, install_crypto_provider},
rsc::DataDir,
};
use render::Renderer;
@@ -28,6 +29,7 @@ mod input;
mod net;
mod render;
mod rsc;
mod state;
mod ui;
fn main() {
@@ -35,28 +37,26 @@ fn main() {
App::run();
}
pub enum ClientEvent {
Connect { send: NetSender, username: String },
ServerMsg(ServerMsg),
Err(String),
}
pub struct Client {
renderer: Renderer,
input: Input,
ui: Ui,
focus: Option<WidgetId<TextEdit>>,
channel: Option<WidgetId<Span>>,
username: String,
clipboard: Clipboard,
dir: DataDir,
data: ClientData,
handle: AppHandle,
error: Option<WidgetId<WidgetPtr>>,
net: NetState,
msgs: Vec<NetMsg>,
state: ClientState,
ime: usize,
last_click: Instant,
main_ui: WidgetId<WidgetPtr>,
notif: WidgetId<WidgetPtr>,
}
pub enum ClientEvent {
Connect { send: NetSender },
ServerMsg(ServerMsg),
Err(String),
}
impl Client {
@@ -70,62 +70,90 @@ impl Client {
let dir = DataDir::default();
let handle = AppHandle { proxy, window };
let mut ui = Ui::new();
let notif = WidgetPtr::default().add(&mut ui);
let main_ui = WidgetPtr::default().add(&mut ui);
(
notif.clone().pad(Padding::top(10)).align(Align::TOP_CENTER),
main_ui.clone(),
)
.stack()
.set_root(&mut ui);
let mut s = Self {
handle,
renderer,
input: Input::default(),
ui: Ui::new(),
ui,
data: dir.load(CLIENT_DATA),
state: Default::default(),
dir,
channel: None,
focus: None,
net: Default::default(),
username: "<unknown>".to_string(),
clipboard: Clipboard::new().unwrap(),
error: None,
ime: 0,
last_click: Instant::now(),
msgs: Vec::new(),
main_ui: main_ui.clone(),
notif,
};
ui::init(&mut s);
connect_screen(&mut s).set_ptr(&main_ui, &mut s.ui);
s
}
pub fn event(&mut self, event: ClientEvent, _: &ActiveEventLoop) {
match event {
ClientEvent::Connect { send, username } => {
self.username = username;
send.send(ClientMsg::RequestMsgs);
let NetState::Connecting(th) = self.net.take() else {
ClientEvent::Connect { send } => {
let ClientState::Connect(state) = self.state.take() else {
panic!("invalid state");
};
self.net = NetState::Connected(NetHandle {
send: send.clone(),
thread: th,
let th = state.handle.unwrap();
self.state = ClientState::Login(Login {
handle: NetHandle {
send: send.clone(),
thread: th,
},
});
main_view(self, send).set_root(&mut self.ui);
login_screen(self).set_ptr(&self.main_ui, &mut self.ui);
}
ClientEvent::ServerMsg(msg) => match msg {
ServerMsg::SendMsg(msg) => {
if let Some(msg_area) = &self.channel {
let msg = msg_widget(msg).add(&mut self.ui);
if let ClientState::LoggedIn(state) = &mut self.state
&& let Some(msg_area) = &state.channel
{
let msg = msg_widget(&msg.user, &msg.content).add(&mut self.ui);
self.ui[msg_area].children.push(msg.any());
}
}
ServerMsg::LoadMsgs(msgs) => {
if let Some(msg_area) = &self.channel {
if let ClientState::LoggedIn(state) = &mut self.state
&& let Some(msg_area) = &state.channel
{
for msg in msgs {
self.msgs.push(msg.clone());
let msg = msg_widget(msg).add(&mut self.ui);
state.msgs.push(msg.clone());
let msg = msg_widget(&msg.user, &msg.content).add(&mut self.ui);
self.ui[msg_area].children.push(msg.any());
}
}
}
ServerMsg::Login { username } => {
let ClientState::Login(state) = self.state.take() else {
panic!("invalid state");
};
state.handle.send(ClientMsg::RequestMsgs);
self.state = ClientState::LoggedIn(LoggedIn {
network: state.handle,
channel: None,
msgs: Vec::new(),
username,
});
main_view(self).set_ptr(&self.main_ui, &mut self.ui);
}
ServerMsg::Error(error) => {
let msg = format!("{error:?}");
self.ui[&self.notif].inner = Some(werror(&mut self.ui, &msg));
}
},
ClientEvent::Err(msg) => {
if let Some(err) = &self.error {
self.ui[err].inner = Some(ui::error(&mut self.ui, &msg));
}
self.ui[&self.notif].inner = Some(werror(&mut self.ui, &msg));
}
}
}
@@ -222,10 +250,7 @@ impl Client {
}
pub fn exit(&mut self) {
if let Some(handle) = self.net.take_connection() {
handle.send.send(NetCtrlMsg::Exit);
let _ = handle.thread.join();
}
self.state.exit();
self.dir.save(CLIENT_DATA, &self.data);
}
}

34
src/bin/client/net.rs
View File

@@ -19,7 +19,6 @@ pub const CLIENT_SOCKET: SocketAddr =
pub struct ConnectInfo {
pub ip: String,
pub username: String,
}
pub struct NetHandle {
@@ -27,27 +26,6 @@ pub struct NetHandle {
pub thread: JoinHandle<()>,
}
#[derive(Default)]
pub enum NetState {
#[default]
None,
Connecting(JoinHandle<()>),
Connected(NetHandle),
}
impl NetState {
pub fn take_connection(&mut self) -> Option<NetHandle> {
match self.take() {
NetState::Connected(net_handle) => Some(net_handle),
_ => None,
}
}
pub fn take(&mut self) -> Self {
std::mem::replace(self, Self::None)
}
}
pub fn connect(handle: AppHandle, info: ConnectInfo) -> JoinHandle<()> {
std::thread::spawn(move || {
if let Err(msg) = connect_the(handle.clone(), info) {
@@ -80,6 +58,17 @@ impl NetSender {
}
}
impl NetHandle {
pub fn send(&self, msg: impl Into<NetCtrlMsg>) {
self.send.send(msg.into());
}
pub fn exit(self) {
self.send(NetCtrlMsg::Exit);
let _ = self.thread.join();
}
}
// async fn connection_cert(addr: SocketAddr) -> NetResult<Connection> {
// let dirs = directories_next::ProjectDirs::from("", "", "openworm").unwrap();
// let mut roots = quinn::rustls::RootCertStore::empty();
@@ -151,7 +140,6 @@ async fn connect_the(handle: AppHandle, info: ConnectInfo) -> NetResult<()> {
let conn_ = conn.clone();
handle.send(ClientEvent::Connect {
username: info.username,
send: NetSender { send },
});

6
src/bin/client/rsc.rs
View File

@@ -1,7 +1,11 @@
pub const CLIENT_DATA: &str = "client_data";
#[derive(Default, bincode::Encode, bincode::Decode)]
#[derive(Debug, Default, bincode::Encode, bincode::Decode)]
pub struct ClientData {
pub ip: String,
pub username: String,
/// TODO: not store this as plain string?
/// need to figure out crypto stuff
/// or store session token
pub password: String,
}

51
src/bin/client/state.rs Normal file
View File

@@ -0,0 +1,51 @@
use iris::prelude::*;
use openworm::net::NetServerMsg;
use std::thread::JoinHandle;
use crate::net::NetHandle;
#[derive(Default)]
pub struct Connect {
pub handle: Option<JoinHandle<()>>,
}
pub struct Login {
pub handle: NetHandle,
}
pub struct LoggedIn {
pub network: NetHandle,
pub msgs: Vec<NetServerMsg>,
pub channel: Option<WidgetId<Span>>,
pub username: String,
}
pub enum ClientState {
Connect(Connect),
Login(Login),
LoggedIn(LoggedIn),
}
impl Default for ClientState {
fn default() -> Self {
Self::Connect(Default::default())
}
}
impl ClientState {
pub fn take(&mut self) -> Self {
std::mem::take(self)
}
pub fn exit(&mut self) {
let s = self.take();
match s {
ClientState::Connect(_) => (),
ClientState::Login(Login { handle }) => {
handle.exit();
}
ClientState::LoggedIn(state) => {
state.network.exit();
}
}
}
}

154
src/bin/client/ui/login.rs
View File

@@ -1,53 +1,65 @@
use crate::net::NetState;
use openworm::net::ClientMsg;
use crate::state::ClientState;
use super::*;
pub fn login_screen(client: &mut Client) -> WidgetId {
let Client {
ui, handle, data, ..
} = client;
pub fn field_widget(name: &str, hint_text: &str, ui: &mut Ui) -> WidgetId<TextEdit> {
wtext(name)
.editable(true)
.size(20)
.hint(hint(hint_text))
.add(ui)
}
let mut field = |name, hint_| text(name).editable(true).size(20).hint(hint(hint_)).add(ui);
let ip = field(&data.ip, "ip");
let username = field(&data.username, "username");
// let password = field("password");
pub fn field_box(field: WidgetId<TextEdit>, ui: &mut Ui) -> WidgetId {
field
.clone()
.pad(10)
.background(rect(Color::BLACK.brighter(0.1)).radius(15))
.attr::<Selector>(field)
.add(ui)
.any()
}
let fbx = |field: WidgetId<TextEdit>| {
field
.clone()
.pad(10)
.background(rect(Color::BLACK.brighter(0.1)).radius(15))
.attr::<Selector>(field)
};
// I LAV NOT HAVING ERGONOMIC CLONES
let handle = handle.clone();
let ip_ = ip.clone();
let username_ = username.clone();
pub fn submit_button(text: &str, on_submit: impl Fn(&mut Client) + 'static) -> impl WidgetRet {
let color = Color::GREEN;
let submit = rect(color)
rect(color)
.radius(15)
.id_on(CursorSense::click(), move |id, client: &mut Client, _| {
client.ui[id].color = color.darker(0.3);
let ip = client.ui[&ip_].content();
let username = client.ui[&username_].content();
let th = connect(handle.clone(), ConnectInfo { ip, username });
client.net = NetState::Connecting(th);
on_submit(client);
})
.height(40);
let modal = (
text("login").text_align(Align::CENTER).size(30),
fbx(ip
.id_on(Edited, |id, client: &mut Client, _| {
.height(40)
.foreground(wtext(text).size(20).text_align(Align::CENTER))
.to_any()
}
pub fn connect_screen(client: &mut Client) -> WidgetId {
let Client {
data, ui, handle, ..
} = client;
let ip = field_widget(&data.ip, "ip", ui);
let ip_ = ip.clone();
let handle = handle.clone();
let submit = submit_button("connect", move |client| {
let ClientState::Connect(state) = &mut client.state else {
return;
};
let ip = client.ui[&ip_].content();
state.handle = Some(connect(handle.clone(), ConnectInfo { ip }));
});
(
wtext("connect to a server")
.text_align(Align::CENTER)
.size(30),
field_box(
ip.id_on(Edited, |id, client: &mut Client, _| {
client.data.ip = client.ui[id].content();
})
.add(ui)),
fbx(username
.id_on(Edited, |id, client: &mut Client, _| {
client.data.username = client.ui[id].content();
})
.add(ui)),
// fbx(password),
.add(ui),
ui,
),
submit,
)
.span(Dir::DOWN)
@@ -55,10 +67,64 @@ pub fn login_screen(client: &mut Client) -> WidgetId {
.pad(15)
.background(rect(Color::BLACK.brighter(0.2)).radius(15))
.width(400)
.align(Align::CENTER);
let err = WidgetPtr::default().add(ui);
client.error = Some(err.clone());
(modal, err.align(Align::TOP_CENTER)).stack().add(ui).any()
.align(Align::CENTER)
.add(ui)
.any()
}
pub fn login_screen(client: &mut Client) -> WidgetId {
let Client { data, ui, .. } = client;
let username = field_widget(&data.username, "username", ui);
let password = field_widget(&data.password, "password", ui);
let username_ = username.clone();
let password_ = password.clone();
let submit = submit_button("login", move |client| {
let ClientState::Login(state) = &mut client.state else {
return;
};
let username = client.ui[&username_].content();
let password = client.ui[&password_].content();
state.handle.send(ClientMsg::Login { username, password });
});
let username_ = username.clone();
let password_ = password.clone();
let create_button = submit_button("create account", move |client| {
let ClientState::Login(state) = &mut client.state else {
return;
};
let username = client.ui[&username_].content();
let password = client.ui[&password_].content();
state
.handle
.send(ClientMsg::CreateAccount { username, password });
});
(
wtext("login to server").text_align(Align::CENTER).size(30),
field_box(
username
.id_on(Edited, |id, client: &mut Client, _| {
client.data.username = client.ui[id].content();
})
.add(ui),
ui,
),
field_box(
password
.id_on(Edited, |id, client: &mut Client, _| {
client.data.password = client.ui[id].content();
})
.add(ui),
ui,
),
submit,
create_button,
)
.span(Dir::DOWN)
.gap(10)
.pad(15)
.background(rect(Color::BLACK.brighter(0.2)).radius(15))
.width(400)
.align(Align::CENTER)
.add(ui)
.any()
}

39
src/bin/client/ui/main.rs
View File

@@ -1,9 +1,15 @@
use super::*;
use crate::state::{ClientState, LoggedIn};
use iris::layout::len_fns::*;
use openworm::net::{ClientMsg, NetClientMsg, NetServerMsg};
pub const SIZE: u32 = 20;
pub fn main_view(client: &mut Client, network: NetSender) -> WidgetId {
let msg_panel = msg_panel(client, network);
pub fn main_view(client: &mut Client) -> WidgetId {
let ClientState::LoggedIn(state) = &mut client.state else {
panic!("we ain't logged in buh");
};
let msg_panel = msg_panel(&mut client.ui, state);
let side_bar = rect(Color::BLACK.brighter(0.05)).width(80);
let bg = (
@@ -18,13 +24,13 @@ pub fn main_view(client: &mut Client, network: NetSender) -> WidgetId {
.any()
}
pub fn msg_widget(msg: NetMsg) -> impl WidgetLike<FnTag> {
let content = text(msg.content)
pub fn msg_widget(username: &str, content: &str) -> impl WidgetRet {
let content = wtext(content)
.editable(false)
.size(SIZE)
.wrap(true)
.attr::<Selectable>(());
let header = text(msg.user).size(SIZE);
let header = wtext(username).size(SIZE);
(
image(include_bytes!("../assets/sungals.png"))
.sized((70, 70))
@@ -37,14 +43,14 @@ pub fn msg_widget(msg: NetMsg) -> impl WidgetLike<FnTag> {
)
.span(Dir::RIGHT)
.gap(10)
.to_any()
}
pub fn msg_panel(client: &mut Client, network: NetSender) -> impl WidgetFn<Sized> + use<> {
let Client { ui, channel, .. } = client;
pub fn msg_panel(ui: &mut Ui, state: &mut LoggedIn) -> impl WidgetRet + use<> {
let msg_area = Span::empty(Dir::DOWN).gap(15).add(ui);
*channel = Some(msg_area.clone());
state.channel = Some(msg_area.clone());
let send_text = text("")
let send_text = wtext("")
.editable(false)
.size(SIZE)
.wrap(true)
@@ -60,13 +66,15 @@ pub fn msg_panel(client: &mut Client, network: NetSender) -> impl WidgetFn<Sized
send_text
.clone()
.id_on(Submit, move |id, client: &mut Client, _| {
let content = client.ui.text(id).take();
let msg = NetMsg {
content: content.clone(),
user: client.username.clone(),
let ClientState::LoggedIn(state) = &mut client.state else {
panic!("we ain't logged in buh");
};
network.send(ClientMsg::SendMsg(msg.clone()));
let msg = msg_widget(msg).add(&mut client.ui);
let content = client.ui.text(id).take();
let msg = NetClientMsg {
content: content.clone(),
};
state.network.send(ClientMsg::SendMsg(msg.clone()));
let msg = msg_widget(&client.data.username, &content).add(&mut client.ui);
client.ui[&msg_area].children.push(msg.any());
})
.pad(15)
@@ -80,4 +88,5 @@ pub fn msg_panel(client: &mut Client, network: NetSender) -> impl WidgetFn<Sized
)
.span(Dir::DOWN)
.width(rest(1))
.to_any()
}

8
src/bin/client/ui/misc.rs
View File

@@ -2,11 +2,11 @@ use std::time::{Duration, Instant};
use super::*;
pub fn error(ui: &mut Ui, msg: &str) -> WidgetId {
text(msg)
pub fn werror(ui: &mut Ui, msg: &str) -> WidgetId {
wtext(msg)
.size(20)
.color(Color::RED.brighter(0.3))
.pad(10)
.background(rect(Color::RED).radius(10))
.add(ui)
.any()
}
@@ -69,5 +69,5 @@ fn select(id: WidgetId<TextEdit>, client: &mut Client, data: CursorData) {
}
pub fn hint(msg: impl Into<String>) -> TextBuilder {
text(msg).size(20).color(Color::GRAY)
wtext(msg).size(20).color(Color::GRAY)
}

10
src/bin/client/ui/mod.rs
View File

@@ -1,16 +1,14 @@
use crate::{
Client,
net::{ConnectInfo, NetSender, connect},
ui::login::login_screen,
net::{ConnectInfo, connect},
};
use iris::prelude::*;
use len_fns::*;
use openworm::net::{ClientMsg, NetMsg};
use winit::dpi::{LogicalPosition, LogicalSize};
mod login;
mod main;
mod misc;
pub use login::*;
pub use main::*;
pub use misc::*;
@@ -27,7 +25,3 @@ impl DefaultEvent for Submit {
impl DefaultEvent for Edited {
type Data = ();
}
pub fn init(client: &mut Client) {
login_screen(client).set_root(&mut client.ui);
}

134
src/bin/server/db.rs
View File

@@ -1,11 +1,90 @@
use std::path::Path;
use std::{
marker::PhantomData,
ops::{Deref, DerefMut},
path::Path,
};
use bincode::{Decode, Encode};
use openworm::net::BINCODE_CONFIG;
use sled::{Db, Tree};
use sled::Tree;
pub const DB_VERSION: u64 = 0;
#[derive(Encode, Decode)]
pub struct User {
pub username: String,
pub password_hash: String,
}
#[derive(Clone, Encode, Decode)]
pub struct Msg {
pub user: u64,
pub content: String,
}
#[derive(Clone)]
pub struct Db {
pub db: sled::Db,
pub msgs: DbMap<u64, Msg>,
pub users: DbMap<u64, User>,
pub usernames: DbMap<String, u64>,
}
pub struct DbMap<K, V> {
tree: Tree,
_pd: PhantomData<(K, V)>,
}
pub trait Key {
type Output<'a>: AsRef<[u8]>
where
Self: 'a;
fn bytes(&self) -> Self::Output<'_>;
}
impl Key for String {
type Output<'a> = &'a Self;
fn bytes(&self) -> Self::Output<'_> {
self
}
}
impl Key for str {
type Output<'a> = &'a Self;
fn bytes(&self) -> Self::Output<'_> {
self
}
}
impl Key for u64 {
type Output<'a> = [u8; 8];
fn bytes(&self) -> Self::Output<'_> {
self.to_be_bytes()
}
}
impl<K: Key, V: Encode + Decode<()>> DbMap<K, V> {
pub fn insert(&self, k: &K, v: &V) {
self.tree.insert_(k, v);
}
pub fn get(&self, k: &K) -> Option<V> {
self.tree.get_(k)
}
pub fn init_unique(&self, k: &K) -> bool {
self.tree
.compare_and_swap(k.bytes(), None as Option<&[u8]>, Some(&[0]))
.unwrap()
.is_ok()
}
pub fn iter_all(&self) -> impl Iterator<Item = V> {
self.tree.iter_all()
}
}
pub fn open_db(path: impl AsRef<Path>) -> Db {
let db = sled::open(path).expect("failed to open database");
if !db.was_recovered() {
@@ -19,23 +98,28 @@ pub fn open_db(path: impl AsRef<Path>) -> Db {
panic!("non matching db version! (auto update in the future)");
}
}
db
Db {
msgs: open_tree("msg", &db),
users: open_tree("user", &db),
usernames: open_tree("username", &db),
db,
}
}
pub trait DbUtil {
fn insert_<K: AsRef<[u8]>, V: Encode>(&self, k: K, v: V);
fn get_<K: AsRef<[u8]>, V: Decode<()>>(&self, k: K) -> Option<V>;
trait DbUtil {
fn insert_<V: Encode>(&self, k: &(impl Key + ?Sized), v: V);
fn get_<V: Decode<()>>(&self, k: &(impl Key + ?Sized)) -> Option<V>;
fn iter_all<V: Decode<()>>(&self) -> impl Iterator<Item = V>;
}
impl DbUtil for Tree {
fn insert_<K: AsRef<[u8]>, V: Encode>(&self, k: K, v: V) {
fn insert_<V: Encode>(&self, k: &(impl Key + ?Sized), v: V) {
let bytes = bincode::encode_to_vec(v, BINCODE_CONFIG).unwrap();
self.insert(k, bytes).unwrap();
self.insert(k.bytes(), bytes).unwrap();
}
fn get_<K: AsRef<[u8]>, V: Decode<()>>(&self, k: K) -> Option<V> {
let bytes = self.get(k).unwrap()?;
fn get_<V: Decode<()>>(&self, k: &(impl Key + ?Sized)) -> Option<V> {
let bytes = self.get(k.bytes()).unwrap()?;
Some(
bincode::decode_from_slice(&bytes, BINCODE_CONFIG)
.unwrap()
@@ -51,3 +135,33 @@ impl DbUtil for Tree {
})
}
}
pub fn open_tree<K, V>(name: &str, db: &sled::Db) -> DbMap<K, V> {
DbMap {
tree: db.open_tree(name).unwrap(),
_pd: PhantomData,
}
}
impl Deref for Db {
type Target = sled::Db;
fn deref(&self) -> &Self::Target {
&self.db
}
}
impl DerefMut for Db {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.db
}
}
impl<K, V> Clone for DbMap<K, V> {
fn clone(&self) -> Self {
Self {
tree: self.tree.clone(),
_pd: self._pd.clone(),
}
}
}

115
src/bin/server/main.rs
View File

@@ -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(_))
}
}

3
src/bin/server/net.rs
View File

@@ -62,7 +62,8 @@ impl ClientSender {
pub fn remote(&self) -> SocketAddr {
self.conn.remote_address()
}
pub async fn send(&self, msg: ServerMsg) -> SendResult {
pub async fn send(&self, msg: impl Into<ServerMsg>) -> SendResult {
let msg = msg.into();
send_uni(&self.conn, msg).await
}
}

37
src/net/mod.rs
View File

@@ -11,24 +11,53 @@ pub const BINCODE_CONFIG: Configuration = bincode::config::standard();
#[derive(Debug, bincode::Encode, bincode::Decode)]
pub enum ClientMsg {
SendMsg(NetMsg),
SendMsg(NetClientMsg),
RequestMsgs,
CreateAccount { username: String, password: String },
Login { username: String, password: String },
}
#[derive(Debug, bincode::Encode, bincode::Decode)]
pub enum ServerMsg {
SendMsg(NetMsg),
LoadMsgs(Vec<NetMsg>),
SendMsg(NetServerMsg),
LoadMsgs(Vec<NetServerMsg>),
Login { username: String },
Error(ServerError),
}
#[derive(Debug, bincode::Encode, bincode::Decode)]
pub enum ServerError {
NotLoggedIn,
UnknownUsername,
InvalidPassword,
UsernameTaken,
}
impl From<ServerError> for ServerMsg {
fn from(value: ServerError) -> Self {
Self::Error(value)
}
}
pub type ServerResp<T> = Result<T, String>;
#[derive(Debug, Clone, bincode::Encode, bincode::Decode)]
pub struct NetMsg {
pub struct NetClientMsg {
pub content: String,
}
#[derive(Debug, Clone, bincode::Encode, bincode::Decode)]
pub struct NetServerMsg {
pub content: String,
pub user: String,
}
impl From<NetServerMsg> for ServerMsg {
fn from(value: NetServerMsg) -> Self {
Self::SendMsg(value)
}
}
pub fn install_crypto_provider() {
quinn::rustls::crypto::ring::default_provider()
.install_default()