char
/
conduit
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'less-alloc' into 'next' 

Reduce allocations in server_server

See merge request famedly/conduit!190
next
Timo Kösters 2021-09-14 07:09:55 +00:00
parent 06b0c9267f d68c93b5fa
commit 583a966f6e
39 changed files with 471 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
Cargo.lock generated
View File

@ -1968,8 +1968,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma" name = "ruma"
version = "0.4.0" version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "668031e3108d6a2cfbe6eca271d8698f4593440e71a44afdadcf67ce3cb93c1f"
dependencies = [ dependencies = [
"assign", "assign",
"js_int", "js_int",
@ -1990,8 +1989,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-api" name = "ruma-api"
version = "0.18.3" version = "0.18.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "f5f1843792b6749ec1ece62595cf99ad30bf9589c96bb237515235e71da396ea"
dependencies = [ dependencies = [
"bytes", "bytes",
"http", "http",
@ -2007,8 +2005,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-api-macros" name = "ruma-api-macros"
version = "0.18.3" version = "0.18.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "7b18abda5cca94178d08b622bca042e1cbb5eb7d4ebf3a2a81590a3bb3c57008"
dependencies = [ dependencies = [
"proc-macro-crate", "proc-macro-crate",
"proc-macro2", "proc-macro2",
@ -2019,8 +2016,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-appservice-api" name = "ruma-appservice-api"
version = "0.4.0" version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "49369332a5f299e832e19661f92d49e08c345c3c6c4ab16e09cb31c5ff6da878"
dependencies = [ dependencies = [
"ruma-api", "ruma-api",
"ruma-common", "ruma-common",
@ -2034,8 +2030,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-client-api" name = "ruma-client-api"
version = "0.12.2" version = "0.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "9568a222c12cf6220e751484ab78feec28071f85965113a5bb802936a2920ff0"
dependencies = [ dependencies = [
"assign", "assign",
"bytes", "bytes",
@ -2055,8 +2050,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-common" name = "ruma-common"
version = "0.6.0" version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "41d5b7605f58dc0d9cf1848cc7f1af2bae4e4bcd1d2b7a87bbb9864c8a785b91"
dependencies = [ dependencies = [
"indexmap", "indexmap",
"js_int", "js_int",
@ -2071,8 +2065,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-events" name = "ruma-events"
version = "0.24.5" version = "0.24.5"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "87801e1207cfebdee02e7997ebf181a1c9837260b78c1b8ce96b896a2bcb3763"
dependencies = [ dependencies = [
"indoc", "indoc",
"js_int", "js_int",
@ -2088,8 +2081,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-events-macros" name = "ruma-events-macros"
version = "0.24.5" version = "0.24.5"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "5da4498845347de88adf1b7da4578e2ca7355ad4ce47b0976f6594bacf958660"
dependencies = [ dependencies = [
"proc-macro-crate", "proc-macro-crate",
"proc-macro2", "proc-macro2",
@ -2100,8 +2092,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-federation-api" name = "ruma-federation-api"
version = "0.3.1" version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "fa3d1db1a064ab26484df6ef5d96c384fc053022004f34d96c3b4939e13dc204"
dependencies = [ dependencies = [
"js_int", "js_int",
"ruma-api", "ruma-api",
@ -2116,8 +2107,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-identifiers" name = "ruma-identifiers"
version = "0.20.0" version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "cb417d091e8dd5a633e4e5998231a156049d7fcc221045cfdc0642eb72067732"
dependencies = [ dependencies = [
"paste", "paste",
"rand 0.8.4", "rand 0.8.4",
@ -2131,8 +2121,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-identifiers-macros" name = "ruma-identifiers-macros"
version = "0.20.0" version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "c708edad7f605638f26c951cbad7501fbf28ab01009e5ca65ea5a2db74a882b1"
dependencies = [ dependencies = [
"quote", "quote",
"ruma-identifiers-validation", "ruma-identifiers-validation",
@ -2142,14 +2131,12 @@ dependencies = [
[[package]] [[package]]
name = "ruma-identifiers-validation" name = "ruma-identifiers-validation"
version = "0.5.0" version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "42285e7fb5d5f2d5268e45bb683e36d5c6fd9fc1e11a4559ba3c3521f3bbb2cb"
[[package]] [[package]]
name = "ruma-identity-service-api" name = "ruma-identity-service-api"
version = "0.3.0" version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "e76e66e24f2d5a31511fbf6c79e79f67a7a6a98ebf48d72381b7d5bb6c09f035"
dependencies = [ dependencies = [
"js_int", "js_int",
"ruma-api", "ruma-api",
@ -2162,8 +2149,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-push-gateway-api" name = "ruma-push-gateway-api"
version = "0.3.0" version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "5ef5b29da7065efc5b1e1a8f61add7543c9ab4ecce5ee0dd1c1c5ecec83fbeec"
dependencies = [ dependencies = [
"js_int", "js_int",
"ruma-api", "ruma-api",
@ -2178,8 +2164,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-serde" name = "ruma-serde"
version = "0.5.0" version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "8b2b22aae842e7ecda695e42b7b39d4558959d9d9a27acc2a16acf4f4f7f00c3"
dependencies = [ dependencies = [
"bytes", "bytes",
"form_urlencoded", "form_urlencoded",
@ -2193,8 +2178,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-serde-macros" name = "ruma-serde-macros"
version = "0.5.0" version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "243e9bef188b08f94c79bc2f8fd1eb307a9e636b2b8e4571acf8c7be16381d28"
dependencies = [ dependencies = [
"proc-macro-crate", "proc-macro-crate",
"proc-macro2", "proc-macro2",
@ -2205,8 +2189,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-signatures" name = "ruma-signatures"
version = "0.9.0" version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "4a4f64027165b59500162d10d435b1253898bf3ad4f5002cb0d56913fe7f76d7"
dependencies = [ dependencies = [
"base64 0.13.0", "base64 0.13.0",
"ed25519-dalek", "ed25519-dalek",
@ -2223,8 +2206,7 @@ dependencies = [
[[package]] [[package]]
name = "ruma-state-res" name = "ruma-state-res"
version = "0.4.1" version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
checksum = "518c1afbddfcc5ffac8818a5cf0902709e6eca11aca8f24f6479df6f0601f1ba"
dependencies = [ dependencies = [
"itertools 0.10.1", "itertools 0.10.1",
"js_int", "js_int",

4
Cargo.toml
View File

@ -18,8 +18,8 @@ edition = "2018"
rocket = { version = "0.5.0-rc.1", features = ["tls"] } # Used to handle requests rocket = { version = "0.5.0-rc.1", features = ["tls"] } # Used to handle requests
# Used for matrix spec type definitions and helpers # Used for matrix spec type definitions and helpers
ruma = { version = "0.4.0", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] } #ruma = { version = "0.4.0", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
#ruma = { git = "https://github.com/ruma/ruma", rev = "f5ab038e22421ed338396ece977b6b2844772ced", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] } ruma = { git = "https://github.com/ruma/ruma", rev = "a6a1224652912a957b09f136ec5da2686be6e0e2", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
#ruma = { git = "https://github.com/timokoesters/ruma", rev = "50c1db7e0a3a21fc794b0cce3b64285a4c750c71", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] } #ruma = { git = "https://github.com/timokoesters/ruma", rev = "50c1db7e0a3a21fc794b0cce3b64285a4c750c71", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
#ruma = { path = "../ruma/crates/ruma", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] } #ruma = { path = "../ruma/crates/ruma", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }

2
src/appservice_server.rs
View File

@ -21,7 +21,7 @@ where
let hs_token = registration.get("hs_token").unwrap().as_str().unwrap(); let hs_token = registration.get("hs_token").unwrap().as_str().unwrap();
let mut http_request = request let mut http_request = request
.try_into_http_request::<BytesMut>(&destination, SendAccessToken::IfRequired("")) .try_into_http_request::<BytesMut>(destination, SendAccessToken::IfRequired(""))
.unwrap() .unwrap()
.map(|body| body.freeze()); .map(|body| body.freeze());

24
src/client_server/account.rs
View File

@ -572,7 +572,7 @@ pub async fn change_password_route(
if let Some(auth) = &body.auth { if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth( let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user, sender_user,
sender_device, sender_device,
auth, auth,
&uiaainfo, &uiaainfo,
@ -586,24 +586,24 @@ pub async fn change_password_route(
} else if let Some(json) = body.json_body { } else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH)); uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?; .create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo)); return Err(Error::Uiaa(uiaainfo));
} else { } else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json.")); return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
} }
db.users db.users
.set_password(&sender_user, Some(&body.new_password))?; .set_password(sender_user, Some(&body.new_password))?;
if body.logout_devices { if body.logout_devices {
// Logout all devices except the current one // Logout all devices except the current one
for id in db for id in db
.users .users
.all_device_ids(&sender_user) .all_device_ids(sender_user)
.filter_map(|id| id.ok()) .filter_map(|id| id.ok())
.filter(|id| id != sender_device) .filter(|id| id != sender_device)
{ {
db.users.remove_device(&sender_user, &id)?; db.users.remove_device(sender_user, &id)?;
} }
} }
@ -664,8 +664,8 @@ pub async fn deactivate_route(
if let Some(auth) = &body.auth { if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth( let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user, sender_user,
&sender_device, sender_device,
auth, auth,
&uiaainfo, &uiaainfo,
&db.users, &db.users,
@ -678,7 +678,7 @@ pub async fn deactivate_route(
} else if let Some(json) = body.json_body { } else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH)); uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?; .create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo)); return Err(Error::Uiaa(uiaainfo));
} else { } else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json.")); return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
@ -688,10 +688,10 @@ pub async fn deactivate_route(
// TODO: work over federation invites // TODO: work over federation invites
let all_rooms = db let all_rooms = db
.rooms .rooms
.rooms_joined(&sender_user) .rooms_joined(sender_user)
.chain( .chain(
db.rooms db.rooms
.rooms_invited(&sender_user) .rooms_invited(sender_user)
.map(|t| t.map(|(r, _)| r)), .map(|t| t.map(|(r, _)| r)),
) )
.collect::<Vec<_>>(); .collect::<Vec<_>>();
@ -726,7 +726,7 @@ pub async fn deactivate_route(
state_key: Some(sender_user.to_string()), state_key: Some(sender_user.to_string()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -734,7 +734,7 @@ pub async fn deactivate_route(
} }
// Remove devices and mark account as deactivated // Remove devices and mark account as deactivated
db.users.deactivate_account(&sender_user)?; db.users.deactivate_account(sender_user)?;
info!("{} deactivated their account", sender_user); info!("{} deactivated their account", sender_user);

4
src/client_server/alias.rs
View File

@ -112,7 +112,7 @@ pub(crate) async fn get_alias_helper(
} }
let mut room_id = None; let mut room_id = None;
match db.rooms.id_from_alias(&room_alias)? { match db.rooms.id_from_alias(room_alias)? {
Some(r) => room_id = Some(r), Some(r) => room_id = Some(r),
None => { None => {
for (_id, registration) in db.appservice.all()? { for (_id, registration) in db.appservice.all()? {
@ -140,7 +140,7 @@ pub(crate) async fn get_alias_helper(
.await .await
.is_ok() .is_ok()
{ {
room_id = Some(db.rooms.id_from_alias(&room_alias)?.ok_or_else(|| { room_id = Some(db.rooms.id_from_alias(room_alias)?.ok_or_else(|| {
Error::bad_config("Appservice lied to us. Room does not exist.") Error::bad_config("Appservice lied to us. Room does not exist.")
})?); })?);
break; break;

39
src/client_server/backup.rs
View File

@ -27,7 +27,7 @@ pub async fn create_backup_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let version = db let version = db
.key_backups .key_backups
.create_backup(&sender_user, &body.algorithm, &db.globals)?; .create_backup(sender_user, &body.algorithm, &db.globals)?;
db.flush()?; db.flush()?;
@ -48,7 +48,7 @@ pub async fn update_backup_route(
) -> ConduitResult<update_backup::Response> { ) -> ConduitResult<update_backup::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups db.key_backups
.update_backup(&sender_user, &body.version, &body.algorithm, &db.globals)?; .update_backup(sender_user, &body.version, &body.algorithm, &db.globals)?;
db.flush()?; db.flush()?;
@ -71,7 +71,7 @@ pub async fn get_latest_backup_route(
let (version, algorithm) = let (version, algorithm) =
db.key_backups db.key_backups
.get_latest_backup(&sender_user)? .get_latest_backup(sender_user)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"Key backup does not exist.", "Key backup does not exist.",
@ -101,7 +101,7 @@ pub async fn get_backup_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let algorithm = db let algorithm = db
.key_backups .key_backups
.get_backup(&sender_user, &body.version)? .get_backup(sender_user, &body.version)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"Key backup does not exist.", "Key backup does not exist.",
@ -132,7 +132,7 @@ pub async fn delete_backup_route(
) -> ConduitResult<delete_backup::Response> { ) -> ConduitResult<delete_backup::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups.delete_backup(&sender_user, &body.version)?; db.key_backups.delete_backup(sender_user, &body.version)?;
db.flush()?; db.flush()?;
@ -172,11 +172,11 @@ pub async fn add_backup_keys_route(
for (room_id, room) in &body.rooms { for (room_id, room) in &body.rooms {
for (session_id, key_data) in &room.sessions { for (session_id, key_data) in &room.sessions {
db.key_backups.add_key( db.key_backups.add_key(
&sender_user, sender_user,
&body.version, &body.version,
&room_id, room_id,
&session_id, session_id,
&key_data, key_data,
&db.globals, &db.globals,
)? )?
} }
@ -223,11 +223,11 @@ pub async fn add_backup_key_sessions_route(
for (session_id, key_data) in &body.sessions { for (session_id, key_data) in &body.sessions {
db.key_backups.add_key( db.key_backups.add_key(
&sender_user, sender_user,
&body.version, &body.version,
&body.room_id, &body.room_id,
&session_id, session_id,
&key_data, key_data,
&db.globals, &db.globals,
)? )?
} }
@ -272,7 +272,7 @@ pub async fn add_backup_key_session_route(
} }
db.key_backups.add_key( db.key_backups.add_key(
&sender_user, sender_user,
&body.version, &body.version,
&body.room_id, &body.room_id,
&body.session_id, &body.session_id,
@ -303,7 +303,7 @@ pub async fn get_backup_keys_route(
) -> ConduitResult<get_backup_keys::Response> { ) -> ConduitResult<get_backup_keys::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let rooms = db.key_backups.get_all(&sender_user, &body.version)?; let rooms = db.key_backups.get_all(sender_user, &body.version)?;
Ok(get_backup_keys::Response { rooms }.into()) Ok(get_backup_keys::Response { rooms }.into())
} }
@ -324,7 +324,7 @@ pub async fn get_backup_key_sessions_route(
let sessions = db let sessions = db
.key_backups .key_backups
.get_room(&sender_user, &body.version, &body.room_id)?; .get_room(sender_user, &body.version, &body.room_id)?;
Ok(get_backup_key_sessions::Response { sessions }.into()) Ok(get_backup_key_sessions::Response { sessions }.into())
} }
@ -345,7 +345,7 @@ pub async fn get_backup_key_session_route(
let key_data = db let key_data = db
.key_backups .key_backups
.get_session(&sender_user, &body.version, &body.room_id, &body.session_id)? .get_session(sender_user, &body.version, &body.room_id, &body.session_id)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"Backup key not found for this user's session.", "Backup key not found for this user's session.",
@ -368,8 +368,7 @@ pub async fn delete_backup_keys_route(
) -> ConduitResult<delete_backup_keys::Response> { ) -> ConduitResult<delete_backup_keys::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups db.key_backups.delete_all_keys(sender_user, &body.version)?;
.delete_all_keys(&sender_user, &body.version)?;
db.flush()?; db.flush()?;
@ -395,7 +394,7 @@ pub async fn delete_backup_key_sessions_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups db.key_backups
.delete_room_keys(&sender_user, &body.version, &body.room_id)?; .delete_room_keys(sender_user, &body.version, &body.room_id)?;
db.flush()?; db.flush()?;
@ -421,7 +420,7 @@ pub async fn delete_backup_key_session_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups db.key_backups
.delete_room_key(&sender_user, &body.version, &body.room_id, &body.session_id)?; .delete_room_key(sender_user, &body.version, &body.room_id, &body.session_id)?;
db.flush()?; db.flush()?;

3
src/client_server/capabilities.rs
View File

@ -1,5 +1,4 @@
use crate::ConduitResult; use crate::{ConduitResult, Ruma};
use crate::Ruma;
use ruma::{ use ruma::{
api::client::r0::capabilities::{ api::client::r0::capabilities::{
get_capabilities, Capabilities, RoomVersionStability, RoomVersionsCapability, get_capabilities, Capabilities, RoomVersionStability, RoomVersionsCapability,

4
src/client_server/context.rs
View File

@ -50,7 +50,7 @@ pub async fn get_context_route(
let events_before = db let events_before = db
.rooms .rooms
.pdus_until(&sender_user, &body.room_id, base_token)? .pdus_until(sender_user, &body.room_id, base_token)?
.take( .take(
u32::try_from(body.limit).map_err(|_| { u32::try_from(body.limit).map_err(|_| {
Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.") Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.")
@ -72,7 +72,7 @@ pub async fn get_context_route(
let events_after = db let events_after = db
.rooms .rooms
.pdus_after(&sender_user, &body.room_id, base_token)? .pdus_after(sender_user, &body.room_id, base_token)?
.take( .take(
u32::try_from(body.limit).map_err(|_| { u32::try_from(body.limit).map_err(|_| {
Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.") Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.")

22
src/client_server/device.rs
View File

@ -50,7 +50,7 @@ pub async fn get_device_route(
let device = db let device = db
.users .users
.get_device_metadata(&sender_user, &body.body.device_id)? .get_device_metadata(sender_user, &body.body.device_id)?
.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?; .ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;
Ok(get_device::Response { device }.into()) Ok(get_device::Response { device }.into())
@ -72,13 +72,13 @@ pub async fn update_device_route(
let mut device = db let mut device = db
.users .users
.get_device_metadata(&sender_user, &body.device_id)? .get_device_metadata(sender_user, &body.device_id)?
.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?; .ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;
device.display_name = body.display_name.clone(); device.display_name = body.display_name.clone();
db.users db.users
.update_device_metadata(&sender_user, &body.device_id, &device)?; .update_device_metadata(sender_user, &body.device_id, &device)?;
db.flush()?; db.flush()?;
@ -119,8 +119,8 @@ pub async fn delete_device_route(
if let Some(auth) = &body.auth { if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth( let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user, sender_user,
&sender_device, sender_device,
auth, auth,
&uiaainfo, &uiaainfo,
&db.users, &db.users,
@ -133,13 +133,13 @@ pub async fn delete_device_route(
} else if let Some(json) = body.json_body { } else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH)); uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?; .create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo)); return Err(Error::Uiaa(uiaainfo));
} else { } else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json.")); return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
} }
db.users.remove_device(&sender_user, &body.device_id)?; db.users.remove_device(sender_user, &body.device_id)?;
db.flush()?; db.flush()?;
@ -182,8 +182,8 @@ pub async fn delete_devices_route(
if let Some(auth) = &body.auth { if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth( let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user, sender_user,
&sender_device, sender_device,
auth, auth,
&uiaainfo, &uiaainfo,
&db.users, &db.users,
@ -196,14 +196,14 @@ pub async fn delete_devices_route(
} else if let Some(json) = body.json_body { } else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH)); uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?; .create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo)); return Err(Error::Uiaa(uiaainfo));
} else { } else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json.")); return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
} }
for device_id in &body.devices { for device_id in &body.devices {
db.users.remove_device(&sender_user, &device_id)? db.users.remove_device(sender_user, device_id)?
} }
db.flush()?; db.flush()?;

18
src/client_server/keys.rs
View File

@ -158,8 +158,8 @@ pub async fn upload_signing_keys_route(
if let Some(auth) = &body.auth { if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth( let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user, sender_user,
&sender_device, sender_device,
auth, auth,
&uiaainfo, &uiaainfo,
&db.users, &db.users,
@ -172,7 +172,7 @@ pub async fn upload_signing_keys_route(
} else if let Some(json) = body.json_body { } else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH)); uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?; .create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo)); return Err(Error::Uiaa(uiaainfo));
} else { } else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json.")); return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
@ -181,7 +181,7 @@ pub async fn upload_signing_keys_route(
if let Some(master_key) = &body.master_key { if let Some(master_key) = &body.master_key {
db.users.add_cross_signing_keys( db.users.add_cross_signing_keys(
sender_user, sender_user,
&master_key, master_key,
&body.self_signing_key, &body.self_signing_key,
&body.user_signing_key, &body.user_signing_key,
&db.rooms, &db.rooms,
@ -242,10 +242,10 @@ pub async fn upload_signatures_route(
.to_owned(), .to_owned(),
); );
db.users.sign_key( db.users.sign_key(
&user_id, user_id,
&key_id, key_id,
signature, signature,
&sender_user, sender_user,
&db.rooms, &db.rooms,
&db.globals, &db.globals,
)?; )?;
@ -359,8 +359,8 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
} else { } else {
for device_id in device_ids { for device_id in device_ids {
let mut container = BTreeMap::new(); let mut container = BTreeMap::new();
if let Some(mut keys) = db.users.get_device_keys(&user_id.clone(), &device_id)? { if let Some(mut keys) = db.users.get_device_keys(&user_id.clone(), device_id)? {
let metadata = db.users.get_device_metadata(user_id, &device_id)?.ok_or( let metadata = db.users.get_device_metadata(user_id, device_id)?.ok_or(
Error::BadRequest( Error::BadRequest(
ErrorKind::InvalidParam, ErrorKind::InvalidParam,
"Tried to get keys for nonexistent device.", "Tried to get keys for nonexistent device.",

3
src/client_server/media.rs
View File

@ -1,5 +1,6 @@
use crate::{ use crate::{
database::media::FileMeta, database::DatabaseGuard, utils, ConduitResult, Error, Ruma, database::{media::FileMeta, DatabaseGuard},
utils, ConduitResult, Error, Ruma,
}; };
use ruma::api::client::{ use ruma::api::client::{
error::ErrorKind, error::ErrorKind,

72
src/client_server/membership.rs
View File

@ -56,7 +56,7 @@ pub async fn join_room_by_id_route(
let mut servers = db let mut servers = db
.rooms .rooms
.invite_state(&sender_user, &body.room_id)? .invite_state(sender_user, &body.room_id)?
.unwrap_or_default() .unwrap_or_default()
.iter() .iter()
.filter_map(|event| { .filter_map(|event| {
@ -105,7 +105,7 @@ pub async fn join_room_by_id_or_alias_route(
Ok(room_id) => { Ok(room_id) => {
let mut servers = db let mut servers = db
.rooms .rooms
.invite_state(&sender_user, &room_id)? .invite_state(sender_user, &room_id)?
.unwrap_or_default() .unwrap_or_default()
.iter() .iter()
.filter_map(|event| { .filter_map(|event| {
@ -243,7 +243,7 @@ pub async fn kick_user_route(
state_key: Some(body.user_id.to_string()), state_key: Some(body.user_id.to_string()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&body.room_id, &body.room_id,
&db, &db,
&state_lock, &state_lock,
@ -319,7 +319,7 @@ pub async fn ban_user_route(
state_key: Some(body.user_id.to_string()), state_key: Some(body.user_id.to_string()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&body.room_id, &body.room_id,
&db, &db,
&state_lock, &state_lock,
@ -384,7 +384,7 @@ pub async fn unban_user_route(
state_key: Some(body.user_id.to_string()), state_key: Some(body.user_id.to_string()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&body.room_id, &body.room_id,
&db, &db,
&state_lock, &state_lock,
@ -416,7 +416,7 @@ pub async fn forget_room_route(
) -> ConduitResult<forget_room::Response> { ) -> ConduitResult<forget_room::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.rooms.forget(&body.room_id, &sender_user)?; db.rooms.forget(&body.room_id, sender_user)?;
db.flush()?; db.flush()?;
@ -440,7 +440,7 @@ pub async fn joined_rooms_route(
Ok(joined_rooms::Response { Ok(joined_rooms::Response {
joined_rooms: db joined_rooms: db
.rooms .rooms
.rooms_joined(&sender_user) .rooms_joined(sender_user)
.filter_map(|r| r.ok()) .filter_map(|r| r.ok())
.collect(), .collect(),
} }
@ -500,7 +500,7 @@ pub async fn joined_members_route(
) -> ConduitResult<joined_members::Response> { ) -> ConduitResult<joined_members::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !db.rooms.is_joined(&sender_user, &body.room_id)? { if !db.rooms.is_joined(sender_user, &body.room_id)? {
return Err(Error::BadRequest( return Err(Error::BadRequest(
ErrorKind::Forbidden, ErrorKind::Forbidden,
"You aren't a member of the room.", "You aren't a member of the room.",
@ -545,7 +545,7 @@ async fn join_room_by_id_helper(
let state_lock = mutex_state.lock().await; let state_lock = mutex_state.lock().await;
// Ask a remote server if we don't have this room // Ask a remote server if we don't have this room
if !db.rooms.exists(&room_id)? && room_id.server_name() != db.globals.server_name() { if !db.rooms.exists(room_id)? && room_id.server_name() != db.globals.server_name() {
let mut make_join_response_and_server = Err(Error::BadServerResponse( let mut make_join_response_and_server = Err(Error::BadServerResponse(
"No server available to assist in joining.", "No server available to assist in joining.",
)); ));
@ -606,11 +606,11 @@ async fn join_room_by_id_helper(
"content".to_owned(), "content".to_owned(),
to_canonical_value(member::MemberEventContent { to_canonical_value(member::MemberEventContent {
membership: member::MembershipState::Join, membership: member::MembershipState::Join,
displayname: db.users.displayname(&sender_user)?, displayname: db.users.displayname(sender_user)?,
avatar_url: db.users.avatar_url(&sender_user)?, avatar_url: db.users.avatar_url(sender_user)?,
is_direct: None, is_direct: None,
third_party_invite: None, third_party_invite: None,
blurhash: db.users.blurhash(&sender_user)?, blurhash: db.users.blurhash(sender_user)?,
reason: None, reason: None,
}) })
.expect("event is valid, we just created it"), .expect("event is valid, we just created it"),
@ -658,7 +658,7 @@ async fn join_room_by_id_helper(
) )
.await?; .await?;
db.rooms.get_or_create_shortroomid(&room_id, &db.globals)?; db.rooms.get_or_create_shortroomid(room_id, &db.globals)?;
let pdu = PduEvent::from_id_val(&event_id, join_event.clone()) let pdu = PduEvent::from_id_val(&event_id, join_event.clone())
.map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?; .map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?;
@ -670,7 +670,7 @@ async fn join_room_by_id_helper(
&send_join_response, &send_join_response,
&room_version, &room_version,
&pub_key_map, &pub_key_map,
&db, db,
) )
.await?; .await?;
@ -678,7 +678,7 @@ async fn join_room_by_id_helper(
.room_state .room_state
.state .state
.iter() .iter()
.map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map, &db)) .map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map, db))
{ {
let (event_id, value) = match result { let (event_id, value) = match result {
Ok(t) => t, Ok(t) => t,
@ -724,14 +724,14 @@ async fn join_room_by_id_helper(
.into_iter() .into_iter()
.map(|(k, id)| db.rooms.compress_state_event(k, &id, &db.globals)) .map(|(k, id)| db.rooms.compress_state_event(k, &id, &db.globals))
.collect::<Result<HashSet<_>>>()?, .collect::<Result<HashSet<_>>>()?,
&db, db,
)?; )?;
for result in send_join_response for result in send_join_response
.room_state .room_state
.auth_chain .auth_chain
.iter() .iter()
.map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map, &db)) .map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map, db))
{ {
let (event_id, value) = match result { let (event_id, value) = match result {
Ok(t) => t, Ok(t) => t,
@ -754,15 +754,15 @@ async fn join_room_by_id_helper(
// We set the room state after inserting the pdu, so that we never have a moment in time // We set the room state after inserting the pdu, so that we never have a moment in time
// where events in the current room state do not exist // where events in the current room state do not exist
db.rooms.set_room_state(&room_id, statehashid)?; db.rooms.set_room_state(room_id, statehashid)?;
} else { } else {
let event = member::MemberEventContent { let event = member::MemberEventContent {
membership: member::MembershipState::Join, membership: member::MembershipState::Join,
displayname: db.users.displayname(&sender_user)?, displayname: db.users.displayname(sender_user)?,
avatar_url: db.users.avatar_url(&sender_user)?, avatar_url: db.users.avatar_url(sender_user)?,
is_direct: None, is_direct: None,
third_party_invite: None, third_party_invite: None,
blurhash: db.users.blurhash(&sender_user)?, blurhash: db.users.blurhash(sender_user)?,
reason: None, reason: None,
}; };
@ -774,9 +774,9 @@ async fn join_room_by_id_helper(
state_key: Some(sender_user.to_string()), state_key: Some(sender_user.to_string()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, room_id,
&db, db,
&state_lock, &state_lock,
)?; )?;
} }
@ -800,7 +800,7 @@ fn validate_and_add_event_id(
})?; })?;
let event_id = EventId::try_from(&*format!( let event_id = EventId::try_from(&*format!(
"${}", "${}",
ruma::signatures::reference_hash(&value, &room_version) ruma::signatures::reference_hash(&value, room_version)
.expect("ruma can calculate reference hashes") .expect("ruma can calculate reference hashes")
)) ))
.expect("ruma's reference hashes are valid event ids"); .expect("ruma's reference hashes are valid event ids");
@ -927,7 +927,7 @@ pub(crate) async fn invite_helper<'a>(
let auth_events = db.rooms.get_auth_events( let auth_events = db.rooms.get_auth_events(
room_id, room_id,
&kind, &kind,
&sender_user, sender_user,
Some(&state_key), Some(&state_key),
&content, &content,
)?; )?;
@ -976,10 +976,10 @@ pub(crate) async fn invite_helper<'a>(
let auth_check = state_res::auth_check( let auth_check = state_res::auth_check(
&room_version, &room_version,
&Arc::new(pdu.clone()), &pdu,
create_prev_event, create_prev_event,
None, // TODO: third_party_invite None::<PduEvent>, // TODO: third_party_invite
|k, s| auth_events.get(&(k.clone(), s.to_owned())).map(Arc::clone), |k, s| auth_events.get(&(k.clone(), s.to_owned())),
) )
.map_err(|e| { .map_err(|e| {
error!("{:?}", e); error!("{:?}", e);
@ -1074,10 +1074,10 @@ pub(crate) async fn invite_helper<'a>(
let pdu_id = server_server::handle_incoming_pdu( let pdu_id = server_server::handle_incoming_pdu(
&origin, &origin,
&event_id, &event_id,
&room_id, room_id,
value, value,
true, true,
&db, db,
&pub_key_map, &pub_key_map,
) )
.await .await
@ -1119,11 +1119,11 @@ pub(crate) async fn invite_helper<'a>(
event_type: EventType::RoomMember, event_type: EventType::RoomMember,
content: serde_json::to_value(member::MemberEventContent { content: serde_json::to_value(member::MemberEventContent {
membership: member::MembershipState::Invite, membership: member::MembershipState::Invite,
displayname: db.users.displayname(&user_id)?, displayname: db.users.displayname(user_id)?,
avatar_url: db.users.avatar_url(&user_id)?, avatar_url: db.users.avatar_url(user_id)?,
is_direct: Some(is_direct), is_direct: Some(is_direct),
third_party_invite: None, third_party_invite: None,
blurhash: db.users.blurhash(&user_id)?, blurhash: db.users.blurhash(user_id)?,
reason: None, reason: None,
}) })
.expect("event is valid, we just created it"), .expect("event is valid, we just created it"),
@ -1131,9 +1131,9 @@ pub(crate) async fn invite_helper<'a>(
state_key: Some(user_id.to_string()), state_key: Some(user_id.to_string()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
room_id, room_id,
&db, db,
&state_lock, &state_lock,
)?; )?;

6
src/client_server/message.rs
View File

@ -79,7 +79,7 @@ pub async fn send_message_event_route(
state_key: None, state_key: None,
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&body.room_id, &body.room_id,
&db, &db,
&state_lock, &state_lock,
@ -141,7 +141,7 @@ pub async fn get_message_events_route(
get_message_events::Direction::Forward => { get_message_events::Direction::Forward => {
let events_after = db let events_after = db
.rooms .rooms
.pdus_after(&sender_user, &body.room_id, from)? .pdus_after(sender_user, &body.room_id, from)?
.take(limit) .take(limit)
.filter_map(|r| r.ok()) // Filter out buggy events .filter_map(|r| r.ok()) // Filter out buggy events
.filter_map(|(pdu_id, pdu)| { .filter_map(|(pdu_id, pdu)| {
@ -171,7 +171,7 @@ pub async fn get_message_events_route(
get_message_events::Direction::Backward => { get_message_events::Direction::Backward => {
let events_before = db let events_before = db
.rooms .rooms
.pdus_until(&sender_user, &body.room_id, from)? .pdus_until(sender_user, &body.room_id, from)?
.take(limit) .take(limit)
.filter_map(|r| r.ok()) // Filter out buggy events .filter_map(|r| r.ok()) // Filter out buggy events
.filter_map(|(pdu_id, pdu)| { .filter_map(|(pdu_id, pdu)| {

10
src/client_server/presence.rs
View File

@ -19,17 +19,17 @@ pub async fn set_presence_route(
) -> ConduitResult<set_presence::Response> { ) -> ConduitResult<set_presence::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
for room_id in db.rooms.rooms_joined(&sender_user) { for room_id in db.rooms.rooms_joined(sender_user) {
let room_id = room_id?; let room_id = room_id?;
db.rooms.edus.update_presence( db.rooms.edus.update_presence(
&sender_user, sender_user,
&room_id, &room_id,
ruma::events::presence::PresenceEvent { ruma::events::presence::PresenceEvent {
content: ruma::events::presence::PresenceEventContent { content: ruma::events::presence::PresenceEventContent {
avatar_url: db.users.avatar_url(&sender_user)?, avatar_url: db.users.avatar_url(sender_user)?,
currently_active: None, currently_active: None,
displayname: db.users.displayname(&sender_user)?, displayname: db.users.displayname(sender_user)?,
last_active_ago: Some( last_active_ago: Some(
utils::millis_since_unix_epoch() utils::millis_since_unix_epoch()
.try_into() .try_into()
@ -76,7 +76,7 @@ pub async fn get_presence_route(
if let Some(presence) = db if let Some(presence) = db
.rooms .rooms
.edus .edus
.get_last_presence_event(&sender_user, &room_id)? .get_last_presence_event(sender_user, &room_id)?
{ {
presence_event = Some(presence); presence_event = Some(presence);
break; break;

34
src/client_server/profile.rs
View File

@ -34,12 +34,12 @@ pub async fn set_displayname_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.users db.users
.set_displayname(&sender_user, body.displayname.clone())?; .set_displayname(sender_user, body.displayname.clone())?;
// Send a new membership event and presence update into all joined rooms // Send a new membership event and presence update into all joined rooms
let all_rooms_joined: Vec<_> = db let all_rooms_joined: Vec<_> = db
.rooms .rooms
.rooms_joined(&sender_user) .rooms_joined(sender_user)
.filter_map(|r| r.ok()) .filter_map(|r| r.ok())
.map(|room_id| { .map(|room_id| {
Ok::<_, Error>(( Ok::<_, Error>((
@ -89,19 +89,19 @@ pub async fn set_displayname_route(
); );
let state_lock = mutex_state.lock().await; let state_lock = mutex_state.lock().await;
let _ = let _ = db
db.rooms .rooms
.build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock); .build_and_append_pdu(pdu_builder, sender_user, &room_id, &db, &state_lock);
// Presence update // Presence update
db.rooms.edus.update_presence( db.rooms.edus.update_presence(
&sender_user, sender_user,
&room_id, &room_id,
ruma::events::presence::PresenceEvent { ruma::events::presence::PresenceEvent {
content: ruma::events::presence::PresenceEventContent { content: ruma::events::presence::PresenceEventContent {
avatar_url: db.users.avatar_url(&sender_user)?, avatar_url: db.users.avatar_url(sender_user)?,
currently_active: None, currently_active: None,
displayname: db.users.displayname(&sender_user)?, displayname: db.users.displayname(sender_user)?,
last_active_ago: Some( last_active_ago: Some(
utils::millis_since_unix_epoch() utils::millis_since_unix_epoch()
.try_into() .try_into()
@ -177,14 +177,14 @@ pub async fn set_avatar_url_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.users db.users
.set_avatar_url(&sender_user, body.avatar_url.clone())?; .set_avatar_url(sender_user, body.avatar_url.clone())?;
db.users.set_blurhash(&sender_user, body.blurhash.clone())?; db.users.set_blurhash(sender_user, body.blurhash.clone())?;
// Send a new membership event and presence update into all joined rooms // Send a new membership event and presence update into all joined rooms
let all_joined_rooms: Vec<_> = db let all_joined_rooms: Vec<_> = db
.rooms .rooms
.rooms_joined(&sender_user) .rooms_joined(sender_user)
.filter_map(|r| r.ok()) .filter_map(|r| r.ok())
.map(|room_id| { .map(|room_id| {
Ok::<_, Error>(( Ok::<_, Error>((
@ -234,19 +234,19 @@ pub async fn set_avatar_url_route(
); );
let state_lock = mutex_state.lock().await; let state_lock = mutex_state.lock().await;
let _ = let _ = db
db.rooms .rooms
.build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock); .build_and_append_pdu(pdu_builder, sender_user, &room_id, &db, &state_lock);
// Presence update // Presence update
db.rooms.edus.update_presence( db.rooms.edus.update_presence(
&sender_user, sender_user,
&room_id, &room_id,
ruma::events::presence::PresenceEvent { ruma::events::presence::PresenceEvent {
content: ruma::events::presence::PresenceEventContent { content: ruma::events::presence::PresenceEventContent {
avatar_url: db.users.avatar_url(&sender_user)?, avatar_url: db.users.avatar_url(sender_user)?,
currently_active: None, currently_active: None,
displayname: db.users.displayname(&sender_user)?, displayname: db.users.displayname(sender_user)?,
last_active_ago: Some( last_active_ago: Some(
utils::millis_since_unix_epoch() utils::millis_since_unix_epoch()
.try_into() .try_into()

52
src/client_server/push.rs
View File

@ -31,7 +31,7 @@ pub async fn get_pushrules_all_route(
let event = db let event = db
.account_data .account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)? .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"PushRules event not found.", "PushRules event not found.",
@ -59,7 +59,7 @@ pub async fn get_pushrule_route(
let event = db let event = db
.account_data .account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)? .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"PushRules event not found.", "PushRules event not found.",
@ -124,7 +124,7 @@ pub async fn set_pushrule_route(
let mut event = db let mut event = db
.account_data .account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)? .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"PushRules event not found.", "PushRules event not found.",
@ -193,13 +193,8 @@ pub async fn set_pushrule_route(
_ => {} _ => {}
} }
db.account_data.update( db.account_data
None, .update(None, sender_user, EventType::PushRules, &event, &db.globals)?;
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.flush()?; db.flush()?;
@ -229,7 +224,7 @@ pub async fn get_pushrule_actions_route(
let mut event = db let mut event = db
.account_data .account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)? .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"PushRules event not found.", "PushRules event not found.",
@ -291,7 +286,7 @@ pub async fn set_pushrule_actions_route(
let mut event = db let mut event = db
.account_data .account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)? .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"PushRules event not found.", "PushRules event not found.",
@ -332,13 +327,8 @@ pub async fn set_pushrule_actions_route(
_ => {} _ => {}
}; };
db.account_data.update( db.account_data
None, .update(None, sender_user, EventType::PushRules, &event, &db.globals)?;
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.flush()?; db.flush()?;
@ -368,7 +358,7 @@ pub async fn get_pushrule_enabled_route(
let mut event = db let mut event = db
.account_data .account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)? .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"PushRules event not found.", "PushRules event not found.",
@ -432,7 +422,7 @@ pub async fn set_pushrule_enabled_route(
let mut event = db let mut event = db
.account_data .account_data
.get::<ruma::events::push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)? .get::<ruma::events::push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"PushRules event not found.", "PushRules event not found.",
@ -478,13 +468,8 @@ pub async fn set_pushrule_enabled_route(
_ => {} _ => {}
} }
db.account_data.update( db.account_data
None, .update(None, sender_user, EventType::PushRules, &event, &db.globals)?;
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.flush()?; db.flush()?;
@ -514,7 +499,7 @@ pub async fn delete_pushrule_route(
let mut event = db let mut event = db
.account_data .account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)? .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"PushRules event not found.", "PushRules event not found.",
@ -550,13 +535,8 @@ pub async fn delete_pushrule_route(
_ => {} _ => {}
} }
db.account_data.update( db.account_data
None, .update(None, sender_user, EventType::PushRules, &event, &db.globals)?;
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.flush()?; db.flush()?;

14
src/client_server/read_marker.rs
View File

@ -37,7 +37,7 @@ pub async fn set_read_marker_route(
}; };
db.account_data.update( db.account_data.update(
Some(&body.room_id), Some(&body.room_id),
&sender_user, sender_user,
EventType::FullyRead, EventType::FullyRead,
&fully_read_event, &fully_read_event,
&db.globals, &db.globals,
@ -46,7 +46,7 @@ pub async fn set_read_marker_route(
if let Some(event) = &body.read_receipt { if let Some(event) = &body.read_receipt {
db.rooms.edus.private_read_set( db.rooms.edus.private_read_set(
&body.room_id, &body.room_id,
&sender_user, sender_user,
db.rooms.get_pdu_count(event)?.ok_or(Error::BadRequest( db.rooms.get_pdu_count(event)?.ok_or(Error::BadRequest(
ErrorKind::InvalidParam, ErrorKind::InvalidParam,
"Event does not exist.", "Event does not exist.",
@ -54,7 +54,7 @@ pub async fn set_read_marker_route(
&db.globals, &db.globals,
)?; )?;
db.rooms db.rooms
.reset_notification_counts(&sender_user, &body.room_id)?; .reset_notification_counts(sender_user, &body.room_id)?;
let mut user_receipts = BTreeMap::new(); let mut user_receipts = BTreeMap::new();
user_receipts.insert( user_receipts.insert(
@ -71,7 +71,7 @@ pub async fn set_read_marker_route(
receipt_content.insert(event.to_owned(), receipts); receipt_content.insert(event.to_owned(), receipts);
db.rooms.edus.readreceipt_update( db.rooms.edus.readreceipt_update(
&sender_user, sender_user,
&body.room_id, &body.room_id,
AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent { AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent {
content: ruma::events::receipt::ReceiptEventContent(receipt_content), content: ruma::events::receipt::ReceiptEventContent(receipt_content),
@ -102,7 +102,7 @@ pub async fn create_receipt_route(
db.rooms.edus.private_read_set( db.rooms.edus.private_read_set(
&body.room_id, &body.room_id,
&sender_user, sender_user,
db.rooms db.rooms
.get_pdu_count(&body.event_id)? .get_pdu_count(&body.event_id)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
@ -112,7 +112,7 @@ pub async fn create_receipt_route(
&db.globals, &db.globals,
)?; )?;
db.rooms db.rooms
.reset_notification_counts(&sender_user, &body.room_id)?; .reset_notification_counts(sender_user, &body.room_id)?;
let mut user_receipts = BTreeMap::new(); let mut user_receipts = BTreeMap::new();
user_receipts.insert( user_receipts.insert(
@ -128,7 +128,7 @@ pub async fn create_receipt_route(
receipt_content.insert(body.event_id.to_owned(), receipts); receipt_content.insert(body.event_id.to_owned(), receipts);
db.rooms.edus.readreceipt_update( db.rooms.edus.readreceipt_update(
&sender_user, sender_user,
&body.room_id, &body.room_id,
AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent { AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent {
content: ruma::events::receipt::ReceiptEventContent(receipt_content), content: ruma::events::receipt::ReceiptEventContent(receipt_content),

2
src/client_server/redact.rs
View File

@ -46,7 +46,7 @@ pub async fn redact_event_route(
state_key: None, state_key: None,
redacts: Some(body.event_id.clone()), redacts: Some(body.event_id.clone()),
}, },
&sender_user, sender_user,
&body.room_id, &body.room_id,
&db, &db,
&state_lock, &state_lock,

32
src/client_server/room.rs
View File

@ -106,7 +106,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()), state_key: Some("".to_owned()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -118,11 +118,11 @@ pub async fn create_room_route(
event_type: EventType::RoomMember, event_type: EventType::RoomMember,
content: serde_json::to_value(member::MemberEventContent { content: serde_json::to_value(member::MemberEventContent {
membership: member::MembershipState::Join, membership: member::MembershipState::Join,
displayname: db.users.displayname(&sender_user)?, displayname: db.users.displayname(sender_user)?,
avatar_url: db.users.avatar_url(&sender_user)?, avatar_url: db.users.avatar_url(sender_user)?,
is_direct: Some(body.is_direct), is_direct: Some(body.is_direct),
third_party_invite: None, third_party_invite: None,
blurhash: db.users.blurhash(&sender_user)?, blurhash: db.users.blurhash(sender_user)?,
reason: None, reason: None,
}) })
.expect("event is valid, we just created it"), .expect("event is valid, we just created it"),
@ -130,7 +130,7 @@ pub async fn create_room_route(
state_key: Some(sender_user.to_string()), state_key: Some(sender_user.to_string()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -185,7 +185,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()), state_key: Some("".to_owned()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -207,7 +207,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()), state_key: Some("".to_owned()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -235,7 +235,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()), state_key: Some("".to_owned()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -253,7 +253,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()), state_key: Some("".to_owned()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -279,7 +279,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()), state_key: Some("".to_owned()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -298,7 +298,7 @@ pub async fn create_room_route(
} }
db.rooms db.rooms
.build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock)?; .build_and_append_pdu(pdu_builder, sender_user, &room_id, &db, &state_lock)?;
} }
// 7. Events implied by name and topic // 7. Events implied by name and topic
@ -312,7 +312,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()), state_key: Some("".to_owned()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -331,7 +331,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()), state_key: Some("".to_owned()),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, &room_id,
&db, &db,
&state_lock, &state_lock,
@ -551,11 +551,11 @@ pub async fn upgrade_room_route(
event_type: EventType::RoomMember, event_type: EventType::RoomMember,
content: serde_json::to_value(member::MemberEventContent { content: serde_json::to_value(member::MemberEventContent {
membership: member::MembershipState::Join, membership: member::MembershipState::Join,
displayname: db.users.displayname(&sender_user)?, displayname: db.users.displayname(sender_user)?,
avatar_url: db.users.avatar_url(&sender_user)?, avatar_url: db.users.avatar_url(sender_user)?,
is_direct: None, is_direct: None,
third_party_invite: None, third_party_invite: None,
blurhash: db.users.blurhash(&sender_user)?, blurhash: db.users.blurhash(sender_user)?,
reason: None, reason: None,
}) })
.expect("event is valid, we just created it"), .expect("event is valid, we just created it"),

4
src/client_server/search.rs
View File

@ -27,7 +27,7 @@ pub async fn search_events_route(
let room_ids = filter.rooms.clone().unwrap_or_else(|| { let room_ids = filter.rooms.clone().unwrap_or_else(|| {
db.rooms db.rooms
.rooms_joined(&sender_user) .rooms_joined(sender_user)
.filter_map(|r| r.ok()) .filter_map(|r| r.ok())
.collect() .collect()
}); });
@ -88,7 +88,7 @@ pub async fn search_events_route(
rank: None, rank: None,
result: db result: db
.rooms .rooms
.get_pdu_from_id(&result)? .get_pdu_from_id(result)?
.map(|pdu| pdu.to_room_event()), .map(|pdu| pdu.to_room_event()),
}) })
}) })

8
src/client_server/session.rs
View File

@ -100,8 +100,8 @@ pub async fn login_route(
login::IncomingLoginInfo::Token { token } => { login::IncomingLoginInfo::Token { token } => {
if let Some(jwt_decoding_key) = db.globals.jwt_decoding_key() { if let Some(jwt_decoding_key) = db.globals.jwt_decoding_key() {
let token = jsonwebtoken::decode::<Claims>( let token = jsonwebtoken::decode::<Claims>(
&token, token,
&jwt_decoding_key, jwt_decoding_key,
&jsonwebtoken::Validation::default(), &jsonwebtoken::Validation::default(),
) )
.map_err(|_| Error::BadRequest(ErrorKind::InvalidUsername, "Token is invalid."))?; .map_err(|_| Error::BadRequest(ErrorKind::InvalidUsername, "Token is invalid."))?;
@ -179,7 +179,7 @@ pub async fn logout_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device = body.sender_device.as_ref().expect("user is authenticated"); let sender_device = body.sender_device.as_ref().expect("user is authenticated");
db.users.remove_device(&sender_user, sender_device)?; db.users.remove_device(sender_user, sender_device)?;
db.flush()?; db.flush()?;
@ -209,7 +209,7 @@ pub async fn logout_all_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
for device_id in db.users.all_device_ids(sender_user).flatten() { for device_id in db.users.all_device_ids(sender_user).flatten() {
db.users.remove_device(&sender_user, &device_id)?; db.users.remove_device(sender_user, &device_id)?;
} }
db.flush()?; db.flush()?;

6
src/client_server/state.rs
View File

@ -308,9 +308,9 @@ async fn send_state_event_for_key_helper(
state_key: Some(state_key), state_key: Some(state_key),
redacts: None, redacts: None,
}, },
&sender_user, sender_user,
&room_id, room_id,
&db, db,
&state_lock, &state_lock,
)?; )?;

8
src/client_server/to_device.rs
View File

@ -68,8 +68,8 @@ pub async fn send_event_to_device_route(
match target_device_id_maybe { match target_device_id_maybe {
DeviceIdOrAllDevices::DeviceId(target_device_id) => db.users.add_to_device_event( DeviceIdOrAllDevices::DeviceId(target_device_id) => db.users.add_to_device_event(
sender_user, sender_user,
&target_user_id, target_user_id,
&target_device_id, target_device_id,
&body.event_type, &body.event_type,
event.deserialize_as().map_err(|_| { event.deserialize_as().map_err(|_| {
Error::BadRequest(ErrorKind::InvalidParam, "Event is invalid") Error::BadRequest(ErrorKind::InvalidParam, "Event is invalid")
@ -78,10 +78,10 @@ pub async fn send_event_to_device_route(
)?, )?,
DeviceIdOrAllDevices::AllDevices => { DeviceIdOrAllDevices::AllDevices => {
for target_device_id in db.users.all_device_ids(&target_user_id) { for target_device_id in db.users.all_device_ids(target_user_id) {
db.users.add_to_device_event( db.users.add_to_device_event(
sender_user, sender_user,
&target_user_id, target_user_id,
&target_device_id?, &target_device_id?,
&body.event_type, &body.event_type,
event.deserialize_as().map_err(|_| { event.deserialize_as().map_err(|_| {

4
src/client_server/typing.rs
View File

@ -21,7 +21,7 @@ pub fn create_typing_event_route(
if let Typing::Yes(duration) = body.state { if let Typing::Yes(duration) = body.state {
db.rooms.edus.typing_add( db.rooms.edus.typing_add(
&sender_user, sender_user,
&body.room_id, &body.room_id,
duration.as_millis() as u64 + utils::millis_since_unix_epoch(), duration.as_millis() as u64 + utils::millis_since_unix_epoch(),
&db.globals, &db.globals,
@ -29,7 +29,7 @@ pub fn create_typing_event_route(
} else { } else {
db.rooms db.rooms
.edus .edus
.typing_remove(&sender_user, &body.room_id, &db.globals)?; .typing_remove(sender_user, &body.room_id, &db.globals)?;
} }
Ok(create_typing_event::Response {}.into()) Ok(create_typing_event::Response {}.into())

14
src/database.rs
View File

@ -196,14 +196,14 @@ impl Database {
/// Load an existing database or create a new one. /// Load an existing database or create a new one.
pub async fn load_or_create(config: &Config) -> Result<Arc<TokioRwLock<Self>>> { pub async fn load_or_create(config: &Config) -> Result<Arc<TokioRwLock<Self>>> {
Self::check_sled_or_sqlite_db(&config)?; Self::check_sled_or_sqlite_db(config)?;
if !Path::new(&config.database_path).exists() { if !Path::new(&config.database_path).exists() {
std::fs::create_dir_all(&config.database_path) std::fs::create_dir_all(&config.database_path)
.map_err(|_| Error::BadConfig("Database folder doesn't exists and couldn't be created (e.g. due to missing permissions). Please create the database folder yourself."))?; .map_err(|_| Error::BadConfig("Database folder doesn't exists and couldn't be created (e.g. due to missing permissions). Please create the database folder yourself."))?;
} }
let builder = Engine::open(&config)?; let builder = Engine::open(config)?;
if config.max_request_size < 1024 { if config.max_request_size < 1024 {
eprintln!("ERROR: Max request size is less than 1KB. Please increase it."); eprintln!("ERROR: Max request size is less than 1KB. Please increase it.");
@ -618,7 +618,7 @@ impl Database {
let short_room_id = db let short_room_id = db
.rooms .rooms
.roomid_shortroomid .roomid_shortroomid
.get(&room_id) .get(room_id)
.unwrap() .unwrap()
.expect("shortroomid should exist"); .expect("shortroomid should exist");
@ -641,7 +641,7 @@ impl Database {
let short_room_id = db let short_room_id = db
.rooms .rooms
.roomid_shortroomid .roomid_shortroomid
.get(&room_id) .get(room_id)
.unwrap() .unwrap()
.expect("shortroomid should exist"); .expect("shortroomid should exist");
@ -677,7 +677,7 @@ impl Database {
let short_room_id = db let short_room_id = db
.rooms .rooms
.roomid_shortroomid .roomid_shortroomid
.get(&room_id) .get(room_id)
.unwrap() .unwrap()
.expect("shortroomid should exist"); .expect("shortroomid should exist");
let mut new_key = short_room_id; let mut new_key = short_room_id;
@ -757,7 +757,7 @@ impl Database {
#[cfg(feature = "sqlite")] #[cfg(feature = "sqlite")]
{ {
Self::start_wal_clean_task(Arc::clone(&db), &config).await; Self::start_wal_clean_task(Arc::clone(&db), config).await;
} }
Ok(db) Ok(db)
@ -964,7 +964,7 @@ impl<'r> FromRequest<'r> for DatabaseGuard {
async fn from_request(req: &'r Request<'_>) -> rocket::request::Outcome<Self, ()> { async fn from_request(req: &'r Request<'_>) -> rocket::request::Outcome<Self, ()> {
let db = try_outcome!(req.guard::<&State<Arc<TokioRwLock<Database>>>>().await); let db = try_outcome!(req.guard::<&State<Arc<TokioRwLock<Database>>>>().await);
Ok(DatabaseGuard(Arc::clone(&db).read_owned().await)).or_forward(()) Ok(DatabaseGuard(Arc::clone(db).read_owned().await)).or_forward(())
} }
} }

4
src/database/abstraction/sqlite.rs
View File

@ -192,7 +192,7 @@ impl SqliteTable {
impl Tree for SqliteTable { impl Tree for SqliteTable {
#[tracing::instrument(skip(self, key))] #[tracing::instrument(skip(self, key))]
fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> { fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
self.get_with_guard(&self.engine.read_lock(), key) self.get_with_guard(self.engine.read_lock(), key)
} }
#[tracing::instrument(skip(self, key, value))] #[tracing::instrument(skip(self, key, value))]
@ -275,7 +275,7 @@ impl Tree for SqliteTable {
fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> { fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
let guard = self.engine.read_lock_iterator(); let guard = self.engine.read_lock_iterator();
self.iter_with_guard(&guard) self.iter_with_guard(guard)
} }
#[tracing::instrument(skip(self, from, backwards))] #[tracing::instrument(skip(self, from, backwards))]

8
src/database/account_data.rs
View File

@ -32,13 +32,13 @@ impl AccountData {
.as_bytes() .as_bytes()
.to_vec(); .to_vec();
prefix.push(0xff); prefix.push(0xff);
prefix.extend_from_slice(&user_id.as_bytes()); prefix.extend_from_slice(user_id.as_bytes());
prefix.push(0xff); prefix.push(0xff);
let mut roomuserdataid = prefix.clone(); let mut roomuserdataid = prefix.clone();
roomuserdataid.extend_from_slice(&globals.next_count()?.to_be_bytes()); roomuserdataid.extend_from_slice(&globals.next_count()?.to_be_bytes());
roomuserdataid.push(0xff); roomuserdataid.push(0xff);
roomuserdataid.extend_from_slice(&event_type.as_bytes()); roomuserdataid.extend_from_slice(event_type.as_bytes());
let mut key = prefix; let mut key = prefix;
key.extend_from_slice(event_type.as_bytes()); key.extend_from_slice(event_type.as_bytes());
@ -83,7 +83,7 @@ impl AccountData {
.as_bytes() .as_bytes()
.to_vec(); .to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&user_id.as_bytes()); key.extend_from_slice(user_id.as_bytes());
key.push(0xff); key.push(0xff);
key.extend_from_slice(kind.as_ref().as_bytes()); key.extend_from_slice(kind.as_ref().as_bytes());
@ -118,7 +118,7 @@ impl AccountData {
.as_bytes() .as_bytes()
.to_vec(); .to_vec();
prefix.push(0xff); prefix.push(0xff);
prefix.extend_from_slice(&user_id.as_bytes()); prefix.extend_from_slice(user_id.as_bytes());
prefix.push(0xff); prefix.push(0xff);
// Skip the data that's exactly at since, because we sent that last time // Skip the data that's exactly at since, because we sent that last time

2
src/database/globals.rs
View File

@ -113,7 +113,7 @@ impl Globals {
.map(|key| (version, key)) .map(|key| (version, key))
}) })
.and_then(|(version, key)| { .and_then(|(version, key)| {
ruma::signatures::Ed25519KeyPair::from_der(&key, version) ruma::signatures::Ed25519KeyPair::from_der(key, version)
.map_err(|_| Error::bad_database("Private or public keys are invalid.")) .map_err(|_| Error::bad_database("Private or public keys are invalid."))
}); });

28
src/database/key_backups.rs
View File

@ -27,7 +27,7 @@ impl KeyBackups {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&version.as_bytes()); key.extend_from_slice(version.as_bytes());
self.backupid_algorithm.insert( self.backupid_algorithm.insert(
&key, &key,
@ -41,7 +41,7 @@ impl KeyBackups {
pub fn delete_backup(&self, user_id: &UserId, version: &str) -> Result<()> { pub fn delete_backup(&self, user_id: &UserId, version: &str) -> Result<()> {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&version.as_bytes()); key.extend_from_slice(version.as_bytes());
self.backupid_algorithm.remove(&key)?; self.backupid_algorithm.remove(&key)?;
self.backupid_etag.remove(&key)?; self.backupid_etag.remove(&key)?;
@ -64,7 +64,7 @@ impl KeyBackups {
) -> Result<String> { ) -> Result<String> {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&version.as_bytes()); key.extend_from_slice(version.as_bytes());
if self.backupid_algorithm.get(&key)?.is_none() { if self.backupid_algorithm.get(&key)?.is_none() {
return Err(Error::BadRequest( return Err(Error::BadRequest(
@ -75,7 +75,7 @@ impl KeyBackups {
self.backupid_algorithm.insert( self.backupid_algorithm.insert(
&key, &key,
&serde_json::to_string(backup_metadata) serde_json::to_string(backup_metadata)
.expect("BackupAlgorithm::to_string always works") .expect("BackupAlgorithm::to_string always works")
.as_bytes(), .as_bytes(),
)?; )?;
@ -192,7 +192,7 @@ impl KeyBackups {
pub fn get_etag(&self, user_id: &UserId, version: &str) -> Result<String> { pub fn get_etag(&self, user_id: &UserId, version: &str) -> Result<String> {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&version.as_bytes()); key.extend_from_slice(version.as_bytes());
Ok(utils::u64_from_bytes( Ok(utils::u64_from_bytes(
&self &self
@ -223,7 +223,7 @@ impl KeyBackups {
let mut parts = key.rsplit(|&b| b == 0xff); let mut parts = key.rsplit(|&b| b == 0xff);
let session_id = let session_id =
utils::string_from_bytes(&parts.next().ok_or_else(|| { utils::string_from_bytes(parts.next().ok_or_else(|| {
Error::bad_database("backupkeyid_backup key is invalid.") Error::bad_database("backupkeyid_backup key is invalid.")
})?) })?)
.map_err(|_| { .map_err(|_| {
@ -231,7 +231,7 @@ impl KeyBackups {
})?; })?;
let room_id = RoomId::try_from( let room_id = RoomId::try_from(
utils::string_from_bytes(&parts.next().ok_or_else(|| { utils::string_from_bytes(parts.next().ok_or_else(|| {
Error::bad_database("backupkeyid_backup key is invalid.") Error::bad_database("backupkeyid_backup key is invalid.")
})?) })?)
.map_err(|_| Error::bad_database("backupkeyid_backup room_id is invalid."))?, .map_err(|_| Error::bad_database("backupkeyid_backup room_id is invalid."))?,
@ -280,7 +280,7 @@ impl KeyBackups {
let mut parts = key.rsplit(|&b| b == 0xff); let mut parts = key.rsplit(|&b| b == 0xff);
let session_id = let session_id =
utils::string_from_bytes(&parts.next().ok_or_else(|| { utils::string_from_bytes(parts.next().ok_or_else(|| {
Error::bad_database("backupkeyid_backup key is invalid.") Error::bad_database("backupkeyid_backup key is invalid.")
})?) })?)
.map_err(|_| { .map_err(|_| {
@ -325,7 +325,7 @@ impl KeyBackups {
pub fn delete_all_keys(&self, user_id: &UserId, version: &str) -> Result<()> { pub fn delete_all_keys(&self, user_id: &UserId, version: &str) -> Result<()> {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&version.as_bytes()); key.extend_from_slice(version.as_bytes());
key.push(0xff); key.push(0xff);
for (outdated_key, _) in self.backupkeyid_backup.scan_prefix(key) { for (outdated_key, _) in self.backupkeyid_backup.scan_prefix(key) {
@ -343,9 +343,9 @@ impl KeyBackups {
) -> Result<()> { ) -> Result<()> {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&version.as_bytes()); key.extend_from_slice(version.as_bytes());
key.push(0xff); key.push(0xff);
key.extend_from_slice(&room_id.as_bytes()); key.extend_from_slice(room_id.as_bytes());
key.push(0xff); key.push(0xff);
for (outdated_key, _) in self.backupkeyid_backup.scan_prefix(key) { for (outdated_key, _) in self.backupkeyid_backup.scan_prefix(key) {
@ -364,11 +364,11 @@ impl KeyBackups {
) -> Result<()> { ) -> Result<()> {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&version.as_bytes()); key.extend_from_slice(version.as_bytes());
key.push(0xff); key.push(0xff);
key.extend_from_slice(&room_id.as_bytes()); key.extend_from_slice(room_id.as_bytes());
key.push(0xff); key.push(0xff);
key.extend_from_slice(&session_id.as_bytes()); key.extend_from_slice(session_id.as_bytes());
for (outdated_key, _) in self.backupkeyid_backup.scan_prefix(key) { for (outdated_key, _) in self.backupkeyid_backup.scan_prefix(key) {
self.backupkeyid_backup.remove(&outdated_key)?; self.backupkeyid_backup.remove(&outdated_key)?;

5
src/database/media.rs
View File

@ -4,7 +4,10 @@ use image::{imageops::FilterType, GenericImageView};
use super::abstraction::Tree; use super::abstraction::Tree;
use crate::{utils, Error, Result}; use crate::{utils, Error, Result};
use std::{mem, sync::Arc}; use std::{mem, sync::Arc};
use tokio::{fs::File, io::AsyncReadExt, io::AsyncWriteExt}; use tokio::{
fs::File,
io::{AsyncReadExt, AsyncWriteExt},
};
pub struct FileMeta { pub struct FileMeta {
pub content_disposition: Option<String>, pub content_disposition: Option<String>,

6
src/database/pusher.rs
View File

@ -236,7 +236,7 @@ pub fn get_actions<'a>(
member_count: 10_u32.into(), // TODO: get member count efficiently member_count: 10_u32.into(), // TODO: get member count efficiently
user_display_name: db user_display_name: db
.users .users
.displayname(&user)? .displayname(user)?
.unwrap_or_else(|| user.localpart().to_owned()), .unwrap_or_else(|| user.localpart().to_owned()),
users_power_levels: power_levels.users.clone(), users_power_levels: power_levels.users.clone(),
default_power_level: power_levels.users_default, default_power_level: power_levels.users_default,
@ -302,7 +302,7 @@ async fn send_notice(
if event_id_only { if event_id_only {
send_request( send_request(
&db.globals, &db.globals,
&url, url,
send_event_notification::v1::Request::new(notifi), send_event_notification::v1::Request::new(notifi),
) )
.await?; .await?;
@ -332,7 +332,7 @@ async fn send_notice(
send_request( send_request(
&db.globals, &db.globals,
&url, url,
send_event_notification::v1::Request::new(notifi), send_event_notification::v1::Request::new(notifi),
) )
.await?; .await?;

144
src/database/rooms.rs
View File

@ -252,12 +252,7 @@ impl Rooms {
return Ok(HashMap::new()); return Ok(HashMap::new());
}; };
let auth_events = state_res::auth_types_for_event( let auth_events = state_res::auth_types_for_event(kind, sender, state_key, content);
kind,
sender,
state_key.map(|s| s.to_string()),
content.clone(),
);
let mut sauthevents = auth_events let mut sauthevents = auth_events
.into_iter() .into_iter()
@ -344,7 +339,7 @@ impl Rooms {
new_state_ids_compressed: HashSet<CompressedStateEvent>, new_state_ids_compressed: HashSet<CompressedStateEvent>,
db: &Database, db: &Database,
) -> Result<()> { ) -> Result<()> {
let previous_shortstatehash = self.current_shortstatehash(&room_id)?; let previous_shortstatehash = self.current_shortstatehash(room_id)?;
let state_hash = self.calculate_hash( let state_hash = self.calculate_hash(
&new_state_ids_compressed &new_state_ids_compressed
@ -429,7 +424,7 @@ impl Rooms {
} }
} }
self.update_joined_count(room_id, &db)?; self.update_joined_count(room_id, db)?;
self.roomid_shortstatehash self.roomid_shortstatehash
.insert(room_id.as_bytes(), &new_shortstatehash.to_be_bytes())?; .insert(room_id.as_bytes(), &new_shortstatehash.to_be_bytes())?;
@ -709,7 +704,7 @@ impl Rooms {
event_id: &EventId, event_id: &EventId,
globals: &super::globals::Globals, globals: &super::globals::Globals,
) -> Result<u64> { ) -> Result<u64> {
if let Some(short) = self.eventidshort_cache.lock().unwrap().get_mut(&event_id) { if let Some(short) = self.eventidshort_cache.lock().unwrap().get_mut(event_id) {
return Ok(*short); return Ok(*short);
} }
@ -737,7 +732,7 @@ impl Rooms {
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
pub fn get_shortroomid(&self, room_id: &RoomId) -> Result<Option<u64>> { pub fn get_shortroomid(&self, room_id: &RoomId) -> Result<Option<u64>> {
self.roomid_shortroomid self.roomid_shortroomid
.get(&room_id.as_bytes())? .get(room_id.as_bytes())?
.map(|bytes| { .map(|bytes| {
utils::u64_from_bytes(&bytes) utils::u64_from_bytes(&bytes)
.map_err(|_| Error::bad_database("Invalid shortroomid in db.")) .map_err(|_| Error::bad_database("Invalid shortroomid in db."))
@ -762,7 +757,7 @@ impl Rooms {
let mut statekey = event_type.as_ref().as_bytes().to_vec(); let mut statekey = event_type.as_ref().as_bytes().to_vec();
statekey.push(0xff); statekey.push(0xff);
statekey.extend_from_slice(&state_key.as_bytes()); statekey.extend_from_slice(state_key.as_bytes());
let short = self let short = self
.statekey_shortstatekey .statekey_shortstatekey
@ -789,13 +784,13 @@ impl Rooms {
room_id: &RoomId, room_id: &RoomId,
globals: &super::globals::Globals, globals: &super::globals::Globals,
) -> Result<u64> { ) -> Result<u64> {
Ok(match self.roomid_shortroomid.get(&room_id.as_bytes())? { Ok(match self.roomid_shortroomid.get(room_id.as_bytes())? {
Some(short) => utils::u64_from_bytes(&short) Some(short) => utils::u64_from_bytes(&short)
.map_err(|_| Error::bad_database("Invalid shortroomid in db."))?, .map_err(|_| Error::bad_database("Invalid shortroomid in db."))?,
None => { None => {
let short = globals.next_count()?; let short = globals.next_count()?;
self.roomid_shortroomid self.roomid_shortroomid
.insert(&room_id.as_bytes(), &short.to_be_bytes())?; .insert(room_id.as_bytes(), &short.to_be_bytes())?;
short short
} }
}) })
@ -819,7 +814,7 @@ impl Rooms {
let mut statekey = event_type.as_ref().as_bytes().to_vec(); let mut statekey = event_type.as_ref().as_bytes().to_vec();
statekey.push(0xff); statekey.push(0xff);
statekey.extend_from_slice(&state_key.as_bytes()); statekey.extend_from_slice(state_key.as_bytes());
let short = match self.statekey_shortstatekey.get(&statekey)? { let short = match self.statekey_shortstatekey.get(&statekey)? {
Some(shortstatekey) => utils::u64_from_bytes(&shortstatekey) Some(shortstatekey) => utils::u64_from_bytes(&shortstatekey)
@ -896,12 +891,12 @@ impl Rooms {
.ok_or_else(|| Error::bad_database("Invalid statekey in shortstatekey_statekey."))?; .ok_or_else(|| Error::bad_database("Invalid statekey in shortstatekey_statekey."))?;
let event_type = let event_type =
EventType::try_from(utils::string_from_bytes(&eventtype_bytes).map_err(|_| { EventType::try_from(utils::string_from_bytes(eventtype_bytes).map_err(|_| {
Error::bad_database("Event type in shortstatekey_statekey is invalid unicode.") Error::bad_database("Event type in shortstatekey_statekey is invalid unicode.")
})?) })?)
.map_err(|_| Error::bad_database("Event type in shortstatekey_statekey is invalid."))?; .map_err(|_| Error::bad_database("Event type in shortstatekey_statekey is invalid."))?;
let state_key = utils::string_from_bytes(&statekey_bytes).map_err(|_| { let state_key = utils::string_from_bytes(statekey_bytes).map_err(|_| {
Error::bad_database("Statekey in shortstatekey_statekey is invalid unicode.") Error::bad_database("Statekey in shortstatekey_statekey is invalid unicode.")
})?; })?;
@ -961,10 +956,8 @@ impl Rooms {
/// Returns the `count` of this pdu's id. /// Returns the `count` of this pdu's id.
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
pub fn pdu_count(&self, pdu_id: &[u8]) -> Result<u64> { pub fn pdu_count(&self, pdu_id: &[u8]) -> Result<u64> {
Ok(
utils::u64_from_bytes(&pdu_id[pdu_id.len() - size_of::<u64>()..]) utils::u64_from_bytes(&pdu_id[pdu_id.len() - size_of::<u64>()..])
.map_err(|_| Error::bad_database("PDU has invalid count bytes."))?, .map_err(|_| Error::bad_database("PDU has invalid count bytes."))
)
} }
/// Returns the `count` of this pdu's id. /// Returns the `count` of this pdu's id.
@ -1081,7 +1074,7 @@ impl Rooms {
/// Checks the `eventid_outlierpdu` Tree if not found in the timeline. /// Checks the `eventid_outlierpdu` Tree if not found in the timeline.
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
pub fn get_pdu(&self, event_id: &EventId) -> Result<Option<Arc<PduEvent>>> { pub fn get_pdu(&self, event_id: &EventId) -> Result<Option<Arc<PduEvent>>> {
if let Some(p) = self.pdu_cache.lock().unwrap().get_mut(&event_id) { if let Some(p) = self.pdu_cache.lock().unwrap().get_mut(event_id) {
return Ok(Some(Arc::clone(p))); return Ok(Some(Arc::clone(p)));
} }
@ -1143,9 +1136,9 @@ impl Rooms {
/// Removes a pdu and creates a new one with the same id. /// Removes a pdu and creates a new one with the same id.
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
fn replace_pdu(&self, pdu_id: &[u8], pdu: &PduEvent) -> Result<()> { fn replace_pdu(&self, pdu_id: &[u8], pdu: &PduEvent) -> Result<()> {
if self.pduid_pdu.get(&pdu_id)?.is_some() { if self.pduid_pdu.get(pdu_id)?.is_some() {
self.pduid_pdu.insert( self.pduid_pdu.insert(
&pdu_id, pdu_id,
&serde_json::to_vec(pdu).expect("PduEvent::to_vec always works"), &serde_json::to_vec(pdu).expect("PduEvent::to_vec always works"),
)?; )?;
Ok(()) Ok(())
@ -1230,20 +1223,20 @@ impl Rooms {
#[tracing::instrument(skip(self, pdu))] #[tracing::instrument(skip(self, pdu))]
pub fn add_pdu_outlier(&self, event_id: &EventId, pdu: &CanonicalJsonObject) -> Result<()> { pub fn add_pdu_outlier(&self, event_id: &EventId, pdu: &CanonicalJsonObject) -> Result<()> {
self.eventid_outlierpdu.insert( self.eventid_outlierpdu.insert(
&event_id.as_bytes(), event_id.as_bytes(),
&serde_json::to_vec(&pdu).expect("CanonicalJsonObject is valid"), &serde_json::to_vec(&pdu).expect("CanonicalJsonObject is valid"),
) )
} }
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
pub fn mark_event_soft_failed(&self, event_id: &EventId) -> Result<()> { pub fn mark_event_soft_failed(&self, event_id: &EventId) -> Result<()> {
self.softfailedeventids.insert(&event_id.as_bytes(), &[]) self.softfailedeventids.insert(event_id.as_bytes(), &[])
} }
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
pub fn is_event_soft_failed(&self, event_id: &EventId) -> Result<bool> { pub fn is_event_soft_failed(&self, event_id: &EventId) -> Result<bool> {
self.softfailedeventids self.softfailedeventids
.get(&event_id.as_bytes()) .get(event_id.as_bytes())
.map(|o| o.is_some()) .map(|o| o.is_some())
} }
@ -1273,7 +1266,7 @@ impl Rooms {
{ {
if let Some(shortstatehash) = self.pdu_shortstatehash(&pdu.event_id).unwrap() { if let Some(shortstatehash) = self.pdu_shortstatehash(&pdu.event_id).unwrap() {
if let Some(prev_state) = self if let Some(prev_state) = self
.state_get(shortstatehash, &pdu.kind, &state_key) .state_get(shortstatehash, &pdu.kind, state_key)
.unwrap() .unwrap()
{ {
unsigned.insert( unsigned.insert(
@ -1355,15 +1348,15 @@ impl Rooms {
let rules_for_user = db let rules_for_user = db
.account_data .account_data
.get::<push_rules::PushRulesEvent>(None, &user, EventType::PushRules)? .get::<push_rules::PushRulesEvent>(None, user, EventType::PushRules)?
.map(|ev| ev.content.global) .map(|ev| ev.content.global)
.unwrap_or_else(|| push::Ruleset::server_default(&user)); .unwrap_or_else(|| push::Ruleset::server_default(user));
let mut highlight = false; let mut highlight = false;
let mut notify = false; let mut notify = false;
for action in pusher::get_actions( for action in pusher::get_actions(
&user, user,
&rules_for_user, &rules_for_user,
&power_levels, &power_levels,
&sync_pdu, &sync_pdu,
@ -1393,7 +1386,7 @@ impl Rooms {
highlights.push(userroom_id); highlights.push(userroom_id);
} }
for senderkey in db.pusher.get_pusher_senderkeys(&user) { for senderkey in db.pusher.get_pusher_senderkeys(user) {
db.sending.send_push_pdu(&*pdu_id, senderkey)?; db.sending.send_push_pdu(&*pdu_id, senderkey)?;
} }
} }
@ -1406,7 +1399,7 @@ impl Rooms {
match pdu.kind { match pdu.kind {
EventType::RoomRedaction => { EventType::RoomRedaction => {
if let Some(redact_id) = &pdu.redacts { if let Some(redact_id) = &pdu.redacts {
self.redact_pdu(&redact_id, &pdu)?; self.redact_pdu(redact_id, pdu)?;
} }
} }
EventType::RoomMember => { EventType::RoomMember => {
@ -1746,9 +1739,9 @@ impl Rooms {
state_ids_compressed: HashSet<CompressedStateEvent>, state_ids_compressed: HashSet<CompressedStateEvent>,
globals: &super::globals::Globals, globals: &super::globals::Globals,
) -> Result<()> { ) -> Result<()> {
let shorteventid = self.get_or_create_shorteventid(&event_id, globals)?; let shorteventid = self.get_or_create_shorteventid(event_id, globals)?;
let previous_shortstatehash = self.current_shortstatehash(&room_id)?; let previous_shortstatehash = self.current_shortstatehash(room_id)?;
let state_hash = self.calculate_hash( let state_hash = self.calculate_hash(
&state_ids_compressed &state_ids_compressed
@ -1820,7 +1813,7 @@ impl Rooms {
.map_or_else(|| Ok(Vec::new()), |p| self.load_shortstatehash_info(p))?; .map_or_else(|| Ok(Vec::new()), |p| self.load_shortstatehash_info(p))?;
let shortstatekey = let shortstatekey =
self.get_or_create_shortstatekey(&new_pdu.kind, &state_key, globals)?; self.get_or_create_shortstatekey(&new_pdu.kind, state_key, globals)?;
let new = self.compress_state_event(shortstatekey, &new_pdu.event_id, globals)?; let new = self.compress_state_event(shortstatekey, &new_pdu.event_id, globals)?;
@ -1845,7 +1838,7 @@ impl Rooms {
let mut statediffremoved = HashSet::new(); let mut statediffremoved = HashSet::new();
if let Some(replaces) = replaces { if let Some(replaces) = replaces {
statediffremoved.insert(replaces.clone()); statediffremoved.insert(*replaces);
} }
self.save_state_from_diff( self.save_state_from_diff(
@ -1958,12 +1951,12 @@ impl Rooms {
} = pdu_builder; } = pdu_builder;
let prev_events = self let prev_events = self
.get_pdu_leaves(&room_id)? .get_pdu_leaves(room_id)?
.into_iter() .into_iter()
.take(20) .take(20)
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let create_event = self.room_state_get(&room_id, &EventType::RoomCreate, "")?; let create_event = self.room_state_get(room_id, &EventType::RoomCreate, "")?;
let create_event_content = create_event let create_event_content = create_event
.as_ref() .as_ref()
@ -1993,13 +1986,8 @@ impl Rooms {
}); });
let room_version = RoomVersion::new(&room_version_id).expect("room version is supported"); let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");
let auth_events = self.get_auth_events( let auth_events =
&room_id, self.get_auth_events(room_id, &event_type, sender, state_key.as_deref(), &content)?;
&event_type,
&sender,
state_key.as_deref(),
&content,
)?;
// Our depth is the maximum depth of prev_events + 1 // Our depth is the maximum depth of prev_events + 1
let depth = prev_events let depth = prev_events
@ -2011,7 +1999,7 @@ impl Rooms {
let mut unsigned = unsigned.unwrap_or_default(); let mut unsigned = unsigned.unwrap_or_default();
if let Some(state_key) = &state_key { if let Some(state_key) = &state_key {
if let Some(prev_pdu) = self.room_state_get(&room_id, &event_type, &state_key)? { if let Some(prev_pdu) = self.room_state_get(room_id, &event_type, state_key)? {
unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone()); unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
unsigned.insert( unsigned.insert(
"prev_sender".to_owned(), "prev_sender".to_owned(),
@ -2046,10 +2034,10 @@ impl Rooms {
let auth_check = state_res::auth_check( let auth_check = state_res::auth_check(
&room_version, &room_version,
&Arc::new(pdu.clone()), &pdu,
create_prev_event, create_prev_event,
None, // TODO: third_party_invite None::<PduEvent>, // TODO: third_party_invite
|k, s| auth_events.get(&(k.clone(), s.to_owned())).map(Arc::clone), |k, s| auth_events.get(&(k.clone(), s.to_owned())),
) )
.map_err(|e| { .map_err(|e| {
error!("{:?}", e); error!("{:?}", e);
@ -2114,7 +2102,7 @@ impl Rooms {
// We set the room state after inserting the pdu, so that we never have a moment in time // We set the room state after inserting the pdu, so that we never have a moment in time
// where events in the current room state do not exist // where events in the current room state do not exist
self.set_room_state(&room_id, statehashid)?; self.set_room_state(room_id, statehashid)?;
for server in self for server in self
.room_servers(room_id) .room_servers(room_id)
@ -2159,10 +2147,10 @@ impl Rooms {
&& pdu && pdu
.state_key .state_key
.as_ref() .as_ref()
.map_or(false, |state_key| users.is_match(&state_key)) .map_or(false, |state_key| users.is_match(state_key))
}; };
let matching_aliases = |aliases: &Regex| { let matching_aliases = |aliases: &Regex| {
self.room_aliases(&room_id) self.room_aliases(room_id)
.filter_map(|r| r.ok()) .filter_map(|r| r.ok())
.any(|room_alias| aliases.is_match(room_alias.as_str())) .any(|room_alias| aliases.is_match(room_alias.as_str()))
}; };
@ -2305,7 +2293,7 @@ impl Rooms {
let mut pdu = self let mut pdu = self
.get_pdu_from_id(&pdu_id)? .get_pdu_from_id(&pdu_id)?
.ok_or_else(|| Error::bad_database("PDU ID points to invalid PDU."))?; .ok_or_else(|| Error::bad_database("PDU ID points to invalid PDU."))?;
pdu.redact(&reason)?; pdu.redact(reason)?;
self.replace_pdu(&pdu_id, &pdu)?; self.replace_pdu(&pdu_id, &pdu)?;
Ok(()) Ok(())
} else { } else {
@ -2353,13 +2341,13 @@ impl Rooms {
match &membership { match &membership {
member::MembershipState::Join => { member::MembershipState::Join => {
// Check if the user never joined this room // Check if the user never joined this room
if !self.once_joined(&user_id, &room_id)? { if !self.once_joined(user_id, room_id)? {
// Add the user ID to the join list then // Add the user ID to the join list then
self.roomuseroncejoinedids.insert(&userroom_id, &[])?; self.roomuseroncejoinedids.insert(&userroom_id, &[])?;
// Check if the room has a predecessor // Check if the room has a predecessor
if let Some(predecessor) = self if let Some(predecessor) = self
.room_state_get(&room_id, &EventType::RoomCreate, "")? .room_state_get(room_id, &EventType::RoomCreate, "")?
.and_then(|create| { .and_then(|create| {
serde_json::from_value::< serde_json::from_value::<
Raw<ruma::events::room::create::CreateEventContent>, Raw<ruma::events::room::create::CreateEventContent>,
@ -2461,11 +2449,11 @@ impl Rooms {
.account_data .account_data
.get::<ignored_user_list::IgnoredUserListEvent>( .get::<ignored_user_list::IgnoredUserListEvent>(
None, // Ignored users are in global account data None, // Ignored users are in global account data
&user_id, // Receiver user_id, // Receiver
EventType::IgnoredUserList, EventType::IgnoredUserList,
)? )?
.map_or(false, |ignored| { .map_or(false, |ignored| {
ignored.content.ignored_users.contains(&sender) ignored.content.ignored_users.contains(sender)
}); });
if is_ignored { if is_ignored {
@ -2527,7 +2515,7 @@ impl Rooms {
let mut joined_servers = HashSet::new(); let mut joined_servers = HashSet::new();
let mut real_users = HashSet::new(); let mut real_users = HashSet::new();
for joined in self.room_members(&room_id).filter_map(|r| r.ok()) { for joined in self.room_members(room_id).filter_map(|r| r.ok()) {
joined_servers.insert(joined.server_name().to_owned()); joined_servers.insert(joined.server_name().to_owned());
if joined.server_name() == db.globals.server_name() if joined.server_name() == db.globals.server_name()
&& !db.users.is_deactivated(&joined).unwrap_or(true) && !db.users.is_deactivated(&joined).unwrap_or(true)
@ -2537,7 +2525,7 @@ impl Rooms {
joinedcount += 1; joinedcount += 1;
} }
for invited in self.room_members_invited(&room_id).filter_map(|r| r.ok()) { for invited in self.room_members_invited(room_id).filter_map(|r| r.ok()) {
joined_servers.insert(invited.server_name().to_owned()); joined_servers.insert(invited.server_name().to_owned());
invitedcount += 1; invitedcount += 1;
} }
@ -2606,7 +2594,7 @@ impl Rooms {
if let Some(users) = maybe { if let Some(users) = maybe {
Ok(users) Ok(users)
} else { } else {
self.update_joined_count(room_id, &db)?; self.update_joined_count(room_id, db)?;
Ok(Arc::clone( Ok(Arc::clone(
self.our_real_users_cache self.our_real_users_cache
.read() .read()
@ -2655,7 +2643,7 @@ impl Rooms {
let in_room = bridge_user_id let in_room = bridge_user_id
.map_or(false, |id| self.is_joined(&id, room_id).unwrap_or(false)) .map_or(false, |id| self.is_joined(&id, room_id).unwrap_or(false))
|| self.room_members(&room_id).any(|userid| { || self.room_members(room_id).any(|userid| {
userid.map_or(false, |userid| { userid.map_or(false, |userid| {
users.iter().any(|r| r.is_match(userid.as_str())) users.iter().any(|r| r.is_match(userid.as_str()))
}) })
@ -2895,21 +2883,21 @@ impl Rooms {
if let Some(room_id) = room_id { if let Some(room_id) = room_id {
// New alias // New alias
self.alias_roomid self.alias_roomid
.insert(&alias.alias().as_bytes(), room_id.as_bytes())?; .insert(alias.alias().as_bytes(), room_id.as_bytes())?;
let mut aliasid = room_id.as_bytes().to_vec(); let mut aliasid = room_id.as_bytes().to_vec();
aliasid.push(0xff); aliasid.push(0xff);
aliasid.extend_from_slice(&globals.next_count()?.to_be_bytes()); aliasid.extend_from_slice(&globals.next_count()?.to_be_bytes());
self.aliasid_alias.insert(&aliasid, &*alias.as_bytes())?; self.aliasid_alias.insert(&aliasid, &*alias.as_bytes())?;
} else { } else {
// room_id=None means remove alias // room_id=None means remove alias
if let Some(room_id) = self.alias_roomid.get(&alias.alias().as_bytes())? { if let Some(room_id) = self.alias_roomid.get(alias.alias().as_bytes())? {
let mut prefix = room_id.to_vec(); let mut prefix = room_id.to_vec();
prefix.push(0xff); prefix.push(0xff);
for (key, _) in self.aliasid_alias.scan_prefix(prefix) { for (key, _) in self.aliasid_alias.scan_prefix(prefix) {
self.aliasid_alias.remove(&key)?; self.aliasid_alias.remove(&key)?;
} }
self.alias_roomid.remove(&alias.alias().as_bytes())?; self.alias_roomid.remove(alias.alias().as_bytes())?;
} else { } else {
return Err(Error::BadRequest( return Err(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
@ -3082,7 +3070,7 @@ impl Rooms {
self.roomserverids.scan_prefix(prefix).map(|(key, _)| { self.roomserverids.scan_prefix(prefix).map(|(key, _)| {
Box::<ServerName>::try_from( Box::<ServerName>::try_from(
utils::string_from_bytes( utils::string_from_bytes(
&key.rsplit(|&b| b == 0xff) key.rsplit(|&b| b == 0xff)
.next() .next()
.expect("rsplit always returns an element"), .expect("rsplit always returns an element"),
) )
@ -3115,7 +3103,7 @@ impl Rooms {
self.serverroomids.scan_prefix(prefix).map(|(key, _)| { self.serverroomids.scan_prefix(prefix).map(|(key, _)| {
RoomId::try_from( RoomId::try_from(
utils::string_from_bytes( utils::string_from_bytes(
&key.rsplit(|&b| b == 0xff) key.rsplit(|&b| b == 0xff)
.next() .next()
.expect("rsplit always returns an element"), .expect("rsplit always returns an element"),
) )
@ -3137,7 +3125,7 @@ impl Rooms {
self.roomuserid_joined.scan_prefix(prefix).map(|(key, _)| { self.roomuserid_joined.scan_prefix(prefix).map(|(key, _)| {
UserId::try_from( UserId::try_from(
utils::string_from_bytes( utils::string_from_bytes(
&key.rsplit(|&b| b == 0xff) key.rsplit(|&b| b == 0xff)
.next() .next()
.expect("rsplit always returns an element"), .expect("rsplit always returns an element"),
) )
@ -3151,26 +3139,24 @@ impl Rooms {
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
pub fn room_joined_count(&self, room_id: &RoomId) -> Result<Option<u64>> { pub fn room_joined_count(&self, room_id: &RoomId) -> Result<Option<u64>> {
Ok(self self.roomid_joinedcount
.roomid_joinedcount
.get(room_id.as_bytes())? .get(room_id.as_bytes())?
.map(|b| { .map(|b| {
utils::u64_from_bytes(&b) utils::u64_from_bytes(&b)
.map_err(|_| Error::bad_database("Invalid joinedcount in db.")) .map_err(|_| Error::bad_database("Invalid joinedcount in db."))
}) })
.transpose()?) .transpose()
} }
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
pub fn room_invited_count(&self, room_id: &RoomId) -> Result<Option<u64>> { pub fn room_invited_count(&self, room_id: &RoomId) -> Result<Option<u64>> {
Ok(self self.roomid_invitedcount
.roomid_invitedcount
.get(room_id.as_bytes())? .get(room_id.as_bytes())?
.map(|b| { .map(|b| {
utils::u64_from_bytes(&b) utils::u64_from_bytes(&b)
.map_err(|_| Error::bad_database("Invalid joinedcount in db.")) .map_err(|_| Error::bad_database("Invalid joinedcount in db."))
}) })
.transpose()?) .transpose()
} }
/// Returns an iterator over all User IDs who ever joined a room. /// Returns an iterator over all User IDs who ever joined a room.
@ -3187,7 +3173,7 @@ impl Rooms {
.map(|(key, _)| { .map(|(key, _)| {
UserId::try_from( UserId::try_from(
utils::string_from_bytes( utils::string_from_bytes(
&key.rsplit(|&b| b == 0xff) key.rsplit(|&b| b == 0xff)
.next() .next()
.expect("rsplit always returns an element"), .expect("rsplit always returns an element"),
) )
@ -3213,7 +3199,7 @@ impl Rooms {
.map(|(key, _)| { .map(|(key, _)| {
UserId::try_from( UserId::try_from(
utils::string_from_bytes( utils::string_from_bytes(
&key.rsplit(|&b| b == 0xff) key.rsplit(|&b| b == 0xff)
.next() .next()
.expect("rsplit always returns an element"), .expect("rsplit always returns an element"),
) )
@ -3266,7 +3252,7 @@ impl Rooms {
.map(|(key, _)| { .map(|(key, _)| {
RoomId::try_from( RoomId::try_from(
utils::string_from_bytes( utils::string_from_bytes(
&key.rsplit(|&b| b == 0xff) key.rsplit(|&b| b == 0xff)
.next() .next()
.expect("rsplit always returns an element"), .expect("rsplit always returns an element"),
) )
@ -3292,7 +3278,7 @@ impl Rooms {
.map(|(key, state)| { .map(|(key, state)| {
let room_id = RoomId::try_from( let room_id = RoomId::try_from(
utils::string_from_bytes( utils::string_from_bytes(
&key.rsplit(|&b| b == 0xff) key.rsplit(|&b| b == 0xff)
.next() .next()
.expect("rsplit always returns an element"), .expect("rsplit always returns an element"),
) )
@ -3317,7 +3303,7 @@ impl Rooms {
) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> { ) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&room_id.as_bytes()); key.extend_from_slice(room_id.as_bytes());
self.userroomid_invitestate self.userroomid_invitestate
.get(&key)? .get(&key)?
@ -3338,7 +3324,7 @@ impl Rooms {
) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> { ) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> {
let mut key = user_id.as_bytes().to_vec(); let mut key = user_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&room_id.as_bytes()); key.extend_from_slice(room_id.as_bytes());
self.userroomid_leftstate self.userroomid_leftstate
.get(&key)? .get(&key)?
@ -3365,7 +3351,7 @@ impl Rooms {
.map(|(key, state)| { .map(|(key, state)| {
let room_id = RoomId::try_from( let room_id = RoomId::try_from(
utils::string_from_bytes( utils::string_from_bytes(
&key.rsplit(|&b| b == 0xff) key.rsplit(|&b| b == 0xff)
.next() .next()
.expect("rsplit always returns an element"), .expect("rsplit always returns an element"),
) )

26
src/database/rooms/edus.rs
View File

@ -60,7 +60,7 @@ impl RoomEdus {
let mut room_latest_id = prefix; let mut room_latest_id = prefix;
room_latest_id.extend_from_slice(&globals.next_count()?.to_be_bytes()); room_latest_id.extend_from_slice(&globals.next_count()?.to_be_bytes());
room_latest_id.push(0xff); room_latest_id.push(0xff);
room_latest_id.extend_from_slice(&user_id.as_bytes()); room_latest_id.extend_from_slice(user_id.as_bytes());
self.readreceiptid_readreceipt.insert( self.readreceiptid_readreceipt.insert(
&room_latest_id, &room_latest_id,
@ -126,7 +126,7 @@ impl RoomEdus {
) -> Result<()> { ) -> Result<()> {
let mut key = room_id.as_bytes().to_vec(); let mut key = room_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&user_id.as_bytes()); key.extend_from_slice(user_id.as_bytes());
self.roomuserid_privateread self.roomuserid_privateread
.insert(&key, &count.to_be_bytes())?; .insert(&key, &count.to_be_bytes())?;
@ -142,7 +142,7 @@ impl RoomEdus {
pub fn private_read_get(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> { pub fn private_read_get(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
let mut key = room_id.as_bytes().to_vec(); let mut key = room_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&user_id.as_bytes()); key.extend_from_slice(user_id.as_bytes());
self.roomuserid_privateread self.roomuserid_privateread
.get(&key)? .get(&key)?
@ -157,7 +157,7 @@ impl RoomEdus {
pub fn last_privateread_update(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> { pub fn last_privateread_update(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
let mut key = room_id.as_bytes().to_vec(); let mut key = room_id.as_bytes().to_vec();
key.push(0xff); key.push(0xff);
key.extend_from_slice(&user_id.as_bytes()); key.extend_from_slice(user_id.as_bytes());
Ok(self Ok(self
.roomuserid_lastprivatereadupdate .roomuserid_lastprivatereadupdate
@ -193,7 +193,7 @@ impl RoomEdus {
.insert(&room_typing_id, &*user_id.as_bytes())?; .insert(&room_typing_id, &*user_id.as_bytes())?;
self.roomid_lasttypingupdate self.roomid_lasttypingupdate
.insert(&room_id.as_bytes(), &count)?; .insert(room_id.as_bytes(), &count)?;
Ok(()) Ok(())
} }
@ -224,7 +224,7 @@ impl RoomEdus {
if found_outdated { if found_outdated {
self.roomid_lasttypingupdate self.roomid_lasttypingupdate
.insert(&room_id.as_bytes(), &globals.next_count()?.to_be_bytes())?; .insert(room_id.as_bytes(), &globals.next_count()?.to_be_bytes())?;
} }
Ok(()) Ok(())
@ -268,7 +268,7 @@ impl RoomEdus {
if found_outdated { if found_outdated {
self.roomid_lasttypingupdate self.roomid_lasttypingupdate
.insert(&room_id.as_bytes(), &globals.next_count()?.to_be_bytes())?; .insert(room_id.as_bytes(), &globals.next_count()?.to_be_bytes())?;
} }
Ok(()) Ok(())
@ -285,7 +285,7 @@ impl RoomEdus {
Ok(self Ok(self
.roomid_lasttypingupdate .roomid_lasttypingupdate
.get(&room_id.as_bytes())? .get(room_id.as_bytes())?
.map_or(Ok::<_, Error>(None), |bytes| { .map_or(Ok::<_, Error>(None), |bytes| {
Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| { Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| {
Error::bad_database("Count in roomid_lastroomactiveupdate is invalid.") Error::bad_database("Count in roomid_lastroomactiveupdate is invalid.")
@ -342,7 +342,7 @@ impl RoomEdus {
presence_id.push(0xff); presence_id.push(0xff);
presence_id.extend_from_slice(&count); presence_id.extend_from_slice(&count);
presence_id.push(0xff); presence_id.push(0xff);
presence_id.extend_from_slice(&presence.sender.as_bytes()); presence_id.extend_from_slice(presence.sender.as_bytes());
self.presenceid_presence.insert( self.presenceid_presence.insert(
&presence_id, &presence_id,
@ -361,7 +361,7 @@ impl RoomEdus {
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self))]
pub fn ping_presence(&self, user_id: &UserId) -> Result<()> { pub fn ping_presence(&self, user_id: &UserId) -> Result<()> {
self.userid_lastpresenceupdate.insert( self.userid_lastpresenceupdate.insert(
&user_id.as_bytes(), user_id.as_bytes(),
&utils::millis_since_unix_epoch().to_be_bytes(), &utils::millis_since_unix_epoch().to_be_bytes(),
)?; )?;
@ -371,7 +371,7 @@ impl RoomEdus {
/// Returns the timestamp of the last presence update of this user in millis since the unix epoch. /// Returns the timestamp of the last presence update of this user in millis since the unix epoch.
pub fn last_presence_update(&self, user_id: &UserId) -> Result<Option<u64>> { pub fn last_presence_update(&self, user_id: &UserId) -> Result<Option<u64>> {
self.userid_lastpresenceupdate self.userid_lastpresenceupdate
.get(&user_id.as_bytes())? .get(user_id.as_bytes())?
.map(|bytes| { .map(|bytes| {
utils::u64_from_bytes(&bytes).map_err(|_| { utils::u64_from_bytes(&bytes).map_err(|_| {
Error::bad_database("Invalid timestamp in userid_lastpresenceupdate.") Error::bad_database("Invalid timestamp in userid_lastpresenceupdate.")
@ -394,7 +394,7 @@ impl RoomEdus {
presence_id.push(0xff); presence_id.push(0xff);
presence_id.extend_from_slice(&last_update.to_be_bytes()); presence_id.extend_from_slice(&last_update.to_be_bytes());
presence_id.push(0xff); presence_id.push(0xff);
presence_id.extend_from_slice(&user_id.as_bytes()); presence_id.extend_from_slice(user_id.as_bytes());
self.presenceid_presence self.presenceid_presence
.get(&presence_id)? .get(&presence_id)?
@ -480,7 +480,7 @@ impl RoomEdus {
} }
self.userid_lastpresenceupdate.insert( self.userid_lastpresenceupdate.insert(
&user_id.as_bytes(), user_id.as_bytes(),
&utils::millis_since_unix_epoch().to_be_bytes(), &utils::millis_since_unix_epoch().to_be_bytes(),
)?; )?;
} }

20
src/database/sending.rs
View File

@ -58,9 +58,9 @@ impl OutgoingKind {
} }
OutgoingKind::Push(user, pushkey) => { OutgoingKind::Push(user, pushkey) => {
let mut p = b"$".to_vec(); let mut p = b"$".to_vec();
p.extend_from_slice(&user); p.extend_from_slice(user);
p.push(0xff); p.push(0xff);
p.extend_from_slice(&pushkey); p.extend_from_slice(pushkey);
p p
} }
OutgoingKind::Normal(server) => { OutgoingKind::Normal(server) => {
@ -179,8 +179,8 @@ impl Sending {
// Insert pdus we found // Insert pdus we found
for (e, key) in &new_events { for (e, key) in &new_events {
let value = if let SendingEventType::Edu(value) = &e.1 { &**value } else { &[] }; let value = if let SendingEventType::Edu(value) = &e.1 { &**value } else { &[] };
guard.sending.servercurrentevent_data.insert(&key, value).unwrap(); guard.sending.servercurrentevent_data.insert(key, value).unwrap();
guard.sending.servernameevent_data.remove(&key).unwrap(); guard.sending.servernameevent_data.remove(key).unwrap();
} }
drop(guard); drop(guard);
@ -345,7 +345,7 @@ impl Sending {
} }
let event = let event =
serde_json::from_str::<AnySyncEphemeralRoomEvent>(&read_receipt.json().get()) serde_json::from_str::<AnySyncEphemeralRoomEvent>(read_receipt.json().get())
.map_err(|_| Error::bad_database("Invalid edu event in read_receipts."))?; .map_err(|_| Error::bad_database("Invalid edu event in read_receipts."))?;
let federation_event = match event { let federation_event = match event {
AnySyncEphemeralRoomEvent::Receipt(r) => { AnySyncEphemeralRoomEvent::Receipt(r) => {
@ -486,7 +486,7 @@ impl Sending {
match event { match event {
SendingEventType::Pdu(pdu_id) => { SendingEventType::Pdu(pdu_id) => {
pdu_jsons.push(db.rooms pdu_jsons.push(db.rooms
.get_pdu_from_id(&pdu_id) .get_pdu_from_id(pdu_id)
.map_err(|e| (kind.clone(), e))? .map_err(|e| (kind.clone(), e))?
.ok_or_else(|| { .ok_or_else(|| {
( (
@ -543,7 +543,7 @@ impl Sending {
SendingEventType::Pdu(pdu_id) => { SendingEventType::Pdu(pdu_id) => {
pdus.push( pdus.push(
db.rooms db.rooms
.get_pdu_from_id(&pdu_id) .get_pdu_from_id(pdu_id)
.map_err(|e| (kind.clone(), e))? .map_err(|e| (kind.clone(), e))?
.ok_or_else(|| { .ok_or_else(|| {
( (
@ -636,7 +636,7 @@ impl Sending {
// TODO: check room version and remove event_id if needed // TODO: check room version and remove event_id if needed
let raw = PduEvent::convert_to_outgoing_federation_event( let raw = PduEvent::convert_to_outgoing_federation_event(
db.rooms db.rooms
.get_pdu_json_from_id(&pdu_id) .get_pdu_json_from_id(pdu_id)
.map_err(|e| (OutgoingKind::Normal(server.clone()), e))? .map_err(|e| (OutgoingKind::Normal(server.clone()), e))?
.ok_or_else(|| { .ok_or_else(|| {
( (
@ -711,7 +711,7 @@ impl Sending {
let event = parts let event = parts
.next() .next()
.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; .ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
let server = utils::string_from_bytes(&server).map_err(|_| { let server = utils::string_from_bytes(server).map_err(|_| {
Error::bad_database("Invalid server bytes in server_currenttransaction") Error::bad_database("Invalid server bytes in server_currenttransaction")
})?; })?;
@ -750,7 +750,7 @@ impl Sending {
let event = parts let event = parts
.next() .next()
.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; .ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
let server = utils::string_from_bytes(&server).map_err(|_| { let server = utils::string_from_bytes(server).map_err(|_| {
Error::bad_database("Invalid server bytes in server_currenttransaction") Error::bad_database("Invalid server bytes in server_currenttransaction")
})?; })?;

2
src/database/uiaa.rs
View File

@ -54,7 +54,7 @@ impl Uiaa {
) -> Result<(bool, UiaaInfo)> { ) -> Result<(bool, UiaaInfo)> {
let mut uiaainfo = auth let mut uiaainfo = auth
.session() .session()
.map(|session| self.get_uiaa_session(&user_id, &device_id, session)) .map(|session| self.get_uiaa_session(user_id, device_id, session))
.unwrap_or_else(|| Ok(uiaainfo.clone()))?; .unwrap_or_else(|| Ok(uiaainfo.clone()))?;
if uiaainfo.session.is_none() { if uiaainfo.session.is_none() {

22
src/database/users.rs
View File

@ -81,13 +81,13 @@ impl Users {
})?; })?;
Ok(Some(( Ok(Some((
UserId::try_from(utils::string_from_bytes(&user_bytes).map_err(|_| { UserId::try_from(utils::string_from_bytes(user_bytes).map_err(|_| {
Error::bad_database("User ID in token_userdeviceid is invalid unicode.") Error::bad_database("User ID in token_userdeviceid is invalid unicode.")
})?) })?)
.map_err(|_| { .map_err(|_| {
Error::bad_database("User ID in token_userdeviceid is invalid.") Error::bad_database("User ID in token_userdeviceid is invalid.")
})?, })?,
utils::string_from_bytes(&device_bytes).map_err(|_| { utils::string_from_bytes(device_bytes).map_err(|_| {
Error::bad_database("Device ID in token_userdeviceid is invalid.") Error::bad_database("Device ID in token_userdeviceid is invalid.")
})?, })?,
))) )))
@ -121,7 +121,7 @@ impl Users {
#[tracing::instrument(skip(self, user_id, password))] #[tracing::instrument(skip(self, user_id, password))]
pub fn set_password(&self, user_id: &UserId, password: Option<&str>) -> Result<()> { pub fn set_password(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
if let Some(password) = password { if let Some(password) = password {
if let Ok(hash) = utils::calculate_hash(&password) { if let Ok(hash) = utils::calculate_hash(password) {
self.userid_password self.userid_password
.insert(user_id.as_bytes(), hash.as_bytes())?; .insert(user_id.as_bytes(), hash.as_bytes())?;
Ok(()) Ok(())
@ -245,7 +245,7 @@ impl Users {
.expect("Device::to_string never fails."), .expect("Device::to_string never fails."),
)?; )?;
self.set_token(user_id, &device_id, token)?; self.set_token(user_id, device_id, token)?;
Ok(()) Ok(())
} }
@ -294,7 +294,7 @@ impl Users {
.scan_prefix(prefix) .scan_prefix(prefix)
.map(|(bytes, _)| { .map(|(bytes, _)| {
Ok(utils::string_from_bytes( Ok(utils::string_from_bytes(
&bytes bytes
.rsplit(|&b| b == 0xff) .rsplit(|&b| b == 0xff)
.next() .next()
.ok_or_else(|| Error::bad_database("UserDevice ID in db is invalid."))?, .ok_or_else(|| Error::bad_database("UserDevice ID in db is invalid."))?,
@ -357,7 +357,7 @@ impl Users {
// TODO: Use DeviceKeyId::to_string when it's available (and update everything, // TODO: Use DeviceKeyId::to_string when it's available (and update everything,
// because there are no wrapping quotation marks anymore) // because there are no wrapping quotation marks anymore)
key.extend_from_slice( key.extend_from_slice(
&serde_json::to_string(one_time_key_key) serde_json::to_string(one_time_key_key)
.expect("DeviceKeyId::to_string always works") .expect("DeviceKeyId::to_string always works")
.as_bytes(), .as_bytes(),
); );
@ -368,7 +368,7 @@ impl Users {
)?; )?;
self.userid_lastonetimekeyupdate self.userid_lastonetimekeyupdate
.insert(&user_id.as_bytes(), &globals.next_count()?.to_be_bytes())?; .insert(user_id.as_bytes(), &globals.next_count()?.to_be_bytes())?;
Ok(()) Ok(())
} }
@ -376,7 +376,7 @@ impl Users {
#[tracing::instrument(skip(self, user_id))] #[tracing::instrument(skip(self, user_id))]
pub fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> { pub fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> {
self.userid_lastonetimekeyupdate self.userid_lastonetimekeyupdate
.get(&user_id.as_bytes())? .get(user_id.as_bytes())?
.map(|bytes| { .map(|bytes| {
utils::u64_from_bytes(&bytes).map_err(|_| { utils::u64_from_bytes(&bytes).map_err(|_| {
Error::bad_database("Count in roomid_lastroomactiveupdate is invalid.") Error::bad_database("Count in roomid_lastroomactiveupdate is invalid.")
@ -402,7 +402,7 @@ impl Users {
prefix.push(b':'); prefix.push(b':');
self.userid_lastonetimekeyupdate self.userid_lastonetimekeyupdate
.insert(&user_id.as_bytes(), &globals.next_count()?.to_be_bytes())?; .insert(user_id.as_bytes(), &globals.next_count()?.to_be_bytes())?;
self.onetimekeyid_onetimekeys self.onetimekeyid_onetimekeys
.scan_prefix(prefix) .scan_prefix(prefix)
@ -680,7 +680,7 @@ impl Users {
globals: &super::globals::Globals, globals: &super::globals::Globals,
) -> Result<()> { ) -> Result<()> {
let count = globals.next_count()?.to_be_bytes(); let count = globals.next_count()?.to_be_bytes();
for room_id in rooms.rooms_joined(&user_id).filter_map(|r| r.ok()) { for room_id in rooms.rooms_joined(user_id).filter_map(|r| r.ok()) {
// Don't send key updates to unencrypted rooms // Don't send key updates to unencrypted rooms
if rooms if rooms
.room_state_get(&room_id, &EventType::RoomEncryption, "")? .room_state_get(&room_id, &EventType::RoomEncryption, "")?
@ -961,7 +961,7 @@ impl Users {
pub fn deactivate_account(&self, user_id: &UserId) -> Result<()> { pub fn deactivate_account(&self, user_id: &UserId) -> Result<()> {
// Remove all associated devices // Remove all associated devices
for device_id in self.all_device_ids(user_id) { for device_id in self.all_device_ids(user_id) {
self.remove_device(&user_id, &device_id?)?; self.remove_device(user_id, &device_id?)?;
} }
// Set the password to "" to indicate a deactivated account. Hashes will never result in an // Set the password to "" to indicate a deactivated account. Hashes will never result in an

30
src/pdu.rs
View File

@ -260,37 +260,47 @@ impl state_res::Event for PduEvent {
fn sender(&self) -> &UserId { fn sender(&self) -> &UserId {
&self.sender &self.sender
} }
fn kind(&self) -> EventType {
self.kind.clone() fn event_type(&self) -> &EventType {
&self.kind
} }
fn content(&self) -> serde_json::Value { fn content(&self) -> &serde_json::Value {
self.content.clone() &self.content
} }
fn origin_server_ts(&self) -> MilliSecondsSinceUnixEpoch { fn origin_server_ts(&self) -> MilliSecondsSinceUnixEpoch {
MilliSecondsSinceUnixEpoch(self.origin_server_ts) MilliSecondsSinceUnixEpoch(self.origin_server_ts)
} }
fn state_key(&self) -> Option<String> {
self.state_key.clone() fn state_key(&self) -> Option<&str> {
self.state_key.as_deref()
} }
fn prev_events(&self) -> Vec<EventId> {
self.prev_events.to_vec() fn prev_events(&self) -> Box<dyn DoubleEndedIterator<Item = &EventId> + '_> {
Box::new(self.prev_events.iter())
} }
fn depth(&self) -> &UInt { fn depth(&self) -> &UInt {
&self.depth &self.depth
} }
fn auth_events(&self) -> Vec<EventId> {
self.auth_events.to_vec() fn auth_events(&self) -> Box<dyn DoubleEndedIterator<Item = &EventId> + '_> {
Box::new(self.auth_events.iter())
} }
fn redacts(&self) -> Option<&EventId> { fn redacts(&self) -> Option<&EventId> {
self.redacts.as_ref() self.redacts.as_ref()
} }
fn hashes(&self) -> &EventHash { fn hashes(&self) -> &EventHash {
&self.hashes &self.hashes
} }
fn signatures(&self) -> BTreeMap<Box<ServerName>, BTreeMap<ruma::ServerSigningKeyId, String>> { fn signatures(&self) -> BTreeMap<Box<ServerName>, BTreeMap<ruma::ServerSigningKeyId, String>> {
self.signatures.clone() self.signatures.clone()
} }
fn unsigned(&self) -> &BTreeMap<String, serde_json::Value> { fn unsigned(&self) -> &BTreeMap<String, serde_json::Value> {
&self.unsigned &self.unsigned
} }

4
src/ruma_wrapper.rs
View File

@ -66,7 +66,7 @@ where
let limit = db.globals.max_request_size(); let limit = db.globals.max_request_size();
let mut handle = data.open(ByteUnit::Byte(limit.into())); let mut handle = data.open(ByteUnit::Byte(limit.into()));
let mut body = Vec::new(); let mut body = Vec::new();
if let Err(_) = handle.read_to_end(&mut body).await { if handle.read_to_end(&mut body).await.is_err() {
// Client disconnected // Client disconnected
// Missing Token // Missing Token
return Failure((Status::new(582), ())); return Failure((Status::new(582), ()));
@ -123,7 +123,7 @@ where
match metadata.authentication { match metadata.authentication {
AuthScheme::AccessToken | AuthScheme::QueryOnlyAccessToken => { AuthScheme::AccessToken | AuthScheme::QueryOnlyAccessToken => {
if let Some(token) = token { if let Some(token) = token {
match db.users.find_from_token(&token).unwrap() { match db.users.find_from_token(token).unwrap() {
// Unknown Token // Unknown Token
None => return Failure((Status::new(581), ())), None => return Failure((Status::new(581), ())),
Some((user_id, device_id)) => ( Some((user_id, device_id)) => (

186
src/server_server.rs
View File

@ -150,7 +150,7 @@ where
} else { } else {
write_destination_to_cache = true; write_destination_to_cache = true;
let result = find_actual_destination(globals, &destination).await; let result = find_actual_destination(globals, destination).await;
(result.0, result.1.into_uri_string()) (result.0, result.1.into_uri_string())
}; };
@ -359,7 +359,7 @@ async fn find_actual_destination(
let (host, port) = destination_str.split_at(pos); let (host, port) = destination_str.split_at(pos);
FedDest::Named(host.to_string(), port.to_string()) FedDest::Named(host.to_string(), port.to_string())
} else { } else {
match request_well_known(globals, &destination.as_str()).await { match request_well_known(globals, destination.as_str()).await {
// 3: A .well-known file is available // 3: A .well-known file is available
Some(delegated_hostname) => { Some(delegated_hostname) => {
hostname = add_port_to_hostname(&delegated_hostname).into_uri_string(); hostname = add_port_to_hostname(&delegated_hostname).into_uri_string();
@ -806,7 +806,7 @@ pub async fn send_transaction_message_route(
.event_ids .event_ids
.iter() .iter()
.filter_map(|id| { .filter_map(|id| {
db.rooms.get_pdu_count(&id).ok().flatten().map(|r| (id, r)) db.rooms.get_pdu_count(id).ok().flatten().map(|r| (id, r))
}) })
.max_by_key(|(_, count)| *count) .max_by_key(|(_, count)| *count)
{ {
@ -875,8 +875,8 @@ pub async fn send_transaction_message_route(
DeviceIdOrAllDevices::DeviceId(target_device_id) => { DeviceIdOrAllDevices::DeviceId(target_device_id) => {
db.users.add_to_device_event( db.users.add_to_device_event(
&sender, &sender,
&target_user_id, target_user_id,
&target_device_id, target_device_id,
&ev_type.to_string(), &ev_type.to_string(),
event.deserialize_as().map_err(|_| { event.deserialize_as().map_err(|_| {
Error::BadRequest( Error::BadRequest(
@ -889,10 +889,10 @@ pub async fn send_transaction_message_route(
} }
DeviceIdOrAllDevices::AllDevices => { DeviceIdOrAllDevices::AllDevices => {
for target_device_id in db.users.all_device_ids(&target_user_id) { for target_device_id in db.users.all_device_ids(target_user_id) {
db.users.add_to_device_event( db.users.add_to_device_event(
&sender, &sender,
&target_user_id, target_user_id,
&target_device_id?, &target_device_id?,
&ev_type.to_string(), &ev_type.to_string(),
event.deserialize_as().map_err(|_| { event.deserialize_as().map_err(|_| {
@ -959,7 +959,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
db: &'a Database, db: &'a Database,
pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, String>>>, pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, String>>>,
) -> StdResult<Option<Vec<u8>>, String> { ) -> StdResult<Option<Vec<u8>>, String> {
match db.rooms.exists(&room_id) { match db.rooms.exists(room_id) {
Ok(true) => {} Ok(true) => {}
_ => { _ => {
return Err("Room is unknown to this server.".to_string()); return Err("Room is unknown to this server.".to_string());
@ -967,19 +967,19 @@ pub(crate) async fn handle_incoming_pdu<'a>(
} }
// 1. Skip the PDU if we already have it as a timeline event // 1. Skip the PDU if we already have it as a timeline event
if let Ok(Some(pdu_id)) = db.rooms.get_pdu_id(&event_id) { if let Ok(Some(pdu_id)) = db.rooms.get_pdu_id(event_id) {
return Ok(Some(pdu_id.to_vec())); return Ok(Some(pdu_id.to_vec()));
} }
let create_event = db let create_event = db
.rooms .rooms
.room_state_get(&room_id, &EventType::RoomCreate, "") .room_state_get(room_id, &EventType::RoomCreate, "")
.map_err(|_| "Failed to ask database for event.".to_owned())? .map_err(|_| "Failed to ask database for event.".to_owned())?
.ok_or_else(|| "Failed to find create event in db.".to_owned())?; .ok_or_else(|| "Failed to find create event in db.".to_owned())?;
let first_pdu_in_room = db let first_pdu_in_room = db
.rooms .rooms
.first_pdu_in_room(&room_id) .first_pdu_in_room(room_id)
.map_err(|_| "Error loading first room event.".to_owned())? .map_err(|_| "Error loading first room event.".to_owned())?
.expect("Room exists"); .expect("Room exists");
@ -1021,7 +1021,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
origin, origin,
&[prev_event_id.clone()], &[prev_event_id.clone()],
&create_event, &create_event,
&room_id, room_id,
pub_key_map, pub_key_map,
) )
.await .await
@ -1049,12 +1049,12 @@ pub(crate) async fn handle_incoming_pdu<'a>(
(*prev_event_id).clone(), (*prev_event_id).clone(),
pdu.prev_events.iter().cloned().collect(), pdu.prev_events.iter().cloned().collect(),
); );
eventid_info.insert(prev_event_id.clone(), (pdu, json));
} else { } else {
// Time based check failed // Time based check failed
graph.insert((*prev_event_id).clone(), HashSet::new()); graph.insert((*prev_event_id).clone(), HashSet::new());
eventid_info.insert(prev_event_id.clone(), (pdu, json));
} }
eventid_info.insert(prev_event_id.clone(), (pdu, json));
} else { } else {
// Get json failed // Get json failed
graph.insert((*prev_event_id).clone(), HashSet::new()); graph.insert((*prev_event_id).clone(), HashSet::new());
@ -1065,8 +1065,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
} }
} }
let sorted = let sorted = state_res::lexicographical_topological_sort(dbg!(&graph), |event_id| {
state_res::StateResolution::lexicographical_topological_sort(dbg!(&graph), |event_id| {
// This return value is the key used for sorting events, // This return value is the key used for sorting events,
// events are then sorted by power level, time, // events are then sorted by power level, time,
// and lexically by event_id. // and lexically by event_id.
@ -1147,7 +1146,7 @@ fn handle_outlier_pdu<'a>(
// We go through all the signatures we see on the value and fetch the corresponding signing // We go through all the signatures we see on the value and fetch the corresponding signing
// keys // keys
fetch_required_signing_keys(&value, &pub_key_map, db) fetch_required_signing_keys(&value, pub_key_map, db)
.await .await
.map_err(|e| e.to_string())?; .map_err(|e| e.to_string())?;
@ -1211,8 +1210,8 @@ fn handle_outlier_pdu<'a>(
.cloned() .cloned()
.map(Arc::new) .map(Arc::new)
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
&create_event, create_event,
&room_id, room_id,
pub_key_map, pub_key_map,
) )
.await; .await;
@ -1257,7 +1256,7 @@ fn handle_outlier_pdu<'a>(
if auth_events if auth_events
.get(&(EventType::RoomCreate, "".to_owned())) .get(&(EventType::RoomCreate, "".to_owned()))
.map(|a| a.as_ref()) .map(|a| a.as_ref())
!= Some(&create_event) != Some(create_event)
{ {
return Err("Incoming event refers to wrong create event.".to_owned()); return Err("Incoming event refers to wrong create event.".to_owned());
} }
@ -1274,14 +1273,12 @@ fn handle_outlier_pdu<'a>(
None None
}; };
let incoming_pdu = Arc::new(incoming_pdu.clone());
if !state_res::event_auth::auth_check( if !state_res::event_auth::auth_check(
&room_version, &room_version,
&incoming_pdu, &incoming_pdu,
previous_create, previous_create,
None, // TODO: third party invite None::<PduEvent>, // TODO: third party invite
|k, s| auth_events.get(&(k.clone(), s.to_owned())).map(Arc::clone), |k, s| auth_events.get(&(k.clone(), s.to_owned())),
) )
.map_err(|_e| "Auth check failed".to_string())? .map_err(|_e| "Auth check failed".to_string())?
{ {
@ -1296,7 +1293,7 @@ fn handle_outlier_pdu<'a>(
.map_err(|_| "Failed to add pdu as outlier.".to_owned())?; .map_err(|_| "Failed to add pdu as outlier.".to_owned())?;
debug!("Added pdu as outlier."); debug!("Added pdu as outlier.");
Ok((incoming_pdu, val)) Ok((Arc::new(incoming_pdu), val))
}) })
} }
@ -1396,10 +1393,11 @@ async fn upgrade_outlier_to_timeline_pdu(
} }
if okay { if okay {
let fork_states: Vec<_> = extremity_sstatehashes let mut fork_states = Vec::with_capacity(extremity_sstatehashes.len());
.into_iter() let mut auth_chain_sets = Vec::with_capacity(extremity_sstatehashes.len());
.map(|(sstatehash, prev_event)| {
let mut leaf_state = db for (sstatehash, prev_event) in extremity_sstatehashes {
let mut leaf_state: BTreeMap<_, _> = db
.rooms .rooms
.state_full_ids(sstatehash) .state_full_ids(sstatehash)
.map_err(|_| "Failed to ask db for room state.".to_owned())?; .map_err(|_| "Failed to ask db for room state.".to_owned())?;
@ -1413,35 +1411,30 @@ async fn upgrade_outlier_to_timeline_pdu(
// Now it's the state after the pdu // Now it's the state after the pdu
} }
leaf_state let mut state = StateMap::with_capacity(leaf_state.len());
.into_iter() let mut starting_events = Vec::with_capacity(leaf_state.len());
.map(|(k, id)| (db.rooms.get_statekey_from_short(k).map(|k| (k, id))))
.collect::<Result<StateMap<_>>>() for (k, id) in leaf_state {
.map_err(|_| "Failed to get_statekey_from_short.".to_owned()) let k = db
}) .rooms
.collect::<StdResult<_, _>>()?; .get_statekey_from_short(k)
.map_err(|_| "Failed to get_statekey_from_short.".to_owned())?;
state.insert(k, (*id).clone());
starting_events.push(id);
}
let mut auth_chain_sets = Vec::new();
for state in &fork_states {
auth_chain_sets.push( auth_chain_sets.push(
get_auth_chain( get_auth_chain(room_id, starting_events, db)
&room_id,
state.iter().map(|(_, id)| id.clone()).collect(),
db,
)
.map_err(|_| "Failed to load auth chain.".to_owned())? .map_err(|_| "Failed to load auth chain.".to_owned())?
.map(|event_id| (*event_id).clone()) .map(|event_id| (*event_id).clone())
.collect(), .collect(),
); );
fork_states.push(state);
} }
let fork_states = &fork_states state_at_incoming_event = match state_res::resolve(
.into_iter()
.map(|map| map.into_iter().map(|(k, id)| (k, (*id).clone())).collect())
.collect::<Vec<_>>();
state_at_incoming_event = match state_res::StateResolution::resolve(
&room_id,
room_version_id, room_version_id,
&fork_states, &fork_states,
auth_chain_sets, auth_chain_sets,
@ -1483,7 +1476,7 @@ async fn upgrade_outlier_to_timeline_pdu(
&db.globals, &db.globals,
origin, origin,
get_room_state_ids::v1::Request { get_room_state_ids::v1::Request {
room_id: &room_id, room_id,
event_id: &incoming_pdu.event_id, event_id: &incoming_pdu.event_id,
}, },
) )
@ -1492,15 +1485,15 @@ async fn upgrade_outlier_to_timeline_pdu(
Ok(res) => { Ok(res) => {
warn!("Fetching state events at event."); warn!("Fetching state events at event.");
let state_vec = fetch_and_handle_outliers( let state_vec = fetch_and_handle_outliers(
&db, db,
origin, origin,
&res.pdu_ids &res.pdu_ids
.iter() .iter()
.cloned() .cloned()
.map(Arc::new) .map(Arc::new)
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
&create_event, create_event,
&room_id, room_id,
pub_key_map, pub_key_map,
) )
.await; .await;
@ -1569,15 +1562,15 @@ async fn upgrade_outlier_to_timeline_pdu(
let check_result = state_res::event_auth::auth_check( let check_result = state_res::event_auth::auth_check(
&room_version, &room_version,
&incoming_pdu, &incoming_pdu,
previous_create.clone(), previous_create.as_deref(),
None, // TODO: third party invite None::<PduEvent>, // TODO: third party invite
|k, s| { |k, s| {
db.rooms db.rooms
.get_shortstatekey(&k, &s) .get_shortstatekey(k, s)
.ok() .ok()
.flatten() .flatten()
.and_then(|shortstatekey| state_at_incoming_event.get(&shortstatekey)) .and_then(|shortstatekey| state_at_incoming_event.get(&shortstatekey))
.and_then(|event_id| db.rooms.get_pdu(&event_id).ok().flatten()) .and_then(|event_id| db.rooms.get_pdu(event_id).ok().flatten())
}, },
) )
.map_err(|_e| "Auth check failed.".to_owned())?; .map_err(|_e| "Auth check failed.".to_owned())?;
@ -1603,7 +1596,7 @@ async fn upgrade_outlier_to_timeline_pdu(
// applied. We start with the previous extremities (aka leaves) // applied. We start with the previous extremities (aka leaves)
let mut extremities = db let mut extremities = db
.rooms .rooms
.get_pdu_leaves(&room_id) .get_pdu_leaves(room_id)
.map_err(|_| "Failed to load room leaves".to_owned())?; .map_err(|_| "Failed to load room leaves".to_owned())?;
// Remove any forward extremities that are referenced by this incoming event's prev_events // Remove any forward extremities that are referenced by this incoming event's prev_events
@ -1614,11 +1607,11 @@ async fn upgrade_outlier_to_timeline_pdu(
} }
// Only keep those extremities were not referenced yet // Only keep those extremities were not referenced yet
extremities.retain(|id| !matches!(db.rooms.is_event_referenced(&room_id, id), Ok(true))); extremities.retain(|id| !matches!(db.rooms.is_event_referenced(room_id, id), Ok(true)));
let current_sstatehash = db let current_sstatehash = db
.rooms .rooms
.current_shortstatehash(&room_id) .current_shortstatehash(room_id)
.map_err(|_| "Failed to load current state hash.".to_owned())? .map_err(|_| "Failed to load current state hash.".to_owned())?
.expect("every room has state"); .expect("every room has state");
@ -1630,7 +1623,7 @@ async fn upgrade_outlier_to_timeline_pdu(
let auth_events = db let auth_events = db
.rooms .rooms
.get_auth_events( .get_auth_events(
&room_id, room_id,
&incoming_pdu.kind, &incoming_pdu.kind,
&incoming_pdu.sender, &incoming_pdu.sender,
incoming_pdu.state_key.as_deref(), incoming_pdu.state_key.as_deref(),
@ -1642,7 +1635,7 @@ async fn upgrade_outlier_to_timeline_pdu(
.iter() .iter()
.map(|(shortstatekey, id)| { .map(|(shortstatekey, id)| {
db.rooms db.rooms
.compress_state_event(*shortstatekey, &id, &db.globals) .compress_state_event(*shortstatekey, id, &db.globals)
.map_err(|_| "Failed to compress_state_event".to_owned()) .map_err(|_| "Failed to compress_state_event".to_owned())
}) })
.collect::<StdResult<_, String>>()?; .collect::<StdResult<_, String>>()?;
@ -1653,15 +1646,15 @@ async fn upgrade_outlier_to_timeline_pdu(
let soft_fail = !state_res::event_auth::auth_check( let soft_fail = !state_res::event_auth::auth_check(
&room_version, &room_version,
&incoming_pdu, &incoming_pdu,
previous_create, previous_create.as_deref(),
None, None::<PduEvent>,
|k, s| auth_events.get(&(k.clone(), s.to_owned())).map(Arc::clone), |k, s| auth_events.get(&(k.clone(), s.to_owned())),
) )
.map_err(|_e| "Auth check failed.".to_owned())?; .map_err(|_e| "Auth check failed.".to_owned())?;
if soft_fail { if soft_fail {
append_incoming_pdu( append_incoming_pdu(
&db, db,
&incoming_pdu, &incoming_pdu,
val, val,
extremities, extremities,
@ -1685,7 +1678,7 @@ async fn upgrade_outlier_to_timeline_pdu(
for id in dbg!(&extremities) { for id in dbg!(&extremities) {
match db match db
.rooms .rooms
.get_pdu(&id) .get_pdu(id)
.map_err(|_| "Failed to ask db for pdu.".to_owned())? .map_err(|_| "Failed to ask db for pdu.".to_owned())?
{ {
Some(leaf_pdu) => { Some(leaf_pdu) => {
@ -1762,7 +1755,7 @@ async fn upgrade_outlier_to_timeline_pdu(
.iter() .iter()
.map(|(k, id)| { .map(|(k, id)| {
db.rooms db.rooms
.compress_state_event(*k, &id, &db.globals) .compress_state_event(*k, id, &db.globals)
.map_err(|_| "Failed to compress_state_event.".to_owned()) .map_err(|_| "Failed to compress_state_event.".to_owned())
}) })
.collect::<StdResult<_, String>>()? .collect::<StdResult<_, String>>()?
@ -1774,7 +1767,7 @@ async fn upgrade_outlier_to_timeline_pdu(
for state in &fork_states { for state in &fork_states {
auth_chain_sets.push( auth_chain_sets.push(
get_auth_chain( get_auth_chain(
&room_id, room_id,
state.iter().map(|(_, id)| id.clone()).collect(), state.iter().map(|(_, id)| id.clone()).collect(),
db, db,
) )
@ -1798,8 +1791,7 @@ async fn upgrade_outlier_to_timeline_pdu(
.collect::<Result<Vec<_>>>() .collect::<Result<Vec<_>>>()
.map_err(|_| "Failed to get_statekey_from_short.".to_owned())?; .map_err(|_| "Failed to get_statekey_from_short.".to_owned())?;
let state = match state_res::StateResolution::resolve( let state = match state_res::resolve(
&room_id,
room_version_id, room_version_id,
fork_states, fork_states,
auth_chain_sets, auth_chain_sets,
@ -1834,7 +1826,7 @@ async fn upgrade_outlier_to_timeline_pdu(
// Set the new room state to the resolved state // Set the new room state to the resolved state
if update_state { if update_state {
db.rooms db.rooms
.force_state(&room_id, new_room_state, &db) .force_state(room_id, new_room_state, db)
.map_err(|_| "Failed to set new room state.".to_owned())?; .map_err(|_| "Failed to set new room state.".to_owned())?;
} }
debug!("Updated resolved state"); debug!("Updated resolved state");
@ -1847,7 +1839,7 @@ async fn upgrade_outlier_to_timeline_pdu(
// represent the state for this event. // represent the state for this event.
let pdu_id = append_incoming_pdu( let pdu_id = append_incoming_pdu(
&db, db,
&incoming_pdu, &incoming_pdu,
val, val,
extremities, extremities,
@ -1892,7 +1884,7 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
let mut pdus = vec![]; let mut pdus = vec![];
for id in events { for id in events {
if let Some((time, tries)) = db.globals.bad_event_ratelimiter.read().unwrap().get(&id) { if let Some((time, tries)) = db.globals.bad_event_ratelimiter.read().unwrap().get(id) {
// Exponential backoff // Exponential backoff
let mut min_elapsed_duration = Duration::from_secs(5 * 60) * (*tries) * (*tries); let mut min_elapsed_duration = Duration::from_secs(5 * 60) * (*tries) * (*tries);
if min_elapsed_duration > Duration::from_secs(60 * 60 * 24) { if min_elapsed_duration > Duration::from_secs(60 * 60 * 24) {
@ -1908,7 +1900,7 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
// a. Look in the main timeline (pduid_pdu tree) // a. Look in the main timeline (pduid_pdu tree)
// b. Look at outlier pdu tree // b. Look at outlier pdu tree
// (get_pdu_json checks both) // (get_pdu_json checks both)
let local_pdu = db.rooms.get_pdu(&id); let local_pdu = db.rooms.get_pdu(id);
let pdu = match local_pdu { let pdu = match local_pdu {
Ok(Some(pdu)) => { Ok(Some(pdu)) => {
trace!("Found {} in db", id); trace!("Found {} in db", id);
@ -1922,7 +1914,7 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
.send_federation_request( .send_federation_request(
&db.globals, &db.globals,
origin, origin,
get_event::v1::Request { event_id: &id }, get_event::v1::Request { event_id: id },
) )
.await .await
{ {
@ -1946,8 +1938,8 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
match handle_outlier_pdu( match handle_outlier_pdu(
origin, origin,
create_event, create_event,
&id, id,
&room_id, room_id,
value.clone(), value.clone(),
db, db,
pub_key_map, pub_key_map,
@ -2095,7 +2087,7 @@ pub(crate) async fn fetch_signing_keys(
.sending .sending
.send_federation_request( .send_federation_request(
&db.globals, &db.globals,
&server, server,
get_remote_server_keys::v2::Request::new( get_remote_server_keys::v2::Request::new(
origin, origin,
MilliSecondsSinceUnixEpoch::from_system_time( MilliSecondsSinceUnixEpoch::from_system_time(
@ -2174,7 +2166,7 @@ fn append_incoming_pdu(
pdu, pdu,
pdu_json, pdu_json,
&new_room_leaves.into_iter().collect::<Vec<_>>(), &new_room_leaves.into_iter().collect::<Vec<_>>(),
&db, db,
)?; )?;
for appservice in db.appservice.all()? { for appservice in db.appservice.all()? {
@ -2212,7 +2204,7 @@ fn append_incoming_pdu(
&& pdu && pdu
.state_key .state_key
.as_ref() .as_ref()
.map_or(false, |state_key| users.is_match(&state_key)) .map_or(false, |state_key| users.is_match(state_key))
}; };
let matching_aliases = |aliases: &Regex| { let matching_aliases = |aliases: &Regex| {
db.rooms db.rooms
@ -2279,7 +2271,7 @@ pub(crate) fn get_auth_chain<'a>(
chunk_cache.extend(cached.iter().cloned()); chunk_cache.extend(cached.iter().cloned());
} else { } else {
misses2 += 1; misses2 += 1;
let auth_chain = Arc::new(get_auth_chain_inner(&room_id, &event_id, db)?); let auth_chain = Arc::new(get_auth_chain_inner(room_id, &event_id, db)?);
db.rooms db.rooms
.cache_auth_chain(vec![sevent_id], Arc::clone(&auth_chain))?; .cache_auth_chain(vec![sevent_id], Arc::clone(&auth_chain))?;
println!( println!(
@ -2776,10 +2768,10 @@ pub fn create_join_event_template_route(
let auth_check = state_res::auth_check( let auth_check = state_res::auth_check(
&room_version, &room_version,
&Arc::new(pdu.clone()), &pdu,
create_prev_event, create_prev_event.as_deref(),
None, // TODO: third_party_invite None::<PduEvent>, // TODO: third_party_invite
|k, s| auth_events.get(&(k.clone(), s.to_owned())).map(Arc::clone), |k, s| auth_events.get(&(k.clone(), s.to_owned())),
) )
.map_err(|e| { .map_err(|e| {
error!("{:?}", e); error!("{:?}", e);
@ -2827,7 +2819,7 @@ async fn create_join_event(
// We need to return the state prior to joining, let's keep a reference to that here // We need to return the state prior to joining, let's keep a reference to that here
let shortstatehash = db let shortstatehash = db
.rooms .rooms
.current_shortstatehash(&room_id)? .current_shortstatehash(room_id)?
.ok_or(Error::BadRequest( .ok_or(Error::BadRequest(
ErrorKind::NotFound, ErrorKind::NotFound,
"Pdu state not found.", "Pdu state not found.",
@ -2837,7 +2829,7 @@ async fn create_join_event(
// let mut auth_cache = EventMap::new(); // let mut auth_cache = EventMap::new();
// We do not add the event_id field to the pdu here because of signature and hashes checks // We do not add the event_id field to the pdu here because of signature and hashes checks
let (event_id, value) = match crate::pdu::gen_event_id_canonical_json(&pdu) { let (event_id, value) = match crate::pdu::gen_event_id_canonical_json(pdu) {
Ok(t) => t, Ok(t) => t,
Err(_) => { Err(_) => {
// Event could not be converted to canonical json // Event could not be converted to canonical json
@ -2866,7 +2858,7 @@ async fn create_join_event(
.or_default(), .or_default(),
); );
let mutex_lock = mutex.lock().await; let mutex_lock = mutex.lock().await;
let pdu_id = handle_incoming_pdu(&origin, &event_id, &room_id, value, true, &db, &pub_key_map) let pdu_id = handle_incoming_pdu(&origin, &event_id, room_id, value, true, db, &pub_key_map)
.await .await
.map_err(|e| { .map_err(|e| {
warn!("Error while handling incoming send join PDU: {}", e); warn!("Error while handling incoming send join PDU: {}", e);
@ -2883,14 +2875,14 @@ async fn create_join_event(
let state_ids = db.rooms.state_full_ids(shortstatehash)?; let state_ids = db.rooms.state_full_ids(shortstatehash)?;
let auth_chain_ids = get_auth_chain( let auth_chain_ids = get_auth_chain(
&room_id, room_id,
state_ids.iter().map(|(_, id)| id.clone()).collect(), state_ids.iter().map(|(_, id)| id.clone()).collect(),
&db, db,
)?; )?;
for server in db for server in db
.rooms .rooms
.room_servers(&room_id) .room_servers(room_id)
.filter_map(|r| r.ok()) .filter_map(|r| r.ok())
.filter(|server| &**server != db.globals.server_name()) .filter(|server| &**server != db.globals.server_name())
{ {
@ -2906,7 +2898,7 @@ async fn create_join_event(
.collect(), .collect(),
state: state_ids state: state_ids
.iter() .iter()
.filter_map(|(_, id)| db.rooms.get_pdu_json(&id).ok().flatten()) .filter_map(|(_, id)| db.rooms.get_pdu_json(id).ok().flatten())
.map(PduEvent::convert_to_outgoing_federation_event) .map(PduEvent::convert_to_outgoing_federation_event)
.collect(), .collect(),
}) })
@ -3302,7 +3294,7 @@ fn get_server_keys_from_cache(
let event_id = EventId::try_from(&*format!( let event_id = EventId::try_from(&*format!(
"${}", "${}",
ruma::signatures::reference_hash(&value, &room_version) ruma::signatures::reference_hash(&value, room_version)
.expect("ruma can calculate reference hashes") .expect("ruma can calculate reference hashes")
)) ))
.expect("ruma's reference hashes are valid event ids"); .expect("ruma's reference hashes are valid event ids");
@ -3394,10 +3386,10 @@ pub(crate) async fn fetch_join_signing_keys(
// Try to fetch keys, failure is okay // Try to fetch keys, failure is okay
// Servers we couldn't find in the cache will be added to `servers` // Servers we couldn't find in the cache will be added to `servers`
for pdu in &event.room_state.state { for pdu in &event.room_state.state {
let _ = get_server_keys_from_cache(pdu, &mut servers, &room_version, &mut pkm, &db); let _ = get_server_keys_from_cache(pdu, &mut servers, room_version, &mut pkm, db);
} }
for pdu in &event.room_state.auth_chain { for pdu in &event.room_state.auth_chain {
let _ = get_server_keys_from_cache(pdu, &mut servers, &room_version, &mut pkm, &db); let _ = get_server_keys_from_cache(pdu, &mut servers, room_version, &mut pkm, db);
} }
drop(pkm); drop(pkm);