forked from lavina/lavina
243 lines
9.1 KiB
Rust
243 lines
9.1 KiB
Rust
//! Handling of all client2server presence stanzas
|
||
|
||
use anyhow::Result;
|
||
use quick_xml::events::Event;
|
||
|
||
use lavina_core::room::RoomId;
|
||
use proto_xmpp::bind::{Jid, Name, Server};
|
||
use proto_xmpp::client::{Message, MessageType, Presence, Subject};
|
||
use proto_xmpp::muc::{Affiliation, Role, XUser, XUserItem};
|
||
use proto_xmpp::xml::{Ignore, ToXml};
|
||
|
||
use crate::XmppConnection;
|
||
|
||
impl<'a> XmppConnection<'a> {
|
||
pub async fn handle_presence(&mut self, output: &mut Vec<Event<'static>>, p: Presence<Ignore>) -> Result<()> {
|
||
match p.to {
|
||
None => {
|
||
self.self_presence(output, p.r#type.as_deref()).await;
|
||
}
|
||
Some(Jid {
|
||
name: Some(name),
|
||
server,
|
||
// resources in MUCs are members' personas – not implemented (yet?)
|
||
resource: Some(_),
|
||
}) if server.0 == self.hostname_rooms => {
|
||
let mut response = self.muc_presence(&name).await?;
|
||
response.id = p.id;
|
||
let subject = Message::<()> {
|
||
from: Some(Jid {
|
||
name: Some(name),
|
||
server: Server(self.hostname_rooms.clone()),
|
||
resource: None,
|
||
}),
|
||
id: None,
|
||
to: Some(Jid {
|
||
name: Some(self.user.xmpp_name.clone()),
|
||
server: Server(self.hostname.clone()),
|
||
resource: Some(self.user.xmpp_resource.clone()),
|
||
}),
|
||
r#type: MessageType::Groupchat,
|
||
lang: None,
|
||
subject: Some(Subject(None)),
|
||
body: None,
|
||
custom: vec![],
|
||
};
|
||
response.serialize(output);
|
||
subject.serialize(output);
|
||
}
|
||
_ => {
|
||
// TODO other presence cases
|
||
let response = Presence::<()>::default();
|
||
response.serialize(output);
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
async fn self_presence(&mut self, output: &mut Vec<Event<'static>>, r#type: Option<&str>) {
|
||
match r#type {
|
||
Some("unavailable") => {
|
||
// do not print anything
|
||
}
|
||
None => {
|
||
let response = Presence::<()> {
|
||
to: Some(Jid {
|
||
name: Some(self.user.xmpp_name.clone()),
|
||
server: Server(self.hostname.clone()),
|
||
resource: Some(self.user.xmpp_resource.clone()),
|
||
}),
|
||
from: Some(Jid {
|
||
name: Some(self.user.xmpp_name.clone()),
|
||
server: Server(self.hostname.clone()),
|
||
resource: Some(self.user.xmpp_resource.clone()),
|
||
}),
|
||
..Default::default()
|
||
};
|
||
response.serialize(output);
|
||
}
|
||
e => {
|
||
tracing::error!("TODO: unknown presence type: {e:?}");
|
||
}
|
||
}
|
||
}
|
||
|
||
// todo: return Presence and serialize on the outside.
|
||
async fn muc_presence(&mut self, name: &Name) -> Result<(Presence<XUser>)> {
|
||
let a = self.user_handle.join_room(RoomId::from(name.0.clone())?).await?;
|
||
// TODO handle bans
|
||
let response = Presence {
|
||
to: Some(Jid {
|
||
name: Some(self.user.xmpp_name.clone()),
|
||
server: Server(self.hostname.clone()),
|
||
resource: Some(self.user.xmpp_resource.clone()),
|
||
}),
|
||
from: Some(Jid {
|
||
name: Some(name.clone()),
|
||
server: Server(self.hostname_rooms.clone()),
|
||
resource: Some(self.user.xmpp_muc_name.clone()),
|
||
}),
|
||
custom: vec![XUser {
|
||
item: XUserItem {
|
||
affiliation: Affiliation::Member,
|
||
role: Role::Participant,
|
||
jid: Jid {
|
||
name: Some(self.user.xmpp_name.clone()),
|
||
server: Server(self.hostname.clone()),
|
||
resource: Some(self.user.xmpp_resource.clone()),
|
||
},
|
||
},
|
||
self_presence: true,
|
||
just_created: false, // TODO we don't know this for sure at this point
|
||
}],
|
||
..Default::default()
|
||
};
|
||
Ok(response)
|
||
}
|
||
}
|
||
|
||
// todo: set up so that the user has been previously joined.
|
||
// todo: first call to muc_presence is OK, next one is OK too.
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use crate::testkit::{expect_user_authenticated, TestServer};
|
||
use crate::Authenticated;
|
||
use anyhow::Result;
|
||
use lavina_core::player::PlayerId;
|
||
use proto_xmpp::bind::{Jid, Name, Resource, Server};
|
||
use proto_xmpp::client::Presence;
|
||
use proto_xmpp::muc::{Affiliation, Role, XUser, XUserItem};
|
||
|
||
#[tokio::test]
|
||
async fn test_muc_joining() -> Result<()> {
|
||
let server = TestServer::start().await.unwrap();
|
||
|
||
server.core.create_player(&PlayerId::from("tester")?).await?;
|
||
|
||
let player_id = PlayerId::from("tester").unwrap();
|
||
let user = Authenticated {
|
||
player_id,
|
||
xmpp_name: Name("tester".into()),
|
||
xmpp_resource: Resource("tester".into()),
|
||
xmpp_muc_name: Resource("tester".into()),
|
||
};
|
||
|
||
let mut player_conn = server.core.connect_to_player(&user.player_id).await;
|
||
let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();
|
||
|
||
let response = conn.muc_presence(&user.xmpp_name).await.unwrap();
|
||
let expected = Presence {
|
||
to: Some(Jid {
|
||
name: Some(conn.user.xmpp_name.clone()),
|
||
server: Server(conn.hostname.clone()),
|
||
resource: Some(conn.user.xmpp_resource.clone()),
|
||
}),
|
||
from: Some(Jid {
|
||
name: Some(user.xmpp_name.clone()),
|
||
server: Server(conn.hostname_rooms.clone()),
|
||
resource: Some(conn.user.xmpp_muc_name.clone()),
|
||
}),
|
||
custom: vec![XUser {
|
||
item: XUserItem {
|
||
affiliation: Affiliation::Member,
|
||
role: Role::Participant,
|
||
jid: Jid {
|
||
name: Some(conn.user.xmpp_name.clone()),
|
||
server: Server(conn.hostname.clone()),
|
||
resource: Some(conn.user.xmpp_resource.clone()),
|
||
},
|
||
},
|
||
self_presence: true,
|
||
just_created: false,
|
||
}],
|
||
..Default::default()
|
||
};
|
||
assert_eq!(expected, response);
|
||
|
||
server.shutdown().await.unwrap();
|
||
Ok(())
|
||
}
|
||
|
||
// Test that joining a room second time after a server restart,
|
||
// i.e. in-memory cache of memberships is cleaned, does not cause any issues.
|
||
#[tokio::test]
|
||
async fn test_muc_joining_twice() -> Result<()> {
|
||
let server = TestServer::start().await.unwrap();
|
||
|
||
server.core.create_player(&PlayerId::from("tester")?).await?;
|
||
|
||
let player_id = PlayerId::from("tester").unwrap();
|
||
let user = Authenticated {
|
||
player_id,
|
||
xmpp_name: Name("tester".into()),
|
||
xmpp_resource: Resource("tester".into()),
|
||
xmpp_muc_name: Resource("tester".into()),
|
||
};
|
||
|
||
let mut player_conn = server.core.connect_to_player(&user.player_id).await;
|
||
let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();
|
||
|
||
let response = conn.muc_presence(&user.xmpp_name).await.unwrap();
|
||
let expected = Presence {
|
||
to: Some(Jid {
|
||
name: Some(conn.user.xmpp_name.clone()),
|
||
server: Server(conn.hostname.clone()),
|
||
resource: Some(conn.user.xmpp_resource.clone()),
|
||
}),
|
||
from: Some(Jid {
|
||
name: Some(user.xmpp_name.clone()),
|
||
server: Server(conn.hostname_rooms.clone()),
|
||
resource: Some(conn.user.xmpp_muc_name.clone()),
|
||
}),
|
||
custom: vec![XUser {
|
||
item: XUserItem {
|
||
affiliation: Affiliation::Member,
|
||
role: Role::Participant,
|
||
jid: Jid {
|
||
name: Some(conn.user.xmpp_name.clone()),
|
||
server: Server(conn.hostname.clone()),
|
||
resource: Some(conn.user.xmpp_resource.clone()),
|
||
},
|
||
},
|
||
self_presence: true,
|
||
just_created: false,
|
||
}],
|
||
..Default::default()
|
||
};
|
||
assert_eq!(expected, response);
|
||
|
||
drop(conn);
|
||
let server = server.reboot().await.unwrap();
|
||
|
||
let mut player_conn = server.core.connect_to_player(&user.player_id).await;
|
||
let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();
|
||
|
||
let response = conn.muc_presence(&user.xmpp_name).await.unwrap();
|
||
assert_eq!(expected, response);
|
||
|
||
server.shutdown().await.unwrap();
|
||
Ok(())
|
||
}
|
||
}
|