mirror of https://gitlab.com/famedly/conduit
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
353 lines
12 KiB
Rust
353 lines
12 KiB
Rust
2 years ago
|
use crate::{database::DatabaseGuard, Error, Result, Ruma};
|
||
4 years ago
|
use ruma::api::client::{
|
||
2 years ago
|
backup::{
|
||
2 years ago
|
add_backup_keys, add_backup_keys_for_room, add_backup_keys_for_session,
|
||
|
create_backup_version, delete_backup_keys, delete_backup_keys_for_room,
|
||
|
delete_backup_keys_for_session, delete_backup_version, get_backup_info, get_backup_keys,
|
||
|
get_backup_keys_for_room, get_backup_keys_for_session, get_latest_backup_info,
|
||
|
update_backup_version,
|
||
4 years ago
|
},
|
||
2 years ago
|
error::ErrorKind,
|
||
4 years ago
|
};
|
||
|
|
||
3 years ago
|
/// # `POST /_matrix/client/r0/room_keys/version`
|
||
|
///
|
||
|
/// Creates a new backup.
|
||
2 years ago
|
pub async fn create_backup_version_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<create_backup_version::v3::Request>,
|
||
|
) -> Result<create_backup_version::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
let version = db
|
||
|
.key_backups
|
||
3 years ago
|
.create_backup(sender_user, &body.algorithm, &db.globals)?;
|
||
4 years ago
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(create_backup_version::v3::Response { version })
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `PUT /_matrix/client/r0/room_keys/version/{version}`
|
||
|
///
|
||
|
/// Update information about an existing backup. Only `auth_data` can be modified.
|
||
2 years ago
|
pub async fn update_backup_version_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<update_backup_version::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<update_backup_version::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
db.key_backups
|
||
3 years ago
|
.update_backup(sender_user, &body.version, &body.algorithm, &db.globals)?;
|
||
4 years ago
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(update_backup_version::v3::Response {})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `GET /_matrix/client/r0/room_keys/version`
|
||
|
///
|
||
|
/// Get information about the latest backup version.
|
||
2 years ago
|
pub async fn get_latest_backup_info_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<get_latest_backup_info::v3::Request>,
|
||
|
) -> Result<get_latest_backup_info::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
|
let (version, algorithm) =
|
||
|
db.key_backups
|
||
3 years ago
|
.get_latest_backup(sender_user)?
|
||
4 years ago
|
.ok_or(Error::BadRequest(
|
||
|
ErrorKind::NotFound,
|
||
|
"Key backup does not exist.",
|
||
|
))?;
|
||
|
|
||
2 years ago
|
Ok(get_latest_backup_info::v3::Response {
|
||
4 years ago
|
algorithm,
|
||
4 years ago
|
count: (db.key_backups.count_keys(sender_user, &version)? as u32).into(),
|
||
|
etag: db.key_backups.get_etag(sender_user, &version)?,
|
||
4 years ago
|
version,
|
||
2 years ago
|
})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `GET /_matrix/client/r0/room_keys/version`
|
||
|
///
|
||
|
/// Get information about an existing backup.
|
||
2 years ago
|
pub async fn get_backup_info_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<get_backup_info::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<get_backup_info::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
let algorithm = db
|
||
|
.key_backups
|
||
3 years ago
|
.get_backup(sender_user, &body.version)?
|
||
4 years ago
|
.ok_or(Error::BadRequest(
|
||
|
ErrorKind::NotFound,
|
||
|
"Key backup does not exist.",
|
||
|
))?;
|
||
|
|
||
2 years ago
|
Ok(get_backup_info::v3::Response {
|
||
4 years ago
|
algorithm,
|
||
4 years ago
|
count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
|
||
|
etag: db.key_backups.get_etag(sender_user, &body.version)?,
|
||
4 years ago
|
version: body.version.to_owned(),
|
||
2 years ago
|
})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `DELETE /_matrix/client/r0/room_keys/version/{version}`
|
||
|
///
|
||
|
/// Delete an existing key backup.
|
||
|
///
|
||
|
/// - Deletes both information about the backup, as well as all key data related to the backup
|
||
2 years ago
|
pub async fn delete_backup_version_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<delete_backup_version::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<delete_backup_version::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
3 years ago
|
db.key_backups.delete_backup(sender_user, &body.version)?;
|
||
4 years ago
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(delete_backup_version::v3::Response {})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `PUT /_matrix/client/r0/room_keys/keys`
|
||
|
///
|
||
4 years ago
|
/// Add the received backup keys to the database.
|
||
3 years ago
|
///
|
||
|
/// - Only manipulating the most recently created version of the backup is allowed
|
||
|
/// - Adds the keys to the backup
|
||
|
/// - Returns the new number of keys in this backup and the etag
|
||
4 years ago
|
pub async fn add_backup_keys_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<add_backup_keys::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<add_backup_keys::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
3 years ago
|
if Some(&body.version)
|
||
|
!= db
|
||
|
.key_backups
|
||
|
.get_latest_backup_version(sender_user)?
|
||
|
.as_ref()
|
||
|
{
|
||
|
return Err(Error::BadRequest(
|
||
|
ErrorKind::InvalidParam,
|
||
|
"You may only manipulate the most recently created version of the backup.",
|
||
|
));
|
||
|
}
|
||
|
|
||
4 years ago
|
for (room_id, room) in &body.rooms {
|
||
|
for (session_id, key_data) in &room.sessions {
|
||
|
db.key_backups.add_key(
|
||
3 years ago
|
sender_user,
|
||
4 years ago
|
&body.version,
|
||
3 years ago
|
room_id,
|
||
|
session_id,
|
||
|
key_data,
|
||
4 years ago
|
&db.globals,
|
||
|
)?
|
||
|
}
|
||
|
}
|
||
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(add_backup_keys::v3::Response {
|
||
4 years ago
|
count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
|
||
|
etag: db.key_backups.get_etag(sender_user, &body.version)?,
|
||
2 years ago
|
})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `PUT /_matrix/client/r0/room_keys/keys/{roomId}`
|
||
|
///
|
||
4 years ago
|
/// Add the received backup keys to the database.
|
||
3 years ago
|
///
|
||
|
/// - Only manipulating the most recently created version of the backup is allowed
|
||
|
/// - Adds the keys to the backup
|
||
|
/// - Returns the new number of keys in this backup and the etag
|
||
2 years ago
|
pub async fn add_backup_keys_for_room_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<add_backup_keys_for_room::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<add_backup_keys_for_room::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
3 years ago
|
if Some(&body.version)
|
||
|
!= db
|
||
|
.key_backups
|
||
|
.get_latest_backup_version(sender_user)?
|
||
|
.as_ref()
|
||
|
{
|
||
|
return Err(Error::BadRequest(
|
||
|
ErrorKind::InvalidParam,
|
||
|
"You may only manipulate the most recently created version of the backup.",
|
||
|
));
|
||
|
}
|
||
|
|
||
4 years ago
|
for (session_id, key_data) in &body.sessions {
|
||
|
db.key_backups.add_key(
|
||
3 years ago
|
sender_user,
|
||
4 years ago
|
&body.version,
|
||
|
&body.room_id,
|
||
3 years ago
|
session_id,
|
||
|
key_data,
|
||
4 years ago
|
&db.globals,
|
||
|
)?
|
||
|
}
|
||
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(add_backup_keys_for_room::v3::Response {
|
||
4 years ago
|
count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
|
||
|
etag: db.key_backups.get_etag(sender_user, &body.version)?,
|
||
2 years ago
|
})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `PUT /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
|
||
|
///
|
||
4 years ago
|
/// Add the received backup key to the database.
|
||
3 years ago
|
///
|
||
|
/// - Only manipulating the most recently created version of the backup is allowed
|
||
|
/// - Adds the keys to the backup
|
||
|
/// - Returns the new number of keys in this backup and the etag
|
||
2 years ago
|
pub async fn add_backup_keys_for_session_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<add_backup_keys_for_session::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<add_backup_keys_for_session::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
3 years ago
|
if Some(&body.version)
|
||
|
!= db
|
||
|
.key_backups
|
||
|
.get_latest_backup_version(sender_user)?
|
||
|
.as_ref()
|
||
|
{
|
||
|
return Err(Error::BadRequest(
|
||
|
ErrorKind::InvalidParam,
|
||
|
"You may only manipulate the most recently created version of the backup.",
|
||
|
));
|
||
|
}
|
||
|
|
||
4 years ago
|
db.key_backups.add_key(
|
||
3 years ago
|
sender_user,
|
||
4 years ago
|
&body.version,
|
||
|
&body.room_id,
|
||
|
&body.session_id,
|
||
|
&body.session_data,
|
||
|
&db.globals,
|
||
|
)?;
|
||
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(add_backup_keys_for_session::v3::Response {
|
||
4 years ago
|
count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
|
||
|
etag: db.key_backups.get_etag(sender_user, &body.version)?,
|
||
2 years ago
|
})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `GET /_matrix/client/r0/room_keys/keys`
|
||
|
///
|
||
|
/// Retrieves all keys from the backup.
|
||
4 years ago
|
pub async fn get_backup_keys_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<get_backup_keys::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<get_backup_keys::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
3 years ago
|
let rooms = db.key_backups.get_all(sender_user, &body.version)?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(get_backup_keys::v3::Response { rooms })
|
||
4 years ago
|
}
|
||
4 years ago
|
|
||
3 years ago
|
/// # `GET /_matrix/client/r0/room_keys/keys/{roomId}`
|
||
|
///
|
||
|
/// Retrieves all keys from the backup for a given room.
|
||
2 years ago
|
pub async fn get_backup_keys_for_room_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<get_backup_keys_for_room::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<get_backup_keys_for_room::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
|
let sessions = db
|
||
|
.key_backups
|
||
3 years ago
|
.get_room(sender_user, &body.version, &body.room_id)?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(get_backup_keys_for_room::v3::Response { sessions })
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `GET /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
|
||
|
///
|
||
|
/// Retrieves a key from the backup.
|
||
2 years ago
|
pub async fn get_backup_keys_for_session_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<get_backup_keys_for_session::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<get_backup_keys_for_session::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
4 years ago
|
let key_data = db
|
||
|
.key_backups
|
||
3 years ago
|
.get_session(sender_user, &body.version, &body.room_id, &body.session_id)?
|
||
3 years ago
|
.ok_or(Error::BadRequest(
|
||
|
ErrorKind::NotFound,
|
||
|
"Backup key not found for this user's session.",
|
||
|
))?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(get_backup_keys_for_session::v3::Response { key_data })
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `DELETE /_matrix/client/r0/room_keys/keys`
|
||
|
///
|
||
|
/// Delete the keys from the backup.
|
||
4 years ago
|
pub async fn delete_backup_keys_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<delete_backup_keys::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<delete_backup_keys::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
3 years ago
|
db.key_backups.delete_all_keys(sender_user, &body.version)?;
|
||
4 years ago
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(delete_backup_keys::v3::Response {
|
||
4 years ago
|
count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
|
||
|
etag: db.key_backups.get_etag(sender_user, &body.version)?,
|
||
2 years ago
|
})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `DELETE /_matrix/client/r0/room_keys/keys/{roomId}`
|
||
|
///
|
||
|
/// Delete the keys from the backup for a given room.
|
||
2 years ago
|
pub async fn delete_backup_keys_for_room_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<delete_backup_keys_for_room::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<delete_backup_keys_for_room::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
|
db.key_backups
|
||
3 years ago
|
.delete_room_keys(sender_user, &body.version, &body.room_id)?;
|
||
4 years ago
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(delete_backup_keys_for_room::v3::Response {
|
||
4 years ago
|
count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
|
||
|
etag: db.key_backups.get_etag(sender_user, &body.version)?,
|
||
2 years ago
|
})
|
||
4 years ago
|
}
|
||
|
|
||
3 years ago
|
/// # `DELETE /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
|
||
|
///
|
||
|
/// Delete a key from the backup.
|
||
2 years ago
|
pub async fn delete_backup_keys_for_session_route(
|
||
3 years ago
|
db: DatabaseGuard,
|
||
2 years ago
|
body: Ruma<delete_backup_keys_for_session::v3::IncomingRequest>,
|
||
2 years ago
|
) -> Result<delete_backup_keys_for_session::v3::Response> {
|
||
4 years ago
|
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
|
||
4 years ago
|
|
||
|
db.key_backups
|
||
3 years ago
|
.delete_room_key(sender_user, &body.version, &body.room_id, &body.session_id)?;
|
||
4 years ago
|
|
||
3 years ago
|
db.flush()?;
|
||
4 years ago
|
|
||
2 years ago
|
Ok(delete_backup_keys_for_session::v3::Response {
|
||
4 years ago
|
count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
|
||
|
etag: db.key_backups.get_etag(sender_user, &body.version)?,
|
||
2 years ago
|
})
|
||
4 years ago
|
}
|