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#[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#[implement(super::Service)]
115#[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 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 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 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 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 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 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() .and_then(|upgraded| {
268 self.upgrade_outlier_to_timeline_pdu(upgrade, incoming_pdu, pdu)
269 .boxed() .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#[implement(super::Service)]
300#[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 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 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 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#[implement(super::Service)]
461async fn handle_prev_events(
462 &self,
463 upgrade: PrevUpgrade<'_>,
464 sorted_prev_events: Vec<OwnedEventId>,
465 mut pdus: Pdus, ) -> 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() .await?;
502
503 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() .await
515}
516
517#[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}