magmaus3/continuwuity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Upgrade Ruma

Browse source
This commit is contained in:
Jonas Platte 2021-11-26 20:36:40 +01:00
parent 1fc616320a
commit 892a0525f2
No known key found for this signature in database
GPG key ID: CC154DE0E30B7C67
25 changed files with 297 additions and 304 deletions
Download patch file Download diff file Expand all files Collapse all files

15
src/client_server/account.rs
View file

@ -11,10 +11,9 @@ use ruma::{
error::ErrorKind,
r0::{
account::{
change_password, deactivate, get_username_availability, register, whoami,
ThirdPartyIdRemovalStatus,
change_password, deactivate, get_3pids, get_username_availability, register,
whoami, ThirdPartyIdRemovalStatus,
},
contact::get_contacts,
uiaa::{AuthFlow, AuthType, UiaaInfo},
},
},
@ -282,7 +281,7 @@ pub async fn register_route(
let mut content = RoomCreateEventContent::new(conduit_user.clone());
content.federate = true;
content.predecessor = None;
content.room_version = RoomVersionId::Version6;
content.room_version = RoomVersionId::V6;
// 1. The room create event
db.rooms.build_and_append_pdu(
@ -433,7 +432,7 @@ pub async fn register_route(
)?;
// Room alias
let alias: RoomAliasId = format!("#admins:{}", db.globals.server_name())
let alias: Box<RoomAliasId> = format!("#admins:{}", db.globals.server_name())
.try_into()
.expect("#admins:server_name is a valid alias name");
@ -757,9 +756,9 @@ pub async fn deactivate_route(
get("/_matrix/client/r0/account/3pid", data = "<body>")
)]
pub async fn third_party_route(
body: Ruma<get_contacts::Request>,
) -> ConduitResult<get_contacts::Response> {
body: Ruma<get_3pids::Request>,
) -> ConduitResult<get_3pids::Response> {
let _sender_user = body.sender_user.as_ref().expect("user is authenticated");
Ok(get_contacts::Response::new(Vec::new()).into())
Ok(get_3pids::Response::new(Vec::new()).into())
}

6
src/client_server/capabilities.rs
View file

@ -22,12 +22,12 @@ pub async fn get_capabilities_route(
_body: Ruma<get_capabilities::Request>,
) -> ConduitResult<get_capabilities::Response> {
let mut available = BTreeMap::new();
available.insert(RoomVersionId::Version5, RoomVersionStability::Stable);
available.insert(RoomVersionId::Version6, RoomVersionStability::Stable);
available.insert(RoomVersionId::V5, RoomVersionStability::Stable);
available.insert(RoomVersionId::V6, RoomVersionStability::Stable);
let mut capabilities = Capabilities::new();
capabilities.room_versions = RoomVersionsCapability {
default: RoomVersionId::Version6,
default: RoomVersionId::V6,
available,
};

2
src/client_server/directory.rs
View file

@ -167,7 +167,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
other_server,
federation::directory::get_public_rooms_filtered::v1::Request {
limit,
since: since.as_deref(),
since,
filter: Filter {
generic_search_term: filter.generic_search_term.as_deref(),
},

22
src/client_server/keys.rs
View file

@ -316,7 +316,7 @@ pub async fn get_key_changes_route(
pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
sender_user: Option<&UserId>,
device_keys_input: &BTreeMap<UserId, Vec<Box<DeviceId>>>,
device_keys_input: &BTreeMap<Box<UserId>, Vec<Box<DeviceId>>>,
allowed_signatures: F,
db: &Database,
) -> Result<get_keys::Response> {
@ -328,6 +328,8 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
let mut get_over_federation = HashMap::new();
for (user_id, device_ids) in device_keys_input {
let user_id: &UserId = &**user_id;
if user_id.server_name() != db.globals.server_name() {
get_over_federation
.entry(user_id.server_name())
@ -355,11 +357,11 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
container.insert(device_id, keys);
}
}
device_keys.insert(user_id.clone(), container);
device_keys.insert(user_id.to_owned(), container);
} else {
for device_id in device_ids {
let mut container = BTreeMap::new();
if let Some(mut keys) = db.users.get_device_keys(&user_id.clone(), device_id)? {
if let Some(mut keys) = db.users.get_device_keys(user_id, device_id)? {
let metadata = db.users.get_device_metadata(user_id, device_id)?.ok_or(
Error::BadRequest(
ErrorKind::InvalidParam,
@ -371,24 +373,24 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
device_display_name: metadata.display_name,
};
container.insert(device_id.clone(), keys);
container.insert(device_id.to_owned(), keys);
}
device_keys.insert(user_id.clone(), container);
device_keys.insert(user_id.to_owned(), container);
}
}
if let Some(master_key) = db.users.get_master_key(user_id, &allowed_signatures)? {
master_keys.insert(user_id.clone(), master_key);
master_keys.insert(user_id.to_owned(), master_key);
}
if let Some(self_signing_key) = db
.users
.get_self_signing_key(user_id, &allowed_signatures)?
{
self_signing_keys.insert(user_id.clone(), self_signing_key);
self_signing_keys.insert(user_id.to_owned(), self_signing_key);
}
if Some(user_id) == sender_user {
if let Some(user_signing_key) = db.users.get_user_signing_key(user_id)? {
user_signing_keys.insert(user_id.clone(), user_signing_key);
user_signing_keys.insert(user_id.to_owned(), user_signing_key);
}
}
}
@ -400,7 +402,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
.map(|(server, vec)| async move {
let mut device_keys_input_fed = BTreeMap::new();
for (user_id, keys) in vec {
device_keys_input_fed.insert(user_id.clone(), keys.clone());
device_keys_input_fed.insert(user_id.to_owned(), keys.clone());
}
(
server,
@ -440,7 +442,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
}
pub(crate) async fn claim_keys_helper(
one_time_keys_input: &BTreeMap<UserId, BTreeMap<Box<DeviceId>, DeviceKeyAlgorithm>>,
one_time_keys_input: &BTreeMap<Box<UserId>, BTreeMap<Box<DeviceId>, DeviceKeyAlgorithm>>,
db: &Database,
) -> Result<claim_keys::Response> {
let mut one_time_keys = BTreeMap::new();

41
src/client_server/membership.rs
View file

@ -64,7 +64,7 @@ pub async fn join_room_by_id_route(
.filter_map(|event| serde_json::from_str(event.json().get()).ok())
.filter_map(|event: serde_json::Value| event.get("sender").cloned())
.filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
.filter_map(|sender| UserId::try_from(sender).ok())
.filter_map(|sender| Box::<UserId>::try_from(sender).ok())
.map(|user| user.server_name().to_owned())
.collect();
@ -72,7 +72,7 @@ pub async fn join_room_by_id_route(
let ret = join_room_by_id_helper(
&db,
body.sender_user.as_ref(),
body.sender_user.as_deref(),
&body.room_id,
&servers,
body.third_party_signed.as_ref(),
@ -101,7 +101,7 @@ pub async fn join_room_by_id_or_alias_route(
) -> ConduitResult<join_room_by_id_or_alias::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let (servers, room_id) = match RoomId::try_from(body.room_id_or_alias.clone()) {
let (servers, room_id) = match Box::<RoomId>::try_from(body.room_id_or_alias.clone()) {
Ok(room_id) => {
let mut servers: HashSet<_> = db
.rooms
@ -111,7 +111,7 @@ pub async fn join_room_by_id_or_alias_route(
.filter_map(|event| serde_json::from_str(event.json().get()).ok())
.filter_map(|event: serde_json::Value| event.get("sender").cloned())
.filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
.filter_map(|sender| UserId::try_from(sender).ok())
.filter_map(|sender| Box::<UserId>::try_from(sender).ok())
.map(|user| user.server_name().to_owned())
.collect();
@ -127,7 +127,7 @@ pub async fn join_room_by_id_or_alias_route(
let join_room_response = join_room_by_id_helper(
&db,
body.sender_user.as_ref(),
body.sender_user.as_deref(),
&room_id,
&servers,
body.third_party_signed.as_ref(),
@ -531,7 +531,7 @@ async fn join_room_by_id_helper(
.roomid_mutex_state
.write()
.unwrap()
.entry(room_id.clone())
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;
@ -551,7 +551,7 @@ async fn join_room_by_id_helper(
federation::membership::create_join_event_template::v1::Request {
room_id,
user_id: sender_user,
ver: &[RoomVersionId::Version5, RoomVersionId::Version6],
ver: &[RoomVersionId::V5, RoomVersionId::V6],
},
)
.await;
@ -567,8 +567,7 @@ async fn join_room_by_id_helper(
let room_version = match make_join_response.room_version {
Some(room_version)
if room_version == RoomVersionId::Version5
|| room_version == RoomVersionId::Version6 =>
if room_version == RoomVersionId::V5 || room_version == RoomVersionId::V6 =>
{
room_version
}
@ -620,7 +619,7 @@ async fn join_room_by_id_helper(
.expect("event is valid, we just created it");
// Generate event id
let event_id = EventId::try_from(&*format!(
let event_id = Box::<EventId>::try_from(&*format!(
"${}",
ruma::signatures::reference_hash(&join_event_stub, &room_version)
.expect("ruma can calculate reference hashes")
@ -776,7 +775,7 @@ async fn join_room_by_id_helper(
db.flush()?;
Ok(join_room_by_id::Response::new(room_id.clone()).into())
Ok(join_room_by_id::Response::new(room_id.to_owned()).into())
}
fn validate_and_add_event_id(
@ -784,12 +783,12 @@ fn validate_and_add_event_id(
room_version: &RoomVersionId,
pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, String>>>,
db: &Database,
) -> Result<(EventId, CanonicalJsonObject)> {
) -> Result<(Box<EventId>, CanonicalJsonObject)> {
let mut value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
error!("Invalid PDU in server response: {:?}: {:?}", pdu, e);
Error::BadServerResponse("Invalid PDU in server response")
})?;
let event_id = EventId::try_from(&*format!(
let event_id = Box::<EventId>::try_from(&*format!(
"${}",
ruma::signatures::reference_hash(&value, room_version)
.expect("ruma can calculate reference hashes")
@ -856,7 +855,7 @@ pub(crate) async fn invite_helper<'a>(
.roomid_mutex_state
.write()
.unwrap()
.entry(room_id.clone())
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;
@ -892,9 +891,7 @@ pub(crate) async fn invite_helper<'a>(
// If there was no create event yet, assume we are creating a version 6 room right now
let room_version_id = create_event_content
.map_or(RoomVersionId::Version6, |create_event| {
create_event.room_version
});
.map_or(RoomVersionId::V6, |create_event| create_event.room_version);
let room_version =
RoomVersion::new(&room_version_id).expect("room version is supported");
@ -939,9 +936,9 @@ pub(crate) async fn invite_helper<'a>(
}
let pdu = PduEvent {
event_id: ruma::event_id!("$thiswillbefilledinlater"),
room_id: room_id.clone(),
sender: sender_user.clone(),
event_id: ruma::event_id!("$thiswillbefilledinlater").to_owned(),
room_id: room_id.to_owned(),
sender: sender_user.to_owned(),
origin_server_ts: utils::millis_since_unix_epoch()
.try_into()
.expect("time is valid"),
@ -1014,7 +1011,7 @@ pub(crate) async fn invite_helper<'a>(
};
// Generate event id
let expected_event_id = EventId::try_from(&*format!(
let expected_event_id = Box::<EventId>::try_from(&*format!(
"${}",
ruma::signatures::reference_hash(&pdu_json, &room_version_id)
.expect("ruma can calculate reference hashes")
@ -1100,7 +1097,7 @@ pub(crate) async fn invite_helper<'a>(
.roomid_mutex_state
.write()
.unwrap()
.entry(room_id.clone())
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;

2
src/client_server/message.rs
View file

@ -67,7 +67,7 @@ pub async fn send_message_event_route(
));
}
let event_id = EventId::try_from(
let event_id = Box::<EventId>::try_from(
utils::string_from_bytes(&response)
.map_err(|_| Error::bad_database("Invalid txnid bytes in database."))?,
)

6
src/client_server/report.rs
View file

@ -57,8 +57,7 @@ pub async fn report_event_route(
Report Score: {}\n\
Report Reason: {}",
sender_user, pdu.event_id, pdu.room_id, pdu.sender, body.score, body.reason
)
.to_owned(),
),
format!(
"<details><summary>Report received from: <a href=\"https://matrix.to/#/{0}\">{0}\
</a></summary><ul><li>Event Info<ul><li>Event ID: <code>{1}</code>\
@ -72,8 +71,7 @@ pub async fn report_event_route(
pdu.sender,
body.score,
RawStr::new(&body.reason).html_escape()
)
.to_owned(),
),
),
));

26
src/client_server/room.rs
View file

@ -88,14 +88,17 @@ pub async fn create_room_route(
));
}
let alias: Option<RoomAliasId> =
let alias: Option<Box<RoomAliasId>> =
body.room_alias_name
.as_ref()
.map_or(Ok(None), |localpart| {
// TODO: Check for invalid characters and maximum length
let alias =
RoomAliasId::try_from(format!("#{}:{}", localpart, db.globals.server_name()))
.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
let alias = Box::<RoomAliasId>::try_from(format!(
"#{}:{}",
localpart,
db.globals.server_name(),
))
.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
if db.rooms.id_from_alias(&alias)?.is_some() {
Err(Error::BadRequest(
@ -109,7 +112,7 @@ pub async fn create_room_route(
let room_version = match body.room_version.clone() {
Some(room_version) => {
if room_version == RoomVersionId::Version5 || room_version == RoomVersionId::Version6 {
if room_version == RoomVersionId::V5 || room_version == RoomVersionId::V6 {
room_version
} else {
return Err(Error::BadRequest(
@ -118,7 +121,7 @@ pub async fn create_room_route(
));
}
}
None => RoomVersionId::Version6,
None => RoomVersionId::V6,
};
let content = match &body.creation_content {
@ -164,7 +167,7 @@ pub async fn create_room_route(
.get(),
);
if let Err(_) = de_result {
if de_result.is_err() {
return Err(Error::BadRequest(
ErrorKind::BadJson,
"Invalid creation content",
@ -269,7 +272,7 @@ pub async fn create_room_route(
PduBuilder {
event_type: EventType::RoomCanonicalAlias,
content: to_raw_value(&RoomCanonicalAliasEventContent {
alias: Some(room_alias_id.clone()),
alias: Some(room_alias_id.to_owned()),
alt_aliases: vec![],
})
.expect("We checked that alias earlier, it must be fine"),
@ -505,10 +508,7 @@ pub async fn upgrade_room_route(
) -> ConduitResult<upgrade_room::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !matches!(
body.new_version,
RoomVersionId::Version5 | RoomVersionId::Version6
) {
if !matches!(body.new_version, RoomVersionId::V5 | RoomVersionId::V6) {
return Err(Error::BadRequest(
ErrorKind::UnsupportedRoomVersion,
"This server does not support that room version.",
@ -605,7 +605,7 @@ pub async fn upgrade_room_route(
.get(),
);
if let Err(_) = de_result {
if de_result.is_err() {
return Err(Error::BadRequest(
ErrorKind::BadJson,
"Error forming creation event",

4
src/client_server/state.rs
View file

@ -267,7 +267,7 @@ async fn send_state_event_for_key_helper(
event_type: EventType,
json: &Raw<AnyStateEventContent>,
state_key: String,
) -> Result<EventId> {
) -> Result<Box<EventId>> {
let sender_user = sender;
// TODO: Review this check, error if event is unparsable, use event type, allow alias if it
@ -303,7 +303,7 @@ async fn send_state_event_for_key_helper(
.roomid_mutex_state
.write()
.unwrap()
.entry(room_id.clone())
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;

27
src/client_server/sync.rs
View file

@ -54,15 +54,17 @@ use rocket::{get, tokio};
/// `since` will be cached
#[cfg_attr(
feature = "conduit_bin",
get("/_matrix/client/r0/sync", data = "<body>")
get("/_matrix/client/r0/sync", data = "<req>")
)]
#[tracing::instrument(skip(db, body))]
#[tracing::instrument(skip(db, req))]
pub async fn sync_events_route(
db: DatabaseGuard,
body: Ruma<sync_events::Request<'_>>,
req: Ruma<sync_events::Request<'_>>,
) -> Result<RumaResponse<sync_events::Response>, RumaResponse<UiaaResponse>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device = body.sender_device.as_ref().expect("user is authenticated");
let body = req.body;
let sender_user = req.sender_user.expect("user is authenticated");
let sender_device = req.sender_device.expect("user is authenticated");
let arc_db = Arc::new(db);
@ -132,7 +134,7 @@ pub async fn sync_events_route(
async fn sync_helper_wrapper(
db: Arc<DatabaseGuard>,
sender_user: UserId,
sender_user: Box<UserId>,
sender_device: Box<DeviceId>,
since: Option<String>,
full_state: bool,
@ -176,7 +178,7 @@ async fn sync_helper_wrapper(
async fn sync_helper(
db: Arc<DatabaseGuard>,
sender_user: UserId,
sender_user: Box<UserId>,
sender_device: Box<DeviceId>,
since: Option<String>,
full_state: bool,
@ -296,9 +298,10 @@ async fn sync_helper(
})?;
if let Some(state_key) = &pdu.state_key {
let user_id = UserId::try_from(state_key.clone()).map_err(|_| {
Error::bad_database("Invalid UserId in member PDU.")
})?;
let user_id =
Box::<UserId>::try_from(state_key.clone()).map_err(|_| {
Error::bad_database("Invalid UserId in member PDU.")
})?;
// The membership was and still is invite or join
if matches!(
@ -424,7 +427,7 @@ async fn sync_helper(
}
if let Some(state_key) = &state_event.state_key {
let user_id = UserId::try_from(state_key.clone())
let user_id = Box::<UserId>::try_from(state_key.clone())
.map_err(|_| Error::bad_database("Invalid UserId in member PDU."))?;
if user_id == sender_user {
@ -793,7 +796,7 @@ fn share_encrypted_room(
) -> Result<bool> {
Ok(db
.rooms
.get_shared_rooms(vec![sender_user.clone(), user_id.clone()])?
.get_shared_rooms(vec![sender_user.to_owned(), user_id.to_owned()])?
.filter_map(|r| r.ok())
.filter(|room_id| room_id != ignore_room)
.filter_map(|other_room_id| {

2
src/client_server/voip.rs
View file

@ -26,7 +26,7 @@ pub async fn turn_server_route(
let turn_secret = db.globals.turn_secret();
let (username, password) = if turn_secret != "" {
let (username, password) = if !turn_secret.is_empty() {
let expiry = SecondsSinceUnixEpoch::from_system_time(
SystemTime::now() + Duration::from_secs(db.globals.turn_ttl()),
)