Merge remote-tracking branch 'benma/cstr2'

benma · benma · commit 2776ce817afb · 2023-04-01T16:20:58.000+02:00
diff --git a/src/rust/bitbox02/src/lib.rs b/src/rust/bitbox02/src/lib.rs
@@ -51,13 +51,14 @@ pub use bitbox02_sys::buffer_t;
 #[macro_use]
 pub mod util;
 
-// ug_put_string displays a debug message on the screen for 3 sec.
 pub fn ug_put_string(x: i16, y: i16, input: &str, inverted: bool) {
-    match str_to_cstr!(input, 128) {
-        Ok(buf) => unsafe {
-            bitbox02_sys::UG_PutString(x, y, buf.as_ptr() as *const _, inverted);
-        },
-        Err(msg) => screen_print_debug(msg, 3000),
+    unsafe {
+        bitbox02_sys::UG_PutString(
+            x,
+            y,
+            crate::util::str_to_cstr_vec(input).unwrap().as_ptr(),
+            inverted,
+        );
     }
 }
 
@@ -99,16 +100,11 @@ pub fn delay(duration: Duration) {
 }
 
 pub fn screen_print_debug(msg: &str, duration: i32) {
-    match str_to_cstr!(msg, 200) {
-        Ok(cstr) => unsafe {
-            bitbox02_sys::screen_print_debug(cstr.as_ptr() as *const _, duration)
-        },
-        Err(errmsg) => unsafe {
-            bitbox02_sys::screen_print_debug(
-                str_to_cstr_force!(errmsg, 200).as_ptr() as *const _,
-                duration,
-            )
-        },
+    unsafe {
+        bitbox02_sys::screen_print_debug(
+            crate::util::str_to_cstr_vec(msg).unwrap().as_ptr(),
+            duration,
+        )
     }
 }
 
diff --git a/src/rust/bitbox02/src/memory.rs b/src/rust/bitbox02/src/memory.rs
@@ -35,12 +35,10 @@ pub fn get_device_name() -> String {
         .into()
 }
 
-/// `name.as_bytes()` must be smaller or equal to
-/// `DEVICE_NAME_MAX_LEN`, otherwise this function panics.
 pub fn set_device_name(name: &str) -> Result<(), Error> {
     match unsafe {
         bitbox02_sys::memory_set_device_name(
-            crate::str_to_cstr_force!(name, DEVICE_NAME_MAX_LEN).as_ptr(),
+            crate::util::str_to_cstr_vec(name).or(Err(Error))?.as_ptr(),
         )
     } {
         true => Ok(()),
diff --git a/src/rust/bitbox02/src/ui/types.rs b/src/rust/bitbox02/src/ui/types.rs
@@ -14,6 +14,7 @@
 
 extern crate alloc;
 use alloc::boxed::Box;
+use alloc::vec::Vec;
 
 use util::Survive;
 
@@ -69,20 +70,18 @@ impl<'a> ConfirmParams<'a> {
     /// alive for as long as the C params live.
     pub(crate) fn to_c_params(
         &self,
-        title_scatch: &'a mut [u8; MAX_LABEL_SIZE + 2],
-        body_scratch: &'a mut [u8; MAX_LABEL_SIZE + 2],
+        title_scatch: &'a mut Vec<u8>,
+        body_scratch: &'a mut Vec<u8>,
     ) -> Survive<'a, bitbox02_sys::confirm_params_t> {
         // We truncate at a bit higher than MAX_LABEL_SIZE, so the label component will correctly
         // truncate and append '...'.
         const TRUNCATE_SIZE: usize = MAX_LABEL_SIZE + 1;
-        *title_scatch = crate::str_to_cstr_force!(
-            crate::util::truncate_str(self.title, TRUNCATE_SIZE),
-            TRUNCATE_SIZE
-        );
-        *body_scratch = crate::str_to_cstr_force!(
-            crate::util::truncate_str(self.body, TRUNCATE_SIZE),
-            TRUNCATE_SIZE
-        );
+        *title_scatch =
+            crate::util::str_to_cstr_vec(crate::util::truncate_str(self.title, TRUNCATE_SIZE))
+                .unwrap();
+        *body_scratch =
+            crate::util::str_to_cstr_vec(crate::util::truncate_str(self.body, TRUNCATE_SIZE))
+                .unwrap();
         Survive::new(bitbox02_sys::confirm_params_t {
             title: title_scatch.as_ptr(),
             title_autowrap: self.title_autowrap,
@@ -113,16 +112,15 @@ impl<'a> TrinaryInputStringParams<'a> {
     #[cfg_attr(feature = "testing", allow(dead_code))]
     pub(crate) fn to_c_params(
         &self,
-        title_scratch: &'a mut [u8; MAX_LABEL_SIZE + 2],
+        title_scratch: &'a mut Vec<u8>,
     ) -> Survive<'a, bitbox02_sys::trinary_input_string_params_t> {
         // We truncate at a bit higher than MAX_LABEL_SIZE, so the label component will correctly
         // truncate and append '...'.
         const TRUNCATE_SIZE: usize = MAX_LABEL_SIZE + 1;
 
-        *title_scratch = crate::str_to_cstr_force!(
-            crate::util::truncate_str(self.title, TRUNCATE_SIZE),
-            TRUNCATE_SIZE
-        );
+        *title_scratch =
+            crate::util::str_to_cstr_vec(crate::util::truncate_str(self.title, TRUNCATE_SIZE))
+                .unwrap();
 
         Survive::new(bitbox02_sys::trinary_input_string_params_t {
             title: title_scratch.as_ptr(),
diff --git a/src/rust/bitbox02/src/ui/ui.rs b/src/rust/bitbox02/src/ui/ui.rs
@@ -13,7 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::types::MAX_LABEL_SIZE;
 pub use super::types::{
     AcceptRejectCb, ConfirmParams, ContinueCancelCb, Font, MenuParams, SelectWordCb, TrinaryChoice,
     TrinaryChoiceCb, TrinaryInputStringParams,
@@ -101,7 +100,7 @@ where
             Box::into_raw(Box::new(cb)) as *mut c_void,
         ),
     };
-    let mut title_scratch = [0; MAX_LABEL_SIZE + 2];
+    let mut title_scratch = Vec::new();
     let component = unsafe {
         bitbox02_sys::trinary_input_string_create(
             &params.to_c_params(&mut title_scratch).data, // title copied in C
@@ -141,8 +140,8 @@ where
         let mut callback = Box::from_raw(param as *mut F2);
         callback(result);
     }
-    let mut title_scratch = [0; MAX_LABEL_SIZE + 2];
-    let mut body_scratch = [0; MAX_LABEL_SIZE + 2];
+    let mut title_scratch = Vec::new();
+    let mut body_scratch = Vec::new();
     let component = unsafe {
         bitbox02_sys::confirm_create(
             &params
@@ -184,7 +183,7 @@ where
 
     let component = unsafe {
         bitbox02_sys::status_create(
-            crate::str_to_cstr_force!(text, MAX_LABEL_SIZE).as_ptr(), // copied in C
+            crate::util::str_to_cstr_vec(text).unwrap().as_ptr(), // copied in C
             status_success,
             Some(c_callback::<F>),
             Box::into_raw(Box::new(callback)) as *mut _, // passed to c_callback as `param`.
@@ -244,10 +243,10 @@ pub fn menu_create(params: MenuParams<'_>) -> Component<'_> {
     //
     // Step 1: create the C strings. This var has to be alive until after menu_create() finishes,
     // otherwise the pointers we send to menu_create() will be invalid.
-    let words: Vec<[u8; 101]> = params
+    let words: Vec<Vec<u8>> = params
         .words
         .iter()
-        .map(|word| crate::str_to_cstr_force!(word, 100))
+        .map(|word| crate::util::str_to_cstr_vec(word).unwrap())
         .collect();
     // Step two: collect pointers. This var also has to be valid until menu_create() finishes, or
     // the pointer will be invalid.
@@ -333,10 +332,10 @@ pub fn trinary_choice_create<'a>(
     let chosen_cb_param = Box::into_raw(Box::new(chosen_callback)) as *mut c_void;
     let component = unsafe {
         bitbox02_sys::trinary_choice_create(
-            crate::str_to_cstr_force!(message, MAX_LABEL_SIZE).as_ptr(), // copied in C
-            crate::str_to_cstr_force!(label_left, MAX_LABEL_SIZE).as_ptr(), // copied in C
-            crate::str_to_cstr_force!(label_middle, MAX_LABEL_SIZE).as_ptr(), // copied in C
-            crate::str_to_cstr_force!(label_right, MAX_LABEL_SIZE).as_ptr(), // copied in C
+            crate::util::str_to_cstr_vec(message).unwrap().as_ptr(), // copied in C
+            crate::util::str_to_cstr_vec(label_left).unwrap().as_ptr(), // copied in C
+            crate::util::str_to_cstr_vec(label_middle).unwrap().as_ptr(), // copied in C
+            crate::util::str_to_cstr_vec(label_right).unwrap().as_ptr(), // copied in C
             Some(c_chosen_cb as _),
             chosen_cb_param,
             core::ptr::null_mut(), // parent component, there is no parent.
@@ -419,7 +418,7 @@ pub fn trinary_input_string_set_input(component: &mut Component, word: &str) {
     unsafe {
         bitbox02_sys::trinary_input_string_set_input(
             component.component,
-            crate::str_to_cstr_force!(word, bitbox02_sys::INPUT_STRING_MAX_SIZE as usize).as_ptr(),
+            crate::util::str_to_cstr_vec(word).unwrap().as_ptr(),
         )
     }
 }
@@ -439,7 +438,7 @@ pub fn screen_stack_pop_all() {
 pub fn progress_create<'a>(title: &str) -> Component<'a> {
     let component = unsafe {
         bitbox02_sys::progress_create(
-            crate::str_to_cstr_force!(title, MAX_LABEL_SIZE).as_ptr(), // copied in C
+            crate::util::str_to_cstr_vec(title).unwrap().as_ptr(), // copied in C
         )
     };
 
diff --git a/src/rust/bitbox02/src/util.rs b/src/rust/bitbox02/src/util.rs
@@ -31,52 +31,6 @@ pub unsafe fn str_from_null_terminated_ptr<'a>(ptr: *const u8) -> Result<&'a str
     core::ffi::CStr::from_ptr(ptr.cast()).to_str().or(Err(()))
 }
 
-/// Macro for creating a stack allocated buffer with the content of a string and a null-terminator
-///
-/// Example usage:
-///
-/// ```
-/// # #[macro_use] extern crate bitbox02;
-/// let name = "sample_string";
-/// let buf = match str_to_cstr!(name, 50) {
-///     Ok(buf) => buf,
-///     Err(msg) => panic!("{}", msg),
-/// };
-/// ```
-#[macro_export]
-macro_rules! str_to_cstr {
-    ($input:expr, $len:expr) => {{
-        let mut buf = [0u8; $len + 1];
-        if !$input.is_ascii() {
-            Err("non-ascii input")
-        } else {
-            let len = core::cmp::min($len, $input.len());
-            {
-                // Take a slice of buf of the correct length
-                let buf = &mut buf[..len];
-                // Take a slice of input of the correct length
-                let input = &$input.as_bytes()[..len];
-                buf.copy_from_slice(input);
-            }
-            if $input.len() > len {
-                Err("str is too long")
-            } else {
-                Ok(buf)
-            }
-        }
-    }};
-}
-
-#[macro_export]
-macro_rules! str_to_cstr_force {
-    ($input:expr, $len:expr) => {
-        match $crate::str_to_cstr!($input, $len) {
-            Ok(buf) => buf,
-            Err(msg) => panic!("{}", msg),
-        }
-    };
-}
-
 /// truncate_str truncates string `s` to `len` chars. If `s` is
 /// shorter than `len`, the string is returned unchanged (no panics).
 pub fn truncate_str(s: &str, len: usize) -> &str {

Original file line number	Diff line number	Diff line change
`@@ -35,12 +35,10 @@ pub fn get_device_name() -> String {`
`35`	`35`	`.into()`
`36`	`36`	`}`
`37`	`37`
`38`		-/// `name.as_bytes()` must be smaller or equal to
`39`		-/// `DEVICE_NAME_MAX_LEN`, otherwise this function panics.
`40`	`38`	`pub fn set_device_name(name: &str) -> Result<(), Error> {`
`41`	`39`	`match unsafe {`
`42`	`40`	`bitbox02_sys::memory_set_device_name(`
`43`		`- crate::str_to_cstr_force!(name, DEVICE_NAME_MAX_LEN).as_ptr(),`
	`41`	`+ crate::util::str_to_cstr_vec(name).or(Err(Error))?.as_ptr(),`
`44`	`42`	`)`
`45`	`43`	`} {`
`46`	`44`	`true => Ok(()),`