1use std::{
2 borrow::Borrow,
3 collections::{BTreeMap, BTreeSet, HashMap, HashSet},
4 iter::once,
5 mem::take,
6 sync::Arc,
7};
8
9use futures::{FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt, future::join};
10use ruma::{
11 CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedServerName, OwnedUserId, RoomId,
12 RoomOrAliasId, RoomVersionId, UserId,
13 api::{error::ErrorKind, federation},
14 canonical_json::to_canonical_value,
15 events::{
16 StateEventType,
17 room::{
18 create::RoomCreateEventContent,
19 join_rules::RoomJoinRulesEventContent,
20 member::{MembershipState, RoomMemberEventContent},
21 },
22 },
23 room::{AllowRule, JoinRule},
24 room_version_rules::RoomVersionRules,
25};
26use serde_json::value::{RawValue as RawJsonValue, to_raw_value};
27use tuwunel_core::{
28 Err, Result, async_noinline, at, debug, debug_error, debug_info, debug_warn, err, error,
29 implement, info, trace,
30 utils::{
31 self, BoolExt, IterStream, ReadyExt, json::serialized_len, math::Expected, shuffle,
32 stream::WidebandExt,
33 },
34 warn,
35};
36use tuwunel_matrix::{
37 event::gen_event_id_canonical_json,
38 pdu::{Pdu, PduBuilder, check_rules},
39 room::state::resolution as state_res,
40 room_version,
41};
42
43use super::{Service, VerifiedPdu};
44use crate::{
45 Services,
46 federation::{Candidates, WhenAllBackedOff},
47 profile::check_member_content,
48 rooms::{
49 state::{IdMapState, RoomMutexGuard},
50 state_compressor::{CompressedState, HashSetCompressStateEvent},
51 },
52};
53
54const RESERVED_JOIN_KEYS: [&str; 3] =
59 ["reason", "third_party_signed", "join_authorised_via_users_server"];
60
61#[derive(Debug)]
62pub struct Join<'a> {
63 pub sender_user: &'a UserId,
64 pub room_id: &'a RoomId,
65 pub orig_room_id: Option<&'a RoomOrAliasId>,
66 pub reason: Option<String>,
67 pub servers: &'a [OwnedServerName],
68 pub is_appservice: bool,
69 pub extra_content: Option<CanonicalJsonObject>,
70}
71
72#[implement(Service)]
73#[async_noinline]
75#[tracing::instrument(
76 name = "join",
77 level = "debug",
78 skip_all,
79 fields(%sender_user, %room_id)
80)]
81pub async fn join<'a>(
82 &'a self,
83 Join {
84 sender_user,
85 room_id,
86 orig_room_id,
87 reason,
88 servers,
89 is_appservice,
90 extra_content,
91 }: Join<'a>,
92) -> Result {
93 let servers =
94 get_servers_for_room(&self.services, sender_user, room_id, orig_room_id, servers).await?;
95
96 let (federation_lock, state_lock) = self.lock_join(room_id, &servers).await;
97
98 self.check_room_ban(sender_user, room_id).await?;
99
100 let user_is_guest = !is_appservice && self.services.users.is_guest(sender_user).await;
101
102 if user_is_guest
103 && !self
104 .services
105 .state_accessor
106 .guest_can_join(room_id)
107 .await
108 {
109 return Err!(Request(Forbidden("Guests are not allowed to join this room")));
110 }
111
112 if self
113 .services
114 .state_cache
115 .is_joined(sender_user, room_id)
116 .await
117 {
118 debug_warn!(%sender_user, %room_id, "User is already joined.");
119 return Ok(());
120 }
121
122 if self
124 .banned_from_resident_room(sender_user, room_id)
125 .await
126 && self
127 .services
128 .state_cache
129 .is_invited(sender_user, room_id)
130 .await
131 .is_false()
132 {
133 debug_warn!(%sender_user, %room_id, "Banned user attempted to join.");
134 return Err!(Request(Forbidden("You are banned from the room.")));
135 }
136
137 match federation_lock {
138 | Some(federation_lock) if !self.is_local_join(room_id, &servers).await =>
139 self.join_remote(
140 sender_user,
141 room_id,
142 reason,
143 &servers,
144 federation_lock,
145 state_lock,
146 extra_content,
147 )
148 .boxed() .await?,
150 | federation_lock => {
151 drop(federation_lock);
152 self.join_local(sender_user, room_id, reason, &servers, state_lock, extra_content)
153 .boxed() .await?;
155 },
156 }
157
158 self.copy_predecessor_push_rules(sender_user, room_id)
159 .await;
160
161 Ok(())
162}
163
164#[implement(Service)]
170#[tracing::instrument(level = "debug", skip_all)]
171pub async fn check_extra_content(
172 &self,
173 sender_user: &UserId,
174 room_id: &RoomId,
175 extra_content: Option<&CanonicalJsonObject>,
176) -> Result {
177 if extra_content.is_none()
178 || self
179 .services
180 .state_cache
181 .is_joined(sender_user, room_id)
182 .await
183 {
184 return Ok(());
185 }
186
187 let content = RoomMemberEventContent::new(MembershipState::Join);
188
189 self.merged_join_content(sender_user, content, extra_content)
190 .await
191 .map(drop)
192}
193
194#[implement(Service)]
195async fn merged_join_content(
196 &self,
197 sender_user: &UserId,
198 content: RoomMemberEventContent,
199 extra_content: Option<&CanonicalJsonObject>,
200) -> Result<CanonicalJsonValue> {
201 let content = self
202 .services
203 .profile
204 .fill_content(sender_user, content)
205 .await;
206
207 let max_bytes = self
208 .services
209 .config
210 .profile
211 .member_event_max_bytes;
212
213 merge_member_content(max_bytes, content, extra_content)
214}
215
216#[implement(Service)]
217async fn check_room_ban(&self, sender_user: &UserId, room_id: &RoomId) -> Result {
218 if self.services.metadata.is_banned(room_id).await
219 && !self
220 .services
221 .admin
222 .user_is_admin(sender_user)
223 .await
224 {
225 return Err!(Request(Forbidden("This room is banned on this homeserver.")));
226 }
227
228 Ok(())
229}
230
231#[implement(Service)]
237async fn lock_join(
238 &self,
239 room_id: &RoomId,
240 servers: &[OwnedServerName],
241) -> (Option<RoomMutexGuard>, RoomMutexGuard) {
242 if !self.is_local_join(room_id, servers).await {
243 let (federation_lock, state_lock) = self.lock_join_remote(room_id).await;
244
245 return (Some(federation_lock), state_lock);
246 }
247
248 let state_lock = self.services.state.mutex.lock(room_id).await;
249
250 if self.is_local_join(room_id, servers).await {
251 return (None, state_lock);
252 }
253
254 drop(state_lock);
255 let (federation_lock, state_lock) = self.lock_join_remote(room_id).await;
256
257 (Some(federation_lock), state_lock)
258}
259
260#[implement(Service)]
261async fn is_local_join(&self, room_id: &RoomId, servers: &[OwnedServerName]) -> bool {
262 servers.is_empty()
263 || (servers.len() == 1 && self.services.globals.server_is_ours(&servers[0]))
264 || self
265 .services
266 .state_cache
267 .server_in_room(self.services.globals.server_name(), room_id)
268 .await
269}
270
271#[implement(Service)]
272async fn lock_join_remote(&self, room_id: &RoomId) -> (RoomMutexGuard, RoomMutexGuard) {
273 let federation_lock = self
276 .services
277 .event_handler
278 .mutex_federation
279 .lock(room_id)
280 .await;
281
282 let state_lock = self.services.state.mutex.lock(room_id).await;
283
284 (federation_lock, state_lock)
285}
286
287#[implement(Service)]
288async fn copy_predecessor_push_rules(&self, user_id: &UserId, room_id: &RoomId) {
289 let Ok(create): Result<RoomCreateEventContent> = self
290 .services
291 .state_accessor
292 .room_state_get_content(room_id, &StateEventType::RoomCreate, "")
293 .await
294 else {
295 return;
296 };
297
298 let Some(predecessor) = create.predecessor else {
299 return;
300 };
301
302 self.services
303 .account_data
304 .copy_room_push_rule(user_id, &predecessor.room_id, room_id)
305 .await
306 .ok();
307}
308
309#[implement(Service)]
310#[expect(clippy::too_many_arguments)]
311#[tracing::instrument(
312 name = "remote",
313 level = "debug",
314 skip_all,
315 fields(?servers)
316)]
317async fn join_remote(
318 &self,
319 sender_user: &UserId,
320 room_id: &RoomId,
321 reason: Option<String>,
322 servers: &[OwnedServerName],
323 _federation_lock: RoomMutexGuard,
324 state_lock: RoomMutexGuard,
325 extra_content: Option<CanonicalJsonObject>,
326) -> Result {
327 info!("Joining {room_id} over federation.");
328
329 let (make_join_response, remote_server) = self
330 .make_join_request(sender_user, room_id, servers)
331 .await?;
332
333 info!("make_join finished");
334
335 let room_version_id = self.require_supported_remote_room_version(&make_join_response)?;
336 let room_version_rules = room_version::rules(&room_version_id)?;
337 let (mut join_event, event_id, join_authorized_via_users_server) = self
338 .create_join_event(
339 room_id,
340 sender_user,
341 &make_join_response.event,
342 &room_version_id,
343 &room_version_rules,
344 reason,
345 extra_content,
346 )
347 .await?;
348
349 let mut response = self
350 .execute_send_join(
351 &remote_server,
352 room_id,
353 &event_id,
354 join_event.clone(),
355 &room_version_id,
356 )
357 .await?;
358
359 if response.members_omitted {
360 self.fetch_omitted_state(&remote_server, room_id, &event_id, servers, &mut response)
361 .await?;
362 }
363
364 if join_authorized_via_users_server.is_some() {
365 merge_restricted_signature(
366 &remote_server,
367 &event_id,
368 &room_version_id,
369 &response,
370 &mut join_event,
371 )?;
372 }
373
374 let shortroomid = self
375 .services
376 .short
377 .get_or_create_shortroomid(room_id)
378 .await;
379
380 info!(
381 %room_id,
382 %shortroomid,
383 "Initialized room. Parsing join event..."
384 );
385 let (parsed_join_pdu, join_event) =
386 Pdu::from_object_federation(room_id, &event_id, join_event, &room_version_rules)?;
387
388 info!(
389 events = response
390 .state
391 .len()
392 .expected_add(response.auth_chain.len()),
393 "Acquiring server signing keys for response events..."
394 );
395 self.services
396 .server_keys
397 .acquire_events_pubkeys(
398 response
399 .auth_chain
400 .iter()
401 .chain(response.state.iter()),
402 )
403 .await;
404
405 let state = self
406 .ingest_send_join_state(room_id, &room_version_id, &room_version_rules, &response.state)
407 .await;
408
409 self.ingest_send_join_auth_chain(
410 room_id,
411 &room_version_id,
412 &room_version_rules,
413 &response.auth_chain,
414 )
415 .await;
416
417 debug!("Running send_join auth check...");
418 state_res::auth_check(
419 &room_version_rules,
420 &parsed_join_pdu,
421 &*self.services.timeline,
422 IdMapState { services: &self.services, ids: &state },
423 )
424 .and_then(async |outcome| outcome.into_result())
425 .inspect_err(|e| error!(?e, "send_join auth check failed"))
426 .boxed() .await?;
428
429 self.apply_send_join_state(room_id, &state, &state_lock)
430 .await?;
431
432 let statehash_after_join = self
435 .services
436 .state
437 .append_to_state(&parsed_join_pdu)
438 .await?;
439
440 info!(
441 event_id = %parsed_join_pdu.event_id,
442 "Appending new room join event..."
443 );
444
445 self.services
446 .timeline
447 .append_pdu(
448 &parsed_join_pdu,
449 join_event,
450 once(parsed_join_pdu.event_id.borrow()),
451 Some(statehash_after_join),
452 &state_lock,
453 )
454 .await?;
455
456 info!(
457 statehash = %statehash_after_join,
458 "Set final room state for new room."
459 );
460
461 Ok(())
462}
463
464#[implement(Service)]
465fn require_supported_remote_room_version(
466 &self,
467 make_join_response: &federation::membership::prepare_join_event::v1::Response,
468) -> Result<RoomVersionId> {
469 let Some(room_version_id) = make_join_response.room_version.clone() else {
470 return Err!(BadServerResponse("Remote room version is not supported by tuwunel"));
471 };
472
473 self.services
474 .config
475 .require_supported_room_version(&room_version_id)?;
476
477 Ok(room_version_id)
478}
479
480#[implement(Service)]
481async fn execute_send_join(
482 &self,
483 remote_server: &OwnedServerName,
484 room_id: &RoomId,
485 event_id: &OwnedEventId,
486 join_event: CanonicalJsonObject,
487 room_version_id: &RoomVersionId,
488) -> Result<federation::membership::create_join_event::v2::RoomState> {
489 let send_join_request = federation::membership::create_join_event::v2::Request {
490 room_id: room_id.to_owned(),
491 event_id: event_id.clone(),
492 omit_members: true,
493 pdu: self
494 .services
495 .federation
496 .format_pdu_into(join_event, Some(room_version_id))
497 .await,
498 };
499
500 info!("Asking {remote_server} for fast_join in room {room_id}");
501 let response = self
502 .services
503 .federation
504 .execute(remote_server, send_join_request)
505 .await
506 .inspect_err(|e| error!("send_join failed: {e}"))?
507 .room_state;
508
509 info!(
510 fast_join = response.members_omitted,
511 auth_chain = response.auth_chain.len(),
512 state = response.state.len(),
513 servers = response
514 .servers_in_room
515 .as_ref()
516 .map(Vec::len)
517 .unwrap_or(0),
518 "send_join finished"
519 );
520
521 Ok(response)
522}
523
524#[implement(Service)]
525async fn fetch_omitted_state(
526 &self,
527 remote_server: &OwnedServerName,
528 room_id: &RoomId,
529 event_id: &OwnedEventId,
530 servers: &[OwnedServerName],
531 response: &mut federation::membership::create_join_event::v2::RoomState,
532) -> Result {
533 use federation::event::get_room_state::v1::{Request, Response};
534
535 let eligible =
536 self.omitted_state_servers(remote_server, servers, response.servers_in_room.as_deref());
537
538 let candidates = self
539 .services
540 .federation
541 .rank_candidates(eligible, WhenAllBackedOff::Attempt)
542 .await;
543
544 let mut last_error = Err!(BadServerResponse("No server provided omitted send_join state."));
545 for server in candidates {
546 info!("Asking {server} for state in room {room_id}");
547 let result = self
548 .services
549 .federation
550 .execute(&server, Request {
551 room_id: room_id.to_owned(),
552 event_id: event_id.clone(),
553 })
554 .await;
555
556 match result {
557 | Err(e) => {
558 debug_warn!(?server, "state fetch failed: {e}");
559 last_error = Err(e);
560 },
561 | Ok(Response { mut auth_chain, mut pdus }) => {
562 response.auth_chain = take(&mut auth_chain);
563 response.state = take(&mut pdus);
564
565 info!(
566 auth_chain = response.auth_chain.len(),
567 state = response.state.len(),
568 "state finished"
569 );
570
571 return Ok(());
572 },
573 }
574 }
575
576 last_error
577}
578
579#[implement(Service)]
580fn omitted_state_servers(
581 &self,
582 remote_server: &OwnedServerName,
583 servers: &[OwnedServerName],
584 servers_in_room: Option<&[String]>,
585) -> Candidates {
586 let extracted = servers_in_room
587 .into_iter()
588 .flatten()
589 .filter_map(|server| OwnedServerName::parse(server.as_str()).ok());
590
591 let limit = self
592 .services
593 .config
594 .rooms
595 .joins
596 .max_make_join_per_attempt;
597
598 let mut seen = BTreeSet::new();
599 once(remote_server.clone())
600 .chain(extracted)
601 .chain(servers.iter().cloned())
602 .filter(|server| !self.services.globals.server_is_ours(server))
603 .filter(move |server| seen.insert(server.clone()))
604 .take(limit)
605 .collect()
606}
607
608fn merge_restricted_signature(
609 remote_server: &OwnedServerName,
610 event_id: &OwnedEventId,
611 room_version_id: &RoomVersionId,
612 response: &federation::membership::create_join_event::v2::RoomState,
613 join_event: &mut CanonicalJsonObject,
614) -> Result {
615 let Some(signed_raw) = &response.event else {
616 return Ok(());
617 };
618
619 debug_info!(
620 "There is a signed event with join_authorized_via_users_server. This room is probably \
621 using restricted joins. Adding signature to our event"
622 );
623
624 let (signed_event_id, signed_value) =
625 gen_event_id_canonical_json(signed_raw, room_version_id).map_err(|e| {
626 err!(Request(BadJson(warn!("Could not convert event to canonical JSON: {e}"))))
627 })?;
628
629 if signed_event_id != *event_id {
630 return Err!(Request(BadJson(warn!(
631 %signed_event_id, %event_id,
632 "Server {remote_server} sent event with wrong event ID"
633 ))));
634 }
635
636 let signature = signed_value["signatures"]
637 .as_object()
638 .ok_or_else(|| {
639 err!(BadServerResponse(warn!("Server {remote_server} sent invalid signatures type")))
640 })
641 .and_then(|e| {
642 e.get(remote_server.as_str()).ok_or_else(|| {
643 err!(BadServerResponse(warn!(
644 "Server {remote_server} did not send its signature for a restricted room"
645 )))
646 })
647 });
648
649 match signature {
650 | Ok(signature) => {
651 join_event
652 .get_mut("signatures")
653 .expect("we created a valid pdu")
654 .as_object_mut()
655 .expect("we created a valid pdu")
656 .insert(remote_server.as_str().into(), signature.clone());
657 },
658 | Err(e) => {
659 warn!(
660 "Server {remote_server} sent invalid signature in send_join signatures for \
661 event {signed_value:?}: {e:?}",
662 );
663 },
664 }
665
666 Ok(())
667}
668
669#[implement(Service)]
670async fn ingest_send_join_state(
671 &self,
672 room_id: &RoomId,
673 room_version_id: &RoomVersionId,
674 room_version_rules: &RoomVersionRules,
675 state_pdus: &[Box<RawJsonValue>],
676) -> HashMap<u64, OwnedEventId> {
677 info!(events = state_pdus.len(), "Going through send_join response room_state...");
678 let cork = self.services.db.cork_and_flush();
679 let state = self
680 .verified_pdus(room_id, room_version_id, room_version_rules, state_pdus, "state")
681 .then(async |(event_id, pdu, value, verified)| {
682 self.services
683 .timeline
684 .add_verified_outlier(&event_id, &value, &verified)
685 .await;
686
687 (event_id, pdu)
688 })
689 .wide_filter_map(async |(event_id, pdu)| {
690 let state_key = pdu.state_key.as_ref()?;
691 let shortstatekey = self
692 .services
693 .short
694 .get_or_create_shortstatekey(&pdu.kind.to_cow_str().as_ref().into(), state_key)
695 .await;
696
697 Some((shortstatekey, event_id))
698 })
699 .collect()
700 .await;
701
702 drop(cork);
703 state
704}
705
706#[implement(Service)]
711fn verified_pdus<'a>(
712 &'a self,
713 room_id: &'a RoomId,
714 room_version_id: &'a RoomVersionId,
715 room_version_rules: &'a RoomVersionRules,
716 pdus: &'a [Box<RawJsonValue>],
717 list: &'static str,
718) -> impl Stream<Item = VerifiedPdu> + Send + 'a {
719 pdus.iter()
720 .stream()
721 .wide_then(|pdu| self.verified_pdu(room_id, room_version_id, room_version_rules, pdu))
722 .inspect_err(move |error| debug_error!(?error, list, "Invalid send_join event."))
723 .ready_filter_map(Result::ok)
724}
725
726#[implement(Service)]
727async fn ingest_send_join_auth_chain(
728 &self,
729 room_id: &RoomId,
730 room_version_id: &RoomVersionId,
731 room_version_rules: &RoomVersionRules,
732 auth_chain: &[Box<RawJsonValue>],
733) {
734 info!(events = auth_chain.len(), "Going through send_join response auth_chain...");
735 let cork = self.services.db.cork_and_flush();
736
737 self.verified_pdus(room_id, room_version_id, room_version_rules, auth_chain, "auth_chain")
738 .for_each(async |(event_id, _, value, verified)| {
739 self.services
740 .timeline
741 .add_verified_outlier(&event_id, &value, &verified)
742 .await;
743 })
744 .await;
745
746 drop(cork);
747}
748
749#[implement(Service)]
750async fn apply_send_join_state(
751 &self,
752 room_id: &RoomId,
753 state: &HashMap<u64, OwnedEventId>,
754 state_lock: &RoomMutexGuard,
755) -> Result {
756 info!(events = state.len(), "Compressing state from send_join...");
757 let compressed: CompressedState = self
758 .services
759 .state_compressor
760 .compress_state_events(state.iter().map(|(ssk, eid)| (ssk, eid.borrow())))
761 .collect()
762 .await;
763
764 debug!("Saving compressed state...");
765 let HashSetCompressStateEvent {
766 shortstatehash: statehash_before_join,
767 added,
768 removed,
769 } = self
770 .services
771 .state_compressor
772 .save_state(room_id, Arc::new(compressed))
773 .await?;
774
775 debug!(
776 state_hash = ?statehash_before_join,
777 "Forcing state for new room..."
778 );
779 self.services
780 .state
781 .force_state(room_id, statehash_before_join, added, removed, state_lock)
782 .await?;
783
784 self.services
785 .state_cache
786 .update_joined_count(room_id)
787 .await;
788
789 Ok(())
790}
791
792#[implement(Service)]
793#[tracing::instrument(name = "local", level = "debug", skip_all)]
794async fn join_local(
795 &self,
796 sender_user: &UserId,
797 room_id: &RoomId,
798 reason: Option<String>,
799 servers: &[OwnedServerName],
800 state_lock: RoomMutexGuard,
801 extra_content: Option<CanonicalJsonObject>,
802) -> Result {
803 debug_info!("We can join locally");
804
805 let join_rules_event_content = self
806 .services
807 .state_accessor
808 .room_state_get_content::<RoomJoinRulesEventContent>(
809 room_id,
810 &StateEventType::RoomJoinRules,
811 "",
812 )
813 .await;
814
815 let restriction_rooms = match join_rules_event_content {
816 | Ok(RoomJoinRulesEventContent {
817 join_rule: JoinRule::Restricted(restricted) | JoinRule::KnockRestricted(restricted),
818 }) => restricted
819 .allow
820 .into_iter()
821 .filter_map(|a| match a {
822 | AllowRule::RoomMembership(r) => Some(r.room_id),
823 | _ => None,
824 })
825 .collect(),
826 | _ => Vec::new(),
827 };
828
829 let is_joined_restricted_rooms = self
830 .services
831 .state_cache
832 .is_joined_any(sender_user, restriction_rooms.iter().map(AsRef::as_ref))
833 .await;
834
835 let join_authorized_via_users_server = is_joined_restricted_rooms
836 .then_async(async || {
837 self.services
838 .state_cache
839 .local_users_in_room(room_id)
840 .filter(|user| {
841 self.services.state_accessor.user_can_invite(
842 room_id,
843 user,
844 sender_user,
845 &state_lock,
846 )
847 })
848 .map(ToOwned::to_owned)
849 .boxed() .next()
851 .await
852 })
853 .map(Option::flatten)
854 .await;
855
856 let content = RoomMemberEventContent {
857 reason: reason.clone(),
858 join_authorized_via_users_server,
859 ..RoomMemberEventContent::new(MembershipState::Join)
860 };
861
862 let content = self
863 .merged_join_content(sender_user, content, extra_content.as_ref())
864 .await?;
865
866 let pdu_builder = PduBuilder {
867 event_type: StateEventType::RoomMember.into(),
868 content: to_raw_value(&content).map(Into::into)?,
869 state_key: Some(sender_user.to_string().into()),
870 ..Default::default()
871 };
872
873 let Err(error) = self
875 .services
876 .timeline
877 .build_and_append_pdu(pdu_builder, sender_user, room_id, &state_lock)
878 .await
879 else {
880 return Ok(());
881 };
882
883 if restriction_rooms.is_empty()
884 && (servers.is_empty()
885 || servers.len() == 1 && self.services.globals.server_is_ours(&servers[0]))
886 {
887 return Err(error);
888 }
889
890 warn!(
891 "We couldn't do the join locally, maybe federation can help to satisfy the restricted \
892 join requirements"
893 );
894
895 drop(state_lock);
898 let (federation_lock, state_lock) = self.lock_join_remote(room_id).await;
899
900 self.check_room_ban(sender_user, room_id).await?;
901 drop(state_lock);
902
903 let Ok((make_join_response, remote_server)) = self
904 .make_join_request(sender_user, room_id, servers)
905 .await
906 else {
907 return Err(error);
908 };
909
910 let room_version_id = self.require_supported_remote_room_version(&make_join_response)?;
911 let room_version_rules = room_version::rules(&room_version_id)?;
912 let (join_event, event_id, _) = self
913 .create_join_event(
914 room_id,
915 sender_user,
916 &make_join_response.event,
917 &room_version_id,
918 &room_version_rules,
919 reason,
920 extra_content,
921 )
922 .await?;
923
924 let send_join_response = self
925 .execute_send_join(&remote_server, room_id, &event_id, join_event, &room_version_id)
926 .await?;
927
928 let Some(signed_raw) = send_join_response.event else {
929 return Err(error);
930 };
931
932 let (signed_event_id, signed_value) =
933 gen_event_id_canonical_json(&signed_raw, &room_version_id).map_err(|e| {
934 err!(Request(BadJson(warn!("Could not convert event to canonical JSON: {e}"))))
935 })?;
936
937 if signed_event_id != event_id {
938 return Err!(Request(BadJson(warn!(
939 %signed_event_id, %event_id, "Server {remote_server} sent event with wrong event ID"
940 ))));
941 }
942
943 self.services
944 .event_handler
945 .handle_incoming_pdu(&remote_server, room_id, &signed_event_id, signed_value, true)
946 .await?
947 .ok_or_else(|| {
948 err!(Request(InvalidParam("Signed join was not accepted as a timeline event.")))
949 })?;
950
951 drop(federation_lock);
952
953 Ok(())
954}
955
956#[implement(Service)]
957#[expect(clippy::too_many_arguments)]
958#[tracing::instrument(name = "make_join", level = "debug", skip_all)]
959async fn create_join_event(
960 &self,
961 room_id: &RoomId,
962 sender_user: &UserId,
963 join_event_stub: &RawJsonValue,
964 room_version_id: &RoomVersionId,
965 room_version_rules: &RoomVersionRules,
966 reason: Option<String>,
967 extra_content: Option<CanonicalJsonObject>,
968) -> Result<(CanonicalJsonObject, OwnedEventId, Option<OwnedUserId>)> {
969 let mut event: CanonicalJsonObject =
970 serde_json::from_str(join_event_stub.get()).map_err(|e| {
971 err!(BadServerResponse("Invalid make_join event json received from server: {e:?}"))
972 })?;
973
974 let join_authorized_via_users_server = room_version_rules
975 .authorization
976 .restricted_join_rule
977 .then(|| event.get("content"))
978 .flatten()
979 .and_then(|s| {
980 s.as_object()?
981 .get("join_authorised_via_users_server")
982 })
983 .and_then(|s| OwnedUserId::try_from(s.as_str().unwrap_or_default()).ok());
984
985 let content = RoomMemberEventContent {
986 reason,
987 join_authorized_via_users_server: join_authorized_via_users_server.clone(),
988 ..RoomMemberEventContent::new(MembershipState::Join)
989 };
990
991 let content = self
992 .merged_join_content(sender_user, content, extra_content.as_ref())
993 .await?;
994
995 event.insert("content".into(), content);
996
997 event.insert(
998 "origin".into(),
999 CanonicalJsonValue::String(
1000 self.services
1001 .globals
1002 .server_name()
1003 .as_str()
1004 .to_owned(),
1005 ),
1006 );
1007
1008 event.insert(
1009 "origin_server_ts".into(),
1010 CanonicalJsonValue::Integer(utils::millis_since_unix_epoch().try_into()?),
1011 );
1012
1013 event.insert("room_id".into(), CanonicalJsonValue::String(room_id.as_str().into()));
1014
1015 event.insert("sender".into(), CanonicalJsonValue::String(sender_user.as_str().into()));
1016
1017 event.insert("state_key".into(), CanonicalJsonValue::String(sender_user.as_str().into()));
1018
1019 event.insert("type".into(), CanonicalJsonValue::String("m.room.member".into()));
1020
1021 let event_id = self
1022 .services
1023 .server_keys
1024 .gen_id_hash_and_sign_event(&mut event, room_version_id)?;
1025
1026 check_rules(&event, &room_version_rules.event_format)?;
1027
1028 Ok((event, event_id, join_authorized_via_users_server))
1029}
1030
1031fn merge_member_content(
1033 max_bytes: usize,
1034 content: RoomMemberEventContent,
1035 extra_content: Option<&CanonicalJsonObject>,
1036) -> Result<CanonicalJsonValue> {
1037 let bound_name = content.displayname.is_none();
1039 let bound_avatar = content.avatar_url.is_none();
1040 let server = to_canonical_value(content)?;
1041
1042 let Some(extra_content) = extra_content else {
1043 return Ok(server);
1044 };
1045
1046 let CanonicalJsonValue::Object(server) = server else {
1047 return Ok(server);
1048 };
1049
1050 let extra: BTreeMap<&str, &CanonicalJsonValue> = extra_content
1052 .iter()
1053 .filter(|(key, _)| !is_reserved_join_key(key))
1054 .map(|(key, value)| (key.as_str(), value))
1055 .collect();
1056
1057 let displayname = bound_string(&extra, "displayname", bound_name)?;
1058 let avatar_url = bound_string(&extra, "avatar_url", bound_avatar)?;
1059
1060 check_member_content(max_bytes, serialized_len(&extra)?, displayname, avatar_url)?;
1061
1062 let merged = extra
1063 .into_iter()
1064 .fold(server, |mut merged, (key, value)| {
1065 if !merged.contains_key(key) {
1066 merged.insert(key.into(), value.clone());
1067 }
1068
1069 merged
1070 });
1071
1072 Ok(CanonicalJsonValue::Object(merged))
1073}
1074
1075#[must_use]
1080pub fn is_reserved_join_key(key: &str) -> bool { RESERVED_JOIN_KEYS.contains(&key) }
1081
1082fn bound_string<'a>(
1084 extra: &BTreeMap<&str, &'a CanonicalJsonValue>,
1085 key: &str,
1086 bound: bool,
1087) -> Result<Option<&'a str>> {
1088 extra
1089 .get(key)
1090 .copied()
1091 .filter(|value| bound && !matches!(value, CanonicalJsonValue::Null))
1092 .map(|value| {
1093 value
1094 .as_str()
1095 .ok_or_else(|| err!(Request(BadJson("{key} must be a string."))))
1096 })
1097 .transpose()
1098}
1099
1100#[implement(Service)]
1101#[tracing::instrument(
1102 name = "make_join",
1103 level = "debug",
1104 skip_all,
1105 fields(?servers)
1106)]
1107async fn make_join_request(
1108 &self,
1109 sender_user: &UserId,
1110 room_id: &RoomId,
1111 servers: &[OwnedServerName],
1112) -> Result<(federation::membership::prepare_join_event::v1::Response, OwnedServerName)> {
1113 let mut make_join_response_and_server =
1114 Err!(BadServerResponse("No server available to assist in joining."));
1115
1116 let mut make_join_counter: usize = 0;
1117 let mut incompatible_room_version_count: usize = 0;
1118
1119 for remote_server in servers {
1120 if self
1121 .services
1122 .globals
1123 .server_is_ours(remote_server)
1124 {
1125 continue;
1126 }
1127 info!("Asking {remote_server} for make_join ({make_join_counter})");
1128 let make_join_response = self
1129 .services
1130 .federation
1131 .execute(remote_server, federation::membership::prepare_join_event::v1::Request {
1132 room_id: room_id.to_owned(),
1133 user_id: sender_user.to_owned(),
1134 ver: self
1135 .services
1136 .config
1137 .supported_room_versions()
1138 .map(at!(0))
1139 .collect(),
1140 })
1141 .await;
1142
1143 trace!("make_join response: {make_join_response:?}");
1144 make_join_counter = make_join_counter.saturating_add(1);
1145
1146 if let Err(ref e) = make_join_response {
1147 if matches!(
1148 e.kind(),
1149 ErrorKind::IncompatibleRoomVersion { .. } | ErrorKind::UnsupportedRoomVersion
1150 ) {
1151 incompatible_room_version_count =
1152 incompatible_room_version_count.saturating_add(1);
1153 }
1154
1155 if incompatible_room_version_count > 15 {
1156 info!(
1157 "15 servers have responded with M_INCOMPATIBLE_ROOM_VERSION or \
1158 M_UNSUPPORTED_ROOM_VERSION, assuming that tuwunel does not support the \
1159 room version {room_id}: {e}"
1160 );
1161
1162 return make_join_response.map(|r| (r, remote_server.clone()));
1163 }
1164
1165 let max_attempts = self
1166 .services
1167 .config
1168 .rooms
1169 .joins
1170 .max_make_join_per_attempt;
1171
1172 if make_join_counter >= max_attempts {
1173 warn!(?remote_server, "last make_join failure reason: {e}");
1174 warn!(
1175 "{max_attempts} servers failed to provide valid make_join response, \
1176 assuming no server can assist in joining."
1177 );
1178
1179 make_join_response_and_server =
1180 Err!(BadServerResponse("No server available to assist in joining."));
1181
1182 return make_join_response_and_server;
1183 }
1184 }
1185
1186 make_join_response_and_server = make_join_response.map(|r| (r, remote_server.clone()));
1187
1188 if make_join_response_and_server.is_ok() {
1189 break;
1190 }
1191 }
1192
1193 make_join_response_and_server
1194}
1195
1196pub(super) async fn get_servers_for_room(
1197 services: &Services,
1198 user_id: &UserId,
1199 room_id: &RoomId,
1200 orig_room_id: Option<&RoomOrAliasId>,
1201 via: &[OwnedServerName],
1202) -> Result<Vec<OwnedServerName>> {
1203 let additional_servers = services
1205 .state_cache
1206 .servers_invite_via(room_id)
1207 .map(ToOwned::to_owned)
1208 .collect::<Vec<_>>();
1209
1210 let invite_state = services
1211 .state_cache
1212 .invite_state(user_id, room_id)
1213 .map(Result::unwrap_or_default);
1214
1215 let (additional_servers, invite_state) = join(additional_servers, invite_state).await;
1216
1217 let mut servers = Vec::from(via);
1218 shuffle(&mut servers);
1219
1220 let has_remote_via = via
1223 .iter()
1224 .any(|s| !services.globals.server_is_ours(s));
1225
1226 if !has_remote_via {
1227 if let Some(server_name) = room_id.server_name() {
1228 servers.insert(0, server_name.to_owned());
1229 }
1230
1231 if let Some(orig_room_id) = orig_room_id
1232 && let Some(orig_server_name) = orig_room_id.server_name()
1233 {
1234 servers.insert(0, orig_server_name.to_owned());
1235 }
1236 }
1237
1238 let extend_and_shuffle = |mut servers: Vec<OwnedServerName>| {
1239 servers.extend(
1240 invite_state
1241 .iter()
1242 .filter_map(|event| event.get_field("sender").ok().flatten())
1243 .filter_map(|sender: &str| UserId::parse(sender).ok())
1244 .map(|user| user.server_name().to_owned()),
1245 );
1246
1247 shuffle(&mut servers);
1248 servers
1249 };
1250
1251 let additional_servers = extend_and_shuffle(additional_servers);
1252
1253 servers.extend_from_slice(&additional_servers);
1254
1255 debug!(?servers);
1260
1261 let mut set = HashSet::new();
1263 servers.retain(|x| set.insert(x.clone()));
1264 debug!(?servers);
1265
1266 if !servers.is_empty() {
1268 for i in 0..servers.len() {
1269 if services
1270 .server
1271 .config
1272 .rooms
1273 .joins
1274 .deprioritize_servers
1275 .is_match(servers[i].host())
1276 {
1277 let server = servers.remove(i);
1278 servers.push(server);
1279 }
1280 }
1281 }
1282
1283 debug_info!(?servers);
1284 Ok(servers)
1285}
1286
1287#[cfg(test)]
1288mod tests;