Skip to main content

tuwunel_service/users/
register.rs

1use 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/// Fully register a local user
30///
31/// Returns a device id and access token for the registered user
32#[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	// Create user
68	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	// Initial account data
92	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 this is the first real user, grant them admin privileges except for guest
109	// users
110	// Note: the server user is generated first
111	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() // cold arm
131			.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				// don't return this error so we don't fail registrations
192				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
203// The account already exists here, so an overlong name is shortened rather than refused.
204fn 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}