Skip to main content

tuwunel_service/membership/
invite.rs

1use futures::{FutureExt, future::join};
2use ruma::{
3	OwnedServerName, RoomId, UserId,
4	api::{
5		error::ErrorKind,
6		federation::membership::{RawStrippedState, create_invite},
7	},
8	events::{
9		invite_permission_config::InvitePermission,
10		room::{
11			join_rules::JoinRule,
12			member::{MembershipState, RoomMemberEventContent},
13		},
14	},
15};
16use tuwunel_core::{
17	Err, Result, at, err, implement,
18	utils::future::{ReadyBoolExt, and4},
19};
20use tuwunel_matrix::{event::gen_event_id_canonical_json, pdu::PduBuilder};
21
22use super::Service;
23
24#[implement(Service)]
25#[tracing::instrument(
26    level = "debug",
27    skip_all,
28    fields(%sender_user, %room_id, %user_id)
29)]
30pub async fn invite(
31	&self,
32	sender_user: &UserId,
33	user_id: &UserId,
34	room_id: &RoomId,
35	reason: Option<&String>,
36	is_direct: bool,
37) -> Result {
38	if self.services.globals.user_is_local(user_id) {
39		self.local_invite(sender_user, user_id, room_id, reason, is_direct)
40			.await?;
41	} else {
42		self.remote_invite(sender_user, user_id, room_id, reason, is_direct)
43			.boxed() // cold arm
44			.await?;
45	}
46
47	Ok(())
48}
49
50/// Reports whether a user must be invited before joining a room.
51///
52/// True when this server is in the room, the user is neither joined nor
53/// invited, and the join rule would refuse the user uninvited: a public rule
54/// admits anyone, and a restricted rule admits members of the rooms it
55/// allows. When this server is not in the room its view of the join rule may
56/// be stale or absent, so the remote join is left to decide.
57#[implement(Service)]
58pub async fn join_needs_invite(&self, room_id: &RoomId, user_id: &UserId) -> bool {
59	let server_in_room = self
60		.services
61		.state_cache
62		.server_in_room(self.services.globals.server_name(), room_id);
63
64	let joined = self
65		.services
66		.state_cache
67		.is_joined(user_id, room_id);
68
69	let invited = self
70		.services
71		.state_cache
72		.is_invited(user_id, room_id);
73
74	let admitted = self
75		.services
76		.state_accessor
77		.get_join_rules(room_id)
78		.then(async |rule| self.admits_uninvited(&rule, user_id).await);
79
80	// and4 polls in order, so a point read refusing at once spares the join-rule reads.
81	and4(server_in_room, joined.is_false(), invited.is_false(), admitted.is_false()).await
82}
83
84#[implement(Service)]
85async fn admits_uninvited(&self, rule: &JoinRule, user_id: &UserId) -> bool {
86	match rule {
87		| JoinRule::Public => true,
88		| JoinRule::Restricted(_) | JoinRule::KnockRestricted(_) =>
89			self.services
90				.state_cache
91				.is_joined_any(user_id, rule.allowed_room_ids())
92				.await,
93		| _ => false,
94	}
95}
96
97#[implement(Service)]
98#[tracing::instrument(name = "remote", level = "debug", skip_all)]
99async fn remote_invite(
100	&self,
101	sender_user: &UserId,
102	user_id: &UserId,
103	room_id: &RoomId,
104	reason: Option<&String>,
105	is_direct: bool,
106) -> Result {
107	let (pdu, pdu_json, invite_room_state, room_version_id) = {
108		let state_lock = self.services.state.mutex.lock(room_id).await;
109
110		let content = self
111			.services
112			.profile
113			.fill_content(user_id, RoomMemberEventContent {
114				is_direct,
115				reason: reason.cloned(),
116				..RoomMemberEventContent::new(MembershipState::Invite)
117			})
118			.await;
119
120		let event = self.services.timeline.create_hash_and_sign_event(
121			PduBuilder::state(user_id.to_string(), &content),
122			sender_user,
123			room_id,
124			&state_lock,
125		);
126
127		let room_version_id = self.services.state.get_room_version(room_id);
128		let (event, room_version_id) = join(event, room_version_id).await;
129		let (pdu, pdu_json) = event?;
130		let room_version_id = room_version_id?;
131
132		let invite_room_state = self
133			.services
134			.state
135			.summary_pdus(&pdu, &pdu_json, &room_version_id)
136			.await;
137
138		drop(state_lock);
139
140		(pdu, pdu_json, invite_room_state, room_version_id)
141	};
142
143	let event = self
144		.services
145		.federation
146		.format_pdu_into(pdu_json.clone(), Some(&room_version_id));
147
148	let via = self
149		.services
150		.state_cache
151		.servers_route_via(room_id)
152		.map(Result::ok);
153
154	let (event, via) = join(event, via).await;
155
156	let response = self
157		.services
158		.federation
159		.execute(user_id.server_name(), create_invite::v2::Request {
160			room_id: room_id.to_owned(),
161			event_id: (*pdu.event_id).to_owned(),
162			room_version: room_version_id.clone(),
163			event,
164			invite_room_state: invite_room_state
165				.into_iter()
166				.map(RawStrippedState::Pdu)
167				.collect(),
168			via,
169		})
170		.await
171		.map_err(|e| match e.kind() {
172			| ErrorKind::IncompatibleRoomVersion { .. } | ErrorKind::UnsupportedRoomVersion =>
173				err!(Request(UnsupportedRoomVersion(
174					"Server {} does not support room version {room_version_id}.",
175					user_id.server_name(),
176				))),
177			// MSC4311: the remote rejected our well-formed invite over create-event
178			// validation; the client cannot make it succeed, so surface a 5xx.
179			| ErrorKind::MissingParam => err!(BadServerResponse(
180				"Remote server could not validate the invite's create event."
181			)),
182			| _ => e,
183		})?;
184
185	// We do not add the event_id field to the pdu here because of signature and
186	// hashes checks
187	let (event_id, value) = gen_event_id_canonical_json(&response.event, &room_version_id)
188		.map_err(|e| {
189			err!(Request(BadJson(warn!("Could not convert event to canonical JSON: {e}"))))
190		})?;
191
192	if pdu.event_id != event_id {
193		return Err!(Request(BadJson(warn!(
194			%pdu.event_id, %event_id,
195			"Server {} sent event with wrong event ID",
196			user_id.server_name()
197		))));
198	}
199
200	let origin: OwnedServerName = serde_json::from_value(serde_json::to_value(
201		value
202			.get("origin")
203			.ok_or_else(|| err!(Request(BadJson("Event missing origin field."))))?,
204	)?)
205	.map_err(|e| {
206		err!(Request(BadJson(warn!("Origin field in event is not a valid server name: {e}"))))
207	})?;
208
209	let pdu_id = self
210		.services
211		.event_handler
212		.handle_incoming_pdu(&origin, room_id, &event_id, value, true)
213		.await?
214		.map(at!(0))
215		.ok_or_else(|| {
216			err!(Request(InvalidParam("Could not accept incoming PDU as timeline event.")))
217		})?;
218
219	self.services
220		.sending
221		.send_pdu_room(room_id, &pdu_id)
222		.await?;
223
224	Ok(())
225}
226
227#[implement(Service)]
228#[tracing::instrument(name = "local", level = "debug", skip_all)]
229async fn local_invite(
230	&self,
231	sender_user: &UserId,
232	user_id: &UserId,
233	room_id: &RoomId,
234	reason: Option<&String>,
235	is_direct: bool,
236) -> Result {
237	let blocked = self
238		.services
239		.users
240		.invite_permission(sender_user, user_id)
241		.map(|permission| permission.eq(&InvitePermission::Block));
242
243	let joined = self
244		.services
245		.state_cache
246		.is_joined(sender_user, room_id);
247
248	let (blocked, joined) = join(blocked, joined).await;
249
250	if blocked {
251		return Err!(Request(InviteBlocked("{user_id} has blocked this invite.")));
252	}
253
254	if !joined {
255		return Err!(Request(Forbidden(
256			"You must be joined in the room you are trying to invite from."
257		)));
258	}
259
260	let state_lock = self.services.state.mutex.lock(room_id).await;
261
262	let content = self
263		.services
264		.profile
265		.fill_content(user_id, RoomMemberEventContent {
266			is_direct,
267			reason: reason.cloned(),
268			..RoomMemberEventContent::new(MembershipState::Invite)
269		})
270		.await;
271
272	self.services
273		.timeline
274		.build_and_append_pdu(
275			PduBuilder::state(user_id.to_string(), &content),
276			sender_user,
277			room_id,
278			&state_lock,
279		)
280		.await?;
281
282	drop(state_lock);
283
284	Ok(())
285}