opt: optee-utee: format files

ivila · ivila · commit 5ae842d09708 · 2026-01-09T19:20:40.000+08:00
diff --git a/optee-utee/optee-utee-sys/src/tee_isocket.rs b/optee-utee/optee-utee-sys/src/tee_isocket.rs
@@ -54,7 +54,7 @@ pub struct TEE_iSocket_s {
 }
 
 pub const TEE_ISOCKET_VERSION: u32 = 0x01000000;
- 
+
 pub const TEE_ISOCKET_ERROR_PROTOCOL: u32 = 0xF1007001;
 pub const TEE_ISOCKET_ERROR_REMOTE_CLOSED: u32 = 0xF1007002;
 pub const TEE_ISOCKET_ERROR_TIMEOUT: u32 = 0xF1007003;
diff --git a/optee-utee/optee-utee-sys/src/tee_tcpsocket.rs b/optee-utee/optee-utee-sys/src/tee_tcpsocket.rs
@@ -30,7 +30,6 @@ extern "C" {
     pub static TEE_tcpSocket: *const TEE_iSocket;
 }
 
-
 pub const TEE_ISOCKET_PROTOCOLID_TCP: u32 = 0x65;
 pub const TEE_ISOCKET_TCP_WARNING_UNKNOWN_OUT_OF_BAND: u32 = 0xF1010002;
 
diff --git a/optee-utee/optee-utee-sys/src/user_ta_header.rs b/optee-utee/optee-utee-sys/src/user_ta_header.rs
@@ -15,10 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use core::ffi::*;
 use super::tee_api_types::*;
 use super::utee_syscalls::*;
 use super::utee_types::*;
+use core::ffi::*;
 
 pub const TA_FLAG_SINGLE_INSTANCE: u32 = 1 << 2;
 pub const TA_FLAG_MULTI_SESSION: u32 = 1 << 3;
@@ -38,7 +38,12 @@ pub struct ta_head {
 }
 
 extern "C" {
-    pub fn __utee_entry(func: c_ulong, session_id: c_ulong, up: *mut utee_params, cmd_id: c_ulong) -> TEE_Result;
+    pub fn __utee_entry(
+        func: c_ulong,
+        session_id: c_ulong,
+        up: *mut utee_params,
+        cmd_id: c_ulong,
+    ) -> TEE_Result;
 }
 
 /// # Safety
@@ -48,7 +53,12 @@ extern "C" {
 /// by the OP-TEE runtime environment. This function should never be called directly
 /// from user code - it is only exported for the OP-TEE OS loader.
 #[no_mangle]
-unsafe fn __ta_entry(func: c_ulong, session_id: c_ulong, up: *mut utee_params, cmd_id: c_ulong) -> ! {
+unsafe fn __ta_entry(
+    func: c_ulong,
+    session_id: c_ulong,
+    up: *mut utee_params,
+    cmd_id: c_ulong,
+) -> ! {
     let res: u32 = __utee_entry(func, session_id, up, cmd_id);
 
     _utee_return(res.into());
diff --git a/optee-utee/optee-utee-sys/src/utee_types.rs b/optee-utee/optee-utee-sys/src/utee_types.rs
@@ -55,10 +55,10 @@ pub struct utee_attribute {
 #[repr(C)]
 pub struct utee_object_info {
     obj_type: u32,
-	obj_size: u32,
-	max_obj_size: u32,
-	obj_usage: u32,
-	data_size: u32,
-	data_pos: u32,
-	handle_flags: u32,
+    obj_size: u32,
+    max_obj_size: u32,
+    obj_usage: u32,
+    data_size: u32,
+    data_pos: u32,
+    handle_flags: u32,
 }
diff --git a/optee-utee/src/arithmetical.rs b/optee-utee/src/arithmetical.rs
@@ -16,10 +16,10 @@
 // under the License.
 
 use crate::{Error, Result};
-use optee_utee_sys as raw;
-use core::{cmp::max, fmt};
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
+use core::{cmp::max, fmt};
+use optee_utee_sys as raw;
 
 pub type BigIntUnit = u32;
 pub type BigIntFMMUnit = u32;
@@ -274,9 +274,7 @@ impl BigIntFMMContext {
     pub fn new(bits: u32, modulus: BigInt) -> Result<Self> {
         let size: usize = Self::size_in_u32(bits as usize);
         let mut tmp_vec: Vec<BigIntFMMContextUnit> = vec![0; size];
-        unsafe {
-            raw::TEE_BigIntInitFMMContext(tmp_vec.as_mut_ptr(), size, modulus.data_ptr())
-        };
+        unsafe { raw::TEE_BigIntInitFMMContext(tmp_vec.as_mut_ptr(), size, modulus.data_ptr()) };
         Ok(Self(tmp_vec))
     }
 }
diff --git a/optee-utee/src/crypto_op.rs b/optee-utee/src/crypto_op.rs
@@ -621,9 +621,7 @@ impl Cipher {
                 &mut dest_size,
             )
         } {
-            raw::TEE_SUCCESS => {
-                Ok(dest_size)
-            }
+            raw::TEE_SUCCESS => Ok(dest_size),
             code => Err(Error::from_raw_error(code)),
         }
     }
@@ -742,7 +740,11 @@ impl Cipher {
     /// 6) If operation is not in initial state.
     /// 7) Hardware or cryptographic algorithm failure.
     /// 8) If the Implementation detects any other error.
-    pub fn set_key_2<T: GenericObject, D: GenericObject>(&self, object1: &T, object2: &D) -> Result<()> {
+    pub fn set_key_2<T: GenericObject, D: GenericObject>(
+        &self,
+        object1: &T,
+        object2: &D,
+    ) -> Result<()> {
         match unsafe {
             raw::TEE_SetOperationKey2(self.handle(), object1.handle(), object2.handle())
         } {
@@ -1067,9 +1069,7 @@ impl AE {
                 &mut dest_size,
             )
         } {
-            raw::TEE_SUCCESS => {
-                Ok(dest_size)
-            }
+            raw::TEE_SUCCESS => Ok(dest_size),
             code => Err(Error::from_raw_error(code)),
         }
     }
@@ -1155,9 +1155,7 @@ impl AE {
                 &mut tag_size,
             )
         } {
-            raw::TEE_SUCCESS => {
-                Ok((dest_size, tag_size))
-            }
+            raw::TEE_SUCCESS => Ok((dest_size, tag_size)),
             code => Err(Error::from_raw_error(code)),
         }
     }
@@ -1198,9 +1196,7 @@ impl AE {
                 tag.len(),
             )
         } {
-            raw::TEE_SUCCESS => {
-                Ok(dest_size)
-            }
+            raw::TEE_SUCCESS => Ok(dest_size),
             code => Err(Error::from_raw_error(code)),
         }
     }
@@ -1417,9 +1413,7 @@ impl Asymmetric {
                 &mut signature_size,
             )
         } {
-            raw::TEE_SUCCESS => {
-                Ok(signature_size)
-            }
+            raw::TEE_SUCCESS => Ok(signature_size),
             code => Err(Error::from_raw_error(code)),
         }
     }
diff --git a/optee-utee/src/net/optee.rs b/optee-utee/src/net/optee.rs
@@ -41,25 +41,25 @@ impl Setup {
         })
     }
     /// Construct a new IPv4 target parameter using the address and port. It
-    /// will return `BadParameters` if the address contains a `\0` character in 
+    /// will return `BadParameters` if the address contains a `\0` character in
     /// the middle.
     pub fn new_v4(addr: &str, port: u16) -> crate::Result<Self> {
         Self::new(addr, port, raw::TEE_ipSocket_ipVersion::TEE_IP_VERSION_4)
     }
     /// Construct a new IPv6 target parameter using the address and port. It
-    /// will return `BadParameters` if the address contains a `\0` character in 
+    /// will return `BadParameters` if the address contains a `\0` character in
     /// the middle.
     pub fn new_v6(addr: &str, port: u16) -> crate::Result<Self> {
         Self::new(addr, port, raw::TEE_ipSocket_ipVersion::TEE_IP_VERSION_6)
     }
 }
 
-/// An adapter for TCP sockets in OP-TEE. Typically, it is not used directly, 
-/// but can be employed for wrapper operations, such as traffic control within 
+/// An adapter for TCP sockets in OP-TEE. Typically, it is not used directly,
+/// but can be employed for wrapper operations, such as traffic control within
 /// the TEE.
 pub struct TcpAdapter(raw::TEE_iSocketHandle);
-/// An adapter for UDP sockets in OP-TEE. Typically, it is not used directly, 
-/// but can be employed for wrapper operations, such as traffic control within 
+/// An adapter for UDP sockets in OP-TEE. Typically, it is not used directly,
+/// but can be employed for wrapper operations, such as traffic control within
 /// the TEE.
 pub struct UdpAdapter(raw::TEE_iSocketHandle);
 /// A TcpStream that is compatible with OP-TEE.
@@ -108,12 +108,7 @@ impl SocketAdapter for TcpAdapter {
     fn send(handle: &mut Self::Handle, buf: &[u8], timeout: u32) -> Result<usize, SocketError> {
         let mut length: u32 = buf.len() as _;
         let ret = unsafe {
-            ((*raw::TEE_tcpSocket).send)(
-                handle.0,
-                buf.as_ptr() as _,
-                &mut length,
-                timeout,
-            )
+            ((*raw::TEE_tcpSocket).send)(handle.0, buf.as_ptr() as _, &mut length, timeout)
         };
         match ret {
             raw::TEE_SUCCESS => Ok(length as usize),
@@ -168,12 +163,7 @@ impl SocketAdapter for UdpAdapter {
     fn send(handle: &mut Self::Handle, buf: &[u8], timeout: u32) -> Result<usize, SocketError> {
         let mut length: u32 = buf.len() as _;
         let ret = unsafe {
-            ((*raw::TEE_udpSocket).send)(
-                handle.0,
-                buf.as_ptr() as _,
-                &mut length,
-                timeout,
-            )
+            ((*raw::TEE_udpSocket).send)(handle.0, buf.as_ptr() as _, &mut length, timeout)
         };
         match ret {
             raw::TEE_SUCCESS => Ok(length as usize),
diff --git a/optee-utee/src/net/optee_no_std.rs b/optee-utee/src/net/optee_no_std.rs
@@ -16,7 +16,7 @@
 // under the License.
 use super::{Setup, Socket, SocketAdapter, SocketError};
 
-/// A trait used for convenience; import it so that the code remains consistent 
+/// A trait used for convenience; import it so that the code remains consistent
 /// with the std version (with the only difference being the return error type).
 ///
 /// Take TcpStream as example:
@@ -42,7 +42,7 @@ pub trait StdCompatConnect: Sized {
     }
 }
 
-/// A trait used for convenience; import it so that the code remains consistent 
+/// A trait used for convenience; import it so that the code remains consistent
 /// with the std version (with the only difference being the return error type).
 ///
 /// Take TcpStream as example:
@@ -81,7 +81,7 @@ pub trait StdCompatWrite {
     }
 }
 
-/// A trait used for convenience; import it so that the code remains consistent 
+/// A trait used for convenience; import it so that the code remains consistent
 /// with the std version (with the only difference being the return error type).
 ///
 /// Take TcpStream as example:
diff --git a/optee-utee/src/net/optee_std.rs b/optee-utee/src/net/optee_std.rs
@@ -106,7 +106,7 @@ impl std::io::Write for UdpSocket {
     }
 }
 
-// This is implemented to save developers from having to make numerous map_err 
+// This is implemented to save developers from having to make numerous map_err
 // calls.
 impl Into<std::io::Error> for SocketError {
     fn into(self) -> std::io::Error {
diff --git a/optee-utee/src/net/socket.rs b/optee-utee/src/net/socket.rs
@@ -20,7 +20,7 @@ use optee_utee_sys as raw;
 use super::SocketError;
 use core::time::Duration;
 
-/// A trait designed to accommodate various implementations of GP TEE Sockets 
+/// A trait designed to accommodate various implementations of GP TEE Sockets
 /// API.
 ///
 /// An implementation of this trait is responsible for handling all
@@ -62,16 +62,16 @@ impl<T: SocketAdapter> Socket<T> {
     pub fn set_send_timeout_in_milli(&mut self, milliseconds: u32) {
         self.send_timeout = milliseconds;
     }
-    /// a wrapper of `set_recv_timeout_in_milli`, similar to `set_read_timeout` 
-    /// in std::net::TcpStream, it will set timeout to `TEE_TIMEOUT_INFINITE` 
+    /// a wrapper of `set_recv_timeout_in_milli`, similar to `set_read_timeout`
+    /// in std::net::TcpStream, it will set timeout to `TEE_TIMEOUT_INFINITE`
     /// if `Option::None` is provided.
     pub fn set_recv_timeout(&mut self, dur: Option<Duration>) -> crate::Result<()> {
         let milliseconds = convert_duration_option_to_timeout(dur)?;
         self.set_recv_timeout_in_milli(milliseconds);
         Ok(())
     }
-    /// a wrapper of `set_send_timeout_in_milli`, similar to 
-    /// `set_write_timeout` in std::net::TcpStream, it will set timeout to 
+    /// a wrapper of `set_send_timeout_in_milli`, similar to
+    /// `set_write_timeout` in std::net::TcpStream, it will set timeout to
     /// `TEE_TIMEOUT_INFINITE` if `Option::None` is provided.
     pub fn set_send_timeout(&mut self, dur: Option<Duration>) -> crate::Result<()> {
         let milliseconds = convert_duration_option_to_timeout(dur)?;
diff --git a/optee-utee/src/object/enum_handle.rs b/optee-utee/src/object/enum_handle.rs
@@ -34,7 +34,8 @@ impl ObjectEnumHandle {
     /// Once an object enumerator has been allocated, it can be reused for
     /// multiple enumerations.
     pub fn allocate() -> Result<Self> {
-        let raw_handle: *mut raw::TEE_ObjectEnumHandle = Box::into_raw(Box::new(core::ptr::null_mut()));
+        let raw_handle: *mut raw::TEE_ObjectEnumHandle =
+            Box::into_raw(Box::new(core::ptr::null_mut()));
         match unsafe { raw::TEE_AllocatePersistentObjectEnumerator(raw_handle) } {
             raw::TEE_SUCCESS => Ok(Self { raw: raw_handle }),
             code => {
diff --git a/optee-utee/src/object/persistent_object.rs b/optee-utee/src/object/persistent_object.rs
@@ -534,7 +534,10 @@ impl GenericObject for PersistentObject {
 
 #[cfg(test)]
 mod tests {
-    use optee_utee_sys::{mock_api, mock_utils::{SERIAL_TEST_LOCK, object::MockHandle}};
+    use optee_utee_sys::{
+        mock_api,
+        mock_utils::{object::MockHandle, SERIAL_TEST_LOCK},
+    };
 
     use super::*;
 
@@ -549,10 +552,11 @@ mod tests {
         let fn1 = mock_api::TEE_CreatePersistentObject_context();
         let fn2 = mock_api::TEE_CloseObject_context();
 
-        fn1.expect().return_once_st(move |_, _, _, _, _, _, _, obj| {
-            unsafe { *obj = handle.clone() };
-            raw::TEE_SUCCESS
-        });
+        fn1.expect()
+            .return_once_st(move |_, _, _, _, _, _, _, obj| {
+                unsafe { *obj = handle.clone() };
+                raw::TEE_SUCCESS
+            });
         fn2.expect().return_once_st(move |obj| {
             debug_assert_eq!(obj, handle);
         });
@@ -598,11 +602,12 @@ mod tests {
         let handle = raw_handle.as_handle();
         let fn1 = mock_api::TEE_CreatePersistentObject_context();
         let fn2 = mock_api::TEE_CloseAndDeletePersistentObject1_context();
-       
-        fn1.expect().return_once_st(move |_, _, _, _, _, _, _, obj| {
-            unsafe { *obj = handle.clone() };
-            raw::TEE_SUCCESS
-        });
+
+        fn1.expect()
+            .return_once_st(move |_, _, _, _, _, _, _, obj| {
+                unsafe { *obj = handle.clone() };
+                raw::TEE_SUCCESS
+            });
         fn2.expect().return_once_st(move |obj| {
             debug_assert_eq!(obj, handle);
             raw::TEE_SUCCESS
@@ -631,10 +636,11 @@ mod tests {
         let fn1 = mock_api::TEE_CreatePersistentObject_context();
         let fn2 = mock_api::TEE_CloseAndDeletePersistentObject1_context();
 
-        fn1.expect().return_once_st(move |_, _, _, _, _, _, _, obj| {
-            unsafe { *obj = handle.clone() };
-            raw::TEE_SUCCESS
-        });
+        fn1.expect()
+            .return_once_st(move |_, _, _, _, _, _, _, obj| {
+                unsafe { *obj = handle.clone() };
+                raw::TEE_SUCCESS
+            });
         fn2.expect().return_once_st(move |obj| {
             debug_assert_eq!(obj, handle);
             raw::TEE_ERROR_BUSY
diff --git a/optee-utee/src/object/transient_object.rs b/optee-utee/src/object/transient_object.rs
@@ -384,7 +384,7 @@ impl GenericObject for TransientObject {
 mod tests {
     use optee_utee_sys::{
         mock_api,
-        mock_utils::{SERIAL_TEST_LOCK, object::MockHandle},
+        mock_utils::{object::MockHandle, SERIAL_TEST_LOCK},
     };
 
     use super::*;
diff --git a/optee-utee/src/parameter.rs b/optee-utee/src/parameter.rs
diff --git a/optee-utee/src/property.rs b/optee-utee/src/property.rs
diff --git a/optee-utee/src/time.rs b/optee-utee/src/time.rs
diff --git a/optee-utee/src/trace.rs b/optee-utee/src/trace.rs
diff --git a/optee-utee/src/uuid.rs b/optee-utee/src/uuid.rs

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ pub struct TEE_iSocket_s {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`pub const TEE_ISOCKET_VERSION: u32 = 0x01000000;`
`57`		`-`
	`57`	`+`
`58`	`58`	`pub const TEE_ISOCKET_ERROR_PROTOCOL: u32 = 0xF1007001;`
`59`	`59`	`pub const TEE_ISOCKET_ERROR_REMOTE_CLOSED: u32 = 0xF1007002;`
`60`	`60`	`pub const TEE_ISOCKET_ERROR_TIMEOUT: u32 = 0xF1007003;`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,6 @@ extern "C" {`
`30`	`30`	`pub static TEE_tcpSocket: *const TEE_iSocket;`
`31`	`31`	`}`
`32`	`32`
`33`		`-`
`34`	`33`	`pub const TEE_ISOCKET_PROTOCOLID_TCP: u32 = 0x65;`
`35`	`34`	`pub const TEE_ISOCKET_TCP_WARNING_UNKNOWN_OUT_OF_BAND: u32 = 0xF1010002;`
`36`	`35`
Original file line number	Diff line number	Diff line change
`@@ -621,9 +621,7 @@ impl Cipher {`
`621`	`621`	`&mut dest_size,`
`622`	`622`	`)`
`623`	`623`	`} {`
`624`		`- raw::TEE_SUCCESS => {`
`625`		`- Ok(dest_size)`
`626`		`- }`
	`624`	`+ raw::TEE_SUCCESS => Ok(dest_size),`
`627`	`625`	`code => Err(Error::from_raw_error(code)),`
`628`	`626`	`}`
`629`	`627`	`}`
`@@ -742,7 +740,11 @@ impl Cipher {`
`742`	`740`	`/// 6) If operation is not in initial state.`
`743`	`741`	`/// 7) Hardware or cryptographic algorithm failure.`
`744`	`742`	`/// 8) If the Implementation detects any other error.`
`745`		`- pub fn set_key_2<T: GenericObject, D: GenericObject>(&self, object1: &T, object2: &D) -> Result<()> {`
	`743`	`+ pub fn set_key_2<T: GenericObject, D: GenericObject>(`
	`744`	`+ &self,`
	`745`	`+ object1: &T,`
	`746`	`+ object2: &D,`
	`747`	`+ ) -> Result<()> {`
`746`	`748`	`match unsafe {`
`747`	`749`	`raw::TEE_SetOperationKey2(self.handle(), object1.handle(), object2.handle())`
`748`	`750`	`} {`
`@@ -1067,9 +1069,7 @@ impl AE {`
`1067`	`1069`	`&mut dest_size,`
`1068`	`1070`	`)`
`1069`	`1071`	`} {`
`1070`		`- raw::TEE_SUCCESS => {`
`1071`		`- Ok(dest_size)`
`1072`		`- }`
	`1072`	`+ raw::TEE_SUCCESS => Ok(dest_size),`
`1073`	`1073`	`code => Err(Error::from_raw_error(code)),`
`1074`	`1074`	`}`
`1075`	`1075`	`}`
`@@ -1155,9 +1155,7 @@ impl AE {`
`1155`	`1155`	`&mut tag_size,`
`1156`	`1156`	`)`
`1157`	`1157`	`} {`
`1158`		`- raw::TEE_SUCCESS => {`
`1159`		`- Ok((dest_size, tag_size))`
`1160`		`- }`
	`1158`	`+ raw::TEE_SUCCESS => Ok((dest_size, tag_size)),`
`1161`	`1159`	`code => Err(Error::from_raw_error(code)),`
`1162`	`1160`	`}`
`1163`	`1161`	`}`
`@@ -1198,9 +1196,7 @@ impl AE {`
`1198`	`1196`	`tag.len(),`
`1199`	`1197`	`)`
`1200`	`1198`	`} {`
`1201`		`- raw::TEE_SUCCESS => {`
`1202`		`- Ok(dest_size)`
`1203`		`- }`
	`1199`	`+ raw::TEE_SUCCESS => Ok(dest_size),`
`1204`	`1200`	`code => Err(Error::from_raw_error(code)),`
`1205`	`1201`	`}`
`1206`	`1202`	`}`
`@@ -1417,9 +1413,7 @@ impl Asymmetric {`
`1417`	`1413`	`&mut signature_size,`
`1418`	`1414`	`)`
`1419`	`1415`	`} {`
`1420`		`- raw::TEE_SUCCESS => {`
`1421`		`- Ok(signature_size)`
`1422`		`- }`
	`1416`	`+ raw::TEE_SUCCESS => Ok(signature_size),`
`1423`	`1417`	`code => Err(Error::from_raw_error(code)),`
`1424`	`1418`	`}`
`1425`	`1419`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`	`// under the License.`
`17`	`17`	`use super::{Setup, Socket, SocketAdapter, SocketError};`
`18`	`18`
`19`		`-/// A trait used for convenience; import it so that the code remains consistent`
	`19`	`+/// A trait used for convenience; import it so that the code remains consistent`
`20`	`20`	`/// with the std version (with the only difference being the return error type).`
`21`	`21`	`///`
`22`	`22`	`/// Take TcpStream as example:`
`@@ -42,7 +42,7 @@ pub trait StdCompatConnect: Sized {`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
`45`		`-/// A trait used for convenience; import it so that the code remains consistent`
	`45`	`+/// A trait used for convenience; import it so that the code remains consistent`
`46`	`46`	`/// with the std version (with the only difference being the return error type).`
`47`	`47`	`///`
`48`	`48`	`/// Take TcpStream as example:`
`@@ -81,7 +81,7 @@ pub trait StdCompatWrite {`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`-/// A trait used for convenience; import it so that the code remains consistent`
	`84`	`+/// A trait used for convenience; import it so that the code remains consistent`
`85`	`85`	`/// with the std version (with the only difference being the return error type).`
`86`	`86`	`///`
`87`	`87`	`/// Take TcpStream as example:`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ impl std::io::Write for UdpSocket {`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`
`109`		`-// This is implemented to save developers from having to make numerous map_err`
	`109`	`+// This is implemented to save developers from having to make numerous map_err`
`110`	`110`	`// calls.`
`111`	`111`	`impl Into<std::io::Error> for SocketError {`
`112`	`112`	`fn into(self) -> std::io::Error {`