tuwunel_service/membership/
invite.rs1use 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() .await?;
45 }
46
47 Ok(())
48}
49
50#[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(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 | ErrorKind::MissingParam => err!(BadServerResponse(
180 "Remote server could not validate the invite's create event."
181 )),
182 | _ => e,
183 })?;
184
185 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}