2020-07-30 16:14:47 +00:00
|
|
|
use super::State;
|
2020-08-14 09:31:31 +00:00
|
|
|
use crate::{
|
2020-08-18 20:26:03 +00:00
|
|
|
client_server,
|
|
|
|
|
pdu::{PduBuilder, PduEvent},
|
2020-12-19 15:00:11 +00:00
|
|
|
utils, ConduitResult, Database, Error, Result, Ruma,
|
2020-08-14 09:31:31 +00:00
|
|
|
};
|
2021-03-23 18:46:54 +00:00
|
|
|
use log::{error, info, warn};
|
2020-07-30 16:14:47 +00:00
|
|
|
use ruma::{
|
2020-08-14 09:31:31 +00:00
|
|
|
api::{
|
|
|
|
|
client::{
|
|
|
|
|
error::ErrorKind,
|
2020-08-20 16:12:02 +00:00
|
|
|
r0::membership::{
|
|
|
|
|
ban_user, forget_room, get_member_events, invite_user, join_room_by_id,
|
|
|
|
|
join_room_by_id_or_alias, joined_members, joined_rooms, kick_user, leave_room,
|
|
|
|
|
unban_user, IncomingThirdPartySigned,
|
2020-08-14 09:31:31 +00:00
|
|
|
},
|
2020-07-30 16:14:47 +00:00
|
|
|
},
|
2020-08-14 09:31:31 +00:00
|
|
|
federation,
|
2020-07-30 16:14:47 +00:00
|
|
|
},
|
2020-11-08 19:45:52 +00:00
|
|
|
events::{pdu::Pdu, room::member, EventType},
|
2020-12-04 23:16:17 +00:00
|
|
|
serde::{to_canonical_value, CanonicalJsonObject, Raw},
|
|
|
|
|
EventId, RoomId, RoomVersionId, ServerName, UserId,
|
2020-07-30 16:14:47 +00:00
|
|
|
};
|
2021-03-25 22:55:40 +00:00
|
|
|
use std::{collections::BTreeMap, convert::TryFrom, sync::Arc};
|
2020-07-30 16:14:47 +00:00
|
|
|
|
|
|
|
|
#[cfg(feature = "conduit_bin")]
|
|
|
|
|
use rocket::{get, post};
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
post("/_matrix/client/r0/rooms/<_>/join", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-08-14 09:31:31 +00:00
|
|
|
pub async fn join_room_by_id_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<join_room_by_id::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<join_room_by_id::Response> {
|
2020-08-19 23:30:28 +00:00
|
|
|
join_room_by_id_helper(
|
|
|
|
|
&db,
|
2020-10-18 18:33:12 +00:00
|
|
|
body.sender_user.as_ref(),
|
2020-08-19 23:30:28 +00:00
|
|
|
&body.room_id,
|
2020-09-14 09:00:31 +00:00
|
|
|
&[body.room_id.server_name().to_owned()],
|
2020-08-19 23:30:28 +00:00
|
|
|
body.third_party_signed.as_ref(),
|
|
|
|
|
)
|
|
|
|
|
.await
|
2020-07-30 16:14:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
post("/_matrix/client/r0/join/<_>", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-08-14 09:31:31 +00:00
|
|
|
pub async fn join_room_by_id_or_alias_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<join_room_by_id_or_alias::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<join_room_by_id_or_alias::Response> {
|
2020-09-14 09:00:31 +00:00
|
|
|
let (servers, room_id) = match RoomId::try_from(body.room_id_or_alias.clone()) {
|
|
|
|
|
Ok(room_id) => (vec![room_id.server_name().to_owned()], room_id),
|
2020-08-14 09:31:31 +00:00
|
|
|
Err(room_alias) => {
|
2020-09-14 09:00:31 +00:00
|
|
|
let response = client_server::get_alias_helper(&db, &room_alias).await?;
|
|
|
|
|
|
|
|
|
|
(response.0.servers, response.0.room_id)
|
2020-08-14 09:31:31 +00:00
|
|
|
}
|
|
|
|
|
};
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-21 19:28:02 +00:00
|
|
|
let join_room_response = join_room_by_id_helper(
|
|
|
|
|
&db,
|
|
|
|
|
body.sender_user.as_ref(),
|
|
|
|
|
&room_id,
|
|
|
|
|
&servers,
|
|
|
|
|
body.third_party_signed.as_ref(),
|
|
|
|
|
)
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
|
|
db.flush().await?;
|
|
|
|
|
|
2020-07-30 16:14:47 +00:00
|
|
|
Ok(join_room_by_id_or_alias::Response {
|
2020-10-21 19:28:02 +00:00
|
|
|
room_id: join_room_response.0.room_id,
|
2020-07-30 16:14:47 +00:00
|
|
|
}
|
|
|
|
|
.into())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
post("/_matrix/client/r0/rooms/<_>/leave", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-09-14 18:23:19 +00:00
|
|
|
pub async fn leave_room_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<leave_room::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<leave_room::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
|
|
|
|
let mut event = serde_json::from_value::<Raw<member::MemberEventContent>>(
|
|
|
|
|
db.rooms
|
|
|
|
|
.room_state_get(
|
|
|
|
|
&body.room_id,
|
|
|
|
|
&EventType::RoomMember,
|
2020-10-18 18:33:12 +00:00
|
|
|
&sender_user.to_string(),
|
2020-07-30 16:14:47 +00:00
|
|
|
)?
|
|
|
|
|
.ok_or(Error::BadRequest(
|
|
|
|
|
ErrorKind::BadState,
|
|
|
|
|
"Cannot leave a room you are not a member of.",
|
|
|
|
|
))?
|
|
|
|
|
.content,
|
|
|
|
|
)
|
|
|
|
|
.expect("from_value::<Raw<..>> can never fail")
|
|
|
|
|
.deserialize()
|
|
|
|
|
.map_err(|_| Error::bad_database("Invalid member event in database."))?;
|
|
|
|
|
|
|
|
|
|
event.membership = member::MembershipState::Leave;
|
|
|
|
|
|
2020-10-05 20:19:22 +00:00
|
|
|
db.rooms.build_and_append_pdu(
|
|
|
|
|
PduBuilder {
|
|
|
|
|
event_type: EventType::RoomMember,
|
|
|
|
|
content: serde_json::to_value(event).expect("event is valid, we just created it"),
|
|
|
|
|
unsigned: None,
|
2020-10-18 18:33:12 +00:00
|
|
|
state_key: Some(sender_user.to_string()),
|
2020-10-05 20:19:22 +00:00
|
|
|
redacts: None,
|
|
|
|
|
},
|
2020-10-18 18:33:12 +00:00
|
|
|
&sender_user,
|
2020-10-05 20:19:22 +00:00
|
|
|
&body.room_id,
|
2021-01-15 16:05:57 +00:00
|
|
|
&db,
|
2020-10-05 20:19:22 +00:00
|
|
|
)?;
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-21 19:28:02 +00:00
|
|
|
db.flush().await?;
|
|
|
|
|
|
2020-08-06 12:29:59 +00:00
|
|
|
Ok(leave_room::Response::new().into())
|
2020-07-30 16:14:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
post("/_matrix/client/r0/rooms/<_>/invite", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-09-14 18:23:19 +00:00
|
|
|
pub async fn invite_user_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<invite_user::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<invite_user::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-09-08 15:32:03 +00:00
|
|
|
if let invite_user::IncomingInvitationRecipient::UserId { user_id } = &body.recipient {
|
2020-10-05 20:19:22 +00:00
|
|
|
db.rooms.build_and_append_pdu(
|
|
|
|
|
PduBuilder {
|
|
|
|
|
event_type: EventType::RoomMember,
|
|
|
|
|
content: serde_json::to_value(member::MemberEventContent {
|
|
|
|
|
membership: member::MembershipState::Invite,
|
|
|
|
|
displayname: db.users.displayname(&user_id)?,
|
|
|
|
|
avatar_url: db.users.avatar_url(&user_id)?,
|
|
|
|
|
is_direct: None,
|
|
|
|
|
third_party_invite: None,
|
|
|
|
|
})
|
|
|
|
|
.expect("event is valid, we just created it"),
|
|
|
|
|
unsigned: None,
|
|
|
|
|
state_key: Some(user_id.to_string()),
|
|
|
|
|
redacts: None,
|
|
|
|
|
},
|
2020-10-18 18:33:12 +00:00
|
|
|
&sender_user,
|
2020-10-05 20:19:22 +00:00
|
|
|
&body.room_id,
|
2021-01-15 16:05:57 +00:00
|
|
|
&db,
|
2020-10-05 20:19:22 +00:00
|
|
|
)?;
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-21 19:28:02 +00:00
|
|
|
db.flush().await?;
|
|
|
|
|
|
2020-07-30 16:14:47 +00:00
|
|
|
Ok(invite_user::Response.into())
|
|
|
|
|
} else {
|
|
|
|
|
Err(Error::BadRequest(ErrorKind::NotFound, "User not found."))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
post("/_matrix/client/r0/rooms/<_>/kick", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-09-14 18:23:19 +00:00
|
|
|
pub async fn kick_user_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<kick_user::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<kick_user::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
|
|
|
|
let mut event = serde_json::from_value::<Raw<ruma::events::room::member::MemberEventContent>>(
|
|
|
|
|
db.rooms
|
|
|
|
|
.room_state_get(
|
|
|
|
|
&body.room_id,
|
|
|
|
|
&EventType::RoomMember,
|
|
|
|
|
&body.user_id.to_string(),
|
|
|
|
|
)?
|
|
|
|
|
.ok_or(Error::BadRequest(
|
|
|
|
|
ErrorKind::BadState,
|
|
|
|
|
"Cannot kick member that's not in the room.",
|
|
|
|
|
))?
|
|
|
|
|
.content,
|
|
|
|
|
)
|
|
|
|
|
.expect("Raw::from_value always works")
|
|
|
|
|
.deserialize()
|
|
|
|
|
.map_err(|_| Error::bad_database("Invalid member event in database."))?;
|
|
|
|
|
|
|
|
|
|
event.membership = ruma::events::room::member::MembershipState::Leave;
|
|
|
|
|
// TODO: reason
|
|
|
|
|
|
2020-10-05 20:19:22 +00:00
|
|
|
db.rooms.build_and_append_pdu(
|
|
|
|
|
PduBuilder {
|
|
|
|
|
event_type: EventType::RoomMember,
|
|
|
|
|
content: serde_json::to_value(event).expect("event is valid, we just created it"),
|
|
|
|
|
unsigned: None,
|
|
|
|
|
state_key: Some(body.user_id.to_string()),
|
|
|
|
|
redacts: None,
|
|
|
|
|
},
|
2020-10-18 18:33:12 +00:00
|
|
|
&sender_user,
|
2020-10-05 20:19:22 +00:00
|
|
|
&body.room_id,
|
2021-01-15 16:05:57 +00:00
|
|
|
&db,
|
2020-10-05 20:19:22 +00:00
|
|
|
)?;
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-21 19:28:02 +00:00
|
|
|
db.flush().await?;
|
|
|
|
|
|
2020-08-06 12:29:59 +00:00
|
|
|
Ok(kick_user::Response::new().into())
|
2020-07-30 16:14:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
post("/_matrix/client/r0/rooms/<_>/ban", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-09-14 18:23:19 +00:00
|
|
|
pub async fn ban_user_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<ban_user::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<ban_user::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
|
|
|
|
// TODO: reason
|
|
|
|
|
|
|
|
|
|
let event = db
|
|
|
|
|
.rooms
|
|
|
|
|
.room_state_get(
|
|
|
|
|
&body.room_id,
|
|
|
|
|
&EventType::RoomMember,
|
|
|
|
|
&body.user_id.to_string(),
|
|
|
|
|
)?
|
|
|
|
|
.map_or(
|
|
|
|
|
Ok::<_, Error>(member::MemberEventContent {
|
|
|
|
|
membership: member::MembershipState::Ban,
|
|
|
|
|
displayname: db.users.displayname(&body.user_id)?,
|
|
|
|
|
avatar_url: db.users.avatar_url(&body.user_id)?,
|
|
|
|
|
is_direct: None,
|
|
|
|
|
third_party_invite: None,
|
|
|
|
|
}),
|
2021-03-17 21:30:25 +00:00
|
|
|
|event| {
|
2020-07-30 16:14:47 +00:00
|
|
|
let mut event =
|
|
|
|
|
serde_json::from_value::<Raw<member::MemberEventContent>>(event.content)
|
|
|
|
|
.expect("Raw::from_value always works")
|
|
|
|
|
.deserialize()
|
|
|
|
|
.map_err(|_| Error::bad_database("Invalid member event in database."))?;
|
|
|
|
|
event.membership = ruma::events::room::member::MembershipState::Ban;
|
|
|
|
|
Ok(event)
|
|
|
|
|
},
|
|
|
|
|
)?;
|
|
|
|
|
|
2020-10-05 20:19:22 +00:00
|
|
|
db.rooms.build_and_append_pdu(
|
|
|
|
|
PduBuilder {
|
|
|
|
|
event_type: EventType::RoomMember,
|
|
|
|
|
content: serde_json::to_value(event).expect("event is valid, we just created it"),
|
|
|
|
|
unsigned: None,
|
|
|
|
|
state_key: Some(body.user_id.to_string()),
|
|
|
|
|
redacts: None,
|
|
|
|
|
},
|
2020-10-18 18:33:12 +00:00
|
|
|
&sender_user,
|
2020-10-05 20:19:22 +00:00
|
|
|
&body.room_id,
|
2021-01-15 16:05:57 +00:00
|
|
|
&db,
|
2020-10-05 20:19:22 +00:00
|
|
|
)?;
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-21 19:28:02 +00:00
|
|
|
db.flush().await?;
|
|
|
|
|
|
2020-08-06 12:29:59 +00:00
|
|
|
Ok(ban_user::Response::new().into())
|
2020-07-30 16:14:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
post("/_matrix/client/r0/rooms/<_>/unban", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-09-14 18:23:19 +00:00
|
|
|
pub async fn unban_user_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<unban_user::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<unban_user::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
|
|
|
|
let mut event = serde_json::from_value::<Raw<ruma::events::room::member::MemberEventContent>>(
|
|
|
|
|
db.rooms
|
|
|
|
|
.room_state_get(
|
|
|
|
|
&body.room_id,
|
|
|
|
|
&EventType::RoomMember,
|
|
|
|
|
&body.user_id.to_string(),
|
|
|
|
|
)?
|
|
|
|
|
.ok_or(Error::BadRequest(
|
|
|
|
|
ErrorKind::BadState,
|
|
|
|
|
"Cannot unban a user who is not banned.",
|
|
|
|
|
))?
|
|
|
|
|
.content,
|
|
|
|
|
)
|
|
|
|
|
.expect("from_value::<Raw<..>> can never fail")
|
|
|
|
|
.deserialize()
|
|
|
|
|
.map_err(|_| Error::bad_database("Invalid member event in database."))?;
|
|
|
|
|
|
|
|
|
|
event.membership = ruma::events::room::member::MembershipState::Leave;
|
|
|
|
|
|
2020-10-05 20:19:22 +00:00
|
|
|
db.rooms.build_and_append_pdu(
|
|
|
|
|
PduBuilder {
|
|
|
|
|
event_type: EventType::RoomMember,
|
|
|
|
|
content: serde_json::to_value(event).expect("event is valid, we just created it"),
|
|
|
|
|
unsigned: None,
|
|
|
|
|
state_key: Some(body.user_id.to_string()),
|
|
|
|
|
redacts: None,
|
|
|
|
|
},
|
2020-10-18 18:33:12 +00:00
|
|
|
&sender_user,
|
2020-10-05 20:19:22 +00:00
|
|
|
&body.room_id,
|
2021-01-15 16:05:57 +00:00
|
|
|
&db,
|
2020-10-05 20:19:22 +00:00
|
|
|
)?;
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-21 19:28:02 +00:00
|
|
|
db.flush().await?;
|
|
|
|
|
|
2020-08-06 12:29:59 +00:00
|
|
|
Ok(unban_user::Response::new().into())
|
2020-07-30 16:14:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
post("/_matrix/client/r0/rooms/<_>/forget", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-10-21 19:28:02 +00:00
|
|
|
pub async fn forget_room_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<forget_room::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<forget_room::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-18 18:33:12 +00:00
|
|
|
db.rooms.forget(&body.room_id, &sender_user)?;
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-21 19:28:02 +00:00
|
|
|
db.flush().await?;
|
|
|
|
|
|
2020-08-06 12:29:59 +00:00
|
|
|
Ok(forget_room::Response::new().into())
|
2020-07-30 16:14:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
get("/_matrix/client/r0/joined_rooms", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-10-21 19:28:02 +00:00
|
|
|
pub async fn joined_rooms_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
|
|
|
|
body: Ruma<joined_rooms::Request>,
|
|
|
|
|
) -> ConduitResult<joined_rooms::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
|
|
|
|
Ok(joined_rooms::Response {
|
|
|
|
|
joined_rooms: db
|
|
|
|
|
.rooms
|
2020-10-18 18:33:12 +00:00
|
|
|
.rooms_joined(&sender_user)
|
2020-07-30 16:14:47 +00:00
|
|
|
.filter_map(|r| r.ok())
|
|
|
|
|
.collect(),
|
|
|
|
|
}
|
|
|
|
|
.into())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
get("/_matrix/client/r0/rooms/<_>/members", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-10-21 19:28:02 +00:00
|
|
|
pub async fn get_member_events_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<get_member_events::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<get_member_events::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
2020-10-18 18:33:12 +00:00
|
|
|
if !db.rooms.is_joined(sender_user, &body.room_id)? {
|
2020-07-30 16:14:47 +00:00
|
|
|
return Err(Error::BadRequest(
|
|
|
|
|
ErrorKind::Forbidden,
|
|
|
|
|
"You don't have permission to view this room.",
|
|
|
|
|
));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ok(get_member_events::Response {
|
|
|
|
|
chunk: db
|
|
|
|
|
.rooms
|
2020-12-19 15:00:11 +00:00
|
|
|
.room_state_full(&body.room_id)?
|
|
|
|
|
.iter()
|
|
|
|
|
.filter(|(key, _)| key.0 == EventType::RoomMember)
|
|
|
|
|
.map(|(_, pdu)| pdu.to_member_event())
|
2020-07-30 16:14:47 +00:00
|
|
|
.collect(),
|
|
|
|
|
}
|
|
|
|
|
.into())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
|
feature = "conduit_bin",
|
|
|
|
|
get("/_matrix/client/r0/rooms/<_>/joined_members", data = "<body>")
|
|
|
|
|
)]
|
2021-02-28 11:41:03 +00:00
|
|
|
#[tracing::instrument(skip(db, body))]
|
2020-10-21 19:28:02 +00:00
|
|
|
pub async fn joined_members_route(
|
2020-07-30 16:14:47 +00:00
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<joined_members::Request<'_>>,
|
2020-07-30 16:14:47 +00:00
|
|
|
) -> ConduitResult<joined_members::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
2020-07-30 16:14:47 +00:00
|
|
|
|
|
|
|
|
if !db
|
|
|
|
|
.rooms
|
2020-10-18 18:33:12 +00:00
|
|
|
.is_joined(&sender_user, &body.room_id)
|
2020-07-30 16:14:47 +00:00
|
|
|
.unwrap_or(false)
|
|
|
|
|
{
|
|
|
|
|
return Err(Error::BadRequest(
|
|
|
|
|
ErrorKind::Forbidden,
|
|
|
|
|
"You aren't a member of the room.",
|
|
|
|
|
));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let mut joined = BTreeMap::new();
|
|
|
|
|
for user_id in db.rooms.room_members(&body.room_id).filter_map(|r| r.ok()) {
|
|
|
|
|
let display_name = db.users.displayname(&user_id)?;
|
|
|
|
|
let avatar_url = db.users.avatar_url(&user_id)?;
|
|
|
|
|
|
|
|
|
|
joined.insert(
|
|
|
|
|
user_id,
|
|
|
|
|
joined_members::RoomMember {
|
|
|
|
|
display_name,
|
|
|
|
|
avatar_url,
|
|
|
|
|
},
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ok(joined_members::Response { joined }.into())
|
|
|
|
|
}
|
2020-08-19 23:30:28 +00:00
|
|
|
|
2021-03-13 15:30:12 +00:00
|
|
|
#[tracing::instrument(skip(db))]
|
2020-08-19 23:30:28 +00:00
|
|
|
async fn join_room_by_id_helper(
|
|
|
|
|
db: &Database,
|
2020-10-18 18:33:12 +00:00
|
|
|
sender_user: Option<&UserId>,
|
2020-08-19 23:30:28 +00:00
|
|
|
room_id: &RoomId,
|
2020-09-14 09:00:31 +00:00
|
|
|
servers: &[Box<ServerName>],
|
2020-08-19 23:30:28 +00:00
|
|
|
_third_party_signed: Option<&IncomingThirdPartySigned>,
|
|
|
|
|
) -> ConduitResult<join_room_by_id::Response> {
|
2020-10-18 18:33:12 +00:00
|
|
|
let sender_user = sender_user.expect("user is authenticated");
|
2020-08-19 23:30:28 +00:00
|
|
|
|
|
|
|
|
// Ask a remote server if we don't have this room
|
|
|
|
|
if !db.rooms.exists(&room_id)? && room_id.server_name() != db.globals.server_name() {
|
2020-09-14 09:00:31 +00:00
|
|
|
let mut make_join_response_and_server = Err(Error::BadServerResponse(
|
|
|
|
|
"No server available to assist in joining.",
|
|
|
|
|
));
|
|
|
|
|
|
|
|
|
|
for remote_server in servers {
|
2020-12-19 15:00:11 +00:00
|
|
|
let make_join_response = db
|
|
|
|
|
.sending
|
|
|
|
|
.send_federation_request(
|
|
|
|
|
&db.globals,
|
2021-01-14 19:39:56 +00:00
|
|
|
remote_server,
|
2020-12-19 15:00:11 +00:00
|
|
|
federation::membership::create_join_event_template::v1::Request {
|
|
|
|
|
room_id,
|
|
|
|
|
user_id: sender_user,
|
|
|
|
|
ver: &[RoomVersionId::Version5, RoomVersionId::Version6],
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
.await;
|
2020-09-14 09:00:31 +00:00
|
|
|
|
|
|
|
|
make_join_response_and_server = make_join_response.map(|r| (r, remote_server));
|
|
|
|
|
|
|
|
|
|
if make_join_response_and_server.is_ok() {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let (make_join_response, remote_server) = make_join_response_and_server?;
|
2020-08-19 23:30:28 +00:00
|
|
|
|
2020-11-30 17:10:33 +00:00
|
|
|
let mut join_event_stub =
|
|
|
|
|
serde_json::from_str::<CanonicalJsonObject>(make_join_response.event.json().get())
|
2020-08-19 23:30:28 +00:00
|
|
|
.map_err(|_| {
|
|
|
|
|
Error::BadServerResponse("Invalid make_join event json received from server.")
|
|
|
|
|
})?;
|
|
|
|
|
|
|
|
|
|
join_event_stub.insert(
|
|
|
|
|
"origin".to_owned(),
|
2020-11-30 17:10:33 +00:00
|
|
|
to_canonical_value(db.globals.server_name())
|
|
|
|
|
.map_err(|_| Error::bad_database("Invalid server name found"))?,
|
2020-08-19 23:30:28 +00:00
|
|
|
);
|
|
|
|
|
join_event_stub.insert(
|
|
|
|
|
"origin_server_ts".to_owned(),
|
2020-11-30 17:10:33 +00:00
|
|
|
to_canonical_value(utils::millis_since_unix_epoch())
|
|
|
|
|
.expect("Timestamp is valid js_int value"),
|
2020-08-19 23:30:28 +00:00
|
|
|
);
|
2020-10-17 09:24:57 +00:00
|
|
|
join_event_stub.insert(
|
|
|
|
|
"content".to_owned(),
|
2020-11-30 17:10:33 +00:00
|
|
|
to_canonical_value(member::MemberEventContent {
|
2020-10-17 09:24:57 +00:00
|
|
|
membership: member::MembershipState::Join,
|
2020-10-18 18:33:12 +00:00
|
|
|
displayname: db.users.displayname(&sender_user)?,
|
|
|
|
|
avatar_url: db.users.avatar_url(&sender_user)?,
|
2020-10-17 09:24:57 +00:00
|
|
|
is_direct: None,
|
|
|
|
|
third_party_invite: None,
|
|
|
|
|
})
|
|
|
|
|
.expect("event is valid, we just created it"),
|
|
|
|
|
);
|
2020-08-19 23:30:28 +00:00
|
|
|
|
2020-11-08 18:54:59 +00:00
|
|
|
// We don't leave the event id in the pdu because that's only allowed in v1 or v2 rooms
|
2020-11-30 17:10:33 +00:00
|
|
|
join_event_stub.remove("event_id");
|
2020-08-19 23:30:28 +00:00
|
|
|
|
2020-11-08 18:49:02 +00:00
|
|
|
// In order to create a compatible ref hash (EventID) the `hashes` field needs to be present
|
2020-08-19 23:30:28 +00:00
|
|
|
ruma::signatures::hash_and_sign_event(
|
|
|
|
|
db.globals.server_name().as_str(),
|
|
|
|
|
db.globals.keypair(),
|
2020-11-30 17:10:33 +00:00
|
|
|
&mut join_event_stub,
|
2020-10-27 23:10:09 +00:00
|
|
|
&RoomVersionId::Version6,
|
2020-08-19 23:30:28 +00:00
|
|
|
)
|
|
|
|
|
.expect("event is valid, we just created it");
|
|
|
|
|
|
2020-11-08 18:49:02 +00:00
|
|
|
// Generate event id
|
|
|
|
|
let event_id = EventId::try_from(&*format!(
|
|
|
|
|
"${}",
|
2020-11-30 17:10:33 +00:00
|
|
|
ruma::signatures::reference_hash(&join_event_stub, &RoomVersionId::Version6)
|
2020-11-08 18:49:02 +00:00
|
|
|
.expect("ruma can calculate reference hashes")
|
|
|
|
|
))
|
|
|
|
|
.expect("ruma's reference hashes are valid event ids");
|
|
|
|
|
|
2020-10-17 09:24:57 +00:00
|
|
|
// Add event_id back
|
2020-11-30 17:10:33 +00:00
|
|
|
join_event_stub.insert(
|
2020-10-27 23:10:09 +00:00
|
|
|
"event_id".to_owned(),
|
2020-11-30 17:10:33 +00:00
|
|
|
to_canonical_value(&event_id).expect("EventId is a valid CanonicalJsonValue"),
|
2020-10-27 23:10:09 +00:00
|
|
|
);
|
2020-10-17 09:24:57 +00:00
|
|
|
|
|
|
|
|
// It has enough fields to be called a proper event now
|
2020-11-30 17:10:33 +00:00
|
|
|
let join_event = join_event_stub;
|
2020-10-17 09:24:57 +00:00
|
|
|
|
2020-12-19 15:00:11 +00:00
|
|
|
let send_join_response = db
|
|
|
|
|
.sending
|
|
|
|
|
.send_federation_request(
|
|
|
|
|
&db.globals,
|
2021-01-14 19:39:56 +00:00
|
|
|
remote_server,
|
2020-12-19 15:00:11 +00:00
|
|
|
federation::membership::create_join_event::v2::Request {
|
|
|
|
|
room_id,
|
|
|
|
|
event_id: &event_id,
|
|
|
|
|
pdu: PduEvent::convert_to_outgoing_federation_event(join_event.clone()),
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
.await?;
|
2020-08-19 23:30:28 +00:00
|
|
|
|
2020-11-30 17:10:33 +00:00
|
|
|
let add_event_id = |pdu: &Raw<Pdu>| -> Result<(EventId, CanonicalJsonObject)> {
|
2021-03-23 18:46:54 +00:00
|
|
|
let mut value = serde_json::from_str(pdu.json().get()).map_err(|e| {
|
|
|
|
|
error!("{:?}: {:?}", pdu, e);
|
|
|
|
|
Error::BadServerResponse("Invalid PDU in server response")
|
|
|
|
|
})?;
|
2020-09-13 20:24:36 +00:00
|
|
|
let event_id = EventId::try_from(&*format!(
|
|
|
|
|
"${}",
|
2020-10-27 23:10:09 +00:00
|
|
|
ruma::signatures::reference_hash(&value, &RoomVersionId::Version6)
|
2020-09-13 20:24:36 +00:00
|
|
|
.expect("ruma can calculate reference hashes")
|
|
|
|
|
))
|
|
|
|
|
.expect("ruma's reference hashes are valid event ids");
|
|
|
|
|
|
2020-10-27 23:10:09 +00:00
|
|
|
value.insert(
|
|
|
|
|
"event_id".to_owned(),
|
2020-11-30 17:10:33 +00:00
|
|
|
to_canonical_value(&event_id)
|
2020-10-27 23:10:09 +00:00
|
|
|
.expect("a valid EventId can be converted to CanonicalJsonValue"),
|
|
|
|
|
);
|
2020-09-13 20:24:36 +00:00
|
|
|
|
2020-11-30 17:10:33 +00:00
|
|
|
Ok((event_id, value))
|
2020-09-13 20:24:36 +00:00
|
|
|
};
|
|
|
|
|
|
2021-03-13 15:30:12 +00:00
|
|
|
let count = db.globals.next_count()?;
|
2020-09-13 20:24:36 +00:00
|
|
|
|
2021-03-13 15:30:12 +00:00
|
|
|
let mut pdu_id = room_id.as_bytes().to_vec();
|
|
|
|
|
pdu_id.push(0xff);
|
|
|
|
|
pdu_id.extend_from_slice(&count.to_be_bytes());
|
2020-09-13 20:24:36 +00:00
|
|
|
|
2021-03-13 15:30:12 +00:00
|
|
|
let pdu = PduEvent::from_id_val(&event_id, join_event.clone())
|
|
|
|
|
.map_err(|_| Error::BadServerResponse("Invalid PDU in send_join response."))?;
|
|
|
|
|
|
2021-03-25 22:55:40 +00:00
|
|
|
let mut state = BTreeMap::new();
|
2021-03-13 15:30:12 +00:00
|
|
|
|
|
|
|
|
for pdu in send_join_response
|
2020-08-19 23:30:28 +00:00
|
|
|
.room_state
|
2021-03-13 15:30:12 +00:00
|
|
|
.state
|
2020-08-19 23:30:28 +00:00
|
|
|
.iter()
|
2021-03-13 15:30:12 +00:00
|
|
|
.map(add_event_id)
|
2020-09-13 20:24:36 +00:00
|
|
|
.map(|r| {
|
|
|
|
|
let (event_id, value) = r?;
|
2020-12-31 13:40:49 +00:00
|
|
|
PduEvent::from_id_val(&event_id, value.clone())
|
2020-09-13 20:24:36 +00:00
|
|
|
.map(|ev| (event_id, Arc::new(ev)))
|
2020-09-12 19:30:07 +00:00
|
|
|
.map_err(|e| {
|
2020-11-30 17:10:33 +00:00
|
|
|
warn!("{:?}: {}", value, e);
|
2020-11-08 18:49:02 +00:00
|
|
|
Error::BadServerResponse("Invalid PDU in send_join response.")
|
2020-09-12 19:30:07 +00:00
|
|
|
})
|
2020-08-19 23:30:28 +00:00
|
|
|
})
|
2021-03-13 15:30:12 +00:00
|
|
|
{
|
|
|
|
|
let (id, pdu) = pdu?;
|
|
|
|
|
info!("adding {} to outliers: {:#?}", id, pdu);
|
|
|
|
|
db.rooms.add_pdu_outlier(&pdu)?;
|
|
|
|
|
if let Some(state_key) = &pdu.state_key {
|
|
|
|
|
if pdu.kind == EventType::RoomMember {
|
|
|
|
|
let target_user_id = UserId::try_from(state_key.clone()).map_err(|_| {
|
|
|
|
|
Error::BadServerResponse("Invalid user id in send_join response.")
|
|
|
|
|
})?;
|
|
|
|
|
|
|
|
|
|
// Update our membership info, we do this here incase a user is invited
|
|
|
|
|
// and immediately leaves we need the DB to record the invite event for auth
|
|
|
|
|
db.rooms.update_membership(
|
|
|
|
|
&pdu.room_id,
|
|
|
|
|
&target_user_id,
|
|
|
|
|
serde_json::from_value::<member::MemberEventContent>(pdu.content.clone())
|
|
|
|
|
.map_err(|_| {
|
|
|
|
|
Error::BadRequest(
|
|
|
|
|
ErrorKind::InvalidParam,
|
|
|
|
|
"Invalid member event content.",
|
|
|
|
|
)
|
|
|
|
|
})?,
|
|
|
|
|
&pdu.sender,
|
|
|
|
|
&db.account_data,
|
|
|
|
|
&db.globals,
|
|
|
|
|
)?;
|
|
|
|
|
}
|
2021-03-17 21:30:25 +00:00
|
|
|
state.insert((pdu.kind.clone(), state_key.clone()), pdu.event_id.clone());
|
2021-03-13 15:30:12 +00:00
|
|
|
}
|
|
|
|
|
}
|
2020-08-22 01:44:55 +00:00
|
|
|
|
2021-03-13 15:30:12 +00:00
|
|
|
state.insert(
|
|
|
|
|
(
|
|
|
|
|
pdu.kind.clone(),
|
|
|
|
|
pdu.state_key.clone().expect("join event has state key"),
|
|
|
|
|
),
|
2021-03-17 21:30:25 +00:00
|
|
|
pdu.event_id.clone(),
|
2020-08-21 21:19:18 +00:00
|
|
|
);
|
2020-08-19 23:30:28 +00:00
|
|
|
|
2021-03-13 15:30:12 +00:00
|
|
|
db.rooms.force_state(room_id, state, &db.globals)?;
|
2020-08-30 20:08:47 +00:00
|
|
|
|
2021-03-13 15:30:12 +00:00
|
|
|
for pdu in send_join_response
|
|
|
|
|
.room_state
|
|
|
|
|
.auth_chain
|
2020-08-30 20:08:47 +00:00
|
|
|
.iter()
|
2021-03-13 15:30:12 +00:00
|
|
|
.map(add_event_id)
|
|
|
|
|
.map(|r| {
|
|
|
|
|
let (event_id, value) = r?;
|
|
|
|
|
PduEvent::from_id_val(&event_id, value.clone())
|
|
|
|
|
.map(|ev| (event_id, Arc::new(ev)))
|
|
|
|
|
.map_err(|e| {
|
|
|
|
|
warn!("{:?}: {}", value, e);
|
|
|
|
|
Error::BadServerResponse("Invalid PDU in send_join response.")
|
|
|
|
|
})
|
|
|
|
|
})
|
2020-08-30 20:08:47 +00:00
|
|
|
{
|
2021-03-13 15:30:12 +00:00
|
|
|
let (id, pdu) = pdu?;
|
|
|
|
|
info!("adding {} to outliers: {:#?}", id, pdu);
|
|
|
|
|
db.rooms.add_pdu_outlier(&pdu)?;
|
2020-08-19 23:30:28 +00:00
|
|
|
}
|
2021-03-13 15:30:12 +00:00
|
|
|
|
2021-03-23 21:31:19 +00:00
|
|
|
// We append to state before appending the pdu, so we don't have a moment in time with the
|
|
|
|
|
// pdu without it's state. This is okay because append_pdu can't fail.
|
|
|
|
|
let statehashid = db.rooms.append_to_state(&pdu, &db.globals)?;
|
|
|
|
|
|
2021-03-13 15:30:12 +00:00
|
|
|
db.rooms.append_pdu(
|
|
|
|
|
&pdu,
|
|
|
|
|
utils::to_canonical_object(&pdu).expect("Pdu is valid canonical object"),
|
|
|
|
|
db.globals.next_count()?,
|
|
|
|
|
pdu_id.into(),
|
|
|
|
|
&[pdu.event_id.clone()],
|
|
|
|
|
db,
|
|
|
|
|
)?;
|
2021-03-23 21:31:19 +00:00
|
|
|
|
|
|
|
|
// We set the room state after inserting the pdu, so that we never have a moment in time
|
|
|
|
|
// where events in the current room state do not exist
|
|
|
|
|
db.rooms.set_room_state(&room_id, statehashid)?;
|
2020-09-12 19:30:07 +00:00
|
|
|
} else {
|
|
|
|
|
let event = member::MemberEventContent {
|
|
|
|
|
membership: member::MembershipState::Join,
|
2020-10-18 18:33:12 +00:00
|
|
|
displayname: db.users.displayname(&sender_user)?,
|
|
|
|
|
avatar_url: db.users.avatar_url(&sender_user)?,
|
2020-09-12 19:30:07 +00:00
|
|
|
is_direct: None,
|
|
|
|
|
third_party_invite: None,
|
|
|
|
|
};
|
2020-08-19 23:30:28 +00:00
|
|
|
|
2020-10-05 20:19:22 +00:00
|
|
|
db.rooms.build_and_append_pdu(
|
|
|
|
|
PduBuilder {
|
|
|
|
|
event_type: EventType::RoomMember,
|
|
|
|
|
content: serde_json::to_value(event).expect("event is valid, we just created it"),
|
|
|
|
|
unsigned: None,
|
2020-10-18 18:33:12 +00:00
|
|
|
state_key: Some(sender_user.to_string()),
|
2020-10-05 20:19:22 +00:00
|
|
|
redacts: None,
|
|
|
|
|
},
|
2020-10-18 18:33:12 +00:00
|
|
|
&sender_user,
|
2020-10-05 20:19:22 +00:00
|
|
|
&room_id,
|
2021-01-15 16:05:57 +00:00
|
|
|
&db,
|
2020-10-05 20:19:22 +00:00
|
|
|
)?;
|
2020-09-12 19:30:07 +00:00
|
|
|
}
|
2020-08-19 23:30:28 +00:00
|
|
|
|
|
|
|
|
Ok(join_room_by_id::Response::new(room_id.clone()).into())
|
|
|
|
|
}
|
