From 2211f324782cdc617b4b5ecd071178e372539fe4 Mon Sep 17 00:00:00 2001 From: cel 🌸 Date: Wed, 26 Mar 2025 14:29:40 +0000 Subject: refactor: rename crates and move client logic to separate crate `filament` --- .helix/languages.toml | 2 +- Cargo.toml | 4 +- filamento/Cargo.toml | 17 + filamento/README.md | 3 + filamento/filamento.db | Bin 0 -> 90112 bytes filamento/migrations/20240113011930_luz.sql | 119 ++ filamento/src/chat.rs | 57 + filamento/src/db.rs | 521 ++++++++ filamento/src/error.rs | 142 ++ filamento/src/lib.rs | 1598 ++++++++++++++++++++++ filamento/src/presence.rs | 151 +++ filamento/src/roster.rs | 127 ++ filamento/src/user.rs | 7 + jabber/Cargo.lock | 1935 --------------------------- jabber/Cargo.toml | 42 - jabber/src/client.rs | 181 --- jabber/src/connection.rs | 182 --- jabber/src/error.rs | 58 - jabber/src/jabber_stream.rs | 482 ------- jabber/src/jabber_stream/bound_stream.rs | 87 -- jabber/src/lib.rs | 25 - lampada/.gitignore | 2 + lampada/Cargo.toml | 17 + lampada/README.md | 3 + lampada/scratch | 90 ++ lampada/src/connection/mod.rs | 374 ++++++ lampada/src/connection/read.rs | 233 ++++ lampada/src/connection/write.rs | 258 ++++ lampada/src/error.rs | 82 ++ lampada/src/lib.rs | 238 ++++ lampada/src/main.rs | 42 + luz/.gitignore | 2 - luz/Cargo.lock | 1935 +++++++++++++++++++++++++++ luz/Cargo.toml | 46 +- luz/migrations/20240113011930_luz.sql | 119 -- luz/scratch | 87 -- luz/src/chat.rs | 57 - luz/src/client.rs | 181 +++ luz/src/connection.rs | 182 +++ luz/src/connection/mod.rs | 373 ------ luz/src/connection/read.rs | 242 ---- luz/src/connection/write.rs | 258 ---- luz/src/db/mod.rs | 521 -------- luz/src/error.rs | 246 +--- luz/src/jabber_stream.rs | 482 +++++++ luz/src/jabber_stream/bound_stream.rs | 87 ++ luz/src/lib.rs | 1785 +----------------------- luz/src/main.rs | 42 - luz/src/presence.rs | 151 --- luz/src/roster.rs | 127 -- luz/src/user.rs | 7 - 51 files changed, 7048 insertions(+), 6961 deletions(-) create mode 100644 filamento/Cargo.toml create mode 100644 filamento/README.md create mode 100644 filamento/filamento.db create mode 100644 filamento/migrations/20240113011930_luz.sql create mode 100644 filamento/src/chat.rs create mode 100644 filamento/src/db.rs create mode 100644 filamento/src/error.rs create mode 100644 filamento/src/lib.rs create mode 100644 filamento/src/presence.rs create mode 100644 filamento/src/roster.rs create mode 100644 filamento/src/user.rs delete mode 100644 jabber/Cargo.lock delete mode 100644 jabber/Cargo.toml delete mode 100644 jabber/src/client.rs delete mode 100644 jabber/src/connection.rs delete mode 100644 jabber/src/error.rs delete mode 100644 jabber/src/jabber_stream.rs delete mode 100644 jabber/src/jabber_stream/bound_stream.rs delete mode 100644 jabber/src/lib.rs create mode 100644 lampada/.gitignore create mode 100644 lampada/Cargo.toml create mode 100644 lampada/README.md create mode 100644 lampada/scratch create mode 100644 lampada/src/connection/mod.rs create mode 100644 lampada/src/connection/read.rs create mode 100644 lampada/src/connection/write.rs create mode 100644 lampada/src/error.rs create mode 100644 lampada/src/lib.rs create mode 100644 lampada/src/main.rs delete mode 100644 luz/.gitignore create mode 100644 luz/Cargo.lock delete mode 100644 luz/migrations/20240113011930_luz.sql delete mode 100644 luz/scratch delete mode 100644 luz/src/chat.rs create mode 100644 luz/src/client.rs create mode 100644 luz/src/connection.rs delete mode 100644 luz/src/connection/mod.rs delete mode 100644 luz/src/connection/read.rs delete mode 100644 luz/src/connection/write.rs delete mode 100644 luz/src/db/mod.rs create mode 100644 luz/src/jabber_stream.rs create mode 100644 luz/src/jabber_stream/bound_stream.rs delete mode 100644 luz/src/main.rs delete mode 100644 luz/src/presence.rs delete mode 100644 luz/src/roster.rs delete mode 100644 luz/src/user.rs diff --git a/.helix/languages.toml b/.helix/languages.toml index 9e34dc3..ad628c8 100644 --- a/.helix/languages.toml +++ b/.helix/languages.toml @@ -1,4 +1,4 @@ [language-server.rust-analyzer] command = "rust-analyzer" -environment = { "DATABASE_URL" = "sqlite://luz/luz.db" } +environment = { "DATABASE_URL" = "sqlite://filamento/filamento.db" } config = { cargo.features = "all" } diff --git a/Cargo.toml b/Cargo.toml index f3137ce..a9daa7a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,6 +3,6 @@ resolver = "2" members = [ "luz", - "jabber", - "stanza", "jid", + "lampada", + "stanza", "jid", "filamento", ] diff --git a/filamento/Cargo.toml b/filamento/Cargo.toml new file mode 100644 index 0000000..e25024a --- /dev/null +++ b/filamento/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "filamento" +version = "0.1.0" +edition = "2024" + +[dependencies] +futures = "0.3.31" +lampada = { version = "0.1.0", path = "../lampada" } +tokio = "1.42.0" +thiserror = "2.0.11" +stanza = { version = "0.1.0", path = "../stanza", features = ["xep_0203"] } +sqlx = { version = "0.8.3", features = ["sqlite", "runtime-tokio", "uuid", "chrono"] } +# TODO: re-export jid? +jid = { version = "0.1.0", path = "../jid", features = ["sqlx"] } +uuid = { version = "1.13.1", features = ["v4"] } +tracing = "0.1.41" +chrono = "0.4.40" diff --git a/filamento/README.md b/filamento/README.md new file mode 100644 index 0000000..57b4135 --- /dev/null +++ b/filamento/README.md @@ -0,0 +1,3 @@ +# filament + +a high-level xmpp chat client using luz diff --git a/filamento/filamento.db b/filamento/filamento.db new file mode 100644 index 0000000..5c3c720 Binary files /dev/null and b/filamento/filamento.db differ diff --git a/filamento/migrations/20240113011930_luz.sql b/filamento/migrations/20240113011930_luz.sql new file mode 100644 index 0000000..148598b --- /dev/null +++ b/filamento/migrations/20240113011930_luz.sql @@ -0,0 +1,119 @@ +PRAGMA foreign_keys = on; + +-- a user jid will never change, only a chat user will change +-- TODO: avatar, nick, etc. +create table users( + -- TODO: enforce bare jid + jid text primary key not null, + -- can receive presence status from non-contacts + cached_status_message text + -- TODO: last_seen +); + +-- -- links to messages, jabber users, stores jid history, etc. +-- create table identities( +-- id text primary key not null +-- ); + +-- create table identities_users( +-- id text not null, +-- jid text not null, +-- -- whichever has the newest timestamp is the active one. +-- -- what to do when somebody moves, but then the old jid is used again without having explicitly moved back? create new identity to assign ownership to? +-- -- merging of identities? +-- activated_timestamp not null, +-- foreign key(id) references identities(id), +-- foreign key(jid) references users(jid), +-- primary key(activated timestamp, id, jid) +-- ); + +create table resources( + bare_jid text not null, + resource text not null, + foreign key(bare_jid) references users(jid), + primary key(bare_jid, resource) +); + +-- enum for subscription state +create table subscription( + state text primary key not null +); + +insert into subscription ( state ) values ('none'), ('pending-out'), ('pending-in'), ('pending-in-pending-out'), ('only-out'), ('only-in'), ('out-pending-in'), ('in-pending-out'), ('buddy'); + +-- a roster contains users, with client-set nickname +CREATE TABLE roster( + user_jid text primary key not null, + name TEXT, + subscription text not null, + foreign key(subscription) references subscription(state), + foreign key(user_jid) references users(jid) +); + +create table groups( + group_name text primary key not null +); + +create table groups_roster( + group_name text not null, + contact_jid text not null, + foreign key(group_name) references groups(group_name), + foreign key(contact_jid) references roster(user_jid) on delete cascade, + primary key(group_name, contact_jid) +); + +-- chat includes reference to user jid chat is with +-- specifically for dms, groups should be different +-- can send chat message to user (creating a new chat if not already exists) +create table chats ( + id text primary key not null, + correspondent text not null unique, + foreign key(correspondent) references users(jid) +); + +-- messages include reference to chat they are in, and who sent them. +create table messages ( + id text primary key not null, + body text, + chat_id text not null, + -- TODO: channel stuff + -- channel_id uuid, + -- check ((chat_id == null) <> (channel_id == null)), + -- check ((chat_id == null) or (channel_id == null)), + -- user is the current "owner" of the message + -- TODO: queued messages offline + -- TODO: timestamp + timestamp text not null, + + -- TODO: icky + -- the user to show it coming from (not necessarily the original sender) + -- from_identity text not null, + -- original sender details (only from jabber supported for now) + from_jid text not null, + -- resource can be null + from_resource text, + -- check (from_jid != original_sender), + + -- TODO: from can be either a jid, a moved jid (for when a contact moves, save original sender jid/user but link to new user), or imported (from another service (save details), linked to new user) + -- TODO: read bool not null, + foreign key(chat_id) references chats(id) on delete cascade, + -- foreign key(from_identity) references identities(id), + foreign key(from_jid) references users(jid), + foreign key(from_jid, from_resource) references resources(bare_jid, resource) +); + +-- enum for subscription state +create table show ( + state text primary key not null +); + +insert into show ( state ) values ('away'), ('chat'), ('do-not-disturb'), ('extended-away'); + +create table cached_status ( + id integer primary key not null, + show text, + message text, + foreign key(show) references show(state) +); + +insert into cached_status (id) values (0); diff --git a/filamento/src/chat.rs b/filamento/src/chat.rs new file mode 100644 index 0000000..c1194ea --- /dev/null +++ b/filamento/src/chat.rs @@ -0,0 +1,57 @@ +use chrono::{DateTime, Utc}; +use jid::JID; +use uuid::Uuid; + +#[derive(Debug, sqlx::FromRow, Clone)] +pub struct Message { + pub id: Uuid, + // does not contain full user information + #[sqlx(rename = "from_jid")] + pub from: JID, + pub timestamp: DateTime, + // TODO: originally_from + // TODO: message edits + // TODO: message timestamp + #[sqlx(flatten)] + pub body: Body, +} + +// TODO: user migrations +// pub enum Migrated { +// Jabber(User), +// Outside, +// } + +#[derive(Debug, sqlx::FromRow, Clone)] +pub struct Body { + // TODO: rich text, other contents, threads + pub body: String, +} + +#[derive(sqlx::FromRow, Debug, Clone)] +pub struct Chat { + pub correspondent: JID, + // pub unread_messages: i32, + // pub latest_message: Message, + // when a new message is received, the chat should be updated, and the new message should be delivered too. + // message history is not stored in chat, retreived separately. + // pub message_history: Vec, +} + +pub enum ChatUpdate {} + +impl Chat { + pub fn new(correspondent: JID) -> Self { + Self { correspondent } + } + pub fn correspondent(&self) -> &JID { + &self.correspondent + } +} + +// TODO: group chats +// pub enum Chat { +// Direct(DirectChat), +// Channel(Channel), +// } +// pub struct Channel {} diff --git a/filamento/src/db.rs b/filamento/src/db.rs new file mode 100644 index 0000000..aea40ac --- /dev/null +++ b/filamento/src/db.rs @@ -0,0 +1,521 @@ +use std::{collections::HashSet, path::Path}; + +use jid::JID; +use sqlx::{migrate, Error, SqlitePool}; +use uuid::Uuid; + +use crate::{ + chat::{Chat, Message}, + error::{DatabaseError, DatabaseOpenError}, + presence::Online, + roster::Contact, + user::User, +}; + +#[derive(Clone)] +pub struct Db { + db: SqlitePool, +} + +// TODO: turn into trait +impl Db { + pub async fn create_connect_and_migrate( + path: impl AsRef, + ) -> Result { + if let Some(dir) = path.as_ref().parent() { + if dir.is_dir() { + } else { + tokio::fs::create_dir_all(dir).await?; + } + let _file = tokio::fs::OpenOptions::new() + .append(true) + .create(true) + .open(path.as_ref()) + .await?; + } + let url = format!( + "sqlite://{}", + path.as_ref() + .to_str() + .ok_or(DatabaseOpenError::InvalidPath)? + ); + let db = SqlitePool::connect(&url).await?; + migrate!().run(&db).await?; + Ok(Self { db }) + } + + pub(crate) fn new(db: SqlitePool) -> Self { + Self { db } + } + + pub(crate) async fn create_user(&self, user: User) -> Result<(), Error> { + sqlx::query!( + "insert into users ( jid, cached_status_message ) values ( ?, ? )", + user.jid, + user.cached_status_message + ) + .execute(&self.db) + .await?; + Ok(()) + } + + pub(crate) async fn read_user(&self, user: JID) -> Result { + let user: User = sqlx::query_as("select * from users where jid = ?") + .bind(user) + .fetch_one(&self.db) + .await?; + Ok(user) + } + + pub(crate) async fn update_user(&self, user: User) -> Result<(), Error> { + sqlx::query!( + "update users set cached_status_message = ? where jid = ?", + user.cached_status_message, + user.jid + ) + .execute(&self.db) + .await?; + Ok(()) + } + + // TODO: should this be allowed? messages need to reference users. should probably only allow delete if every other thing referencing it has been deleted, or if you make clear to the user deleting a user will delete all messages associated with them. + // pub(crate) async fn delete_user(&self, user: JID) -> Result<(), Error> {} + + /// does not create the underlying user, if underlying user does not exist, create_user() must be called separately + pub(crate) async fn create_contact(&self, contact: Contact) -> Result<(), Error> { + sqlx::query!( + "insert into roster ( user_jid, name, subscription ) values ( ?, ?, ? )", + contact.user_jid, + contact.name, + contact.subscription + ) + .execute(&self.db) + .await?; + // TODO: abstract this out in to add_to_group() function ? + for group in contact.groups { + sqlx::query!( + "insert into groups (group_name) values (?) on conflict do nothing", + group + ) + .execute(&self.db) + .await?; + sqlx::query!( + "insert into groups_roster (group_name, contact_jid) values (?, ?)", + group, + contact.user_jid + ) + .execute(&self.db) + .await?; + } + Ok(()) + } + + pub(crate) async fn read_contact(&self, contact: JID) -> Result { + let mut contact: Contact = sqlx::query_as("select * from roster where user_jid = ?") + .bind(contact) + .fetch_one(&self.db) + .await?; + #[derive(sqlx::FromRow)] + struct Row { + group_name: String, + } + let groups: Vec = + sqlx::query_as("select group_name from groups_roster where contact_jid = ?") + .bind(&contact.user_jid) + .fetch_all(&self.db) + .await?; + contact.groups = HashSet::from_iter(groups.into_iter().map(|row| row.group_name)); + Ok(contact) + } + + pub(crate) async fn read_contact_opt(&self, contact: &JID) -> Result, Error> { + let contact: Option = + sqlx::query_as("select * from roster join users on jid = user_jid where jid = ?") + .bind(contact) + .fetch_optional(&self.db) + .await?; + if let Some(mut contact) = contact { + #[derive(sqlx::FromRow)] + struct Row { + group_name: String, + } + let groups: Vec = + sqlx::query_as("select group_name from groups_roster where contact_jid = ?") + .bind(&contact.user_jid) + .fetch_all(&self.db) + .await?; + contact.groups = HashSet::from_iter(groups.into_iter().map(|row| row.group_name)); + Ok(Some(contact)) + } else { + Ok(None) + } + } + + /// does not update the underlying user, to update user, update_user() must be called separately + pub(crate) async fn update_contact(&self, contact: Contact) -> Result<(), Error> { + sqlx::query!( + "update roster set name = ?, subscription = ? where user_jid = ?", + contact.name, + contact.subscription, + contact.user_jid + ) + .execute(&self.db) + .await?; + sqlx::query!( + "delete from groups_roster where contact_jid = ?", + contact.user_jid + ) + .execute(&self.db) + .await?; + // TODO: delete orphaned groups from groups table + for group in contact.groups { + sqlx::query!( + "insert into groups (group_name) values (?) on conflict do nothing", + group + ) + .execute(&self.db) + .await?; + sqlx::query!( + "insert into groups_roster (group_name, contact_jid) values (?, ?)", + group, + contact.user_jid + ) + .execute(&self.db) + .await?; + } + Ok(()) + } + + pub(crate) async fn upsert_contact(&self, contact: Contact) -> Result<(), Error> { + sqlx::query!( + "insert into users ( jid ) values ( ? ) on conflict do nothing", + contact.user_jid, + ) + .execute(&self.db) + .await?; + sqlx::query!( + "insert into roster ( user_jid, name, subscription ) values ( ?, ?, ? ) on conflict do update set name = ?, subscription = ?", + contact.user_jid, + contact.name, + contact.subscription, + contact.name, + contact.subscription + ) + .execute(&self.db) + .await?; + sqlx::query!( + "delete from groups_roster where contact_jid = ?", + contact.user_jid + ) + .execute(&self.db) + .await?; + // TODO: delete orphaned groups from groups table + for group in contact.groups { + sqlx::query!( + "insert into groups (group_name) values (?) on conflict do nothing", + group + ) + .execute(&self.db) + .await?; + sqlx::query!( + "insert into groups_roster (group_name, contact_jid) values (?, ?)", + group, + contact.user_jid + ) + .execute(&self.db) + .await?; + } + Ok(()) + } + + pub(crate) async fn delete_contact(&self, contact: JID) -> Result<(), Error> { + sqlx::query!("delete from roster where user_jid = ?", contact) + .execute(&self.db) + .await?; + // TODO: delete orphaned groups from groups table + Ok(()) + } + + pub(crate) async fn replace_cached_roster(&self, roster: Vec) -> Result<(), Error> { + sqlx::query!("delete from roster").execute(&self.db).await?; + for contact in roster { + self.upsert_contact(contact).await?; + } + Ok(()) + } + + pub(crate) async fn read_cached_roster(&self) -> Result, Error> { + let mut roster: Vec = + sqlx::query_as("select * from roster join users on jid = user_jid") + .fetch_all(&self.db) + .await?; + for contact in &mut roster { + #[derive(sqlx::FromRow)] + struct Row { + group_name: String, + } + let groups: Vec = + sqlx::query_as("select group_name from groups_roster where contact_jid = ?") + .bind(&contact.user_jid) + .fetch_all(&self.db) + .await?; + contact.groups = HashSet::from_iter(groups.into_iter().map(|row| row.group_name)); + } + Ok(roster) + } + + pub(crate) async fn create_chat(&self, chat: Chat) -> Result<(), Error> { + let id = Uuid::new_v4(); + let jid = chat.correspondent(); + sqlx::query!( + "insert into chats (id, correspondent) values (?, ?)", + id, + jid + ) + .execute(&self.db) + .await?; + Ok(()) + } + + // TODO: what happens if a correspondent changes from a user to a contact? maybe just have correspondent be a user, then have the client make the user show up as a contact in ui if they are in the loaded roster. + + pub(crate) async fn read_chat(&self, chat: JID) -> Result { + // check if the chat correponding with the jid exists + let chat: Chat = sqlx::query_as("select correspondent from chats where correspondent = ?") + .bind(chat) + .fetch_one(&self.db) + .await?; + Ok(chat) + } + + pub(crate) async fn update_chat_correspondent( + &self, + old_chat: Chat, + new_correspondent: JID, + ) -> Result { + // TODO: update other chat data if it differs (for now there is only correspondent so doesn't matter) + let new_jid = &new_correspondent; + let old_jid = old_chat.correspondent(); + sqlx::query!( + "update chats set correspondent = ? where correspondent = ?", + new_jid, + old_jid, + ) + .execute(&self.db) + .await?; + let chat = self.read_chat(new_correspondent).await?; + Ok(chat) + } + + // pub(crate) async fn update_chat + + pub(crate) async fn delete_chat(&self, chat: JID) -> Result<(), Error> { + sqlx::query!("delete from chats where correspondent = ?", chat) + .execute(&self.db) + .await?; + Ok(()) + } + + /// TODO: sorting and filtering (for now there is no sorting) + pub(crate) async fn read_chats(&self) -> Result, Error> { + let chats: Vec = sqlx::query_as("select * from chats") + .fetch_all(&self.db) + .await?; + Ok(chats) + } + + /// chats ordered by date of last message + // greatest-n-per-group + pub(crate) async fn read_chats_ordered(&self) -> Result, Error> { + let chats = sqlx::query_as("select c.*, m.* from chats c join (select chat_id, max(timestamp) max_timestamp from messages group by chat_id) max_timestamps on c.id = max_timestamps.chat_id join messages m on max_timestamps.chat_id = m.chat_id and max_timestamps.max_timestamp = m.timestamp order by m.timestamp desc") + .fetch_all(&self.db) + .await?; + Ok(chats) + } + + /// chats ordered by date of last message + // greatest-n-per-group + pub(crate) async fn read_chats_ordered_with_latest_messages( + &self, + ) -> Result, Error> { + #[derive(sqlx::FromRow)] + pub struct ChatWithMessage { + #[sqlx(flatten)] + pub chat: Chat, + #[sqlx(flatten)] + pub message: Message, + } + + // TODO: i don't know if this will assign the right uuid to the latest message or the chat's id. should probably check but i don't think it matters as nothing ever gets called with the id of the latest message in the chats list + let chats: Vec = sqlx::query_as("select c.*, m.* from chats c join (select chat_id, max(timestamp) max_timestamp from messages group by chat_id) max_timestamps on c.id = max_timestamps.chat_id join messages m on max_timestamps.chat_id = m.chat_id and max_timestamps.max_timestamp = m.timestamp order by m.timestamp desc") + .fetch_all(&self.db) + .await?; + + let chats = chats + .into_iter() + .map(|chat_with_message| (chat_with_message.chat, chat_with_message.message)) + .collect(); + + Ok(chats) + } + + async fn read_chat_id(&self, chat: JID) -> Result { + #[derive(sqlx::FromRow)] + struct Row { + id: Uuid, + } + let chat = chat.as_bare(); + let chat_id: Row = sqlx::query_as("select id from chats where correspondent = ?") + .bind(chat) + .fetch_one(&self.db) + .await?; + let chat_id = chat_id.id; + Ok(chat_id) + } + + async fn read_chat_id_opt(&self, chat: JID) -> Result, Error> { + #[derive(sqlx::FromRow)] + struct Row { + id: Uuid, + } + let chat_id: Option = sqlx::query_as("select id from chats where correspondent = ?") + .bind(chat) + .fetch_optional(&self.db) + .await?; + let chat_id = chat_id.map(|row| row.id); + Ok(chat_id) + } + + /// if the chat doesn't already exist, it must be created by calling create_chat() before running this function. + pub(crate) async fn create_message(&self, message: Message, chat: JID) -> Result<(), Error> { + // TODO: one query + let bare_jid = message.from.as_bare(); + let resource = message.from.resourcepart; + let chat_id = self.read_chat_id(chat).await?; + sqlx::query!("insert into messages (id, body, chat_id, from_jid, from_resource, timestamp) values (?, ?, ?, ?, ?, ?)", message.id, message.body.body, chat_id, bare_jid, resource, message.timestamp).execute(&self.db).await?; + Ok(()) + } + + pub(crate) async fn create_message_with_self_resource_and_chat( + &self, + message: Message, + chat: JID, + ) -> Result<(), Error> { + let from_jid = message.from.as_bare(); + let resource = &message.from.resourcepart; + let bare_chat = chat.as_bare(); + sqlx::query!( + "insert into users (jid) values (?) on conflict do nothing", + from_jid + ) + .execute(&self.db) + .await?; + let id = Uuid::new_v4(); + sqlx::query!( + "insert into chats (id, correspondent) values (?, ?) on conflict do nothing", + id, + bare_chat + ) + .execute(&self.db) + .await?; + if let Some(resource) = resource { + sqlx::query!( + "insert into resources (bare_jid, resource) values (?, ?) on conflict do nothing", + from_jid, + resource + ) + .execute(&self.db) + .await?; + } + self.create_message(message, chat).await?; + Ok(()) + } + + // create direct message from incoming + pub(crate) async fn create_message_with_user_resource_and_chat( + &self, + message: Message, + chat: JID, + ) -> Result<(), Error> { + let bare_chat = chat.as_bare(); + let resource = &chat.resourcepart; + sqlx::query!( + "insert into users (jid) values (?) on conflict do nothing", + bare_chat + ) + .execute(&self.db) + .await?; + let id = Uuid::new_v4(); + sqlx::query!( + "insert into chats (id, correspondent) values (?, ?) on conflict do nothing", + id, + bare_chat + ) + .execute(&self.db) + .await?; + if let Some(resource) = resource { + sqlx::query!( + "insert into resources (bare_jid, resource) values (?, ?) on conflict do nothing", + bare_chat, + resource + ) + .execute(&self.db) + .await?; + } + self.create_message(message, chat).await?; + Ok(()) + } + + pub(crate) async fn read_message(&self, message: Uuid) -> Result { + let message: Message = sqlx::query_as("select * from messages where id = ?") + .bind(message) + .fetch_one(&self.db) + .await?; + Ok(message) + } + + // TODO: message updates/edits pub(crate) async fn update_message(&self, message: Message) -> Result<(), Error> {} + + pub(crate) async fn delete_message(&self, message: Uuid) -> Result<(), Error> { + sqlx::query!("delete from messages where id = ?", message) + .execute(&self.db) + .await?; + Ok(()) + } + + // TODO: paging + pub(crate) async fn read_message_history(&self, chat: JID) -> Result, Error> { + let chat_id = self.read_chat_id(chat).await?; + let messages: Vec = + sqlx::query_as("select * from messages where chat_id = ? order by timestamp asc") + .bind(chat_id) + .fetch_all(&self.db) + .await?; + Ok(messages) + } + + pub(crate) async fn read_cached_status(&self) -> Result { + let online: Online = sqlx::query_as("select * from cached_status where id = 0") + .fetch_one(&self.db) + .await?; + Ok(online) + } + + pub(crate) async fn upsert_cached_status(&self, status: Online) -> Result<(), Error> { + sqlx::query!( + "insert into cached_status (id, show, message) values (0, ?, ?) on conflict do update set show = ?, message = ?", + status.show, + status.status, + status.show, + status.status + ).execute(&self.db).await?; + Ok(()) + } + + pub(crate) async fn delete_cached_status(&self) -> Result<(), Error> { + sqlx::query!("update cached_status set show = null, message = null where id = 0") + .execute(&self.db) + .await?; + Ok(()) + } +} diff --git a/filamento/src/error.rs b/filamento/src/error.rs new file mode 100644 index 0000000..996a503 --- /dev/null +++ b/filamento/src/error.rs @@ -0,0 +1,142 @@ +use std::sync::Arc; + +use lampada::error::{ConnectionError, ReadError, WriteError}; +use stanza::client::Stanza; +use thiserror::Error; + +pub use lampada::error::CommandError; + +// for the client logic impl +#[derive(Debug, Error, Clone)] +pub enum Error { + #[error("core error: {0}")] + Connection(#[from] ConnectionError), + #[error("received unrecognized/unsupported content")] + UnrecognizedContent, + // TODO: include content + // UnrecognizedContent(peanuts::element::Content), + #[error("iq receive error: {0}")] + Iq(IqError), + // TODO: change to Connecting(ConnectingError) + #[error("connecting: {0}")] + Connecting(#[from] ConnectionJobError), + #[error("presence: {0}")] + Presence(#[from] PresenceError), + #[error("set status: {0}")] + SetStatus(#[from] StatusError), + // TODO: have different ones for get/update/set + #[error("roster: {0}")] + Roster(RosterError), + #[error("stream error: {0}")] + Stream(#[from] stanza::stream::Error), + #[error("message send error: {0}")] + MessageSend(MessageSendError), + #[error("message receive error: {0}")] + MessageRecv(MessageRecvError), +} + +#[derive(Debug, Error, Clone)] +pub enum MessageSendError { + #[error("could not add to message history: {0}")] + MessageHistory(#[from] DatabaseError), +} + +#[derive(Debug, Error, Clone)] +pub enum MessageRecvError { + #[error("could not add to message history: {0}")] + MessageHistory(#[from] DatabaseError), + #[error("missing from")] + MissingFrom, +} + +#[derive(Debug, Error, Clone)] +pub enum StatusError { + #[error("cache: {0}")] + Cache(#[from] DatabaseError), + #[error("stream write: {0}")] + Write(#[from] WriteError), +} + +#[derive(Debug, Clone, Error)] +pub enum ConnectionJobError { + // #[error("connection failed: {0}")] + // ConnectionFailed(#[from] luz::Error), + #[error("failed roster retreival: {0}")] + RosterRetreival(#[from] RosterError), + #[error("failed to send available presence: {0}")] + SendPresence(#[from] WriteError), + #[error("cached status: {0}")] + StatusCacheError(#[from] DatabaseError), +} + +#[derive(Debug, Error, Clone)] +pub enum RosterError { + #[error("cache: {0}")] + Cache(#[from] DatabaseError), + #[error("stream write: {0}")] + Write(#[from] WriteError), + // TODO: display for stanza, to show as xml, same for read error types. + #[error("unexpected reply: {0:?}")] + UnexpectedStanza(Stanza), + #[error("stream read: {0}")] + Read(#[from] ReadError), + #[error("stanza error: {0}")] + StanzaError(#[from] stanza::client::error::Error), +} + +#[derive(Debug, Error, Clone)] +#[error("database error: {0}")] +pub struct DatabaseError(Arc); + +impl From for DatabaseError { + fn from(e: sqlx::Error) -> Self { + Self(Arc::new(e)) + } +} + +impl From for DatabaseOpenError { + fn from(e: sqlx::Error) -> Self { + Self::Error(Arc::new(e)) + } +} + +#[derive(Debug, Error, Clone)] +// TODO: should probably have all iq query related errors here, including read, write, stanza error, etc. +pub enum IqError { + #[error("no iq with id matching `{0}`")] + NoMatchingId(String), +} + +#[derive(Debug, Error, Clone)] +pub enum DatabaseOpenError { + #[error("error: {0}")] + Error(Arc), + #[error("migration: {0}")] + Migration(Arc), + #[error("io: {0}")] + Io(Arc), + #[error("invalid path")] + InvalidPath, +} + +impl From for DatabaseOpenError { + fn from(e: sqlx::migrate::MigrateError) -> Self { + Self::Migration(Arc::new(e)) + } +} + +impl From for DatabaseOpenError { + fn from(e: tokio::io::Error) -> Self { + Self::Io(Arc::new(e)) + } +} + +#[derive(Debug, Error, Clone)] +pub enum PresenceError { + #[error("unsupported")] + Unsupported, + #[error("missing from")] + MissingFrom, + #[error("stanza error: {0}")] + StanzaError(#[from] stanza::client::error::Error), +} diff --git a/filamento/src/lib.rs b/filamento/src/lib.rs new file mode 100644 index 0000000..db59a67 --- /dev/null +++ b/filamento/src/lib.rs @@ -0,0 +1,1598 @@ +use std::{ + collections::HashMap, + ops::{Deref, DerefMut}, + str::FromStr, + sync::Arc, + time::Duration, +}; + +use chat::{Body, Chat, Message}; +use chrono::Utc; +use db::Db; +use error::{ + ConnectionJobError, DatabaseError, Error, IqError, MessageRecvError, PresenceError, + RosterError, StatusError, +}; +use futures::FutureExt; +use jid::JID; +use lampada::{ + Connected, CoreClient, CoreClientCommand, Logic, SupervisorSender, WriteMessage, + error::{ActorError, CommandError, ConnectionError, ReadError, WriteError}, +}; +use presence::{Offline, Online, Presence, PresenceType, Show}; +use roster::{Contact, ContactUpdate}; +use stanza::client::{ + Stanza, + iq::{self, Iq, IqType}, +}; +use tokio::{ + sync::{Mutex, mpsc, oneshot}, + time::timeout, +}; +use tracing::{debug, info}; +use user::User; +use uuid::Uuid; + +pub mod chat; +pub mod db; +pub mod error; +pub mod presence; +pub mod roster; +pub mod user; + +pub enum Command { + /// get the roster. if offline, retreive cached version from database. should be stored in application memory + GetRoster(oneshot::Sender, RosterError>>), + /// get all chats. chat will include 10 messages in their message Vec (enough for chat previews) + // TODO: paging and filtering + GetChats(oneshot::Sender, DatabaseError>>), + // TODO: paging and filtering + GetChatsOrdered(oneshot::Sender, DatabaseError>>), + // TODO: paging and filtering + GetChatsOrderedWithLatestMessages(oneshot::Sender, DatabaseError>>), + /// get a specific chat by jid + GetChat(JID, oneshot::Sender>), + /// get message history for chat (does appropriate mam things) + // TODO: paging and filtering + GetMessages(JID, oneshot::Sender, DatabaseError>>), + /// delete a chat from your chat history, along with all the corresponding messages + DeleteChat(JID, oneshot::Sender>), + /// delete a message from your chat history + DeleteMessage(Uuid, oneshot::Sender>), + /// get a user from your users database + GetUser(JID, oneshot::Sender>), + /// add a contact to your roster, with a status of none, no subscriptions. + AddContact(JID, oneshot::Sender>), + /// send a friend request i.e. a subscription request with a subscription pre-approval. if not already added to roster server adds to roster. + BuddyRequest(JID, oneshot::Sender>), + /// send a subscription request, without pre-approval. if not already added to roster server adds to roster. + SubscriptionRequest(JID, oneshot::Sender>), + /// accept a friend request by accepting a pending subscription and sending a subscription request back. if not already added to roster adds to roster. + AcceptBuddyRequest(JID, oneshot::Sender>), + /// accept a pending subscription and doesn't send a subscription request back. if not already added to roster adds to roster. + AcceptSubscriptionRequest(JID, oneshot::Sender>), + /// unsubscribe to a contact, but don't remove their subscription. + UnsubscribeFromContact(JID, oneshot::Sender>), + /// stop a contact from being subscribed, but stay subscribed to the contact. + UnsubscribeContact(JID, oneshot::Sender>), + /// remove subscriptions to and from contact, but keep in roster. + UnfriendContact(JID, oneshot::Sender>), + /// remove a contact from the contact list. will remove subscriptions if not already done then delete contact from roster. + DeleteContact(JID, oneshot::Sender>), + /// update contact. contact details will be overwritten with the contents of the contactupdate struct. + UpdateContact(JID, ContactUpdate, oneshot::Sender>), + /// set online status. if disconnected, will be cached so when client connects, will be sent as the initial presence. + SetStatus(Online, oneshot::Sender>), + /// send presence stanza + // TODO: cache presence stanza + SendPresence( + Option, + PresenceType, + oneshot::Sender>, + ), + /// send a directed presence (usually to a non-contact). + // TODO: should probably make it so people can add non-contact auto presence sharing in the client (most likely through setting an internal setting) + /// send a message to a jid (any kind of jid that can receive a message, e.g. a user or a + /// chatroom). if disconnected, will be cached so when client connects, message will be sent. + SendMessage(JID, Body, oneshot::Sender>), +} +/// an xmpp client that is suited for a chat client use case +#[derive(Debug)] +pub struct Client { + sender: mpsc::Sender>, + timeout: Duration, +} + +impl Clone for Client { + fn clone(&self) -> Self { + Self { + sender: self.sender.clone(), + timeout: self.timeout, + } + } +} + +impl Deref for Client { + type Target = mpsc::Sender>; + + fn deref(&self) -> &Self::Target { + &self.sender + } +} + +impl DerefMut for Client { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.sender + } +} + +impl Client { + pub async fn connect(&self) -> Result<(), ActorError> { + self.send(CoreClientCommand::Connect).await?; + Ok(()) + } + + pub async fn disconnect(&self, offline: Offline) -> Result<(), ActorError> { + self.send(CoreClientCommand::Disconnect).await?; + Ok(()) + } + + pub fn new(jid: JID, password: String, db: Db) -> (Self, mpsc::Receiver) { + let (command_sender, command_receiver) = mpsc::channel(20); + let (update_send, update_recv) = mpsc::channel(20); + + // might be bad, first supervisor shutdown notification oneshot is never used (disgusting) + let (_sup_send, sup_recv) = oneshot::channel(); + let sup_recv = sup_recv.fuse(); + + let logic = ClientLogic { + db, + pending: Arc::new(Mutex::new(HashMap::new())), + update_sender: update_send, + }; + + let actor: CoreClient = + CoreClient::new(jid, password, command_receiver, None, sup_recv, logic); + tokio::spawn(async move { actor.run().await }); + + ( + Self { + sender: command_sender, + // TODO: configure timeout + timeout: Duration::from_secs(10), + }, + update_recv, + ) + } + + pub async fn get_roster(&self) -> Result, CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::GetRoster(send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let roster = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(roster) + } + + pub async fn get_chats(&self) -> Result, CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::GetChats(send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let chats = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(chats) + } + + pub async fn get_chats_ordered(&self) -> Result, CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::GetChatsOrdered(send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let chats = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(chats) + } + + pub async fn get_chats_ordered_with_latest_messages( + &self, + ) -> Result, CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command( + Command::GetChatsOrderedWithLatestMessages(send), + )) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let chats = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(chats) + } + + pub async fn get_chat(&self, jid: JID) -> Result> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::GetChat(jid, send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let chat = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(chat) + } + + pub async fn get_messages( + &self, + jid: JID, + ) -> Result, CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::GetMessages(jid, send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let messages = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(messages) + } + + pub async fn delete_chat(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::DeleteChat(jid, send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn delete_message(&self, id: Uuid) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::DeleteMessage(id, send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn get_user(&self, jid: JID) -> Result> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::GetUser(jid, send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn add_contact(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::AddContact(jid, send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn buddy_request(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::BuddyRequest(jid, send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn subscription_request(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::SubscriptionRequest( + jid, send, + ))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn accept_buddy_request(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::AcceptBuddyRequest( + jid, send, + ))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn accept_subscription_request( + &self, + jid: JID, + ) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command( + Command::AcceptSubscriptionRequest(jid, send), + )) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn unsubscribe_from_contact(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::UnsubscribeFromContact( + jid, send, + ))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn unsubscribe_contact(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::UnsubscribeContact( + jid, send, + ))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn unfriend_contact(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::UnfriendContact( + jid, send, + ))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn delete_contact(&self, jid: JID) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::DeleteContact( + jid, send, + ))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn update_contact( + &self, + jid: JID, + update: ContactUpdate, + ) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::UpdateContact( + jid, update, send, + ))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn set_status(&self, online: Online) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::SetStatus(online, send))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } + + pub async fn send_message(&self, jid: JID, body: Body) -> Result<(), CommandError> { + let (send, recv) = oneshot::channel(); + self.send(CoreClientCommand::Command(Command::SendMessage( + jid, body, send, + ))) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))?; + let result = timeout(self.timeout, recv) + .await + .map_err(|e| CommandError::Actor(Into::::into(e)))? + .map_err(|e| CommandError::Actor(Into::::into(e)))??; + Ok(result) + } +} + +#[derive(Clone)] +pub struct ClientLogic { + db: Db, + pending: Arc>>>>, + update_sender: mpsc::Sender, +} + +impl Logic for ClientLogic { + type Cmd = Command; + + async fn handle_connect(self, connection: Connected) { + let (send, recv) = oneshot::channel(); + debug!("getting roster"); + self.clone() + .handle_online(Command::GetRoster(send), connection.clone()) + .await; + debug!("sent roster req"); + let roster = recv.await; + debug!("got roster"); + match roster { + Ok(r) => match r { + Ok(roster) => { + let online = self.db.read_cached_status().await; + let online = match online { + Ok(online) => online, + Err(e) => { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Connecting( + ConnectionJobError::StatusCacheError(e.into()), + ))) + .await; + Online::default() + } + }; + let (send, recv) = oneshot::channel(); + self.clone() + .handle_online( + Command::SendPresence(None, PresenceType::Online(online.clone()), send), + connection, + ) + .await; + let set_status = recv.await; + match set_status { + Ok(s) => match s { + Ok(()) => { + let _ = self + .update_sender + .send(UpdateMessage::Online(online, roster)) + .await; + } + Err(e) => { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Connecting(e.into()))) + .await; + } + }, + Err(e) => { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Connecting( + ConnectionJobError::SendPresence(WriteError::Actor(e.into())), + ))) + .await; + } + } + } + Err(e) => { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Connecting(e.into()))) + .await; + } + }, + Err(e) => { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Connecting( + ConnectionJobError::RosterRetreival(RosterError::Write(WriteError::Actor( + e.into(), + ))), + ))) + .await; + } + } + } + + async fn handle_disconnect(self, connection: Connected) { + // TODO: be able to set offline status message + let offline_presence: stanza::client::presence::Presence = + Offline::default().into_stanza(None); + let stanza = Stanza::Presence(offline_presence); + // TODO: timeout and error check + connection.write_handle().write(stanza).await; + let _ = self + .update_sender + .send(UpdateMessage::Offline(Offline::default())) + .await; + } + + async fn handle_stanza( + self, + stanza: Stanza, + connection: Connected, + supervisor: SupervisorSender, + ) { + match stanza { + Stanza::Message(stanza_message) => { + if let Some(mut from) = stanza_message.from { + // TODO: don't ignore delay from. xep says SHOULD send error if incorrect. + let timestamp = stanza_message + .delay + .map(|delay| delay.stamp) + .unwrap_or_else(|| Utc::now()); + // TODO: group chat messages + let mut message = Message { + id: stanza_message + .id + // TODO: proper id storage + .map(|id| Uuid::from_str(&id).unwrap_or_else(|_| Uuid::new_v4())) + .unwrap_or_else(|| Uuid::new_v4()), + from: from.clone(), + timestamp, + body: Body { + // TODO: should this be an option? + body: stanza_message + .body + .map(|body| body.body) + .unwrap_or_default() + .unwrap_or_default(), + }, + }; + // TODO: can this be more efficient? + let result = self + .db + .create_message_with_user_resource_and_chat(message.clone(), from.clone()) + .await; + if let Err(e) = result { + tracing::error!("messagecreate"); + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::MessageRecv( + MessageRecvError::MessageHistory(e.into()), + ))) + .await; + } + message.from = message.from.as_bare(); + from = from.as_bare(); + let _ = self + .update_sender + .send(UpdateMessage::Message { to: from, message }) + .await; + } else { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::MessageRecv( + MessageRecvError::MissingFrom, + ))) + .await; + } + } + Stanza::Presence(presence) => { + if let Some(from) = presence.from { + match presence.r#type { + Some(r#type) => match r#type { + // error processing a presence from somebody + stanza::client::presence::PresenceType::Error => { + // TODO: is there any other information that should go with the error? also MUST have an error, otherwise it's a different error. maybe it shoulnd't be an option. + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Presence( + // TODO: ughhhhhhhhhhhhh these stanza errors should probably just have an option, and custom display + PresenceError::StanzaError( + presence + .errors + .first() + .cloned() + .expect("error MUST have error"), + ), + ))) + .await; + } + // should not happen (error to server) + stanza::client::presence::PresenceType::Probe => { + // TODO: should probably write an error and restart stream + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Presence( + PresenceError::Unsupported, + ))) + .await; + } + stanza::client::presence::PresenceType::Subscribe => { + // may get a subscription request from somebody who is not a contact!!! therefore should be its own kind of event + let _ = self + .update_sender + .send(UpdateMessage::SubscriptionRequest(from)) + .await; + } + stanza::client::presence::PresenceType::Unavailable => { + let offline = Offline { + status: presence.status.map(|status| status.status.0), + }; + let timestamp = presence + .delay + .map(|delay| delay.stamp) + .unwrap_or_else(|| Utc::now()); + let _ = self + .update_sender + .send(UpdateMessage::Presence { + from, + presence: Presence { + timestamp, + presence: PresenceType::Offline(offline), + }, + }) + .await; + } + // for now, do nothing, as these are simply informational. will receive roster push from the server regarding the changes to do with them. + stanza::client::presence::PresenceType::Subscribed => {} + stanza::client::presence::PresenceType::Unsubscribe => {} + stanza::client::presence::PresenceType::Unsubscribed => {} + }, + None => { + let online = Online { + show: presence.show.map(|show| match show { + stanza::client::presence::Show::Away => Show::Away, + stanza::client::presence::Show::Chat => Show::Chat, + stanza::client::presence::Show::Dnd => Show::DoNotDisturb, + stanza::client::presence::Show::Xa => Show::ExtendedAway, + }), + status: presence.status.map(|status| status.status.0), + priority: presence.priority.map(|priority| priority.0), + }; + let timestamp = presence + .delay + .map(|delay| delay.stamp) + .unwrap_or_else(|| Utc::now()); + let _ = self + .update_sender + .send(UpdateMessage::Presence { + from, + presence: Presence { + timestamp, + presence: PresenceType::Online(online), + }, + }) + .await; + } + } + } else { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Presence( + PresenceError::MissingFrom, + ))) + .await; + } + } + Stanza::Iq(iq) => match iq.r#type { + stanza::client::iq::IqType::Error | stanza::client::iq::IqType::Result => { + let send; + { + send = self.pending.lock().await.remove(&iq.id); + } + if let Some(send) = send { + send.send(Ok(Stanza::Iq(iq))); + } else { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Iq(IqError::NoMatchingId( + iq.id, + )))) + .await; + } + } + // TODO: send unsupported to server + // TODO: proper errors i am so tired please + stanza::client::iq::IqType::Get => {} + stanza::client::iq::IqType::Set => { + if let Some(query) = iq.query { + match query { + stanza::client::iq::Query::Roster(mut query) => { + // TODO: there should only be one + if let Some(item) = query.items.pop() { + match item.subscription { + Some(stanza::roster::Subscription::Remove) => { + self.db.delete_contact(item.jid.clone()).await; + self.update_sender + .send(UpdateMessage::RosterDelete(item.jid)) + .await; + // TODO: send result + } + _ => { + let contact: Contact = item.into(); + if let Err(e) = + self.db.upsert_contact(contact.clone()).await + { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Roster( + RosterError::Cache(e.into()), + ))) + .await; + } + let _ = self + .update_sender + .send(UpdateMessage::RosterUpdate(contact)) + .await; + // TODO: send result + // write_handle.write(Stanza::Iq(stanza::client::iq::Iq { + // from: , + // id: todo!(), + // to: todo!(), + // r#type: todo!(), + // lang: todo!(), + // query: todo!(), + // errors: todo!(), + // })); + } + } + } + } + // TODO: send unsupported to server + _ => {} + } + } else { + // TODO: send error (unsupported) to server + } + } + }, + Stanza::Error(error) => { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::Stream(error))) + .await; + // TODO: reconnect + } + Stanza::OtherContent(content) => { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::UnrecognizedContent)); + // TODO: send error to write_thread + } + } + } + + async fn handle_online(self, command: Command, connection: Connected) { + match command { + Command::GetRoster(result_sender) => { + // TODO: jid resource should probably be stored within the connection + debug!("before client_jid lock"); + debug!("after client_jid lock"); + let iq_id = Uuid::new_v4().to_string(); + let (send, iq_recv) = oneshot::channel(); + { + self.pending.lock().await.insert(iq_id.clone(), send); + } + let stanza = Stanza::Iq(Iq { + from: Some(connection.jid().clone()), + id: iq_id.to_string(), + to: None, + r#type: IqType::Get, + lang: None, + query: Some(iq::Query::Roster(stanza::roster::Query { + ver: None, + items: Vec::new(), + })), + errors: Vec::new(), + }); + let (send, recv) = oneshot::channel(); + let _ = connection + .write_handle() + .send(WriteMessage { + stanza, + respond_to: send, + }) + .await; + // TODO: timeout + match recv.await { + Ok(Ok(())) => info!("roster request sent"), + Ok(Err(e)) => { + // TODO: log errors if fail to send + let _ = result_sender.send(Err(RosterError::Write(e.into()))); + return; + } + Err(e) => { + let _ = result_sender + .send(Err(RosterError::Write(WriteError::Actor(e.into())))); + return; + } + }; + // TODO: timeout + match iq_recv.await { + Ok(Ok(stanza)) => match stanza { + Stanza::Iq(Iq { + from: _, + id, + to: _, + r#type, + lang: _, + query: Some(iq::Query::Roster(stanza::roster::Query { ver: _, items })), + errors: _, + }) if id == iq_id && r#type == IqType::Result => { + let contacts: Vec = + items.into_iter().map(|item| item.into()).collect(); + if let Err(e) = self.db.replace_cached_roster(contacts.clone()).await { + self.update_sender + .send(UpdateMessage::Error(Error::Roster(RosterError::Cache( + e.into(), + )))) + .await; + }; + result_sender.send(Ok(contacts)); + return; + } + ref s @ Stanza::Iq(Iq { + from: _, + ref id, + to: _, + r#type, + lang: _, + query: _, + ref errors, + }) if *id == iq_id && r#type == IqType::Error => { + if let Some(error) = errors.first() { + result_sender.send(Err(RosterError::StanzaError(error.clone()))); + } else { + result_sender.send(Err(RosterError::UnexpectedStanza(s.clone()))); + } + return; + } + s => { + result_sender.send(Err(RosterError::UnexpectedStanza(s))); + return; + } + }, + Ok(Err(e)) => { + result_sender.send(Err(RosterError::Read(e))); + return; + } + Err(e) => { + result_sender.send(Err(RosterError::Write(WriteError::Actor(e.into())))); + return; + } + } + } + Command::GetChats(sender) => { + let chats = self.db.read_chats().await.map_err(|e| e.into()); + sender.send(chats); + } + Command::GetChatsOrdered(sender) => { + let chats = self.db.read_chats_ordered().await.map_err(|e| e.into()); + sender.send(chats); + } + Command::GetChatsOrderedWithLatestMessages(sender) => { + let chats = self + .db + .read_chats_ordered_with_latest_messages() + .await + .map_err(|e| e.into()); + sender.send(chats); + } + Command::GetChat(jid, sender) => { + let chats = self.db.read_chat(jid).await.map_err(|e| e.into()); + sender.send(chats); + } + Command::GetMessages(jid, sender) => { + let messages = self + .db + .read_message_history(jid) + .await + .map_err(|e| e.into()); + sender.send(messages); + } + Command::DeleteChat(jid, sender) => { + let result = self.db.delete_chat(jid).await.map_err(|e| e.into()); + sender.send(result); + } + Command::DeleteMessage(uuid, sender) => { + let result = self.db.delete_message(uuid).await.map_err(|e| e.into()); + sender.send(result); + } + Command::GetUser(jid, sender) => { + let user = self.db.read_user(jid).await.map_err(|e| e.into()); + sender.send(user); + } + // TODO: offline queue to modify roster + Command::AddContact(jid, sender) => { + let iq_id = Uuid::new_v4().to_string(); + let set_stanza = Stanza::Iq(Iq { + from: Some(connection.jid().clone()), + id: iq_id.clone(), + to: None, + r#type: IqType::Set, + lang: None, + query: Some(iq::Query::Roster(stanza::roster::Query { + ver: None, + items: vec![stanza::roster::Item { + approved: None, + ask: false, + jid, + name: None, + subscription: None, + groups: Vec::new(), + }], + })), + errors: Vec::new(), + }); + let (send, recv) = oneshot::channel(); + { + self.pending.lock().await.insert(iq_id.clone(), send); + } + // TODO: write_handle send helper function + let result = connection.write_handle().write(set_stanza).await; + if let Err(e) = result { + sender.send(Err(RosterError::Write(e))); + return; + } + let iq_result = recv.await; + match iq_result { + Ok(i) => match i { + Ok(iq_result) => match iq_result { + Stanza::Iq(Iq { + from: _, + id, + to: _, + r#type, + lang: _, + query: _, + errors: _, + }) if id == iq_id && r#type == IqType::Result => { + sender.send(Ok(())); + return; + } + ref s @ Stanza::Iq(Iq { + from: _, + ref id, + to: _, + r#type, + lang: _, + query: _, + ref errors, + }) if *id == iq_id && r#type == IqType::Error => { + if let Some(error) = errors.first() { + sender.send(Err(RosterError::StanzaError(error.clone()))); + } else { + sender.send(Err(RosterError::UnexpectedStanza(s.clone()))); + } + return; + } + s => { + sender.send(Err(RosterError::UnexpectedStanza(s))); + return; + } + }, + Err(e) => { + sender.send(Err(e.into())); + return; + } + }, + Err(e) => { + sender.send(Err(RosterError::Write(WriteError::Actor(e.into())))); + return; + } + } + } + Command::BuddyRequest(jid, sender) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid.clone()), + r#type: Some(stanza::client::presence::PresenceType::Subscribe), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + match result { + Err(_) => { + let _ = sender.send(result); + } + Ok(()) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid), + r#type: Some(stanza::client::presence::PresenceType::Subscribed), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + let _ = sender.send(result); + } + } + } + Command::SubscriptionRequest(jid, sender) => { + // TODO: i should probably have builders + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid), + r#type: Some(stanza::client::presence::PresenceType::Subscribe), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + let _ = sender.send(result); + } + Command::AcceptBuddyRequest(jid, sender) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid.clone()), + r#type: Some(stanza::client::presence::PresenceType::Subscribed), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + match result { + Err(_) => { + let _ = sender.send(result); + } + Ok(()) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid), + r#type: Some(stanza::client::presence::PresenceType::Subscribe), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + let _ = sender.send(result); + } + } + } + Command::AcceptSubscriptionRequest(jid, sender) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid), + r#type: Some(stanza::client::presence::PresenceType::Subscribe), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + let _ = sender.send(result); + } + Command::UnsubscribeFromContact(jid, sender) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid), + r#type: Some(stanza::client::presence::PresenceType::Unsubscribe), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + let _ = sender.send(result); + } + Command::UnsubscribeContact(jid, sender) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid), + r#type: Some(stanza::client::presence::PresenceType::Unsubscribed), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + let _ = sender.send(result); + } + Command::UnfriendContact(jid, sender) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid.clone()), + r#type: Some(stanza::client::presence::PresenceType::Unsubscribe), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + match result { + Err(_) => { + let _ = sender.send(result); + } + Ok(()) => { + let presence = Stanza::Presence(stanza::client::presence::Presence { + from: None, + id: None, + to: Some(jid), + r#type: Some(stanza::client::presence::PresenceType::Unsubscribed), + lang: None, + show: None, + status: None, + priority: None, + errors: Vec::new(), + delay: None, + }); + let result = connection.write_handle().write(presence).await; + let _ = sender.send(result); + } + } + } + Command::DeleteContact(jid, sender) => { + let iq_id = Uuid::new_v4().to_string(); + let set_stanza = Stanza::Iq(Iq { + from: Some(connection.jid().clone()), + id: iq_id.clone(), + to: None, + r#type: IqType::Set, + lang: None, + query: Some(iq::Query::Roster(stanza::roster::Query { + ver: None, + items: vec![stanza::roster::Item { + approved: None, + ask: false, + jid, + name: None, + subscription: Some(stanza::roster::Subscription::Remove), + groups: Vec::new(), + }], + })), + errors: Vec::new(), + }); + let (send, recv) = oneshot::channel(); + { + self.pending.lock().await.insert(iq_id.clone(), send); + } + let result = connection.write_handle().write(set_stanza).await; + if let Err(e) = result { + sender.send(Err(RosterError::Write(e))); + return; + } + let iq_result = recv.await; + match iq_result { + Ok(i) => match i { + Ok(iq_result) => match iq_result { + Stanza::Iq(Iq { + from: _, + id, + to: _, + r#type, + lang: _, + query: _, + errors: _, + }) if id == iq_id && r#type == IqType::Result => { + sender.send(Ok(())); + return; + } + ref s @ Stanza::Iq(Iq { + from: _, + ref id, + to: _, + r#type, + lang: _, + query: _, + ref errors, + }) if *id == iq_id && r#type == IqType::Error => { + if let Some(error) = errors.first() { + sender.send(Err(RosterError::StanzaError(error.clone()))); + } else { + sender.send(Err(RosterError::UnexpectedStanza(s.clone()))); + } + return; + } + s => { + sender.send(Err(RosterError::UnexpectedStanza(s))); + return; + } + }, + Err(e) => { + sender.send(Err(e.into())); + return; + } + }, + Err(e) => { + sender.send(Err(RosterError::Write(WriteError::Actor(e.into())))); + return; + } + } + } + Command::UpdateContact(jid, contact_update, sender) => { + let iq_id = Uuid::new_v4().to_string(); + let groups = Vec::from_iter( + contact_update + .groups + .into_iter() + .map(|group| stanza::roster::Group(Some(group))), + ); + let set_stanza = Stanza::Iq(Iq { + from: Some(connection.jid().clone()), + id: iq_id.clone(), + to: None, + r#type: IqType::Set, + lang: None, + query: Some(iq::Query::Roster(stanza::roster::Query { + ver: None, + items: vec![stanza::roster::Item { + approved: None, + ask: false, + jid, + name: contact_update.name, + subscription: None, + groups, + }], + })), + errors: Vec::new(), + }); + let (send, recv) = oneshot::channel(); + { + self.pending.lock().await.insert(iq_id.clone(), send); + } + let result = connection.write_handle().write(set_stanza).await; + if let Err(e) = result { + sender.send(Err(RosterError::Write(e))); + return; + } + let iq_result = recv.await; + match iq_result { + Ok(i) => match i { + Ok(iq_result) => match iq_result { + Stanza::Iq(Iq { + from: _, + id, + to: _, + r#type, + lang: _, + query: _, + errors: _, + }) if id == iq_id && r#type == IqType::Result => { + sender.send(Ok(())); + return; + } + ref s @ Stanza::Iq(Iq { + from: _, + ref id, + to: _, + r#type, + lang: _, + query: _, + ref errors, + }) if *id == iq_id && r#type == IqType::Error => { + if let Some(error) = errors.first() { + sender.send(Err(RosterError::StanzaError(error.clone()))); + } else { + sender.send(Err(RosterError::UnexpectedStanza(s.clone()))); + } + return; + } + s => { + sender.send(Err(RosterError::UnexpectedStanza(s))); + return; + } + }, + Err(e) => { + sender.send(Err(e.into())); + return; + } + }, + Err(e) => { + sender.send(Err(RosterError::Write(WriteError::Actor(e.into())))); + return; + } + } + } + Command::SetStatus(online, sender) => { + let result = self.db.upsert_cached_status(online.clone()).await; + if let Err(e) = result { + let _ = self + .update_sender + .send(UpdateMessage::Error(Error::SetStatus(StatusError::Cache( + e.into(), + )))) + .await; + } + let result = connection + .write_handle() + .write(Stanza::Presence(online.into_stanza(None))) + .await + .map_err(|e| StatusError::Write(e)); + // .map_err(|e| StatusError::Write(e)); + let _ = sender.send(result); + } + // TODO: offline message queue + Command::SendMessage(jid, body, sender) => { + let id = Uuid::new_v4(); + let message = Stanza::Message(stanza::client::message::Message { + from: Some(connection.jid().clone()), + id: Some(id.to_string()), + to: Some(jid.clone()), + // TODO: specify message type + r#type: stanza::client::message::MessageType::Chat, + // TODO: lang ? + lang: None, + subject: None, + body: Some(stanza::client::message::Body { + lang: None, + body: Some(body.body.clone()), + }), + thread: None, + delay: None, + }); + let _ = sender.send(Ok(())); + // let _ = sender.send(Ok(message.clone())); + let result = connection.write_handle().write(message).await; + match result { + Ok(_) => { + let mut message = Message { + id, + from: connection.jid().clone(), + body, + timestamp: Utc::now(), + }; + info!("send message {:?}", message); + if let Err(e) = self + .db + .create_message_with_self_resource_and_chat( + message.clone(), + jid.clone(), + ) + .await + .map_err(|e| e.into()) + { + tracing::error!("{}", e); + let _ = + self.update_sender + .send(UpdateMessage::Error(Error::MessageSend( + error::MessageSendError::MessageHistory(e), + ))); + } + // TODO: don't do this, have separate from from details + message.from = message.from.as_bare(); + let _ = self + .update_sender + .send(UpdateMessage::Message { to: jid, message }) + .await; + } + Err(_) => { + // let _ = sender.send(result); + } + } + } + Command::SendPresence(jid, presence, sender) => { + let mut presence: stanza::client::presence::Presence = presence.into(); + if let Some(jid) = jid { + presence.to = Some(jid); + }; + let result = connection + .write_handle() + .write(Stanza::Presence(presence)) + .await; + // .map_err(|e| StatusError::Write(e)); + let _ = sender.send(result); + } + } + } + + async fn handle_offline(self, command: Command) { + match command { + Command::GetRoster(sender) => { + let roster = self.db.read_cached_roster().await; + match roster { + Ok(roster) => { + let _ = sender.send(Ok(roster)); + } + Err(e) => { + let _ = sender.send(Err(RosterError::Cache(e.into()))); + } + } + } + Command::GetChats(sender) => { + let chats = self.db.read_chats().await.map_err(|e| e.into()); + sender.send(chats); + } + Command::GetChatsOrdered(sender) => { + let chats = self.db.read_chats_ordered().await.map_err(|e| e.into()); + sender.send(chats); + } + Command::GetChatsOrderedWithLatestMessages(sender) => { + let chats = self + .db + .read_chats_ordered_with_latest_messages() + .await + .map_err(|e| e.into()); + sender.send(chats); + } + Command::GetChat(jid, sender) => { + let chats = self.db.read_chat(jid).await.map_err(|e| e.into()); + sender.send(chats); + } + Command::GetMessages(jid, sender) => { + let messages = self + .db + .read_message_history(jid) + .await + .map_err(|e| e.into()); + sender.send(messages); + } + Command::DeleteChat(jid, sender) => { + let result = self.db.delete_chat(jid).await.map_err(|e| e.into()); + sender.send(result); + } + Command::DeleteMessage(uuid, sender) => { + let result = self.db.delete_message(uuid).await.map_err(|e| e.into()); + sender.send(result); + } + Command::GetUser(jid, sender) => { + let user = self.db.read_user(jid).await.map_err(|e| e.into()); + sender.send(user); + } + // TODO: offline queue to modify roster + Command::AddContact(_jid, sender) => { + sender.send(Err(RosterError::Write(WriteError::Disconnected))); + } + Command::BuddyRequest(_jid, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + Command::SubscriptionRequest(_jid, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + Command::AcceptBuddyRequest(_jid, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + Command::AcceptSubscriptionRequest(_jid, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + Command::UnsubscribeFromContact(_jid, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + Command::UnsubscribeContact(_jid, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + Command::UnfriendContact(_jid, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + Command::DeleteContact(_jid, sender) => { + sender.send(Err(RosterError::Write(WriteError::Disconnected))); + } + Command::UpdateContact(_jid, _contact_update, sender) => { + sender.send(Err(RosterError::Write(WriteError::Disconnected))); + } + Command::SetStatus(online, sender) => { + let result = self + .db + .upsert_cached_status(online) + .await + .map_err(|e| StatusError::Cache(e.into())); + sender.send(result); + } + // TODO: offline message queue + Command::SendMessage(_jid, _body, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + Command::SendPresence(_jid, _presence, sender) => { + sender.send(Err(WriteError::Disconnected)); + } + } + } + // pub async fn handle_stream_error(self, error) {} + // stanza errors (recoverable) + // pub async fn handle_error(self, error: Error) {} + // when it aborts, must clear iq map no matter what + async fn on_abort(self) { + let mut iqs = self.pending.lock().await; + for (_id, sender) in iqs.drain() { + let _ = sender.send(Err(ReadError::LostConnection)); + } + } + + async fn handle_connection_error(self, error: ConnectionError) { + self.update_sender + .send(UpdateMessage::Error( + ConnectionError::AlreadyConnected.into(), + )) + .await; + } +} + +impl From for CoreClientCommand { + fn from(value: Command) -> Self { + CoreClientCommand::Command(value) + } +} + +#[derive(Debug, Clone)] +pub enum UpdateMessage { + Error(Error), + Online(Online, Vec), + Offline(Offline), + /// received roster from jabber server (replace full app roster state with this) + /// is this needed? + FullRoster(Vec), + /// (only update app roster state, don't replace) + RosterUpdate(Contact), + RosterDelete(JID), + /// presences should be stored with users in the ui, not contacts, as presences can be received from anyone + Presence { + from: JID, + presence: Presence, + }, + // TODO: receipts + // MessageDispatched(Uuid), + Message { + to: JID, + message: Message, + }, + SubscriptionRequest(jid::JID), +} diff --git a/filamento/src/presence.rs b/filamento/src/presence.rs new file mode 100644 index 0000000..e35761c --- /dev/null +++ b/filamento/src/presence.rs @@ -0,0 +1,151 @@ +use chrono::{DateTime, Utc}; +use sqlx::Sqlite; +use stanza::{client::presence::String1024, xep_0203::Delay}; + +#[derive(Debug, Default, sqlx::FromRow, Clone)] +pub struct Online { + pub show: Option, + #[sqlx(rename = "message")] + pub status: Option, + #[sqlx(skip)] + pub priority: Option, +} + +#[derive(Debug, Clone, Copy)] +pub enum Show { + Away, + Chat, + DoNotDisturb, + ExtendedAway, +} + +impl sqlx::Type for Show { + fn type_info() -> ::TypeInfo { + <&str as sqlx::Type>::type_info() + } +} + +impl sqlx::Decode<'_, Sqlite> for Show { + fn decode( + value: ::ValueRef<'_>, + ) -> Result { + let value = <&str as sqlx::Decode>::decode(value)?; + match value { + "away" => Ok(Self::Away), + "chat" => Ok(Self::Chat), + "do-not-disturb" => Ok(Self::DoNotDisturb), + "extended-away" => Ok(Self::ExtendedAway), + _ => unreachable!(), + } + } +} + +impl sqlx::Encode<'_, Sqlite> for Show { + fn encode_by_ref( + &self, + buf: &mut ::ArgumentBuffer<'_>, + ) -> Result { + let value = match self { + Show::Away => "away", + Show::Chat => "chat", + Show::DoNotDisturb => "do-not-disturb", + Show::ExtendedAway => "extended-away", + }; + <&str as sqlx::Encode>::encode(value, buf) + } +} + +#[derive(Debug, Default, Clone)] +pub struct Offline { + pub status: Option, +} + +#[derive(Debug, Clone)] +pub enum PresenceType { + Online(Online), + Offline(Offline), +} + +#[derive(Debug, Clone)] +pub struct Presence { + pub timestamp: DateTime, + pub presence: PresenceType, +} + +impl Online { + pub fn into_stanza( + self, + timestamp: Option>, + ) -> stanza::client::presence::Presence { + stanza::client::presence::Presence { + from: None, + id: None, + to: None, + r#type: None, + lang: None, + show: self.show.map(|show| match show { + Show::Away => stanza::client::presence::Show::Away, + Show::Chat => stanza::client::presence::Show::Chat, + Show::DoNotDisturb => stanza::client::presence::Show::Dnd, + Show::ExtendedAway => stanza::client::presence::Show::Xa, + }), + // TODO: enforce message length in status message + status: self.status.map(|status| stanza::client::presence::Status { + lang: None, + status: String1024(status), + }), + priority: self + .priority + .map(|priority| stanza::client::presence::Priority(priority)), + errors: Vec::new(), + delay: timestamp.map(|timestamp| Delay { + from: None, + stamp: timestamp, + }), + } + } +} + +impl Offline { + pub fn into_stanza( + self, + timestamp: Option>, + ) -> stanza::client::presence::Presence { + stanza::client::presence::Presence { + from: None, + id: None, + to: None, + r#type: Some(stanza::client::presence::PresenceType::Unavailable), + lang: None, + show: None, + status: self.status.map(|status| stanza::client::presence::Status { + lang: None, + status: String1024(status), + }), + priority: None, + errors: Vec::new(), + delay: timestamp.map(|timestamp| Delay { + from: None, + stamp: timestamp, + }), + } + } +} + +impl From for stanza::client::presence::Presence { + fn from(value: PresenceType) -> Self { + match value { + PresenceType::Online(online) => online.into_stanza(None), + PresenceType::Offline(offline) => offline.into_stanza(None), + } + } +} + +impl From for stanza::client::presence::Presence { + fn from(value: Presence) -> Self { + match value.presence { + PresenceType::Online(online) => online.into_stanza(Some(value.timestamp)), + PresenceType::Offline(offline) => offline.into_stanza(Some(value.timestamp)), + } + } +} diff --git a/filamento/src/roster.rs b/filamento/src/roster.rs new file mode 100644 index 0000000..43c32f5 --- /dev/null +++ b/filamento/src/roster.rs @@ -0,0 +1,127 @@ +use std::collections::HashSet; + +use jid::JID; +use sqlx::Sqlite; + +pub struct ContactUpdate { + pub name: Option, + pub groups: HashSet, +} + +#[derive(Debug, sqlx::FromRow, Clone)] +pub struct Contact { + // jid is the id used to reference everything, but not the primary key + pub user_jid: JID, + pub subscription: Subscription, + /// client user defined name + pub name: Option, + // TODO: avatar, nickname + /// nickname picked by contact + // nickname: Option, + #[sqlx(skip)] + pub groups: HashSet, +} + +#[derive(Debug, Clone)] +pub enum Subscription { + None, + PendingOut, + PendingIn, + PendingInPendingOut, + OnlyOut, + OnlyIn, + OutPendingIn, + InPendingOut, + Buddy, + // TODO: perhaps don't need, just emit event to remove contact + // Remove, +} + +impl sqlx::Type for Subscription { + fn type_info() -> ::TypeInfo { + <&str as sqlx::Type>::type_info() + } +} + +impl sqlx::Decode<'_, Sqlite> for Subscription { + fn decode( + value: ::ValueRef<'_>, + ) -> Result { + let value = <&str as sqlx::Decode>::decode(value)?; + match value { + "none" => Ok(Self::None), + "pending-out" => Ok(Self::PendingOut), + "pending-in" => Ok(Self::PendingIn), + "pending-in-pending-out" => Ok(Self::PendingInPendingOut), + "only-out" => Ok(Self::OnlyOut), + "only-in" => Ok(Self::OnlyIn), + "out-pending-in" => Ok(Self::OutPendingIn), + "in-pending-out" => Ok(Self::InPendingOut), + "buddy" => Ok(Self::Buddy), + _ => panic!("unexpected subscription `{value}`"), + } + } +} + +impl sqlx::Encode<'_, Sqlite> for Subscription { + fn encode_by_ref( + &self, + buf: &mut ::ArgumentBuffer<'_>, + ) -> Result { + let value = match self { + Subscription::None => "none", + Subscription::PendingOut => "pending-out", + Subscription::PendingIn => "pending-in", + Subscription::PendingInPendingOut => "pending-in-pending-out", + Subscription::OnlyOut => "only-out", + Subscription::OnlyIn => "only-in", + Subscription::OutPendingIn => "out-pending-in", + Subscription::InPendingOut => "in-pending-out", + Subscription::Buddy => "buddy", + }; + <&str as sqlx::Encode>::encode(value, buf) + } +} + +// none +// > +// >> +// < +// << +// >< +// >>< +// ><< +// >><< + +impl From for Contact { + fn from(value: stanza::roster::Item) -> Self { + let subscription = match value.ask { + true => match value.subscription { + Some(s) => match s { + stanza::roster::Subscription::Both => Subscription::Buddy, + stanza::roster::Subscription::From => Subscription::InPendingOut, + stanza::roster::Subscription::None => Subscription::PendingOut, + stanza::roster::Subscription::Remove => Subscription::PendingOut, + stanza::roster::Subscription::To => Subscription::OnlyOut, + }, + None => Subscription::PendingOut, + }, + false => match value.subscription { + Some(s) => match s { + stanza::roster::Subscription::Both => Subscription::Buddy, + stanza::roster::Subscription::From => Subscription::OnlyIn, + stanza::roster::Subscription::None => Subscription::None, + stanza::roster::Subscription::Remove => Subscription::None, + stanza::roster::Subscription::To => Subscription::OnlyOut, + }, + None => Subscription::None, + }, + }; + Contact { + user_jid: value.jid, + subscription, + name: value.name, + groups: HashSet::from_iter(value.groups.into_iter().filter_map(|group| group.0)), + } + } +} diff --git a/filamento/src/user.rs b/filamento/src/user.rs new file mode 100644 index 0000000..9914d14 --- /dev/null +++ b/filamento/src/user.rs @@ -0,0 +1,7 @@ +use jid::JID; + +#[derive(Debug, sqlx::FromRow)] +pub struct User { + pub jid: JID, + pub cached_status_message: Option, +} diff --git a/jabber/Cargo.lock b/jabber/Cargo.lock deleted file mode 100644 index d45d7c1..0000000 --- a/jabber/Cargo.lock +++ /dev/null @@ -1,1935 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "addr2line" -version = "0.24.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1" -dependencies = [ - "gimli", -] - -[[package]] -name = "adler2" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" - -[[package]] -name = "aho-corasick" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" -dependencies = [ - "memchr", -] - -[[package]] -name = "anstream" -version = "0.6.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b" -dependencies = [ - "anstyle", - "anstyle-parse", - "anstyle-query", - "anstyle-wincon", - "colorchoice", - "is_terminal_polyfill", - "utf8parse", -] - -[[package]] -name = "anstyle" -version = "1.0.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9" - -[[package]] -name = "anstyle-parse" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9" -dependencies = [ - "utf8parse", -] - -[[package]] -name = "anstyle-query" -version = "1.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c" -dependencies = [ - "windows-sys 0.59.0", -] - -[[package]] -name = "anstyle-wincon" -version = "3.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125" -dependencies = [ - "anstyle", - "windows-sys 0.59.0", -] - -[[package]] -name = "async-recursion" -version = "1.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "async-trait" -version = "0.1.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "autocfg" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" - -[[package]] -name = "backtrace" -version = "0.3.74" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a" -dependencies = [ - "addr2line", - "cfg-if", - "libc", - "miniz_oxide", - "object", - "rustc-demangle", - "windows-targets 0.52.6", -] - -[[package]] -name = "base64" -version = "0.22.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" - -[[package]] -name = "bitflags" -version = "2.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" - -[[package]] -name = "block-buffer" -version = "0.10.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" -dependencies = [ - "generic-array", -] - -[[package]] -name = "byteorder" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" - -[[package]] -name = "bytes" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da" - -[[package]] -name = "cc" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd9de9f2205d5ef3fd67e685b0df337994ddd4495e2a28d185500d0e1edfea47" -dependencies = [ - "shlex", -] - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "circular" -version = "0.3.0" -dependencies = [ - "bytes", -] - -[[package]] -name = "colorchoice" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990" - -[[package]] -name = "core-foundation" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "core-foundation-sys" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" - -[[package]] -name = "core2" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505" -dependencies = [ - "memchr", -] - -[[package]] -name = "cpufeatures" -version = "0.2.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "16b80225097f2e5ae4e7179dd2266824648f3e2f49d9134d584b76389d31c4c3" -dependencies = [ - "libc", -] - -[[package]] -name = "crypto-common" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" -dependencies = [ - "generic-array", - "typenum", -] - -[[package]] -name = "data-encoding" -version = "2.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2" - -[[package]] -name = "digest" -version = "0.10.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" -dependencies = [ - "block-buffer", - "crypto-common", - "subtle", -] - -[[package]] -name = "displaydoc" -version = "0.2.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "enum-as-inner" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116" -dependencies = [ - "heck", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "env_filter" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab" -dependencies = [ - "log", - "regex", -] - -[[package]] -name = "env_logger" -version = "0.11.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d" -dependencies = [ - "anstream", - "anstyle", - "env_filter", - "humantime", - "log", -] - -[[package]] -name = "errno" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba" -dependencies = [ - "libc", - "windows-sys 0.52.0", -] - -[[package]] -name = "fastrand" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4" - -[[package]] -name = "foreign-types" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" -dependencies = [ - "foreign-types-shared", -] - -[[package]] -name = "foreign-types-shared" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" - -[[package]] -name = "form_urlencoded" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" -dependencies = [ - "percent-encoding", -] - -[[package]] -name = "futures" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" -dependencies = [ - "futures-channel", - "futures-core", - "futures-executor", - "futures-io", - "futures-sink", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-channel" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" -dependencies = [ - "futures-core", - "futures-sink", -] - -[[package]] -name = "futures-core" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" - -[[package]] -name = "futures-executor" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" -dependencies = [ - "futures-core", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-io" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" - -[[package]] -name = "futures-macro" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "futures-sink" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" - -[[package]] -name = "futures-task" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" - -[[package]] -name = "futures-util" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" -dependencies = [ - "futures-channel", - "futures-core", - "futures-io", - "futures-macro", - "futures-sink", - "futures-task", - "memchr", - "pin-project-lite", - "pin-utils", - "slab", -] - -[[package]] -name = "generic-array" -version = "0.14.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" -dependencies = [ - "typenum", - "version_check", -] - -[[package]] -name = "getrandom" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" -dependencies = [ - "cfg-if", - "libc", - "wasi", -] - -[[package]] -name = "gimli" -version = "0.31.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f" - -[[package]] -name = "heck" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" - -[[package]] -name = "hermit-abi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" - -[[package]] -name = "hmac" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" -dependencies = [ - "digest", -] - -[[package]] -name = "hostname" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867" -dependencies = [ - "libc", - "match_cfg", - "winapi", -] - -[[package]] -name = "humantime" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" - -[[package]] -name = "icu_collections" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526" -dependencies = [ - "displaydoc", - "yoke", - "zerofrom", - "zerovec", -] - -[[package]] -name = "icu_locid" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637" -dependencies = [ - "displaydoc", - "litemap", - "tinystr", - "writeable", - "zerovec", -] - -[[package]] -name = "icu_locid_transform" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e" -dependencies = [ - "displaydoc", - "icu_locid", - "icu_locid_transform_data", - "icu_provider", - "tinystr", - "zerovec", -] - -[[package]] -name = "icu_locid_transform_data" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e" - -[[package]] -name = "icu_normalizer" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f" -dependencies = [ - "displaydoc", - "icu_collections", - "icu_normalizer_data", - "icu_properties", - "icu_provider", - "smallvec", - "utf16_iter", - "utf8_iter", - "write16", - "zerovec", -] - -[[package]] -name = "icu_normalizer_data" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516" - -[[package]] -name = "icu_properties" -version = "1.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5" -dependencies = [ - "displaydoc", - "icu_collections", - "icu_locid_transform", - "icu_properties_data", - "icu_provider", - "tinystr", - "zerovec", -] - -[[package]] -name = "icu_properties_data" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569" - -[[package]] -name = "icu_provider" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9" -dependencies = [ - "displaydoc", - "icu_locid", - "icu_provider_macros", - "stable_deref_trait", - "tinystr", - "writeable", - "yoke", - "zerofrom", - "zerovec", -] - -[[package]] -name = "icu_provider_macros" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "idna" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8" -dependencies = [ - "matches", - "unicode-bidi", - "unicode-normalization", -] - -[[package]] -name = "idna" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" -dependencies = [ - "idna_adapter", - "smallvec", - "utf8_iter", -] - -[[package]] -name = "idna_adapter" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71" -dependencies = [ - "icu_normalizer", - "icu_properties", -] - -[[package]] -name = "ipconfig" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f" -dependencies = [ - "socket2", - "widestring", - "windows-sys 0.48.0", - "winreg", -] - -[[package]] -name = "ipnet" -version = "2.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddc24109865250148c2e0f3d25d4f0f479571723792d3802153c60922a4fb708" - -[[package]] -name = "is_terminal_polyfill" -version = "1.70.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" - -[[package]] -name = "itoa" -version = "1.0.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a73e9fe3c49d7afb2ace819fa181a287ce54a0983eda4e0eb05c22f82ffe534" - -[[package]] -name = "lazy_static" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" - -[[package]] -name = "libc" -version = "0.2.164" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "433bfe06b8c75da9b2e3fbea6e5329ff87748f0b144ef75306e674c3f6f7c13f" - -[[package]] -name = "linked-hash-map" -version = "0.5.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f" - -[[package]] -name = "linux-raw-sys" -version = "0.4.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" - -[[package]] -name = "litemap" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "643cb0b8d4fcc284004d5fd0d67ccf61dfffadb7f75e1e71bc420f4688a3a704" - -[[package]] -name = "lock_api" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" -dependencies = [ - "autocfg", - "scopeguard", -] - -[[package]] -name = "log" -version = "0.4.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" - -[[package]] -name = "lru-cache" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c" -dependencies = [ - "linked-hash-map", -] - -[[package]] -name = "luz" -version = "0.0.1" -dependencies = [ - "async-recursion", - "async-trait", - "env_logger", - "futures", - "lazy_static", - "nanoid", - "peanuts", - "rsasl", - "test-log", - "tokio", - "tokio-native-tls", - "tracing", - "tracing-subscriber", - "trust-dns-resolver", - "try_map", -] - -[[package]] -name = "match_cfg" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4" - -[[package]] -name = "matchers" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" -dependencies = [ - "regex-automata 0.1.10", -] - -[[package]] -name = "matches" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5" - -[[package]] -name = "memchr" -version = "2.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" - -[[package]] -name = "minimal-lexical" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" - -[[package]] -name = "miniz_oxide" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1" -dependencies = [ - "adler2", -] - -[[package]] -name = "mio" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec" -dependencies = [ - "hermit-abi", - "libc", - "wasi", - "windows-sys 0.52.0", -] - -[[package]] -name = "nanoid" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ffa00dec017b5b1a8b7cf5e2c008bfda1aa7e0697ac1508b491fdf2622fb4d8" -dependencies = [ - "rand", -] - -[[package]] -name = "native-tls" -version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466" -dependencies = [ - "libc", - "log", - "openssl", - "openssl-probe", - "openssl-sys", - "schannel", - "security-framework", - "security-framework-sys", - "tempfile", -] - -[[package]] -name = "nom" -version = "7.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" -dependencies = [ - "memchr", - "minimal-lexical", -] - -[[package]] -name = "nu-ansi-term" -version = "0.46.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" -dependencies = [ - "overload", - "winapi", -] - -[[package]] -name = "object" -version = "0.36.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aedf0a2d09c573ed1d8d85b30c119153926a2b36dce0ab28322c09a117a4683e" -dependencies = [ - "memchr", -] - -[[package]] -name = "once_cell" -version = "1.20.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" - -[[package]] -name = "openssl" -version = "0.10.68" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6174bc48f102d208783c2c84bf931bb75927a617866870de8a4ea85597f871f5" -dependencies = [ - "bitflags", - "cfg-if", - "foreign-types", - "libc", - "once_cell", - "openssl-macros", - "openssl-sys", -] - -[[package]] -name = "openssl-macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "openssl-probe" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" - -[[package]] -name = "openssl-sys" -version = "0.9.104" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "45abf306cbf99debc8195b66b7346498d7b10c210de50418b5ccd7ceba08c741" -dependencies = [ - "cc", - "libc", - "pkg-config", - "vcpkg", -] - -[[package]] -name = "overload" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" - -[[package]] -name = "parking_lot" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" -dependencies = [ - "lock_api", - "parking_lot_core", -] - -[[package]] -name = "parking_lot_core" -version = "0.9.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" -dependencies = [ - "cfg-if", - "libc", - "redox_syscall", - "smallvec", - "windows-targets 0.52.6", -] - -[[package]] -name = "pbkdf2" -version = "0.12.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" -dependencies = [ - "digest", -] - -[[package]] -name = "peanuts" -version = "0.1.0" -dependencies = [ - "async-recursion", - "circular", - "futures", - "nom", - "tokio", - "tracing", -] - -[[package]] -name = "percent-encoding" -version = "2.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" - -[[package]] -name = "pin-project-lite" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff" - -[[package]] -name = "pin-utils" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" - -[[package]] -name = "pkg-config" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2" - -[[package]] -name = "ppv-lite86" -version = "0.2.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" -dependencies = [ - "zerocopy", -] - -[[package]] -name = "proc-macro2" -version = "1.0.89" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quick-error" -version = "1.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" - -[[package]] -name = "quote" -version = "1.0.37" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "rand" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" -dependencies = [ - "libc", - "rand_chacha", - "rand_core", -] - -[[package]] -name = "rand_chacha" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" -dependencies = [ - "ppv-lite86", - "rand_core", -] - -[[package]] -name = "rand_core" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" -dependencies = [ - "getrandom", -] - -[[package]] -name = "redox_syscall" -version = "0.5.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f" -dependencies = [ - "bitflags", -] - -[[package]] -name = "regex" -version = "1.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" -dependencies = [ - "aho-corasick", - "memchr", - "regex-automata 0.4.9", - "regex-syntax 0.8.5", -] - -[[package]] -name = "regex-automata" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" -dependencies = [ - "regex-syntax 0.6.29", -] - -[[package]] -name = "regex-automata" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax 0.8.5", -] - -[[package]] -name = "regex-syntax" -version = "0.6.29" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" - -[[package]] -name = "regex-syntax" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" - -[[package]] -name = "resolv-conf" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52e44394d2086d010551b14b53b1f24e31647570cd1deb0379e2c21b329aba00" -dependencies = [ - "hostname", - "quick-error", -] - -[[package]] -name = "rsasl" -version = "2.2.0" -dependencies = [ - "base64", - "core2", - "digest", - "hmac", - "pbkdf2", - "rand", - "serde_json", - "sha1", - "stringprep", - "thiserror", -] - -[[package]] -name = "rustc-demangle" -version = "0.1.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" - -[[package]] -name = "rustix" -version = "0.38.41" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6" -dependencies = [ - "bitflags", - "errno", - "libc", - "linux-raw-sys", - "windows-sys 0.52.0", -] - -[[package]] -name = "ryu" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" - -[[package]] -name = "schannel" -version = "0.1.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d" -dependencies = [ - "windows-sys 0.59.0", -] - -[[package]] -name = "scopeguard" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" - -[[package]] -name = "security-framework" -version = "2.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" -dependencies = [ - "bitflags", - "core-foundation", - "core-foundation-sys", - "libc", - "security-framework-sys", -] - -[[package]] -name = "security-framework-sys" -version = "2.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa39c7303dc58b5543c94d22c1766b0d31f2ee58306363ea622b10bbc075eaa2" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "serde" -version = "1.0.215" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_derive" -version = "1.0.215" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "serde_json" -version = "1.0.133" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377" -dependencies = [ - "itoa", - "memchr", - "ryu", - "serde", -] - -[[package]] -name = "sha1" -version = "0.10.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" -dependencies = [ - "cfg-if", - "cpufeatures", - "digest", -] - -[[package]] -name = "sharded-slab" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" -dependencies = [ - "lazy_static", -] - -[[package]] -name = "shlex" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" - -[[package]] -name = "signal-hook-registry" -version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1" -dependencies = [ - "libc", -] - -[[package]] -name = "slab" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" -dependencies = [ - "autocfg", -] - -[[package]] -name = "smallvec" -version = "1.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" - -[[package]] -name = "socket2" -version = "0.5.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c" -dependencies = [ - "libc", - "windows-sys 0.52.0", -] - -[[package]] -name = "stable_deref_trait" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" - -[[package]] -name = "stringprep" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1" -dependencies = [ - "unicode-bidi", - "unicode-normalization", - "unicode-properties", -] - -[[package]] -name = "subtle" -version = "2.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" - -[[package]] -name = "syn" -version = "1.0.109" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "syn" -version = "2.0.87" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "synstructure" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "tempfile" -version = "3.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c" -dependencies = [ - "cfg-if", - "fastrand", - "once_cell", - "rustix", - "windows-sys 0.59.0", -] - -[[package]] -name = "test-log" -version = "0.2.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3dffced63c2b5c7be278154d76b479f9f9920ed34e7574201407f0b14e2bbb93" -dependencies = [ - "env_logger", - "test-log-macros", - "tracing-subscriber", -] - -[[package]] -name = "test-log-macros" -version = "0.2.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5999e24eaa32083191ba4e425deb75cdf25efefabe5aaccb7446dd0d4122a3f5" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "thiserror" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" -dependencies = [ - "thiserror-impl", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "thread_local" -version = "1.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" -dependencies = [ - "cfg-if", - "once_cell", -] - -[[package]] -name = "tinystr" -version = "0.7.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f" -dependencies = [ - "displaydoc", - "zerovec", -] - -[[package]] -name = "tinyvec" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938" -dependencies = [ - "tinyvec_macros", -] - -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - -[[package]] -name = "tokio" -version = "1.41.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22cfb5bee7a6a52939ca9224d6ac897bb669134078daa8735560897f69de4d33" -dependencies = [ - "backtrace", - "bytes", - "libc", - "mio", - "parking_lot", - "pin-project-lite", - "signal-hook-registry", - "socket2", - "tokio-macros", - "windows-sys 0.52.0", -] - -[[package]] -name = "tokio-macros" -version = "2.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "tokio-native-tls" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2" -dependencies = [ - "native-tls", - "tokio", -] - -[[package]] -name = "tracing" -version = "0.1.41" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" -dependencies = [ - "pin-project-lite", - "tracing-attributes", - "tracing-core", -] - -[[package]] -name = "tracing-attributes" -version = "0.1.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "tracing-core" -version = "0.1.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c" -dependencies = [ - "once_cell", - "valuable", -] - -[[package]] -name = "tracing-log" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" -dependencies = [ - "log", - "once_cell", - "tracing-core", -] - -[[package]] -name = "tracing-subscriber" -version = "0.3.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b" -dependencies = [ - "matchers", - "nu-ansi-term", - "once_cell", - "regex", - "sharded-slab", - "thread_local", - "tracing", - "tracing-core", - "tracing-log", -] - -[[package]] -name = "trust-dns-proto" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4f7f83d1e4a0e4358ac54c5c3681e5d7da5efc5a7a632c90bb6d6669ddd9bc26" -dependencies = [ - "async-trait", - "cfg-if", - "data-encoding", - "enum-as-inner", - "futures-channel", - "futures-io", - "futures-util", - "idna 0.2.3", - "ipnet", - "lazy_static", - "rand", - "smallvec", - "thiserror", - "tinyvec", - "tokio", - "tracing", - "url", -] - -[[package]] -name = "trust-dns-resolver" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aff21aa4dcefb0a1afbfac26deb0adc93888c7d295fb63ab273ef276ba2b7cfe" -dependencies = [ - "cfg-if", - "futures-util", - "ipconfig", - "lazy_static", - "lru-cache", - "parking_lot", - "resolv-conf", - "smallvec", - "thiserror", - "tokio", - "tracing", - "trust-dns-proto", -] - -[[package]] -name = "try_map" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fb1626d07cb5c1bb2cf17d94c0be4852e8a7c02b041acec9a8c5bdda99f9d580" - -[[package]] -name = "typenum" -version = "1.17.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" - -[[package]] -name = "unicode-bidi" -version = "0.3.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ab17db44d7388991a428b2ee655ce0c212e862eff1768a455c58f9aad6e7893" - -[[package]] -name = "unicode-ident" -version = "1.0.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" - -[[package]] -name = "unicode-normalization" -version = "0.1.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956" -dependencies = [ - "tinyvec", -] - -[[package]] -name = "unicode-properties" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0" - -[[package]] -name = "url" -version = "2.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d157f1b96d14500ffdc1f10ba712e780825526c03d9a49b4d0324b0d9113ada" -dependencies = [ - "form_urlencoded", - "idna 1.0.3", - "percent-encoding", -] - -[[package]] -name = "utf16_iter" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246" - -[[package]] -name = "utf8_iter" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" - -[[package]] -name = "utf8parse" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" - -[[package]] -name = "valuable" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" - -[[package]] -name = "vcpkg" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" - -[[package]] -name = "version_check" -version = "0.9.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" - -[[package]] -name = "wasi" -version = "0.11.0+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" - -[[package]] -name = "widestring" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311" - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "windows-sys" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" -dependencies = [ - "windows-targets 0.48.5", -] - -[[package]] -name = "windows-sys" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" -dependencies = [ - "windows-targets 0.52.6", -] - -[[package]] -name = "windows-sys" -version = "0.59.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" -dependencies = [ - "windows-targets 0.52.6", -] - -[[package]] -name = "windows-targets" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" -dependencies = [ - "windows_aarch64_gnullvm 0.48.5", - "windows_aarch64_msvc 0.48.5", - "windows_i686_gnu 0.48.5", - "windows_i686_msvc 0.48.5", - "windows_x86_64_gnu 0.48.5", - "windows_x86_64_gnullvm 0.48.5", - "windows_x86_64_msvc 0.48.5", -] - -[[package]] -name = "windows-targets" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" -dependencies = [ - "windows_aarch64_gnullvm 0.52.6", - "windows_aarch64_msvc 0.52.6", - "windows_i686_gnu 0.52.6", - "windows_i686_gnullvm", - "windows_i686_msvc 0.52.6", - "windows_x86_64_gnu 0.52.6", - "windows_x86_64_gnullvm 0.52.6", - "windows_x86_64_msvc 0.52.6", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" - -[[package]] -name = "windows_i686_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" - -[[package]] -name = "windows_i686_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" - -[[package]] -name = "windows_i686_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" - -[[package]] -name = "winreg" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" -dependencies = [ - "cfg-if", - "windows-sys 0.48.0", -] - -[[package]] -name = "write16" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936" - -[[package]] -name = "writeable" -version = "0.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51" - -[[package]] -name = "yoke" -version = "0.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c5b1314b079b0930c31e3af543d8ee1757b1951ae1e1565ec704403a7240ca5" -dependencies = [ - "serde", - "stable_deref_trait", - "yoke-derive", - "zerofrom", -] - -[[package]] -name = "yoke-derive" -version = "0.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", - "synstructure", -] - -[[package]] -name = "zerocopy" -version = "0.7.35" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" -dependencies = [ - "byteorder", - "zerocopy-derive", -] - -[[package]] -name = "zerocopy-derive" -version = "0.7.35" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] - -[[package]] -name = "zerofrom" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91ec111ce797d0e0784a1116d0ddcdbea84322cd79e5d5ad173daeba4f93ab55" -dependencies = [ - "zerofrom-derive", -] - -[[package]] -name = "zerofrom-derive" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", - "synstructure", -] - -[[package]] -name = "zerovec" -version = "0.10.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079" -dependencies = [ - "yoke", - "zerofrom", - "zerovec-derive", -] - -[[package]] -name = "zerovec-derive" -version = "0.10.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.87", -] diff --git a/jabber/Cargo.toml b/jabber/Cargo.toml deleted file mode 100644 index fbb776b..0000000 --- a/jabber/Cargo.toml +++ /dev/null @@ -1,42 +0,0 @@ -[package] -name = "jabber" -authors = ["cel "] -version = "0.1.0" -edition = "2021" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[dependencies] -async-recursion = "1.0.4" -async-trait = "0.1.68" -lazy_static = "1.4.0" -nanoid = "0.4.0" -# TODO: remove unneeded features and dependencies -rsasl = { version = "2.0.1", default_features = false, features = [ - "provider_base64", - "plain", - "config_builder", - "scram-sha-1", -] } -tokio = { version = "1.28", features = ["full"] } -tokio-native-tls = "0.3.1" -tracing = "0.1.40" -trust-dns-resolver = "0.22.0" -try_map = "0.3.1" -stanza = { version = "0.1.0", path = "../stanza" } -peanuts = { version = "0.1.0", path = "../../peanuts" } -jid = { version = "0.1.0", path = "../jid" } -futures = "0.3.31" -take_mut = "0.2.2" -pin-project-lite = "0.2.15" -pin-project = "1.1.7" -thiserror = "2.0.11" - -[dev-dependencies] -test-log = { version = "0.2", features = ["trace"] } -env_logger = "*" -tracing-subscriber = { version = "0.3", default-features = false, features = [ - "env-filter", - "fmt", -] } -stanza = { version = "0.1.0", path = "../stanza", features = ["xep_0199"] } diff --git a/jabber/src/client.rs b/jabber/src/client.rs deleted file mode 100644 index de2be08..0000000 --- a/jabber/src/client.rs +++ /dev/null @@ -1,181 +0,0 @@ -use rsasl::config::SASLConfig; -use stanza::{ - sasl::Mechanisms, - stream::{Feature, Features}, -}; - -use crate::{ - connection::{Tls, Unencrypted}, - jabber_stream::bound_stream::BoundJabberStream, - Connection, Error, JabberStream, Result, JID, -}; - -pub async fn connect_and_login( - jid: &mut JID, - password: impl AsRef, - server: &mut String, -) -> Result> { - let auth = SASLConfig::with_credentials( - None, - jid.localpart.clone().ok_or(Error::NoLocalpart)?, - password.as_ref().to_string(), - ) - .map_err(|e| Error::SASL(e.into()))?; - let mut conn_state = Connecting::start(&server).await?; - loop { - match conn_state { - Connecting::InsecureConnectionEstablised(tcp_stream) => { - conn_state = Connecting::InsecureStreamStarted( - JabberStream::start_stream(tcp_stream, server).await?, - ) - } - Connecting::InsecureStreamStarted(jabber_stream) => { - conn_state = Connecting::InsecureGotFeatures(jabber_stream.get_features().await?) - } - Connecting::InsecureGotFeatures((features, jabber_stream)) => { - match features.negotiate().ok_or(Error::Negotiation)? { - Feature::StartTls(_start_tls) => { - conn_state = Connecting::StartTls(jabber_stream) - } - // TODO: better error - _ => return Err(Error::TlsRequired), - } - } - Connecting::StartTls(jabber_stream) => { - conn_state = - Connecting::ConnectionEstablished(jabber_stream.starttls(&server).await?) - } - Connecting::ConnectionEstablished(tls_stream) => { - conn_state = - Connecting::StreamStarted(JabberStream::start_stream(tls_stream, server).await?) - } - Connecting::StreamStarted(jabber_stream) => { - conn_state = Connecting::GotFeatures(jabber_stream.get_features().await?) - } - Connecting::GotFeatures((features, jabber_stream)) => { - match features.negotiate().ok_or(Error::Negotiation)? { - Feature::StartTls(_start_tls) => return Err(Error::AlreadyTls), - Feature::Sasl(mechanisms) => { - conn_state = Connecting::Sasl(mechanisms, jabber_stream) - } - Feature::Bind => conn_state = Connecting::Bind(jabber_stream), - Feature::Unknown => return Err(Error::Unsupported), - } - } - Connecting::Sasl(mechanisms, jabber_stream) => { - conn_state = Connecting::ConnectionEstablished( - jabber_stream.sasl(mechanisms, auth.clone()).await?, - ) - } - Connecting::Bind(jabber_stream) => { - return Ok(jabber_stream.bind(jid).await?.to_bound_jabber()); - } - } - } -} - -pub enum Connecting { - InsecureConnectionEstablised(Unencrypted), - InsecureStreamStarted(JabberStream), - InsecureGotFeatures((Features, JabberStream)), - StartTls(JabberStream), - ConnectionEstablished(Tls), - StreamStarted(JabberStream), - GotFeatures((Features, JabberStream)), - Sasl(Mechanisms, JabberStream), - Bind(JabberStream), -} - -impl Connecting { - pub async fn start(server: &str) -> Result { - match Connection::connect(server).await? { - Connection::Encrypted(tls_stream) => Ok(Connecting::ConnectionEstablished(tls_stream)), - Connection::Unencrypted(tcp_stream) => { - Ok(Connecting::InsecureConnectionEstablised(tcp_stream)) - } - } - } -} - -pub enum InsecureConnecting { - Disconnected, - ConnectionEstablished(Connection), - PreStarttls(JabberStream), - PreAuthenticated(JabberStream), - Authenticated(Tls), - PreBound(JabberStream), - Bound(JabberStream), -} - -#[cfg(test)] -mod tests { - use std::time::Duration; - - use jid::JID; - use stanza::{ - client::{ - iq::{Iq, IqType, Query}, - Stanza, - }, - xep_0199::Ping, - }; - use test_log::test; - use tokio::time::sleep; - use tracing::info; - - use super::connect_and_login; - - #[test(tokio::test)] - async fn login() { - let mut jid: JID = "test@blos.sm".try_into().unwrap(); - let _client = connect_and_login(&mut jid, "slayed", &mut "blos.sm".to_string()) - .await - .unwrap(); - sleep(Duration::from_secs(5)).await - } - - #[test(tokio::test)] - async fn ping_parallel() { - let mut jid: JID = "test@blos.sm".try_into().unwrap(); - let mut server = "blos.sm".to_string(); - let client = connect_and_login(&mut jid, "slayed", &mut server) - .await - .unwrap(); - let (mut read, mut write) = client.split(); - - tokio::join!( - async { - write - .write(&Stanza::Iq(Iq { - from: Some(jid.clone()), - id: "c2s1".to_string(), - to: Some(server.clone().try_into().unwrap()), - r#type: IqType::Get, - lang: None, - query: Some(Query::Ping(Ping)), - errors: Vec::new(), - })) - .await - .unwrap(); - write - .write(&Stanza::Iq(Iq { - from: Some(jid.clone()), - id: "c2s2".to_string(), - to: Some(server.clone().try_into().unwrap()), - r#type: IqType::Get, - lang: None, - query: Some(Query::Ping(Ping)), - errors: Vec::new(), - })) - .await - .unwrap(); - }, - async { - for _ in 0..2 { - let stanza = read.read::().await.unwrap(); - info!("ping reply: {:#?}", stanza); - } - } - ); - } -} diff --git a/jabber/src/connection.rs b/jabber/src/connection.rs deleted file mode 100644 index b185eca..0000000 --- a/jabber/src/connection.rs +++ /dev/null @@ -1,182 +0,0 @@ -use std::net::{IpAddr, SocketAddr}; -use std::str; -use std::str::FromStr; - -use tokio::net::TcpStream; -use tokio_native_tls::native_tls::TlsConnector; -// TODO: use rustls -use tokio_native_tls::TlsStream; -use tracing::{debug, info, instrument, trace}; - -use crate::Result; -use crate::{Error, JID}; - -pub type Tls = TlsStream; -pub type Unencrypted = TcpStream; - -#[derive(Debug)] -pub enum Connection { - Encrypted(Tls), - Unencrypted(Unencrypted), -} - -impl Connection { - // #[instrument] - /// stream not started - // pub async fn ensure_tls(self) -> Result> { - // match self { - // Connection::Encrypted(j) => Ok(j), - // Connection::Unencrypted(mut j) => { - // j.start_stream().await?; - // info!("upgrading connection to tls"); - // j.get_features().await?; - // let j = j.starttls().await?; - // Ok(j) - // } - // } - // } - - pub async fn connect_user(jid: impl AsRef) -> Result { - let jid: JID = JID::from_str(jid.as_ref())?; - let server = jid.domainpart.clone(); - Self::connect(&server).await - } - - #[instrument] - pub async fn connect(server: impl AsRef + std::fmt::Debug) -> Result { - info!("connecting to {}", server.as_ref()); - let sockets = Self::get_sockets(server.as_ref()).await; - debug!("discovered sockets: {:?}", sockets); - for (socket_addr, tls) in sockets { - match tls { - true => { - if let Ok(connection) = Self::connect_tls(socket_addr, server.as_ref()).await { - info!("connected via encrypted stream to {}", socket_addr); - // let (readhalf, writehalf) = tokio::io::split(connection); - return Ok(Self::Encrypted(connection)); - } - } - false => { - if let Ok(connection) = Self::connect_unencrypted(socket_addr).await { - info!("connected via unencrypted stream to {}", socket_addr); - // let (readhalf, writehalf) = tokio::io::split(connection); - return Ok(Self::Unencrypted(connection)); - } - } - } - } - Err(Error::Connection) - } - - #[instrument] - async fn get_sockets(address: &str) -> Vec<(SocketAddr, bool)> { - let mut socket_addrs = Vec::new(); - - // if it's a socket/ip then just return that - - // socket - trace!("checking if address is a socket address"); - if let Ok(socket_addr) = SocketAddr::from_str(address) { - debug!("{} is a socket address", address); - match socket_addr.port() { - 5223 => socket_addrs.push((socket_addr, true)), - _ => socket_addrs.push((socket_addr, false)), - } - - return socket_addrs; - } - // ip - trace!("checking if address is an ip"); - if let Ok(ip) = IpAddr::from_str(address) { - debug!("{} is an ip", address); - socket_addrs.push((SocketAddr::new(ip, 5222), false)); - socket_addrs.push((SocketAddr::new(ip, 5223), true)); - return socket_addrs; - } - - // otherwise resolve - debug!("resolving {}", address); - if let Ok(resolver) = trust_dns_resolver::AsyncResolver::tokio_from_system_conf() { - if let Ok(lookup) = resolver - .srv_lookup(format!("_xmpp-client._tcp.{}", address)) - .await - { - for srv in lookup { - resolver - .lookup_ip(srv.target().to_owned()) - .await - .map(|ips| { - for ip in ips { - socket_addrs.push((SocketAddr::new(ip, srv.port()), false)) - } - }); - } - } - if let Ok(lookup) = resolver - .srv_lookup(format!("_xmpps-client._tcp.{}", address)) - .await - { - for srv in lookup { - resolver - .lookup_ip(srv.target().to_owned()) - .await - .map(|ips| { - for ip in ips { - socket_addrs.push((SocketAddr::new(ip, srv.port()), true)) - } - }); - } - } - - // in case cannot connect through SRV records - resolver.lookup_ip(address).await.map(|ips| { - for ip in ips { - socket_addrs.push((SocketAddr::new(ip, 5222), false)); - socket_addrs.push((SocketAddr::new(ip, 5223), true)); - } - }); - } - socket_addrs - } - - /// establishes a connection to the server - #[instrument] - pub async fn connect_tls(socket_addr: SocketAddr, domain_name: &str) -> Result { - let socket = TcpStream::connect(socket_addr) - .await - .map_err(|_| Error::Connection)?; - let connector = TlsConnector::new().map_err(|_| Error::Connection)?; - tokio_native_tls::TlsConnector::from(connector) - .connect(domain_name, socket) - .await - .map_err(|_| Error::Connection) - } - - #[instrument] - pub async fn connect_unencrypted(socket_addr: SocketAddr) -> Result { - TcpStream::connect(socket_addr) - .await - .map_err(|_| Error::Connection) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use test_log::test; - - #[test(tokio::test)] - async fn connect() { - Connection::connect("blos.sm").await.unwrap(); - } - - // #[test(tokio::test)] - // async fn test_tls() { - // Connection::connect("blos.sm", None, None) - // .await - // .unwrap() - // .ensure_tls() - // .await - // .unwrap(); - // } -} diff --git a/jabber/src/error.rs b/jabber/src/error.rs deleted file mode 100644 index ec60778..0000000 --- a/jabber/src/error.rs +++ /dev/null @@ -1,58 +0,0 @@ -use std::str::Utf8Error; -use std::sync::Arc; - -use jid::ParseError; -use rsasl::mechname::MechanismNameError; -use stanza::client::error::Error as ClientError; -use stanza::sasl::Failure; -use stanza::stream::Error as StreamError; -use thiserror::Error; - -#[derive(Error, Debug, Clone)] -pub enum Error { - #[error("connection")] - Connection, - #[error("utf8 decode: {0}")] - Utf8Decode(#[from] Utf8Error), - #[error("negotiation")] - Negotiation, - #[error("tls required")] - TlsRequired, - #[error("already connected with tls")] - AlreadyTls, - // TODO: specify unsupported feature - #[error("unsupported feature")] - Unsupported, - #[error("jid missing localpart")] - NoLocalpart, - #[error("received unexpected element: {0:?}")] - UnexpectedElement(peanuts::Element), - #[error("xml error: {0}")] - XML(#[from] peanuts::Error), - #[error("sasl error: {0}")] - SASL(#[from] SASLError), - #[error("jid error: {0}")] - JID(#[from] ParseError), - #[error("client stanza error: {0}")] - ClientError(#[from] ClientError), - #[error("stream error: {0}")] - StreamError(#[from] StreamError), - #[error("error missing")] - MissingError, -} - -#[derive(Error, Debug, Clone)] -pub enum SASLError { - #[error("sasl error: {0}")] - SASL(Arc), - #[error("mechanism error: {0}")] - MechanismName(#[from] MechanismNameError), - #[error("authentication failure: {0}")] - Authentication(#[from] Failure), -} - -impl From for SASLError { - fn from(e: rsasl::prelude::SASLError) -> Self { - Self::SASL(Arc::new(e)) - } -} diff --git a/jabber/src/jabber_stream.rs b/jabber/src/jabber_stream.rs deleted file mode 100644 index 302350d..0000000 --- a/jabber/src/jabber_stream.rs +++ /dev/null @@ -1,482 +0,0 @@ -use std::str::{self, FromStr}; -use std::sync::Arc; - -use jid::JID; -use peanuts::element::IntoElement; -use peanuts::{Reader, Writer}; -use rsasl::prelude::{Mechname, SASLClient, SASLConfig}; -use stanza::bind::{Bind, BindType, FullJidType, ResourceType}; -use stanza::client::iq::{Iq, IqType, Query}; -use stanza::client::Stanza; -use stanza::sasl::{Auth, Challenge, Mechanisms, Response, ServerResponse}; -use stanza::starttls::{Proceed, StartTls}; -use stanza::stream::{Features, Stream}; -use stanza::XML_VERSION; -use tokio::io::{AsyncRead, AsyncWrite, ReadHalf, WriteHalf}; -use tokio_native_tls::native_tls::TlsConnector; -use tracing::{debug, instrument}; - -use crate::connection::{Tls, Unencrypted}; -use crate::error::Error; -use crate::Result; - -pub mod bound_stream; - -// open stream (streams started) -pub struct JabberStream { - reader: JabberReader, - writer: JabberWriter, -} - -impl JabberStream { - fn split(self) -> (JabberReader, JabberWriter) { - let reader = self.reader; - let writer = self.writer; - (reader, writer) - } -} - -pub struct JabberReader(Reader>); - -impl JabberReader { - // TODO: consider taking a readhalf and creating peanuts::Reader here, only one inner - fn new(reader: Reader>) -> Self { - Self(reader) - } - - fn unsplit(self, writer: JabberWriter) -> JabberStream { - JabberStream { - reader: self, - writer, - } - } - - fn into_inner(self) -> Reader> { - self.0 - } -} - -impl JabberReader -where - S: AsyncRead + Unpin, -{ - pub async fn try_close(&mut self) -> Result<()> { - self.read_end_tag().await?; - Ok(()) - } -} - -impl std::ops::Deref for JabberReader { - type Target = Reader>; - - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl std::ops::DerefMut for JabberReader { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -pub struct JabberWriter(Writer>); - -impl JabberWriter { - fn new(writer: Writer>) -> Self { - Self(writer) - } - - fn unsplit(self, reader: JabberReader) -> JabberStream { - JabberStream { - reader, - writer: self, - } - } - - fn into_inner(self) -> Writer> { - self.0 - } -} - -impl JabberWriter -where - S: AsyncWrite + Unpin + Send, -{ - pub async fn try_close(&mut self) -> Result<()> { - self.write_end().await?; - Ok(()) - } -} - -impl std::ops::Deref for JabberWriter { - type Target = Writer>; - - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl std::ops::DerefMut for JabberWriter { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl JabberStream -where - S: AsyncRead + AsyncWrite + Unpin + Send + std::fmt::Debug, - JabberStream: std::fmt::Debug, -{ - #[instrument] - pub async fn sasl(mut self, mechanisms: Mechanisms, sasl_config: Arc) -> Result { - let sasl = SASLClient::new(sasl_config); - let mut offered_mechs: Vec<&Mechname> = Vec::new(); - for mechanism in &mechanisms.mechanisms { - offered_mechs - .push(Mechname::parse(mechanism.as_bytes()).map_err(|e| Error::SASL(e.into()))?) - } - debug!("{:?}", offered_mechs); - let mut session = sasl - .start_suggested(&offered_mechs) - .map_err(|e| Error::SASL(e.into()))?; - let selected_mechanism = session.get_mechname().as_str().to_owned(); - debug!("selected mech: {:?}", selected_mechanism); - let mut data: Option>; - - if !session.are_we_first() { - // if not first mention the mechanism then get challenge data - // mention mechanism - let auth = Auth { - mechanism: selected_mechanism, - sasl_data: "=".to_string(), - }; - self.writer.write_full(&auth).await?; - // get challenge data - let challenge: Challenge = self.reader.read().await?; - debug!("challenge: {:?}", challenge); - data = Some((*challenge).as_bytes().to_vec()); - debug!("we didn't go first"); - } else { - // if first, mention mechanism and send data - let mut sasl_data = Vec::new(); - session.step64(None, &mut sasl_data).unwrap(); - let auth = Auth { - mechanism: selected_mechanism, - sasl_data: str::from_utf8(&sasl_data)?.to_string(), - }; - debug!("{:?}", auth); - self.writer.write_full(&auth).await?; - - let server_response: ServerResponse = self.reader.read().await?; - debug!("server_response: {:#?}", server_response); - match server_response { - ServerResponse::Challenge(challenge) => { - data = Some((*challenge).as_bytes().to_vec()) - } - ServerResponse::Success(success) => { - data = success.clone().map(|success| success.as_bytes().to_vec()) - } - ServerResponse::Failure(failure) => return Err(Error::SASL(failure.into())), - } - debug!("we went first"); - } - - // stepping the authentication exchange to completion - if data != None { - debug!("data: {:?}", data); - let mut sasl_data = Vec::new(); - while { - // decide if need to send more data over - let state = session - .step64(data.as_deref(), &mut sasl_data) - .expect("step errored!"); - state.is_running() - } { - // While we aren't finished, receive more data from the other party - let response = Response::new(str::from_utf8(&sasl_data)?.to_string()); - debug!("response: {:?}", response); - self.writer.write_full(&response).await?; - debug!("response written"); - - let server_response: ServerResponse = self.reader.read().await?; - debug!("server_response: {:#?}", server_response); - match server_response { - ServerResponse::Challenge(challenge) => { - data = Some((*challenge).as_bytes().to_vec()) - } - ServerResponse::Success(success) => { - data = success.clone().map(|success| success.as_bytes().to_vec()) - } - ServerResponse::Failure(failure) => return Err(Error::SASL(failure.into())), - } - } - } - let writer = self.writer.into_inner().into_inner(); - let reader = self.reader.into_inner().into_inner(); - let stream = reader.unsplit(writer); - Ok(stream) - } - - #[instrument] - pub async fn bind(mut self, jid: &mut JID) -> Result { - let iq_id = nanoid::nanoid!(); - if let Some(resource) = &jid.resourcepart { - let iq = Iq { - from: None, - id: iq_id.clone(), - to: None, - r#type: IqType::Set, - lang: None, - query: Some(Query::Bind(Bind { - r#type: Some(BindType::Resource(ResourceType(resource.to_string()))), - })), - errors: Vec::new(), - }; - self.writer.write_full(&iq).await?; - let result: Iq = self.reader.read().await?; - match result { - Iq { - from: _, - id, - to: _, - r#type: IqType::Result, - lang: _, - query: - Some(Query::Bind(Bind { - r#type: Some(BindType::Jid(FullJidType(new_jid))), - })), - errors: _, - } if id == iq_id => { - *jid = new_jid; - return Ok(self); - } - Iq { - from: _, - id, - to: _, - r#type: IqType::Error, - lang: _, - query: None, - errors, - } if id == iq_id => { - return Err(Error::ClientError( - errors.first().ok_or(Error::MissingError)?.clone(), - )) - } - _ => return Err(Error::UnexpectedElement(result.into_element())), - } - } else { - let iq = Iq { - from: None, - id: iq_id.clone(), - to: None, - r#type: IqType::Set, - lang: None, - query: Some(Query::Bind(Bind { r#type: None })), - errors: Vec::new(), - }; - self.writer.write_full(&iq).await?; - let result: Iq = self.reader.read().await?; - match result { - Iq { - from: _, - id, - to: _, - r#type: IqType::Result, - lang: _, - query: - Some(Query::Bind(Bind { - r#type: Some(BindType::Jid(FullJidType(new_jid))), - })), - errors: _, - } if id == iq_id => { - *jid = new_jid; - return Ok(self); - } - Iq { - from: _, - id, - to: _, - r#type: IqType::Error, - lang: _, - query: None, - errors, - } if id == iq_id => { - return Err(Error::ClientError( - errors.first().ok_or(Error::MissingError)?.clone(), - )) - } - _ => return Err(Error::UnexpectedElement(result.into_element())), - } - } - } - - #[instrument] - pub async fn start_stream(connection: S, server: &mut String) -> Result { - // client to server - let (reader, writer) = tokio::io::split(connection); - let mut reader = JabberReader::new(Reader::new(reader)); - let mut writer = JabberWriter::new(Writer::new(writer)); - - // declaration - writer.write_declaration(XML_VERSION).await?; - - // opening stream element - let stream = Stream::new_client( - None, - JID::from_str(server.as_ref())?, - None, - "en".to_string(), - ); - writer.write_start(&stream).await?; - - // server to client - - // may or may not send a declaration - let _decl = reader.read_prolog().await?; - - // receive stream element and validate - let stream: Stream = reader.read_start().await?; - debug!("got stream: {:?}", stream); - if let Some(from) = stream.from { - *server = from.to_string(); - } - - Ok(Self { reader, writer }) - } - - #[instrument] - pub async fn get_features(mut self) -> Result<(Features, Self)> { - debug!("getting features"); - let features: Features = self.reader.read().await?; - debug!("got features: {:?}", features); - Ok((features, self)) - } - - pub fn into_inner(self) -> S { - self.reader - .into_inner() - .into_inner() - .unsplit(self.writer.into_inner().into_inner()) - } - - pub async fn send_stanza(&mut self, stanza: &Stanza) -> Result<()> { - self.writer.write(stanza).await?; - Ok(()) - } -} - -impl JabberStream { - #[instrument] - pub async fn starttls(mut self, domain: impl AsRef + std::fmt::Debug) -> Result { - self.writer - .write_full(&StartTls { required: false }) - .await?; - let proceed: Proceed = self.reader.read().await?; - debug!("got proceed: {:?}", proceed); - let connector = TlsConnector::new().unwrap(); - let stream = self - .reader - .into_inner() - .into_inner() - .unsplit(self.writer.into_inner().into_inner()); - if let Ok(tls_stream) = tokio_native_tls::TlsConnector::from(connector) - .connect(domain.as_ref(), stream) - .await - { - return Ok(tls_stream); - } else { - return Err(Error::Connection); - } - } -} - -impl std::fmt::Debug for JabberStream { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Jabber") - .field("connection", &"tls") - .finish() - } -} - -impl std::fmt::Debug for JabberStream { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Jabber") - .field("connection", &"unencrypted") - .finish() - } -} - -#[cfg(test)] -mod tests { - use test_log::test; - - #[test(tokio::test)] - async fn start_stream() { - // let connection = Connection::connect("blos.sm", None, None).await.unwrap(); - // match connection { - // Connection::Encrypted(mut c) => c.start_stream().await.unwrap(), - // Connection::Unencrypted(mut c) => c.start_stream().await.unwrap(), - // } - } - - #[test(tokio::test)] - async fn sasl() { - // let mut jabber = Connection::connect_user("test@blos.sm", "slayed".to_string()) - // .await - // .unwrap() - // .ensure_tls() - // .await - // .unwrap(); - // let text = str::from_utf8(jabber.reader.buffer.data()).unwrap(); - // println!("data: {}", text); - // jabber.start_stream().await.unwrap(); - - // let text = str::from_utf8(jabber.reader.buffer.data()).unwrap(); - // println!("data: {}", text); - // jabber.reader.read_buf().await.unwrap(); - // let text = str::from_utf8(jabber.reader.buffer.data()).unwrap(); - // println!("data: {}", text); - - // let features = jabber.get_features().await.unwrap(); - // let (sasl_config, feature) = ( - // jabber.auth.clone().unwrap(), - // features - // .features - // .iter() - // .find(|feature| matches!(feature, Feature::Sasl(_))) - // .unwrap(), - // ); - // match feature { - // Feature::StartTls(_start_tls) => todo!(), - // Feature::Sasl(mechanisms) => { - // jabber.sasl(mechanisms.clone(), sasl_config).await.unwrap(); - // } - // Feature::Bind => todo!(), - // Feature::Unknown => todo!(), - // } - } - - #[tokio::test] - async fn sink() { - // let mut client = JabberClient::new("test@blos.sm", "slayed").unwrap(); - // client.connect().await.unwrap(); - // let stream = client.inner().unwrap(); - // let sink = sink::unfold(stream, |mut stream, stanza: Stanza| async move { - // stream.writer.write(&stanza).await?; - // Ok::, Error>(stream) - // }); - // todo!() - // let _jabber = Connection::connect_user("test@blos.sm", "slayed".to_string()) - // .await - // .unwrap() - // .ensure_tls() - // .await - // .unwrap() - // .negotiate() - // .await - // .unwrap(); - // sleep(Duration::from_secs(5)).await - } -} diff --git a/jabber/src/jabber_stream/bound_stream.rs b/jabber/src/jabber_stream/bound_stream.rs deleted file mode 100644 index 25b79ff..0000000 --- a/jabber/src/jabber_stream/bound_stream.rs +++ /dev/null @@ -1,87 +0,0 @@ -use std::ops::{Deref, DerefMut}; - -use tokio::io::{AsyncRead, AsyncWrite}; - -use super::{JabberReader, JabberStream, JabberWriter}; - -pub struct BoundJabberStream(JabberStream); - -impl Deref for BoundJabberStream -where - S: AsyncWrite + AsyncRead + Unpin + Send, -{ - type Target = JabberStream; - - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for BoundJabberStream -where - S: AsyncWrite + AsyncRead + Unpin + Send, -{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl BoundJabberStream { - pub fn split(self) -> (BoundJabberReader, BoundJabberWriter) { - let (reader, writer) = self.0.split(); - (BoundJabberReader(reader), BoundJabberWriter(writer)) - } -} - -pub struct BoundJabberReader(JabberReader); - -impl BoundJabberReader { - pub fn unsplit(self, writer: BoundJabberWriter) -> BoundJabberStream { - BoundJabberStream(self.0.unsplit(writer.0)) - } -} - -impl std::ops::Deref for BoundJabberReader { - type Target = JabberReader; - - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl std::ops::DerefMut for BoundJabberReader { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -pub struct BoundJabberWriter(JabberWriter); - -impl BoundJabberWriter { - pub fn unsplit(self, reader: BoundJabberReader) -> BoundJabberStream { - BoundJabberStream(self.0.unsplit(reader.0)) - } -} - -impl std::ops::Deref for BoundJabberWriter { - type Target = JabberWriter; - - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl std::ops::DerefMut for BoundJabberWriter { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl JabberStream -where - S: AsyncWrite + AsyncRead + Unpin + Send, -{ - pub fn to_bound_jabber(self) -> BoundJabberStream { - BoundJabberStream(self) - } -} diff --git a/jabber/src/lib.rs b/jabber/src/lib.rs deleted file mode 100644 index 8855ca7..0000000 --- a/jabber/src/lib.rs +++ /dev/null @@ -1,25 +0,0 @@ -#![allow(unused_must_use)] -// #![feature(let_chains)] - -// TODO: logging (dropped errors) -pub mod client; -pub mod connection; -pub mod error; -pub mod jabber_stream; - -pub use connection::Connection; -pub use error::Error; -pub use jabber_stream::JabberStream; -pub use jid::JID; - -pub type Result = std::result::Result; - -pub use client::connect_and_login; - -#[cfg(test)] -mod tests { - // #[tokio::test] - // async fn test_login() { - // crate::login("test@blos.sm/clown", "slayed").await.unwrap(); - // } -} diff --git a/lampada/.gitignore b/lampada/.gitignore new file mode 100644 index 0000000..60868fd --- /dev/null +++ b/lampada/.gitignore @@ -0,0 +1,2 @@ +luz.db +.sqlx/ diff --git a/lampada/Cargo.toml b/lampada/Cargo.toml new file mode 100644 index 0000000..856fd7d --- /dev/null +++ b/lampada/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "lampada" +version = "0.1.0" +edition = "2021" + +[dependencies] +futures = "0.3.31" +luz = { version = "0.1.0", path = "../luz" } +peanuts = { version = "0.1.0", path = "../../peanuts" } +jid = { version = "0.1.0", path = "../jid", features = ["sqlx"] } +stanza = { version = "0.1.0", path = "../stanza", features = ["xep_0203"] } +tokio = "1.42.0" +tokio-stream = "0.1.17" +tokio-util = "0.7.13" +tracing = "0.1.41" +tracing-subscriber = "0.3.19" +thiserror = "2.0.11" diff --git a/lampada/README.md b/lampada/README.md new file mode 100644 index 0000000..dc5f016 --- /dev/null +++ b/lampada/README.md @@ -0,0 +1,3 @@ +# lampada + +a core xmpp client that graciously manages streams, delegating logic to an implementor of a trait. diff --git a/lampada/scratch b/lampada/scratch new file mode 100644 index 0000000..e013ded --- /dev/null +++ b/lampada/scratch @@ -0,0 +1,90 @@ +macaw/céu +canopy/sol + +# logic: + +- db +- pending iqs +- ui update sender + + ## logic methods + + - handle_offline: called by lamp + - handle_online: called by lamp + - handle_stanza: called by read thread + + - handle_connect: called by lamp + - handle_disconnect: called by lamp + + - handle_error?: called by lamp handle threads and read thread for error logging + - handle_stream_error: called by supervisor when stream needs to be reset + + +# lamp: + +- login jid (bare or full) +- password provider +- lamp command receiver +- connected session state(connected, supervisorhandle to disconnect current connected session) +- connected state (if intended to be connected or not, for retrying reconnection every minute or something) +- on_crash for connection supervisor +- internal logic struct which has methods to handle logic commands + +# connected: + +- writehandle +- current full jid for connected session + +# supervisor: + +- control_recv +- read_thread_crash +- write_thread_crash +- read_control_handle +- write_control_handle +- on_crash +- connected +- password +- logic + +# read: + +must be passed around when crash +- supervisor_control +- tasks + +can be cloned from supervisor +- connected . +- logic . + +can be recreated by supervisor +- stream +- disconnecting +- disconnect_timedout +- on_crash +- control_recv + +# write: + +must be passed around when crash +- stanza_recv + +can be recreated by supervisor +- stream +- on_crash +- control_recv + + +message types: + +command: + +- getroster +- send message +- etc. + +lamp commands: + +- connect +- disconnect +- command(command) diff --git a/lampada/src/connection/mod.rs b/lampada/src/connection/mod.rs new file mode 100644 index 0000000..1e767b0 --- /dev/null +++ b/lampada/src/connection/mod.rs @@ -0,0 +1,374 @@ +// TODO: consider if this needs to be handled by a supervisor or could be handled by luz directly + +use std::{ + collections::HashMap, + ops::{Deref, DerefMut}, + sync::Arc, + time::Duration, +}; + +use jid::JID; +use luz::{connection::Tls, jabber_stream::bound_stream::BoundJabberStream}; +use read::{ReadControl, ReadControlHandle, ReadState}; +use stanza::client::Stanza; +use tokio::{ + sync::{mpsc, oneshot, Mutex}, + task::{JoinHandle, JoinSet}, +}; +use tracing::info; +use write::{WriteControl, WriteControlHandle, WriteHandle, WriteMessage, WriteState}; + +use crate::{ + error::{ConnectionError, WriteError}, + Connected, Logic, +}; + +mod read; +pub(crate) mod write; + +pub struct Supervisor { + command_recv: mpsc::Receiver, + reader_crash: oneshot::Receiver, + writer_crash: oneshot::Receiver<(WriteMessage, WriteState)>, + read_control_handle: ReadControlHandle, + write_control_handle: WriteControlHandle, + on_crash: oneshot::Sender<()>, + // jid in connected stays the same over the life of the supervisor (the connection session) + connected: Connected, + password: Arc, + logic: Lgc, +} + +pub enum SupervisorCommand { + Disconnect, + // for if there was a stream error, require to reconnect + // couldn't stream errors just cause a crash? lol + Reconnect(ChildState), +} + +pub enum ChildState { + Write(WriteState), + Read(ReadState), +} + +impl Supervisor { + fn new( + command_recv: mpsc::Receiver, + reader_crash: oneshot::Receiver, + writer_crash: oneshot::Receiver<(WriteMessage, WriteState)>, + read_control_handle: ReadControlHandle, + write_control_handle: WriteControlHandle, + on_crash: oneshot::Sender<()>, + connected: Connected, + password: Arc, + logic: Lgc, + ) -> Self { + Self { + command_recv, + reader_crash, + writer_crash, + read_control_handle, + write_control_handle, + on_crash, + connected, + password, + logic, + } + } + + async fn run(mut self) { + loop { + tokio::select! { + Some(msg) = self.command_recv.recv() => { + match msg { + SupervisorCommand::Disconnect => { + info!("disconnecting"); + self.logic + .handle_disconnect(self.connected.clone()) + .await; + let _ = self.write_control_handle.send(WriteControl::Disconnect).await; + let _ = self.read_control_handle.send(ReadControl::Disconnect).await; + info!("sent disconnect command"); + tokio::select! { + _ = async { tokio::join!( + async { let _ = (&mut self.write_control_handle.handle).await; }, + async { let _ = (&mut self.read_control_handle.handle).await; } + ) } => {}, + // TODO: config timeout + _ = async { tokio::time::sleep(Duration::from_secs(5)) } => { + (&mut self.read_control_handle.handle).abort(); + (&mut self.write_control_handle.handle).abort(); + } + } + info!("disconnected"); + break; + }, + // TODO: Reconnect without aborting, gentle reconnect. + SupervisorCommand::Reconnect(state) => { + // TODO: please omfg + // send abort to read stream, as already done, consider + let (read_state, mut write_state); + match state { + ChildState::Write(receiver) => { + write_state = receiver; + let (send, recv) = oneshot::channel(); + let _ = self.read_control_handle.send(ReadControl::Abort(send)).await; + // TODO: need a tokio select, in case the state arrives from somewhere else + if let Ok(state) = recv.await { + read_state = state; + } else { + break + } + }, + ChildState::Read(read) => { + read_state = read; + let (send, recv) = oneshot::channel(); + let _ = self.write_control_handle.send(WriteControl::Abort(send)).await; + // TODO: need a tokio select, in case the state arrives from somewhere else + if let Ok(state) = recv.await { + write_state = state; + } else { + break + } + }, + } + + let mut jid = self.connected.jid.clone(); + let mut domain = jid.domainpart.clone(); + // TODO: make sure connect_and_login does not modify the jid, but instead returns a jid. or something like that + let connection = luz::connect_and_login(&mut jid, &*self.password, &mut domain).await; + match connection { + Ok(c) => { + let (read, write) = c.split(); + let (send, recv) = oneshot::channel(); + self.writer_crash = recv; + self.write_control_handle = + WriteControlHandle::reconnect(write, send, write_state.stanza_recv); + let (send, recv) = oneshot::channel(); + self.reader_crash = recv; + self.read_control_handle = ReadControlHandle::reconnect( + read, + read_state.tasks, + self.connected.clone(), + self.logic.clone(), + read_state.supervisor_control, + send, + ); + }, + Err(e) => { + // if reconnection failure, respond to all current write messages with lost connection error. the received processes should complete themselves. + write_state.stanza_recv.close(); + while let Some(msg) = write_state.stanza_recv.recv().await { + let _ = msg.respond_to.send(Err(WriteError::LostConnection)); + } + // TODO: is this the correct error? + self.logic.handle_connection_error(ConnectionError::LostConnection).await; + break; + }, + } + }, + } + }, + Ok((write_msg, mut write_state)) = &mut self.writer_crash => { + // consider awaiting/aborting the read and write threads + let (send, recv) = oneshot::channel(); + let _ = self.read_control_handle.send(ReadControl::Abort(send)).await; + let read_state = tokio::select! { + Ok(s) = recv => s, + Ok(s) = &mut self.reader_crash => s, + // in case, just break as irrecoverable + else => break, + }; + + let mut jid = self.connected.jid.clone(); + let mut domain = jid.domainpart.clone(); + // TODO: same here + let connection = luz::connect_and_login(&mut jid, &*self.password, &mut domain).await; + match connection { + Ok(c) => { + let (read, write) = c.split(); + let (send, recv) = oneshot::channel(); + self.writer_crash = recv; + self.write_control_handle = + WriteControlHandle::reconnect_retry(write, send, write_state.stanza_recv, write_msg); + let (send, recv) = oneshot::channel(); + self.reader_crash = recv; + self.read_control_handle = ReadControlHandle::reconnect( + read, + read_state.tasks, + self.connected.clone(), + self.logic.clone(), + read_state.supervisor_control, + send, + ); + }, + Err(e) => { + // if reconnection failure, respond to all current write messages with lost connection error. the received processes should complete themselves. + write_state.stanza_recv.close(); + let _ = write_msg.respond_to.send(Err(WriteError::LostConnection)); + while let Some(msg) = write_state.stanza_recv.recv().await { + let _ = msg.respond_to.send(Err(WriteError::LostConnection)); + } + // TODO: is this the correct error to send? + self.logic.handle_connection_error(ConnectionError::LostConnection).await; + break; + }, + } + }, + Ok(read_state) = &mut self.reader_crash => { + let (send, recv) = oneshot::channel(); + let _ = self.write_control_handle.send(WriteControl::Abort(send)).await; + let (retry_msg, mut write_state) = tokio::select! { + Ok(s) = recv => (None, s), + Ok(s) = &mut self.writer_crash => (Some(s.0), s.1), + // in case, just break as irrecoverable + else => break, + }; + + let mut jid = self.connected.jid.clone(); + let mut domain = jid.domainpart.clone(); + let connection = luz::connect_and_login(&mut jid, &*self.password, &mut domain).await; + match connection { + Ok(c) => { + let (read, write) = c.split(); + let (send, recv) = oneshot::channel(); + self.writer_crash = recv; + if let Some(msg) = retry_msg { + self.write_control_handle = + WriteControlHandle::reconnect_retry(write, send, write_state.stanza_recv, msg); + } else { + self.write_control_handle = WriteControlHandle::reconnect(write, send, write_state.stanza_recv) + } + let (send, recv) = oneshot::channel(); + self.reader_crash = recv; + self.read_control_handle = ReadControlHandle::reconnect( + read, + read_state.tasks, + self.connected.clone(), + self.logic.clone(), + read_state.supervisor_control, + send, + ); + }, + Err(e) => { + // if reconnection failure, respond to all current messages with lost connection error. + write_state.stanza_recv.close(); + if let Some(msg) = retry_msg { + msg.respond_to.send(Err(WriteError::LostConnection)); + } + while let Some(msg) = write_state.stanza_recv.recv().await { + msg.respond_to.send(Err(WriteError::LostConnection)); + } + // TODO: is this the correct error? + self.logic.handle_connection_error(ConnectionError::LostConnection).await; + break; + }, + } + }, + else => break, + } + } + // TODO: maybe don't just on_crash + let _ = self.on_crash.send(()); + } +} + +pub struct SupervisorHandle { + sender: SupervisorSender, + handle: JoinHandle<()>, +} + +impl Deref for SupervisorHandle { + type Target = SupervisorSender; + + fn deref(&self) -> &Self::Target { + &self.sender + } +} + +impl DerefMut for SupervisorHandle { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.sender + } +} + +#[derive(Clone)] +pub struct SupervisorSender { + sender: mpsc::Sender, +} + +impl Deref for SupervisorSender { + type Target = mpsc::Sender; + + fn deref(&self) -> &Self::Target { + &self.sender + } +} + +impl DerefMut for SupervisorSender { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.sender + } +} + +impl SupervisorHandle { + pub fn new( + streams: BoundJabberStream, + on_crash: oneshot::Sender<()>, + jid: JID, + password: Arc, + logic: Lgc, + ) -> (WriteHandle, Self) { + let (command_send, command_recv) = mpsc::channel(20); + let (writer_crash_send, writer_crash_recv) = oneshot::channel(); + let (reader_crash_send, reader_crash_recv) = oneshot::channel(); + + let (read_stream, write_stream) = streams.split(); + + let (write_handle, write_control_handle) = + WriteControlHandle::new(write_stream, writer_crash_send); + + let connected = Connected { + jid, + write_handle: write_handle.clone(), + }; + + let supervisor_sender = SupervisorSender { + sender: command_send, + }; + + let read_control_handle = ReadControlHandle::new( + read_stream, + connected.clone(), + logic.clone(), + supervisor_sender.clone(), + reader_crash_send, + ); + + let actor = Supervisor::new( + command_recv, + reader_crash_recv, + writer_crash_recv, + read_control_handle, + write_control_handle, + on_crash, + connected, + password, + logic, + ); + + let handle = tokio::spawn(async move { actor.run().await }); + + ( + write_handle, + Self { + sender: supervisor_sender, + handle, + }, + ) + } + + pub fn sender(&self) -> SupervisorSender { + self.sender.clone() + } +} diff --git a/lampada/src/connection/read.rs b/lampada/src/connection/read.rs new file mode 100644 index 0000000..cc69387 --- /dev/null +++ b/lampada/src/connection/read.rs @@ -0,0 +1,233 @@ +use std::{ + collections::HashMap, + marker::PhantomData, + ops::{Deref, DerefMut}, + str::FromStr, + sync::Arc, + time::Duration, +}; + +use luz::{connection::Tls, jabber_stream::bound_stream::BoundJabberReader}; +use stanza::client::Stanza; +use tokio::{ + sync::{mpsc, oneshot, Mutex}, + task::{JoinHandle, JoinSet}, +}; +use tracing::info; + +use crate::{Connected, Logic}; + +use super::{write::WriteHandle, SupervisorCommand, SupervisorSender}; + +/// read actor +pub struct Read { + stream: BoundJabberReader, + disconnecting: bool, + disconnect_timedout: oneshot::Receiver<()>, + + // all the threads spawned by the current connection session + tasks: JoinSet<()>, + + // for handling incoming stanzas + // jabber server must be able to both terminate the connection from error, and ask for data from the client (such as supported XEPs) + connected: Connected, + logic: Lgc, + supervisor_control: SupervisorSender, + + // control stuff + control_receiver: mpsc::Receiver, + on_crash: oneshot::Sender, +} + +/// when a crash/abort occurs, this gets sent back to the supervisor, so that the connection session can continue +pub struct ReadState { + pub supervisor_control: SupervisorSender, + // TODO: when a stream dies, the iq gets from the server should not be replied to on the new stream + pub tasks: JoinSet<()>, +} + +impl Read { + fn new( + stream: BoundJabberReader, + tasks: JoinSet<()>, + connected: Connected, + logic: Lgc, + supervisor_control: SupervisorSender, + control_receiver: mpsc::Receiver, + on_crash: oneshot::Sender, + ) -> Self { + let (_send, recv) = oneshot::channel(); + Self { + stream, + disconnecting: false, + disconnect_timedout: recv, + tasks, + connected, + logic, + supervisor_control, + control_receiver, + on_crash, + } + } +} + +impl Read { + async fn run(mut self) { + println!("started read thread"); + // let stanza = self.stream.read::().await; + // println!("{:?}", stanza); + loop { + tokio::select! { + // if still haven't received the end tag in time, just kill itself + // TODO: is this okay??? what if notification thread dies? + Ok(()) = &mut self.disconnect_timedout => { + info!("disconnect_timedout"); + break; + } + Some(msg) = self.control_receiver.recv() => { + match msg { + // when disconnect received, + ReadControl::Disconnect => { + let (send, recv) = oneshot::channel(); + self.disconnect_timedout = recv; + self.disconnecting = true; + tokio::spawn(async { + tokio::time::sleep(Duration::from_secs(10)).await; + let _ = send.send(()); + }) + }, + ReadControl::Abort(sender) => { + let _ = sender.send(ReadState { supervisor_control: self.supervisor_control, tasks: self.tasks }); + break; + }, + }; + }, + s = self.stream.read::() => { + println!("read stanza"); + match s { + Ok(s) => { + self.tasks.spawn(self.logic.clone().handle_stanza(s, self.connected.clone(), self.supervisor_control.clone())); + }, + Err(e) => { + println!("error: {:?}", e); + // TODO: NEXT write the correct error stanza depending on error, decide whether to reconnect or properly disconnect, depending on if disconnecting is true + // match e { + // peanuts::Error::ReadError(error) => todo!(), + // peanuts::Error::Utf8Error(utf8_error) => todo!(), + // peanuts::Error::ParseError(_) => todo!(), + // peanuts::Error::EntityProcessError(_) => todo!(), + // peanuts::Error::InvalidCharRef(_) => todo!(), + // peanuts::Error::DuplicateNameSpaceDeclaration(namespace_declaration) => todo!(), + // peanuts::Error::DuplicateAttribute(_) => todo!(), + // peanuts::Error::UnqualifiedNamespace(_) => todo!(), + // peanuts::Error::MismatchedEndTag(name, name1) => todo!(), + // peanuts::Error::NotInElement(_) => todo!(), + // peanuts::Error::ExtraData(_) => todo!(), + // peanuts::Error::UndeclaredNamespace(_) => todo!(), + // peanuts::Error::IncorrectName(name) => todo!(), + // peanuts::Error::DeserializeError(_) => todo!(), + // peanuts::Error::Deserialize(deserialize_error) => todo!(), + // peanuts::Error::RootElementEnded => todo!(), + // } + // TODO: make sure this only happens when an end tag is received + if self.disconnecting == true { + break; + } else { + let _ = self.on_crash.send(ReadState { supervisor_control: self.supervisor_control, tasks: self.tasks }); + } + break; + }, + } + }, + else => break + } + } + println!("stopping read thread"); + self.logic.on_abort().await; + } +} + +// what do stanza processes do? +// - update ui +// - access database +// - disconnect proper, reconnect +// - respond to server requests + +pub enum ReadControl { + Disconnect, + Abort(oneshot::Sender), +} + +pub struct ReadControlHandle { + sender: mpsc::Sender, + pub(crate) handle: JoinHandle<()>, +} + +impl Deref for ReadControlHandle { + type Target = mpsc::Sender; + + fn deref(&self) -> &Self::Target { + &self.sender + } +} + +impl DerefMut for ReadControlHandle { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.sender + } +} + +impl ReadControlHandle { + pub fn new( + stream: BoundJabberReader, + connected: Connected, + logic: Lgc, + supervisor_control: SupervisorSender, + on_crash: oneshot::Sender, + ) -> Self { + let (control_sender, control_receiver) = mpsc::channel(20); + + let actor = Read::new( + stream, + JoinSet::new(), + connected, + logic, + supervisor_control, + control_receiver, + on_crash, + ); + let handle = tokio::spawn(async move { actor.run().await }); + + Self { + sender: control_sender, + handle, + } + } + + pub fn reconnect( + stream: BoundJabberReader, + tasks: JoinSet<()>, + connected: Connected, + logic: Lgc, + supervisor_control: SupervisorSender, + on_crash: oneshot::Sender, + ) -> Self { + let (control_sender, control_receiver) = mpsc::channel(20); + + let actor = Read::new( + stream, + tasks, + connected, + logic, + supervisor_control, + control_receiver, + on_crash, + ); + let handle = tokio::spawn(async move { actor.run().await }); + + Self { + sender: control_sender, + handle, + } + } +} diff --git a/lampada/src/connection/write.rs b/lampada/src/connection/write.rs new file mode 100644 index 0000000..8f0c34b --- /dev/null +++ b/lampada/src/connection/write.rs @@ -0,0 +1,258 @@ +use std::ops::{Deref, DerefMut}; + +use luz::{connection::Tls, jabber_stream::bound_stream::BoundJabberWriter}; +use stanza::client::Stanza; +use tokio::{ + sync::{mpsc, oneshot}, + task::JoinHandle, +}; + +use crate::error::WriteError; + +/// actor that receives jabber stanzas to write, and if there is an error, sends a message back to the supervisor then aborts, so the supervisor can spawn a new stream. +pub struct Write { + stream: BoundJabberWriter, + + /// connection session write queue + stanza_receiver: mpsc::Receiver, + + // control stuff + control_receiver: mpsc::Receiver, + on_crash: oneshot::Sender<(WriteMessage, WriteState)>, +} + +/// when a crash/abort occurs, this gets sent back to the supervisor, possibly with the current write that failed, so that the connection session can continue +pub struct WriteState { + pub stanza_recv: mpsc::Receiver, +} + +#[derive(Debug)] +pub struct WriteMessage { + pub stanza: Stanza, + pub respond_to: oneshot::Sender>, +} + +pub enum WriteControl { + Disconnect, + Abort(oneshot::Sender), +} + +impl Write { + fn new( + stream: BoundJabberWriter, + stanza_receiver: mpsc::Receiver, + control_receiver: mpsc::Receiver, + on_crash: oneshot::Sender<(WriteMessage, WriteState)>, + ) -> Self { + Self { + stream, + stanza_receiver, + control_receiver, + on_crash, + } + } + + async fn write(&mut self, stanza: &Stanza) -> Result<(), peanuts::Error> { + Ok(self.stream.write(stanza).await?) + } + + async fn run_reconnected(mut self, retry_msg: WriteMessage) { + // try to retry sending the message that failed to send previously + let result = self.stream.write(&retry_msg.stanza).await; + match result { + Err(e) => match &e { + peanuts::Error::ReadError(_error) => { + // make sure message is not lost from error, supervisor handles retry and reporting + // TODO: upon reconnect, make sure we are not stuck in a reconnection loop + let _ = self.on_crash.send(( + retry_msg, + WriteState { + stanza_recv: self.stanza_receiver, + }, + )); + return; + } + _ => { + let _ = retry_msg.respond_to.send(Err(e.into())); + } + }, + _ => { + let _ = retry_msg.respond_to.send(Ok(())); + } + } + // return to normal loop + self.run().await + } + + async fn run(mut self) { + loop { + tokio::select! { + Some(msg) = self.control_receiver.recv() => { + match msg { + WriteControl::Disconnect => { + // close the stanza_receiver channel and drain out all of the remaining stanzas to send + self.stanza_receiver.close(); + // TODO: put this in some kind of function to avoid code duplication + while let Some(msg) = self.stanza_receiver.recv().await { + let result = self.stream.write(&msg.stanza).await; + match result { + Err(e) => match &e { + peanuts::Error::ReadError(_error) => { + // if connection lost during disconnection, just send lost connection error to the write requests + let _ = msg.respond_to.send(Err(WriteError::LostConnection)); + while let Some(msg) = self.stanza_receiver.recv().await { + let _ = msg.respond_to.send(Err(WriteError::LostConnection)); + } + break; + } + // otherwise complete sending all the stanzas currently in the queue + _ => { + let _ = msg.respond_to.send(Err(e.into())); + } + }, + _ => { + let _ = msg.respond_to.send(Ok(())); + } + } + } + let _ = self.stream.try_close().await; + break; + }, + // in case of abort, stream is already fucked, just send the receiver ready for a reconnection at the same resource + WriteControl::Abort(sender) => { + let _ = sender.send(WriteState { stanza_recv: self.stanza_receiver }); + break; + }, + } + }, + Some(msg) = self.stanza_receiver.recv() => { + let result = self.stream.write(&msg.stanza).await; + match result { + Err(e) => match &e { + peanuts::Error::ReadError(_error) => { + // make sure message is not lost from error, supervisor handles retry and reporting + let _ = self.on_crash.send((msg, WriteState { stanza_recv: self.stanza_receiver })); + break; + } + _ => { + let _ = msg.respond_to.send(Err(e.into())); + } + }, + _ => { + let _ = msg.respond_to.send(Ok(())); + } + } + }, + else => break, + } + } + } +} + +#[derive(Clone)] +pub struct WriteHandle { + sender: mpsc::Sender, +} + +impl WriteHandle { + pub async fn write(&self, stanza: Stanza) -> Result<(), WriteError> { + let (send, recv) = oneshot::channel(); + self.send(WriteMessage { + stanza, + respond_to: send, + }) + .await + .map_err(|e| WriteError::Actor(e.into()))?; + // TODO: timeout + recv.await.map_err(|e| WriteError::Actor(e.into()))? + } +} + +impl Deref for WriteHandle { + type Target = mpsc::Sender; + + fn deref(&self) -> &Self::Target { + &self.sender + } +} + +impl DerefMut for WriteHandle { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.sender + } +} + +pub struct WriteControlHandle { + sender: mpsc::Sender, + pub(crate) handle: JoinHandle<()>, +} + +impl Deref for WriteControlHandle { + type Target = mpsc::Sender; + + fn deref(&self) -> &Self::Target { + &self.sender + } +} + +impl DerefMut for WriteControlHandle { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.sender + } +} + +impl WriteControlHandle { + pub fn new( + stream: BoundJabberWriter, + on_crash: oneshot::Sender<(WriteMessage, WriteState)>, + ) -> (WriteHandle, Self) { + let (control_sender, control_receiver) = mpsc::channel(20); + let (stanza_sender, stanza_receiver) = mpsc::channel(20); + + let actor = Write::new(stream, stanza_receiver, control_receiver, on_crash); + let handle = tokio::spawn(async move { actor.run().await }); + + ( + WriteHandle { + sender: stanza_sender, + }, + Self { + sender: control_sender, + handle, + }, + ) + } + + pub fn reconnect_retry( + stream: BoundJabberWriter, + on_crash: oneshot::Sender<(WriteMessage, WriteState)>, + stanza_receiver: mpsc::Receiver, + retry_msg: WriteMessage, + ) -> Self { + let (control_sender, control_receiver) = mpsc::channel(20); + + let actor = Write::new(stream, stanza_receiver, control_receiver, on_crash); + let handle = tokio::spawn(async move { actor.run_reconnected(retry_msg).await }); + + Self { + sender: control_sender, + handle, + } + } + + pub fn reconnect( + stream: BoundJabberWriter, + on_crash: oneshot::Sender<(WriteMessage, WriteState)>, + stanza_receiver: mpsc::Receiver, + ) -> Self { + let (control_sender, control_receiver) = mpsc::channel(20); + + let actor = Write::new(stream, stanza_receiver, control_receiver, on_crash); + let handle = tokio::spawn(async move { actor.run().await }); + + Self { + sender: control_sender, + handle, + } + } +} diff --git a/lampada/src/error.rs b/lampada/src/error.rs new file mode 100644 index 0000000..cdfb4db --- /dev/null +++ b/lampada/src/error.rs @@ -0,0 +1,82 @@ +use std::sync::Arc; + +use stanza::client::Stanza; +use thiserror::Error; +use tokio::{ + sync::{mpsc::error::SendError, oneshot::error::RecvError}, + time::error::Elapsed, +}; + +#[derive(Debug, Error, Clone)] +pub enum ConnectionError { + #[error("connection failed: {0}")] + ConnectionFailed(#[from] luz::Error), + #[error("already connected")] + AlreadyConnected, + #[error("already disconnected")] + AlreadyDisconnected, + #[error("lost connection")] + LostConnection, + // TODO: Display for Content + #[error("disconnected")] + Disconnected, +} + +#[derive(Debug, Error, Clone)] +pub enum CommandError { + #[error("actor: {0}")] + Actor(ActorError), + #[error("{0}")] + Error(#[from] T), +} + +#[derive(Debug, Error, Clone)] +pub enum WriteError { + #[error("xml: {0}")] + XML(#[from] peanuts::Error), + #[error("lost connection")] + LostConnection, + // TODO: should this be in writeerror or separate? + #[error("actor: {0}")] + Actor(#[from] ActorError), + #[error("disconnected")] + Disconnected, +} + +// TODO: separate peanuts read and write error? +// TODO: which crate +#[derive(Debug, Error, Clone)] +pub enum ReadError { + #[error("xml: {0}")] + XML(#[from] peanuts::Error), + #[error("lost connection")] + LostConnection, +} + +#[derive(Debug, Error, Clone)] +pub enum ActorError { + #[error("receive timed out")] + Timeout, + #[error("could not send message to actor, channel closed")] + Send, + #[error("could not receive message from actor, channel closed")] + Receive, +} + +impl From for ActorError { + fn from(_e: Elapsed) -> Self { + Self::Timeout + } +} + +impl From> for ActorError { + fn from(_e: SendError) -> Self { + Self::Send + } +} + +impl From for ActorError { + fn from(_e: RecvError) -> Self { + Self::Receive + } +} diff --git a/lampada/src/lib.rs b/lampada/src/lib.rs new file mode 100644 index 0000000..c61c596 --- /dev/null +++ b/lampada/src/lib.rs @@ -0,0 +1,238 @@ +use std::{ + collections::HashMap, + ops::{Deref, DerefMut}, + str::FromStr, + sync::Arc, + time::Duration, +}; + +pub use connection::write::WriteMessage; +pub use connection::SupervisorSender; +use error::ConnectionError; +use futures::{future::Fuse, FutureExt}; +use luz::JID; +use stanza::client::{ + iq::{self, Iq, IqType}, + Stanza, +}; +use tokio::{ + sync::{mpsc, oneshot, Mutex}, + task::JoinSet, + time::timeout, +}; +use tracing::{debug, info}; + +use crate::connection::write::WriteHandle; +use crate::connection::{SupervisorCommand, SupervisorHandle}; + +mod connection; +pub mod error; + +#[derive(Clone)] +pub struct Connected { + // full jid will stay stable across reconnections + jid: JID, + write_handle: WriteHandle, +} + +impl Connected { + pub fn jid(&self) -> &JID { + &self.jid + } + + pub fn write_handle(&self) -> &WriteHandle { + &self.write_handle + } +} + +/// everything that a particular xmpp client must implement +pub trait Logic { + /// the command message type + type Cmd; + + /// run after binding to the stream (e.g. for a chat client, ) + fn handle_connect(self, connection: Connected) -> impl std::future::Future + Send; + + /// run before closing the stream (e.g. send unavailable presence in a chat client) + fn handle_disconnect( + self, + connection: Connected, + ) -> impl std::future::Future + Send; + + /// run to handle an incoming xmpp stanza + fn handle_stanza( + self, + stanza: Stanza, + connection: Connected, + supervisor: SupervisorSender, + ) -> impl std::future::Future + std::marker::Send; + + /// run to handle a command message when a connection is currently established + fn handle_online( + self, + command: Self::Cmd, + connection: Connected, + ) -> impl std::future::Future + std::marker::Send; + + /// run to handle a command message when disconnected + fn handle_offline( + self, + command: Self::Cmd, + ) -> impl std::future::Future + std::marker::Send; + + /// run as cleanup after either an abort or a disconnect (e.g. reply to all pending requests with a disconnected error) + fn on_abort(self) -> impl std::future::Future + std::marker::Send; + + /// handle connection errors from the core client logic + fn handle_connection_error( + self, + error: ConnectionError, + ) -> impl std::future::Future + std::marker::Send; + + // async fn handle_stream_error(self, error) {} +} + +/// an actor that implements xmpp core (rfc6120), manages connection/stream status, and delegates any other logic to the generic which implements Logic, allowing different kinds of clients (e.g. chat, social, pubsub) to be built upon the same core +pub struct CoreClient { + jid: JID, + // TODO: use a dyn passwordprovider trait to avoid storing password in memory + password: Arc, + receiver: mpsc::Receiver>, + connected: Option<(Connected, SupervisorHandle)>, + // TODO: will need to have an auto reconnect state as well (e.g. in case server shut down, to try and reconnect later) + // connected_intention: bool, + /// if connection was shut down due to e.g. server shutdown, supervisor must be able to mark client as disconnected + connection_supervisor_shutdown: Fuse>, + logic: Lgc, + // config: LampConfig, + // TODO: will grow forever at this point, maybe not required as tasks will naturally shut down anyway? + tasks: JoinSet<()>, +} + +impl CoreClient { + /// create a new actor + pub fn new( + jid: JID, + password: String, + receiver: mpsc::Receiver>, + connected: Option<(Connected, SupervisorHandle)>, + connection_supervisor_shutdown: Fuse>, + logic: Lgc, + ) -> Self { + Self { + jid, + password: Arc::new(password), + connected, + receiver, + connection_supervisor_shutdown, + logic, + tasks: JoinSet::new(), + } + } + + /// run the actor + pub async fn run(mut self) { + loop { + let msg = tokio::select! { + // this is okay, as when created the supervisor (and connection) doesn't exist, but a bit messy + // THIS IS NOT OKAY LOLLLL - apparently fusing is the best option??? + _ = &mut self.connection_supervisor_shutdown => { + self.connected = None; + continue; + } + Some(msg) = self.receiver.recv() => { + msg + }, + else => break, + }; + match msg { + CoreClientCommand::Connect => { + match self.connected { + Some(_) => { + self.logic + .clone() + .handle_connection_error(ConnectionError::AlreadyConnected) + .await; + } + None => { + let mut jid = self.jid.clone(); + let mut domain = jid.domainpart.clone(); + // TODO: check what happens upon reconnection with same resource (this is probably what one wants to do and why jid should be mutated from a bare jid to one with a resource) + let streams_result = + luz::connect_and_login(&mut jid, &*self.password, &mut domain) + .await; + match streams_result { + Ok(s) => { + debug!("ok stream result"); + let (shutdown_send, shutdown_recv) = oneshot::channel::<()>(); + let (writer, supervisor) = SupervisorHandle::new( + s, + shutdown_send, + jid.clone(), + self.password.clone(), + self.logic.clone(), + ); + + let shutdown_recv = shutdown_recv.fuse(); + self.connection_supervisor_shutdown = shutdown_recv; + + let connected = Connected { + jid, + write_handle: writer, + }; + + self.logic.clone().handle_connect(connected.clone()).await; + + self.connected = Some((connected, supervisor)); + } + Err(e) => { + tracing::error!("error: {}", e); + self.logic + .clone() + .handle_connection_error(ConnectionError::ConnectionFailed( + e.into(), + )) + .await; + } + } + } + }; + } + CoreClientCommand::Disconnect => match self.connected { + None => { + self.logic + .clone() + .handle_connection_error(ConnectionError::AlreadyDisconnected) + .await; + } + ref mut c => { + if let Some((connected, supervisor_handle)) = c.take() { + let _ = supervisor_handle.send(SupervisorCommand::Disconnect).await; + } else { + unreachable!() + }; + } + }, + CoreClientCommand::Command(command) => { + match self.connected.as_ref() { + Some((w, s)) => self + .tasks + .spawn(self.logic.clone().handle_online(command, w.clone())), + None => self.tasks.spawn(self.logic.clone().handle_offline(command)), + }; + } + } + } + } +} + +// TODO: generate methods for each with a macro +pub enum CoreClientCommand { + // TODO: login invisible xep-0186 + /// connect to XMPP chat server. gets roster and publishes initial presence. + Connect, + /// disconnect from XMPP chat server, sending unavailable presence then closing stream. + Disconnect, + /// TODO: generics + Command(C), +} diff --git a/lampada/src/main.rs b/lampada/src/main.rs new file mode 100644 index 0000000..7b7469d --- /dev/null +++ b/lampada/src/main.rs @@ -0,0 +1,42 @@ +use std::{path::Path, str::FromStr, time::Duration}; + +use jid::JID; +use lampada::{db::Db, CoreClientCommand, LuzHandle}; +use sqlx::SqlitePool; +use tokio::{ + io::{AsyncReadExt, AsyncWriteExt}, + sync::oneshot, +}; +use tracing::info; + +#[tokio::main] +async fn main() { + tracing_subscriber::fmt::init(); + let db = Db::create_connect_and_migrate(Path::new("./luz.db")) + .await + .unwrap(); + let (luz, mut recv) = + LuzHandle::new("test@blos.sm".try_into().unwrap(), "slayed".to_string(), db); + + tokio::spawn(async move { + while let Some(msg) = recv.recv().await { + info!("{:#?}", msg) + } + }); + + luz.send(CoreClientCommand::Connect).await.unwrap(); + let (send, recv) = oneshot::channel(); + tokio::time::sleep(Duration::from_secs(5)).await; + info!("sending message"); + luz.send(CoreClientCommand::SendMessage( + JID::from_str("cel@blos.sm").unwrap(), + luz::chat::Body { + body: "hallo!!!".to_string(), + }, + send, + )) + .await + .unwrap(); + recv.await.unwrap().unwrap(); + println!("sent message"); +} diff --git a/luz/.gitignore b/luz/.gitignore deleted file mode 100644 index 60868fd..0000000 --- a/luz/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -luz.db -.sqlx/ diff --git a/luz/Cargo.lock b/luz/Cargo.lock new file mode 100644 index 0000000..d45d7c1 --- /dev/null +++ b/luz/Cargo.lock @@ -0,0 +1,1935 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "addr2line" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "anstream" +version = "0.6.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9" + +[[package]] +name = "anstyle-parse" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c" +dependencies = [ + "windows-sys 0.59.0", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125" +dependencies = [ + "anstyle", + "windows-sys 0.59.0", +] + +[[package]] +name = "async-recursion" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "async-trait" +version = "0.1.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "autocfg" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" + +[[package]] +name = "backtrace" +version = "0.3.74" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", + "windows-targets 0.52.6", +] + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "bitflags" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da" + +[[package]] +name = "cc" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd9de9f2205d5ef3fd67e685b0df337994ddd4495e2a28d185500d0e1edfea47" +dependencies = [ + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "circular" +version = "0.3.0" +dependencies = [ + "bytes", +] + +[[package]] +name = "colorchoice" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990" + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "core2" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505" +dependencies = [ + "memchr", +] + +[[package]] +name = "cpufeatures" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16b80225097f2e5ae4e7179dd2266824648f3e2f49d9134d584b76389d31c4c3" +dependencies = [ + "libc", +] + +[[package]] +name = "crypto-common" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "data-encoding" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2" + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", + "subtle", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "enum-as-inner" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "env_filter" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab" +dependencies = [ + "log", + "regex", +] + +[[package]] +name = "env_logger" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d" +dependencies = [ + "anstream", + "anstyle", + "env_filter", + "humantime", + "log", +] + +[[package]] +name = "errno" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + +[[package]] +name = "fastrand" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "form_urlencoded" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-executor" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "futures-sink" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "gimli" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f" + +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + +[[package]] +name = "hermit-abi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + +[[package]] +name = "hostname" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867" +dependencies = [ + "libc", + "match_cfg", + "winapi", +] + +[[package]] +name = "humantime" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" + +[[package]] +name = "icu_collections" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locid" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_locid_transform" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e" +dependencies = [ + "displaydoc", + "icu_locid", + "icu_locid_transform_data", + "icu_provider", + "tinystr", + "zerovec", +] + +[[package]] +name = "icu_locid_transform_data" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e" + +[[package]] +name = "icu_normalizer" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "utf16_iter", + "utf8_iter", + "write16", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516" + +[[package]] +name = "icu_properties" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locid_transform", + "icu_properties_data", + "icu_provider", + "tinystr", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569" + +[[package]] +name = "icu_provider" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9" +dependencies = [ + "displaydoc", + "icu_locid", + "icu_provider_macros", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_provider_macros" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "idna" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8" +dependencies = [ + "matches", + "unicode-bidi", + "unicode-normalization", +] + +[[package]] +name = "idna" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "ipconfig" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f" +dependencies = [ + "socket2", + "widestring", + "windows-sys 0.48.0", + "winreg", +] + +[[package]] +name = "ipnet" +version = "2.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddc24109865250148c2e0f3d25d4f0f479571723792d3802153c60922a4fb708" + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" + +[[package]] +name = "itoa" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a73e9fe3c49d7afb2ace819fa181a287ce54a0983eda4e0eb05c22f82ffe534" + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "libc" +version = "0.2.164" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "433bfe06b8c75da9b2e3fbea6e5329ff87748f0b144ef75306e674c3f6f7c13f" + +[[package]] +name = "linked-hash-map" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f" + +[[package]] +name = "linux-raw-sys" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" + +[[package]] +name = "litemap" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "643cb0b8d4fcc284004d5fd0d67ccf61dfffadb7f75e1e71bc420f4688a3a704" + +[[package]] +name = "lock_api" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" + +[[package]] +name = "lru-cache" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c" +dependencies = [ + "linked-hash-map", +] + +[[package]] +name = "luz" +version = "0.0.1" +dependencies = [ + "async-recursion", + "async-trait", + "env_logger", + "futures", + "lazy_static", + "nanoid", + "peanuts", + "rsasl", + "test-log", + "tokio", + "tokio-native-tls", + "tracing", + "tracing-subscriber", + "trust-dns-resolver", + "try_map", +] + +[[package]] +name = "match_cfg" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4" + +[[package]] +name = "matchers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +dependencies = [ + "regex-automata 0.1.10", +] + +[[package]] +name = "matches" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5" + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "miniz_oxide" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1" +dependencies = [ + "adler2", +] + +[[package]] +name = "mio" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec" +dependencies = [ + "hermit-abi", + "libc", + "wasi", + "windows-sys 0.52.0", +] + +[[package]] +name = "nanoid" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ffa00dec017b5b1a8b7cf5e2c008bfda1aa7e0697ac1508b491fdf2622fb4d8" +dependencies = [ + "rand", +] + +[[package]] +name = "native-tls" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466" +dependencies = [ + "libc", + "log", + "openssl", + "openssl-probe", + "openssl-sys", + "schannel", + "security-framework", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "nu-ansi-term" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +dependencies = [ + "overload", + "winapi", +] + +[[package]] +name = "object" +version = "0.36.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedf0a2d09c573ed1d8d85b30c119153926a2b36dce0ab28322c09a117a4683e" +dependencies = [ + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" + +[[package]] +name = "openssl" +version = "0.10.68" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6174bc48f102d208783c2c84bf931bb75927a617866870de8a4ea85597f871f5" +dependencies = [ + "bitflags", + "cfg-if", + "foreign-types", + "libc", + "once_cell", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "openssl-probe" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" + +[[package]] +name = "openssl-sys" +version = "0.9.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45abf306cbf99debc8195b66b7346498d7b10c210de50418b5ccd7ceba08c741" +dependencies = [ + "cc", + "libc", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "overload" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" + +[[package]] +name = "parking_lot" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-targets 0.52.6", +] + +[[package]] +name = "pbkdf2" +version = "0.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" +dependencies = [ + "digest", +] + +[[package]] +name = "peanuts" +version = "0.1.0" +dependencies = [ + "async-recursion", + "circular", + "futures", + "nom", + "tokio", + "tracing", +] + +[[package]] +name = "percent-encoding" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" + +[[package]] +name = "pin-project-lite" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2" + +[[package]] +name = "ppv-lite86" +version = "0.2.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "proc-macro2" +version = "1.0.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-error" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" + +[[package]] +name = "quote" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "redox_syscall" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f" +dependencies = [ + "bitflags", +] + +[[package]] +name = "regex" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata 0.4.9", + "regex-syntax 0.8.5", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" +dependencies = [ + "regex-syntax 0.6.29", +] + +[[package]] +name = "regex-automata" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax 0.8.5", +] + +[[package]] +name = "regex-syntax" +version = "0.6.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" + +[[package]] +name = "regex-syntax" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" + +[[package]] +name = "resolv-conf" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52e44394d2086d010551b14b53b1f24e31647570cd1deb0379e2c21b329aba00" +dependencies = [ + "hostname", + "quick-error", +] + +[[package]] +name = "rsasl" +version = "2.2.0" +dependencies = [ + "base64", + "core2", + "digest", + "hmac", + "pbkdf2", + "rand", + "serde_json", + "sha1", + "stringprep", + "thiserror", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" + +[[package]] +name = "rustix" +version = "0.38.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.52.0", +] + +[[package]] +name = "ryu" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" + +[[package]] +name = "schannel" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d" +dependencies = [ + "windows-sys 0.59.0", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "security-framework" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" +dependencies = [ + "bitflags", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa39c7303dc58b5543c94d22c1766b0d31f2ee58306363ea622b10bbc075eaa2" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "serde" +version = "1.0.215" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.215" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "serde_json" +version = "1.0.133" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377" +dependencies = [ + "itoa", + "memchr", + "ryu", + "serde", +] + +[[package]] +name = "sha1" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "signal-hook-registry" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1" +dependencies = [ + "libc", +] + +[[package]] +name = "slab" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" +dependencies = [ + "autocfg", +] + +[[package]] +name = "smallvec" +version = "1.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" + +[[package]] +name = "socket2" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + +[[package]] +name = "stringprep" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1" +dependencies = [ + "unicode-bidi", + "unicode-normalization", + "unicode-properties", +] + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.87" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "tempfile" +version = "3.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c" +dependencies = [ + "cfg-if", + "fastrand", + "once_cell", + "rustix", + "windows-sys 0.59.0", +] + +[[package]] +name = "test-log" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3dffced63c2b5c7be278154d76b479f9f9920ed34e7574201407f0b14e2bbb93" +dependencies = [ + "env_logger", + "test-log-macros", + "tracing-subscriber", +] + +[[package]] +name = "test-log-macros" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5999e24eaa32083191ba4e425deb75cdf25efefabe5aaccb7446dd0d4122a3f5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "thread_local" +version = "1.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" +dependencies = [ + "cfg-if", + "once_cell", +] + +[[package]] +name = "tinystr" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "tinyvec" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "tokio" +version = "1.41.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cfb5bee7a6a52939ca9224d6ac897bb669134078daa8735560897f69de4d33" +dependencies = [ + "backtrace", + "bytes", + "libc", + "mio", + "parking_lot", + "pin-project-lite", + "signal-hook-registry", + "socket2", + "tokio-macros", + "windows-sys 0.52.0", +] + +[[package]] +name = "tokio-macros" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "tokio-native-tls" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2" +dependencies = [ + "native-tls", + "tokio", +] + +[[package]] +name = "tracing" +version = "0.1.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "tracing-core" +version = "0.1.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex", + "sharded-slab", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "trust-dns-proto" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f7f83d1e4a0e4358ac54c5c3681e5d7da5efc5a7a632c90bb6d6669ddd9bc26" +dependencies = [ + "async-trait", + "cfg-if", + "data-encoding", + "enum-as-inner", + "futures-channel", + "futures-io", + "futures-util", + "idna 0.2.3", + "ipnet", + "lazy_static", + "rand", + "smallvec", + "thiserror", + "tinyvec", + "tokio", + "tracing", + "url", +] + +[[package]] +name = "trust-dns-resolver" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aff21aa4dcefb0a1afbfac26deb0adc93888c7d295fb63ab273ef276ba2b7cfe" +dependencies = [ + "cfg-if", + "futures-util", + "ipconfig", + "lazy_static", + "lru-cache", + "parking_lot", + "resolv-conf", + "smallvec", + "thiserror", + "tokio", + "tracing", + "trust-dns-proto", +] + +[[package]] +name = "try_map" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb1626d07cb5c1bb2cf17d94c0be4852e8a7c02b041acec9a8c5bdda99f9d580" + +[[package]] +name = "typenum" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" + +[[package]] +name = "unicode-bidi" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ab17db44d7388991a428b2ee655ce0c212e862eff1768a455c58f9aad6e7893" + +[[package]] +name = "unicode-ident" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" + +[[package]] +name = "unicode-normalization" +version = "0.1.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "unicode-properties" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0" + +[[package]] +name = "url" +version = "2.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d157f1b96d14500ffdc1f10ba712e780825526c03d9a49b4d0324b0d9113ada" +dependencies = [ + "form_urlencoded", + "idna 1.0.3", + "percent-encoding", +] + +[[package]] +name = "utf16_iter" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "valuable" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "widestring" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winreg" +version = "0.50.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" +dependencies = [ + "cfg-if", + "windows-sys 0.48.0", +] + +[[package]] +name = "write16" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936" + +[[package]] +name = "writeable" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51" + +[[package]] +name = "yoke" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c5b1314b079b0930c31e3af543d8ee1757b1951ae1e1565ec704403a7240ca5" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", + "synstructure", +] + +[[package]] +name = "zerocopy" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" +dependencies = [ + "byteorder", + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "zerofrom" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91ec111ce797d0e0784a1116d0ddcdbea84322cd79e5d5ad173daeba4f93ab55" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", + "synstructure", +] + +[[package]] +name = "zerovec" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] diff --git a/luz/Cargo.toml b/luz/Cargo.toml index 08a0d6c..c1c1511 100644 --- a/luz/Cargo.toml +++ b/luz/Cargo.toml @@ -1,20 +1,42 @@ [package] name = "luz" +authors = ["cel "] version = "0.1.0" edition = "2021" +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + [dependencies] -futures = "0.3.31" -jabber = { version = "0.1.0", path = "../jabber" } +async-recursion = "1.0.4" +async-trait = "0.1.68" +lazy_static = "1.4.0" +nanoid = "0.4.0" +# TODO: remove unneeded features and dependencies +rsasl = { version = "2.0.1", default_features = false, features = [ + "provider_base64", + "plain", + "config_builder", + "scram-sha-1", +] } +tokio = { version = "1.28", features = ["full"] } +tokio-native-tls = "0.3.1" +tracing = "0.1.40" +trust-dns-resolver = "0.22.0" +try_map = "0.3.1" +stanza = { version = "0.1.0", path = "../stanza" } peanuts = { version = "0.1.0", path = "../../peanuts" } -jid = { version = "0.1.0", path = "../jid", features = ["sqlx"] } -sqlx = { version = "0.8.3", features = ["sqlite", "runtime-tokio", "uuid", "chrono"] } -stanza = { version = "0.1.0", path = "../stanza", features = ["xep_0203"] } -tokio = "1.42.0" -tokio-stream = "0.1.17" -tokio-util = "0.7.13" -tracing = "0.1.41" -tracing-subscriber = "0.3.19" -uuid = { version = "1.13.1", features = ["v4"] } +jid = { version = "0.1.0", path = "../jid" } +futures = "0.3.31" +take_mut = "0.2.2" +pin-project-lite = "0.2.15" +pin-project = "1.1.7" thiserror = "2.0.11" -chrono = "0.4.40" + +[dev-dependencies] +test-log = { version = "0.2", features = ["trace"] } +env_logger = "*" +tracing-subscriber = { version = "0.3", default-features = false, features = [ + "env-filter", + "fmt", +] } +stanza = { version = "0.1.0", path = "../stanza", features = ["xep_0199"] } diff --git a/luz/migrations/20240113011930_luz.sql b/luz/migrations/20240113011930_luz.sql deleted file mode 100644 index 148598b..0000000 --- a/luz/migrations/20240113011930_luz.sql +++ /dev/null @@ -1,119 +0,0 @@ -PRAGMA foreign_keys = on; - --- a user jid will never change, only a chat user will change --- TODO: avatar, nick, etc. -create table users( - -- TODO: enforce bare jid - jid text primary key not null, - -- can receive presence status from non-contacts - cached_status_message text - -- TODO: last_seen -); - --- -- links to messages, jabber users, stores jid history, etc. --- create table identities( --- id text primary key not null --- ); - --- create table identities_users( --- id text not null, --- jid text not null, --- -- whichever has the newest timestamp is the active one. --- -- what to do when somebody moves, but then the old jid is used again without having explicitly moved back? create new identity to assign ownership to? --- -- merging of identities? --- activated_timestamp not null, --- foreign key(id) references identities(id), --- foreign key(jid) references users(jid), --- primary key(activated timestamp, id, jid) --- ); - -create table resources( - bare_jid text not null, - resource text not null, - foreign key(bare_jid) references users(jid), - primary key(bare_jid, resource) -); - --- enum for subscription state -create table subscription( - state text primary key not null -); - -insert into subscription ( state ) values ('none'), ('pending-out'), ('pending-in'), ('pending-in-pending-out'), ('only-out'), ('only-in'), ('out-pending-in'), ('in-pending-out'), ('buddy'); - --- a roster contains users, with client-set nickname -CREATE TABLE roster( - user_jid text primary key not null, - name TEXT, - subscription text not null, - foreign key(subscription) references subscription(state), - foreign key(user_jid) references users(jid) -); - -create table groups( - group_name text primary key not null -); - -create table groups_roster( - group_name text not null, - contact_jid text not null, - foreign key(group_name) references groups(group_name), - foreign key(contact_jid) references roster(user_jid) on delete cascade, - primary key(group_name, contact_jid) -); - --- chat includes reference to user jid chat is with --- specifically for dms, groups should be different --- can send chat message to user (creating a new chat if not already exists) -create table chats ( - id text primary key not null, - correspondent text not null unique, - foreign key(correspondent) references users(jid) -); - --- messages include reference to chat they are in, and who sent them. -create table messages ( - id text primary key not null, - body text, - chat_id text not null, - -- TODO: channel stuff - -- channel_id uuid, - -- check ((chat_id == null) <> (channel_id == null)), - -- check ((chat_id == null) or (channel_id == null)), - -- user is the current "owner" of the message - -- TODO: queued messages offline - -- TODO: timestamp - timestamp text not null, - - -- TODO: icky - -- the user to show it coming from (not necessarily the original sender) - -- from_identity text not null, - -- original sender details (only from jabber supported for now) - from_jid text not null, - -- resource can be null - from_resource text, - -- check (from_jid != original_sender), - - -- TODO: from can be either a jid, a moved jid (for when a contact moves, save original sender jid/user but link to new user), or imported (from another service (save details), linked to new user) - -- TODO: read bool not null, - foreign key(chat_id) references chats(id) on delete cascade, - -- foreign key(from_identity) references identities(id), - foreign key(from_jid) references users(jid), - foreign key(from_jid, from_resource) references resources(bare_jid, resource) -); - --- enum for subscription state -create table show ( - state text primary key not null -); - -insert into show ( state ) values ('away'), ('chat'), ('do-not-disturb'), ('extended-away'); - -create table cached_status ( - id integer primary key not null, - show text, - message text, - foreign key(show) references show(state) -); - -insert into cached_status (id) values (0); diff --git a/luz/scratch b/luz/scratch deleted file mode 100644 index 9954aef..0000000 --- a/luz/scratch +++ /dev/null @@ -1,87 +0,0 @@ -# logic: - -- db -- pending iqs -- ui update sender - - ## logic methods - - - handle_offline: called by lamp - - handle_online: called by lamp - - handle_stanza: called by read thread - - - handle_connect: called by lamp - - handle_disconnect: called by lamp - - - handle_error?: called by lamp handle threads and read thread for error logging - - handle_stream_error: called by supervisor when stream needs to be reset - - -# lamp: - -- login jid (bare or full) -- password provider -- lamp command receiver -- connected session state(connected, supervisorhandle to disconnect current connected session) -- connected state (if intended to be connected or not, for retrying reconnection every minute or something) -- on_crash for connection supervisor -- internal logic struct which has methods to handle logic commands - -# connected: - -- writehandle -- current full jid for connected session - -# supervisor: - -- control_recv -- read_thread_crash -- write_thread_crash -- read_control_handle -- write_control_handle -- on_crash -- connected -- password -- logic - -# read: - -must be passed around when crash -- supervisor_control -- tasks - -can be cloned from supervisor -- connected . -- logic . - -can be recreated by supervisor -- stream -- disconnecting -- disconnect_timedout -- on_crash -- control_recv - -# write: - -must be passed around when crash -- stanza_recv - -can be recreated by supervisor -- stream -- on_crash -- control_recv - - -message types: - -command: - -- getroster -- send message -- etc. - -lamp commands: - -- connect -- disconnect -- command(command) diff --git a/luz/src/chat.rs b/luz/src/chat.rs deleted file mode 100644 index c1194ea..0000000 --- a/luz/src/chat.rs +++ /dev/null @@ -1,57 +0,0 @@ -use chrono::{DateTime, Utc}; -use jid::JID; -use uuid::Uuid; - -#[derive(Debug, sqlx::FromRow, Clone)] -pub struct Message { - pub id: Uuid, - // does not contain full user information - #[sqlx(rename = "from_jid")] - pub from: JID, - pub timestamp: DateTime, - // TODO: originally_from - // TODO: message edits - // TODO: message timestamp - #[sqlx(flatten)] - pub body: Body, -} - -// TODO: user migrations -// pub enum Migrated { -// Jabber(User), -// Outside, -// } - -#[derive(Debug, sqlx::FromRow, Clone)] -pub struct Body { - // TODO: rich text, other contents, threads - pub body: String, -} - -#[derive(sqlx::FromRow, Debug, Clone)] -pub struct Chat { - pub correspondent: JID, - // pub unread_messages: i32, - // pub latest_message: Message, - // when a new message is received, the chat should be updated, and the new message should be delivered too. - // message history is not stored in chat, retreived separately. - // pub message_history: Vec, -} - -pub enum ChatUpdate {} - -impl Chat { - pub fn new(correspondent: JID) -> Self { - Self { correspondent } - } - pub fn correspondent(&self) -> &JID { - &self.correspondent - } -} - -// TODO: group chats -// pub enum Chat { -// Direct(DirectChat), -// Channel(Channel), -// } -// pub struct Channel {} diff --git a/luz/src/client.rs b/luz/src/client.rs new file mode 100644 index 0000000..de2be08 --- /dev/null +++ b/luz/src/client.rs @@ -0,0 +1,181 @@ +use rsasl::config::SASLConfig; +use stanza::{ + sasl::Mechanisms, + stream::{Feature, Features}, +}; + +use crate::{ + connection::{Tls, Unencrypted}, + jabber_stream::bound_stream::BoundJabberStream, + Connection, Error, JabberStream, Result, JID, +}; + +pub async fn connect_and_login( + jid: &mut JID, + password: impl AsRef, + server: &mut String, +) -> Result> { + let auth = SASLConfig::with_credentials( + None, + jid.localpart.clone().ok_or(Error::NoLocalpart)?, + password.as_ref().to_string(), + ) + .map_err(|e| Error::SASL(e.into()))?; + let mut conn_state = Connecting::start(&server).await?; + loop { + match conn_state { + Connecting::InsecureConnectionEstablised(tcp_stream) => { + conn_state = Connecting::InsecureStreamStarted( + JabberStream::start_stream(tcp_stream, server).await?, + ) + } + Connecting::InsecureStreamStarted(jabber_stream) => { + conn_state = Connecting::InsecureGotFeatures(jabber_stream.get_features().await?) + } + Connecting::InsecureGotFeatures((features, jabber_stream)) => { + match features.negotiate().ok_or(Error::Negotiation)? { + Feature::StartTls(_start_tls) => { + conn_state = Connecting::StartTls(jabber_stream) + } + // TODO: better error + _ => return Err(Error::TlsRequired), + } + } + Connecting::StartTls(jabber_stream) => { + conn_state = + Connecting::ConnectionEstablished(jabber_stream.starttls(&server).await?) + } + Connecting::ConnectionEstablished(tls_stream) => { + conn_state = + Connecting::StreamStarted(JabberStream::start_stream(tls_stream, server).await?) + } + Connecting::StreamStarted(jabber_stream) => { + conn_state = Connecting::GotFeatures(jabber_stream.get_features().await?) + } + Connecting::GotFeatures((features, jabber_stream)) => { + match features.negotiate().ok_or(Error::Negotiation)? { + Feature::StartTls(_start_tls) => return Err(Error::AlreadyTls), + Feature::Sasl(mechanisms) => { + conn_state = Connecting::Sasl(mechanisms, jabber_stream) + } + Feature::Bind => conn_state = Connecting::Bind(jabber_stream), + Feature::Unknown => return Err(Error::Unsupported), + } + } + Connecting::Sasl(mechanisms, jabber_stream) => { + conn_state = Connecting::ConnectionEstablished( + jabber_stream.sasl(mechanisms, auth.clone()).await?, + ) + } + Connecting::Bind(jabber_stream) => { + return Ok(jabber_stream.bind(jid).await?.to_bound_jabber()); + } + } + } +} + +pub enum Connecting { + InsecureConnectionEstablised(Unencrypted), + InsecureStreamStarted(JabberStream), + InsecureGotFeatures((Features, JabberStream)), + StartTls(JabberStream), + ConnectionEstablished(Tls), + StreamStarted(JabberStream), + GotFeatures((Features, JabberStream)), + Sasl(Mechanisms, JabberStream), + Bind(JabberStream), +} + +impl Connecting { + pub async fn start(server: &str) -> Result { + match Connection::connect(server).await? { + Connection::Encrypted(tls_stream) => Ok(Connecting::ConnectionEstablished(tls_stream)), + Connection::Unencrypted(tcp_stream) => { + Ok(Connecting::InsecureConnectionEstablised(tcp_stream)) + } + } + } +} + +pub enum InsecureConnecting { + Disconnected, + ConnectionEstablished(Connection), + PreStarttls(JabberStream), + PreAuthenticated(JabberStream), + Authenticated(Tls), + PreBound(JabberStream), + Bound(JabberStream), +} + +#[cfg(test)] +mod tests { + use std::time::Duration; + + use jid::JID; + use stanza::{ + client::{ + iq::{Iq, IqType, Query}, + Stanza, + }, + xep_0199::Ping, + }; + use test_log::test; + use tokio::time::sleep; + use tracing::info; + + use super::connect_and_login; + + #[test(tokio::test)] + async fn login() { + let mut jid: JID = "test@blos.sm".try_into().unwrap(); + let _client = connect_and_login(&mut jid, "slayed", &mut "blos.sm".to_string()) + .await + .unwrap(); + sleep(Duration::from_secs(5)).await + } + + #[test(tokio::test)] + async fn ping_parallel() { + let mut jid: JID = "test@blos.sm".try_into().unwrap(); + let mut server = "blos.sm".to_string(); + let client = connect_and_login(&mut jid, "slayed", &mut server) + .await + .unwrap(); + let (mut read, mut write) = client.split(); + + tokio::join!( + async { + write + .write(&Stanza::Iq(Iq { + from: Some(jid.clone()), + id: "c2s1".to_string(), + to: Some(server.clone().try_into().unwrap()), + r#type: IqType::Get, + lang: None, + query: Some(Query::Ping(Ping)), + errors: Vec::new(), + })) + .await + .unwrap(); + write + .write(&Stanza::Iq(Iq { + from: Some(jid.clone()), + id: "c2s2".to_string(), + to: Some(server.clone().try_into().unwrap()), + r#type: IqType::Get, + lang: None, + query: Some(Query::Ping(Ping)), + errors: Vec::new(), + })) + .await + .unwrap(); + }, + async { + for _ in 0..2 { + let stanza = read.read::().await.unwrap(); + info!("ping reply: {:#?}", stanza); + } + } + ); + } +} diff --git a/luz/src/connection.rs b/luz/src/connection.rs new file mode 100644 index 0000000..b185eca --- /dev/null +++ b/luz/src/connection.rs @@ -0,0 +1,182 @@ +use std::net::{IpAddr, SocketAddr}; +use std::str; +use std::str::FromStr; + +use tokio::net::TcpStream; +use tokio_native_tls::native_tls::TlsConnector; +// TODO: use rustls +use tokio_native_tls::TlsStream; +use tracing::{debug, info, instrument, trace}; + +use crate::Result; +use crate::{Error, JID}; + +pub type Tls = TlsStream; +pub type Unencrypted = TcpStream; + +#[derive(Debug)] +pub enum Connection { + Encrypted(Tls), + Unencrypted(Unencrypted), +} + +impl Connection { + // #[instrument] + /// stream not started + // pub async fn ensure_tls(self) -> Result> { + // match self { + // Connection::Encrypted(j) => Ok(j), + // Connection::Unencrypted(mut j) => { + // j.start_stream().await?; + // info!("upgrading connection to tls"); + // j.get_features().await?; + // let j = j.starttls().await?; + // Ok(j) + // } + // } + // } + + pub async fn connect_user(jid: impl AsRef) -> Result { + let jid: JID = JID::from_str(jid.as_ref())?; + let server = jid.domainpart.clone(); + Self::connect(&server).await + } + + #[instrument] + pub async fn connect(server: impl AsRef + std::fmt::Debug) -> Result { + info!("connecting to {}", server.as_ref()); + let sockets = Self::get_sockets(server.as_ref()).await; + debug!("discovered sockets: {:?}", sockets); + for (socket_addr, tls) in sockets { + match tls { + true => { + if let Ok(connection) = Self::connect_tls(socket_addr, server.as_ref()).await { + info!("connected via encrypted stream to {}", socket_addr); + // let (readhalf, writehalf) = tokio::io::split(connection); + return Ok(Self::Encrypted(connection)); + } + } + false => { + if let Ok(connection) = Self::connect_unencrypted(socket_addr).await { + info!("connected via unencrypted stream to {}", socket_addr); + // let (readhalf, writehalf) = tokio::io::split(connection); + return Ok(Self::Unencrypted(connection)); + } + } + } + } + Err(Error::Connection) + } + + #[instrument] + async fn get_sockets(address: &str) -> Vec<(SocketAddr, bool)> { + let mut socket_addrs = Vec::new(); + + // if it's a socket/ip then just return that + + // socket + trace!("checking if address is a socket address"); + if let Ok(socket_addr) = SocketAddr::from_str(address) { + debug!("{} is a socket address", address); + match socket_addr.port() { + 5223 => socket_addrs.push((socket_addr, true)), + _ => socket_addrs.push((socket_addr, false)), + } + + return socket_addrs; + } + // ip + trace!("checking if address is an ip"); + if let Ok(ip) = IpAddr::from_str(address) { + debug!("{} is an ip", address); + socket_addrs.push((SocketAddr::new(ip, 5222), false)); + socket_addrs.push((SocketAddr::new(ip, 5223), true)); + return socket_addrs; + } + + // otherwise resolve + debug!("resolving {}", address); + if let Ok(resolver) = trust_dns_resolver::AsyncResolver::tokio_from_system_conf() { + if let Ok(lookup) = resolver + .srv_lookup(format!("_xmpp-client._tcp.{}", address)) + .await + { + for srv in lookup { + resolver + .lookup_ip(srv.target().to_owned()) + .await + .map(|ips| { + for ip in ips { + socket_addrs.push((SocketAddr::new(ip, srv.port()), false)) + } + }); + } + } + if let Ok(lookup) = resolver + .srv_lookup(format!("_xmpps-client._tcp.{}", address)) + .await + { + for srv in lookup { + resolver + .lookup_ip(srv.target().to_owned()) + .await + .map(|ips| { + for ip in ips { + socket_addrs.push((SocketAddr::new(ip, srv.port()), true)) + } + }); + } + } + + // in case cannot connect through SRV records + resolver.lookup_ip(address).await.map(|ips| { + for ip in ips { + socket_addrs.push((SocketAddr::new(ip, 5222), false)); + socket_addrs.push((SocketAddr::new(ip, 5223), true)); + } + }); + } + socket_addrs + } + + /// establishes a connection to the server + #[instrument] + pub async fn connect_tls(socket_addr: SocketAddr, domain_name: &str) -> Result { + let socket = TcpStream::connect(socket_addr) + .await + .map_err(|_| Error::Connection)?; + let connector = TlsConnector::new().map_err(|_| Error::Connection)?; + tokio_native_tls::TlsConnector::from(connector) + .connect(domain_name, socket) + .await + .map_err(|_| Error::Connection) + } + + #[instrument] + pub async fn connect_unencrypted(socket_addr: SocketAddr) -> Result { + TcpStream::connect(socket_addr) + .await + .map_err(|_| Error::Connection) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use test_log::test; + + #[test(tokio::test)] + async fn connect() { + Connection::connect("blos.sm").await.unwrap(); + } + + // #[test(tokio::test)] + // async fn test_tls() { + // Connection::connect("blos.sm", None, None) + // .await + // .unwrap() + // .ensure_tls() + // .await + // .unwrap(); + // } +} diff --git a/luz/src/connection/mod.rs b/luz/src/connection/mod.rs deleted file mode 100644 index 288de70..0000000 --- a/luz/src/connection/mod.rs +++ /dev/null @@ -1,373 +0,0 @@ -// TODO: consider if this needs to be handled by a supervisor or could be handled by luz directly - -use std::{ - collections::HashMap, - ops::{Deref, DerefMut}, - sync::Arc, - time::Duration, -}; - -use jabber::{connection::Tls, jabber_stream::bound_stream::BoundJabberStream}; -use jid::JID; -use read::{ReadControl, ReadControlHandle, ReadState}; -use stanza::client::Stanza; -use tokio::{ - sync::{mpsc, oneshot, Mutex}, - task::{JoinHandle, JoinSet}, -}; -use tracing::info; -use write::{WriteControl, WriteControlHandle, WriteHandle, WriteMessage, WriteState}; - -use crate::{ - db::Db, - error::{ConnectionError, Error, ReadError, WriteError}, - Connected, Logic, LogicState, UpdateMessage, -}; - -mod read; -pub(crate) mod write; - -pub struct Supervisor { - command_recv: mpsc::Receiver, - reader_crash: oneshot::Receiver, - writer_crash: oneshot::Receiver<(WriteMessage, WriteState)>, - read_control_handle: ReadControlHandle, - write_control_handle: WriteControlHandle, - on_crash: oneshot::Sender<()>, - // jid in connected stays the same over the life of the supervisor (the connection session) - connected: Connected, - password: Arc, - logic: Lgc, -} - -pub enum SupervisorCommand { - Disconnect, - // for if there was a stream error, require to reconnect - // couldn't stream errors just cause a crash? lol - Reconnect(ChildState), -} - -pub enum ChildState { - Write(WriteState), - Read(ReadState), -} - -impl Supervisor { - fn new( - command_recv: mpsc::Receiver, - reader_crash: oneshot::Receiver, - writer_crash: oneshot::Receiver<(WriteMessage, WriteState)>, - read_control_handle: ReadControlHandle, - write_control_handle: WriteControlHandle, - on_crash: oneshot::Sender<()>, - connected: Connected, - password: Arc, - logic: Lgc, - ) -> Self { - Self { - command_recv, - reader_crash, - writer_crash, - read_control_handle, - write_control_handle, - on_crash, - connected, - password, - logic, - } - } - - async fn run(mut self) { - loop { - tokio::select! { - Some(msg) = self.command_recv.recv() => { - match msg { - SupervisorCommand::Disconnect => { - info!("disconnecting"); - // TODO: do handle_disconnect here - let _ = self.write_control_handle.send(WriteControl::Disconnect).await; - let _ = self.read_control_handle.send(ReadControl::Disconnect).await; - info!("sent disconnect command"); - tokio::select! { - _ = async { tokio::join!( - async { let _ = (&mut self.write_control_handle.handle).await; }, - async { let _ = (&mut self.read_control_handle.handle).await; } - ) } => {}, - // TODO: config timeout - _ = async { tokio::time::sleep(Duration::from_secs(5)) } => { - (&mut self.read_control_handle.handle).abort(); - (&mut self.write_control_handle.handle).abort(); - } - } - info!("disconnected"); - break; - }, - // TODO: Reconnect without aborting, gentle reconnect. - SupervisorCommand::Reconnect(state) => { - // TODO: please omfg - // send abort to read stream, as already done, consider - let (read_state, mut write_state); - match state { - // TODO: proper state things for read and write thread - ChildState::Write(receiver) => { - write_state = receiver; - let (send, recv) = oneshot::channel(); - let _ = self.read_control_handle.send(ReadControl::Abort(send)).await; - if let Ok(state) = recv.await { - read_state = state; - } else { - break - } - }, - ChildState::Read(read) => { - read_state = read; - let (send, recv) = oneshot::channel(); - let _ = self.write_control_handle.send(WriteControl::Abort(send)).await; - // TODO: need a tokio select, in case the state arrives from somewhere else - if let Ok(state) = recv.await { - write_state = state; - } else { - break - } - }, - } - - let mut jid = self.connected.jid.clone(); - let mut domain = jid.domainpart.clone(); - // TODO: make sure connect_and_login does not modify the jid, but instead returns a jid. or something like that - let connection = jabber::connect_and_login(&mut jid, &*self.password, &mut domain).await; - match connection { - Ok(c) => { - let (read, write) = c.split(); - let (send, recv) = oneshot::channel(); - self.writer_crash = recv; - self.write_control_handle = - WriteControlHandle::reconnect(write, send, write_state.stanza_recv); - let (send, recv) = oneshot::channel(); - self.reader_crash = recv; - self.read_control_handle = ReadControlHandle::reconnect( - read, - read_state.tasks, - self.connected.clone(), - self.logic.clone(), - read_state.supervisor_control, - send, - ); - }, - Err(e) => { - // if reconnection failure, respond to all current write messages with lost connection error. the received processes should complete themselves. - write_state.stanza_recv.close(); - while let Some(msg) = write_state.stanza_recv.recv().await { - let _ = msg.respond_to.send(Err(WriteError::LostConnection)); - } - // TODO: is this the correct error? - self.logic.handle_connection_error(ConnectionError::LostConnection).await; - break; - }, - } - }, - } - }, - Ok((write_msg, mut write_state)) = &mut self.writer_crash => { - // consider awaiting/aborting the read and write threads - let (send, recv) = oneshot::channel(); - let _ = self.read_control_handle.send(ReadControl::Abort(send)).await; - let read_state = tokio::select! { - Ok(s) = recv => s, - Ok(s) = &mut self.reader_crash => s, - // in case, just break as irrecoverable - else => break, - }; - - let mut jid = self.connected.jid.clone(); - let mut domain = jid.domainpart.clone(); - // TODO: same here - let connection = jabber::connect_and_login(&mut jid, &*self.password, &mut domain).await; - match connection { - Ok(c) => { - let (read, write) = c.split(); - let (send, recv) = oneshot::channel(); - self.writer_crash = recv; - self.write_control_handle = - WriteControlHandle::reconnect_retry(write, send, write_state.stanza_recv, write_msg); - let (send, recv) = oneshot::channel(); - self.reader_crash = recv; - self.read_control_handle = ReadControlHandle::reconnect( - read, - read_state.tasks, - self.connected.clone(), - self.logic.clone(), - read_state.supervisor_control, - send, - ); - }, - Err(e) => { - // if reconnection failure, respond to all current write messages with lost connection error. the received processes should complete themselves. - write_state.stanza_recv.close(); - let _ = write_msg.respond_to.send(Err(WriteError::LostConnection)); - while let Some(msg) = write_state.stanza_recv.recv().await { - let _ = msg.respond_to.send(Err(WriteError::LostConnection)); - } - // TODO: is this the correct error to send? - self.logic.handle_connection_error(ConnectionError::LostConnection).await; - break; - }, - } - }, - Ok(read_state) = &mut self.reader_crash => { - let (send, recv) = oneshot::channel(); - let _ = self.write_control_handle.send(WriteControl::Abort(send)).await; - let (retry_msg, mut write_state) = tokio::select! { - Ok(s) = recv => (None, s), - Ok(s) = &mut self.writer_crash => (Some(s.0), s.1), - // in case, just break as irrecoverable - else => break, - }; - - let mut jid = self.connected.jid.clone(); - let mut domain = jid.domainpart.clone(); - let connection = jabber::connect_and_login(&mut jid, &*self.password, &mut domain).await; - match connection { - Ok(c) => { - let (read, write) = c.split(); - let (send, recv) = oneshot::channel(); - self.writer_crash = recv; - if let Some(msg) = retry_msg { - self.write_control_handle = - WriteControlHandle::reconnect_retry(write, send, write_state.stanza_recv, msg); - } else { - self.write_control_handle = WriteControlHandle::reconnect(write, send, write_state.stanza_recv) - } - let (send, recv) = oneshot::channel(); - self.reader_crash = recv; - self.read_control_handle = ReadControlHandle::reconnect( - read, - read_state.tasks, - self.connected.clone(), - self.logic.clone(), - read_state.supervisor_control, - send, - ); - }, - Err(e) => { - // if reconnection failure, respond to all current messages with lost connection error. - write_state.stanza_recv.close(); - if let Some(msg) = retry_msg { - msg.respond_to.send(Err(WriteError::LostConnection)); - } - while let Some(msg) = write_state.stanza_recv.recv().await { - msg.respond_to.send(Err(WriteError::LostConnection)); - } - // TODO: is this the correct error? - self.logic.handle_connection_error(ConnectionError::LostConnection).await; - break; - }, - } - }, - else => break, - } - } - // TODO: maybe don't just on_crash - let _ = self.on_crash.send(()); - } -} - -pub struct SupervisorHandle { - sender: SupervisorSender, - handle: JoinHandle<()>, -} - -impl Deref for SupervisorHandle { - type Target = SupervisorSender; - - fn deref(&self) -> &Self::Target { - &self.sender - } -} - -impl DerefMut for SupervisorHandle { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.sender - } -} - -#[derive(Clone)] -pub struct SupervisorSender { - sender: mpsc::Sender, -} - -impl Deref for SupervisorSender { - type Target = mpsc::Sender; - - fn deref(&self) -> &Self::Target { - &self.sender - } -} - -impl DerefMut for SupervisorSender { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.sender - } -} - -impl SupervisorHandle { - pub fn new( - streams: BoundJabberStream, - on_crash: oneshot::Sender<()>, - jid: JID, - password: Arc, - logic: Lgc, - ) -> (WriteHandle, Self) { - let (command_send, command_recv) = mpsc::channel(20); - let (writer_crash_send, writer_crash_recv) = oneshot::channel(); - let (reader_crash_send, reader_crash_recv) = oneshot::channel(); - - let (read_stream, write_stream) = streams.split(); - - let (write_handle, write_control_handle) = - WriteControlHandle::new(write_stream, writer_crash_send); - - let connected = Connected { - jid, - write_handle: write_handle.clone(), - }; - - let supervisor_sender = SupervisorSender { - sender: command_send, - }; - - let read_control_handle = ReadControlHandle::new( - read_stream, - connected.clone(), - logic.clone(), - supervisor_sender.clone(), - reader_crash_send, - ); - - let actor = Supervisor::new( - command_recv, - reader_crash_recv, - writer_crash_recv, - read_control_handle, - write_control_handle, - on_crash, - connected, - password, - logic, - ); - - let handle = tokio::spawn(async move { actor.run().await }); - - ( - write_handle, - Self { - sender: supervisor_sender, - handle, - }, - ) - } - - pub fn sender(&self) -> SupervisorSender { - self.sender.clone() - } -} diff --git a/luz/src/connection/read.rs b/luz/src/connection/read.rs deleted file mode 100644 index 4e55bc5..0000000 --- a/luz/src/connection/read.rs +++ /dev/null @@ -1,242 +0,0 @@ -use std::{ - collections::HashMap, - marker::PhantomData, - ops::{Deref, DerefMut}, - str::FromStr, - sync::Arc, - time::Duration, -}; - -use chrono::{DateTime, Utc}; -use jabber::{connection::Tls, jabber_stream::bound_stream::BoundJabberReader}; -use stanza::client::Stanza; -use tokio::{ - sync::{mpsc, oneshot, Mutex}, - task::{JoinHandle, JoinSet}, -}; -use tracing::info; -use uuid::Uuid; - -use crate::{ - chat::{Body, Message}, - db::Db, - error::{Error, IqError, MessageRecvError, PresenceError, ReadError, RosterError}, - presence::{Offline, Online, Presence, PresenceType, Show}, - roster::Contact, - Connected, Logic, LogicState, UpdateMessage, -}; - -use super::{write::WriteHandle, SupervisorCommand, SupervisorSender}; - -/// read actor -pub struct Read { - stream: BoundJabberReader, - disconnecting: bool, - disconnect_timedout: oneshot::Receiver<()>, - - // all the threads spawned by the current connection session - tasks: JoinSet<()>, - - // for handling incoming stanzas - // jabber server must be able to both terminate the connection from error, and ask for data from the client (such as supported XEPs) - connected: Connected, - logic: Lgc, - supervisor_control: SupervisorSender, - - // control stuff - control_receiver: mpsc::Receiver, - on_crash: oneshot::Sender, -} - -/// when a crash/abort occurs, this gets sent back to the supervisor, so that the connection session can continue -pub struct ReadState { - pub supervisor_control: SupervisorSender, - // TODO: when a stream dies, the iq gets from the server should not be replied to on the new stream - pub tasks: JoinSet<()>, -} - -impl Read { - fn new( - stream: BoundJabberReader, - tasks: JoinSet<()>, - connected: Connected, - logic: Lgc, - supervisor_control: SupervisorSender, - control_receiver: mpsc::Receiver, - on_crash: oneshot::Sender, - ) -> Self { - let (_send, recv) = oneshot::channel(); - Self { - stream, - disconnecting: false, - disconnect_timedout: recv, - tasks, - connected, - logic, - supervisor_control, - control_receiver, - on_crash, - } - } -} - -impl Read { - async fn run(mut self) { - println!("started read thread"); - // let stanza = self.stream.read::().await; - // println!("{:?}", stanza); - loop { - tokio::select! { - // if still haven't received the end tag in time, just kill itself - // TODO: is this okay??? what if notification thread dies? - Ok(()) = &mut self.disconnect_timedout => { - info!("disconnect_timedout"); - break; - } - Some(msg) = self.control_receiver.recv() => { - match msg { - // when disconnect received, - ReadControl::Disconnect => { - let (send, recv) = oneshot::channel(); - self.disconnect_timedout = recv; - self.disconnecting = true; - tokio::spawn(async { - tokio::time::sleep(Duration::from_secs(10)).await; - let _ = send.send(()); - }) - }, - ReadControl::Abort(sender) => { - let _ = sender.send(ReadState { supervisor_control: self.supervisor_control, tasks: self.tasks }); - break; - }, - }; - }, - s = self.stream.read::() => { - println!("read stanza"); - match s { - Ok(s) => { - self.tasks.spawn(self.logic.clone().handle_stanza(s, self.connected.clone(), self.supervisor_control.clone())); - }, - Err(e) => { - println!("error: {:?}", e); - // TODO: NEXT write the correct error stanza depending on error, decide whether to reconnect or properly disconnect, depending on if disconnecting is true - // match e { - // peanuts::Error::ReadError(error) => todo!(), - // peanuts::Error::Utf8Error(utf8_error) => todo!(), - // peanuts::Error::ParseError(_) => todo!(), - // peanuts::Error::EntityProcessError(_) => todo!(), - // peanuts::Error::InvalidCharRef(_) => todo!(), - // peanuts::Error::DuplicateNameSpaceDeclaration(namespace_declaration) => todo!(), - // peanuts::Error::DuplicateAttribute(_) => todo!(), - // peanuts::Error::UnqualifiedNamespace(_) => todo!(), - // peanuts::Error::MismatchedEndTag(name, name1) => todo!(), - // peanuts::Error::NotInElement(_) => todo!(), - // peanuts::Error::ExtraData(_) => todo!(), - // peanuts::Error::UndeclaredNamespace(_) => todo!(), - // peanuts::Error::IncorrectName(name) => todo!(), - // peanuts::Error::DeserializeError(_) => todo!(), - // peanuts::Error::Deserialize(deserialize_error) => todo!(), - // peanuts::Error::RootElementEnded => todo!(), - // } - // TODO: make sure this only happens when an end tag is received - if self.disconnecting == true { - break; - } else { - let _ = self.on_crash.send(ReadState { supervisor_control: self.supervisor_control, tasks: self.tasks }); - } - break; - }, - } - }, - else => break - } - } - println!("stopping read thread"); - self.logic.on_abort().await; - } -} - -// what do stanza processes do? -// - update ui -// - access database -// - disconnect proper, reconnect -// - respond to server requests - -pub enum ReadControl { - Disconnect, - Abort(oneshot::Sender), -} - -pub struct ReadControlHandle { - sender: mpsc::Sender, - pub(crate) handle: JoinHandle<()>, -} - -impl Deref for ReadControlHandle { - type Target = mpsc::Sender; - - fn deref(&self) -> &Self::Target { - &self.sender - } -} - -impl DerefMut for ReadControlHandle { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.sender - } -} - -impl ReadControlHandle { - pub fn new( - stream: BoundJabberReader, - connected: Connected, - logic: Lgc, - supervisor_control: SupervisorSender, - on_crash: oneshot::Sender, - ) -> Self { - let (control_sender, control_receiver) = mpsc::channel(20); - - let actor = Read::new( - stream, - JoinSet::new(), - connected, - logic, - supervisor_control, - control_receiver, - on_crash, - ); - let handle = tokio::spawn(async move { actor.run().await }); - - Self { - sender: control_sender, - handle, - } - } - - pub fn reconnect( - stream: BoundJabberReader, - tasks: JoinSet<()>, - connected: Connected, - logic: Lgc, - supervisor_control: SupervisorSender, - on_crash: oneshot::Sender, - ) -> Self { - let (control_sender, control_receiver) = mpsc::channel(20); - - let actor = Read::new( - stream, - tasks, - connected, - logic, - supervisor_control, - control_receiver, - on_crash, - ); - let handle = tokio::spawn(async move { actor.run().await }); - - Self { - sender: control_sender, - handle, - } - } -} diff --git a/luz/src/connection/write.rs b/luz/src/connection/write.rs deleted file mode 100644 index ff78b81..0000000 --- a/luz/src/connection/write.rs +++ /dev/null @@ -1,258 +0,0 @@ -use std::ops::{Deref, DerefMut}; - -use jabber::{connection::Tls, jabber_stream::bound_stream::BoundJabberWriter}; -use stanza::client::Stanza; -use tokio::{ - sync::{mpsc, oneshot}, - task::JoinHandle, -}; - -use crate::error::WriteError; - -/// actor that receives jabber stanzas to write, and if there is an error, sends a message back to the supervisor then aborts, so the supervisor can spawn a new stream. -pub struct Write { - stream: BoundJabberWriter, - - /// connection session write queue - stanza_receiver: mpsc::Receiver, - - // control stuff - control_receiver: mpsc::Receiver, - on_crash: oneshot::Sender<(WriteMessage, WriteState)>, -} - -/// when a crash/abort occurs, this gets sent back to the supervisor, possibly with the current write that failed, so that the connection session can continue -pub struct WriteState { - pub stanza_recv: mpsc::Receiver, -} - -#[derive(Debug)] -pub struct WriteMessage { - pub stanza: Stanza, - pub respond_to: oneshot::Sender>, -} - -pub enum WriteControl { - Disconnect, - Abort(oneshot::Sender), -} - -impl Write { - fn new( - stream: BoundJabberWriter, - stanza_receiver: mpsc::Receiver, - control_receiver: mpsc::Receiver, - on_crash: oneshot::Sender<(WriteMessage, WriteState)>, - ) -> Self { - Self { - stream, - stanza_receiver, - control_receiver, - on_crash, - } - } - - async fn write(&mut self, stanza: &Stanza) -> Result<(), peanuts::Error> { - Ok(self.stream.write(stanza).await?) - } - - async fn run_reconnected(mut self, retry_msg: WriteMessage) { - // try to retry sending the message that failed to send previously - let result = self.stream.write(&retry_msg.stanza).await; - match result { - Err(e) => match &e { - peanuts::Error::ReadError(_error) => { - // make sure message is not lost from error, supervisor handles retry and reporting - // TODO: upon reconnect, make sure we are not stuck in a reconnection loop - let _ = self.on_crash.send(( - retry_msg, - WriteState { - stanza_recv: self.stanza_receiver, - }, - )); - return; - } - _ => { - let _ = retry_msg.respond_to.send(Err(e.into())); - } - }, - _ => { - let _ = retry_msg.respond_to.send(Ok(())); - } - } - // return to normal loop - self.run().await - } - - async fn run(mut self) { - loop { - tokio::select! { - Some(msg) = self.control_receiver.recv() => { - match msg { - WriteControl::Disconnect => { - // close the stanza_receiver channel and drain out all of the remaining stanzas to send - self.stanza_receiver.close(); - // TODO: put this in some kind of function to avoid code duplication - while let Some(msg) = self.stanza_receiver.recv().await { - let result = self.stream.write(&msg.stanza).await; - match result { - Err(e) => match &e { - peanuts::Error::ReadError(_error) => { - // if connection lost during disconnection, just send lost connection error to the write requests - let _ = msg.respond_to.send(Err(WriteError::LostConnection)); - while let Some(msg) = self.stanza_receiver.recv().await { - let _ = msg.respond_to.send(Err(WriteError::LostConnection)); - } - break; - } - // otherwise complete sending all the stanzas currently in the queue - _ => { - let _ = msg.respond_to.send(Err(e.into())); - } - }, - _ => { - let _ = msg.respond_to.send(Ok(())); - } - } - } - let _ = self.stream.try_close().await; - break; - }, - // in case of abort, stream is already fucked, just send the receiver ready for a reconnection at the same resource - WriteControl::Abort(sender) => { - let _ = sender.send(WriteState { stanza_recv: self.stanza_receiver }); - break; - }, - } - }, - Some(msg) = self.stanza_receiver.recv() => { - let result = self.stream.write(&msg.stanza).await; - match result { - Err(e) => match &e { - peanuts::Error::ReadError(_error) => { - // make sure message is not lost from error, supervisor handles retry and reporting - let _ = self.on_crash.send((msg, WriteState { stanza_recv: self.stanza_receiver })); - break; - } - _ => { - let _ = msg.respond_to.send(Err(e.into())); - } - }, - _ => { - let _ = msg.respond_to.send(Ok(())); - } - } - }, - else => break, - } - } - } -} - -#[derive(Clone)] -pub struct WriteHandle { - sender: mpsc::Sender, -} - -impl WriteHandle { - pub async fn write(&self, stanza: Stanza) -> Result<(), WriteError> { - let (send, recv) = oneshot::channel(); - self.send(WriteMessage { - stanza, - respond_to: send, - }) - .await - .map_err(|e| WriteError::Actor(e.into()))?; - // TODO: timeout - recv.await.map_err(|e| WriteError::Actor(e.into()))? - } -} - -impl Deref for WriteHandle { - type Target = mpsc::Sender; - - fn deref(&self) -> &Self::Target { - &self.sender - } -} - -impl DerefMut for WriteHandle { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.sender - } -} - -pub struct WriteControlHandle { - sender: mpsc::Sender, - pub(crate) handle: JoinHandle<()>, -} - -impl Deref for WriteControlHandle { - type Target = mpsc::Sender; - - fn deref(&self) -> &Self::Target { - &self.sender - } -} - -impl DerefMut for WriteControlHandle { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.sender - } -} - -impl WriteControlHandle { - pub fn new( - stream: BoundJabberWriter, - on_crash: oneshot::Sender<(WriteMessage, WriteState)>, - ) -> (WriteHandle, Self) { - let (control_sender, control_receiver) = mpsc::channel(20); - let (stanza_sender, stanza_receiver) = mpsc::channel(20); - - let actor = Write::new(stream, stanza_receiver, control_receiver, on_crash); - let handle = tokio::spawn(async move { actor.run().await }); - - ( - WriteHandle { - sender: stanza_sender, - }, - Self { - sender: control_sender, - handle, - }, - ) - } - - pub fn reconnect_retry( - stream: BoundJabberWriter, - on_crash: oneshot::Sender<(WriteMessage, WriteState)>, - stanza_receiver: mpsc::Receiver, - retry_msg: WriteMessage, - ) -> Self { - let (control_sender, control_receiver) = mpsc::channel(20); - - let actor = Write::new(stream, stanza_receiver, control_receiver, on_crash); - let handle = tokio::spawn(async move { actor.run_reconnected(retry_msg).await }); - - Self { - sender: control_sender, - handle, - } - } - - pub fn reconnect( - stream: BoundJabberWriter, - on_crash: oneshot::Sender<(WriteMessage, WriteState)>, - stanza_receiver: mpsc::Receiver, - ) -> Self { - let (control_sender, control_receiver) = mpsc::channel(20); - - let actor = Write::new(stream, stanza_receiver, control_receiver, on_crash); - let handle = tokio::spawn(async move { actor.run().await }); - - Self { - sender: control_sender, - handle, - } - } -} diff --git a/luz/src/db/mod.rs b/luz/src/db/mod.rs deleted file mode 100644 index aea40ac..0000000 --- a/luz/src/db/mod.rs +++ /dev/null @@ -1,521 +0,0 @@ -use std::{collections::HashSet, path::Path}; - -use jid::JID; -use sqlx::{migrate, Error, SqlitePool}; -use uuid::Uuid; - -use crate::{ - chat::{Chat, Message}, - error::{DatabaseError, DatabaseOpenError}, - presence::Online, - roster::Contact, - user::User, -}; - -#[derive(Clone)] -pub struct Db { - db: SqlitePool, -} - -// TODO: turn into trait -impl Db { - pub async fn create_connect_and_migrate( - path: impl AsRef, - ) -> Result { - if let Some(dir) = path.as_ref().parent() { - if dir.is_dir() { - } else { - tokio::fs::create_dir_all(dir).await?; - } - let _file = tokio::fs::OpenOptions::new() - .append(true) - .create(true) - .open(path.as_ref()) - .await?; - } - let url = format!( - "sqlite://{}", - path.as_ref() - .to_str() - .ok_or(DatabaseOpenError::InvalidPath)? - ); - let db = SqlitePool::connect(&url).await?; - migrate!().run(&db).await?; - Ok(Self { db }) - } - - pub(crate) fn new(db: SqlitePool) -> Self { - Self { db } - } - - pub(crate) async fn create_user(&self, user: User) -> Result<(), Error> { - sqlx::query!( - "insert into users ( jid, cached_status_message ) values ( ?, ? )", - user.jid, - user.cached_status_message - ) - .execute(&self.db) - .await?; - Ok(()) - } - - pub(crate) async fn read_user(&self, user: JID) -> Result { - let user: User = sqlx::query_as("select * from users where jid = ?") - .bind(user) - .fetch_one(&self.db) - .await?; - Ok(user) - } - - pub(crate) async fn update_user(&self, user: User) -> Result<(), Error> { - sqlx::query!( - "update users set cached_status_message = ? where jid = ?", - user.cached_status_message, - user.jid - ) - .execute(&self.db) - .await?; - Ok(()) - } - - // TODO: should this be allowed? messages need to reference users. should probably only allow delete if every other thing referencing it has been deleted, or if you make clear to the user deleting a user will delete all messages associated with them. - // pub(crate) async fn delete_user(&self, user: JID) -> Result<(), Error> {} - - /// does not create the underlying user, if underlying user does not exist, create_user() must be called separately - pub(crate) async fn create_contact(&self, contact: Contact) -> Result<(), Error> { - sqlx::query!( - "insert into roster ( user_jid, name, subscription ) values ( ?, ?, ? )", - contact.user_jid, - contact.name, - contact.subscription - ) - .execute(&self.db) - .await?; - // TODO: abstract this out in to add_to_group() function ? - for group in contact.groups { - sqlx::query!( - "insert into groups (group_name) values (?) on conflict do nothing", - group - ) - .execute(&self.db) - .await?; - sqlx::query!( - "insert into groups_roster (group_name, contact_jid) values (?, ?)", - group, - contact.user_jid - ) - .execute(&self.db) - .await?; - } - Ok(()) - } - - pub(crate) async fn read_contact(&self, contact: JID) -> Result { - let mut contact: Contact = sqlx::query_as("select * from roster where user_jid = ?") - .bind(contact) - .fetch_one(&self.db) - .await?; - #[derive(sqlx::FromRow)] - struct Row { - group_name: String, - } - let groups: Vec = - sqlx::query_as("select group_name from groups_roster where contact_jid = ?") - .bind(&contact.user_jid) - .fetch_all(&self.db) - .await?; - contact.groups = HashSet::from_iter(groups.into_iter().map(|row| row.group_name)); - Ok(contact) - } - - pub(crate) async fn read_contact_opt(&self, contact: &JID) -> Result, Error> { - let contact: Option = - sqlx::query_as("select * from roster join users on jid = user_jid where jid = ?") - .bind(contact) - .fetch_optional(&self.db) - .await?; - if let Some(mut contact) = contact { - #[derive(sqlx::FromRow)] - struct Row { - group_name: String, - } - let groups: Vec = - sqlx::query_as("select group_name from groups_roster where contact_jid = ?") - .bind(&contact.user_jid) - .fetch_all(&self.db) - .await?; - contact.groups = HashSet::from_iter(groups.into_iter().map(|row| row.group_name)); - Ok(Some(contact)) - } else { - Ok(None) - } - } - - /// does not update the underlying user, to update user, update_user() must be called separately - pub(crate) async fn update_contact(&self, contact: Contact) -> Result<(), Error> { - sqlx::query!( - "update roster set name = ?, subscription = ? where user_jid = ?", - contact.name, - contact.subscription, - contact.user_jid - ) - .execute(&self.db) - .await?; - sqlx::query!( - "delete from groups_roster where contact_jid = ?", - contact.user_jid - ) - .execute(&self.db) - .await?; - // TODO: delete orphaned groups from groups table - for group in contact.groups { - sqlx::query!( - "insert into groups (group_name) values (?) on conflict do nothing", - group - ) - .execute(&self.db) - .await?; - sqlx::query!( - "insert into groups_roster (group_name, contact_jid) values (?, ?)", - group, - contact.user_jid - ) - .execute(&self.db) - .await?; - } - Ok(()) - } - - pub(crate) async fn upsert_contact(&self, contact: Contact) -> Result<(), Error> { - sqlx::query!( - "insert into users ( jid ) values ( ? ) on conflict do nothing", - contact.user_jid, - ) - .execute(&self.db) - .await?; - sqlx::query!( - "insert into roster ( user_jid, name, subscription ) values ( ?, ?, ? ) on conflict do update set name = ?, subscription = ?", - contact.user_jid, - contact.name, - contact.subscription, - contact.name, - contact.subscription - ) - .execute(&self.db) - .await?; - sqlx::query!( - "delete from groups_roster where contact_jid = ?", - contact.user_jid - ) - .execute(&self.db) - .await?; - // TODO: delete orphaned groups from groups table - for group in contact.groups { - sqlx::query!( - "insert into groups (group_name) values (?) on conflict do nothing", - group - ) - .execute(&self.db) - .await?; - sqlx::query!( - "insert into groups_roster (group_name, contact_jid) values (?, ?)", - group, - contact.user_jid - ) - .execute(&self.db) - .await?; - } - Ok(()) - } - - pub(crate) async fn delete_contact(&self, contact: JID) -> Result<(), Error> { - sqlx::query!("delete from roster where user_jid = ?", contact) - .execute(&self.db) - .await?; - // TODO: delete orphaned groups from groups table - Ok(()) - } - - pub(crate) async fn replace_cached_roster(&self, roster: Vec) -> Result<(), Error> { - sqlx::query!("delete from roster").execute(&self.db).await?; - for contact in roster { - self.upsert_contact(contact).await?; - } - Ok(()) - } - - pub(crate) async fn read_cached_roster(&self) -> Result, Error> { - let mut roster: Vec = - sqlx::query_as("select * from roster join users on jid = user_jid") - .fetch_all(&self.db) - .await?; - for contact in &mut roster { - #[derive(sqlx::FromRow)] - struct Row { - group_name: String, - } - let groups: Vec = - sqlx::query_as("select group_name from groups_roster where contact_jid = ?") - .bind(&contact.user_jid) - .fetch_all(&self.db) - .await?; - contact.groups = HashSet::from_iter(groups.into_iter().map(|row| row.group_name)); - } - Ok(roster) - } - - pub(crate) async fn create_chat(&self, chat: Chat) -> Result<(), Error> { - let id = Uuid::new_v4(); - let jid = chat.correspondent(); - sqlx::query!( - "insert into chats (id, correspondent) values (?, ?)", - id, - jid - ) - .execute(&self.db) - .await?; - Ok(()) - } - - // TODO: what happens if a correspondent changes from a user to a contact? maybe just have correspondent be a user, then have the client make the user show up as a contact in ui if they are in the loaded roster. - - pub(crate) async fn read_chat(&self, chat: JID) -> Result { - // check if the chat correponding with the jid exists - let chat: Chat = sqlx::query_as("select correspondent from chats where correspondent = ?") - .bind(chat) - .fetch_one(&self.db) - .await?; - Ok(chat) - } - - pub(crate) async fn update_chat_correspondent( - &self, - old_chat: Chat, - new_correspondent: JID, - ) -> Result { - // TODO: update other chat data if it differs (for now there is only correspondent so doesn't matter) - let new_jid = &new_correspondent; - let old_jid = old_chat.correspondent(); - sqlx::query!( - "update chats set correspondent = ? where correspondent = ?", - new_jid, - old_jid, - ) - .execute(&self.db) - .await?; - let chat = self.read_chat(new_correspondent).await?; - Ok(chat) - } - - // pub(crate) async fn update_chat - - pub(crate) async fn delete_chat(&self, chat: JID) -> Result<(), Error> { - sqlx::query!("delete from chats where correspondent = ?", chat) - .execute(&self.db) - .await?; - Ok(()) - } - - /// TODO: sorting and filtering (for now there is no sorting) - pub(crate) async fn read_chats(&self) -> Result, Error> { - let chats: Vec = sqlx::query_as("select * from chats") - .fetch_all(&self.db) - .await?; - Ok(chats) - } - - /// chats ordered by date of last message - // greatest-n-per-group - pub(crate) async fn read_chats_ordered(&self) -> Result, Error> { - let chats = sqlx::query_as("select c.*, m.* from chats c join (select chat_id, max(timestamp) max_timestamp from messages group by chat_id) max_timestamps on c.id = max_timestamps.chat_id join messages m on max_timestamps.chat_id = m.chat_id and max_timestamps.max_timestamp = m.timestamp order by m.timestamp desc") - .fetch_all(&self.db) - .await?; - Ok(chats) - } - - /// chats ordered by date of last message - // greatest-n-per-group - pub(crate) async fn read_chats_ordered_with_latest_messages( - &self, - ) -> Result, Error> { - #[derive(sqlx::FromRow)] - pub struct ChatWithMessage { - #[sqlx(flatten)] - pub chat: Chat, - #[sqlx(flatten)] - pub message: Message, - } - - // TODO: i don't know if this will assign the right uuid to the latest message or the chat's id. should probably check but i don't think it matters as nothing ever gets called with the id of the latest message in the chats list - let chats: Vec = sqlx::query_as("select c.*, m.* from chats c join (select chat_id, max(timestamp) max_timestamp from messages group by chat_id) max_timestamps on c.id = max_timestamps.chat_id join messages m on max_timestamps.chat_id = m.chat_id and max_timestamps.max_timestamp = m.timestamp order by m.timestamp desc") - .fetch_all(&self.db) - .await?; - - let chats = chats - .into_iter() - .map(|chat_with_message| (chat_with_message.chat, chat_with_message.message)) - .collect(); - - Ok(chats) - } - - async fn read_chat_id(&self, chat: JID) -> Result { - #[derive(sqlx::FromRow)] - struct Row { - id: Uuid, - } - let chat = chat.as_bare(); - let chat_id: Row = sqlx::query_as("select id from chats where correspondent = ?") - .bind(chat) - .fetch_one(&self.db) - .await?; - let chat_id = chat_id.id; - Ok(chat_id) - } - - async fn read_chat_id_opt(&self, chat: JID) -> Result, Error> { - #[derive(sqlx::FromRow)] - struct Row { - id: Uuid, - } - let chat_id: Option = sqlx::query_as("select id from chats where correspondent = ?") - .bind(chat) - .fetch_optional(&self.db) - .await?; - let chat_id = chat_id.map(|row| row.id); - Ok(chat_id) - } - - /// if the chat doesn't already exist, it must be created by calling create_chat() before running this function. - pub(crate) async fn create_message(&self, message: Message, chat: JID) -> Result<(), Error> { - // TODO: one query - let bare_jid = message.from.as_bare(); - let resource = message.from.resourcepart; - let chat_id = self.read_chat_id(chat).await?; - sqlx::query!("insert into messages (id, body, chat_id, from_jid, from_resource, timestamp) values (?, ?, ?, ?, ?, ?)", message.id, message.body.body, chat_id, bare_jid, resource, message.timestamp).execute(&self.db).await?; - Ok(()) - } - - pub(crate) async fn create_message_with_self_resource_and_chat( - &self, - message: Message, - chat: JID, - ) -> Result<(), Error> { - let from_jid = message.from.as_bare(); - let resource = &message.from.resourcepart; - let bare_chat = chat.as_bare(); - sqlx::query!( - "insert into users (jid) values (?) on conflict do nothing", - from_jid - ) - .execute(&self.db) - .await?; - let id = Uuid::new_v4(); - sqlx::query!( - "insert into chats (id, correspondent) values (?, ?) on conflict do nothing", - id, - bare_chat - ) - .execute(&self.db) - .await?; - if let Some(resource) = resource { - sqlx::query!( - "insert into resources (bare_jid, resource) values (?, ?) on conflict do nothing", - from_jid, - resource - ) - .execute(&self.db) - .await?; - } - self.create_message(message, chat).await?; - Ok(()) - } - - // create direct message from incoming - pub(crate) async fn create_message_with_user_resource_and_chat( - &self, - message: Message, - chat: JID, - ) -> Result<(), Error> { - let bare_chat = chat.as_bare(); - let resource = &chat.resourcepart; - sqlx::query!( - "insert into users (jid) values (?) on conflict do nothing", - bare_chat - ) - .execute(&self.db) - .await?; - let id = Uuid::new_v4(); - sqlx::query!( - "insert into chats (id, correspondent) values (?, ?) on conflict do nothing", - id, - bare_chat - ) - .execute(&self.db) - .await?; - if let Some(resource) = resource { - sqlx::query!( - "insert into resources (bare_jid, resource) values (?, ?) on conflict do nothing", - bare_chat, - resource - ) - .execute(&self.db) - .await?; - } - self.create_message(message, chat).await?; - Ok(()) - } - - pub(crate) async fn read_message(&self, message: Uuid) -> Result { - let message: Message = sqlx::query_as("select * from messages where id = ?") - .bind(message) - .fetch_one(&self.db) - .await?; - Ok(message) - } - - // TODO: message updates/edits pub(crate) async fn update_message(&self, message: Message) -> Result<(), Error> {} - - pub(crate) async fn delete_message(&self, message: Uuid) -> Result<(), Error> { - sqlx::query!("delete from messages where id = ?", message) - .execute(&self.db) - .await?; - Ok(()) - } - - // TODO: paging - pub(crate) async fn read_message_history(&self, chat: JID) -> Result, Error> { - let chat_id = self.read_chat_id(chat).await?; - let messages: Vec = - sqlx::query_as("select * from messages where chat_id = ? order by timestamp asc") - .bind(chat_id) - .fetch_all(&self.db) - .await?; - Ok(messages) - } - - pub(crate) async fn read_cached_status(&self) -> Result { - let online: Online = sqlx::query_as("select * from cached_status where id = 0") - .fetch_one(&self.db) - .await?; - Ok(online) - } - - pub(crate) async fn upsert_cached_status(&self, status: Online) -> Result<(), Error> { - sqlx::query!( - "insert into cached_status (id, show, message) values (0, ?, ?) on conflict do update set show = ?, message = ?", - status.show, - status.status, - status.show, - status.status - ).execute(&self.db).await?; - Ok(()) - } - - pub(crate) async fn delete_cached_status(&self) -> Result<(), Error> { - sqlx::query!("update cached_status set show = null, message = null where id = 0") - .execute(&self.db) - .await?; - Ok(()) - } -} diff --git a/luz/src/error.rs b/luz/src/error.rs index 46f45a8..ec60778 100644 --- a/luz/src/error.rs +++ b/luz/src/error.rs @@ -1,214 +1,58 @@ +use std::str::Utf8Error; use std::sync::Arc; -use stanza::client::Stanza; +use jid::ParseError; +use rsasl::mechname::MechanismNameError; +use stanza::client::error::Error as ClientError; +use stanza::sasl::Failure; +use stanza::stream::Error as StreamError; use thiserror::Error; -use tokio::{ - sync::{mpsc::error::SendError, oneshot::error::RecvError}, - time::error::Elapsed, -}; -#[derive(Debug, Error, Clone)] -pub enum ConnectionError { - #[error("connection failed: {0}")] - ConnectionFailed(#[from] jabber::Error), - #[error("already connected")] - AlreadyConnected, - #[error("already disconnected")] - AlreadyDisconnected, - #[error("lost connection")] - LostConnection, - // TODO: Display for Content - #[error("disconnected")] - Disconnected, -} - -// for the client logic impl -#[derive(Debug, Error, Clone)] +#[derive(Error, Debug, Clone)] pub enum Error { - #[error("core error: {0}")] - Connection(#[from] ConnectionError), - #[error("received unrecognized/unsupported content: {0:?}")] - UnrecognizedContent(peanuts::element::Content), - #[error("iq receive error: {0}")] - Iq(IqError), - // TODO: change to Connecting(ConnectingError) - #[error("connecting: {0}")] - Connecting(#[from] ConnectionJobError), - #[error("presence: {0}")] - Presence(#[from] PresenceError), - #[error("set status: {0}")] - SetStatus(#[from] StatusError), - // TODO: have different ones for get/update/set - #[error("roster: {0}")] - Roster(RosterError), - #[error("stream error: {0}")] - Stream(#[from] stanza::stream::Error), - #[error("message send error: {0}")] - MessageSend(MessageSendError), - #[error("message receive error: {0}")] - MessageRecv(MessageRecvError), -} - -#[derive(Debug, Error, Clone)] -pub enum CommandError { - #[error("actor: {0}")] - Actor(ActorError), - #[error("{0}")] - Error(#[from] T), -} - -#[derive(Debug, Error, Clone)] -pub enum MessageSendError { - #[error("could not add to message history: {0}")] - MessageHistory(#[from] DatabaseError), -} - -#[derive(Debug, Error, Clone)] -pub enum PresenceError { - #[error("unsupported")] + #[error("connection")] + Connection, + #[error("utf8 decode: {0}")] + Utf8Decode(#[from] Utf8Error), + #[error("negotiation")] + Negotiation, + #[error("tls required")] + TlsRequired, + #[error("already connected with tls")] + AlreadyTls, + // TODO: specify unsupported feature + #[error("unsupported feature")] Unsupported, - #[error("missing from")] - MissingFrom, - #[error("stanza error: {0}")] - StanzaError(#[from] stanza::client::error::Error), -} - -#[derive(Debug, Error, Clone)] -// TODO: should probably have all iq query related errors here, including read, write, stanza error, etc. -pub enum IqError { - #[error("no iq with id matching `{0}`")] - NoMatchingId(String), -} - -#[derive(Debug, Error, Clone)] -pub enum MessageRecvError { - #[error("could not add to message history: {0}")] - MessageHistory(#[from] DatabaseError), - #[error("missing from")] - MissingFrom, -} - -#[derive(Debug, Clone, Error)] -pub enum ConnectionJobError { - #[error("connection failed: {0}")] - ConnectionFailed(#[from] jabber::Error), - #[error("failed roster retreival: {0}")] - RosterRetreival(#[from] RosterError), - #[error("failed to send available presence: {0}")] - SendPresence(#[from] WriteError), - #[error("cached status: {0}")] - StatusCacheError(#[from] DatabaseError), -} - -#[derive(Debug, Error, Clone)] -pub enum RosterError { - #[error("cache: {0}")] - Cache(#[from] DatabaseError), - #[error("stream write: {0}")] - Write(#[from] WriteError), - // TODO: display for stanza, to show as xml, same for read error types. - #[error("unexpected reply: {0:?}")] - UnexpectedStanza(Stanza), - #[error("stream read: {0}")] - Read(#[from] ReadError), - #[error("stanza error: {0}")] - StanzaError(#[from] stanza::client::error::Error), -} - -#[derive(Debug, Error, Clone)] -#[error("database error: {0}")] -pub struct DatabaseError(Arc); - -#[derive(Debug, Error, Clone)] -pub enum DatabaseOpenError { - #[error("error: {0}")] - Error(Arc), - #[error("migration: {0}")] - Migration(Arc), - #[error("io: {0}")] - Io(Arc), - #[error("invalid path")] - InvalidPath, -} - -impl From for DatabaseError { - fn from(e: sqlx::Error) -> Self { - Self(Arc::new(e)) - } -} - -impl From for DatabaseOpenError { - fn from(e: sqlx::Error) -> Self { - Self::Error(Arc::new(e)) - } -} - -impl From for DatabaseOpenError { - fn from(e: sqlx::migrate::MigrateError) -> Self { - Self::Migration(Arc::new(e)) - } -} - -impl From for DatabaseOpenError { - fn from(e: tokio::io::Error) -> Self { - Self::Io(Arc::new(e)) - } -} - -#[derive(Debug, Error, Clone)] -pub enum StatusError { - #[error("cache: {0}")] - Cache(#[from] DatabaseError), - #[error("stream write: {0}")] - Write(#[from] WriteError), -} - -#[derive(Debug, Error, Clone)] -pub enum WriteError { - #[error("xml: {0}")] - XML(#[from] peanuts::Error), - #[error("lost connection")] - LostConnection, - // TODO: should this be in writeerror or separate? - #[error("actor: {0}")] - Actor(#[from] ActorError), - #[error("disconnected")] - Disconnected, -} - -// TODO: separate peanuts read and write error? -#[derive(Debug, Error, Clone)] -pub enum ReadError { - #[error("xml: {0}")] + #[error("jid missing localpart")] + NoLocalpart, + #[error("received unexpected element: {0:?}")] + UnexpectedElement(peanuts::Element), + #[error("xml error: {0}")] XML(#[from] peanuts::Error), - #[error("lost connection")] - LostConnection, -} - -#[derive(Debug, Error, Clone)] -pub enum ActorError { - #[error("receive timed out")] - Timeout, - #[error("could not send message to actor, channel closed")] - Send, - #[error("could not receive message from actor, channel closed")] - Receive, -} - -impl From for ActorError { - fn from(_e: Elapsed) -> Self { - Self::Timeout - } + #[error("sasl error: {0}")] + SASL(#[from] SASLError), + #[error("jid error: {0}")] + JID(#[from] ParseError), + #[error("client stanza error: {0}")] + ClientError(#[from] ClientError), + #[error("stream error: {0}")] + StreamError(#[from] StreamError), + #[error("error missing")] + MissingError, } -impl From> for ActorError { - fn from(_e: SendError) -> Self { - Self::Send - } +#[derive(Error, Debug, Clone)] +pub enum SASLError { + #[error("sasl error: {0}")] + SASL(Arc), + #[error("mechanism error: {0}")] + MechanismName(#[from] MechanismNameError), + #[error("authentication failure: {0}")] + Authentication(#[from] Failure), } -impl From for ActorError { - fn from(_e: RecvError) -> Self { - Self::Receive +impl From for SASLError { + fn from(e: rsasl::prelude::SASLError) -> Self { + Self::SASL(Arc::new(e)) } } diff --git a/luz/src/jabber_stream.rs b/luz/src/jabber_stream.rs new file mode 100644 index 0000000..302350d --- /dev/null +++ b/luz/src/jabber_stream.rs @@ -0,0 +1,482 @@ +use std::str::{self, FromStr}; +use std::sync::Arc; + +use jid::JID; +use peanuts::element::IntoElement; +use peanuts::{Reader, Writer}; +use rsasl::prelude::{Mechname, SASLClient, SASLConfig}; +use stanza::bind::{Bind, BindType, FullJidType, ResourceType}; +use stanza::client::iq::{Iq, IqType, Query}; +use stanza::client::Stanza; +use stanza::sasl::{Auth, Challenge, Mechanisms, Response, ServerResponse}; +use stanza::starttls::{Proceed, StartTls}; +use stanza::stream::{Features, Stream}; +use stanza::XML_VERSION; +use tokio::io::{AsyncRead, AsyncWrite, ReadHalf, WriteHalf}; +use tokio_native_tls::native_tls::TlsConnector; +use tracing::{debug, instrument}; + +use crate::connection::{Tls, Unencrypted}; +use crate::error::Error; +use crate::Result; + +pub mod bound_stream; + +// open stream (streams started) +pub struct JabberStream { + reader: JabberReader, + writer: JabberWriter, +} + +impl JabberStream { + fn split(self) -> (JabberReader, JabberWriter) { + let reader = self.reader; + let writer = self.writer; + (reader, writer) + } +} + +pub struct JabberReader(Reader>); + +impl JabberReader { + // TODO: consider taking a readhalf and creating peanuts::Reader here, only one inner + fn new(reader: Reader>) -> Self { + Self(reader) + } + + fn unsplit(self, writer: JabberWriter) -> JabberStream { + JabberStream { + reader: self, + writer, + } + } + + fn into_inner(self) -> Reader> { + self.0 + } +} + +impl JabberReader +where + S: AsyncRead + Unpin, +{ + pub async fn try_close(&mut self) -> Result<()> { + self.read_end_tag().await?; + Ok(()) + } +} + +impl std::ops::Deref for JabberReader { + type Target = Reader>; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl std::ops::DerefMut for JabberReader { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +pub struct JabberWriter(Writer>); + +impl JabberWriter { + fn new(writer: Writer>) -> Self { + Self(writer) + } + + fn unsplit(self, reader: JabberReader) -> JabberStream { + JabberStream { + reader, + writer: self, + } + } + + fn into_inner(self) -> Writer> { + self.0 + } +} + +impl JabberWriter +where + S: AsyncWrite + Unpin + Send, +{ + pub async fn try_close(&mut self) -> Result<()> { + self.write_end().await?; + Ok(()) + } +} + +impl std::ops::Deref for JabberWriter { + type Target = Writer>; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl std::ops::DerefMut for JabberWriter { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl JabberStream +where + S: AsyncRead + AsyncWrite + Unpin + Send + std::fmt::Debug, + JabberStream: std::fmt::Debug, +{ + #[instrument] + pub async fn sasl(mut self, mechanisms: Mechanisms, sasl_config: Arc) -> Result { + let sasl = SASLClient::new(sasl_config); + let mut offered_mechs: Vec<&Mechname> = Vec::new(); + for mechanism in &mechanisms.mechanisms { + offered_mechs + .push(Mechname::parse(mechanism.as_bytes()).map_err(|e| Error::SASL(e.into()))?) + } + debug!("{:?}", offered_mechs); + let mut session = sasl + .start_suggested(&offered_mechs) + .map_err(|e| Error::SASL(e.into()))?; + let selected_mechanism = session.get_mechname().as_str().to_owned(); + debug!("selected mech: {:?}", selected_mechanism); + let mut data: Option>; + + if !session.are_we_first() { + // if not first mention the mechanism then get challenge data + // mention mechanism + let auth = Auth { + mechanism: selected_mechanism, + sasl_data: "=".to_string(), + }; + self.writer.write_full(&auth).await?; + // get challenge data + let challenge: Challenge = self.reader.read().await?; + debug!("challenge: {:?}", challenge); + data = Some((*challenge).as_bytes().to_vec()); + debug!("we didn't go first"); + } else { + // if first, mention mechanism and send data + let mut sasl_data = Vec::new(); + session.step64(None, &mut sasl_data).unwrap(); + let auth = Auth { + mechanism: selected_mechanism, + sasl_data: str::from_utf8(&sasl_data)?.to_string(), + }; + debug!("{:?}", auth); + self.writer.write_full(&auth).await?; + + let server_response: ServerResponse = self.reader.read().await?; + debug!("server_response: {:#?}", server_response); + match server_response { + ServerResponse::Challenge(challenge) => { + data = Some((*challenge).as_bytes().to_vec()) + } + ServerResponse::Success(success) => { + data = success.clone().map(|success| success.as_bytes().to_vec()) + } + ServerResponse::Failure(failure) => return Err(Error::SASL(failure.into())), + } + debug!("we went first"); + } + + // stepping the authentication exchange to completion + if data != None { + debug!("data: {:?}", data); + let mut sasl_data = Vec::new(); + while { + // decide if need to send more data over + let state = session + .step64(data.as_deref(), &mut sasl_data) + .expect("step errored!"); + state.is_running() + } { + // While we aren't finished, receive more data from the other party + let response = Response::new(str::from_utf8(&sasl_data)?.to_string()); + debug!("response: {:?}", response); + self.writer.write_full(&response).await?; + debug!("response written"); + + let server_response: ServerResponse = self.reader.read().await?; + debug!("server_response: {:#?}", server_response); + match server_response { + ServerResponse::Challenge(challenge) => { + data = Some((*challenge).as_bytes().to_vec()) + } + ServerResponse::Success(success) => { + data = success.clone().map(|success| success.as_bytes().to_vec()) + } + ServerResponse::Failure(failure) => return Err(Error::SASL(failure.into())), + } + } + } + let writer = self.writer.into_inner().into_inner(); + let reader = self.reader.into_inner().into_inner(); + let stream = reader.unsplit(writer); + Ok(stream) + } + + #[instrument] + pub async fn bind(mut self, jid: &mut JID) -> Result { + let iq_id = nanoid::nanoid!(); + if let Some(resource) = &jid.resourcepart { + let iq = Iq { + from: None, + id: iq_id.clone(), + to: None, + r#type: IqType::Set, + lang: None, + query: Some(Query::Bind(Bind { + r#type: Some(BindType::Resource(ResourceType(resource.to_string()))), + })), + errors: Vec::new(), + }; + self.writer.write_full(&iq).await?; + let result: Iq = self.reader.read().await?; + match result { + Iq { + from: _, + id, + to: _, + r#type: IqType::Result, + lang: _, + query: + Some(Query::Bind(Bind { + r#type: Some(BindType::Jid(FullJidType(new_jid))), + })), + errors: _, + } if id == iq_id => { + *jid = new_jid; + return Ok(self); + } + Iq { + from: _, + id, + to: _, + r#type: IqType::Error, + lang: _, + query: None, + errors, + } if id == iq_id => { + return Err(Error::ClientError( + errors.first().ok_or(Error::MissingError)?.clone(), + )) + } + _ => return Err(Error::UnexpectedElement(result.into_element())), + } + } else { + let iq = Iq { + from: None, + id: iq_id.clone(), + to: None, + r#type: IqType::Set, + lang: None, + query: Some(Query::Bind(Bind { r#type: None })), + errors: Vec::new(), + }; + self.writer.write_full(&iq).await?; + let result: Iq = self.reader.read().await?; + match result { + Iq { + from: _, + id, + to: _, + r#type: IqType::Result, + lang: _, + query: + Some(Query::Bind(Bind { + r#type: Some(BindType::Jid(FullJidType(new_jid))), + })), + errors: _, + } if id == iq_id => { + *jid = new_jid; + return Ok(self); + } + Iq { + from: _, + id, + to: _, + r#type: IqType::Error, + lang: _, + query: None, + errors, + } if id == iq_id => { + return Err(Error::ClientError( + errors.first().ok_or(Error::MissingError)?.clone(), + )) + } + _ => return Err(Error::UnexpectedElement(result.into_element())), + } + } + } + + #[instrument] + pub async fn start_stream(connection: S, server: &mut String) -> Result { + // client to server + let (reader, writer) = tokio::io::split(connection); + let mut reader = JabberReader::new(Reader::new(reader)); + let mut writer = JabberWriter::new(Writer::new(writer)); + + // declaration + writer.write_declaration(XML_VERSION).await?; + + // opening stream element + let stream = Stream::new_client( + None, + JID::from_str(server.as_ref())?, + None, + "en".to_string(), + ); + writer.write_start(&stream).await?; + + // server to client + + // may or may not send a declaration + let _decl = reader.read_prolog().await?; + + // receive stream element and validate + let stream: Stream = reader.read_start().await?; + debug!("got stream: {:?}", stream); + if let Some(from) = stream.from { + *server = from.to_string(); + } + + Ok(Self { reader, writer }) + } + + #[instrument] + pub async fn get_features(mut self) -> Result<(Features, Self)> { + debug!("getting features"); + let features: Features = self.reader.read().await?; + debug!("got features: {:?}", features); + Ok((features, self)) + } + + pub fn into_inner(self) -> S { + self.reader + .into_inner() + .into_inner() + .unsplit(self.writer.into_inner().into_inner()) + } + + pub async fn send_stanza(&mut self, stanza: &Stanza) -> Result<()> { + self.writer.write(stanza).await?; + Ok(()) + } +} + +impl JabberStream { + #[instrument] + pub async fn starttls(mut self, domain: impl AsRef + std::fmt::Debug) -> Result { + self.writer + .write_full(&StartTls { required: false }) + .await?; + let proceed: Proceed = self.reader.read().await?; + debug!("got proceed: {:?}", proceed); + let connector = TlsConnector::new().unwrap(); + let stream = self + .reader + .into_inner() + .into_inner() + .unsplit(self.writer.into_inner().into_inner()); + if let Ok(tls_stream) = tokio_native_tls::TlsConnector::from(connector) + .connect(domain.as_ref(), stream) + .await + { + return Ok(tls_stream); + } else { + return Err(Error::Connection); + } + } +} + +impl std::fmt::Debug for JabberStream { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Jabber") + .field("connection", &"tls") + .finish() + } +} + +impl std::fmt::Debug for JabberStream { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Jabber") + .field("connection", &"unencrypted") + .finish() + } +} + +#[cfg(test)] +mod tests { + use test_log::test; + + #[test(tokio::test)] + async fn start_stream() { + // let connection = Connection::connect("blos.sm", None, None).await.unwrap(); + // match connection { + // Connection::Encrypted(mut c) => c.start_stream().await.unwrap(), + // Connection::Unencrypted(mut c) => c.start_stream().await.unwrap(), + // } + } + + #[test(tokio::test)] + async fn sasl() { + // let mut jabber = Connection::connect_user("test@blos.sm", "slayed".to_string()) + // .await + // .unwrap() + // .ensure_tls() + // .await + // .unwrap(); + // let text = str::from_utf8(jabber.reader.buffer.data()).unwrap(); + // println!("data: {}", text); + // jabber.start_stream().await.unwrap(); + + // let text = str::from_utf8(jabber.reader.buffer.data()).unwrap(); + // println!("data: {}", text); + // jabber.reader.read_buf().await.unwrap(); + // let text = str::from_utf8(jabber.reader.buffer.data()).unwrap(); + // println!("data: {}", text); + + // let features = jabber.get_features().await.unwrap(); + // let (sasl_config, feature) = ( + // jabber.auth.clone().unwrap(), + // features + // .features + // .iter() + // .find(|feature| matches!(feature, Feature::Sasl(_))) + // .unwrap(), + // ); + // match feature { + // Feature::StartTls(_start_tls) => todo!(), + // Feature::Sasl(mechanisms) => { + // jabber.sasl(mechanisms.clone(), sasl_config).await.unwrap(); + // } + // Feature::Bind => todo!(), + // Feature::Unknown => todo!(), + // } + } + + #[tokio::test] + async fn sink() { + // let mut client = JabberClient::new("test@blos.sm", "slayed").unwrap(); + // client.connect().await.unwrap(); + // let stream = client.inner().unwrap(); + // let sink = sink::unfold(stream, |mut stream, stanza: Stanza| async move { + // stream.writer.write(&stanza).await?; + // Ok::, Error>(stream) + // }); + // todo!() + // let _jabber = Connection::connect_user("test@blos.sm", "slayed".to_string()) + // .await + // .unwrap() + // .ensure_tls() + // .await + // .unwrap() + // .negotiate() + // .await + // .unwrap(); + // sleep(Duration::from_secs(5)).await + } +} diff --git a/luz/src/jabber_stream/bound_stream.rs b/luz/src/jabber_stream/bound_stream.rs new file mode 100644 index 0000000..25b79ff --- /dev/null +++ b/luz/src/jabber_stream/bound_stream.rs @@ -0,0 +1,87 @@ +use std::ops::{Deref, DerefMut}; + +use tokio::io::{AsyncRead, AsyncWrite}; + +use super::{JabberReader, JabberStream, JabberWriter}; + +pub struct BoundJabberStream(JabberStream); + +impl Deref for BoundJabberStream +where + S: AsyncWrite + AsyncRead + Unpin + Send, +{ + type Target = JabberStream; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for BoundJabberStream +where + S: AsyncWrite + AsyncRead + Unpin + Send, +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl BoundJabberStream { + pub fn split(self) -> (BoundJabberReader, BoundJabberWriter) { + let (reader, writer) = self.0.split(); + (BoundJabberReader(reader), BoundJabberWriter(writer)) + } +} + +pub struct BoundJabberReader(JabberReader); + +impl BoundJabberReader { + pub fn unsplit(self, writer: BoundJabberWriter) -> BoundJabberStream { + BoundJabberStream(self.0.unsplit(writer.0)) + } +} + +impl std::ops::Deref for BoundJabberReader { + type Target = JabberReader; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl std::ops::DerefMut for BoundJabberReader { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +pub struct BoundJabberWriter(JabberWriter); + +impl BoundJabberWriter { + pub fn unsplit(self, reader: BoundJabberReader) -> BoundJabberStream { + BoundJabberStream(self.0.unsplit(reader.0)) + } +} + +impl std::ops::Deref for BoundJabberWriter { + type Target = JabberWriter; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl std::ops::DerefMut for BoundJabberWriter { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl JabberStream +where + S: AsyncWrite + AsyncRead + Unpin + Send, +{ + pub fn to_bound_jabber(self) -> BoundJabberStream { + BoundJabberStream(self) + } +} diff --git a/luz/src/lib.rs b/luz/src/lib.rs index b9c482c..8855ca7 100644 --- a/luz/src/lib.rs +++ b/luz/src/lib.rs @@ -1,1774 +1,25 @@ -use std::{ - collections::HashMap, - ops::{Deref, DerefMut}, - str::FromStr, - sync::Arc, - time::Duration, -}; +#![allow(unused_must_use)] +// #![feature(let_chains)] -use chat::{Body, Chat, Message}; -use chrono::Utc; -use connection::{write::WriteMessage, SupervisorSender}; -use db::Db; -use error::{ - ActorError, CommandError, ConnectionError, ConnectionJobError, DatabaseError, IqError, - MessageRecvError, PresenceError, ReadError, RosterError, StatusError, WriteError, -}; -use futures::{future::Fuse, FutureExt}; -use jabber::JID; -use presence::{Offline, Online, Presence, PresenceType, Show}; -use roster::{Contact, ContactUpdate}; -use sqlx::SqlitePool; -use stanza::client::{ - iq::{self, Iq, IqType}, - Stanza, -}; -use tokio::{ - sync::{mpsc, oneshot, Mutex}, - task::JoinSet, - time::timeout, -}; -use tracing::{debug, info}; -use user::User; -use uuid::Uuid; - -use crate::connection::write::WriteHandle; -use crate::connection::{SupervisorCommand, SupervisorHandle}; -use crate::error::Error; - -pub mod chat; -mod connection; -pub mod db; +// TODO: logging (dropped errors) +pub mod client; +pub mod connection; pub mod error; -pub mod presence; -pub mod roster; -pub mod user; - -pub enum Command { - /// get the roster. if offline, retreive cached version from database. should be stored in application memory - GetRoster(oneshot::Sender, RosterError>>), - /// get all chats. chat will include 10 messages in their message Vec (enough for chat previews) - // TODO: paging and filtering - GetChats(oneshot::Sender, DatabaseError>>), - // TODO: paging and filtering - GetChatsOrdered(oneshot::Sender, DatabaseError>>), - // TODO: paging and filtering - GetChatsOrderedWithLatestMessages(oneshot::Sender, DatabaseError>>), - /// get a specific chat by jid - GetChat(JID, oneshot::Sender>), - /// get message history for chat (does appropriate mam things) - // TODO: paging and filtering - GetMessages(JID, oneshot::Sender, DatabaseError>>), - /// delete a chat from your chat history, along with all the corresponding messages - DeleteChat(JID, oneshot::Sender>), - /// delete a message from your chat history - DeleteMessage(Uuid, oneshot::Sender>), - /// get a user from your users database - GetUser(JID, oneshot::Sender>), - /// add a contact to your roster, with a status of none, no subscriptions. - AddContact(JID, oneshot::Sender>), - /// send a friend request i.e. a subscription request with a subscription pre-approval. if not already added to roster server adds to roster. - BuddyRequest(JID, oneshot::Sender>), - /// send a subscription request, without pre-approval. if not already added to roster server adds to roster. - SubscriptionRequest(JID, oneshot::Sender>), - /// accept a friend request by accepting a pending subscription and sending a subscription request back. if not already added to roster adds to roster. - AcceptBuddyRequest(JID, oneshot::Sender>), - /// accept a pending subscription and doesn't send a subscription request back. if not already added to roster adds to roster. - AcceptSubscriptionRequest(JID, oneshot::Sender>), - /// unsubscribe to a contact, but don't remove their subscription. - UnsubscribeFromContact(JID, oneshot::Sender>), - /// stop a contact from being subscribed, but stay subscribed to the contact. - UnsubscribeContact(JID, oneshot::Sender>), - /// remove subscriptions to and from contact, but keep in roster. - UnfriendContact(JID, oneshot::Sender>), - /// remove a contact from the contact list. will remove subscriptions if not already done then delete contact from roster. - DeleteContact(JID, oneshot::Sender>), - /// update contact. contact details will be overwritten with the contents of the contactupdate struct. - UpdateContact(JID, ContactUpdate, oneshot::Sender>), - /// set online status. if disconnected, will be cached so when client connects, will be sent as the initial presence. - SetStatus(Online, oneshot::Sender>), - /// send presence stanza - // TODO: cache presence stanza - SendPresence( - Option, - PresenceType, - oneshot::Sender>, - ), - /// send a directed presence (usually to a non-contact). - // TODO: should probably make it so people can add non-contact auto presence sharing in the client (most likely through setting an internal setting) - /// send a message to a jid (any kind of jid that can receive a message, e.g. a user or a - /// chatroom). if disconnected, will be cached so when client connects, message will be sent. - SendMessage(JID, Body, oneshot::Sender>), -} - -#[derive(Debug)] -pub struct Client { - sender: mpsc::Sender>, - timeout: Duration, -} - -impl Clone for Client { - fn clone(&self) -> Self { - Self { - sender: self.sender.clone(), - timeout: self.timeout, - } - } -} - -impl Deref for Client { - type Target = mpsc::Sender>; - - fn deref(&self) -> &Self::Target { - &self.sender - } -} - -impl DerefMut for Client { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.sender - } -} - -impl Client { - pub async fn connect(&self) -> Result<(), ActorError> { - self.send(LuzMessage::Connect).await?; - Ok(()) - } - - pub async fn disconnect(&self, offline: Offline) -> Result<(), ActorError> { - self.send(LuzMessage::Disconnect).await?; - Ok(()) - } - - pub fn new(jid: JID, password: String, db: Db) -> (Self, mpsc::Receiver) { - let (command_sender, command_receiver) = mpsc::channel(20); - let (update_send, update_recv) = mpsc::channel(20); - - // might be bad, first supervisor shutdown notification oneshot is never used (disgusting) - let (_sup_send, sup_recv) = oneshot::channel(); - let sup_recv = sup_recv.fuse(); - - let logic = LogicState { - db, - pending: Arc::new(Mutex::new(HashMap::new())), - update_sender: update_send, - }; - - let actor: Luz = - Luz::new(jid, password, command_receiver, None, sup_recv, logic); - tokio::spawn(async move { actor.run().await }); - - ( - Self { - sender: command_sender, - // TODO: configure timeout - timeout: Duration::from_secs(10), - }, - update_recv, - ) - } - - pub async fn get_roster(&self) -> Result, CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::GetRoster(send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let roster = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(roster) - } - - pub async fn get_chats(&self) -> Result, CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::GetChats(send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let chats = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(chats) - } - - pub async fn get_chats_ordered(&self) -> Result, CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::GetChatsOrdered(send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let chats = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(chats) - } - - pub async fn get_chats_ordered_with_latest_messages( - &self, - ) -> Result, CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command( - Command::GetChatsOrderedWithLatestMessages(send), - )) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let chats = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(chats) - } - - pub async fn get_chat(&self, jid: JID) -> Result> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::GetChat(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let chat = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(chat) - } - - pub async fn get_messages( - &self, - jid: JID, - ) -> Result, CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::GetMessages(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let messages = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(messages) - } - - pub async fn delete_chat(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::DeleteChat(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn delete_message(&self, id: Uuid) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::DeleteMessage(id, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn get_user(&self, jid: JID) -> Result> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::GetUser(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn add_contact(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::AddContact(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn buddy_request(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::BuddyRequest(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn subscription_request(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::SubscriptionRequest(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn accept_buddy_request(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::AcceptBuddyRequest(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } +pub mod jabber_stream; - pub async fn accept_subscription_request( - &self, - jid: JID, - ) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::AcceptSubscriptionRequest( - jid, send, - ))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } +pub use connection::Connection; +pub use error::Error; +pub use jabber_stream::JabberStream; +pub use jid::JID; - pub async fn unsubscribe_from_contact(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::UnsubscribeFromContact( - jid, send, - ))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } +pub type Result = std::result::Result; - pub async fn unsubscribe_contact(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::UnsubscribeContact(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn unfriend_contact(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::UnfriendContact(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn delete_contact(&self, jid: JID) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::DeleteContact(jid, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn update_contact( - &self, - jid: JID, - update: ContactUpdate, - ) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::UpdateContact( - jid, update, send, - ))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn set_status(&self, online: Online) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::SetStatus(online, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } - - pub async fn send_message(&self, jid: JID, body: Body) -> Result<(), CommandError> { - let (send, recv) = oneshot::channel(); - self.send(LuzMessage::Command(Command::SendMessage(jid, body, send))) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))?; - let result = timeout(self.timeout, recv) - .await - .map_err(|e| CommandError::Actor(Into::::into(e)))? - .map_err(|e| CommandError::Actor(Into::::into(e)))??; - Ok(result) - } -} - -#[derive(Clone)] -pub struct LogicState { - db: Db, - pending: Arc>>>>, - update_sender: mpsc::Sender, -} - -impl Logic for LogicState { - type Cmd = Command; - - async fn handle_connect(self, connection: Connected) { - let (send, recv) = oneshot::channel(); - debug!("getting roster"); - self.clone() - .handle_online(Command::GetRoster(send), connection.clone()) - .await; - debug!("sent roster req"); - let roster = recv.await; - debug!("got roster"); - match roster { - Ok(r) => match r { - Ok(roster) => { - let online = self.db.read_cached_status().await; - let online = match online { - Ok(online) => online, - Err(e) => { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Connecting( - ConnectionJobError::StatusCacheError(e.into()), - ))) - .await; - Online::default() - } - }; - let (send, recv) = oneshot::channel(); - self.clone() - .handle_online( - Command::SendPresence(None, PresenceType::Online(online.clone()), send), - connection, - ) - .await; - let set_status = recv.await; - match set_status { - Ok(s) => match s { - Ok(()) => { - let _ = self - .update_sender - .send(UpdateMessage::Online(online, roster)) - .await; - } - Err(e) => { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Connecting(e.into()))) - .await; - } - }, - Err(e) => { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Connecting( - ConnectionJobError::SendPresence(WriteError::Actor(e.into())), - ))) - .await; - } - } - } - Err(e) => { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Connecting(e.into()))) - .await; - } - }, - Err(e) => { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Connecting( - ConnectionJobError::RosterRetreival(RosterError::Write(WriteError::Actor( - e.into(), - ))), - ))) - .await; - } - } - } - - async fn handle_disconnect(self, connection: Connected) { - // TODO: be able to set offline status message - let offline_presence: stanza::client::presence::Presence = - Offline::default().into_stanza(None); - let stanza = Stanza::Presence(offline_presence); - // TODO: timeout and error check - connection.write_handle.write(stanza).await; - let _ = self - .update_sender - .send(UpdateMessage::Offline(Offline::default())) - .await; - } - - async fn handle_stanza( - self, - stanza: Stanza, - connection: Connected, - supervisor: SupervisorSender, - ) { - match stanza { - Stanza::Message(stanza_message) => { - if let Some(mut from) = stanza_message.from { - // TODO: don't ignore delay from. xep says SHOULD send error if incorrect. - let timestamp = stanza_message - .delay - .map(|delay| delay.stamp) - .unwrap_or_else(|| Utc::now()); - // TODO: group chat messages - let mut message = Message { - id: stanza_message - .id - // TODO: proper id storage - .map(|id| Uuid::from_str(&id).unwrap_or_else(|_| Uuid::new_v4())) - .unwrap_or_else(|| Uuid::new_v4()), - from: from.clone(), - timestamp, - body: Body { - // TODO: should this be an option? - body: stanza_message - .body - .map(|body| body.body) - .unwrap_or_default() - .unwrap_or_default(), - }, - }; - // TODO: can this be more efficient? - let result = self - .db - .create_message_with_user_resource_and_chat(message.clone(), from.clone()) - .await; - if let Err(e) = result { - tracing::error!("messagecreate"); - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::MessageRecv( - MessageRecvError::MessageHistory(e.into()), - ))) - .await; - } - message.from = message.from.as_bare(); - from = from.as_bare(); - let _ = self - .update_sender - .send(UpdateMessage::Message { to: from, message }) - .await; - } else { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::MessageRecv( - MessageRecvError::MissingFrom, - ))) - .await; - } - } - Stanza::Presence(presence) => { - if let Some(from) = presence.from { - match presence.r#type { - Some(r#type) => match r#type { - // error processing a presence from somebody - stanza::client::presence::PresenceType::Error => { - // TODO: is there any other information that should go with the error? also MUST have an error, otherwise it's a different error. maybe it shoulnd't be an option. - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Presence( - // TODO: ughhhhhhhhhhhhh these stanza errors should probably just have an option, and custom display - PresenceError::StanzaError( - presence - .errors - .first() - .cloned() - .expect("error MUST have error"), - ), - ))) - .await; - } - // should not happen (error to server) - stanza::client::presence::PresenceType::Probe => { - // TODO: should probably write an error and restart stream - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Presence( - PresenceError::Unsupported, - ))) - .await; - } - stanza::client::presence::PresenceType::Subscribe => { - // may get a subscription request from somebody who is not a contact!!! therefore should be its own kind of event - let _ = self - .update_sender - .send(UpdateMessage::SubscriptionRequest(from)) - .await; - } - stanza::client::presence::PresenceType::Unavailable => { - let offline = Offline { - status: presence.status.map(|status| status.status.0), - }; - let timestamp = presence - .delay - .map(|delay| delay.stamp) - .unwrap_or_else(|| Utc::now()); - let _ = self - .update_sender - .send(UpdateMessage::Presence { - from, - presence: Presence { - timestamp, - presence: PresenceType::Offline(offline), - }, - }) - .await; - } - // for now, do nothing, as these are simply informational. will receive roster push from the server regarding the changes to do with them. - stanza::client::presence::PresenceType::Subscribed => {} - stanza::client::presence::PresenceType::Unsubscribe => {} - stanza::client::presence::PresenceType::Unsubscribed => {} - }, - None => { - let online = Online { - show: presence.show.map(|show| match show { - stanza::client::presence::Show::Away => Show::Away, - stanza::client::presence::Show::Chat => Show::Chat, - stanza::client::presence::Show::Dnd => Show::DoNotDisturb, - stanza::client::presence::Show::Xa => Show::ExtendedAway, - }), - status: presence.status.map(|status| status.status.0), - priority: presence.priority.map(|priority| priority.0), - }; - let timestamp = presence - .delay - .map(|delay| delay.stamp) - .unwrap_or_else(|| Utc::now()); - let _ = self - .update_sender - .send(UpdateMessage::Presence { - from, - presence: Presence { - timestamp, - presence: PresenceType::Online(online), - }, - }) - .await; - } - } - } else { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Presence( - PresenceError::MissingFrom, - ))) - .await; - } - } - Stanza::Iq(iq) => match iq.r#type { - stanza::client::iq::IqType::Error | stanza::client::iq::IqType::Result => { - let send; - { - send = self.pending.lock().await.remove(&iq.id); - } - if let Some(send) = send { - send.send(Ok(Stanza::Iq(iq))); - } else { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Iq(IqError::NoMatchingId( - iq.id, - )))) - .await; - } - } - // TODO: send unsupported to server - // TODO: proper errors i am so tired please - stanza::client::iq::IqType::Get => {} - stanza::client::iq::IqType::Set => { - if let Some(query) = iq.query { - match query { - stanza::client::iq::Query::Roster(mut query) => { - // TODO: there should only be one - if let Some(item) = query.items.pop() { - match item.subscription { - Some(stanza::roster::Subscription::Remove) => { - self.db.delete_contact(item.jid.clone()).await; - self.update_sender - .send(UpdateMessage::RosterDelete(item.jid)) - .await; - // TODO: send result - } - _ => { - let contact: Contact = item.into(); - if let Err(e) = - self.db.upsert_contact(contact.clone()).await - { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Roster( - RosterError::Cache(e.into()), - ))) - .await; - } - let _ = self - .update_sender - .send(UpdateMessage::RosterUpdate(contact)) - .await; - // TODO: send result - // write_handle.write(Stanza::Iq(stanza::client::iq::Iq { - // from: , - // id: todo!(), - // to: todo!(), - // r#type: todo!(), - // lang: todo!(), - // query: todo!(), - // errors: todo!(), - // })); - } - } - } - } - // TODO: send unsupported to server - _ => {} - } - } else { - // TODO: send error (unsupported) to server - } - } - }, - Stanza::Error(error) => { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::Stream(error))) - .await; - // TODO: reconnect - } - Stanza::OtherContent(content) => { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::UnrecognizedContent(content))); - // TODO: send error to write_thread - } - } - } - - async fn handle_online(self, command: Command, connection: Connected) { - match command { - Command::GetRoster(result_sender) => { - // TODO: jid resource should probably be stored within the connection - debug!("before client_jid lock"); - debug!("after client_jid lock"); - let iq_id = Uuid::new_v4().to_string(); - let (send, iq_recv) = oneshot::channel(); - { - self.pending.lock().await.insert(iq_id.clone(), send); - } - let stanza = Stanza::Iq(Iq { - from: Some(connection.jid), - id: iq_id.to_string(), - to: None, - r#type: IqType::Get, - lang: None, - query: Some(iq::Query::Roster(stanza::roster::Query { - ver: None, - items: Vec::new(), - })), - errors: Vec::new(), - }); - let (send, recv) = oneshot::channel(); - let _ = connection - .write_handle - .send(WriteMessage { - stanza, - respond_to: send, - }) - .await; - // TODO: timeout - match recv.await { - Ok(Ok(())) => info!("roster request sent"), - Ok(Err(e)) => { - // TODO: log errors if fail to send - let _ = result_sender.send(Err(RosterError::Write(e.into()))); - return; - } - Err(e) => { - let _ = result_sender - .send(Err(RosterError::Write(WriteError::Actor(e.into())))); - return; - } - }; - // TODO: timeout - match iq_recv.await { - Ok(Ok(stanza)) => match stanza { - Stanza::Iq(Iq { - from: _, - id, - to: _, - r#type, - lang: _, - query: Some(iq::Query::Roster(stanza::roster::Query { ver: _, items })), - errors: _, - }) if id == iq_id && r#type == IqType::Result => { - let contacts: Vec = - items.into_iter().map(|item| item.into()).collect(); - if let Err(e) = self.db.replace_cached_roster(contacts.clone()).await { - self.update_sender - .send(UpdateMessage::Error(Error::Roster(RosterError::Cache( - e.into(), - )))) - .await; - }; - result_sender.send(Ok(contacts)); - return; - } - ref s @ Stanza::Iq(Iq { - from: _, - ref id, - to: _, - r#type, - lang: _, - query: _, - ref errors, - }) if *id == iq_id && r#type == IqType::Error => { - if let Some(error) = errors.first() { - result_sender.send(Err(RosterError::StanzaError(error.clone()))); - } else { - result_sender.send(Err(RosterError::UnexpectedStanza(s.clone()))); - } - return; - } - s => { - result_sender.send(Err(RosterError::UnexpectedStanza(s))); - return; - } - }, - Ok(Err(e)) => { - result_sender.send(Err(RosterError::Read(e))); - return; - } - Err(e) => { - result_sender.send(Err(RosterError::Write(WriteError::Actor(e.into())))); - return; - } - } - } - Command::GetChats(sender) => { - let chats = self.db.read_chats().await.map_err(|e| e.into()); - sender.send(chats); - } - Command::GetChatsOrdered(sender) => { - let chats = self.db.read_chats_ordered().await.map_err(|e| e.into()); - sender.send(chats); - } - Command::GetChatsOrderedWithLatestMessages(sender) => { - let chats = self - .db - .read_chats_ordered_with_latest_messages() - .await - .map_err(|e| e.into()); - sender.send(chats); - } - Command::GetChat(jid, sender) => { - let chats = self.db.read_chat(jid).await.map_err(|e| e.into()); - sender.send(chats); - } - Command::GetMessages(jid, sender) => { - let messages = self - .db - .read_message_history(jid) - .await - .map_err(|e| e.into()); - sender.send(messages); - } - Command::DeleteChat(jid, sender) => { - let result = self.db.delete_chat(jid).await.map_err(|e| e.into()); - sender.send(result); - } - Command::DeleteMessage(uuid, sender) => { - let result = self.db.delete_message(uuid).await.map_err(|e| e.into()); - sender.send(result); - } - Command::GetUser(jid, sender) => { - let user = self.db.read_user(jid).await.map_err(|e| e.into()); - sender.send(user); - } - // TODO: offline queue to modify roster - Command::AddContact(jid, sender) => { - let iq_id = Uuid::new_v4().to_string(); - let set_stanza = Stanza::Iq(Iq { - from: Some(connection.jid), - id: iq_id.clone(), - to: None, - r#type: IqType::Set, - lang: None, - query: Some(iq::Query::Roster(stanza::roster::Query { - ver: None, - items: vec![stanza::roster::Item { - approved: None, - ask: false, - jid, - name: None, - subscription: None, - groups: Vec::new(), - }], - })), - errors: Vec::new(), - }); - let (send, recv) = oneshot::channel(); - { - self.pending.lock().await.insert(iq_id.clone(), send); - } - // TODO: write_handle send helper function - let result = connection.write_handle.write(set_stanza).await; - if let Err(e) = result { - sender.send(Err(RosterError::Write(e))); - return; - } - let iq_result = recv.await; - match iq_result { - Ok(i) => match i { - Ok(iq_result) => match iq_result { - Stanza::Iq(Iq { - from: _, - id, - to: _, - r#type, - lang: _, - query: _, - errors: _, - }) if id == iq_id && r#type == IqType::Result => { - sender.send(Ok(())); - return; - } - ref s @ Stanza::Iq(Iq { - from: _, - ref id, - to: _, - r#type, - lang: _, - query: _, - ref errors, - }) if *id == iq_id && r#type == IqType::Error => { - if let Some(error) = errors.first() { - sender.send(Err(RosterError::StanzaError(error.clone()))); - } else { - sender.send(Err(RosterError::UnexpectedStanza(s.clone()))); - } - return; - } - s => { - sender.send(Err(RosterError::UnexpectedStanza(s))); - return; - } - }, - Err(e) => { - sender.send(Err(e.into())); - return; - } - }, - Err(e) => { - sender.send(Err(RosterError::Write(WriteError::Actor(e.into())))); - return; - } - } - } - Command::BuddyRequest(jid, sender) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid.clone()), - r#type: Some(stanza::client::presence::PresenceType::Subscribe), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - match result { - Err(_) => { - let _ = sender.send(result); - } - Ok(()) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid), - r#type: Some(stanza::client::presence::PresenceType::Subscribed), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - let _ = sender.send(result); - } - } - } - Command::SubscriptionRequest(jid, sender) => { - // TODO: i should probably have builders - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid), - r#type: Some(stanza::client::presence::PresenceType::Subscribe), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - let _ = sender.send(result); - } - Command::AcceptBuddyRequest(jid, sender) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid.clone()), - r#type: Some(stanza::client::presence::PresenceType::Subscribed), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - match result { - Err(_) => { - let _ = sender.send(result); - } - Ok(()) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid), - r#type: Some(stanza::client::presence::PresenceType::Subscribe), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - let _ = sender.send(result); - } - } - } - Command::AcceptSubscriptionRequest(jid, sender) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid), - r#type: Some(stanza::client::presence::PresenceType::Subscribe), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - let _ = sender.send(result); - } - Command::UnsubscribeFromContact(jid, sender) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid), - r#type: Some(stanza::client::presence::PresenceType::Unsubscribe), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - let _ = sender.send(result); - } - Command::UnsubscribeContact(jid, sender) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid), - r#type: Some(stanza::client::presence::PresenceType::Unsubscribed), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - let _ = sender.send(result); - } - Command::UnfriendContact(jid, sender) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid.clone()), - r#type: Some(stanza::client::presence::PresenceType::Unsubscribe), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - match result { - Err(_) => { - let _ = sender.send(result); - } - Ok(()) => { - let presence = Stanza::Presence(stanza::client::presence::Presence { - from: None, - id: None, - to: Some(jid), - r#type: Some(stanza::client::presence::PresenceType::Unsubscribed), - lang: None, - show: None, - status: None, - priority: None, - errors: Vec::new(), - delay: None, - }); - let result = connection.write_handle.write(presence).await; - let _ = sender.send(result); - } - } - } - Command::DeleteContact(jid, sender) => { - let iq_id = Uuid::new_v4().to_string(); - let set_stanza = Stanza::Iq(Iq { - from: Some(connection.jid), - id: iq_id.clone(), - to: None, - r#type: IqType::Set, - lang: None, - query: Some(iq::Query::Roster(stanza::roster::Query { - ver: None, - items: vec![stanza::roster::Item { - approved: None, - ask: false, - jid, - name: None, - subscription: Some(stanza::roster::Subscription::Remove), - groups: Vec::new(), - }], - })), - errors: Vec::new(), - }); - let (send, recv) = oneshot::channel(); - { - self.pending.lock().await.insert(iq_id.clone(), send); - } - let result = connection.write_handle.write(set_stanza).await; - if let Err(e) = result { - sender.send(Err(RosterError::Write(e))); - return; - } - let iq_result = recv.await; - match iq_result { - Ok(i) => match i { - Ok(iq_result) => match iq_result { - Stanza::Iq(Iq { - from: _, - id, - to: _, - r#type, - lang: _, - query: _, - errors: _, - }) if id == iq_id && r#type == IqType::Result => { - sender.send(Ok(())); - return; - } - ref s @ Stanza::Iq(Iq { - from: _, - ref id, - to: _, - r#type, - lang: _, - query: _, - ref errors, - }) if *id == iq_id && r#type == IqType::Error => { - if let Some(error) = errors.first() { - sender.send(Err(RosterError::StanzaError(error.clone()))); - } else { - sender.send(Err(RosterError::UnexpectedStanza(s.clone()))); - } - return; - } - s => { - sender.send(Err(RosterError::UnexpectedStanza(s))); - return; - } - }, - Err(e) => { - sender.send(Err(e.into())); - return; - } - }, - Err(e) => { - sender.send(Err(RosterError::Write(WriteError::Actor(e.into())))); - return; - } - } - } - Command::UpdateContact(jid, contact_update, sender) => { - let iq_id = Uuid::new_v4().to_string(); - let groups = Vec::from_iter( - contact_update - .groups - .into_iter() - .map(|group| stanza::roster::Group(Some(group))), - ); - let set_stanza = Stanza::Iq(Iq { - from: Some(connection.jid), - id: iq_id.clone(), - to: None, - r#type: IqType::Set, - lang: None, - query: Some(iq::Query::Roster(stanza::roster::Query { - ver: None, - items: vec![stanza::roster::Item { - approved: None, - ask: false, - jid, - name: contact_update.name, - subscription: None, - groups, - }], - })), - errors: Vec::new(), - }); - let (send, recv) = oneshot::channel(); - { - self.pending.lock().await.insert(iq_id.clone(), send); - } - let result = connection.write_handle.write(set_stanza).await; - if let Err(e) = result { - sender.send(Err(RosterError::Write(e))); - return; - } - let iq_result = recv.await; - match iq_result { - Ok(i) => match i { - Ok(iq_result) => match iq_result { - Stanza::Iq(Iq { - from: _, - id, - to: _, - r#type, - lang: _, - query: _, - errors: _, - }) if id == iq_id && r#type == IqType::Result => { - sender.send(Ok(())); - return; - } - ref s @ Stanza::Iq(Iq { - from: _, - ref id, - to: _, - r#type, - lang: _, - query: _, - ref errors, - }) if *id == iq_id && r#type == IqType::Error => { - if let Some(error) = errors.first() { - sender.send(Err(RosterError::StanzaError(error.clone()))); - } else { - sender.send(Err(RosterError::UnexpectedStanza(s.clone()))); - } - return; - } - s => { - sender.send(Err(RosterError::UnexpectedStanza(s))); - return; - } - }, - Err(e) => { - sender.send(Err(e.into())); - return; - } - }, - Err(e) => { - sender.send(Err(RosterError::Write(WriteError::Actor(e.into())))); - return; - } - } - } - Command::SetStatus(online, sender) => { - let result = self.db.upsert_cached_status(online.clone()).await; - if let Err(e) = result { - let _ = self - .update_sender - .send(UpdateMessage::Error(Error::SetStatus(StatusError::Cache( - e.into(), - )))) - .await; - } - let result = connection - .write_handle - .write(Stanza::Presence(online.into_stanza(None))) - .await - .map_err(|e| StatusError::Write(e)); - // .map_err(|e| StatusError::Write(e)); - let _ = sender.send(result); - } - // TODO: offline message queue - Command::SendMessage(jid, body, sender) => { - let id = Uuid::new_v4(); - let message = Stanza::Message(stanza::client::message::Message { - from: Some(connection.jid.clone()), - id: Some(id.to_string()), - to: Some(jid.clone()), - // TODO: specify message type - r#type: stanza::client::message::MessageType::Chat, - // TODO: lang ? - lang: None, - subject: None, - body: Some(stanza::client::message::Body { - lang: None, - body: Some(body.body.clone()), - }), - thread: None, - delay: None, - }); - let _ = sender.send(Ok(())); - // let _ = sender.send(Ok(message.clone())); - let result = connection.write_handle.write(message).await; - match result { - Ok(_) => { - let mut message = Message { - id, - from: connection.jid, - body, - timestamp: Utc::now(), - }; - info!("send message {:?}", message); - if let Err(e) = self - .db - .create_message_with_self_resource_and_chat( - message.clone(), - jid.clone(), - ) - .await - .map_err(|e| e.into()) - { - tracing::error!("{}", e); - let _ = - self.update_sender - .send(UpdateMessage::Error(Error::MessageSend( - error::MessageSendError::MessageHistory(e), - ))); - } - // TODO: don't do this, have separate from from details - message.from = message.from.as_bare(); - let _ = self - .update_sender - .send(UpdateMessage::Message { to: jid, message }) - .await; - } - Err(_) => { - // let _ = sender.send(result); - } - } - } - Command::SendPresence(jid, presence, sender) => { - let mut presence: stanza::client::presence::Presence = presence.into(); - if let Some(jid) = jid { - presence.to = Some(jid); - }; - let result = connection - .write_handle - .write(Stanza::Presence(presence)) - .await; - // .map_err(|e| StatusError::Write(e)); - let _ = sender.send(result); - } - } - } - - async fn handle_offline(self, command: Command) { - match command { - Command::GetRoster(sender) => { - let roster = self.db.read_cached_roster().await; - match roster { - Ok(roster) => { - let _ = sender.send(Ok(roster)); - } - Err(e) => { - let _ = sender.send(Err(RosterError::Cache(e.into()))); - } - } - } - Command::GetChats(sender) => { - let chats = self.db.read_chats().await.map_err(|e| e.into()); - sender.send(chats); - } - Command::GetChatsOrdered(sender) => { - let chats = self.db.read_chats_ordered().await.map_err(|e| e.into()); - sender.send(chats); - } - Command::GetChatsOrderedWithLatestMessages(sender) => { - let chats = self - .db - .read_chats_ordered_with_latest_messages() - .await - .map_err(|e| e.into()); - sender.send(chats); - } - Command::GetChat(jid, sender) => { - let chats = self.db.read_chat(jid).await.map_err(|e| e.into()); - sender.send(chats); - } - Command::GetMessages(jid, sender) => { - let messages = self - .db - .read_message_history(jid) - .await - .map_err(|e| e.into()); - sender.send(messages); - } - Command::DeleteChat(jid, sender) => { - let result = self.db.delete_chat(jid).await.map_err(|e| e.into()); - sender.send(result); - } - Command::DeleteMessage(uuid, sender) => { - let result = self.db.delete_message(uuid).await.map_err(|e| e.into()); - sender.send(result); - } - Command::GetUser(jid, sender) => { - let user = self.db.read_user(jid).await.map_err(|e| e.into()); - sender.send(user); - } - // TODO: offline queue to modify roster - Command::AddContact(_jid, sender) => { - sender.send(Err(RosterError::Write(WriteError::Disconnected))); - } - Command::BuddyRequest(_jid, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - Command::SubscriptionRequest(_jid, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - Command::AcceptBuddyRequest(_jid, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - Command::AcceptSubscriptionRequest(_jid, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - Command::UnsubscribeFromContact(_jid, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - Command::UnsubscribeContact(_jid, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - Command::UnfriendContact(_jid, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - Command::DeleteContact(_jid, sender) => { - sender.send(Err(RosterError::Write(WriteError::Disconnected))); - } - Command::UpdateContact(_jid, _contact_update, sender) => { - sender.send(Err(RosterError::Write(WriteError::Disconnected))); - } - Command::SetStatus(online, sender) => { - let result = self - .db - .upsert_cached_status(online) - .await - .map_err(|e| StatusError::Cache(e.into())); - sender.send(result); - } - // TODO: offline message queue - Command::SendMessage(_jid, _body, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - Command::SendPresence(_jid, _presence, sender) => { - sender.send(Err(WriteError::Disconnected)); - } - } - } - // pub async fn handle_stream_error(self, error) {} - // stanza errors (recoverable) - // pub async fn handle_error(self, error: Error) {} - // when it aborts, must clear iq map no matter what - async fn on_abort(self) { - let mut iqs = self.pending.lock().await; - for (_id, sender) in iqs.drain() { - let _ = sender.send(Err(ReadError::LostConnection)); - } - } - - async fn handle_connection_error(self, error: ConnectionError) { - self.update_sender - .send(UpdateMessage::Error( - ConnectionError::AlreadyConnected.into(), - )) - .await; - } -} - -#[derive(Clone)] -pub struct Connected { - // full jid will stay stable across reconnections - jid: JID, - write_handle: WriteHandle, -} - -pub trait Logic { - type Cmd; - - fn handle_connect(self, connection: Connected) -> impl std::future::Future + Send; - fn handle_disconnect( - self, - connection: Connected, - ) -> impl std::future::Future + Send; - fn handle_stanza( - self, - stanza: Stanza, - connection: Connected, - supervisor: SupervisorSender, - ) -> impl std::future::Future + std::marker::Send; - fn handle_online( - self, - command: Self::Cmd, - connection: Connected, - ) -> impl std::future::Future + std::marker::Send; - fn handle_offline( - self, - command: Self::Cmd, - ) -> impl std::future::Future + std::marker::Send; - fn on_abort(self) -> impl std::future::Future + std::marker::Send; - // TODO: look at these - fn handle_connection_error( - self, - error: ConnectionError, - ) -> impl std::future::Future + std::marker::Send; - // async fn handle_stream_error(self, error) {} -} - -pub struct Luz { - jid: JID, - password: Arc, - receiver: mpsc::Receiver>, - // TODO: use a dyn passwordprovider trait to avoid storing password in memory - connected: Option<(Connected, SupervisorHandle)>, - // connected_intention: bool, - /// if connection was shut down due to e.g. server shutdown, supervisor must be able to mark client as disconnected - connection_supervisor_shutdown: Fuse>, - // TODO: will need to have an auto reconnect state as well (e.g. in case server shut down, to try and reconnect later) - // TODO: will grow forever at this point, maybe not required as tasks will naturally shut down anyway? - // TODO: genericize - logic: Lgc, - // config: LampConfig, - tasks: JoinSet<()>, -} - -impl Luz { - fn new( - jid: JID, - password: String, - receiver: mpsc::Receiver>, - connected: Option<(Connected, SupervisorHandle)>, - connection_supervisor_shutdown: Fuse>, - logic: Lgc, - ) -> Self { - Self { - jid, - password: Arc::new(password), - connected, - receiver, - connection_supervisor_shutdown, - logic, - tasks: JoinSet::new(), - } - } - - async fn run(mut self) { - loop { - let msg = tokio::select! { - // this is okay, as when created the supervisor (and connection) doesn't exist, but a bit messy - // THIS IS NOT OKAY LOLLLL - apparently fusing is the best option??? - _ = &mut self.connection_supervisor_shutdown => { - self.connected = None; - continue; - } - Some(msg) = self.receiver.recv() => { - msg - }, - else => break, - }; - // TODO: consider separating disconnect/connect and commands apart from commandmessage - // TODO: dispatch commands separate tasks - match msg { - LuzMessage::Connect => { - match self.connected { - Some(_) => { - self.logic - .clone() - .handle_connection_error(ConnectionError::AlreadyConnected) - .await; - } - None => { - let mut jid = self.jid.clone(); - let mut domain = jid.domainpart.clone(); - // TODO: check what happens upon reconnection with same resource (this is probably what one wants to do and why jid should be mutated from a bare jid to one with a resource) - let streams_result = - jabber::connect_and_login(&mut jid, &*self.password, &mut domain) - .await; - match streams_result { - Ok(s) => { - debug!("ok stream result"); - let (shutdown_send, shutdown_recv) = oneshot::channel::<()>(); - let (writer, supervisor) = SupervisorHandle::new( - s, - shutdown_send, - jid.clone(), - self.password.clone(), - self.logic.clone(), - ); - - let shutdown_recv = shutdown_recv.fuse(); - self.connection_supervisor_shutdown = shutdown_recv; - - let connected = Connected { - jid, - write_handle: writer, - }; - - self.logic.clone().handle_connect(connected.clone()).await; - - self.connected = Some((connected, supervisor)); - } - Err(e) => { - tracing::error!("error: {}", e); - self.logic - .clone() - .handle_connection_error(ConnectionError::ConnectionFailed( - e.into(), - )) - .await; - } - } - } - }; - } - LuzMessage::Disconnect => match self.connected { - None => { - self.logic - .clone() - .handle_connection_error(ConnectionError::AlreadyDisconnected) - .await; - } - ref mut c => { - if let Some((connected, supervisor_handle)) = c.take() { - // TODO: better disconnect logic, only reflect once actually disconnected - // TODO: call within supervisor instead - self.logic - .clone() - .handle_disconnect(connected.clone()) - .await; - let _ = supervisor_handle.send(SupervisorCommand::Disconnect).await; - } else { - unreachable!() - }; - } - }, - LuzMessage::Command(command) => { - match self.connected.as_ref() { - Some((w, s)) => self - .tasks - .spawn(self.logic.clone().handle_online(command, w.clone())), - None => self.tasks.spawn(self.logic.clone().handle_offline(command)), - }; - } - } - } - } -} - -// TODO: generate methods for each with a macro -pub enum LuzMessage { - // TODO: login invisible xep-0186 - /// connect to XMPP chat server. gets roster and publishes initial presence. - Connect, - /// disconnect from XMPP chat server, sending unavailable presence then closing stream. - Disconnect, - /// TODO: generics - Command(C), -} +pub use client::connect_and_login; -#[derive(Debug, Clone)] -pub enum UpdateMessage { - Error(Error), - Online(Online, Vec), - Offline(Offline), - /// received roster from jabber server (replace full app roster state with this) - /// is this needed? - FullRoster(Vec), - /// (only update app roster state, don't replace) - RosterUpdate(Contact), - RosterDelete(JID), - /// presences should be stored with users in the ui, not contacts, as presences can be received from anyone - Presence { - from: JID, - presence: Presence, - }, - // TODO: receipts - // MessageDispatched(Uuid), - Message { - to: JID, - message: Message, - }, - SubscriptionRequest(jid::JID), +#[cfg(test)] +mod tests { + // #[tokio::test] + // async fn test_login() { + // crate::login("test@blos.sm/clown", "slayed").await.unwrap(); + // } } diff --git a/luz/src/main.rs b/luz/src/main.rs deleted file mode 100644 index 5aeef14..0000000 --- a/luz/src/main.rs +++ /dev/null @@ -1,42 +0,0 @@ -use std::{path::Path, str::FromStr, time::Duration}; - -use jid::JID; -use luz::{db::Db, LuzHandle, LuzMessage}; -use sqlx::SqlitePool; -use tokio::{ - io::{AsyncReadExt, AsyncWriteExt}, - sync::oneshot, -}; -use tracing::info; - -#[tokio::main] -async fn main() { - tracing_subscriber::fmt::init(); - let db = Db::create_connect_and_migrate(Path::new("./luz.db")) - .await - .unwrap(); - let (luz, mut recv) = - LuzHandle::new("test@blos.sm".try_into().unwrap(), "slayed".to_string(), db); - - tokio::spawn(async move { - while let Some(msg) = recv.recv().await { - info!("{:#?}", msg) - } - }); - - luz.send(LuzMessage::Connect).await.unwrap(); - let (send, recv) = oneshot::channel(); - tokio::time::sleep(Duration::from_secs(5)).await; - info!("sending message"); - luz.send(LuzMessage::SendMessage( - JID::from_str("cel@blos.sm").unwrap(), - luz::chat::Body { - body: "hallo!!!".to_string(), - }, - send, - )) - .await - .unwrap(); - recv.await.unwrap().unwrap(); - println!("sent message"); -} diff --git a/luz/src/presence.rs b/luz/src/presence.rs deleted file mode 100644 index e35761c..0000000 --- a/luz/src/presence.rs +++ /dev/null @@ -1,151 +0,0 @@ -use chrono::{DateTime, Utc}; -use sqlx::Sqlite; -use stanza::{client::presence::String1024, xep_0203::Delay}; - -#[derive(Debug, Default, sqlx::FromRow, Clone)] -pub struct Online { - pub show: Option, - #[sqlx(rename = "message")] - pub status: Option, - #[sqlx(skip)] - pub priority: Option, -} - -#[derive(Debug, Clone, Copy)] -pub enum Show { - Away, - Chat, - DoNotDisturb, - ExtendedAway, -} - -impl sqlx::Type for Show { - fn type_info() -> ::TypeInfo { - <&str as sqlx::Type>::type_info() - } -} - -impl sqlx::Decode<'_, Sqlite> for Show { - fn decode( - value: ::ValueRef<'_>, - ) -> Result { - let value = <&str as sqlx::Decode>::decode(value)?; - match value { - "away" => Ok(Self::Away), - "chat" => Ok(Self::Chat), - "do-not-disturb" => Ok(Self::DoNotDisturb), - "extended-away" => Ok(Self::ExtendedAway), - _ => unreachable!(), - } - } -} - -impl sqlx::Encode<'_, Sqlite> for Show { - fn encode_by_ref( - &self, - buf: &mut ::ArgumentBuffer<'_>, - ) -> Result { - let value = match self { - Show::Away => "away", - Show::Chat => "chat", - Show::DoNotDisturb => "do-not-disturb", - Show::ExtendedAway => "extended-away", - }; - <&str as sqlx::Encode>::encode(value, buf) - } -} - -#[derive(Debug, Default, Clone)] -pub struct Offline { - pub status: Option, -} - -#[derive(Debug, Clone)] -pub enum PresenceType { - Online(Online), - Offline(Offline), -} - -#[derive(Debug, Clone)] -pub struct Presence { - pub timestamp: DateTime, - pub presence: PresenceType, -} - -impl Online { - pub fn into_stanza( - self, - timestamp: Option>, - ) -> stanza::client::presence::Presence { - stanza::client::presence::Presence { - from: None, - id: None, - to: None, - r#type: None, - lang: None, - show: self.show.map(|show| match show { - Show::Away => stanza::client::presence::Show::Away, - Show::Chat => stanza::client::presence::Show::Chat, - Show::DoNotDisturb => stanza::client::presence::Show::Dnd, - Show::ExtendedAway => stanza::client::presence::Show::Xa, - }), - // TODO: enforce message length in status message - status: self.status.map(|status| stanza::client::presence::Status { - lang: None, - status: String1024(status), - }), - priority: self - .priority - .map(|priority| stanza::client::presence::Priority(priority)), - errors: Vec::new(), - delay: timestamp.map(|timestamp| Delay { - from: None, - stamp: timestamp, - }), - } - } -} - -impl Offline { - pub fn into_stanza( - self, - timestamp: Option>, - ) -> stanza::client::presence::Presence { - stanza::client::presence::Presence { - from: None, - id: None, - to: None, - r#type: Some(stanza::client::presence::PresenceType::Unavailable), - lang: None, - show: None, - status: self.status.map(|status| stanza::client::presence::Status { - lang: None, - status: String1024(status), - }), - priority: None, - errors: Vec::new(), - delay: timestamp.map(|timestamp| Delay { - from: None, - stamp: timestamp, - }), - } - } -} - -impl From for stanza::client::presence::Presence { - fn from(value: PresenceType) -> Self { - match value { - PresenceType::Online(online) => online.into_stanza(None), - PresenceType::Offline(offline) => offline.into_stanza(None), - } - } -} - -impl From for stanza::client::presence::Presence { - fn from(value: Presence) -> Self { - match value.presence { - PresenceType::Online(online) => online.into_stanza(Some(value.timestamp)), - PresenceType::Offline(offline) => offline.into_stanza(Some(value.timestamp)), - } - } -} diff --git a/luz/src/roster.rs b/luz/src/roster.rs deleted file mode 100644 index 43c32f5..0000000 --- a/luz/src/roster.rs +++ /dev/null @@ -1,127 +0,0 @@ -use std::collections::HashSet; - -use jid::JID; -use sqlx::Sqlite; - -pub struct ContactUpdate { - pub name: Option, - pub groups: HashSet, -} - -#[derive(Debug, sqlx::FromRow, Clone)] -pub struct Contact { - // jid is the id used to reference everything, but not the primary key - pub user_jid: JID, - pub subscription: Subscription, - /// client user defined name - pub name: Option, - // TODO: avatar, nickname - /// nickname picked by contact - // nickname: Option, - #[sqlx(skip)] - pub groups: HashSet, -} - -#[derive(Debug, Clone)] -pub enum Subscription { - None, - PendingOut, - PendingIn, - PendingInPendingOut, - OnlyOut, - OnlyIn, - OutPendingIn, - InPendingOut, - Buddy, - // TODO: perhaps don't need, just emit event to remove contact - // Remove, -} - -impl sqlx::Type for Subscription { - fn type_info() -> ::TypeInfo { - <&str as sqlx::Type>::type_info() - } -} - -impl sqlx::Decode<'_, Sqlite> for Subscription { - fn decode( - value: ::ValueRef<'_>, - ) -> Result { - let value = <&str as sqlx::Decode>::decode(value)?; - match value { - "none" => Ok(Self::None), - "pending-out" => Ok(Self::PendingOut), - "pending-in" => Ok(Self::PendingIn), - "pending-in-pending-out" => Ok(Self::PendingInPendingOut), - "only-out" => Ok(Self::OnlyOut), - "only-in" => Ok(Self::OnlyIn), - "out-pending-in" => Ok(Self::OutPendingIn), - "in-pending-out" => Ok(Self::InPendingOut), - "buddy" => Ok(Self::Buddy), - _ => panic!("unexpected subscription `{value}`"), - } - } -} - -impl sqlx::Encode<'_, Sqlite> for Subscription { - fn encode_by_ref( - &self, - buf: &mut ::ArgumentBuffer<'_>, - ) -> Result { - let value = match self { - Subscription::None => "none", - Subscription::PendingOut => "pending-out", - Subscription::PendingIn => "pending-in", - Subscription::PendingInPendingOut => "pending-in-pending-out", - Subscription::OnlyOut => "only-out", - Subscription::OnlyIn => "only-in", - Subscription::OutPendingIn => "out-pending-in", - Subscription::InPendingOut => "in-pending-out", - Subscription::Buddy => "buddy", - }; - <&str as sqlx::Encode>::encode(value, buf) - } -} - -// none -// > -// >> -// < -// << -// >< -// >>< -// ><< -// >><< - -impl From for Contact { - fn from(value: stanza::roster::Item) -> Self { - let subscription = match value.ask { - true => match value.subscription { - Some(s) => match s { - stanza::roster::Subscription::Both => Subscription::Buddy, - stanza::roster::Subscription::From => Subscription::InPendingOut, - stanza::roster::Subscription::None => Subscription::PendingOut, - stanza::roster::Subscription::Remove => Subscription::PendingOut, - stanza::roster::Subscription::To => Subscription::OnlyOut, - }, - None => Subscription::PendingOut, - }, - false => match value.subscription { - Some(s) => match s { - stanza::roster::Subscription::Both => Subscription::Buddy, - stanza::roster::Subscription::From => Subscription::OnlyIn, - stanza::roster::Subscription::None => Subscription::None, - stanza::roster::Subscription::Remove => Subscription::None, - stanza::roster::Subscription::To => Subscription::OnlyOut, - }, - None => Subscription::None, - }, - }; - Contact { - user_jid: value.jid, - subscription, - name: value.name, - groups: HashSet::from_iter(value.groups.into_iter().filter_map(|group| group.0)), - } - } -} diff --git a/luz/src/user.rs b/luz/src/user.rs deleted file mode 100644 index 9914d14..0000000 --- a/luz/src/user.rs +++ /dev/null @@ -1,7 +0,0 @@ -use jid::JID; - -#[derive(Debug, sqlx::FromRow)] -pub struct User { - pub jid: JID, - pub cached_status_message: Option, -} -- cgit