Skip to main content

tuwunel_service/rooms/event_handler/
handle_incoming_pdu.rs

1use futures::{FutureExt, TryFutureExt, TryStreamExt, future::try_join4};
2use ruma::{
3	CanonicalJsonObject, CanonicalJsonValue, EventId, OwnedEventId, RoomId, ServerName, UserId,
4	events::{
5		AnyStrippedStateEvent, StateEventType,
6		room::member::{MembershipState, RoomMemberEventContent},
7	},
8};
9use tuwunel_core::{
10	Err, Result, async_noinline, debug,
11	debug::INFO_SPAN_LEVEL,
12	debug_warn, err, implement,
13	smallvec::SmallVec,
14	trace,
15	utils::{
16		BoolExt,
17		future::ReadyEqExt,
18		result::NotFound,
19		stream::{IterStream, TryBroadbandExt, TryReadyExt},
20	},
21	warn,
22};
23use tuwunel_matrix::{
24	Event, PduCount, PduEvent, pdu::MAX_PREV_EVENTS, room_version::from_create_event,
25};
26
27use super::{
28	backoff::{Context, Disposition, Suppression, UPGRADE_RETRY},
29	fetch_prev::{Pdus, PrevFetch},
30	handle_prev_pdu::PrevUpgrade,
31	prev_walk::PrevWalk,
32	room_version_of,
33};
34use crate::rooms::{state_cache::MembershipUpdate, timeline::RawPduId};
35
36type PrevSplit = SmallVec<[OwnedEventId; MAX_PREV_EVENTS]>;
37
38type Handled = Option<(RawPduId, bool)>;
39
40/// Handle a PDU a peer pushed to this server in a federation transaction.
41///
42/// A room every local user has left keeps its stored events and frozen state,
43/// and resolving a pushed event against them can rewrite a local member's
44/// membership, so such a room takes an inviter's rescission and nothing else.
45/// A rescission is signature-checked and clears only that inviter's own invite,
46/// so the room's frozen ACLs and disabled flag do not gate it. Anything else is
47/// dropped as handled, since the sender's view of the room is stale and a retry
48/// cannot help.
49///
50/// The caller holds the room's federation mutex, which a remote join keeps
51/// until its join event is appended, so a PDU arriving during a join waits for
52/// that join and reads the server as resident.
53#[implement(super::Service)]
54pub async fn handle_pushed_pdu<'a>(
55	&'a self,
56	origin: &'a ServerName,
57	room_id: &'a RoomId,
58	event_id: &'a EventId,
59	pdu: CanonicalJsonObject,
60) -> Result<Handled> {
61	let resident = self
62		.services
63		.state_cache
64		.server_in_room_result(self.services.globals.server_name(), room_id)
65		.await?;
66
67	if resident {
68		return self
69			.handle_incoming_pdu(origin, room_id, event_id, pdu, true)
70			.await;
71	}
72
73	if self
74		.handle_rescinded_invite(room_id, event_id, &pdu)
75		.await?
76		.is_false()
77	{
78		debug!(%origin, "Dropping a PDU for a room this server is not in.");
79	}
80
81	Ok(None)
82}
83
84/// Handle an event received from a federation peer.
85///
86/// Only a push is gated on this server being in the room, through
87/// `handle_pushed_pdu`; backfill and the membership routes reach rooms it has
88/// left. When receiving an event one needs to:
89/// 1. Skip the PDU if we already know about it
90/// 1.1. Remove unsigned field
91/// 2. Check signatures, otherwise drop
92/// 3. Check content hash, redact if doesn't match
93/// 4. Fetch any missing auth events doing all checks listed here starting at 1.
94///    These are not timeline events
95/// 5. Reject "due to auth events" if can't get all the auth events or some of
96///    the auth events are also rejected "due to auth events"
97/// 6. Reject "due to auth events" if the event doesn't pass auth based on the
98///    auth events
99/// 7. Persist this event as an outlier
100/// 8. If not timeline event: stop
101/// 9. Fetch any missing prev events doing all checks listed here starting at 1.
102///    These are timeline events
103/// 10. Fetch missing state and auth chain events by calling `/state_ids` at
104///     backwards extremities doing all the checks in this list starting at
105///     1. These are not timeline events
106/// 11. Check the auth of the event passes based on the state of the event
107/// 12. Ensure that the state is derived from the previous current state (i.e.
108///     we calculated by doing state res where one of the inputs was a
109///     previously trusted set of state, don't just trust a set of state we got
110///     from a remote)
111/// 13. Use state resolution to find new room state
112/// 14. Check if the event passes auth based on the "current state" of the room,
113///     if not soft fail it
114#[implement(super::Service)]
115// cross-crate codegen firewall
116#[async_noinline]
117#[tracing::instrument(
118	name = "pdu",
119	level = INFO_SPAN_LEVEL,
120	skip_all,
121	fields(%room_id, %event_id),
122	ret(level = "debug"),
123)]
124pub async fn handle_incoming_pdu<'a>(
125	&'a self,
126	origin: &'a ServerName,
127	room_id: &'a RoomId,
128	event_id: &'a EventId,
129	pdu: CanonicalJsonObject,
130	is_timeline_event: bool,
131) -> Result<Handled> {
132	// 1. Skip the PDU if we already have it as a timeline event
133	if let Ok(pdu_id) = self.services.timeline.get_pdu_id(event_id).await {
134		debug!(?pdu_id, "Exists.");
135		return Ok(Some((pdu_id, false)));
136	}
137
138	let is_disabled = self
139		.services
140		.metadata
141		.is_disabled(room_id)
142		.map(Ok);
143
144	let origin_acl_check = self.acl_check(origin, room_id);
145
146	let sender: &UserId = pdu
147		.get("sender")
148		.try_into()
149		.map_err(|e| err!(Request(InvalidParam("PDU does not have a valid sender key: {e}"))))?;
150
151	let sender_acl_check = sender
152		.server_name()
153		.ne(origin)
154		.then_async(|| self.acl_check(sender.server_name(), room_id));
155
156	// Absent when the room's state was never stored or was deleted.
157	let create_event = self
158		.services
159		.state_accessor
160		.room_state_get(room_id, &StateEventType::RoomCreate, "")
161		.map(|result| Ok(result.ok()));
162
163	let (is_disabled, (), (), create_event) = try_join4(
164		is_disabled,
165		origin_acl_check,
166		sender_acl_check.map(|o| o.unwrap_or(Ok(()))),
167		create_event,
168	)
169	.await?;
170
171	if is_disabled {
172		return Err!(Request(Forbidden("Federation of this room is disabled by this server.")));
173	}
174
175	let create_event =
176		create_event.ok_or_else(|| err!(Request(NotFound("Room is unknown to this server"))))?;
177
178	let room_version = from_create_event(&create_event)?;
179	let recursion_level = 0;
180
181	let (incoming_pdu, pdu) = self
182		.handle_outlier_pdu(origin, room_id, event_id, pdu, &room_version, recursion_level, false)
183		.await?;
184
185	// 8. if not timeline event: stop
186	if !is_timeline_event {
187		debug!(
188			kind = ?incoming_pdu.event_type(),
189			"Not a timeline event.",
190		);
191
192		return Ok(None);
193	}
194
195	let first_normal_ts = self
196		.services
197		.timeline
198		.first_normal_pdu_in_room(room_id)
199		.await?
200		.origin_server_ts();
201
202	let gapped = self
203		.services
204		.timeline
205		.non_outlier_pdus_exist(incoming_pdu.prev_events())
206		.eq(&false)
207		.await;
208
209	// An application service can backdate an event at the tip of the DAG.
210	if gapped && incoming_pdu.origin_server_ts() < first_normal_ts {
211		debug!(
212			origin_server_ts = ?incoming_pdu.origin_server_ts(),
213			?first_normal_ts,
214			"Skipping old event."
215		);
216
217		return Ok(None);
218	}
219
220	self.prev_walk.enter(gapped);
221
222	let create_event_id = create_event.event_id();
223	let upgrade = PrevUpgrade {
224		origin,
225		room_id,
226		event_id,
227		room_version: &room_version,
228		recursion_level,
229		first_normal_ts,
230		create_event_id,
231	};
232
233	// Start before the first await so a dropped future still settles the gapped count.
234	let pass = gapped.then(|| PrevWalk::start(self, &upgrade));
235
236	let standing = gapped
237		.then_async(|| self.is_suppressed(Context::Incoming, event_id, UPGRADE_RETRY))
238		.await
239		.unwrap_or(Suppression::Absent);
240
241	if standing.is_deny() {
242		if let Some(pass) = pass {
243			pass.hold();
244		}
245
246		debug_warn!(%origin, %room_id, %event_id, "Backing off from a gapped incoming event.");
247		return Ok(None);
248	}
249
250	// 9. Fetch any missing prev events doing all checks listed here starting at 1.
251	//    These are timeline events
252	let fetch = self
253		.fetch_prev(upgrade, incoming_pdu.prev_events())
254		.await;
255
256	let stopping = self.services.server.is_stopping();
257	let walk = pass.and_then(|pass| pass.fetched(fetch.as_ref(), stopping));
258	let fetch = fetch?;
259
260	let walking = fetch.sorted.is_empty().is_false();
261	let attempt = walking.then(|| self.record_attempt(Context::Incoming, event_id));
262	let PrevFetch { sorted, pdus, .. } = fetch;
263
264	let (handled, upgraded) = self
265		.handle_prev_events(upgrade, sorted, pdus)
266		.boxed() // size firewall
267		.and_then(|upgraded| {
268			self.upgrade_outlier_to_timeline_pdu(upgrade, incoming_pdu, pdu)
269				.boxed() // size firewall
270				.map(move |handled| Ok((handled, upgraded)))
271		})
272		.unwrap_or_else(|error| (Err(error), 0))
273		.await;
274
275	let appended = handled.as_ref().map(Option::is_some);
276
277	if let Some(walk) = walk {
278		walk.settle(appended, upgraded, self.services.server.is_stopping());
279	}
280
281	self.record_completion(Context::Incoming, event_id, standing, attempt, appended)
282		.await;
283
284	handled
285}
286
287/// Apply a federated leave that rescinds an out-of-band invite for a local
288/// user.
289///
290/// We are not resident in the room, so we hold no current state to process the
291/// kick against as a normal timeline event; but it must still clear the invite
292/// so the invited user's `/sync` reflects the rescission. Mirrors Synapse's
293/// out-of-band membership handling: only a kick from the original inviter is
294/// honored, since without the room state we cannot judge any other sender's
295/// authority. An event already accepted is a replay of history, which leaves a
296/// newer invite from that inviter alone. When the current invite has a recorded
297/// event ID, the kick must name it in `auth_events`. Returns `true` when a
298/// rescission was applied.
299#[implement(super::Service)]
300// cold arm: rescission, whose layout overflows the route's depth limit
301#[async_noinline]
302#[tracing::instrument(
303	name = "rescinded_invite",
304	level = "debug",
305	skip_all,
306	fields(%room_id),
307)]
308async fn handle_rescinded_invite<'a>(
309	&'a self,
310	room_id: &'a RoomId,
311	event_id: &'a EventId,
312	pdu: &'a CanonicalJsonObject,
313) -> Result<bool> {
314	if pdu
315		.get("type")
316		.and_then(CanonicalJsonValue::as_str)
317		!= Some("m.room.member")
318	{
319		return Ok(false);
320	}
321
322	let Some(target) = pdu
323		.get("state_key")
324		.and_then(CanonicalJsonValue::as_str)
325		.and_then(|state_key| UserId::parse(state_key).ok())
326	else {
327		return Ok(false);
328	};
329
330	let Some(sender) = pdu
331		.get("sender")
332		.and_then(CanonicalJsonValue::as_str)
333		.and_then(|sender| UserId::parse(sender).ok())
334	else {
335		return Ok(false);
336	};
337
338	if sender == target || !self.services.globals.user_is_local(&target) {
339		return Ok(false);
340	}
341
342	let Some(content) = pdu
343		.get("content")
344		.cloned()
345		.map(Into::into)
346		.and_then(|content| serde_json::from_value::<RoomMemberEventContent>(content).ok())
347	else {
348		return Ok(false);
349	};
350
351	if content.membership != MembershipState::Leave {
352		return Ok(false);
353	}
354
355	if self
356		.services
357		.state_cache
358		.user_membership(&target, room_id)
359		.ne(&Some(MembershipState::Invite))
360		.await
361	{
362		return Ok(false);
363	}
364
365	// Recover the inviter and the room version from the stored stripped state.
366	let invite_state = self
367		.services
368		.state_cache
369		.invite_state(&target, room_id)
370		.await?;
371
372	let inviter = invite_state
373		.iter()
374		.find_map(|event| match event.deserialize() {
375			| Ok(AnyStrippedStateEvent::RoomMember(member)) if member.state_key == target =>
376				Some(member.sender),
377			| _ => None,
378		});
379
380	// Honor the rescission only from the original inviter.
381	if inviter.as_ref() != Some(&sender) {
382		return Ok(false);
383	}
384
385	if self
386		.services
387		.timeline
388		.get_pdu_id(event_id)
389		.await
390		.optional()?
391		.is_some()
392	{
393		return Ok(false);
394	}
395
396	let invite_event = self
397		.services
398		.state_cache
399		.get_invite_event(room_id, &target)
400		.await?;
401
402	if invite_event.is_some_and(|invite_event| !authenticates_invite(pdu, &invite_event)) {
403		return Ok(false);
404	}
405
406	let Some(room_version_id) = room_version_of(&invite_state) else {
407		return Ok(false);
408	};
409
410	// Verify the kick is signed by the sender's server before acting on it.
411	self.services
412		.server_keys
413		.verify_event(pdu, Some(&room_version_id))
414		.await
415		.map_err(|e| {
416			err!(Request(InvalidParam("Invite rescission signature is invalid: {e}")))
417		})?;
418
419	let count = self.services.globals.next_count();
420	self.services
421		.state_cache
422		.update_membership(MembershipUpdate {
423			room_id,
424			user_id: &target,
425			membership_event: RoomMemberEventContent::new(MembershipState::Leave),
426			sender: &sender,
427			last_state: None,
428			invite_via: None,
429			invite_event: None,
430			update_joined_count: false,
431			replaced_join: None,
432			count: PduCount::Normal(*count),
433		})
434		.await?;
435
436	debug!(%room_id, %target, %sender, "Applied a federated invite rescission.");
437
438	Ok(true)
439}
440
441fn authenticates_invite(pdu: &CanonicalJsonObject, invite_event: &EventId) -> bool {
442	pdu.get("auth_events")
443		.and_then(CanonicalJsonValue::as_array)
444		.into_iter()
445		.flatten()
446		.filter_map(|event| match event {
447			| CanonicalJsonValue::String(event_id) => Some(event_id.as_str()),
448			| CanonicalJsonValue::Array(pair) =>
449				pair.first().and_then(CanonicalJsonValue::as_str),
450			| _ => None,
451		})
452		.any(|event_id| event_id == invite_event.as_str())
453}
454
455/// Upgrade an incoming PDU's previous events, walking interior events after
456/// their parents so each derives state locally instead of refetching it.
457///
458/// Extremities upgrade concurrently up to `prev_events_concurrency`; interior
459/// events upgrade one at a time. Returns how many previous events were upgraded.
460#[implement(super::Service)]
461async fn handle_prev_events(
462	&self,
463	upgrade: PrevUpgrade<'_>,
464	sorted_prev_events: Vec<OwnedEventId>,
465	mut pdus: Pdus, // HashMap::remove takes &mut self
466) -> Result<usize> {
467	trace!(
468		events = sorted_prev_events.len(),
469		event_ids = ?sorted_prev_events,
470		"Handling previous events"
471	);
472
473	let (interior, extremities): (PrevSplit, PrevSplit) = sorted_prev_events
474		.into_iter()
475		.partition(|prev_id| {
476			pdus.get(prev_id).is_some_and(|(pdu, _)| {
477				pdu.prev_events()
478					.any(|prev| pdus.contains_key(prev))
479			})
480		});
481
482	let concurrency = usize::from(
483		self.services
484			.server
485			.config
486			.federation
487			.history
488			.prev_events_concurrency,
489	);
490
491	let upgraded = extremities
492		.into_iter()
493		.try_stream()
494		.map_ok(|prev_id| (pdus.remove(&prev_id), prev_id))
495		.broadn_and_then(concurrency, async |(info, prev_id)| {
496			self.upgrade_prev_event(upgrade, info, &prev_id)
497				.await
498		})
499		.ready_try_fold(0, tally_upgraded)
500		.boxed() // size firewall
501		.await?;
502
503	// Walk interior events forward so each parent commits before its children.
504	interior
505		.into_iter()
506		.try_stream()
507		.map_ok(|prev_id| (pdus.remove(&prev_id), prev_id))
508		.and_then(async |(info, prev_id)| {
509			self.upgrade_prev_event(upgrade, info, &prev_id)
510				.await
511		})
512		.ready_try_fold(upgraded, tally_upgraded)
513		.boxed() // size firewall
514		.await
515}
516
517/// Upgrade one previous event, folding a failure into a non-fatal skip so a
518/// single bad prev does not abort the batch.
519///
520/// A failure records a transient backoff for the prev. A shutdown propagates
521/// through the leading running check; an interruption surfacing from inside
522/// the upgrade is not a verdict on the prev and records nothing.
523#[implement(super::Service)]
524async fn upgrade_prev_event(
525	&self,
526	upgrade: PrevUpgrade<'_>,
527	info: Option<(PduEvent, CanonicalJsonObject)>,
528	prev_id: &EventId,
529) -> Result<Handled> {
530	self.services.server.check_running()?;
531
532	let PrevUpgrade { room_id, event_id, .. } = upgrade;
533
534	match self.handle_prev_pdu(upgrade, info, prev_id).await {
535		| Err(error) if error.is_interrupted() || self.services.server.is_stopping() => {
536			debug!(?prev_id, ?event_id, ?room_id, %error, "Prev event processing interrupted.");
537
538			Ok(None)
539		},
540		| Err(error) => {
541			self.record_outcome(Context::Upgrade, prev_id, Disposition::Transient);
542			warn!(?prev_id, ?event_id, ?room_id, %error, "Prev event processing failed.");
543
544			Ok(None)
545		},
546		| Ok(None) => {
547			debug_warn!(?prev_id, "Prev event not processed.");
548
549			Ok(None)
550		},
551		| Ok(handled) => {
552			self.record_success(Context::Upgrade, prev_id)
553				.await;
554
555			debug!(?prev_id, ?handled, "Prev event processed.");
556
557			Ok(handled)
558		},
559	}
560}
561
562fn tally_upgraded(upgraded: usize, handled: Handled) -> Result<usize> {
563	Ok(upgraded.saturating_add(usize::from(handled.is_some())))
564}