tuwunel_service/users/
register.rs1use std::borrow::Cow;
2
3use futures::FutureExt;
4use ruma::{UserId, events::GlobalAccountDataEventType, push};
5use tuwunel_core::{
6 Err, Result, error, implement, info, is_equal_to,
7 utils::{BoolExt, string::truncate_chars},
8 warn,
9};
10
11use crate::{
12 membership::Join,
13 profile::{MAX_DISPLAYNAME_LENGTH, Propagation},
14};
15
16#[derive(Debug, Default)]
17pub struct Register<'a> {
18 pub user_id: Option<&'a UserId>,
19 pub username: Option<&'a str>,
20 pub password: Option<&'a str>,
21 pub origin: Option<&'a str>,
22 pub is_appservice: bool,
23 pub is_guest: bool,
24 pub grant_first_user_admin: bool,
25 pub displayname: Option<&'a str>,
26 pub omit_displayname_suffix: bool,
27}
28
29#[implement(super::Service)]
33#[tracing::instrument(level = "info", skip(self, password))]
34pub async fn full_register(
35 &self,
36 Register {
37 username,
38 user_id,
39 password,
40 origin,
41 is_appservice,
42 is_guest,
43 grant_first_user_admin,
44 displayname,
45 omit_displayname_suffix,
46 }: Register<'_>,
47) -> Result {
48 let ref user_id = user_id
49 .map(ToOwned::to_owned)
50 .map(Ok)
51 .or_else(|| {
52 username.map(|username| {
53 UserId::parse_with_server_name(username, self.services.globals.server_name())
54 })
55 })
56 .transpose()?
57 .expect("Caller failed to supply either user_id or username parameter");
58
59 if !self.services.globals.user_is_local(user_id) {
60 return Err!("Cannot register remote user");
61 }
62
63 if self.services.users.exists(user_id).await {
64 return Err!(Request(UserInUse("User ID is not available.")));
65 }
66
67 self.services
69 .users
70 .create(user_id, password, origin)
71 .await?;
72
73 let suffix = self
74 .services
75 .config
76 .registration
77 .displayname_suffix
78 .as_str();
79
80 let suffix = omit_displayname_suffix
81 .or_some(suffix)
82 .filter(|suffix| !suffix.is_empty());
83
84 let displayname = new_displayname(displayname.unwrap_or_else(|| user_id.localpart()), suffix);
85
86 self.services
87 .profile
88 .set_displayname(user_id, Some(&displayname), Some(Propagation::None))
89 .await?;
90
91 self.services
93 .account_data
94 .update(
95 None,
96 user_id,
97 GlobalAccountDataEventType::PushRules
98 .to_string()
99 .into(),
100 &serde_json::to_value(ruma::events::push_rules::PushRulesEvent {
101 content: ruma::events::push_rules::PushRulesEventContent {
102 global: push::Ruleset::server_default(user_id),
103 },
104 })?,
105 )
106 .await?;
107
108 if !is_guest
112 && !is_appservice
113 && grant_first_user_admin
114 && self
115 .services
116 .config
117 .registration
118 .grant_admin_to_first_user
119 && let Ok(admin_room) = self.services.admin.get_admin_room().await
120 && self
121 .services
122 .state_cache
123 .room_joined_count(&admin_room)
124 .await
125 .is_ok_and(is_equal_to!(1))
126 {
127 self.services
128 .admin
129 .make_user_admin(user_id)
130 .boxed() .await?;
132
133 warn!("Granting {user_id} admin privileges as the first user");
134 }
135
136 if is_appservice
137 || (self
138 .services
139 .config
140 .registration
141 .guests
142 .allow_auto_join_rooms
143 .is_false()
144 && is_guest)
145 {
146 return Ok(());
147 }
148
149 for room in &self
150 .services
151 .server
152 .config
153 .registration
154 .auto_join_rooms
155 {
156 let Ok(room_id) = self.services.alias.maybe_resolve(room).await else {
157 error!(
158 "Failed to resolve room alias to room ID when attempting to auto join {room}, \
159 skipping"
160 );
161
162 continue;
163 };
164
165 if !self
166 .services
167 .state_cache
168 .server_in_room(self.services.globals.server_name(), &room_id)
169 .await
170 {
171 warn!("Skipping room {room} to automatically join as we have never joined before.");
172
173 continue;
174 }
175
176 match self
177 .services
178 .membership
179 .join(Join {
180 sender_user: user_id,
181 room_id: &room_id,
182 orig_room_id: Some(room),
183 reason: Some("Automatically joining this room upon registration".to_owned()),
184 servers: &[],
185 is_appservice: false,
186 extra_content: None,
187 })
188 .await
189 {
190 | Err(e) => {
191 error!("Failed to automatically join room {room} for user {user_id}: {e}");
193 },
194 | _ => {
195 info!("Automatically joined room {room} for user {user_id}");
196 },
197 }
198 }
199
200 Ok(())
201}
202
203fn new_displayname<'a>(name: &'a str, suffix: Option<&str>) -> Cow<'a, str> {
205 let name = truncate_chars(name, MAX_DISPLAYNAME_LENGTH);
206 let fits = |suffix: &&str| {
207 name.chars()
208 .count()
209 .saturating_add(suffix.chars().count())
210 .lt(&MAX_DISPLAYNAME_LENGTH)
211 };
212
213 suffix
214 .filter(fits)
215 .map_or_else(|| name.into(), |suffix| format!("{name} {suffix}").into())
216}
217
218#[cfg(test)]
219mod tests {
220 use super::{MAX_DISPLAYNAME_LENGTH, new_displayname};
221
222 #[test]
223 fn a_name_that_fits_is_kept() {
224 assert_eq!(new_displayname("june", None), "june");
225 assert_eq!(new_displayname("june", Some("💕")), "june 💕");
226 }
227
228 #[test]
229 fn an_overlong_name_is_shortened_to_the_limit() {
230 let long = "é".repeat(MAX_DISPLAYNAME_LENGTH + 1);
231
232 assert_eq!(new_displayname(&long, None).chars().count(), MAX_DISPLAYNAME_LENGTH);
233 assert_eq!(new_displayname(&long, Some("💕")).chars().count(), MAX_DISPLAYNAME_LENGTH);
234 }
235
236 #[test]
237 fn the_suffix_is_added_only_where_it_fits() {
238 let fits = "n".repeat(MAX_DISPLAYNAME_LENGTH - 2);
239 let full = "n".repeat(MAX_DISPLAYNAME_LENGTH - 1);
240
241 assert_eq!(new_displayname(&fits, Some("💕")), format!("{fits} 💕"));
242 assert_eq!(new_displayname(&full, Some("💕")), full);
243 }
244
245 #[test]
246 fn an_overlong_suffix_leaves_the_name_alone() {
247 let suffix = "s".repeat(MAX_DISPLAYNAME_LENGTH);
248
249 assert_eq!(new_displayname("june", Some(&suffix)), "june");
250 }
251}