rust/hww: fix module-inception

api::api is bad (clippy), so we move it to mod.rs.

Author: benma

src/rust/bitbox02-rust/src/hww/api/api.rs

@@ -16,5 +16,154 @@ mod pb {
     include!("./shiftcrypto.bitbox02.rs");
 }
 
-mod api;
-pub use api::process;
+use alloc::vec::Vec;
+
+use bitbox02::commander::Error;
+use pb::request::Request;
+use pb::response::Response;
+
+/// Creates an Error response. Corresponds to commander.c:_report_error().
+fn make_error(err: bitbox02::commander::Error) -> Response {
+    use Error::*;
+    let err = match err {
+        COMMANDER_OK => panic!("can't call this function with COMMANDER_OK"),
+        COMMANDER_ERR_INVALID_INPUT => pb::Error {
+            code: 101,
+            message: "invalid input".into(),
+        },
+        COMMANDER_ERR_MEMORY => pb::Error {
+            code: 102,
+            message: "memory".into(),
+        },
+        COMMANDER_ERR_GENERIC => pb::Error {
+            code: 103,
+            message: "generic error".into(),
+        },
+        COMMANDER_ERR_USER_ABORT => pb::Error {
+            code: 104,
+            message: "aborted by the user".into(),
+        },
+        COMMANDER_ERR_INVALID_STATE => pb::Error {
+            code: 105,
+            message: "can't call this endpoint: wrong state".into(),
+        },
+        COMMANDER_ERR_DISABLED => pb::Error {
+            code: 106,
+            message: "function disabled".into(),
+        },
+        COMMANDER_ERR_DUPLICATE => pb::Error {
+            code: 107,
+            message: "duplicate entry".into(),
+        },
+    };
+    Response::Error(err)
+}
+
+/// Encodes a protobuf Response message.
+fn encode(response: Response) -> Vec<u8> {
+    use prost::Message;
+    let response = pb::Response {
+        response: Some(response),
+    };
+    let mut out = Vec::<u8>::new();
+    response.encode(&mut out).unwrap();
+    out
+}
+
+/// Returns the field tag number of the request as defined in the .proto file.  This is needed for
+/// compatibility with commander_states.c, and needed as long as API calls processed in C use
+/// `commmander_states_force_next()`.
+fn request_tag(request: &Request) -> u32 {
+    use Request::*;
+    match request {
+        RandomNumber(_) => bitbox02::Request_random_number_tag,
+        DeviceName(_) => bitbox02::Request_device_name_tag,
+        DeviceLanguage(_) => bitbox02::Request_device_language_tag,
+        DeviceInfo(_) => bitbox02::Request_device_info_tag,
+        SetPassword(_) => bitbox02::Request_set_password_tag,
+        CreateBackup(_) => bitbox02::Request_create_backup_tag,
+        ShowMnemonic(_) => bitbox02::Request_show_mnemonic_tag,
+        BtcPub(_) => bitbox02::Request_btc_pub_tag,
+        BtcSignInit(_) => bitbox02::Request_btc_sign_init_tag,
+        BtcSignInput(_) => bitbox02::Request_btc_sign_input_tag,
+        BtcSignOutput(_) => bitbox02::Request_btc_sign_output_tag,
+        InsertRemoveSdcard(_) => bitbox02::Request_insert_remove_sdcard_tag,
+        CheckSdcard(_) => bitbox02::Request_check_sdcard_tag,
+        SetMnemonicPassphraseEnabled(_) => bitbox02::Request_set_mnemonic_passphrase_enabled_tag,
+        ListBackups(_) => bitbox02::Request_list_backups_tag,
+        RestoreBackup(_) => bitbox02::Request_restore_backup_tag,
+        PerformAttestation(_) => bitbox02::Request_perform_attestation_tag,
+        Reboot(_) => bitbox02::Request_reboot_tag,
+        CheckBackup(_) => bitbox02::Request_check_backup_tag,
+        Eth(_) => bitbox02::Request_eth_tag,
+        Reset(_) => bitbox02::Request_reset_tag,
+        RestoreFromMnemonic(_) => bitbox02::Request_restore_from_mnemonic_tag,
+        Bitboxbase(_) => bitbox02::Request_bitboxbase_tag,
+        Fingerprint(_) => bitbox02::Request_fingerprint_tag,
+        Btc(_) => bitbox02::Request_btc_tag,
+        ElectrumEncryptionKey(_) => bitbox02::Request_electrum_encryption_key_tag,
+    }
+}
+
+async fn api_set_device_name(
+    pb::SetDeviceNameRequest { name }: &pb::SetDeviceNameRequest,
+) -> Response {
+    use crate::workflow::confirm;
+    let params = confirm::Params {
+        title: "Name",
+        body: &name,
+        scrollable: true,
+        ..Default::default()
+    };
+
+    if !confirm::confirm(&params).await {
+        return make_error(Error::COMMANDER_ERR_USER_ABORT);
+    }
+
+    if bitbox02::memory::set_device_name(&name).is_err() {
+        return make_error(Error::COMMANDER_ERR_MEMORY);
+    }
+
+    Response::Success(pb::Success {})
+}
+
+/// Handle a protobuf api call.
+///
+/// Returns `None` if the call was not handled by Rust, in which case
+/// it should be handled by the C commander.
+async fn process_api(request: &Request) -> Option<Response> {
+    match request {
+        Request::DeviceName(ref request) => Some(api_set_device_name(request).await),
+        _ => None,
+    }
+}
+
+/// Handle a protobuf api call.  API calls not handled by Rust are
+/// handled by the C commander, which allows us to use Rust for new
+/// api calls and port the old calls step by step.
+///
+/// `input` is a hww.proto Request message, protobuf encoded.
+/// Returns a protobuf encoded hww.proto Response message.
+pub async fn process(input: Vec<u8>) -> Vec<u8> {
+    use prost::Message;
+    let request = match pb::Request::decode(&input[..]) {
+        Ok(pb::Request {
+            request: Some(request),
+        }) => request,
+        _ => return encode(make_error(Error::COMMANDER_ERR_INVALID_INPUT)),
+    };
+    if !bitbox02::commander::states_can_call(request_tag(&request) as u16) {
+        return encode(make_error(Error::COMMANDER_ERR_INVALID_STATE));
+    }
+
+    // Since we will process the call now, so can clear the 'force next' info.
+    // We do this before processing as the api call can potentially define the next api call
+    // to be forced.
+    bitbox02::commander::states_clear_force_next();
+
+    match process_api(&request).await {
+        Some(response) => encode(response),
+        // Api call not handled in Rust -> handle it in C.
+        _ => bitbox02::commander::commander(input),
+    }
+}