tuwunel_service/integrity/short_ids/rooms/
rows.rs1use 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
30pub(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 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 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}