1 files changed, 10 insertions, 44 deletions

diff --git a/rustables/src/expr/immediate.rs b/rustables/src/expr/immediate.rs
index 1196211..b5be101 100644
--- a/rustables/src/expr/immediate.rs
+++ b/rustables/src/expr/immediate.rs
@@ -1,7 +1,6 @@
-use super::{Expression, Register, Rule, ToSlice};
+use super::{DeserializationError, Expression, Register, Rule, ToSlice};
 use rustables_sys as sys;
 use std::ffi::c_void;
-use std::mem::size_of_val;
 use std::os::raw::c_char;
 
 /// An immediate expression. Used to set immediate data.
@@ -33,11 +32,12 @@ impl<T: ToSlice> Expression for Immediate<T> {
                 self.register.to_raw(),
             );
 
+            let data = self.data.to_slice();
             sys::nftnl_expr_set(
                 expr,
                 sys::NFTNL_EXPR_IMM_DATA as u16,
-                &self.data.to_slice() as *const _ as *const c_void,
-                size_of_val(&self.data) as u32,
+                data.as_ptr() as *const c_void,
+                data.len() as u32,
             );
 
             expr
@@ -54,7 +54,7 @@ impl<const N: usize> Expression for Immediate<[u8; N]> {
     // be *extremely* dangerous in terms of memory safety,
     // rustables only accept to deserialize expressions with variable-size data
     // to arrays of bytes, so that the memory layout cannot be invalid.
-    fn from_expr(expr: *const sys::nftnl_expr) -> Option<Self> {
+    fn from_expr(expr: *const sys::nftnl_expr) -> Result<Self, DeserializationError> {
         unsafe {
             let ref_len = std::mem::size_of::<[u8; N]>() as u32;
             let mut data_len = 0;
@@ -65,10 +65,9 @@ impl<const N: usize> Expression for Immediate<[u8; N]> {
             );
 
             if data.is_null() {
-                return None;
+                return Err(DeserializationError::NullPointer);
             } else if data_len != ref_len {
-                debug!("Invalid size requested for deserializing an 'immediate' expression: expected {} bytes, got {}", ref_len, data_len);
-                return None;
+                return Err(DeserializationError::InvalidDataSize);
             }
 
             let data = *(data as *const [u8; N]);
@@ -76,9 +75,9 @@ impl<const N: usize> Expression for Immediate<[u8; N]> {
             let register = Register::from_raw(sys::nftnl_expr_get_u32(
                 expr,
                 sys::NFTNL_EXPR_IMM_DREG as u16,
-            ));
+            ))?;
 
-            register.map(|register| Immediate { data, register })
+            Ok(Immediate { data, register })
         }
     }
 
@@ -86,44 +85,11 @@ impl<const N: usize> Expression for Immediate<[u8; N]> {
     fn to_expr(&self, rule: &Rule) -> *mut sys::nftnl_expr {
         Immediate {
             register: self.register,
-            data: self.data.as_ref(),
+            data: &self.data as &[u8],
         }
         .to_expr(rule)
     }
 }
-// As casting bytes to any type of the same size as the input would
-// be *extremely* dangerous in terms of memory safety,
-// rustables only accept to deserialize expressions with variable-size data
-// to arrays of bytes, so that the memory layout cannot be invalid.
-impl<const N: usize> Immediate<[u8; N]> {
-    pub fn from_expr(expr: *const sys::nftnl_expr) -> Option<Self> {
-        unsafe {
-            let ref_len = std::mem::size_of::<[u8; N]>() as u32;
-            let mut data_len = 0;
-            let data = sys::nftnl_expr_get(
-                expr,
-                sys::NFTNL_EXPR_IMM_DATA as u16,
-                &mut data_len as *mut u32,
-            );
-
-            if data.is_null() {
-                return None;
-            } else if data_len != ref_len {
-                debug!("Invalid size requested for deserializing an 'immediate' expression: expected {} bytes, got {}", ref_len, data_len);
-                return None;
-            }
-
-            let data = *(data as *const [u8; N]);
-
-            let register = Register::from_raw(sys::nftnl_expr_get_u32(
-                expr,
-                sys::NFTNL_EXPR_IMM_DREG as u16,
-            ));
-
-            register.map(|register| Immediate { data, register })
-        }
-    }
-}
 
 #[macro_export]
 macro_rules! nft_expr_immediate {