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

Turn pdu into trait to avoid having our own PDU type

Browse Source
This commit is contained in:
Devin Ragotzy 2020-12-30 15:13:07 -05:00
parent 05a4dd1bf0
commit 9721042198
4 changed files with 203 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
src/event_auth.rs
View File

@ -15,7 +15,7 @@ use ruma::{
identifiers::{RoomVersionId, UserId}, identifiers::{RoomVersionId, UserId},
}; };
use crate::{state_event::Requester, to_requester, Error, Result, StateMap}; use crate::{Error, Event, Result, StateMap};
/// For the given event `kind` what are the relevant auth events /// For the given event `kind` what are the relevant auth events
/// that are needed to authenticate this `content`. /// that are needed to authenticate this `content`.
@ -68,14 +68,14 @@ pub fn auth_types_for_event(
/// * check that the event is being authenticated for the correct room /// * check that the event is being authenticated for the correct room
/// * check that the events signatures are valid /// * check that the events signatures are valid
/// * then there are checks for specific event types /// * then there are checks for specific event types
pub fn auth_check( pub fn auth_check<E: Event>(
room_version: &RoomVersionId, room_version: &RoomVersionId,
incoming_event: &Arc<ServerPdu>, incoming_event: &Arc<E>,
prev_event: Option<Arc<ServerPdu>>, prev_event: Option<Arc<E>>,
auth_events: StateMap<Arc<ServerPdu>>, auth_events: StateMap<Arc<E>>,
current_third_party_invite: Option<Arc<ServerPdu>>, current_third_party_invite: Option<Arc<E>>,
) -> Result<bool> { ) -> Result<bool> {
tracing::info!("auth_check beginning for {}", incoming_event.kind); tracing::info!("auth_check beginning for {}", incoming_event.kind());
// [synapse] check that all the events are in the same room as `incoming_event` // [synapse] check that all the events are in the same room as `incoming_event`
@ -88,17 +88,17 @@ pub fn auth_check(
// Implementation of https://matrix.org/docs/spec/rooms/v1#authorization-rules // Implementation of https://matrix.org/docs/spec/rooms/v1#authorization-rules
// //
// 1. If type is m.room.create: // 1. If type is m.room.create:
if incoming_event.kind == EventType::RoomCreate { if incoming_event.kind() == EventType::RoomCreate {
tracing::info!("start m.room.create check"); tracing::info!("start m.room.create check");
// If it has any previous events, reject // If it has any previous events, reject
if !incoming_event.prev_events.is_empty() { if !incoming_event.prev_events().is_empty() {
tracing::warn!("the room creation event had previous events"); tracing::warn!("the room creation event had previous events");
return Ok(false); return Ok(false);
} }
// If the domain of the room_id does not match the domain of the sender, reject // If the domain of the room_id does not match the domain of the sender, reject
if incoming_event.room_id.server_name() != incoming_event.sender.server_name() { if incoming_event.room_id().server_name() != incoming_event.sender().server_name() {
tracing::warn!("creation events server does not match sender"); tracing::warn!("creation events server does not match sender");
return Ok(false); // creation events room id does not match senders return Ok(false); // creation events room id does not match senders
} }
@ -106,7 +106,7 @@ pub fn auth_check(
// If content.room_version is present and is not a recognized version, reject // If content.room_version is present and is not a recognized version, reject
if serde_json::from_value::<RoomVersionId>( if serde_json::from_value::<RoomVersionId>(
incoming_event incoming_event
.content .content()
.get("room_version") .get("room_version")
.cloned() .cloned()
// TODO synapse defaults to version 1 // TODO synapse defaults to version 1
@ -119,7 +119,7 @@ pub fn auth_check(
} }
// If content has no creator field, reject // If content has no creator field, reject
if incoming_event.content.get("creator").is_none() { if incoming_event.content().get("creator").is_none() {
tracing::warn!("no creator field found in room create content"); tracing::warn!("no creator field found in room create content");
return Ok(false); return Ok(false);
} }
@ -163,7 +163,7 @@ pub fn auth_check(
// [synapse] checks for federation here // [synapse] checks for federation here
// 4. if type is m.room.aliases // 4. if type is m.room.aliases
if incoming_event.kind == EventType::RoomAliases { if incoming_event.kind() == EventType::RoomAliases {
tracing::info!("starting m.room.aliases check"); tracing::info!("starting m.room.aliases check");
// [synapse] adds `&& room_version` "special case aliases auth" // [synapse] adds `&& room_version` "special case aliases auth"
@ -174,7 +174,7 @@ pub fn auth_check(
// } // }
// If sender's domain doesn't matches state_key, reject // If sender's domain doesn't matches state_key, reject
if incoming_event.state_key != Some(incoming_event.sender.server_name().to_string()) { if incoming_event.state_key() != Some(incoming_event.sender().server_name().to_string()) {
tracing::warn!("state_key does not match sender"); tracing::warn!("state_key does not match sender");
return Ok(false); return Ok(false);
} }
@ -183,12 +183,10 @@ pub fn auth_check(
return Ok(true); return Ok(true);
} }
if incoming_event.kind == EventType::RoomMember { if incoming_event.kind() == EventType::RoomMember {
tracing::info!("starting m.room.member check"); tracing::info!("starting m.room.member check");
if serde_json::from_value::<room::member::MemberEventContent>( if serde_json::from_value::<room::member::MemberEventContent>(incoming_event.content())
incoming_event.content.clone(),
)
.is_err() .is_err()
{ {
tracing::warn!("no membership filed found for m.room.member event content"); tracing::warn!("no membership filed found for m.room.member event content");
@ -196,7 +194,7 @@ pub fn auth_check(
} }
if !valid_membership_change( if !valid_membership_change(
to_requester(incoming_event), incoming_event,
prev_event, prev_event,
current_third_party_invite, current_third_party_invite,
&auth_events, &auth_events,
@ -209,7 +207,7 @@ pub fn auth_check(
} }
// If the sender's current membership state is not join, reject // If the sender's current membership state is not join, reject
match check_event_sender_in_room(&incoming_event.sender, &auth_events) { match check_event_sender_in_room(&incoming_event.sender(), &auth_events) {
Some(true) => {} // sender in room Some(true) => {} // sender in room
Some(false) => { Some(false) => {
tracing::warn!("sender's membership is not join"); tracing::warn!("sender's membership is not join");
@ -223,8 +221,8 @@ pub fn auth_check(
// Allow if and only if sender's current power level is greater than // Allow if and only if sender's current power level is greater than
// or equal to the invite level // or equal to the invite level
if incoming_event.kind == EventType::RoomThirdPartyInvite if incoming_event.kind() == EventType::RoomThirdPartyInvite
&& !can_send_invite(&to_requester(incoming_event), &auth_events)? && !can_send_invite(incoming_event, &auth_events)?
{ {
tracing::warn!("sender's cannot send invites in this room"); tracing::warn!("sender's cannot send invites in this room");
return Ok(false); return Ok(false);
@ -237,7 +235,7 @@ pub fn auth_check(
return Ok(false); return Ok(false);
} }
if incoming_event.kind == EventType::RoomPowerLevels { if incoming_event.kind() == EventType::RoomPowerLevels {
tracing::info!("starting m.room.power_levels check"); tracing::info!("starting m.room.power_levels check");
if let Some(required_pwr_lvl) = if let Some(required_pwr_lvl) =
@ -254,7 +252,7 @@ pub fn auth_check(
tracing::info!("power levels event allowed"); tracing::info!("power levels event allowed");
} }
if incoming_event.kind == EventType::RoomRedaction if incoming_event.kind() == EventType::RoomRedaction
&& !check_redaction(room_version, incoming_event, &auth_events)? && !check_redaction(room_version, incoming_event, &auth_events)?
{ {
return Ok(false); return Ok(false);
@ -273,32 +271,31 @@ pub fn auth_check(
/// * `auth_events` - The set of auth events that relate to a membership event. /// * `auth_events` - The set of auth events that relate to a membership event.
/// this is generated by calling `auth_types_for_event` with the membership event and /// this is generated by calling `auth_types_for_event` with the membership event and
/// the current State. /// the current State.
pub fn valid_membership_change( pub fn valid_membership_change<E: Event>(
user: Requester<'_>, user: &Arc<E>,
prev_event: Option<Arc<ServerPdu>>, prev_event: Option<Arc<E>>,
current_third_party_invite: Option<Arc<ServerPdu>>, current_third_party_invite: Option<Arc<E>>,
auth_events: &StateMap<Arc<ServerPdu>>, auth_events: &StateMap<Arc<E>>,
) -> Result<bool> { ) -> Result<bool> {
let state_key = if let Some(s) = user.state_key.as_ref() { let state_key = if let Some(s) = user.state_key() {
s s
} else { } else {
return Err(Error::InvalidPdu("State event requires state_key".into())); return Err(Error::InvalidPdu("State event requires state_key".into()));
}; };
let content = let content = serde_json::from_value::<room::member::MemberEventContent>(user.content())?;
serde_json::from_str::<room::member::MemberEventContent>(&user.content.to_string())?;
let target_membership = content.membership; let target_membership = content.membership;
let target_user_id = UserId::try_from(state_key.as_str()) let target_user_id = UserId::try_from(state_key.as_str())
.map_err(|e| Error::ConversionError(format!("{}", e)))?; .map_err(|e| Error::ConversionError(format!("{}", e)))?;
let key = (EventType::RoomMember, Some(user.sender.to_string())); let key = (EventType::RoomMember, Some(user.sender().to_string()));
let sender = auth_events.get(&key); let sender = auth_events.get(&key);
let sender_membership = let sender_membership =
sender.map_or(Ok::<_, Error>(member::MembershipState::Leave), |pdu| { sender.map_or(Ok::<_, Error>(member::MembershipState::Leave), |pdu| {
Ok( Ok(
serde_json::from_value::<room::member::MemberEventContent>(pdu.content.clone())? serde_json::from_value::<room::member::MemberEventContent>(pdu.content())?
.membership, .membership,
) )
})?; })?;
@ -308,7 +305,7 @@ pub fn valid_membership_change(
let current_membership = let current_membership =
current.map_or(Ok::<_, Error>(member::MembershipState::Leave), |pdu| { current.map_or(Ok::<_, Error>(member::MembershipState::Leave), |pdu| {
Ok( Ok(
serde_json::from_value::<room::member::MemberEventContent>(pdu.content.clone())? serde_json::from_value::<room::member::MemberEventContent>(pdu.content())?
.membership, .membership,
) )
})?; })?;
@ -332,12 +329,12 @@ pub fn valid_membership_change(
}) })
}, },
|power_levels| { |power_levels| {
serde_json::from_value::<PowerLevelsEventContent>(power_levels.content.clone()) serde_json::from_value::<PowerLevelsEventContent>(power_levels.content())
.map_err(Into::into) .map_err(Into::into)
}, },
)?; )?;
let sender_power = power_levels.users.get(&user.sender).map_or_else( let sender_power = power_levels.users.get(&user.sender()).map_or_else(
|| { || {
if sender_membership != member::MembershipState::Join { if sender_membership != member::MembershipState::Join {
None None
@ -365,18 +362,18 @@ pub fn valid_membership_change(
let mut join_rules = JoinRule::Invite; let mut join_rules = JoinRule::Invite;
if let Some(jr) = join_rules_event { if let Some(jr) = join_rules_event {
join_rules = join_rules =
serde_json::from_value::<room::join_rules::JoinRulesEventContent>(jr.content.clone())? serde_json::from_value::<room::join_rules::JoinRulesEventContent>(jr.content())?
.join_rule; .join_rule;
} }
if let Some(prev) = prev_event { if let Some(prev) = prev_event {
if prev.kind == EventType::RoomCreate && prev.prev_events.is_empty() { if prev.kind() == EventType::RoomCreate && prev.prev_events().is_empty() {
return Ok(true); return Ok(true);
} }
} }
Ok(if target_membership == MembershipState::Join { Ok(if target_membership == MembershipState::Join {
if user.sender != &target_user_id { if user.sender() != target_user_id {
false false
} else if let MembershipState::Ban = current_membership { } else if let MembershipState::Ban = current_membership {
false false
@ -392,7 +389,7 @@ pub fn valid_membership_change(
if current_membership == MembershipState::Ban { if current_membership == MembershipState::Ban {
false false
} else { } else {
verify_third_party_invite(&user, &tp_id, current_third_party_invite) verify_third_party_invite(user, &tp_id, current_third_party_invite)
} }
} else if sender_membership != MembershipState::Join } else if sender_membership != MembershipState::Join
|| current_membership == MembershipState::Join || current_membership == MembershipState::Join
@ -405,7 +402,7 @@ pub fn valid_membership_change(
.is_some() .is_some()
} }
} else if target_membership == MembershipState::Leave { } else if target_membership == MembershipState::Leave {
if user.sender == &target_user_id { if user.sender() == target_user_id {
current_membership == MembershipState::Join current_membership == MembershipState::Join
|| current_membership == MembershipState::Invite || current_membership == MembershipState::Invite
} else if sender_membership != MembershipState::Join } else if sender_membership != MembershipState::Join
@ -430,13 +427,13 @@ pub fn valid_membership_change(
} }
/// Is the event's sender in the room that they sent the event to. /// Is the event's sender in the room that they sent the event to.
pub fn check_event_sender_in_room( pub fn check_event_sender_in_room<E: Event>(
sender: &UserId, sender: &UserId,
auth_events: &StateMap<Arc<ServerPdu>>, auth_events: &StateMap<Arc<E>>,
) -> Option<bool> { ) -> Option<bool> {
let mem = auth_events.get(&(EventType::RoomMember, Some(sender.to_string())))?; let mem = auth_events.get(&(EventType::RoomMember, Some(sender.to_string())))?;
Some( Some(
serde_json::from_value::<room::member::MemberEventContent>(mem.content.clone()) serde_json::from_value::<room::member::MemberEventContent>(mem.content())
.ok()? .ok()?
.membership .membership
== MembershipState::Join, == MembershipState::Join,
@ -445,15 +442,15 @@ pub fn check_event_sender_in_room(
/// Is the user allowed to send a specific event based on the rooms power levels. Does the event /// Is the user allowed to send a specific event based on the rooms power levels. Does the event
/// have the correct userId as it's state_key if it's not the "" state_key. /// have the correct userId as it's state_key if it's not the "" state_key.
pub fn can_send_event(event: &Arc<ServerPdu>, auth_events: &StateMap<Arc<ServerPdu>>) -> bool { pub fn can_send_event<E: Event>(event: &Arc<E>, auth_events: &StateMap<Arc<E>>) -> bool {
let ple = auth_events.get(&(EventType::RoomPowerLevels, Some("".into()))); let ple = auth_events.get(&(EventType::RoomPowerLevels, Some("".into())));
let event_type_power_level = get_send_level(&event.kind, event.state_key.clone(), ple); let event_type_power_level = get_send_level(&event.kind(), event.state_key(), ple);
let user_level = get_user_power_level(&event.sender, auth_events); let user_level = get_user_power_level(&event.sender(), auth_events);
tracing::debug!( tracing::debug!(
"{} ev_type {} usr {}", "{} ev_type {} usr {}",
event.event_id.to_string(), event.event_id().to_string(),
event_type_power_level, event_type_power_level,
user_level user_level
); );
@ -463,10 +460,10 @@ pub fn can_send_event(event: &Arc<ServerPdu>, auth_events: &StateMap<Arc<ServerP
} }
if event if event
.state_key .state_key()
.as_ref() .as_ref()
.map_or(false, |k| k.starts_with('@')) .map_or(false, |k| k.starts_with('@'))
&& event.state_key.as_deref() != Some(event.sender.as_str()) && event.state_key().as_deref() != Some(event.sender().as_str())
{ {
return false; // permission required to post in this room return false; // permission required to post in this room
} }
@ -475,12 +472,12 @@ pub fn can_send_event(event: &Arc<ServerPdu>, auth_events: &StateMap<Arc<ServerP
} }
/// Confirm that the event sender has the required power levels. /// Confirm that the event sender has the required power levels.
pub fn check_power_levels( pub fn check_power_levels<E: Event>(
_: &RoomVersionId, _: &RoomVersionId,
power_event: &Arc<ServerPdu>, power_event: &Arc<E>,
auth_events: &StateMap<Arc<ServerPdu>>, auth_events: &StateMap<Arc<E>>,
) -> Option<bool> { ) -> Option<bool> {
let key = (power_event.kind.clone(), power_event.state_key.clone()); let key = (power_event.kind(), power_event.state_key());
let current_state = if let Some(current_state) = auth_events.get(&key) { let current_state = if let Some(current_state) = auth_events.get(&key) {
current_state current_state
} else { } else {
@ -491,18 +488,18 @@ pub fn check_power_levels(
// If users key in content is not a dictionary with keys that are valid user IDs // If users key in content is not a dictionary with keys that are valid user IDs
// with values that are integers (or a string that is an integer), reject. // with values that are integers (or a string that is an integer), reject.
let user_content = serde_json::from_value::<room::power_levels::PowerLevelsEventContent>( let user_content = serde_json::from_value::<room::power_levels::PowerLevelsEventContent>(
power_event.content.clone(), power_event.content(),
) )
.unwrap(); .unwrap();
let current_content = serde_json::from_value::<room::power_levels::PowerLevelsEventContent>( let current_content = serde_json::from_value::<room::power_levels::PowerLevelsEventContent>(
current_state.content.clone(), current_state.content(),
) )
.unwrap(); .unwrap();
// validation of users is done in Ruma, synapse for loops validating user_ids and integers here // validation of users is done in Ruma, synapse for loops validating user_ids and integers here
tracing::info!("validation of power event finished"); tracing::info!("validation of power event finished");
let user_level = get_user_power_level(&power_event.sender, auth_events); let user_level = get_user_power_level(&power_event.sender(), auth_events);
let mut user_levels_to_check = btreeset![]; let mut user_levels_to_check = btreeset![];
let old_list = &current_content.users; let old_list = &current_content.users;
@ -552,7 +549,7 @@ pub fn check_power_levels(
} }
// If the current value is equal to the sender's current power level, reject // If the current value is equal to the sender's current power level, reject
if user != &power_event.sender && old_level.map(|int| (*int).into()) == Some(user_level) { if user != &power_event.sender() && old_level.map(|int| (*int).into()) == Some(user_level) {
tracing::warn!("m.room.power_level cannot remove ops == to own"); tracing::warn!("m.room.power_level cannot remove ops == to own");
return Some(false); // cannot remove ops level == to own return Some(false); // cannot remove ops level == to own
} }
@ -623,12 +620,12 @@ fn get_deserialize_levels(
} }
/// Does the event redacting come from a user with enough power to redact the given event. /// Does the event redacting come from a user with enough power to redact the given event.
pub fn check_redaction( pub fn check_redaction<E: Event>(
room_version: &RoomVersionId, room_version: &RoomVersionId,
redaction_event: &Arc<ServerPdu>, redaction_event: &Arc<E>,
auth_events: &StateMap<Arc<ServerPdu>>, auth_events: &StateMap<Arc<E>>,
) -> Result<bool> { ) -> Result<bool> {
let user_level = get_user_power_level(&redaction_event.sender, auth_events); let user_level = get_user_power_level(&redaction_event.sender(), auth_events);
let redact_level = get_named_level(auth_events, "redact", 50); let redact_level = get_named_level(auth_events, "redact", 50);
if user_level >= redact_level { if user_level >= redact_level {
@ -646,9 +643,9 @@ pub fn check_redaction(
// version 1 check // version 1 check
if let RoomVersionId::Version1 = room_version { if let RoomVersionId::Version1 = room_version {
// If the domain of the event_id of the event being redacted is the same as the domain of the event_id of the m.room.redaction, allow // If the domain of the event_id of the event being redacted is the same as the domain of the event_id of the m.room.redaction, allow
if redaction_event.event_id.server_name() if redaction_event.event_id().server_name()
== redaction_event == redaction_event
.redacts .redacts()
.as_ref() .as_ref()
.and_then(|id| id.server_name()) .and_then(|id| id.server_name())
{ {
@ -693,11 +690,11 @@ pub fn can_federate(auth_events: &StateMap<Arc<ServerPdu>>) -> bool {
/// Helper function to fetch a field, `name`, from a "m.room.power_level" event's content. /// Helper function to fetch a field, `name`, from a "m.room.power_level" event's content.
/// or return `default` if no power level event is found or zero if no field matches `name`. /// or return `default` if no power level event is found or zero if no field matches `name`.
pub fn get_named_level(auth_events: &StateMap<Arc<ServerPdu>>, name: &str, default: i64) -> i64 { pub fn get_named_level<E: Event>(auth_events: &StateMap<Arc<E>>, name: &str, default: i64) -> i64 {
let power_level_event = auth_events.get(&(EventType::RoomPowerLevels, Some("".into()))); let power_level_event = auth_events.get(&(EventType::RoomPowerLevels, Some("".into())));
if let Some(pl) = power_level_event { if let Some(pl) = power_level_event {
// TODO do this the right way and deserialize // TODO do this the right way and deserialize
if let Some(level) = pl.content.get(name) { if let Some(level) = pl.content().get(name) {
level.to_string().parse().unwrap_or(default) level.to_string().parse().unwrap_or(default)
} else { } else {
0 0
@ -709,11 +706,11 @@ pub fn get_named_level(auth_events: &StateMap<Arc<ServerPdu>>, name: &str, defau
/// Helper function to fetch a users default power level from a "m.room.power_level" event's `users` /// Helper function to fetch a users default power level from a "m.room.power_level" event's `users`
/// object. /// object.
pub fn get_user_power_level(user_id: &UserId, auth_events: &StateMap<Arc<ServerPdu>>) -> i64 { pub fn get_user_power_level<E: Event>(user_id: &UserId, auth_events: &StateMap<Arc<E>>) -> i64 {
if let Some(pl) = auth_events.get(&(EventType::RoomPowerLevels, Some("".into()))) { if let Some(pl) = auth_events.get(&(EventType::RoomPowerLevels, Some("".into()))) {
if let Ok(content) = serde_json::from_value::<room::power_levels::PowerLevelsEventContent>( if let Ok(content) =
pl.content.clone(), serde_json::from_value::<room::power_levels::PowerLevelsEventContent>(pl.content())
) { {
if let Some(level) = content.users.get(user_id) { if let Some(level) = content.users.get(user_id) {
(*level).into() (*level).into()
} else { } else {
@ -727,7 +724,7 @@ pub fn get_user_power_level(user_id: &UserId, auth_events: &StateMap<Arc<ServerP
let key = (EventType::RoomCreate, Some("".into())); let key = (EventType::RoomCreate, Some("".into()));
if let Some(create) = auth_events.get(&key) { if let Some(create) = auth_events.get(&key) {
if let Ok(c) = if let Ok(c) =
serde_json::from_value::<room::create::CreateEventContent>(create.content.clone()) serde_json::from_value::<room::create::CreateEventContent>(create.content())
{ {
if &c.creator == user_id { if &c.creator == user_id {
100 100
@ -745,16 +742,16 @@ pub fn get_user_power_level(user_id: &UserId, auth_events: &StateMap<Arc<ServerP
/// Helper function to fetch the power level needed to send an event of type /// Helper function to fetch the power level needed to send an event of type
/// `e_type` based on the rooms "m.room.power_level" event. /// `e_type` based on the rooms "m.room.power_level" event.
pub fn get_send_level( pub fn get_send_level<E: Event>(
e_type: &EventType, e_type: &EventType,
state_key: Option<String>, state_key: Option<String>,
power_lvl: Option<&Arc<ServerPdu>>, power_lvl: Option<&Arc<E>>,
) -> i64 { ) -> i64 {
tracing::debug!("{:?} {:?}", e_type, state_key); tracing::debug!("{:?} {:?}", e_type, state_key);
if let Some(ple) = power_lvl { if let Some(ple) = power_lvl {
if let Ok(content) = serde_json::from_value::<room::power_levels::PowerLevelsEventContent>( if let Ok(content) =
ple.content.clone(), serde_json::from_value::<room::power_levels::PowerLevelsEventContent>(ple.content())
) { {
let mut lvl: i64 = content let mut lvl: i64 = content
.events .events
.get(&e_type) .get(&e_type)
@ -776,18 +773,15 @@ pub fn get_send_level(
} }
/// Check user can send invite. /// Check user can send invite.
pub fn can_send_invite( pub fn can_send_invite<E: Event>(event: &Arc<E>, auth_events: &StateMap<Arc<E>>) -> Result<bool> {
event: &Requester<'_>, let user_level = get_user_power_level(&event.sender(), auth_events);
auth_events: &StateMap<Arc<ServerPdu>>,
) -> Result<bool> {
let user_level = get_user_power_level(event.sender, auth_events);
let key = (EventType::RoomPowerLevels, Some("".into())); let key = (EventType::RoomPowerLevels, Some("".into()));
let invite_level = auth_events let invite_level = auth_events
.get(&key) .get(&key)
.map_or_else( .map_or_else(
|| Ok::<_, Error>(ruma::int!(50)), || Ok::<_, Error>(ruma::int!(50)),
|power_levels| { |power_levels| {
serde_json::from_value::<PowerLevelsEventContent>(power_levels.content.clone()) serde_json::from_value::<PowerLevelsEventContent>(power_levels.content())
.map(|pl| pl.invite) .map(|pl| pl.invite)
.map_err(Into::into) .map_err(Into::into)
}, },
@ -797,33 +791,33 @@ pub fn can_send_invite(
Ok(user_level >= invite_level) Ok(user_level >= invite_level)
} }
pub fn verify_third_party_invite( pub fn verify_third_party_invite<E: Event>(
event: &Requester<'_>, event: &Arc<E>,
tp_id: &member::ThirdPartyInvite, tp_id: &member::ThirdPartyInvite,
current_third_party_invite: Option<Arc<ServerPdu>>, current_third_party_invite: Option<Arc<E>>,
) -> bool { ) -> bool {
// 1. check for user being banned happens before this is called // 1. check for user being banned happens before this is called
// checking for mxid and token keys is done by ruma when deserializing // checking for mxid and token keys is done by ruma when deserializing
if event.state_key != Some(tp_id.signed.mxid.to_string()) { if event.state_key() != Some(tp_id.signed.mxid.to_string()) {
return false; return false;
} }
// If there is no m.room.third_party_invite event in the current room state // If there is no m.room.third_party_invite event in the current room state
// with state_key matching token, reject // with state_key matching token, reject
if let Some(current_tpid) = current_third_party_invite { if let Some(current_tpid) = current_third_party_invite {
if current_tpid.state_key.as_ref() != Some(&tp_id.signed.token) { if current_tpid.state_key().as_ref() != Some(&tp_id.signed.token) {
return false; return false;
} }
if event.sender != &current_tpid.sender { if event.sender() != current_tpid.sender() {
return false; return false;
} }
// If any signature in signed matches any public key in the m.room.third_party_invite event, allow // If any signature in signed matches any public key in the m.room.third_party_invite event, allow
if let Ok(tpid_ev) = serde_json::from_value::< if let Ok(tpid_ev) = serde_json::from_value::<
ruma::events::room::third_party_invite::ThirdPartyInviteEventContent, ruma::events::room::third_party_invite::ThirdPartyInviteEventContent,
>(current_tpid.content.clone()) >(current_tpid.content())
{ {
// A list of public keys in the public_keys field // A list of public keys in the public_keys field
for key in tpid_ev.public_keys.unwrap_or_default() { for key in tpid_ev.public_keys.unwrap_or_default() {

154
src/lib.rs
View File

@ -19,7 +19,7 @@ mod state_store;
pub use error::{Error, Result}; pub use error::{Error, Result};
pub use event_auth::{auth_check, auth_types_for_event}; pub use event_auth::{auth_check, auth_types_for_event};
pub use state_event::Requester; pub use state_event::{Event, Requester};
pub use state_store::StateStore; pub use state_store::StateStore;
// We want to yield to the reactor occasionally during state res when dealing // We want to yield to the reactor occasionally during state res when dealing
@ -41,13 +41,13 @@ impl StateResolution {
/// ///
/// This will authenticate the event against the current state of the room. It /// This will authenticate the event against the current state of the room. It
/// is important that the `current_state` argument is accurate and complete. /// is important that the `current_state` argument is accurate and complete.
pub fn apply_event( pub fn apply_event<E: Event>(
room_id: &RoomId, room_id: &RoomId,
room_version: &RoomVersionId, room_version: &RoomVersionId,
incoming_event: Arc<ServerPdu>, incoming_event: Arc<E>,
current_state: &StateMap<EventId>, current_state: &StateMap<EventId>,
event_map: Option<EventMap<Arc<ServerPdu>>>, event_map: Option<EventMap<Arc<E>>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
) -> Result<bool> { ) -> Result<bool> {
tracing::info!("Applying a single event, state resolution starting"); tracing::info!("Applying a single event, state resolution starting");
let ev = incoming_event; let ev = incoming_event;
@ -57,19 +57,16 @@ impl StateResolution {
} else { } else {
EventMap::new() EventMap::new()
}; };
let prev_event = if let Some(id) = ev.prev_events.first() { let prev_event = if let Some(id) = ev.prev_events().first() {
store.get_event(room_id, id).ok() store.get_event(room_id, id).ok()
} else { } else {
None None
}; };
let mut auth_events = StateMap::new(); let mut auth_events = StateMap::new();
for key in event_auth::auth_types_for_event( for key in
&ev.kind, event_auth::auth_types_for_event(&ev.kind(), &ev.sender(), ev.state_key(), ev.content())
&ev.sender, {
ev.state_key.clone(),
ev.content.clone(),
) {
if let Some(ev_id) = current_state.get(&key) { if let Some(ev_id) = current_state.get(&key) {
if let Some(event) = if let Some(event) =
StateResolution::get_or_load_event(room_id, ev_id, &mut event_map, store) StateResolution::get_or_load_event(room_id, ev_id, &mut event_map, store)
@ -101,13 +98,13 @@ impl StateResolution {
/// ///
/// It is up the the caller to check that the events returned from `StateStore::get_event` are /// It is up the the caller to check that the events returned from `StateStore::get_event` are
/// events for the correct room (synapse checks that all events are in the right room). /// events for the correct room (synapse checks that all events are in the right room).
pub fn resolve( pub fn resolve<E: Event>(
room_id: &RoomId, room_id: &RoomId,
room_version: &RoomVersionId, room_version: &RoomVersionId,
state_sets: &[StateMap<EventId>], state_sets: &[StateMap<EventId>],
// TODO: make the `Option<&mut EventMap<Arc<ServerPdu>>>` // TODO: make the `Option<&mut EventMap<Arc<ServerPdu>>>`
event_map: Option<EventMap<Arc<ServerPdu>>>, event_map: Option<EventMap<Arc<E>>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
) -> Result<StateMap<EventId>> { ) -> Result<StateMap<EventId>> {
tracing::info!("State resolution starting"); tracing::info!("State resolution starting");
@ -157,7 +154,7 @@ impl StateResolution {
.unwrap(); .unwrap();
// update event_map to include the fetched events // update event_map to include the fetched events
event_map.extend(events.into_iter().map(|ev| (ev.event_id.clone(), ev))); event_map.extend(events.into_iter().map(|ev| (ev.event_id(), ev)));
// at this point our event_map == store there should be no missing events // at this point our event_map == store there should be no missing events
tracing::debug!("event map size: {}", event_map.len()); tracing::debug!("event map size: {}", event_map.len());
@ -312,10 +309,10 @@ impl StateResolution {
} }
/// Returns a Vec of deduped EventIds that appear in some chains but not others. /// Returns a Vec of deduped EventIds that appear in some chains but not others.
pub fn get_auth_chain_diff( pub fn get_auth_chain_diff<E: Event>(
room_id: &RoomId, room_id: &RoomId,
state_sets: &[StateMap<EventId>], state_sets: &[StateMap<EventId>],
store: &dyn StateStore, store: &dyn StateStore<E>,
) -> Result<Vec<EventId>> { ) -> Result<Vec<EventId>> {
use itertools::Itertools; use itertools::Itertools;
@ -338,11 +335,11 @@ impl StateResolution {
/// ///
/// The power level is negative because a higher power level is equated to an /// The power level is negative because a higher power level is equated to an
/// earlier (further back in time) origin server timestamp. /// earlier (further back in time) origin server timestamp.
pub fn reverse_topological_power_sort( pub fn reverse_topological_power_sort<E: Event>(
room_id: &RoomId, room_id: &RoomId,
events_to_sort: &[EventId], events_to_sort: &[EventId],
event_map: &mut EventMap<Arc<ServerPdu>>, event_map: &mut EventMap<Arc<E>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
auth_diff: &[EventId], auth_diff: &[EventId],
) -> Vec<EventId> { ) -> Vec<EventId> {
tracing::debug!("reverse topological sort of power events"); tracing::debug!("reverse topological sort of power events");
@ -381,12 +378,12 @@ impl StateResolution {
let ev = event_map.get(event_id).unwrap(); let ev = event_map.get(event_id).unwrap();
let pl = event_to_pl.get(event_id).unwrap(); let pl = event_to_pl.get(event_id).unwrap();
tracing::debug!("{:?}", (-*pl, ev.origin_server_ts, &ev.event_id)); tracing::debug!("{:?}", (-*pl, ev.origin_server_ts(), &ev.event_id()));
// This return value is the key used for sorting events, // This return value is the key used for sorting events,
// events are then sorted by power level, time, // events are then sorted by power level, time,
// and lexically by event_id. // and lexically by event_id.
(-*pl, ev.origin_server_ts, ev.event_id.clone()) (-*pl, ev.origin_server_ts(), ev.event_id())
}) })
} }
@ -464,11 +461,11 @@ impl StateResolution {
} }
/// Find the power level for the sender of `event_id` or return a default value of zero. /// Find the power level for the sender of `event_id` or return a default value of zero.
fn get_power_level_for_sender( fn get_power_level_for_sender<E: Event>(
room_id: &RoomId, room_id: &RoomId,
event_id: &EventId, event_id: &EventId,
event_map: &mut EventMap<Arc<ServerPdu>>, event_map: &mut EventMap<Arc<E>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
) -> i64 { ) -> i64 {
tracing::info!("fetch event ({}) senders power level", event_id.to_string()); tracing::info!("fetch event ({}) senders power level", event_id.to_string());
@ -479,7 +476,7 @@ impl StateResolution {
// event.auth_event_ids does not include its own event id ? // event.auth_event_ids does not include its own event id ?
for aid in event for aid in event
.as_ref() .as_ref()
.map(|pdu| pdu.auth_events.to_vec()) .map(|pdu| pdu.auth_events())
.unwrap_or_default() .unwrap_or_default()
{ {
if let Some(aev) = StateResolution::get_or_load_event(room_id, &aid, event_map, store) { if let Some(aev) = StateResolution::get_or_load_event(room_id, &aid, event_map, store) {
@ -497,15 +494,15 @@ impl StateResolution {
if let Some(content) = pl if let Some(content) = pl
.map(|pl| { .map(|pl| {
serde_json::from_value::<ruma::events::room::power_levels::PowerLevelsEventContent>( serde_json::from_value::<ruma::events::room::power_levels::PowerLevelsEventContent>(
pl.content.clone(), pl.content(),
) )
.ok() .ok()
}) })
.flatten() .flatten()
{ {
if let Some(ev) = event { if let Some(ev) = event {
if let Some(user) = content.users.get(&ev.sender) { if let Some(user) = content.users.get(&ev.sender()) {
tracing::debug!("found {} at power_level {}", ev.sender.to_string(), user); tracing::debug!("found {} at power_level {}", ev.sender().to_string(), user);
return (*user).into(); return (*user).into();
} }
} }
@ -525,13 +522,13 @@ impl StateResolution {
/// For each `events_to_check` event we gather the events needed to auth it from the /// For each `events_to_check` event we gather the events needed to auth it from the
/// `event_map` or `store` and verify each event using the `event_auth::auth_check` /// `event_map` or `store` and verify each event using the `event_auth::auth_check`
/// function. /// function.
pub fn iterative_auth_check( pub fn iterative_auth_check<E: Event>(
room_id: &RoomId, room_id: &RoomId,
room_version: &RoomVersionId, room_version: &RoomVersionId,
events_to_check: &[EventId], events_to_check: &[EventId],
unconflicted_state: &StateMap<EventId>, unconflicted_state: &StateMap<EventId>,
event_map: &mut EventMap<Arc<ServerPdu>>, event_map: &mut EventMap<Arc<E>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
) -> Result<StateMap<EventId>> { ) -> Result<StateMap<EventId>> {
tracing::info!("starting iterative auth check"); tracing::info!("starting iterative auth check");
@ -550,23 +547,23 @@ impl StateResolution {
StateResolution::get_or_load_event(room_id, event_id, event_map, store).unwrap(); StateResolution::get_or_load_event(room_id, event_id, event_map, store).unwrap();
let mut auth_events = BTreeMap::new(); let mut auth_events = BTreeMap::new();
for aid in &event.auth_events { for aid in &event.auth_events() {
if let Some(ev) = if let Some(ev) =
StateResolution::get_or_load_event(room_id, &aid, event_map, store) StateResolution::get_or_load_event(room_id, &aid, event_map, store)
{ {
// TODO what to do when no state_key is found ?? // TODO what to do when no state_key is found ??
// TODO synapse check "rejected_reason", I'm guessing this is redacted_because in ruma ?? // TODO synapse check "rejected_reason", I'm guessing this is redacted_because in ruma ??
auth_events.insert((ev.kind.clone(), ev.state_key.clone()), ev); auth_events.insert((ev.kind(), ev.state_key()), ev);
} else { } else {
tracing::warn!("auth event id for {} is missing {}", aid, event_id); tracing::warn!("auth event id for {} is missing {}", aid, event_id);
} }
} }
for key in event_auth::auth_types_for_event( for key in event_auth::auth_types_for_event(
&event.kind, &event.kind(),
&event.sender, &event.sender(),
event.state_key.clone(), event.state_key(),
event.content.clone(), event.content(),
) { ) {
if let Some(ev_id) = resolved_state.get(&key) { if let Some(ev_id) = resolved_state.get(&key) {
if let Some(event) = if let Some(event) =
@ -578,10 +575,10 @@ impl StateResolution {
} }
} }
tracing::debug!("event to check {:?}", event.event_id.as_str()); tracing::debug!("event to check {:?}", event.event_id().as_str());
let most_recent_prev_event = event let most_recent_prev_event = event
.prev_events .prev_events()
.iter() .iter()
.filter_map(|id| StateResolution::get_or_load_event(room_id, id, event_map, store)) .filter_map(|id| StateResolution::get_or_load_event(room_id, id, event_map, store))
.next_back(); .next_back();
@ -589,7 +586,7 @@ impl StateResolution {
// The key for this is (eventType + a state_key of the signed token not sender) so search // The key for this is (eventType + a state_key of the signed token not sender) so search
// for it // for it
let current_third_party = auth_events.iter().find_map(|(_, pdu)| { let current_third_party = auth_events.iter().find_map(|(_, pdu)| {
if pdu.kind == EventType::RoomThirdPartyInvite { if pdu.kind() == EventType::RoomThirdPartyInvite {
Some(pdu.clone()) // TODO no clone, auth_events is borrowed while moved Some(pdu.clone()) // TODO no clone, auth_events is borrowed while moved
} else { } else {
None None
@ -604,10 +601,7 @@ impl StateResolution {
current_third_party, current_third_party,
)? { )? {
// add event to resolved state map // add event to resolved state map
resolved_state.insert( resolved_state.insert((event.kind(), event.state_key()), event_id.clone());
(event.kind.clone(), event.state_key.clone()),
event_id.clone(),
);
} else { } else {
// synapse passes here on AuthError. We do not add this event to resolved_state. // synapse passes here on AuthError. We do not add this event to resolved_state.
tracing::warn!( tracing::warn!(
@ -632,12 +626,12 @@ impl StateResolution {
/// power_level event. If there have been two power events the after the most recent are /// power_level event. If there have been two power events the after the most recent are
/// depth 0, the events before (with the first power level as a parent) will be marked /// depth 0, the events before (with the first power level as a parent) will be marked
/// as depth 1. depth 1 is "older" than depth 0. /// as depth 1. depth 1 is "older" than depth 0.
pub fn mainline_sort( pub fn mainline_sort<E: Event>(
room_id: &RoomId, room_id: &RoomId,
to_sort: &[EventId], to_sort: &[EventId],
resolved_power_level: Option<&EventId>, resolved_power_level: Option<&EventId>,
event_map: &mut EventMap<Arc<ServerPdu>>, event_map: &mut EventMap<Arc<E>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
) -> Vec<EventId> { ) -> Vec<EventId> {
tracing::debug!("mainline sort of events"); tracing::debug!("mainline sort of events");
@ -653,7 +647,7 @@ impl StateResolution {
mainline.push(p.clone()); mainline.push(p.clone());
let event = StateResolution::get_or_load_event(room_id, &p, event_map, store).unwrap(); let event = StateResolution::get_or_load_event(room_id, &p, event_map, store).unwrap();
let auth_events = &event.auth_events; let auth_events = &event.auth_events();
pl = None; pl = None;
for aid in auth_events { for aid in auth_events {
let ev = let ev =
@ -694,7 +688,7 @@ impl StateResolution {
ev_id, ev_id,
( (
depth, depth,
event_map.get(ev_id).map(|ev| ev.origin_server_ts), event_map.get(ev_id).map(|ev| ev.origin_server_ts()),
ev_id, // TODO should this be a &str to sort lexically?? ev_id, // TODO should this be a &str to sort lexically??
), ),
); );
@ -718,22 +712,22 @@ impl StateResolution {
/// Get the mainline depth from the `mainline_map` or finds a power_level event /// Get the mainline depth from the `mainline_map` or finds a power_level event
/// that has an associated mainline depth. /// that has an associated mainline depth.
fn get_mainline_depth( fn get_mainline_depth<E: Event>(
room_id: &RoomId, room_id: &RoomId,
mut event: Option<Arc<ServerPdu>>, mut event: Option<Arc<E>>,
mainline_map: &EventMap<usize>, mainline_map: &EventMap<usize>,
event_map: &mut EventMap<Arc<ServerPdu>>, event_map: &mut EventMap<Arc<E>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
) -> Result<usize> { ) -> Result<usize> {
while let Some(sort_ev) = event { while let Some(sort_ev) = event {
tracing::debug!("mainline event_id {}", sort_ev.event_id.to_string()); tracing::debug!("mainline event_id {}", sort_ev.event_id().to_string());
let id = &sort_ev.event_id; let id = &sort_ev.event_id();
if let Some(depth) = mainline_map.get(&id) { if let Some(depth) = mainline_map.get(&id) {
return Ok(*depth); return Ok(*depth);
} }
// dbg!(&sort_ev); // dbg!(&sort_ev);
let auth_events = &sort_ev.auth_events; let auth_events = &sort_ev.auth_events();
event = None; event = None;
for aid in auth_events { for aid in auth_events {
// dbg!(&aid); // dbg!(&aid);
@ -749,12 +743,12 @@ impl StateResolution {
Ok(0) Ok(0)
} }
fn add_event_and_auth_chain_to_graph( fn add_event_and_auth_chain_to_graph<E: Event>(
room_id: &RoomId, room_id: &RoomId,
graph: &mut BTreeMap<EventId, Vec<EventId>>, graph: &mut BTreeMap<EventId, Vec<EventId>>,
event_id: &EventId, event_id: &EventId,
event_map: &mut EventMap<Arc<ServerPdu>>, event_map: &mut EventMap<Arc<E>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
auth_diff: &[EventId], auth_diff: &[EventId],
) { ) {
let mut state = vec![event_id.clone()]; let mut state = vec![event_id.clone()];
@ -766,7 +760,7 @@ impl StateResolution {
// otherwise it seems we can loop forever // otherwise it seems we can loop forever
for aid in &StateResolution::get_or_load_event(room_id, &eid, event_map, store) for aid in &StateResolution::get_or_load_event(room_id, &eid, event_map, store)
.unwrap() .unwrap()
.auth_events .auth_events()
{ {
if auth_diff.contains(&aid) { if auth_diff.contains(&aid) {
if !graph.contains_key(&aid) { if !graph.contains_key(&aid) {
@ -786,12 +780,12 @@ impl StateResolution {
/// if the event_map does not have the PDU. /// if the event_map does not have the PDU.
/// ///
/// If the PDU is missing from the `event_map` it is added. /// If the PDU is missing from the `event_map` it is added.
fn get_or_load_event( fn get_or_load_event<E: Event>(
room_id: &RoomId, room_id: &RoomId,
ev_id: &EventId, ev_id: &EventId,
event_map: &mut EventMap<Arc<ServerPdu>>, event_map: &mut EventMap<Arc<E>>,
store: &dyn StateStore, store: &dyn StateStore<E>,
) -> Option<Arc<ServerPdu>> { ) -> Option<Arc<E>> {
if let Some(e) = event_map.get(ev_id) { if let Some(e) = event_map.get(ev_id) {
return Some(Arc::clone(e)); return Some(Arc::clone(e));
} }
@ -804,32 +798,32 @@ impl StateResolution {
} }
} }
pub fn is_power_event_id(event_id: &EventId, event_map: &EventMap<Arc<ServerPdu>>) -> bool { pub fn is_power_event_id<E: Event>(event_id: &EventId, event_map: &EventMap<Arc<E>>) -> bool {
match event_map.get(event_id) { match event_map.get(event_id) {
Some(state) => is_power_event(state), Some(state) => is_power_event(state),
_ => false, _ => false,
} }
} }
pub fn is_type_and_key(ev: &Arc<ServerPdu>, ev_type: EventType, state_key: &str) -> bool { pub fn is_type_and_key<E: Event>(ev: &Arc<E>, ev_type: EventType, state_key: &str) -> bool {
ev.kind == ev_type && ev.state_key.as_deref() == Some(state_key) ev.kind() == ev_type && ev.state_key().as_deref() == Some(state_key)
} }
pub fn is_power_event(event: &Arc<ServerPdu>) -> bool { pub fn is_power_event<E: Event>(event: &Arc<E>) -> bool {
use ruma::events::room::member::{MemberEventContent, MembershipState}; use ruma::events::room::member::{MemberEventContent, MembershipState};
match event.kind { match event.kind() {
EventType::RoomPowerLevels | EventType::RoomJoinRules | EventType::RoomCreate => { EventType::RoomPowerLevels | EventType::RoomJoinRules | EventType::RoomCreate => {
event.state_key == Some("".into()) event.state_key() == Some("".into())
} }
EventType::RoomMember => { EventType::RoomMember => {
if let Ok(content) = if let Ok(content) =
// TODO fix clone // TODO fix clone
serde_json::from_value::<MemberEventContent>(event.content.clone()) serde_json::from_value::<MemberEventContent>(event.content())
{ {
if [MembershipState::Leave, MembershipState::Ban].contains(&content.membership) { if [MembershipState::Leave, MembershipState::Ban].contains(&content.membership) {
return event.sender.as_str() return event.sender().as_str()
// TODO is None here a failure // TODO is None here a failure
!= event.state_key.as_deref().unwrap_or("NOT A STATE KEY"); != event.state_key().as_deref().unwrap_or("NOT A STATE KEY");
} }
} }
@ -838,13 +832,3 @@ pub fn is_power_event(event: &Arc<ServerPdu>) -> bool {
_ => false, _ => false,
} }
} }
pub fn to_requester(event: &Arc<ServerPdu>) -> Requester<'_> {
Requester {
prev_event_ids: event.prev_events.to_vec(),
room_id: &event.room_id,
content: &event.content,
state_key: event.state_key.clone(),
sender: &event.sender,
}
}

45
src/state_event.rs
View File

@ -8,12 +8,55 @@ use ruma::{
EventDeHelper, EventType, EventDeHelper, EventType,
}, },
serde::CanonicalJsonValue, serde::CanonicalJsonValue,
signatures::reference_hash, signatures::{reference_hash, CanonicalJsonObject},
EventId, RoomId, RoomVersionId, ServerName, UInt, UserId, EventId, RoomId, RoomVersionId, ServerName, UInt, UserId,
}; };
use serde::{de, ser, Deserialize, Serialize}; use serde::{de, ser, Deserialize, Serialize};
use serde_json::value::RawValue as RawJsonValue; use serde_json::value::RawValue as RawJsonValue;
/// Abstraction of a PDU so users can have their own PDU types.
pub trait Event {
/// The `EventId` of this event.
fn event_id(&self) -> EventId;
/// The `RoomId` of this event.
fn room_id(&self) -> RoomId;
/// The `UserId` of this event.
fn sender(&self) -> UserId;
/// The time of creation on the originating server.
fn origin_server_ts(&self) -> SystemTime;
/// The kind of event.
fn kind(&self) -> EventType;
/// The `UserId` of this PDU.
fn content(&self) -> serde_json::Value;
/// The state key for this event.
fn state_key(&self) -> Option<String>;
/// The events before this event.
fn prev_events(&self) -> Vec<EventId>;
/// The maximum number of `prev_events` plus 1.
fn depth(&self) -> UInt;
/// All the authenticating events for this event.
fn auth_events(&self) -> Vec<EventId>;
/// If this event is a redaction event this is the event it redacts.
fn redacts(&self) -> Option<EventId>;
/// The `unsigned` content of this event.
fn unsigned(&self) -> CanonicalJsonObject;
fn hashes(&self) -> &EventHash;
fn signatures(&self) -> BTreeMap<Box<ServerName>, BTreeMap<ruma::ServerSigningKeyId, String>>;
}
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
struct EventIdHelper { struct EventIdHelper {
event_id: EventId, event_id: EventId,

10
src/state_store.rs
View File

@ -5,14 +5,14 @@ use ruma::{
identifiers::{EventId, RoomId}, identifiers::{EventId, RoomId},
}; };
use crate::Result; use crate::{Event, Result};
pub trait StateStore { pub trait StateStore<E: Event> {
/// Return a single event based on the EventId. /// Return a single event based on the EventId.
fn get_event(&self, room_id: &RoomId, event_id: &EventId) -> Result<Arc<ServerPdu>>; fn get_event(&self, room_id: &RoomId, event_id: &EventId) -> Result<Arc<E>>;
/// Returns the events that correspond to the `event_ids` sorted in the same order. /// Returns the events that correspond to the `event_ids` sorted in the same order.
fn get_events(&self, room_id: &RoomId, event_ids: &[EventId]) -> Result<Vec<Arc<ServerPdu>>> { fn get_events(&self, room_id: &RoomId, event_ids: &[EventId]) -> Result<Vec<Arc<E>>> {
let mut events = vec![]; let mut events = vec![];
for id in event_ids { for id in event_ids {
events.push(self.get_event(room_id, id)?); events.push(self.get_event(room_id, id)?);
@ -36,7 +36,7 @@ pub trait StateStore {
let event = self.get_event(room_id, &ev_id)?; let event = self.get_event(room_id, &ev_id)?;
stack.extend(event.auth_events.clone()); stack.extend(event.auth_events().clone());
} }
Ok(result) Ok(result)