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

work

Browse Source
This commit is contained in:
Shadow Cat
2026-01-26 13:53:51 -05:00
parent e1eff49be9
commit 53ed4775ae
19 changed files with 565 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/bin/client/data.rs
View File

@@ -1,9 +1,7 @@
use ed25519_dalek::SigningKey;
use openworm::{
net::LoginKey,
rsc::{DataDir, DataRsc},
};
use rand::{TryRngCore, rngs::OsRng};
pub struct ClientData {
pub dir: DataDir,
@@ -26,16 +24,14 @@ impl ClientData {
pub fn login_key(&self, user: &str) -> LoginKey {
let entry = keyring::Entry::new("openworm", user).expect("failed to open keyring entry");
if let Ok(secret) = entry.get_secret() {
secret
.try_into()
.expect("failed to load key from secrets (invalid format)")
LoginKey::from(secret)
} else {
LoginKey::new()
}
}
}
#[derive(Debug, Default, bincode::Encode, bincode::Decode)]
#[derive(Debug, Default, bitcode::Encode, bitcode::Decode)]
pub struct Cache {
pub ip: String,
pub username: String,

23
src/bin/client/debug.rs
View File

@@ -1,31 +1,8 @@
use crate::{Client, Rsc};
use iris::core::UiRenderState;
use openworm::net::NetServerMsg;
impl Client {
pub fn debug(&mut self, _rsc: &mut Rsc, render: &mut UiRenderState) {
render.debug_layers();
// let mut file = std::fs::OpenOptions::new()
// .write(true)
// .create(true)
// .truncate(true)
// .open("./old_msgs")
// .unwrap();
// bincode::encode_into_std_write(
// self.msgs.clone(),
// &mut file,
// openworm::net::BINCODE_CONFIG,
// )
// .unwrap();
let mut file = std::fs::OpenOptions::new()
.read(true)
.open("/home/bryan/.local/share/openworm/old_msgs")
.unwrap();
let msgs: Vec<NetServerMsg> =
bincode::decode_from_std_read(&mut file, openworm::net::BINCODE_CONFIG).unwrap();
for msg in msgs {
println!("{msg:?}");
}
// client.ui.debug_layers();
}
}

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

@@ -1,11 +1,9 @@
#![feature(async_fn_traits)]
#![windows_subsystem = "windows"]
use crate::{
data::ClientData,
state::{ClientState, LoggedIn},
};
use crate::{data::ClientData, state::ClientState};
use iris::prelude::*;
use openworm::net::{ClientMsg, ServerMsg, install_crypto_provider};
use openworm::net::{ServerMsg, install_crypto_provider};
use winit::{
event::{ElementState, MouseButton, WindowEvent},
window::WindowAttributes,
@@ -83,44 +81,7 @@ impl DefaultAppState for Client {
_render: &mut UiRenderState,
) {
match event {
ClientEvent::ServerMsg(msg) => match msg {
ServerMsg::SendMsg(msg) => {
if let ClientState::LoggedIn(state) = &mut self.state
&& let Some(msg_area) = state.channel
{
let msg = ui::msg_widget(&msg.user, &msg.content).add_strong(rsc);
rsc[msg_area].children.push(msg);
}
}
ServerMsg::LoadMsgs(msgs) => {
if let ClientState::LoggedIn(state) = &mut self.state
&& let Some(msg_area) = state.channel
{
for msg in msgs {
state.msgs.push(msg.clone());
let msg = ui::msg_widget(&msg.user, &msg.content).add_strong(rsc);
rsc[msg_area].children.push(msg);
}
}
}
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,
});
ui::main_view(rsc).set_ptr(self.main_ui, rsc);
}
ServerMsg::Error(error) => {
let msg = format!("{error:?}");
rsc[self.notif].inner = Some(ui::werror(&msg, rsc));
}
},
ClientEvent::ServerMsg(_) => {}
ClientEvent::Err(msg) => {
rsc[self.notif].inner = Some(ui::werror(&msg, rsc));
}

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

@@ -1,6 +1,8 @@
use crate::ClientEvent;
use dashmap::DashMap;
use openworm::net::{
ClientMsg, RecvHandler, SERVER_NAME, ServerMsg, SkipServerVerification, recv_uni, send_uni,
AccountCreated, ClientMsg, ClientMsgInst, CreateAccount, RecvHandler, RequestId, SERVER_NAME,
ServerMsg, ServerRespMsg, SkipServerVerification, recv_uni, send_uni,
};
use quinn::{
ClientConfig, Connection, Endpoint, IdleTimeout, TransportConfig,
@@ -38,25 +40,53 @@ impl AppHandle {
type NetResult<T> = Result<T, String>;
pub trait ClientRequest {}
pub enum NetCtrlMsg {
Exchange(ClientMsg, oneshot::Sender<>),
Send(ClientMsg),
Request(ClientMsg, oneshot::Sender<ServerMsg>),
Exit,
}
impl From<ClientMsg> for NetCtrlMsg {
fn from(value: ClientMsg) -> Self {
Self::Send(value)
}
}
impl NetHandle {
pub fn send(&self, msg: impl Into<NetCtrlMsg>) {
self.send.send(msg.into());
fn send_(&self, msg: NetCtrlMsg) {
let _ = self.send.send(msg);
}
pub fn send(&self, msg: impl Into<ClientMsg>) {
self.send_(NetCtrlMsg::Send(msg.into()));
}
pub async fn request<R: RequestMsg>(&self, msg: R) -> Result<R::Result, ()> {
let (send, recv) = oneshot::channel();
self.send_(NetCtrlMsg::Request(msg.into(), send));
let Ok(recv) = recv.await else { todo!() };
if let Some(res) = R::result(recv) {
Ok(res)
} else {
todo!()
}
}
pub fn exit(self) {
self.send(NetCtrlMsg::Exit);
self.send_(NetCtrlMsg::Exit);
}
}
pub trait RequestMsg: Into<ClientMsg> {
type Result;
fn result(msg: ServerMsg) -> Option<Self::Result>;
}
impl RequestMsg for CreateAccount {
type Result = AccountCreated;
fn result(msg: ServerMsg) -> Option<Self::Result> {
if let ServerMsg::AccountCreated(res) = msg {
Some(res)
} else {
None
}
}
}
@@ -129,12 +159,25 @@ pub async fn connect(msg: impl MsgHandler, info: ConnectInfo) -> Result<NetHandl
let (endpoint, conn) = connection_no_cert(addr).await?;
let conn_ = conn.clone();
let recv = ServerRecv { msg };
tokio::spawn(recv_uni(conn_, recv.into()));
let mut req_id = RequestId::first();
let recv = Arc::new(ServerRecv {
msg,
requests: DashMap::default(),
});
tokio::spawn(recv_uni(conn_, recv.clone()));
tokio::spawn(async move {
while let Some(msg) = ui_recv.recv().await {
match msg {
NetCtrlMsg::Send(msg) => {
let msg = ClientMsgInst::from(msg);
if send_uni(&conn, msg).await.is_err() {
println!("disconnected from server");
break;
}
}
NetCtrlMsg::Request(msg, send) => {
let msg = ClientMsgInst::from(msg);
recv.requests.insert(req_id.next(), send);
if send_uni(&conn, msg).await.is_err() {
println!("disconnected from server");
break;
@@ -155,18 +198,29 @@ pub async fn connect(msg: impl MsgHandler, info: ConnectInfo) -> Result<NetHandl
pub trait MsgHandler: Sync + Send + 'static {
fn run(&self, msg: ServerMsg) -> impl Future<Output = ()> + Send;
}
impl<F: AsyncFn(ServerMsg) + Sync + Send + 'static> MsgHandler for F {
impl<F: AsyncFn(ServerMsg) + Sync + Send + 'static> MsgHandler for F
where
for<'a> F::CallRefFuture<'a>: Send,
{
async fn run(&self, msg: ServerMsg) {
self(msg);
self(msg).await;
}
}
struct ServerRecv<F: MsgHandler> {
requests: DashMap<RequestId, oneshot::Sender<ServerMsg>>,
msg: F,
}
impl<F: MsgHandler> RecvHandler<ServerMsg> for ServerRecv<F> {
async fn msg(&self, msg: ServerMsg) {
self.msg.run(msg).await;
impl<F: MsgHandler> RecvHandler<ServerRespMsg> for ServerRecv<F> {
async fn msg(&self, resp: ServerRespMsg) {
let msg = resp.msg.into();
if let Some(id) = resp.request_id
&& let Some((_, send)) = self.requests.remove(&id)
{
send.send(msg);
} else {
self.msg.run(msg).await;
}
}
}

4
src/bin/client/state.rs
View File

@@ -1,6 +1,6 @@
use crate::net::NetHandle;
use iris::prelude::*;
use openworm::net::NetServerMsg;
use openworm::net::LoadMsg;
use std::thread::JoinHandle;
#[derive(Default)]
@@ -14,7 +14,7 @@ pub struct Login {
pub struct LoggedIn {
pub network: NetHandle,
pub msgs: Vec<NetServerMsg>,
pub msgs: Vec<LoadMsg>,
pub channel: Option<WeakWidget<Span>>,
pub username: String,
}

34
src/bin/client/ui/connect.rs
View File

@@ -1,3 +1,5 @@
use openworm::net::CreateAccount;
use crate::net::{self, ConnectInfo};
use super::*;
@@ -43,19 +45,39 @@ pub fn create_account(rsc: &mut Rsc) -> WeakWidget {
let create = Button::submit("create", rsc);
rsc.events.register(create, Submit, move |ctx, rsc| {
create.disable(rsc);
let url = rsc[url].content();
let user = rsc[username].content();
let pwd = rsc[password].content();
let key = ctx.state.data.login_key(&user);
rsc.spawn_task(async |ctx| {
let net = net::connect(
let username = rsc[username].content();
let password = rsc[password].content();
let login_key = ctx.state.data.login_key(&username);
rsc.spawn_task(async move |mut ctx| {
let mut fail = move |reason| {
ctx.update(move |ctx, rsc| {
rsc[ctx.notif].inner = Some(werror(reason, rsc));
create.enable(rsc);
})
};
let Ok(net) = net::connect(
async |msg| {
println!("msg recv :joy:");
},
ConnectInfo { url },
)
.await
.expect("failed to connect");
else {
return fail("failed to connect");
};
let Ok(resp) = net
.request(CreateAccount {
username,
password,
login_key,
})
.await
else {
return fail("failed to create account");
};
});
});

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

@@ -84,6 +84,11 @@ impl Button {
rsc[self.enabled] = false;
rsc[self.rect].color = self.color.darker(0.8);
}
pub fn enable(&self, rsc: &mut Rsc) {
rsc[self.enabled] = true;
rsc[self.rect].color = self.color;
}
}
widget_trait! {

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

@@ -4,9 +4,7 @@ use std::{
path::Path,
};
use bincode::{Decode, Encode};
use openworm::net::BINCODE_CONFIG;
use sled::Tree;
use bitcode::{Decode, DecodeOwned, Encode};
pub const DB_VERSION: u64 = 0;
@@ -24,14 +22,14 @@ pub struct Msg {
#[derive(Clone)]
pub struct Db {
pub db: sled::Db,
pub db: fjall::Database,
pub msgs: DbMap<u64, Msg>,
pub users: DbMap<u64, User>,
pub usernames: DbMap<String, u64>,
}
pub struct DbMap<K, V> {
tree: Tree,
tree: fjall::Tree,
_pd: PhantomData<(K, V)>,
}
@@ -64,7 +62,7 @@ impl Key for u64 {
}
}
impl<K: Key, V: Encode + Decode<()>> DbMap<K, V> {
impl<K: Key, V: Encode + DecodeOwned> DbMap<K, V> {
pub fn insert(&self, k: &K, v: &V) {
self.tree.insert_(k, v);
}
@@ -108,13 +106,13 @@ pub fn open_db(path: impl AsRef<Path>) -> Db {
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>;
fn get_<V: DecodeOwned>(&self, k: &(impl Key + ?Sized)) -> Option<V>;
fn iter_all<V: DecodeOwned>(&self) -> impl Iterator<Item = V>;
}
impl DbUtil for Tree {
fn insert_<V: Encode>(&self, k: &(impl Key + ?Sized), v: V) {
let bytes = bincode::encode_to_vec(v, BINCODE_CONFIG).unwrap();
fn insert_<V: Encode>(&self, k: &(impl Key + ?Sized), v: &V) {
let bytes = bitcode::encode(v);
self.insert(k.bytes(), bytes).unwrap();
}

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

@@ -7,14 +7,14 @@ use clap::Parser;
use net::{ClientSender, ConAccepter, listen};
use openworm::{
net::{
ClientMsg, DisconnectReason, NetServerMsg, RecvHandler, ServerError, ServerMsg,
install_crypto_provider,
ClientMsg, ClientMsgInst, CreateAccount, DisconnectReason, LoadMsg, RecvHandler,
ServerError, ServerMsg, install_crypto_provider,
},
rsc::DataDir,
};
use scrypt::{
Scrypt,
password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString, rand_core::OsRng},
password_hash::{PasswordHasher, SaltString, rand_core::OsRng},
};
use std::{
collections::HashMap,
@@ -76,7 +76,7 @@ pub enum ClientState {
}
impl ConAccepter for ServerListener {
async fn accept(&self, send: ClientSender) -> impl RecvHandler<ClientMsg> {
async fn accept(&self, send: ClientSender) -> impl RecvHandler<ClientMsgInst> {
let id = self.count.fetch_add(1, Ordering::Release);
self.senders.write().await.insert(id, send.clone());
ClientHandler {
@@ -97,11 +97,12 @@ struct ClientHandler {
state: Arc<RwLock<ClientState>>,
}
impl RecvHandler<ClientMsg> for ClientHandler {
impl RecvHandler<ClientMsgInst> for ClientHandler {
async fn connect(&self) -> () {
println!("connected: {:?}", self.send.remote().ip());
}
async fn msg(&self, msg: ClientMsg) {
async fn msg(&self, msg: ClientMsgInst) {
let msg = ClientMsg::from(msg);
match msg {
ClientMsg::SendMsg(msg) => {
let ClientState::Authed(uid) = &*self.state.read().await else {
@@ -116,7 +117,7 @@ impl RecvHandler<ClientMsg> for ClientHandler {
self.db.msgs.insert(&id, &msg);
let mut handles = Vec::new();
let user: User = self.db.users.get(uid).unwrap();
let msg = NetServerMsg {
let msg = LoadMsg {
content: msg.content,
user: user.username,
};
@@ -151,7 +152,7 @@ impl RecvHandler<ClientMsg> for ClientHandler {
.get(&msg.user)
.map(|user| user.username.to_string())
.unwrap_or("deleted user".to_string());
NetServerMsg {
LoadMsg {
content: msg.content,
user,
}
@@ -159,8 +160,13 @@ impl RecvHandler<ClientMsg> for ClientHandler {
.collect();
let _ = self.send.send(ServerMsg::LoadMsgs(msgs)).await;
}
ClientMsg::CreateAccount { username, password } => {
if !self.db.usernames.init_unique(&username) {
ClientMsg::CreateAccount(info) => {
let CreateAccount {
username,
password,
login_key,
} = &info;
if !self.db.usernames.init_unique(username) {
let _ = self.send.send(ServerError::UsernameTaken).await;
return;
}
@@ -181,26 +187,25 @@ impl RecvHandler<ClientMsg> for ClientHandler {
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;
}
// let _ = self.send.send(ServerMsg::Login()).await;
} // ClientMsgType::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(ServerMsgType::Login { username }).await;
// }
}
}

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

@@ -1,5 +1,6 @@
use openworm::net::{
ClientMsg, RecvHandler, SERVER_NAME, SendResult, ServerMsg, recv_uni, send_uni,
ClientMsg, ClientMsgInst, RecvHandler, SERVER_NAME, SendResult, ServerMsg, ServerMsgInst,
recv_uni, send_uni,
};
use quinn::{
Connection, Endpoint, ServerConfig,
@@ -63,7 +64,7 @@ impl ClientSender {
self.conn.remote_address()
}
pub async fn send(&self, msg: impl Into<ServerMsg>) -> SendResult {
let msg = msg.into();
let msg = ServerMsgInst::from(msg.into());
send_uni(&self.conn, msg).await
}
}
@@ -72,7 +73,7 @@ pub trait ConAccepter: Send + Sync + 'static {
fn accept(
&self,
send: ClientSender,
) -> impl Future<Output = impl RecvHandler<ClientMsg>> + Send;
) -> impl Future<Output = impl RecvHandler<ClientMsgInst>> + Send;
}
pub fn listen(