conduit/src/client_server/device.rs

use crate::{database::DatabaseGuard, utils, ConduitResult, Error, Ruma};
use ruma::api::client::{
    error::ErrorKind,
    r0::{
        device::{self, delete_device, delete_devices, get_device, get_devices, update_device},
        uiaa::{AuthFlow, AuthType, UiaaInfo},
    },
};

use super::SESSION_ID_LENGTH;
#[cfg(feature = "conduit_bin")]
use rocket::{delete, get, post, put};

/// # `GET /_matrix/client/r0/devices`
///
/// Get metadata on all devices of the sender user.
#[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/client/r0/devices", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn get_devices_route(
    db: DatabaseGuard,
    body: Ruma<get_devices::Request>,
) -> ConduitResult<get_devices::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    let devices = db
        .users
        .all_devices_metadata(sender_user)
        .filter_map(|r| r.ok()) // Filter out buggy devices
        .collect::<Vec<device::Device>>();

    Ok(get_devices::Response { devices }.into())
}

/// # `GET /_matrix/client/r0/devices/{deviceId}`
///
/// Get metadata on a single device of the sender user.
#[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/client/r0/devices/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn get_device_route(
    db: DatabaseGuard,
    body: Ruma<get_device::Request<'_>>,
) -> ConduitResult<get_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    let device = db
        .users
        .get_device_metadata(sender_user, &body.body.device_id)?
        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;

    Ok(get_device::Response { device }.into())
}

/// # `PUT /_matrix/client/r0/devices/{deviceId}`
///
/// Updates the metadata on a given device of the sender user.
#[cfg_attr(
    feature = "conduit_bin",
    put("/_matrix/client/r0/devices/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn update_device_route(
    db: DatabaseGuard,
    body: Ruma<update_device::Request<'_>>,
) -> ConduitResult<update_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    let mut device = db
        .users
        .get_device_metadata(sender_user, &body.device_id)?
        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;

    device.display_name = body.display_name.clone();

    db.users
        .update_device_metadata(sender_user, &body.device_id, &device)?;

    db.flush()?;

    Ok(update_device::Response {}.into())
}

/// # `PUT /_matrix/client/r0/devices/{deviceId}`
///
/// Deletes the given device.
///
/// - Requires UIAA to verify user password
/// - Invalidates access token
/// - Deletes device metadata (device id, device display name, last seen ip, last seen ts)
/// - Forgets to-device events
/// - Triggers device list updates
#[cfg_attr(
    feature = "conduit_bin",
    delete("/_matrix/client/r0/devices/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn delete_device_route(
    db: DatabaseGuard,
    body: Ruma<delete_device::Request<'_>>,
) -> ConduitResult<delete_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
    let sender_device = body.sender_device.as_ref().expect("user is authenticated");

    // UIAA
    let mut uiaainfo = UiaaInfo {
        flows: vec![AuthFlow {
            stages: vec![AuthType::Password],
        }],
        completed: Vec::new(),
        params: Default::default(),
        session: None,
        auth_error: None,
    };

    if let Some(auth) = &body.auth {
        let (worked, uiaainfo) = db.uiaa.try_auth(
            sender_user,
            sender_device,
            auth,
            &uiaainfo,
            &db.users,
            &db.globals,
        )?;
        if !worked {
            return Err(Error::Uiaa(uiaainfo));
        }
    // Success!
    } else if let Some(json) = body.json_body {
        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
        db.uiaa
            .create(sender_user, sender_device, &uiaainfo, &json)?;
        return Err(Error::Uiaa(uiaainfo));
    } else {
        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
    }

    db.users.remove_device(sender_user, &body.device_id)?;

    db.flush()?;

    Ok(delete_device::Response {}.into())
}

/// # `PUT /_matrix/client/r0/devices/{deviceId}`
///
/// Deletes the given device.
///
/// - Requires UIAA to verify user password
///
/// For each device:
/// - Invalidates access token
/// - Deletes device metadata (device id, device display name, last seen ip, last seen ts)
/// - Forgets to-device events
/// - Triggers device list updates
#[cfg_attr(
    feature = "conduit_bin",
    post("/_matrix/client/r0/delete_devices", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn delete_devices_route(
    db: DatabaseGuard,
    body: Ruma<delete_devices::Request<'_>>,
) -> ConduitResult<delete_devices::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
    let sender_device = body.sender_device.as_ref().expect("user is authenticated");

    // UIAA
    let mut uiaainfo = UiaaInfo {
        flows: vec![AuthFlow {
            stages: vec![AuthType::Password],
        }],
        completed: Vec::new(),
        params: Default::default(),
        session: None,
        auth_error: None,
    };

    if let Some(auth) = &body.auth {
        let (worked, uiaainfo) = db.uiaa.try_auth(
            sender_user,
            sender_device,
            auth,
            &uiaainfo,
            &db.users,
            &db.globals,
        )?;
        if !worked {
            return Err(Error::Uiaa(uiaainfo));
        }
    // Success!
    } else if let Some(json) = body.json_body {
        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
        db.uiaa
            .create(sender_user, sender_device, &uiaainfo, &json)?;
        return Err(Error::Uiaa(uiaainfo));
    } else {
        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
    }

    for device_id in &body.devices {
        db.users.remove_device(sender_user, device_id)?
    }

    db.flush()?;

    Ok(delete_devices::Response {}.into())
}
Sqlite 2021-07-14 09:07:08 +02:00			`use crate::{database::DatabaseGuard, utils, ConduitResult, Error, Ruma};`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`use ruma::api::client::{`
			`error::ErrorKind,`
			`r0::{`
			`device::{self, delete_device, delete_devices, get_device, get_devices, update_device},`
Upgrade Ruma Co-authored-by: Timo Kösters <timo@koesters.xyz> 2021-10-13 10:16:45 +02:00			`uiaa::{AuthFlow, AuthType, UiaaInfo},`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`},`
			`};`

			`use super::SESSION_ID_LENGTH;`
			`#[cfg(feature = "conduit_bin")]`
			`use rocket::{delete, get, post, put};`

docs: documentation for every endpoint 2021-08-31 19:14:37 +02:00			/// # `GET /_matrix/client/r0/devices`
			`///`
			`/// Get metadata on all devices of the sender user.`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`get("/_matrix/client/r0/devices", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 12:41:03 +01:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00			`pub async fn get_devices_route(`
Sqlite 2021-07-14 09:07:08 +02:00			`db: DatabaseGuard,`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`body: Ruma<get_devices::Request>,`
			`) -> ConduitResult<get_devices::Response> {`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
			`let devices = db`
			`.users`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`.all_devices_metadata(sender_user)`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.filter_map(\|r\| r.ok()) // Filter out buggy devices`
			`.collect::<Vec<device::Device>>();`

			`Ok(get_devices::Response { devices }.into())`
			`}`

docs: documentation for every endpoint 2021-08-31 19:14:37 +02:00			/// # `GET /_matrix/client/r0/devices/{deviceId}`
			`///`
			`/// Get metadata on a single device of the sender user.`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`#[cfg_attr(`
			`feature = "conduit_bin",`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`get("/_matrix/client/r0/devices/<_>", data = "<body>")`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`)]`
feat: opentelemetry/jaeger support 2021-02-28 12:41:03 +01:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00			`pub async fn get_device_route(`
Sqlite 2021-07-14 09:07:08 +02:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 17:32:03 +02:00			`body: Ruma<get_device::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`) -> ConduitResult<get_device::Response> {`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
			`let device = db`
			`.users`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`.get_device_metadata(sender_user, &body.body.device_id)?`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;`

			`Ok(get_device::Response { device }.into())`
			`}`

docs: documentation for every endpoint 2021-08-31 19:14:37 +02:00			/// # `PUT /_matrix/client/r0/devices/{deviceId}`
			`///`
			`/// Updates the metadata on a given device of the sender user.`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`#[cfg_attr(`
			`feature = "conduit_bin",`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`put("/_matrix/client/r0/devices/<_>", data = "<body>")`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`)]`
feat: opentelemetry/jaeger support 2021-02-28 12:41:03 +01:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00			`pub async fn update_device_route(`
Sqlite 2021-07-14 09:07:08 +02:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 17:32:03 +02:00			`body: Ruma<update_device::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`) -> ConduitResult<update_device::Response> {`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
			`let mut device = db`
			`.users`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`.get_device_metadata(sender_user, &body.device_id)?`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;`

			`device.display_name = body.display_name.clone();`

			`db.users`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`.update_device_metadata(sender_user, &body.device_id, &device)?;`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
improvement: make better use of sqlite connections 2021-08-02 10:13:34 +02:00			`db.flush()?;`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00
improvement: upgrade ruma and implement blurhashes 2021-07-15 23:17:58 +02:00			`Ok(update_device::Response {}.into())`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}`

docs: documentation for every endpoint 2021-08-31 19:14:37 +02:00			/// # `PUT /_matrix/client/r0/devices/{deviceId}`
			`///`
			`/// Deletes the given device.`
			`///`
			`/// - Requires UIAA to verify user password`
			`/// - Invalidates access token`
			`/// - Deletes device metadata (device id, device display name, last seen ip, last seen ts)`
			`/// - Forgets to-device events`
			`/// - Triggers device list updates`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`#[cfg_attr(`
			`feature = "conduit_bin",`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`delete("/_matrix/client/r0/devices/<_>", data = "<body>")`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`)]`
feat: opentelemetry/jaeger support 2021-02-28 12:41:03 +01:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00			`pub async fn delete_device_route(`
Sqlite 2021-07-14 09:07:08 +02:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 17:32:03 +02:00			`body: Ruma<delete_device::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`) -> ConduitResult<delete_device::Response> {`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
			`let sender_device = body.sender_device.as_ref().expect("user is authenticated");`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
			`// UIAA`
			`let mut uiaainfo = UiaaInfo {`
			`flows: vec![AuthFlow {`
Upgrade Ruma Co-authored-by: Timo Kösters <timo@koesters.xyz> 2021-10-13 10:16:45 +02:00			`stages: vec![AuthType::Password],`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}],`
			`completed: Vec::new(),`
			`params: Default::default(),`
			`session: None,`
			`auth_error: None,`
			`};`

			`if let Some(auth) = &body.auth {`
			`let (worked, uiaainfo) = db.uiaa.try_auth(`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`sender_user,`
			`sender_device,`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`auth,`
			`&uiaainfo,`
			`&db.users,`
			`&db.globals,`
			`)?;`
			`if !worked {`
			`return Err(Error::Uiaa(uiaainfo));`
			`}`
			`// Success!`
apply lint suggestions and version bump 2021-07-14 12:31:38 +02:00			`} else if let Some(json) = body.json_body {`
			`uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));`
			`db.uiaa`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`.create(sender_user, sender_device, &uiaainfo, &json)?;`
apply lint suggestions and version bump 2021-07-14 12:31:38 +02:00			`return Err(Error::Uiaa(uiaainfo));`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`} else {`
apply lint suggestions and version bump 2021-07-14 12:31:38 +02:00			`return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}`

Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`db.users.remove_device(sender_user, &body.device_id)?;`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
improvement: make better use of sqlite connections 2021-08-02 10:13:34 +02:00			`db.flush()?;`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00
improvement: upgrade ruma and implement blurhashes 2021-07-15 23:17:58 +02:00			`Ok(delete_device::Response {}.into())`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}`

docs: documentation for every endpoint 2021-08-31 19:14:37 +02:00			/// # `PUT /_matrix/client/r0/devices/{deviceId}`
			`///`
			`/// Deletes the given device.`
			`///`
			`/// - Requires UIAA to verify user password`
			`///`
			`/// For each device:`
			`/// - Invalidates access token`
			`/// - Deletes device metadata (device id, device display name, last seen ip, last seen ts)`
			`/// - Forgets to-device events`
			`/// - Triggers device list updates`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`post("/_matrix/client/r0/delete_devices", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 12:41:03 +01:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00			`pub async fn delete_devices_route(`
Sqlite 2021-07-14 09:07:08 +02:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 17:32:03 +02:00			`body: Ruma<delete_devices::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`) -> ConduitResult<delete_devices::Response> {`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 20:33:12 +02:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
			`let sender_device = body.sender_device.as_ref().expect("user is authenticated");`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
			`// UIAA`
			`let mut uiaainfo = UiaaInfo {`
			`flows: vec![AuthFlow {`
Upgrade Ruma Co-authored-by: Timo Kösters <timo@koesters.xyz> 2021-10-13 10:16:45 +02:00			`stages: vec![AuthType::Password],`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}],`
			`completed: Vec::new(),`
			`params: Default::default(),`
			`session: None,`
			`auth_error: None,`
			`};`

			`if let Some(auth) = &body.auth {`
			`let (worked, uiaainfo) = db.uiaa.try_auth(`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`sender_user,`
			`sender_device,`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`auth,`
			`&uiaainfo,`
			`&db.users,`
			`&db.globals,`
			`)?;`
			`if !worked {`
			`return Err(Error::Uiaa(uiaainfo));`
			`}`
			`// Success!`
apply lint suggestions and version bump 2021-07-14 12:31:38 +02:00			`} else if let Some(json) = body.json_body {`
			`uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));`
			`db.uiaa`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`.create(sender_user, sender_device, &uiaainfo, &json)?;`
apply lint suggestions and version bump 2021-07-14 12:31:38 +02:00			`return Err(Error::Uiaa(uiaainfo));`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`} else {`
apply lint suggestions and version bump 2021-07-14 12:31:38 +02:00			`return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}`

			`for device_id in &body.devices {`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`db.users.remove_device(sender_user, device_id)?`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}`

improvement: make better use of sqlite connections 2021-08-02 10:13:34 +02:00			`db.flush()?;`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00
improvement: upgrade ruma and implement blurhashes 2021-07-15 23:17:58 +02:00			`Ok(delete_devices::Response {}.into())`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}`