studio/tuwunel
2
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

fix and enable collapsible_if lint

Browse Source 
Signed-off-by: June Strawberry <june@vern.cc>
This commit is contained in:
June Strawberry
2026-01-15 17:39:33 -05:00
parent fb102f0e0a
commit 04e66a03d3
54 changed files with 453 additions and 504 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@@ -987,7 +987,6 @@ style = { level = "warn", priority = -1 }
assertions_on_constants = { level = "allow", priority = 1 } assertions_on_constants = { level = "allow", priority = 1 }
module_inception = { level = "allow", priority = 1 } module_inception = { level = "allow", priority = 1 }
obfuscated_if_else = { level = "allow", priority = 1 } obfuscated_if_else = { level = "allow", priority = 1 }
collapsible_if = { level = "allow", priority = 1 } # TODO stable v. nightly 05-21-25
toplevel-ref-arg = { level = "allow", priority = 1 } toplevel-ref-arg = { level = "allow", priority = 1 }
################### ###################

16
src/admin/query/resolver.rs
View File

@@ -35,10 +35,10 @@ async fn destinations_cache(&self, server_name: Option<OwnedServerName>) -> Resu
.boxed(); .boxed();
while let Some((name, CachedDest { dest, host, expire })) = destinations.next().await { while let Some((name, CachedDest { dest, host, expire })) = destinations.next().await {
if let Some(server_name) = server_name.as_ref() { if let Some(server_name) = server_name.as_ref()
if name != server_name { && name != server_name
continue; {
} continue;
} }
let expire = time::format(expire, "%+"); let expire = time::format(expire, "%+");
@@ -61,10 +61,10 @@ async fn overrides_cache(&self, server_name: Option<String>) -> Result {
while let Some((name, CachedOverride { ips, port, expire, overriding })) = while let Some((name, CachedOverride { ips, port, expire, overriding })) =
overrides.next().await overrides.next().await
{ {
if let Some(server_name) = server_name.as_ref() { if let Some(server_name) = server_name.as_ref()
if name != server_name { && name != server_name
continue; {
} continue;
} }
let expire = time::format(expire, "%+"); let expire = time::format(expire, "%+");

20
src/admin/room/moderation.rs
View File

@@ -50,10 +50,10 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result {
let admin_room_alias = &self.services.admin.admin_alias; let admin_room_alias = &self.services.admin.admin_alias;
if let Ok(admin_room_id) = self.services.admin.get_admin_room().await { if let Ok(admin_room_id) = self.services.admin.get_admin_room().await
if room.to_string().eq(&admin_room_id) || room.to_string().eq(admin_room_alias) { && (room.to_string().eq(&admin_room_id) || room.to_string().eq(admin_room_alias))
return Err!("Not allowed to ban the admin room."); {
} return Err!("Not allowed to ban the admin room.");
} }
let room_id = if room.is_room_id() { let room_id = if room.is_room_id() {
@@ -217,12 +217,12 @@ async fn ban_list_of_rooms(&self) -> Result {
for &room in &rooms_s { for &room in &rooms_s {
match <&RoomOrAliasId>::try_from(room) { match <&RoomOrAliasId>::try_from(room) {
| Ok(room_alias_or_id) => { | Ok(room_alias_or_id) => {
if let Ok(admin_room_id) = self.services.admin.get_admin_room().await { if let Ok(admin_room_id) = self.services.admin.get_admin_room().await
if room.to_owned().eq(&admin_room_id) || room.to_owned().eq(admin_room_alias) && (room.to_owned().eq(&admin_room_id)
{ || room.to_owned().eq(admin_room_alias))
warn!("User specified admin room in bulk ban list, ignoring"); {
continue; warn!("User specified admin room in bulk ban list, ignoring");
} continue;
} }
if room_alias_or_id.is_room_id() { if room_alias_or_id.is_room_id() {

8
src/admin/user/commands.rs
View File

@@ -49,10 +49,10 @@ pub(super) async fn create_user(&self, username: String, password: Option<String
// Validate user id // Validate user id
let user_id = parse_local_user_id(self.services, &username)?; let user_id = parse_local_user_id(self.services, &username)?;
if let Err(e) = user_id.validate_strict() { if let Err(e) = user_id.validate_strict()
if self.services.config.emergency_password.is_none() { && self.services.config.emergency_password.is_none()
return Err!("Username {user_id} contains disallowed characters or spaces: {e}"); {
} return Err!("Username {user_id} contains disallowed characters or spaces: {e}");
} }
if self.services.users.exists(&user_id).await { if self.services.users.exists(&user_id).await {

20
src/api/client/directory.rs
View File

@@ -301,30 +301,26 @@ pub(crate) async fn get_public_rooms_filtered_helper(
return None; return None;
} }
if let Some(query) = search_room_id { if let Some(query) = search_room_id
if chunk.room_id.as_str().contains(query) { && chunk.room_id.as_str().contains(query) {
return Some(chunk); return Some(chunk);
} }
}
if let Some(query) = search_term.as_deref() { if let Some(query) = search_term.as_deref() {
if let Some(name) = &chunk.name { if let Some(name) = &chunk.name
if name.as_str().to_lowercase().contains(query) { && name.as_str().to_lowercase().contains(query) {
return Some(chunk); return Some(chunk);
} }
}
if let Some(topic) = &chunk.topic { if let Some(topic) = &chunk.topic
if topic.to_lowercase().contains(query) { && topic.to_lowercase().contains(query) {
return Some(chunk); return Some(chunk);
} }
}
if let Some(canonical_alias) = &chunk.canonical_alias { if let Some(canonical_alias) = &chunk.canonical_alias
if canonical_alias.as_str().to_lowercase().contains(query) { && canonical_alias.as_str().to_lowercase().contains(query) {
return Some(chunk); return Some(chunk);
} }
}
return None; return None;
} }

8
src/api/client/keys.rs
View File

@@ -484,10 +484,10 @@ where
{ {
self_signing_keys.insert(user_id.to_owned(), self_signing_key); self_signing_keys.insert(user_id.to_owned(), self_signing_key);
} }
if Some(user_id) == sender_user { if Some(user_id) == sender_user
if let Ok(user_signing_key) = services.users.get_user_signing_key(user_id).await { && let Ok(user_signing_key) = services.users.get_user_signing_key(user_id).await
user_signing_keys.insert(user_id.to_owned(), user_signing_key); {
} user_signing_keys.insert(user_id.to_owned(), user_signing_key);
} }
} }

6
src/api/client/membership/invite.rs
View File

@@ -49,11 +49,9 @@ pub(crate) async fn invite_user_route(
if let Ok(target_user_membership) = services if let Ok(target_user_membership) = services
.state_accessor .state_accessor
.get_member(room_id, user_id) .get_member(room_id, user_id)
.await .await && target_user_membership.membership == MembershipState::Ban
{ {
if target_user_membership.membership == MembershipState::Ban { return Err!(Request(Forbidden("User is banned from this room.")));
return Err!(Request(Forbidden("User is banned from this room.")));
}
} }
if recipient_ignored_by_sender { if recipient_ignored_by_sender {

9
src/api/client/presence.rs
View File

@@ -48,14 +48,13 @@ pub(crate) async fn get_presence_route(
.user_sees_user(body.sender_user(), &body.user_id) .user_sees_user(body.sender_user(), &body.user_id)
.await; .await;
if has_shared_rooms { if has_shared_rooms
if let Ok(presence) = services && let Ok(presence) = services
.presence .presence
.get_presence(&body.user_id) .get_presence(&body.user_id)
.await .await
{ {
presence_event = Some(presence); presence_event = Some(presence);
}
} }
match presence_event { match presence_event {

8
src/api/client/register.rs
View File

@@ -93,10 +93,10 @@ pub(crate) async fn get_register_available_route(
return Err!(Request(UserInUse("User ID is not available."))); return Err!(Request(UserInUse("User ID is not available.")));
} }
if let Some(ref info) = body.appservice_info { if let Some(ref info) = body.appservice_info
if !info.is_user_match(&user_id) { && !info.is_user_match(&user_id)
return Err!(Request(Exclusive("Username is not in an appservice namespace."))); {
} return Err!(Request(Exclusive("Username is not in an appservice namespace.")));
} }
if services if services

16
src/api/client/room/create.rs
View File

@@ -446,10 +446,10 @@ async fn create_create_event(
)))) ))))
})?; })?;
if !services.config.federate_created_rooms { if !services.config.federate_created_rooms
if !services.config.allow_federation || !content.contains_key("m.federate") { && (!services.config.allow_federation || !content.contains_key("m.federate"))
content.insert("m.federate".into(), json!(false).try_into()?); {
} content.insert("m.federate".into(), json!(false).try_into()?);
} }
content.insert( content.insert(
@@ -578,10 +578,10 @@ async fn create_create_event_legacy(
}, },
} }
if !services.config.federate_created_rooms { if !services.config.federate_created_rooms
if !services.config.allow_federation || !content.contains_key("m.federate") { && (!services.config.allow_federation || !content.contains_key("m.federate"))
content.insert("m.federate".into(), json!(false).try_into()?); {
} content.insert("m.federate".into(), json!(false).try_into()?);
} }
content.insert( content.insert(

5
src/api/client/session/sso.rs
View File

@@ -646,8 +646,9 @@ async fn try_user_id(
fn parse_user_id(server_name: &ServerName, username: &str) -> Result<OwnedUserId> { fn parse_user_id(server_name: &ServerName, username: &str) -> Result<OwnedUserId> {
match UserId::parse_with_server_name(username, server_name) { match UserId::parse_with_server_name(username, server_name) {
| Err(e) => | Err(e) => {
Err!(Request(InvalidUsername(debug_error!("Username {username} is not valid: {e}")))), Err!(Request(InvalidUsername(debug_error!("Username {username} is not valid: {e}"))))
},
| Ok(user_id) => match user_id.validate_strict() { | Ok(user_id) => match user_id.validate_strict() {
| Ok(()) => Ok(user_id), | Ok(()) => Ok(user_id),
| Err(e) => Err!(Request(InvalidUsername(debug_error!( | Err(e) => Err!(Request(InvalidUsername(debug_error!(

12
src/api/client/space.rs
View File

@@ -45,12 +45,12 @@ pub(crate) async fn get_hierarchy_route(
.and_then(|s| PaginationToken::from_str(s).ok()); .and_then(|s| PaginationToken::from_str(s).ok());
// Should prevent unexpected behaviour in (bad) clients // Should prevent unexpected behaviour in (bad) clients
if let Some(ref token) = key { if let Some(ref token) = key
if token.suggested_only != body.suggested_only || token.max_depth != max_depth { && (token.suggested_only != body.suggested_only || token.max_depth != max_depth)
return Err!(Request(InvalidParam( {
"suggested_only and max_depth cannot change on paginated requests" return Err!(Request(InvalidParam(
))); "suggested_only and max_depth cannot change on paginated requests"
} )));
} }
get_client_hierarchy( get_client_hierarchy(

28
src/api/client/state.rs
View File

@@ -276,21 +276,21 @@ async fn allowed_to_send_state_event(
}, },
| StateEventType::RoomJoinRules => { | StateEventType::RoomJoinRules => {
// admin room is a sensitive room, it should not ever be made public // admin room is a sensitive room, it should not ever be made public
if let Ok(admin_room_id) = services.admin.get_admin_room().await { if let Ok(admin_room_id) = services.admin.get_admin_room().await
if admin_room_id == room_id { && admin_room_id == room_id
match json.deserialize_as_unchecked::<RoomJoinRulesEventContent>() { {
| Ok(join_rule) => match json.deserialize_as_unchecked::<RoomJoinRulesEventContent>() {
if join_rule.join_rule == JoinRule::Public { | Ok(join_rule) =>
return Err!(Request(Forbidden( if join_rule.join_rule == JoinRule::Public {
"Admin room is a sensitive room, it cannot be made public" return Err!(Request(Forbidden(
))); "Admin room is a sensitive room, it cannot be made public"
}, )));
| Err(e) => {
return Err!(Request(BadJson(debug_warn!(
"Room join rules event is invalid: {e}"
))));
}, },
} | Err(e) => {
return Err!(Request(BadJson(debug_warn!(
"Room join rules event is invalid: {e}"
))));
},
} }
} }
}, },

9
src/api/server/invite.rs
View File

@@ -51,14 +51,13 @@ pub(crate) async fn create_invite_route(
)); ));
} }
if let Some(server) = body.room_id.server_name() { if let Some(server) = body.room_id.server_name()
if services && services
.config .config
.forbidden_remote_server_names .forbidden_remote_server_names
.is_match(server.host()) .is_match(server.host())
{ {
return Err!(Request(Forbidden("Server is banned on this homeserver."))); return Err!(Request(Forbidden("Server is banned on this homeserver.")));
}
} }
if services if services

13
src/api/server/make_join.rs
View File

@@ -54,16 +54,15 @@ pub(crate) async fn create_join_event_template_route(
return Err!(Request(Forbidden("Server is banned on this homeserver."))); return Err!(Request(Forbidden("Server is banned on this homeserver.")));
} }
if let Some(server) = body.room_id.server_name() { if let Some(server) = body.room_id.server_name()
if services && services
.config .config
.forbidden_remote_server_names .forbidden_remote_server_names
.is_match(server.host()) .is_match(server.host())
{ {
return Err!(Request(Forbidden(warn!( return Err!(Request(Forbidden(warn!(
"Room ID server name {server} is banned on this homeserver." "Room ID server name {server} is banned on this homeserver."
)))); ))));
}
} }
let room_version_id = services let room_version_id = services

25
src/api/server/make_knock.rs
View File

@@ -46,14 +46,13 @@ pub(crate) async fn create_knock_event_template_route(
return Err!(Request(Forbidden("Server is banned on this homeserver."))); return Err!(Request(Forbidden("Server is banned on this homeserver.")));
} }
if let Some(server) = body.room_id.server_name() { if let Some(server) = body.room_id.server_name()
if services && services
.config .config
.forbidden_remote_server_names .forbidden_remote_server_names
.is_match(server.host()) .is_match(server.host())
{ {
return Err!(Request(Forbidden("Server is banned on this homeserver."))); return Err!(Request(Forbidden("Server is banned on this homeserver.")));
}
} }
let room_version = services let room_version = services
@@ -80,17 +79,15 @@ pub(crate) async fn create_knock_event_template_route(
if let Ok(membership) = services if let Ok(membership) = services
.state_accessor .state_accessor
.get_member(&body.room_id, &body.user_id) .get_member(&body.room_id, &body.user_id)
.await .await && membership.membership == MembershipState::Ban
{ {
if membership.membership == MembershipState::Ban { debug_warn!(
debug_warn!( "Remote user {} is banned from {} but attempted to knock",
"Remote user {} is banned from {} but attempted to knock", &body.user_id,
&body.user_id, &body.room_id
&body.room_id );
);
return Err!(Request(Forbidden("You cannot knock on a room you are banned from."))); return Err!(Request(Forbidden("You cannot knock on a room you are banned from.")));
}
} }
let pdu_json = services let pdu_json = services

8
src/api/server/send.rs
View File

@@ -115,10 +115,10 @@ pub(crate) async fn send_transaction_message_route(
"Finished txn", "Finished txn",
); );
for (id, result) in &results { for (id, result) in &results {
if let Err(e) = result { if let Err(e) = result
if matches!(e, Error::BadRequest(ErrorKind::NotFound, _)) { && matches!(e, Error::BadRequest(ErrorKind::NotFound, _))
warn!("Incoming PDU failed {id}: {e:?}"); {
} warn!("Incoming PDU failed {id}: {e:?}");
} }
} }

50
src/api/server/send_join.rs
View File

@@ -285,23 +285,22 @@ pub(crate) async fn create_join_event_v1_route(
return Err!(Request(Forbidden("Server is banned on this homeserver."))); return Err!(Request(Forbidden("Server is banned on this homeserver.")));
} }
if let Some(server) = body.room_id.server_name() { if let Some(server) = body.room_id.server_name()
if services && services
.config .config
.forbidden_remote_server_names .forbidden_remote_server_names
.is_match(server.host()) .is_match(server.host())
{ {
warn!( warn!(
"Server {} tried joining room ID {} through us which has a server name that is \ "Server {} tried joining room ID {} through us which has a server name that is \
globally forbidden. Rejecting.", globally forbidden. Rejecting.",
body.origin(), body.origin(),
&body.room_id, &body.room_id,
); );
return Err!(Request(Forbidden(warn!( return Err!(Request(Forbidden(warn!(
"Room ID server name {server} is banned on this homeserver." "Room ID server name {server} is banned on this homeserver."
)))); ))));
}
} }
Ok(create_join_event::v1::Response { Ok(create_join_event::v1::Response {
@@ -326,23 +325,22 @@ pub(crate) async fn create_join_event_v2_route(
return Err!(Request(Forbidden("Server is banned on this homeserver."))); return Err!(Request(Forbidden("Server is banned on this homeserver.")));
} }
if let Some(server) = body.room_id.server_name() { if let Some(server) = body.room_id.server_name()
if services && services
.config .config
.forbidden_remote_server_names .forbidden_remote_server_names
.is_match(server.host()) .is_match(server.host())
{ {
warn!( warn!(
"Server {} tried joining room ID {} through us which has a server name that is \ "Server {} tried joining room ID {} through us which has a server name that is \
globally forbidden. Rejecting.", globally forbidden. Rejecting.",
body.origin(), body.origin(),
&body.room_id, &body.room_id,
); );
return Err!(Request(Forbidden(warn!( return Err!(Request(Forbidden(warn!(
"Room ID server name {server} is banned on this homeserver." "Room ID server name {server} is banned on this homeserver."
)))); ))));
}
} }
let create_join_event::v1::RoomState { auth_chain, state, event } = let create_join_event::v1::RoomState { auth_chain, state, event } =

21
src/api/server/send_knock.rs
View File

@@ -39,20 +39,19 @@ pub(crate) async fn create_knock_event_v1_route(
return Err!(Request(Forbidden("Server is banned on this homeserver."))); return Err!(Request(Forbidden("Server is banned on this homeserver.")));
} }
if let Some(server) = body.room_id.server_name() { if let Some(server) = body.room_id.server_name()
if services && services
.config .config
.forbidden_remote_server_names .forbidden_remote_server_names
.is_match(server.host()) .is_match(server.host())
{ {
warn!( warn!(
"Server {} tried knocking room ID {} which has a server name that is globally \ "Server {} tried knocking room ID {} which has a server name that is globally \
forbidden. Rejecting.", forbidden. Rejecting.",
body.origin(), body.origin(),
&body.room_id, &body.room_id,
); );
return Err!(Request(Forbidden("Server is banned on this homeserver."))); return Err!(Request(Forbidden("Server is banned on this homeserver.")));
}
} }
if !services.metadata.exists(&body.room_id).await { if !services.metadata.exists(&body.room_id).await {

14
src/core/config/check.rs
View File

@@ -269,13 +269,13 @@ pub fn check(config: &Config) -> Result {
); );
} }
if let Some(Either::Right(_)) = config.url_preview_bound_interface.as_ref() { if let Some(Either::Right(_)) = config.url_preview_bound_interface.as_ref()
if !matches!(OS, "android" | "fuchsia" | "linux") { && !matches!(OS, "android" | "fuchsia" | "linux")
return Err!(Config( {
"url_preview_bound_interface", return Err!(Config(
"Not a valid IP address. Interface names not supported on {OS}." "url_preview_bound_interface",
)); "Not a valid IP address. Interface names not supported on {OS}."
} ));
} }
if !Server::available_room_versions() if !Server::available_room_versions()

10
src/core/info/rustc.rs
View File

@@ -53,13 +53,13 @@ fn append_features(features: &mut Vec<&'static str>, flags: &[&'static str]) {
for flag in flags { for flag in flags {
let is_cfg = *flag == "--cfg"; let is_cfg = *flag == "--cfg";
let is_feature = flag.starts_with("feature="); let is_feature = flag.starts_with("feature=");
if replace(&mut next_is_cfg, is_cfg) && is_feature { if replace(&mut next_is_cfg, is_cfg)
if let Some(feature) = flag && is_feature
&& let Some(feature) = flag
.split_once('=') .split_once('=')
.map(|(_, feature)| feature.trim_matches('"')) .map(|(_, feature)| feature.trim_matches('"'))
{ {
features.push(feature); features.push(feature);
}
} }
} }
} }

40
src/core/matrix/event/filter.rs
View File

@@ -65,10 +65,10 @@ fn matches_user_id(user_id: &UserId, filter: &Filter) -> bool {
return false; return false;
} }
if let Some(senders) = filter.senders.as_ref() { if let Some(senders) = filter.senders.as_ref()
if !senders.iter().any(is_equal_to!(user_id)) { && !senders.iter().any(is_equal_to!(user_id))
return false; {
} return false;
} }
true true
@@ -79,10 +79,10 @@ fn matches_room_id(room_id: &RoomId, filter: &RoomFilter) -> bool {
return false; return false;
} }
if let Some(rooms) = filter.rooms.as_ref() { if let Some(rooms) = filter.rooms.as_ref()
if !rooms.iter().any(is_equal_to!(room_id)) { && !rooms.iter().any(is_equal_to!(room_id))
return false; {
} return false;
} }
true true
@@ -97,10 +97,10 @@ fn matches_room<E: Event>(event: &E, filter: &RoomEventFilter) -> bool {
return false; return false;
} }
if let Some(rooms) = filter.rooms.as_ref() { if let Some(rooms) = filter.rooms.as_ref()
if !rooms.iter().any(is_equal_to!(event.room_id())) { && !rooms.iter().any(is_equal_to!(event.room_id()))
return false; {
} return false;
} }
true true
@@ -115,10 +115,10 @@ fn matches_sender<E: Event>(event: &E, filter: &RoomEventFilter) -> bool {
return false; return false;
} }
if let Some(senders) = filter.senders.as_ref() { if let Some(senders) = filter.senders.as_ref()
if !senders.iter().any(is_equal_to!(event.sender())) { && !senders.iter().any(is_equal_to!(event.sender()))
return false; {
} return false;
} }
true true
@@ -131,10 +131,10 @@ fn matches_type<E: Event>(event: &E, filter: &RoomEventFilter) -> bool {
return false; return false;
} }
if let Some(types) = filter.types.as_ref() { if let Some(types) = filter.types.as_ref()
if !types.iter().any(is_equal_to!(&kind)) { && !types.iter().any(is_equal_to!(&kind))
return false; {
} return false;
} }
true true

8
src/core/matrix/pdu/format.rs
View File

@@ -32,14 +32,12 @@ pub fn into_outgoing_federation(
if !room_rules if !room_rules
.event_format .event_format
.require_room_create_room_id .require_room_create_room_id
{ && pdu_json
if pdu_json
.get("type") .get("type")
.and_then(CanonicalJsonValue::as_str) .and_then(CanonicalJsonValue::as_str)
.is_some_and(is_equal_to!("m.room.create")) .is_some_and(is_equal_to!("m.room.create"))
{ {
pdu_json.remove("room_id"); pdu_json.remove("room_id");
}
} }
if matches!(room_rules.events_reference_format, EventsReferenceFormatVersion::V1) { if matches!(room_rules.events_reference_format, EventsReferenceFormatVersion::V1) {

13
src/core/matrix/state_res/resolve/power_sort.rs
View File

@@ -201,15 +201,14 @@ where
let mut room_create_event = None; let mut room_create_event = None;
let mut room_power_levels_event = None; let mut room_power_levels_event = None;
let event = fetch(event_id.to_owned()).await; let event = fetch(event_id.to_owned()).await;
if let Ok(event) = &event { if let Ok(event) = &event
if rules && rules
.authorization .authorization
.room_create_event_id_as_room_id .room_create_event_id_as_room_id
{ {
let create_id = event.room_id().as_event_id()?; let create_id = event.room_id().as_event_id()?;
let fetched = fetch(create_id).await?; let fetched = fetch(create_id).await?;
room_create_event = Some(RoomCreateEvent::new(fetched)); room_create_event = Some(RoomCreateEvent::new(fetched));
}
} }
for auth_event_id in event for auth_event_id in event

10
src/macros/config.rs
View File

@@ -146,11 +146,11 @@ fn generate_example(input: &ItemStruct, args: &[Meta], write: bool) -> Result<To
} }
} }
if let Some(file) = file.as_mut() { if let Some(file) = file.as_mut()
if let Some(footer) = settings.get("footer") { && let Some(footer) = settings.get("footer")
file.write_all(footer.as_bytes()) {
.expect("written to config file"); file.write_all(footer.as_bytes())
} .expect("written to config file");
} }
let struct_name = &input.ident; let struct_name = &input.ident;

8
src/main/sentry.rs
View File

@@ -70,10 +70,10 @@ fn before_send(event: Event<'static>) -> Option<Event<'static>> {
} }
//NOTE: we can enable this to specify error!(sentry = true, ...) //NOTE: we can enable this to specify error!(sentry = true, ...)
if let Some(Context::Other(context)) = event.contexts.get("Rust Tracing Fields") { if let Some(Context::Other(context)) = event.contexts.get("Rust Tracing Fields")
if !context.contains_key("sentry") { && !context.contains_key("sentry")
//return None; {
} //return None;
} }
} }

8
src/router/run.rs
View File

@@ -132,10 +132,10 @@ async fn handle_services_poll(
) -> Result { ) -> Result {
debug!("Service manager finished: {result:?}"); debug!("Service manager finished: {result:?}");
if server.running() { if server.running()
if let Err(e) = server.shutdown() { && let Err(e) = server.shutdown()
error!("Failed to send shutdown signal: {e}"); {
} error!("Failed to send shutdown signal: {e}");
} }
if let Err(e) = listener.await { if let Err(e) = listener.await {

12
src/router/serve/unix.rs
View File

@@ -174,12 +174,12 @@ async fn fini(server: &Arc<Server>, listener: UnixListener, mut tasks: JoinSet<(
debug!("Shutting down..."); debug!("Shutting down...");
tasks.shutdown().await; tasks.shutdown().await;
if let Ok(local) = local { if let Ok(local) = local
if let Some(path) = local.as_pathname() { && let Some(path) = local.as_pathname()
debug!(?path, "Removing unix socket file."); {
if let Err(e) = fs::remove_file(path).await { debug!(?path, "Removing unix socket file.");
warn!(?path, "Failed to remove UNIX socket file: {e}"); if let Err(e) = fs::remove_file(path).await {
} warn!(?path, "Failed to remove UNIX socket file: {e}");
} }
} }
} }

16
src/service/admin/execute.rs
View File

@@ -50,10 +50,10 @@ pub(super) async fn startup_execute(&self) -> Result {
sleep(Duration::from_millis(500)).await; sleep(Duration::from_millis(500)).await;
for (i, command) in commands.iter().enumerate() { for (i, command) in commands.iter().enumerate() {
if let Err(e) = self.execute_command(i, command.clone()).await { if let Err(e) = self.execute_command(i, command.clone()).await
if !errors { && !errors
return Err(e); {
} return Err(e);
} }
tokio::task::yield_now().await; tokio::task::yield_now().await;
@@ -92,10 +92,10 @@ pub(super) async fn signal_execute(&self) -> Result {
.admin_execute_errors_ignore; .admin_execute_errors_ignore;
for (i, command) in commands.iter().enumerate() { for (i, command) in commands.iter().enumerate() {
if let Err(e) = self.execute_command(i, command.clone()).await { if let Err(e) = self.execute_command(i, command.clone()).await
if !ignore_errors { && !ignore_errors
return Err(e); {
} return Err(e);
} }
tokio::task::yield_now().await; tokio::task::yield_now().await;

9
src/service/admin/grant.rs
View File

@@ -132,15 +132,14 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result {
.admin_room_tag .admin_room_tag
.as_str(); .as_str();
if !room_tag.is_empty() { if !room_tag.is_empty()
if let Err(e) = self && let Err(e) = self
.services .services
.account_data .account_data
.set_room_tag(user_id, &room_id, room_tag.into(), None) .set_room_tag(user_id, &room_id, room_tag.into(), None)
.await .await
{ {
error!(?room_id, ?user_id, ?room_tag, "Failed to set tag for admin grant: {e}"); error!(?room_id, ?user_id, ?room_tag, "Failed to set tag for admin grant: {e}");
}
} }
if self.services.server.config.admin_room_notices { if self.services.server.config.admin_room_notices {

16
src/service/appservice/namespace_regex.rs
View File

@@ -18,10 +18,10 @@ impl NamespaceRegex {
return true; return true;
} }
if let Some(non_exclusive) = &self.non_exclusive { if let Some(non_exclusive) = &self.non_exclusive
if non_exclusive.is_match(heystack) { && non_exclusive.is_match(heystack)
return true; {
} return true;
} }
false false
} }
@@ -30,10 +30,10 @@ impl NamespaceRegex {
#[inline] #[inline]
#[must_use] #[must_use]
pub fn is_exclusive_match(&self, heystack: &str) -> bool { pub fn is_exclusive_match(&self, heystack: &str) -> bool {
if let Some(exclusive) = &self.exclusive { if let Some(exclusive) = &self.exclusive
if exclusive.is_match(heystack) { && exclusive.is_match(heystack)
return true; {
} return true;
} }
false false
} }

10
src/service/federation/execute.rs
View File

@@ -124,11 +124,11 @@ where
#[implement(super::Service)] #[implement(super::Service)]
fn validate_url(&self, url: &Url) -> Result { fn validate_url(&self, url: &Url) -> Result {
if let Some(url_host) = url.host_str() { if let Some(url_host) = url.host_str()
if let Ok(ip) = IPAddress::parse(url_host) { && let Ok(ip) = IPAddress::parse(url_host)
trace!("Checking request URL IP {ip:?}"); {
self.services.resolver.validate_ip(&ip)?; trace!("Checking request URL IP {ip:?}");
} self.services.resolver.validate_ip(&ip)?;
} }
Ok(()) Ok(())

8
src/service/media/mod.rs
View File

@@ -337,10 +337,10 @@ impl Service {
let file_rm = fs::remove_file(&path); let file_rm = fs::remove_file(&path);
let legacy_rm = fs::remove_file(&legacy); let legacy_rm = fs::remove_file(&legacy);
let (file_rm, legacy_rm) = tokio::join!(file_rm, legacy_rm); let (file_rm, legacy_rm) = tokio::join!(file_rm, legacy_rm);
if let Err(e) = legacy_rm { if let Err(e) = legacy_rm
if self.services.server.config.media_compat_file_link { && self.services.server.config.media_compat_file_link
debug_error!(?key, ?legacy, "Failed to remove legacy media symlink: {e}"); {
} debug_error!(?key, ?legacy, "Failed to remove legacy media symlink: {e}");
} }
Ok(file_rm?) Ok(file_rm?)

16
src/service/media/preview.rs
View File

@@ -79,10 +79,10 @@ pub async fn get_url_preview(&self, url: &Url) -> Result<UrlPreviewData> {
#[implement(Service)] #[implement(Service)]
async fn request_url_preview(&self, url: &Url) -> Result<UrlPreviewData> { async fn request_url_preview(&self, url: &Url) -> Result<UrlPreviewData> {
if let Ok(ip) = IPAddress::parse(url.host_str().expect("URL previously validated")) { if let Ok(ip) = IPAddress::parse(url.host_str().expect("URL previously validated"))
if !self.services.client.valid_cidr_range(&ip) { && !self.services.client.valid_cidr_range(&ip)
return Err!(Request(Forbidden("Requesting from this address is forbidden"))); {
} return Err!(Request(Forbidden("Requesting from this address is forbidden")));
} }
let client = &self.services.client.url_preview; let client = &self.services.client.url_preview;
@@ -93,10 +93,10 @@ async fn request_url_preview(&self, url: &Url) -> Result<UrlPreviewData> {
if let Some(remote_addr) = response.remote_addr() { if let Some(remote_addr) = response.remote_addr() {
debug!(?url, "URL preview response remote address: {:?}", remote_addr); debug!(?url, "URL preview response remote address: {:?}", remote_addr);
if let Ok(ip) = IPAddress::parse(remote_addr.ip().to_string()) { if let Ok(ip) = IPAddress::parse(remote_addr.ip().to_string())
if !self.services.client.valid_cidr_range(&ip) { && !self.services.client.valid_cidr_range(&ip)
return Err!(Request(Forbidden("Requesting from this address is forbidden"))); {
} return Err!(Request(Forbidden("Requesting from this address is forbidden")));
} }
} }

95
src/service/membership/join.rs
View File

@@ -96,12 +96,10 @@ pub async fn join(
.services .services
.state_accessor .state_accessor
.get_member(room_id, sender_user) .get_member(room_id, sender_user)
.await .await && membership.membership == MembershipState::Ban
{ {
if membership.membership == MembershipState::Ban { debug_warn!("{sender_user} is banned from {room_id} but attempted to join");
debug_warn!("{sender_user} is banned from {room_id} but attempted to join"); return Err!(Request(Forbidden("You are banned from the room.")));
return Err!(Request(Forbidden("You are banned from the room.")));
}
} }
let server_in_room = self let server_in_room = self
@@ -249,57 +247,54 @@ pub async fn join_remote(
); );
} }
if join_authorized_via_users_server.is_some() { if join_authorized_via_users_server.is_some()
if let Some(signed_raw) = &response.event { && let Some(signed_raw) = &response.event
debug_info!( {
"There is a signed event with join_authorized_via_users_server. This room is \ debug_info!(
probably using restricted joins. Adding signature to our event" "There is a signed event with join_authorized_via_users_server. This room is \
); probably using restricted joins. Adding signature to our event"
);
let (signed_event_id, signed_value) = let (signed_event_id, signed_value) =
gen_event_id_canonical_json(signed_raw, &room_version_id).map_err(|e| { gen_event_id_canonical_json(signed_raw, &room_version_id).map_err(|e| {
err!(Request(BadJson(warn!( err!(Request(BadJson(warn!("Could not convert event to canonical JSON: {e}"))))
"Could not convert event to canonical JSON: {e}" })?;
))))
})?;
if signed_event_id != event_id { if signed_event_id != event_id {
return Err!(Request(BadJson(warn!( return Err!(Request(BadJson(warn!(
%signed_event_id, %event_id, %signed_event_id, %event_id,
"Server {remote_server} sent event with wrong event ID" "Server {remote_server} sent event with wrong event ID"
)))); ))));
} }
match signed_value["signatures"] match signed_value["signatures"]
.as_object() .as_object()
.ok_or_else(|| { .ok_or_else(|| {
err!(BadServerResponse(warn!(
"Server {remote_server} sent invalid signatures type"
)))
})
.and_then(|e| {
e.get(remote_server.as_str()).ok_or_else(|| {
err!(BadServerResponse(warn!( err!(BadServerResponse(warn!(
"Server {remote_server} sent invalid signatures type" "Server {remote_server} did not send its signature for a restricted room"
))) )))
}) })
.and_then(|e| { }) {
e.get(remote_server.as_str()).ok_or_else(|| { | Ok(signature) => {
err!(BadServerResponse(warn!( join_event
"Server {remote_server} did not send its signature for a restricted \ .get_mut("signatures")
room" .expect("we created a valid pdu")
))) .as_object_mut()
}) .expect("we created a valid pdu")
}) { .insert(remote_server.as_str().into(), signature.clone());
| Ok(signature) => { },
join_event | Err(e) => {
.get_mut("signatures") warn!(
.expect("we created a valid pdu") "Server {remote_server} sent invalid signature in send_join signatures for \
.as_object_mut() event {signed_value:?}: {e:?}",
.expect("we created a valid pdu") );
.insert(remote_server.as_str().into(), signature.clone()); },
},
| Err(e) => {
warn!(
"Server {remote_server} sent invalid signature in send_join signatures \
for event {signed_value:?}: {e:?}",
);
},
}
} }
} }

8
src/service/membership/knock.rs
View File

@@ -83,12 +83,10 @@ pub async fn knock(
.services .services
.state_accessor .state_accessor
.get_member(room_id, sender_user) .get_member(room_id, sender_user)
.await .await && membership.membership == MembershipState::Ban
{ {
if membership.membership == MembershipState::Ban { debug_warn!("{sender_user} is banned from {room_id} but attempted to knock");
debug_warn!("{sender_user} is banned from {room_id} but attempted to knock"); return Err!(Request(Forbidden("You cannot knock on a room you are banned from.")));
return Err!(Request(Forbidden("You cannot knock on a room you are banned from.")));
}
} }
let server_in_room = self let server_in_room = self

8
src/service/oauth/mod.rs
View File

@@ -195,10 +195,10 @@ where
.body(body); .body(body);
} }
if let Some(session) = session { if let Some(session) = session
if let Some(access_token) = session.access_token.clone() { && let Some(access_token) = session.access_token.clone()
request = request.bearer_auth(access_token); {
} request = request.bearer_auth(access_token);
} }
let response: JsonValue = request let response: JsonValue = request

43
src/service/oauth/sessions.rs
View File

@@ -129,26 +129,22 @@ pub async fn delete(&self, sess_id: &str) {
// Check the user_id still points to this sess_id before deleting. If not, the // Check the user_id still points to this sess_id before deleting. If not, the
// association was updated to a newer session. // association was updated to a newer session.
if let Some(user_id) = session.user_id.as_deref() { if let Some(user_id) = session.user_id.as_deref()
if let Ok(assoc_id) = self.get_sess_id_by_user(user_id).await { && let Ok(assoc_id) = self.get_sess_id_by_user(user_id).await
if assoc_id == sess_id { && assoc_id == sess_id
self.db.userid_oauthid.remove(user_id); {
} self.db.userid_oauthid.remove(user_id);
}
} }
// Check the unique identity still points to this sess_id before deleting. If // Check the unique identity still points to this sess_id before deleting. If
// not, the association was updated to a newer session. // not, the association was updated to a newer session.
if let Some(idp_id) = session.idp_id.as_ref() { if let Some(idp_id) = session.idp_id.as_ref()
if let Ok(provider) = self.providers.get(idp_id).await { && let Ok(provider) = self.providers.get(idp_id).await
if let Ok(unique_id) = unique_id((&provider, &session)) { && let Ok(unique_id) = unique_id((&provider, &session))
if let Ok(assoc_id) = self.get_sess_id_by_unique_id(&unique_id).await { && let Ok(assoc_id) = self.get_sess_id_by_unique_id(&unique_id).await
if assoc_id == sess_id { && assoc_id == sess_id
self.db.oauthuniqid_oauthid.remove(&unique_id); {
} self.db.oauthuniqid_oauthid.remove(&unique_id);
}
}
}
} }
self.db.oauthid_session.remove(sess_id); self.db.oauthid_session.remove(sess_id);
@@ -166,14 +162,13 @@ pub async fn put(&self, sess_id: &str, session: &Session) {
self.db.userid_oauthid.insert(user_id, sess_id); self.db.userid_oauthid.insert(user_id, sess_id);
} }
if let Some(idp_id) = session.idp_id.as_ref() { if let Some(idp_id) = session.idp_id.as_ref()
if let Ok(provider) = self.providers.get(idp_id).await { && let Ok(provider) = self.providers.get(idp_id).await
if let Ok(unique_id) = unique_id((&provider, session)) { && let Ok(unique_id) = unique_id((&provider, session))
self.db {
.oauthuniqid_oauthid self.db
.insert(&unique_id, sess_id); .oauthuniqid_oauthid
} .insert(&unique_id, sess_id);
}
} }
} }

20
src/service/pusher/append.rs
View File

@@ -68,17 +68,15 @@ pub(crate) async fn append_pdu(&self, pdu_id: RawPduId, pdu: &Pdu) -> Result {
let (mut push_target, power_levels) = join(push_target, power_levels).boxed().await; let (mut push_target, power_levels) = join(push_target, power_levels).boxed().await;
if *pdu.kind() == TimelineEventType::RoomMember { if *pdu.kind() == TimelineEventType::RoomMember
if let Some(Ok(target_user_id)) = pdu.state_key().map(UserId::parse) { && let Some(Ok(target_user_id)) = pdu.state_key().map(UserId::parse)
if self && self
.services .services
.users .users
.is_active_local(target_user_id) .is_active_local(target_user_id)
.await .await
{ {
push_target.insert(target_user_id.to_owned()); push_target.insert(target_user_id.to_owned());
}
}
} }
let serialized = pdu.to_format(); let serialized = pdu.to_format();

9
src/service/pusher/mod.rs
View File

@@ -110,12 +110,11 @@ pub async fn set_pusher(
if let Ok(ip) = if let Ok(ip) =
IPAddress::parse(url.host_str().expect("URL previously validated")) IPAddress::parse(url.host_str().expect("URL previously validated"))
&& !self.services.client.valid_cidr_range(&ip)
{ {
if !self.services.client.valid_cidr_range(&ip) { return Err!(Request(InvalidParam(
return Err!(Request(InvalidParam( warn!(%url, "HTTP pusher URL is a forbidden remote address")
warn!(%url, "HTTP pusher URL is a forbidden remote address") )));
)));
}
} }
} }

21
src/service/pusher/request.rs
View File

@@ -36,10 +36,10 @@ where
let reqwest_request = reqwest::Request::try_from(http_request)?; let reqwest_request = reqwest::Request::try_from(http_request)?;
if let Some(url_host) = reqwest_request.url().host_str() { if let Some(url_host) = reqwest_request.url().host_str() {
trace!("Checking request URL for IP"); trace!("Checking request URL for IP");
if let Ok(ip) = IPAddress::parse(url_host) { if let Ok(ip) = IPAddress::parse(url_host)
if !self.services.client.valid_cidr_range(&ip) { && !self.services.client.valid_cidr_range(&ip)
return Err!(BadServerResponse("Not allowed to send requests to this IP")); {
} return Err!(BadServerResponse("Not allowed to send requests to this IP"));
} }
} }
@@ -55,14 +55,11 @@ where
// reqwest::Response -> http::Response conversion // reqwest::Response -> http::Response conversion
trace!("Checking response destination's IP"); trace!("Checking response destination's IP");
if let Some(remote_addr) = response.remote_addr() { if let Some(remote_addr) = response.remote_addr()
if let Ok(ip) = IPAddress::parse(remote_addr.ip().to_string()) { && let Ok(ip) = IPAddress::parse(remote_addr.ip().to_string())
if !self.services.client.valid_cidr_range(&ip) { && !self.services.client.valid_cidr_range(&ip)
return Err!(BadServerResponse( {
"Not allowed to send requests to this IP" return Err!(BadServerResponse("Not allowed to send requests to this IP"));
));
}
}
} }
let status = response.status(); let status = response.status();

12
src/service/pusher/send.rs
View File

@@ -104,12 +104,12 @@ async fn send_notice<Pdu: Event>(
))); )));
} }
if let Ok(ip) = IPAddress::parse(url.host_str().expect("URL previously validated")) { if let Ok(ip) = IPAddress::parse(url.host_str().expect("URL previously validated"))
if !self.services.client.valid_cidr_range(&ip) { && !self.services.client.valid_cidr_range(&ip)
return Err!(Request(InvalidParam( {
warn!(%url, "HTTP pusher URL is a forbidden remote address") return Err!(Request(InvalidParam(
))); warn!(%url, "HTTP pusher URL is a forbidden remote address")
} )));
} }
// TODO (timo): can pusher/devices have conflicting formats // TODO (timo): can pusher/devices have conflicting formats

10
src/service/rooms/lazy_loading/mod.rs
View File

@@ -93,11 +93,11 @@ pub async fn witness_retain(&self, senders: Witness, ctx: &Context<'_>) -> Witne
continue; continue;
} }
if let Status::Seen(seen) = status { if let Status::Seen(seen) = status
if seen == 0 || ctx.token == Some(seen) { && (seen == 0 || ctx.token == Some(seen))
senders.insert(sender.into()); {
continue; senders.insert(sender.into());
} continue;
} }
} }

8
src/service/rooms/spaces/mod.rs
View File

@@ -500,10 +500,10 @@ fn get_space_child_events<'a>(
.await .await
}) })
.ready_filter_map(|(state_key, pdu)| { .ready_filter_map(|(state_key, pdu)| {
if let Ok(content) = pdu.get_content::<SpaceChildEventContent>() { if let Ok(content) = pdu.get_content::<SpaceChildEventContent>()
if content.via.is_empty() { && content.via.is_empty()
return None; {
} return None;
} }
if RoomId::parse(&state_key).is_err() { if RoomId::parse(&state_key).is_err() {

85
src/service/rooms/timeline/append.rs
View File

@@ -113,34 +113,32 @@ where
.services .services
.state .state
.pdu_shortstatehash(pdu.event_id()) .pdu_shortstatehash(pdu.event_id())
.await && let Ok(prev_state) = self
.services
.state_accessor
.state_get(shortstatehash, &pdu.kind().to_string().into(), state_key)
.await .await
{ {
if let Ok(prev_state) = self unsigned.insert(
.services "prev_content".into(),
.state_accessor CanonicalJsonValue::Object(
.state_get(shortstatehash, &pdu.kind().to_string().into(), state_key) utils::to_canonical_object(prev_state.get_content_as_value()).map_err(
.await |e| {
{ err!(Database(error!(
unsigned.insert( "Failed to convert prev_state to canonical JSON: {e}",
"prev_content".into(), )))
CanonicalJsonValue::Object( },
utils::to_canonical_object(prev_state.get_content_as_value()) )?,
.map_err(|e| { ),
err!(Database(error!( );
"Failed to convert prev_state to canonical JSON: {e}", unsigned.insert(
))) "prev_sender".into(),
})?, CanonicalJsonValue::String(prev_state.sender().to_string()),
), );
); unsigned.insert(
unsigned.insert( "replaces_state".into(),
"prev_sender".into(), CanonicalJsonValue::String(prev_state.event_id().to_string()),
CanonicalJsonValue::String(prev_state.sender().to_string()), );
);
unsigned.insert(
"replaces_state".into(),
CanonicalJsonValue::String(prev_state.event_id().to_string()),
);
}
} }
} else { } else {
error!("Invalid unsigned type in pdu."); error!("Invalid unsigned type in pdu.");
@@ -222,30 +220,28 @@ async fn append_pdu_effects(
match room_version_id { match room_version_id {
| V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 => { | V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 => {
if let Some(redact_id) = pdu.redacts() { if let Some(redact_id) = pdu.redacts()
if self && self
.services .services
.state_accessor .state_accessor
.user_can_redact(redact_id, pdu.sender(), pdu.room_id(), false) .user_can_redact(redact_id, pdu.sender(), pdu.room_id(), false)
.await? .await?
{ {
self.redact_pdu(redact_id, pdu, shortroomid) self.redact_pdu(redact_id, pdu, shortroomid)
.await?; .await?;
}
} }
}, },
| _ => { | _ => {
let content: RoomRedactionEventContent = pdu.get_content()?; let content: RoomRedactionEventContent = pdu.get_content()?;
if let Some(redact_id) = &content.redacts { if let Some(redact_id) = &content.redacts
if self && self
.services .services
.state_accessor .state_accessor
.user_can_redact(redact_id, pdu.sender(), pdu.room_id(), false) .user_can_redact(redact_id, pdu.sender(), pdu.room_id(), false)
.await? .await?
{ {
self.redact_pdu(redact_id, pdu, shortroomid) self.redact_pdu(redact_id, pdu, shortroomid)
.await?; .await?;
}
} }
}, },
} }
@@ -317,15 +313,14 @@ async fn append_pdu_effects(
| _ => {}, | _ => {},
} }
if let Ok(content) = pdu.get_content::<ExtractRelatesToEventId>() { if let Ok(content) = pdu.get_content::<ExtractRelatesToEventId>()
if let Ok(related_pducount) = self && let Ok(related_pducount) = self
.get_pdu_count(&content.relates_to.event_id) .get_pdu_count(&content.relates_to.event_id)
.await .await
{ {
self.services self.services
.pdu_metadata .pdu_metadata
.add_relation(count, related_pducount); .add_relation(count, related_pducount);
}
} }
if let Ok(content) = pdu.get_content::<ExtractRelatesTo>() { if let Ok(content) = pdu.get_content::<ExtractRelatesTo>() {

27
src/service/rooms/timeline/build.rs
View File

@@ -70,28 +70,26 @@ pub async fn build_and_append_pdu(
.await? .await?
{ {
| V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 => { | V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 => {
if let Some(redact_id) = pdu.redacts() { if let Some(redact_id) = pdu.redacts()
if !self && !self
.services .services
.state_accessor .state_accessor
.user_can_redact(redact_id, pdu.sender(), pdu.room_id(), false) .user_can_redact(redact_id, pdu.sender(), pdu.room_id(), false)
.await? .await?
{ {
return Err!(Request(Forbidden("User cannot redact this event."))); return Err!(Request(Forbidden("User cannot redact this event.")));
}
} }
}, },
| _ => { | _ => {
let content: RoomRedactionEventContent = pdu.get_content()?; let content: RoomRedactionEventContent = pdu.get_content()?;
if let Some(redact_id) = &content.redacts { if let Some(redact_id) = &content.redacts
if !self && !self
.services .services
.state_accessor .state_accessor
.user_can_redact(redact_id, pdu.sender(), pdu.room_id(), false) .user_can_redact(redact_id, pdu.sender(), pdu.room_id(), false)
.await? .await?
{ {
return Err!(Request(Forbidden("User cannot redact this event."))); return Err!(Request(Forbidden("User cannot redact this event.")));
}
} }
}, },
} }
@@ -155,14 +153,13 @@ pub async fn build_and_append_pdu(
// In case we are kicking or banning a user, we need to inform their server of // In case we are kicking or banning a user, we need to inform their server of
// the change // the change
if *pdu.kind() == TimelineEventType::RoomMember { if *pdu.kind() == TimelineEventType::RoomMember
if let Some(state_key_uid) = &pdu && let Some(state_key_uid) = &pdu
.state_key .state_key
.as_ref() .as_ref()
.and_then(|state_key| UserId::parse(state_key.as_str()).ok()) .and_then(|state_key| UserId::parse(state_key.as_str()).ok())
{ {
servers.insert(state_key_uid.server_name().to_owned()); servers.insert(state_key_uid.server_name().to_owned());
}
} }
// Remove our server from the server list since it will be added to it by // Remove our server from the server list since it will be added to it by

14
src/service/rooms/timeline/create.rs
View File

@@ -100,18 +100,16 @@ pub async fn create_hash_and_sign_event(
.saturating_add(uint!(1)); .saturating_add(uint!(1));
let mut unsigned = unsigned.unwrap_or_default(); let mut unsigned = unsigned.unwrap_or_default();
if let Some(state_key) = &state_key { if let Some(state_key) = &state_key
if let Ok(prev_pdu) = self && let Ok(prev_pdu) = self
.services .services
.state_accessor .state_accessor
.room_state_get(room_id, &event_type.to_string().into(), state_key) .room_state_get(room_id, &event_type.to_string().into(), state_key)
.await .await
{ {
unsigned.insert("prev_content".to_owned(), prev_pdu.get_content_as_value()); unsigned.insert("prev_content".to_owned(), prev_pdu.get_content_as_value());
unsigned.insert("prev_sender".to_owned(), serde_json::to_value(prev_pdu.sender())?); unsigned.insert("prev_sender".to_owned(), serde_json::to_value(prev_pdu.sender())?);
unsigned unsigned.insert("replaces_state".to_owned(), serde_json::to_value(prev_pdu.event_id())?);
.insert("replaces_state".to_owned(), serde_json::to_value(prev_pdu.event_id())?);
}
} }
let unsigned = unsigned let unsigned = unsigned

12
src/service/rooms/timeline/redact.rs
View File

@@ -31,12 +31,12 @@ pub async fn redact_pdu<Pdu: Event + Send + Sync>(
err!(Database(error!(?pdu_id, ?event_id, ?e, "PDU ID points to invalid PDU."))) err!(Database(error!(?pdu_id, ?event_id, ?e, "PDU ID points to invalid PDU.")))
})?; })?;
if let Ok(content) = pdu.get_content::<ExtractBody>() { if let Ok(content) = pdu.get_content::<ExtractBody>()
if let Some(body) = content.body { && let Some(body) = content.body
self.services {
.search self.services
.deindex_pdu(shortroomid, &pdu_id, &body); .search
} .deindex_pdu(shortroomid, &pdu_id, &body);
} }
let room_version_id = self let room_version_id = self

25
src/service/sending/sender.rs
View File

@@ -325,15 +325,15 @@ impl Service {
} }
// Add EDU's into the transaction // Add EDU's into the transaction
if let Destination::Federation(server_name) = dest { if let Destination::Federation(server_name) = dest
if let Ok((select_edus, last_count)) = self.select_edus(server_name).await { && let Ok((select_edus, last_count)) = self.select_edus(server_name).await
debug_assert!(select_edus.len() <= EDU_LIMIT, "exceeded edus limit"); {
let select_edus = select_edus.into_iter().map(SendingEvent::Edu); debug_assert!(select_edus.len() <= EDU_LIMIT, "exceeded edus limit");
let select_edus = select_edus.into_iter().map(SendingEvent::Edu);
events.extend(select_edus); events.extend(select_edus);
self.db self.db
.set_latest_educount(server_name, last_count); .set_latest_educount(server_name, last_count);
}
} }
Ok(Some(events)) Ok(Some(events))
@@ -735,12 +735,11 @@ impl Service {
} }
}, },
| SendingEvent::Edu(edu) => | SendingEvent::Edu(edu) =>
if appservice.receive_ephemeral { if appservice.receive_ephemeral
if let Ok(edu) = && let Ok(edu) =
serde_json::from_slice(edu).and_then(|edu| Raw::new(&edu)) serde_json::from_slice(edu).and_then(|edu| Raw::new(&edu))
{ {
edu_jsons.push(edu); edu_jsons.push(edu);
}
}, },
| SendingEvent::Flush => {}, // flush only; no new content | SendingEvent::Flush => {}, // flush only; no new content
} }

27
src/service/server_keys/get.rs
View File

@@ -82,31 +82,28 @@ pub async fn get_verify_key(
return Ok(result); return Ok(result);
} }
if notary_first { if notary_first
if let Ok(result) = self && let Ok(result) = self
.get_verify_key_from_notaries(origin, key_id) .get_verify_key_from_notaries(origin, key_id)
.await .await
{ {
return Ok(result); return Ok(result);
}
} }
if !notary_only { if !notary_only
if let Ok(result) = self && let Ok(result) = self
.get_verify_key_from_origin(origin, key_id) .get_verify_key_from_origin(origin, key_id)
.await .await
{ {
return Ok(result); return Ok(result);
}
} }
if !notary_first { if !notary_first
if let Ok(result) = self && let Ok(result) = self
.get_verify_key_from_notaries(origin, key_id) .get_verify_key_from_notaries(origin, key_id)
.await .await
{ {
return Ok(result); return Ok(result);
}
} }
Err!(BadServerResponse(debug_error!( Err!(BadServerResponse(debug_error!(

16
src/service/server_keys/mod.rs
View File

@@ -141,16 +141,16 @@ pub async fn verify_key_exists(&self, origin: &ServerName, key_id: &ServerSignin
return false; return false;
}; };
if let Ok(Some(verify_keys)) = keys.get_field::<KeysMap<'_>>("verify_keys") { if let Ok(Some(verify_keys)) = keys.get_field::<KeysMap<'_>>("verify_keys")
if verify_keys.contains_key(key_id) { && verify_keys.contains_key(key_id)
return true; {
} return true;
} }
if let Ok(Some(old_verify_keys)) = keys.get_field::<KeysMap<'_>>("old_verify_keys") { if let Ok(Some(old_verify_keys)) = keys.get_field::<KeysMap<'_>>("old_verify_keys")
if old_verify_keys.contains_key(key_id) { && old_verify_keys.contains_key(key_id)
return true; {
} return true;
} }
false false

8
src/service/sync/mod.rs
View File

@@ -247,10 +247,10 @@ pub fn store(&self, service: &Service, key: &ConnectionKey) {
#[tracing::instrument(level = "debug", skip(self))] #[tracing::instrument(level = "debug", skip(self))]
pub fn update_rooms_prologue(&mut self, retard_since: Option<u64>) { pub fn update_rooms_prologue(&mut self, retard_since: Option<u64>) {
self.rooms.values_mut().for_each(|room| { self.rooms.values_mut().for_each(|room| {
if let Some(retard_since) = retard_since { if let Some(retard_since) = retard_since
if room.roomsince > retard_since { && room.roomsince > retard_since
room.roomsince = retard_since; {
} room.roomsince = retard_since;
} }
}); });
} }

20
src/service/uiaa/mod.rs
View File

@@ -117,16 +117,16 @@ pub async fn try_auth(
#[cfg(feature = "ldap")] #[cfg(feature = "ldap")]
if !password_verified && self.services.server.config.ldap.enable { if !password_verified && self.services.server.config.ldap.enable {
// Search for user in LDAP to get their DN // Search for user in LDAP to get their DN
if let Ok(dns) = self.services.users.search_ldap(&user_id).await { if let Ok(dns) = self.services.users.search_ldap(&user_id).await
if let Some((user_dn, _is_admin)) = dns.first() { && let Some((user_dn, _is_admin)) = dns.first()
// Try to authenticate with LDAP {
password_verified = self // Try to authenticate with LDAP
.services password_verified = self
.users .services
.auth_ldap(user_dn, password) .users
.await .auth_ldap(user_dn, password)
.is_ok(); .await
} .is_ok();
} }
} }

8
src/service/users/dehydrated_device.rs
View File

@@ -113,10 +113,10 @@ pub(super) async fn remove_dehydrated_device(
return Err!(Request(NotFound("No dehydrated device for this user."))); return Err!(Request(NotFound("No dehydrated device for this user.")));
}; };
if let Some(maybe_device_id) = maybe_device_id { if let Some(maybe_device_id) = maybe_device_id
if maybe_device_id != device_id { && maybe_device_id != device_id
return Err!(Request(NotFound("Not the user's dehydrated device."))); {
} return Err!(Request(NotFound("Not the user's dehydrated device.")));
} }
self.db.userid_dehydrateddevice.remove(user_id); self.db.userid_dehydrateddevice.remove(user_id);