Skip to main content

tuwunel_service/membership/
join.rs

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
54/// Keys a client may not set on `/join`, because the server owns them.
55///
56/// The `/join` route and `merge_member_content` both drop them, so the merged
57/// member event never carries one from a client.
58const 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// cross-crate codegen firewall
74#[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	// Resolved state can lag a federated re-invite; trust the invite index.
123	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() // cold arm: remote join
149			.await?,
150		| federation_lock => {
151			drop(federation_lock);
152			self.join_local(sender_user, room_id, reason, &servers, state_lock, extra_content)
153				.boxed() // size firewall
154				.await?;
155		},
156	}
157
158	self.copy_predecessor_push_rules(sender_user, room_id)
159		.await;
160
161	Ok(())
162}
163
164/// Refuses `/join` extras that a join would refuse once it is under way.
165///
166/// The route retries a failed join on other servers, and a refused body fails
167/// the same way on every attempt, so it is refused here before one is made. A
168/// join by a member changes nothing, so a member's extras pass.
169#[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/// Acquires the room's federation and state mutexes in canonical order.
232///
233/// A remote join needs both mutexes, but the branch is final only under the
234/// state mutex. The unlocked prediction is revalidated under the locks, so
235/// correctness does not depend on it.
236#[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	// Hold federation before state so inbound events stay belayed until the join
274	// response is applied.
275	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() // cold arm: remote-join auth check
427	.await?;
428
429	self.apply_send_join_state(room_id, &state, &state_lock)
430		.await?;
431
432	// Prepare the join's snapshot before appending. The append installs current
433	// state after the timeline row exists and before publishing its stream count.
434	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/// Verifies the events of one send_join response list, dropping each that fails.
707///
708/// The events come back in their response order, each in the form this server
709/// stores it. The list's name labels the log of a failing event.
710#[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() // Unpin for next
850				.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	// Try normal join first
874	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 before the federation fallback: handle_incoming_pdu re-acquires
896	// the same per-room state mutex while ingesting prev_events; deadlock.
897	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
1031// The server's fields win the merge, and client keys only fill the gaps.
1032fn merge_member_content(
1033	max_bytes: usize,
1034	content: RoomMemberEventContent,
1035	extra_content: Option<&CanonicalJsonObject>,
1036) -> Result<CanonicalJsonValue> {
1037	// The server's name and avatar win the merge, so only client values are bounded.
1038	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	// Server-owned keys are dropped here too, so no caller can set them.
1051	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/// Whether a client's `/join` key is one the server owns.
1076///
1077/// A client value under such a key is dropped, never merged into the member
1078/// event the server builds.
1079#[must_use]
1080pub fn is_reserved_join_key(key: &str) -> bool { RESERVED_JOIN_KEYS.contains(&key) }
1081
1082// A remote join sends the merged content as it is, so a non-string cannot pass here.
1083fn 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	// add invited vias
1204	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	// Strict via: an explicit remote server in via must not be padded with
1221	// the room owner, otherwise failover-probe semantics break.
1222	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	// 1. (room alias server)?
1256	// 2. (room id server)?
1257	// 3. shuffle [via query + resolve servers]?
1258	// 4. shuffle [invited via, inviters servers]?
1259	debug!(?servers);
1260
1261	// dedup preserving order
1262	let mut set = HashSet::new();
1263	servers.retain(|x| set.insert(x.clone()));
1264	debug!(?servers);
1265
1266	// sort deprioritized servers last
1267	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;