chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

state-res: Use match instead of repeatedly comparing the same variable

Browse Source
This commit is contained in:
Jonas Platte 2021-09-04 01:41:24 +02:00
parent b4c22d5783
commit 43c8df18ad
No known key found for this signature in database
GPG Key ID: CC154DE0E30B7C67
1 changed files with 103 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
crates/ruma-state-res/src/event_auth.rs
View File

@ -441,123 +441,130 @@ fn valid_membership_change<E: Event>(
let target_user_membership_event_id = let target_user_membership_event_id =
target_user_membership_event.as_ref().map(|e| e.event_id()); target_user_membership_event.as_ref().map(|e| e.event_id());
Ok(if target_membership == MembershipState::Join { Ok(match target_membership {
if sender != target_user { MembershipState::Join => {
warn!("Can't make other user join"); if sender != target_user {
false warn!("Can't make other user join");
} else if let MembershipState::Ban = target_user_current_membership { false
warn!( } else if let MembershipState::Ban = target_user_current_membership {
"Banned user can't join\nCurrent user state: {:?}",
target_user_membership_event_id,
);
false
} else {
let allow = join_rules == JoinRule::Invite
&& (target_user_current_membership == MembershipState::Join
|| target_user_current_membership == MembershipState::Invite)
|| join_rules == JoinRule::Public;
if !allow {
warn!("Can't join if join rules is not public and user is not invited/joined\nJoin Rules: {:?}\nCurrent user state: {:?}",
join_rules_event.as_ref().map(|e| e.event_id()),
target_user_membership_event_id,
);
}
allow
}
} else if target_membership == MembershipState::Invite {
// If content has third_party_invite key
if let Some(Ok(tp_id)) = third_party_invite {
if target_user_current_membership == MembershipState::Ban {
warn!( warn!(
"Can't invite banned user\nCurrent user state: {:?}", "Banned user can't join\nCurrent user state: {:?}",
target_user_membership_event_id, target_user_membership_event_id,
); );
false false
} else { } else {
let allow = verify_third_party_invite( let allow = join_rules == JoinRule::Invite
Some(target_user), && (target_user_current_membership == MembershipState::Join
sender, || target_user_current_membership == MembershipState::Invite)
&tp_id, || join_rules == JoinRule::Public;
current_third_party_invite,
);
if !allow { if !allow {
warn!("Third party invite invalid"); warn!("Can't join if join rules is not public and user is not invited/joined\nJoin Rules: {:?}\nCurrent user state: {:?}",
join_rules_event.as_ref().map(|e| e.event_id()),
target_user_membership_event_id,
);
} }
allow allow
} }
} else if !sender_is_joined
|| target_user_current_membership == MembershipState::Join
|| target_user_current_membership == MembershipState::Ban
{
warn!(
"Can't invite user if sender not joined or the user is currently joined or banned\nCurrent user state: {:?}\nSender user state: {:?}",
target_user_membership_event_id,
sender_membership_event_id,
);
false
} else {
let allow = sender_power.filter(|&p| p >= &power_levels.invite).is_some();
if !allow {
warn!("User does not have enough power to invite\nCurrent user state: {:?}\nPower levels: {:?}",
target_user_membership_event_id,
power_levels_event_id,
);
}
allow
} }
} else if target_membership == MembershipState::Leave { MembershipState::Invite => {
if sender == target_user { // If content has third_party_invite key
let allow = target_user_current_membership == MembershipState::Join if let Some(Ok(tp_id)) = third_party_invite {
|| target_user_current_membership == MembershipState::Invite; if target_user_current_membership == MembershipState::Ban {
if !allow { warn!(
"Can't invite banned user\nCurrent user state: {:?}",
target_user_membership_event_id,
);
false
} else {
let allow = verify_third_party_invite(
Some(target_user),
sender,
&tp_id,
current_third_party_invite,
);
if !allow {
warn!("Third party invite invalid");
}
allow
}
} else if !sender_is_joined
|| target_user_current_membership == MembershipState::Join
|| target_user_current_membership == MembershipState::Ban
{
warn!( warn!(
"Can't leave if not invited or joined\nCurrent user state: {:?}", "Can't invite user if sender not joined or the user is currently joined or banned\nCurrent user state: {:?}\nSender user state: {:?}",
target_user_membership_event_id, target_user_membership_event_id,
sender_membership_event_id,
); );
false
} else {
let allow = sender_power.filter(|&p| p >= &power_levels.invite).is_some();
if !allow {
warn!(
"User does not have enough power to invite\nCurrent user state: {:?}\nPower levels: {:?}",
target_user_membership_event_id,
power_levels_event_id,
);
}
allow
} }
allow }
} else if !sender_is_joined MembershipState::Leave => {
|| target_user_current_membership == MembershipState::Ban if sender == target_user {
&& sender_power.filter(|&p| p < &power_levels.ban).is_some() let allow = target_user_current_membership == MembershipState::Join
{ || target_user_current_membership == MembershipState::Invite;
warn!("Can't kick if sender not joined or user is already banned\nCurrent user state: {:?}\nSender user state: {:?}", if !allow {
target_user_membership_event_id, warn!(
sender_membership_event_id "Can't leave if not invited or joined\nCurrent user state: {:?}",
); target_user_membership_event_id,
false );
} else { }
let allow = sender_power.filter(|&p| p >= &power_levels.kick).is_some() allow
&& target_power < sender_power; } else if !sender_is_joined
if !allow { || target_user_current_membership == MembershipState::Ban
warn!("User does not have enough power to kick\nCurrent user state: {:?}\nPower levels: {:?}", && sender_power.filter(|&p| p < &power_levels.ban).is_some()
{
warn!("Can't kick if sender not joined or user is already banned\nCurrent user state: {:?}\nSender user state: {:?}",
target_user_membership_event_id,
sender_membership_event_id
);
false
} else {
let allow = sender_power.filter(|&p| p >= &power_levels.kick).is_some()
&& target_power < sender_power;
if !allow {
warn!("User does not have enough power to kick\nCurrent user state: {:?}\nPower levels: {:?}",
target_user_membership_event_id,
power_levels_event_id,
);
}
allow
}
}
MembershipState::Ban => {
if !sender_is_joined {
warn!(
"Can't ban user if sender is not joined\nSender user state: {:?}",
sender_membership_event_id
);
false
} else {
let allow = sender_power.filter(|&p| p >= &power_levels.ban).is_some()
&& target_power < sender_power;
if !allow {
warn!("User does not have enough power to ban\nCurrent user state: {:?}\nPower levels: {:?}",
target_user_membership_event_id, target_user_membership_event_id,
power_levels_event_id, power_levels_event_id,
); );
}
allow
} }
allow
} }
} else if target_membership == MembershipState::Ban { _ => {
if !sender_is_joined { warn!("Unknown membership transition");
warn!(
"Can't ban user if sender is not joined\nSender user state: {:?}",
sender_membership_event_id
);
false false
} else {
let allow = sender_power.filter(|&p| p >= &power_levels.ban).is_some()
&& target_power < sender_power;
if !allow {
warn!("User does not have enough power to ban\nCurrent user state: {:?}\nPower levels: {:?}",
target_user_membership_event_id,
power_levels_event_id,
);
}
allow
} }
} else {
warn!("Unknown membership transition");
false
}) })
} }