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#[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 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 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
440fn is_leaveable(state: &MembershipState) -> bool {
444 matches!(state, MembershipState::Invite | MembershipState::Join | MembershipState::Knock,)
445}