Merge branch 'strftime'

Author: benma

.ci/ci

@@ -59,6 +59,10 @@ if arm-none-eabi-nm build/bin/firmware.elf | grep -q "float_to_decimal_common_sh
     echo "Use something simpler like (float*10).round() as u64, then format with util::decimal::format"
     exit 1
 fi
+if arm-none-eabi-nm build/bin/firmware.elf | grep -q "strftime"; then
+    echo "strftime adds significant binary bloat. Use custom formatting like in `format_dateimte()`."
+    exit 1
+fi
 
 (cd tools/atecc608; go test ./...)
 

src/CMakeLists.txt

@@ -296,7 +296,6 @@ add_custom_target(rust-bindgen
     --with-derive-default
     --ctypes-prefix util::c_types
     --allowlist-function bip32_derive_xpub
-    --allowlist-function strftime
     --allowlist-function localtime
     --allowlist-function wally_free_string
     --allowlist-function mock_memory_factoryreset

src/rust/bitbox02-rust/src/backup.rs

@@ -228,12 +228,20 @@ pub fn create(
     let dir = id(seed);
     let files = bitbox02::sd::list_subdir(Some(&dir)).or(Err(Error::SdList))?;
 
+    let filename_datetime = {
+        let tm = bitbox02::get_datetime(backup_create_timestamp).map_err(|_| Error::Generic)?;
+        format!(
+            "{}_{}T{}-{}-{}Z",
+            tm.weekday(),
+            tm.date(),
+            tm.hour(),
+            tm.minute(),
+            tm.second()
+        )
+    };
+
     for i in 0..3 {
-        let filename = format!(
-            "backup_{}_{}.bin",
-            bitbox02::strftime(backup_create_timestamp, "%a_%Y-%m-%dT%H-%M-%SZ"),
-            i,
-        );
+        let filename = format!("backup_{}_{}.bin", filename_datetime, i,);
         // Timestamp must be different from an existing backup when recreating a backup, otherwise
         // we might end up corrupting the existing backup.
         if files.contains(&filename) {

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

@@ -373,7 +373,7 @@ mod tests {
                     UI_COUNTER += 1;
                     UI_COUNTER
                 } {
-                    1 => assert_eq!(params.body, "<date>"),
+                    1 => assert_eq!(params.body, "Mon 2020-09-28"),
                     2 => assert_eq!(params.body, "Proceed to upgrade?"),
                     _ => panic!("too many dialogs"),
                 }
@@ -467,7 +467,7 @@ mod tests {
                         UI_COUNTER += 1;
                         UI_COUNTER
                     } {
-                        1 => assert_eq!(params.body, "<date>"),
+                        1 => assert_eq!(params.body, "Mon 2020-09-28"),
                         2 => assert_eq!(params.title, "RESET"),
                         3 => assert_eq!(params.body, "Restore backup?"),
                         4 => assert!(params.body.starts_with("Name: test device name.")),

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

@@ -75,16 +75,10 @@ pub async fn create(
         timezone_offset,
     }: &pb::CreateBackupRequest,
 ) -> Result<Response, Error> {
-    const MAX_EAST_UTC_OFFSET: i32 = 50400; // 14 hours in seconds
-    const MAX_WEST_UTC_OFFSET: i32 = -43200; // 12 hours in seconds
-
-    if !(MAX_WEST_UTC_OFFSET..=MAX_EAST_UTC_OFFSET).contains(&timezone_offset) {
-        return Err(Error::InvalidInput);
-    }
-
     confirm::confirm(&confirm::Params {
         title: "Is today?",
-        body: &bitbox02::format_datetime(timestamp, timezone_offset, true),
+        body: &bitbox02::format_datetime(timestamp, timezone_offset, true)
+            .map_err(|_| Error::InvalidInput)?,
         ..Default::default()
     })
     .await?;
@@ -174,7 +168,7 @@ mod tests {
         mock(Data {
             sdcard_inserted: Some(true),
             ui_confirm_create: Some(Box::new(|params| {
-                assert_eq!(params.body, "<date>");
+                assert_eq!(params.body, "Mon 2020-09-28");
                 true
             })),
             ..Default::default()

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

@@ -47,7 +47,8 @@ pub async fn from_file(request: &pb::RestoreBackupRequest) -> Result<Response, E
     #[cfg(feature = "app-u2f")]
     {
         let datetime_string =
-            bitbox02::format_datetime(request.timestamp, request.timezone_offset, false);
+            bitbox02::format_datetime(request.timestamp, request.timezone_offset, false)
+                .map_err(|_| Error::InvalidInput)?;
         let params = confirm::Params {
             title: "Is now?",
             body: &datetime_string,
@@ -92,7 +93,8 @@ pub async fn from_mnemonic(
 ) -> Result<Response, Error> {
     #[cfg(feature = "app-u2f")]
     {
-        let datetime_string = bitbox02::format_datetime(timestamp, timezone_offset, false);
+        let datetime_string = bitbox02::format_datetime(timestamp, timezone_offset, false)
+            .map_err(|_| Error::InvalidInput)?;
         confirm::confirm(&confirm::Params {
             title: "Is now?",
             body: &datetime_string,

src/rust/bitbox02/src/lib.rs

@@ -48,6 +48,7 @@ pub mod secp256k1;
 pub mod securechip;
 pub mod ui;
 
+use ::util::c_types::c_int;
 use core::time::Duration;
 
 pub use bitbox02_sys::buffer_t;
@@ -116,45 +117,103 @@ pub fn reset(status: bool) {
     unsafe { bitbox02_sys::reset_reset(status) }
 }
 
-pub fn strftime(timestamp: u32, format: &str) -> String {
-    let mut out = [0u8; 100];
-    unsafe {
-        bitbox02_sys::strftime(
-            out.as_mut_ptr(),
-            out.len() as _,
-            crate::util::str_to_cstr_vec(format).unwrap().as_ptr(),
-            bitbox02_sys::localtime(&(timestamp as bitbox02_sys::time_t)),
-        );
-    }
-    crate::util::str_from_null_terminated(&out[..])
-        .unwrap()
-        .into()
+pub struct Tm {
+    tm: bitbox02_sys::tm,
 }
 
-#[cfg(not(feature = "testing"))]
-pub fn format_datetime(timestamp: u32, timezone_offset: i32, date_only: bool) -> String {
-    let mut out = [0u8; 100];
-    unsafe {
-        bitbox02_sys::util_format_datetime(
-            timestamp,
-            timezone_offset,
-            date_only,
-            out.as_mut_ptr(),
-            out.len() as _,
+fn range(low: c_int, item: c_int, high: c_int) -> c_int {
+    core::cmp::max(low, core::cmp::min(item, high))
+}
+
+impl Tm {
+    /// Returns the weekday, one of "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+    pub fn weekday(&self) -> String {
+        // Same as '%a' in strftime:
+        // https://github.com/arnoldrobbins/strftime/blob/2011b7e82365d25220b8949e252eb5f28c0994cd/strftime.c#435
+        let wday = self.tm.tm_wday;
+        if !(0..=6).contains(&wday) {
+            return "?".into();
+        }
+        ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][wday as usize].into()
+    }
+
+    /// Returns 'year-month-day', e.g. 2024-07-16, equivalent of '%Y-%m-%d' in strftime.
+    pub fn date(&self) -> String {
+        // Same as strftime:
+        // %Y - https://github.com/arnoldrobbins/strftime/blob/2011b7e82365d25220b8949e252eb5f28c0994cd/strftime.c#L712
+        // %m - https://github.com/arnoldrobbins/strftime/blob/2011b7e82365d25220b8949e252eb5f28c0994cd/strftime.c#L600
+        // %d - https://github.com/arnoldrobbins/strftime/blob/2011b7e82365d25220b8949e252eb5f28c0994cd/strftime.c#L498
+        format!(
+            "{}-{:02}-{:02}",
+            1900 + self.tm.tm_year,
+            range(0, self.tm.tm_mon, 11) + 1,
+            range(1, self.tm.tm_mday, 31)
         )
     }
-    crate::util::str_from_null_terminated(&out[..])
-        .unwrap()
-        .into()
+
+    /// Returns the zero-padded hour from 00-23, e.g. "07".
+    pub fn hour(&self) -> String {
+        // Same as '%H' in strftime:
+        // https://github.com/arnoldrobbins/strftime/blob/2011b7e82365d25220b8949e252eb5f28c0994cd/strftime.c#582
+        format!("{:02}", range(0, self.tm.tm_hour, 23))
+    }
+
+    /// Returns the zero-padded minute from 00-59, e.g. "07".
+    pub fn minute(&self) -> String {
+        // Same as '%M' in strftime:
+        // https://github.com/arnoldrobbins/strftime/blob/2011b7e82365d25220b8949e252eb5f28c0994cd/strftime.c#L605
+        format!("{:02}", range(0, self.tm.tm_min, 59))
+    }
+
+    /// Returns the zero-padded second from 00-60, e.g. "07".
+    pub fn second(&self) -> String {
+        // Same as '%S' in strftime:
+        // https://github.com/arnoldrobbins/strftime/blob/2011b7e82365d25220b8949e252eb5f28c0994cd/strftime.c#L645
+        format!("{:02}", range(0, self.tm.tm_sec, 60))
+    }
 }
 
-#[cfg(feature = "testing")]
-pub fn format_datetime(_timestamp: u32, _timezone_offset: i32, date_only: bool) -> String {
-    if date_only {
-        "<date>".into()
-    } else {
-        "<datetime>".into()
+pub fn get_datetime(timestamp: u32) -> Result<Tm, ()> {
+    Ok(Tm {
+        tm: unsafe {
+            let localtime = bitbox02_sys::localtime(&(timestamp as bitbox02_sys::time_t));
+            if localtime.is_null() {
+                return Err(());
+            }
+
+            *localtime
+        },
+    })
+}
+
+/// Formats the timestamp in the local timezone.
+/// timestamp is the unix timestamp in seconds.
+/// timezone_offset is added to the timestamp, timezone part.
+/// date_only: if true, only the date is formatted. If false, both date and time are.
+pub fn format_datetime(
+    timestamp: u32,
+    timezone_offset: i32,
+    date_only: bool,
+) -> Result<String, ()> {
+    const MAX_EAST_UTC_OFFSET: i32 = 50400; // 14 hours in seconds
+    const MAX_WEST_UTC_OFFSET: i32 = -43200; // 12 hours in seconds
+
+    if !(MAX_WEST_UTC_OFFSET..=MAX_EAST_UTC_OFFSET).contains(&timezone_offset) {
+        return Err(());
     }
+    let ts = ((timestamp as i64) + (timezone_offset as i64)) as u32;
+    let tm = get_datetime(ts)?;
+    Ok(if date_only {
+        format!("{} {}", tm.weekday(), tm.date())
+    } else {
+        format!(
+            "{} {}\n{}:{}",
+            tm.weekday(),
+            tm.date(),
+            tm.hour(),
+            tm.minute()
+        )
+    })
 }
 
 #[cfg(not(feature = "testing"))]
@@ -201,10 +260,25 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_strftime() {
+    fn test_format_datetime() {
         assert_eq!(
-            strftime(1601281809, "%a %Y-%m-%d\n%H:%M").as_str(),
-            "Mon 2020-09-28\n08:30",
+            format_datetime(1601281809, 0, true),
+            Ok("Mon 2020-09-28".into())
         );
+        assert_eq!(
+            format_datetime(1601281809, 0, false),
+            Ok("Mon 2020-09-28\n08:30".into()),
+        );
+        assert_eq!(
+            format_datetime(1601281809, 18000, false),
+            Ok("Mon 2020-09-28\n13:30".into()),
+        );
+        assert_eq!(
+            format_datetime(1601281809, -32400, false),
+            Ok("Sun 2020-09-27\n23:30".into()),
+        );
+
+        assert!(format_datetime(1601281809, 50401, false).is_err());
+        assert!(format_datetime(1601281809, -43201, false).is_err());
     }
 }

src/util.c

@@ -68,15 +68,3 @@ void util_cleanup_64(uint8_t** buf)
 {
     util_zero(*buf, 64);
 }
-
-void util_format_datetime(
-    uint32_t timestamp,
-    int32_t timezone_offset,
-    bool date_only,
-    char* out,
-    size_t out_size)
-{
-    time_t local_timestamp = timestamp + timezone_offset;
-    struct tm* local_time = localtime(&local_timestamp);
-    strftime(out, out_size, date_only ? "%a %Y-%m-%d" : "%a %Y-%m-%d\n%H:%M", local_time);
-}

src/util.h

@@ -145,18 +145,4 @@ typedef struct {
  */
 typedef enum { ASYNC_OP_TRUE, ASYNC_OP_FALSE, ASYNC_OP_NOT_READY } async_op_result_t;
 
-/**
- * Formats the timestamp in the local timezone.
- * @param[in] timestamp unix timestamp in seconds.
- * @param[in] timezone_offset is added to the timestamp, timezone part.
- * @param[in] date_only if true, only the date is formatted. If false, both date and time are
- * formatted.
- */
-void util_format_datetime(
-    uint32_t timestamp,
-    int32_t timezone_offset,
-    bool date_only,
-    char* out,
-    size_t out_size);
-
 #endif

test/unit-test/test_util.c

@@ -50,27 +50,10 @@ static void test_minmax(void** state)
     assert_int_not_equal(res, 5);
 }
 
-static void test_util_format_datetime(void** state)
-{
-    char out[100];
-    util_format_datetime(1601281809, 0, true, out, sizeof(out));
-    assert_string_equal(out, "Mon 2020-09-28");
-
-    util_format_datetime(1601281809, 0, false, out, sizeof(out));
-    assert_string_equal(out, "Mon 2020-09-28\n08:30");
-
-    util_format_datetime(1601281809, 18000, false, out, sizeof(out));
-    assert_string_equal(out, "Mon 2020-09-28\n13:30");
-
-    util_format_datetime(1601281809, -32400, false, out, sizeof(out));
-    assert_string_equal(out, "Sun 2020-09-27\n23:30");
-}
-
 int main(void)
 {
     const struct CMUnitTest tests[] = {
         cmocka_unit_test(test_minmax),
-        cmocka_unit_test(test_util_format_datetime),
     };
     return cmocka_run_group_tests(tests, NULL, NULL);
 }