Skip to main content

tuwunel_service/membership/
leave.rs

1use std::collections::HashSet;
2
3use futures::{
4	FutureExt, StreamExt, TryFutureExt,
5	future::{join, ready},
6};
7use ruma::{
8	CanonicalJsonObject, CanonicalJsonValue, OwnedServerName, RoomId, UserId,
9	api::federation,
10	canonical_json::to_canonical_value,
11	events::{
12		AnyStrippedStateEvent, StateEventType,
13		room::member::{MembershipState, RoomMemberEventContent},
14	},
15	serde::Raw,
16};
17use tuwunel_core::{
18	Err, Error, Result, async_noinline, debug_info, debug_warn, err, implement,
19	utils::{self, FutureBoolExt, future::ReadyBoolExt},
20	warn,
21};
22use tuwunel_matrix::{
23	PduCount,
24	pdu::{PduBuilder, check_rules},
25	room_version,
26};
27
28use super::Service;
29use crate::rooms::{state_cache::MembershipUpdate, timeline::RoomMutexGuard};
30
31#[implement(Service)]
32// cross-crate codegen firewall
33#[async_noinline]
34#[tracing::instrument(
35    name = "leave",
36    level = "debug",
37    skip_all,
38    fields(%room_id, %user_id)
39)]
40pub async fn leave<'a>(
41	&'a self,
42	user_id: &'a UserId,
43	room_id: &'a RoomId,
44	reason: Option<String>,
45	remote_leave_now: bool,
46	state_lock: &'a RoomMutexGuard,
47) -> Result {
48	let leave_content = RoomMemberEventContent {
49		membership: MembershipState::Leave,
50		reason: reason.clone(),
51		join_authorized_via_users_server: None,
52		is_direct: false,
53		avatar_url: None,
54		displayname: None,
55		third_party_invite: None,
56		blurhash: None,
57	};
58
59	let member_event = self
60		.services
61		.state_accessor
62		.room_state_get_content::<RoomMemberEventContent>(
63			room_id,
64			&StateEventType::RoomMember,
65			user_id.as_str(),
66		)
67		.await;
68
69	let dont_have_room = self
70		.services
71		.state_cache
72		.server_in_room(self.services.globals.server_name(), room_id)
73		.is_false()
74		.and(ready(member_event.as_ref().is_err()));
75
76	let not_knocked = self
77		.services
78		.state_cache
79		.is_knocked(user_id, room_id)
80		.is_false();
81
82	if remote_leave_now || dont_have_room.and(not_knocked).await {
83		self.leave_via_remote(user_id, room_id, reason, leave_content)
84			.await
85	} else {
86		self.leave_locally(user_id, room_id, reason, leave_content, member_event, state_lock)
87			.await
88	}
89}
90
91#[implement(Service)]
92async fn leave_via_remote(
93	&self,
94	user_id: &UserId,
95	room_id: &RoomId,
96	reason: Option<String>,
97	leave_content: RoomMemberEventContent,
98) -> Result {
99	let is_banned = self.services.metadata.is_banned(room_id);
100	let is_disabled = self.services.metadata.is_disabled(room_id);
101
102	if is_banned.or(is_disabled).await {
103		return self
104			.clear_local_leave(user_id, room_id, leave_content, None)
105			.await;
106	}
107
108	if let Err(e) = self.remote_leave(user_id, room_id, reason).await {
109		warn!(%user_id, "Failed to leave room {room_id} remotely: {e}");
110	}
111
112	let last_state = self
113		.last_known_strip_state(user_id, room_id)
114		.await;
115
116	self.clear_local_leave(user_id, room_id, leave_content, last_state)
117		.await
118}
119
120#[implement(Service)]
121async fn last_known_strip_state(
122	&self,
123	user_id: &UserId,
124	room_id: &RoomId,
125) -> Option<Vec<Raw<AnyStrippedStateEvent>>> {
126	self.services
127		.state_cache
128		.invite_state(user_id, room_id)
129		.or_else(|_| {
130			self.services
131				.state_cache
132				.knock_state(user_id, room_id)
133		})
134		.or_else(|_| {
135			self.services
136				.state_cache
137				.left_state(user_id, room_id)
138		})
139		.await
140		.ok()
141}
142
143#[implement(Service)]
144async fn leave_locally(
145	&self,
146	user_id: &UserId,
147	room_id: &RoomId,
148	reason: Option<String>,
149	leave_content: RoomMemberEventContent,
150	member_event: Result<RoomMemberEventContent>,
151	state_lock: &RoomMutexGuard,
152) -> Result {
153	let Ok(event) = member_event else {
154		debug_warn!(
155			"Trying to leave a room you are not a member of, marking room as left locally."
156		);
157
158		return self
159			.clear_local_leave(user_id, room_id, leave_content, None)
160			.await;
161	};
162
163	if !is_leaveable(&event.membership) {
164		debug_warn!(
165			current = ?event.membership,
166			"Room state shows non-leaveable membership; clearing local caches.",
167		);
168
169		return self
170			.clear_local_leave(user_id, room_id, leave_content, None)
171			.await;
172	}
173
174	let build_result = self
175		.services
176		.timeline
177		.build_and_append_pdu(
178			PduBuilder::state(user_id.to_string(), &RoomMemberEventContent {
179				membership: MembershipState::Leave,
180				reason,
181				join_authorized_via_users_server: None,
182				is_direct: false,
183				..event
184			}),
185			user_id,
186			room_id,
187			state_lock,
188		)
189		.await;
190
191	// On state-res auth-check rejection, re-read membership. The pre-check above
192	// and the auth_check inside build_and_append_pdu both run under state_lock,
193	// so they observe the same state; re-reading here narrows the swallow to
194	// non-leaveable membership (Leave/Ban/_Custom), which is the stale-state
195	// population this branch targets. Genuine auth_check rejections against
196	// fresh Invite/Join/Knock state propagate unchanged.
197	match build_result {
198		| Ok(_) => Ok(()),
199		| Err(Error::AuthCheck(inner)) => {
200			let current = self
201				.services
202				.state_accessor
203				.room_state_get_content::<RoomMemberEventContent>(
204					room_id,
205					&StateEventType::RoomMember,
206					user_id.as_str(),
207				)
208				.await
209				.map(|c| c.membership);
210
211			if current.as_ref().is_ok_and(is_leaveable) {
212				return Err(Error::AuthCheck(inner));
213			}
214
215			warn!(
216				error = %inner,
217				?current,
218				"Auth refused self-leave PDU; clearing local caches.",
219			);
220
221			self.clear_local_leave(user_id, room_id, leave_content, None)
222				.await
223		},
224		| Err(e) => Err(e),
225	}
226}
227
228#[implement(Service)]
229async fn clear_local_leave(
230	&self,
231	user_id: &UserId,
232	room_id: &RoomId,
233	leave_content: RoomMemberEventContent,
234	last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>,
235) -> Result {
236	// Preserve the departure position used for history visibility.
237	if self
238		.services
239		.state_cache
240		.user_membership(user_id, room_id)
241		.map(|membership| membership.as_ref().is_some_and(is_leaveable))
242		.is_false()
243		.await
244	{
245		return Ok(());
246	}
247
248	let count = self.services.globals.next_count();
249
250	self.services
251		.state_cache
252		.update_membership(MembershipUpdate {
253			last_state,
254			..MembershipUpdate::self_sent(
255				room_id,
256				user_id,
257				leave_content,
258				PduCount::Normal(*count),
259			)
260		})
261		.await
262}
263
264#[implement(Service)]
265#[tracing::instrument(name = "remote", level = "debug", skip_all)]
266async fn remote_leave(
267	&self,
268	user_id: &UserId,
269	room_id: &RoomId,
270	reason: Option<String>,
271) -> Result {
272	let mut make_leave_response_and_server =
273		Err!(BadServerResponse("No remote server available to assist in leaving {room_id}."));
274
275	let invite_servers = self
276		.services
277		.state_cache
278		.servers_invite_via(room_id)
279		.map(ToOwned::to_owned);
280
281	let room_servers = self
282		.services
283		.state_cache
284		.room_servers(room_id)
285		.map(ToOwned::to_owned);
286
287	let servers = invite_servers
288		.chain(room_servers)
289		.collect::<HashSet<OwnedServerName>>();
290
291	let invite_state = self
292		.services
293		.state_cache
294		.invite_state(user_id, room_id);
295
296	let (servers, invite_state) = join(servers, invite_state).await;
297
298	let (state, is_knock) = match invite_state {
299		| Ok(state) => (state, false),
300		| _ =>
301			self.services
302				.state_cache
303				.knock_state(user_id, room_id)
304				.map(Result::unwrap_or_default)
305				.map(|state| (state, true))
306				.await,
307	};
308
309	let extend_servers = |mut servers: HashSet<OwnedServerName>| {
310		servers.extend(
311			state
312				.iter()
313				.filter_map(|event| event.get_field("sender").ok().flatten())
314				.filter_map(|sender: &str| UserId::parse(sender).ok())
315				.filter(|sender| !is_knock || !self.services.globals.user_is_local(sender))
316				.map(|sender| sender.server_name().to_owned()),
317		);
318
319		servers.insert(user_id.server_name().to_owned());
320		if let Some(room_id_server_name) = room_id.server_name() {
321			servers.insert(room_id_server_name.to_owned());
322		}
323
324		servers
325	};
326
327	let servers = extend_servers(servers);
328
329	drop(state);
330
331	debug_info!("servers in remote_leave_room: {servers:?}");
332
333	for remote_server in servers
334		.into_iter()
335		.filter(|server| !self.services.globals.server_is_ours(server))
336	{
337		let make_leave_response = self
338			.services
339			.federation
340			.execute(&remote_server, federation::membership::prepare_leave_event::v1::Request {
341				room_id: room_id.to_owned(),
342				user_id: user_id.to_owned(),
343			})
344			.await;
345
346		make_leave_response_and_server = make_leave_response.map(|r| (r, remote_server));
347
348		if make_leave_response_and_server.is_ok() {
349			break;
350		}
351	}
352
353	let (make_leave_response, remote_server) = make_leave_response_and_server?;
354
355	let Some(room_version_id) = make_leave_response.room_version else {
356		return Err!(BadServerResponse(warn!(
357			"No room version was returned by {remote_server} for {room_id}, room version is \
358			 likely not supported by tuwunel"
359		)));
360	};
361
362	if !self
363		.services
364		.config
365		.supported_room_version(&room_version_id)
366	{
367		return Err!(BadServerResponse(warn!(
368			"Remote room version {room_version_id} for {room_id} is not supported by conduwuit",
369		)));
370	}
371
372	let room_version_rules = room_version::rules(&room_version_id)?;
373
374	let mut event = serde_json::from_str::<CanonicalJsonObject>(make_leave_response.event.get())
375		.map_err(|e| {
376			err!(BadServerResponse(warn!(
377				"Invalid make_leave event json received from {remote_server} for {room_id}: \
378				 {e:?}"
379			)))
380		})?;
381
382	let content = self
383		.services
384		.profile
385		.fill_content(user_id, RoomMemberEventContent {
386			reason,
387			..RoomMemberEventContent::new(MembershipState::Leave)
388		})
389		.await;
390
391	event.insert("content".into(), to_canonical_value(content)?);
392
393	event.insert(
394		"origin".into(),
395		CanonicalJsonValue::String(
396			self.services
397				.globals
398				.server_name()
399				.as_str()
400				.to_owned(),
401		),
402	);
403
404	event.insert(
405		"origin_server_ts".into(),
406		CanonicalJsonValue::Integer(utils::millis_since_unix_epoch().try_into()?),
407	);
408
409	event.insert("room_id".into(), CanonicalJsonValue::String(room_id.as_str().into()));
410
411	event.insert("state_key".into(), CanonicalJsonValue::String(user_id.as_str().into()));
412
413	event.insert("sender".into(), CanonicalJsonValue::String(user_id.as_str().into()));
414
415	event.insert("type".into(), CanonicalJsonValue::String("m.room.member".into()));
416
417	let event_id = self
418		.services
419		.server_keys
420		.gen_id_hash_and_sign_event(&mut event, &room_version_id)?;
421
422	check_rules(&event, &room_version_rules.event_format)?;
423
424	self.services
425		.federation
426		.execute(&remote_server, federation::membership::create_leave_event::v2::Request {
427			room_id: room_id.to_owned(),
428			event_id,
429			pdu: self
430				.services
431				.federation
432				.format_pdu_into(event.clone(), Some(&room_version_id))
433				.await,
434		})
435		.await?;
436
437	Ok(())
438}
439
440/// Membership states permitted to transition to `Leave` via a self-leave PDU.
441/// ruma's `MembershipState` is `#[non_exhaustive]`; future variants are
442/// conservatively treated as non-leaveable.
443fn is_leaveable(state: &MembershipState) -> bool {
444	matches!(state, MembershipState::Invite | MembershipState::Join | MembershipState::Knock,)
445}