Skip to main content

tuwunel_service/integrity/
joined_members.rs

1//! Joined members against their rooms' current state.
2//!
3//! `roomuserid_joined` lists who is joined to each room, and the member event in
4//! each room's current state says the same. A conduwuit-era bug could leave the
5//! two disagreeing.
6
7use std::{fmt, str::from_utf8, sync::Arc};
8
9use futures::{Stream, TryFutureExt};
10use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId, events::room::member::MembershipState};
11use tuwunel_core::{
12	Result,
13	result::NotFound,
14	utils::{TryReadyExt, stream::TryBroadbandExt},
15};
16use tuwunel_database::{KeyBuf, SEP};
17
18use super::{Check, Report, ScanExt, per_room, tally, undecodable};
19use crate::{
20	Services,
21	rooms::{state_compressor::CompressedState, timeline::Mapped},
22};
23
24type Member = (OwnedRoomId, OwnedUserId);
25
26// A room's current state, rebuilt once for its members; none when it has none.
27type State = Option<Mapped<Arc<CompressedState>>>;
28
29pub(super) static CHECK: Check = Check {
30	name: "joined-members",
31	about: "Every member roomuserid_joined lists has a join in its room's current state",
32	quiescent: true,
33	walk: |services, limit| tally(scan(services), limit),
34};
35
36/// A joined member whose room's current state does not say joined.
37///
38/// The membership repair marks a contradicted member left, and leaves a member
39/// the state does not resolve as it is.
40pub enum Finding {
41	/// The current state gives the member another membership.
42	Contradicted {
43		/// The room.
44		room_id: OwnedRoomId,
45
46		/// The member.
47		user_id: OwnedUserId,
48
49		/// The membership the current state gives.
50		membership: MembershipState,
51	},
52
53	/// The current state holds no member event for the member.
54	Unbacked {
55		/// The room.
56		room_id: OwnedRoomId,
57
58		/// The member.
59		user_id: OwnedUserId,
60	},
61
62	/// A row leading from the room's current state to the member event is
63	/// damaged, the event's timeline mapping included.
64	MalformedMapping {
65		/// The room.
66		room_id: OwnedRoomId,
67
68		/// The member.
69		user_id: OwnedUserId,
70	},
71
72	/// The member event in the current state does not decode.
73	Unreadable {
74		/// The room.
75		room_id: OwnedRoomId,
76
77		/// The member.
78		user_id: OwnedUserId,
79	},
80
81	/// The key separates its ids, but they do not read as a room and a user.
82	Unparsable {
83		/// The stored key.
84		key: KeyBuf,
85	},
86}
87
88/// Streams each joined member the current state does not show joined.
89///
90/// Every row of `roomuserid_joined` is read and its member looked up in the
91/// room's current state, as the membership repair walks them, the state rebuilt
92/// once for each run of rows in one room. A key whose first separator is missing
93/// or doubled is skipped, as the joined keys check reports it.
94#[tracing::instrument(level = "trace", skip_all)]
95pub fn scan(services: &Services) -> impl Stream<Item = Result<Finding>> + Send + '_ {
96	let members = services.db["roomuserid_joined"]
97		.raw_scan()
98		.scanned(&services.server)
99		.ready_try_filter_map(|(key, _)| Ok(split(key)));
100
101	per_room(
102		members,
103		|(room_id, _): &Member| room_id,
104		move |room_id| state(services, room_id),
105	)
106	.broad_and_then(async |member| match member {
107		| Ok((member, state)) => verify(services, member, state).await,
108		| Err(key) => Ok(Some(Finding::Unparsable { key })),
109	})
110	.ready_try_filter_map(Ok)
111}
112
113impl Report for Finding {
114	fn kind(&self) -> &'static str {
115		match self {
116			| Self::Contradicted { .. } => "contradicted-join",
117			| Self::Unbacked { .. } => "unbacked-join",
118			| Self::MalformedMapping { .. } => "malformed-mapping",
119			| Self::Unreadable { .. } => "unreadable-member",
120			| Self::Unparsable { .. } => "unparsable-key",
121		}
122	}
123}
124
125impl fmt::Display for Finding {
126	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
127		match self {
128			| Self::Contradicted { room_id, user_id, membership } => {
129				write!(
130					f,
131					"{user_id} is listed joined to {room_id}, whose state says {membership}"
132				)
133			},
134			| Self::Unbacked { room_id, user_id } => {
135				write!(
136					f,
137					"{user_id} is listed joined to {room_id}, whose state has no member event"
138				)
139			},
140			| Self::MalformedMapping { room_id, user_id } => {
141				write!(f, "a row resolving the member event of {user_id} in {room_id} is damaged")
142			},
143			| Self::Unreadable { room_id, user_id } => {
144				write!(f, "member event of {user_id} in {room_id} does not decode")
145			},
146			| Self::Unparsable { key } => {
147				write!(f, "key does not read as a room and a user: {}", key.escape_ascii())
148			},
149		}
150	}
151}
152
153/// Splits a key into its room and user, by hand.
154///
155/// A key the joined keys check reports gives `None`, and one whose ids do not
156/// parse gives the key back.
157fn split(key: &[u8]) -> Option<Result<Member, KeyBuf>> {
158	let at = key.iter().position(|&byte| byte == SEP)?;
159	let (room_id, user_id) = key.split_at(at);
160
161	user_id
162		.strip_prefix(&[SEP])
163		.filter(|user_id| user_id.first() != Some(&SEP))
164		.map(|user_id| member(room_id, user_id).ok_or_else(|| KeyBuf::from_slice(key)))
165}
166
167fn member(room_id: &[u8], user_id: &[u8]) -> Option<Member> {
168	let room_id: &RoomId = from_utf8(room_id).ok()?.try_into().ok()?;
169	let user_id: &UserId = from_utf8(user_id).ok()?.try_into().ok()?;
170
171	Some((room_id.to_owned(), user_id.to_owned()))
172}
173
174#[tracing::instrument(level = "debug", skip(services))]
175async fn state(services: &Services, room_id: OwnedRoomId) -> Result<State> {
176	services
177		.state_accessor
178		.room_state_checked(&room_id)
179		.map_ok(|state| state.map(Arc::new))
180		.await
181		.present()
182}
183
184#[tracing::instrument(level = "debug", skip_all)]
185async fn verify(
186	services: &Services,
187	(room_id, user_id): Member,
188	state: State,
189) -> Result<Option<Finding>> {
190	let member = match state {
191		| None => return Ok(Some(Finding::Unbacked { room_id, user_id })),
192		| Some(Mapped::Damaged) => {
193			return Ok(Some(Finding::MalformedMapping { room_id, user_id }));
194		},
195		| Some(Mapped::Event(state)) =>
196			services
197				.state_accessor
198				.get_member_checked(&state, &user_id)
199				.await,
200	};
201
202	let finding: Option<Finding> = match member {
203		| Ok(Mapped::Event(member)) if member.membership == MembershipState::Join => None,
204		| Ok(Mapped::Damaged) => Some(Finding::MalformedMapping { room_id, user_id }),
205		| Ok(Mapped::Event(member)) => Finding::Contradicted {
206			room_id,
207			user_id,
208			membership: member.membership,
209		}
210		.into(),
211		| Err(error) if error.is_missing() => Some(Finding::Unbacked { room_id, user_id }),
212		| Err(error) if undecodable(&error) => Some(Finding::Unreadable { room_id, user_id }),
213		| Err(error) => return Err(error),
214	};
215
216	Ok(finding)
217}