Skip to main content

tuwunel_service/integrity/short_ids/rooms/
rows.rs

1use std::str::from_utf8;
2
3use ruma::{EventId, ServerName, UserId};
4use serde::Deserialize;
5use serde_json::{Value as JsonValue, from_slice};
6use tuwunel_core::utils::BoolExt;
7use tuwunel_database::{Json, SEP, serialize_val};
8
9use self::Part::{Key, Value};
10use crate::pusher::Notified;
11
12type Spot = Option<(Part, usize)>;
13
14type Record = (Box<[u8]>, Box<[u8]>);
15
16pub(crate) const COLUMNS: [&str; 11] = [
17	"pduid_pdu",
18	"eventid_pduid",
19	"tokenids",
20	"relatesto_typed",
21	"threadid_userids",
22	"threadrootid_latestcount",
23	"threadactivityid_rootid",
24	"useridcount_notification",
25	"servernameevent_data",
26	"servercurrentevent_data",
27	"servershortroomid_park",
28];
29
30// Keys in these columns lead with the short room id, so a prefix scan finds a room's rows.
31pub(super) const SCANNED: [usize; 6] = [0, 2, 3, 4, 5, 6];
32
33#[derive(Clone, Copy)]
34pub(crate) struct Decoded {
35	pub(super) rooms: [u64; 2],
36	spots: [Spot; 2],
37}
38
39#[derive(Clone, Copy)]
40enum Part {
41	Key,
42	Value,
43}
44
45#[derive(Deserialize)]
46struct NotifiedRoom {
47	sroomid: u64,
48}
49
50pub(crate) fn decode(column: usize, key: &[u8], value: &[u8]) -> Option<Decoded> {
51	let spots = match column {
52		| 0 => {
53			raw(key)?;
54			[Some((Key, 0)), None]
55		},
56		| 1 => {
57			<&EventId>::try_from(from_utf8(key).ok()?).ok()?;
58			raw(value)?;
59			[Some((Value, 0)), None]
60		},
61		| 2 => {
62			let (token, end) = segment(key, 8)?;
63			let start = end.saturating_add(1);
64
65			token.is_empty().is_false().into_option()?;
66			raw(key.get(start..)?)?;
67			value.is_empty().into_option()?;
68			[Some((Key, 0)), Some((Key, start))]
69		},
70		| 3 => {
71			let valid = key.len() == 33 && matches!(key[16], 1 | 2);
72
73			valid.into_option()?;
74			let room = word(&key[..8])?;
75
76			normal(room, word(&key[8..16])?)?;
77			normal(room, word(&key[25..])?)?;
78			short(value)?;
79			[Some((Key, 0)), None]
80		},
81		| 4 => {
82			raw(key)?;
83			users(value)?;
84			[Some((Key, 0)), None]
85		},
86		| 5 => {
87			normal(raw(key)?, word(value)?)?;
88			[Some((Key, 0)), None]
89		},
90		| 6 => {
91			raw(key)?;
92			raw(value)?;
93			[Some((Key, 0)), Some((Value, 0))]
94		},
95		| 7 => {
96			let (user, end) = segment(key, 0)?;
97
98			<&UserId>::try_from(user).ok()?;
99			let count = word(key.get(end.saturating_add(1)..)?)?;
100			let room = from_slice(value)
101				.ok()
102				.map(|stored: Notified| stored.sroomid)?;
103
104			normal(room, count)?;
105			return Some(Decoded { rooms: [room, 0], spots: [None; 2] });
106		},
107		| 8 | 9 if value.is_empty().is_false() =>
108			return Some(Decoded { rooms: [0; 2], spots: [None; 2] }),
109		| 8 | 9 => {
110			let end = destination(key)?;
111
112			raw(key.get(end..)?)?;
113			[Some((Key, end)), None]
114		},
115		| 10 => {
116			let (server, end) = segment(key, 0)?;
117
118			<&ServerName>::try_from(server).ok()?;
119			let valid =
120				value.len() == 17 && value[8] == SEP && key.len() == end.saturating_add(9);
121
122			valid.into_option()?;
123			[Some((Key, end.saturating_add(1))), None]
124		},
125		| _ => return None,
126	};
127
128	let rooms = spots.map(|spot| {
129		spot.map_or(Some(0), |(part, offset)| short_at(part.select(key, value), offset))
130	});
131
132	Some(Decoded { rooms: [rooms[0]?, rooms[1]?], spots })
133}
134
135pub(super) fn hints(column: usize, key: &[u8], value: &[u8]) -> [Option<u64>; 2] {
136	match column {
137		| 1 => [short_at(value, 0), None],
138		| 2 => {
139			let pdu_room = separator(key, 8).and_then(|end| short_at(key, end.saturating_add(1)));
140
141			[short_at(key, 0), pdu_room]
142		},
143		| 6 => [short_at(key, 0), short_at(value, 0)],
144		| 7 => [sroomid(value), None],
145		| 8 | 9 => [destination(key).and_then(|end| short_at(key, end)), None],
146		| 10 => {
147			let room = key
148				.len()
149				.checked_sub(8)
150				.and_then(|offset| short_at(key, offset));
151
152			[room, None]
153		},
154		| _ => [short_at(key, 0), None],
155	}
156}
157
158pub(crate) fn rewrite(
159	decoded: Decoded,
160	column: usize,
161	key: &[u8],
162	value: &[u8],
163	from: u64,
164	to: u64,
165) -> Option<Record> {
166	let value = if column == 7 {
167		notification(value, to)?
168	} else {
169		Box::from(value)
170	};
171
172	Some(patch(Box::from(key), value, decoded, from, to))
173}
174
175impl Part {
176	fn select<T>(self, key: T, value: T) -> T {
177		match self {
178			| Key => key,
179			| Value => value,
180		}
181	}
182}
183
184pub(super) fn raw(bytes: &[u8]) -> Option<u64> {
185	let room = short_at(bytes, 0)?;
186	let count = i64::from_be_bytes(*bytes.last_chunk()?);
187	let valid = match bytes.len() {
188		| 16 => count > 0,
189		| 24 => bytes[8..16] == [0; 8] && count <= 0,
190		| _ => false,
191	};
192
193	valid.then_some(room)
194}
195
196pub(super) fn word(bytes: &[u8]) -> Option<u64> { bytes.try_into().ok().map(u64::from_be_bytes) }
197
198fn segment(key: &[u8], start: usize) -> Option<(&str, usize)> {
199	let end = separator(key, start)?;
200
201	from_utf8(&key[start..end])
202		.ok()
203		.map(|text| (text, end))
204}
205
206fn separator(key: &[u8], start: usize) -> Option<usize> {
207	key.get(start..)?
208		.iter()
209		.position(|byte| *byte == SEP)
210		.map(|offset| offset.saturating_add(start))
211}
212
213fn normal(room: u64, count: u64) -> Option<()> {
214	let valid = room != 0 && count > 0 && count <= i64::MAX.cast_unsigned();
215
216	valid.into_option()
217}
218
219fn users(value: &[u8]) -> Option<()> {
220	value
221		.split(|byte| *byte == SEP)
222		.try_for_each(|user| {
223			from_utf8(user)
224				.ok()
225				.and_then(|user| <&UserId>::try_from(user).ok())
226				.map(|_| ())
227		})
228}
229
230fn destination(key: &[u8]) -> Option<usize> {
231	let (prefix, end) = segment(key, 0)?;
232	let after = end.saturating_add(1);
233
234	match key.first()? {
235		| b'$' => prefix
236			.get(1..)
237			.and_then(|user| <&UserId>::try_from(user).ok())
238			.and_then(|_| segment(key, after))
239			.map(|(_, next)| next.saturating_add(1)),
240		| b'+' => prefix.len().gt(&1).then_some(after),
241		| _ => <&ServerName>::try_from(prefix)
242			.ok()
243			.map(|_| after),
244	}
245}
246
247fn short_at(bytes: &[u8], offset: usize) -> Option<u64> {
248	bytes
249		.get(offset..offset.saturating_add(8))
250		.and_then(short)
251}
252
253fn short(bytes: &[u8]) -> Option<u64> { word(bytes).filter(|id| id.ne(&0)) }
254
255fn sroomid(value: &[u8]) -> Option<u64> {
256	// None leaves the row's room unknown, and a zero sroomid names no room.
257	from_slice(value)
258		.ok()
259		.map(|room: NotifiedRoom| room.sroomid)
260		.filter(|id| id.ne(&0))
261}
262
263fn notification(value: &[u8], to: u64) -> Option<Box<[u8]>> {
264	// Untyped, so fields this build does not model survive the rewrite.
265	from_slice(value)
266		.ok()
267		.and_then(|json| notified(json, to))
268		.and_then(|json| serialize_val(Json(&json)).ok())
269		.map(|bytes| Box::from(&*bytes))
270}
271
272fn notified(mut json: JsonValue, to: u64) -> Option<JsonValue> {
273	*json.get_mut("sroomid")? = JsonValue::from(to);
274
275	Some(json)
276}
277
278fn patch(
279	mut key: Box<[u8]>,
280	mut value: Box<[u8]>,
281	decoded: Decoded,
282	from: u64,
283	to: u64,
284) -> Record {
285	decoded
286		.spots
287		.into_iter()
288		.zip(decoded.rooms)
289		.filter(|(_, room)| room.eq(&from))
290		.filter_map(|(spot, _)| spot)
291		.for_each(|(part, offset)| {
292			let bytes = part.select(&mut *key, &mut *value);
293
294			bytes[offset..offset.saturating_add(8)].copy_from_slice(&to.to_be_bytes());
295		});
296
297	(key, value)
298}