Skip to main content

tuwunel_service/rooms/event_handler/
fetch_state.rs

1use std::collections::{HashMap, hash_map};
2
3use futures::FutureExt;
4use ruma::{EventId, OwnedEventId, RoomId, RoomVersionId, ServerName, events::StateEventType};
5use serde::Deserialize;
6use tuwunel_core::{Err, Result, debug, debug_warn, err, implement};
7use tuwunel_matrix::Event;
8
9use crate::{
10	fetcher::{Op, Opts},
11	rooms::short::ShortStateKey,
12};
13
14#[derive(Deserialize)]
15struct StateIdsResponse {
16	pdu_ids: Vec<OwnedEventId>,
17}
18
19/// Call /state_ids to find out what the state at this pdu is. We trust the
20/// server's response to some extend (sic), but we still do a lot of checks
21/// on the events
22#[implement(super::Service)]
23#[tracing::instrument(
24	level = "debug",
25	skip_all,
26	fields(%origin),
27)]
28pub(super) async fn fetch_state(
29	&self,
30	origin: &ServerName,
31	room_id: &RoomId,
32	event_id: &EventId,
33	room_version: &RoomVersionId,
34	recursion_level: usize,
35	create_event_id: &EventId,
36) -> Result<Option<HashMap<u64, OwnedEventId>>> {
37	let opts = Opts::new(Op::StateIds, room_id.to_owned())
38		.event_id(event_id.to_owned())
39		.hint(origin.to_owned())
40		.attempt_limit(super::EVENT_FETCH_ATTEMPT_LIMIT)
41		.fanout_for_op();
42
43	let outcome = self
44		.services
45		.fetcher
46		.fetch(opts)
47		.await
48		.inspect_err(|e| debug_warn!("Fetching state for event failed: {e}"))?;
49
50	let StateIdsResponse { pdu_ids } = serde_json::from_slice(&outcome.bytes)
51		.map_err(|e| err!(BadServerResponse("malformed state_ids response: {e}")))?;
52
53	debug!("Fetching state events");
54	let state_ids = pdu_ids.iter().map(AsRef::as_ref);
55	let state_vec = self
56		.fetch_auth(origin, room_id, state_ids, room_version, recursion_level)
57		.boxed() // cold arm: federation fallback
58		.await;
59
60	let mut state: HashMap<ShortStateKey, OwnedEventId> = HashMap::with_capacity(state_vec.len());
61	for (pdu, _) in state_vec {
62		let state_key = pdu
63			.state_key()
64			.ok_or_else(|| err!(Database("Found non-state pdu in state events.")))?;
65
66		let shortstatekey = self
67			.services
68			.short
69			.get_or_create_shortstatekey(&pdu.kind().to_string().into(), state_key)
70			.await;
71
72		match state.entry(shortstatekey) {
73			| hash_map::Entry::Vacant(v) => {
74				v.insert(pdu.event_id().to_owned());
75			},
76			| hash_map::Entry::Occupied(_) => {
77				return Err!(Request(InvalidParam(
78					"State event's type and state_key ({:?},{:?}) exists multiple times.",
79					pdu.event_type(),
80					pdu.state_key()
81						.expect("all state events have state_key"),
82				)));
83			},
84		}
85	}
86
87	// The original create event must still be in the state
88	let create_shortstatekey = self
89		.services
90		.short
91		.get_shortstatekey(&StateEventType::RoomCreate, "")
92		.await?;
93
94	if state
95		.get(&create_shortstatekey)
96		.map(AsRef::as_ref)
97		!= Some(create_event_id)
98	{
99		return Err!(Database("Incoming event refers to wrong create event."));
100	}
101
102	Ok(Some(state))
103}