Fix status message parsing on different kernels

src/status.rs

@@ -17,9 +17,11 @@ const RATE_LIMITING: Field = 16..20;
 const BACKLOG_LIMIT: Field = 20..24;
 const LOST: Field = 24..28;
 const BACKLOG: Field = 28..32;
+pub const MINIMAL_STATUS_MESSAGE_LEN: usize = BACKLOG.end;
 const FEATURE_BITMAP: Field = 32..36;
 const BACKLOG_WAIT_TIME: Field = 36..40;
-pub const STATUS_MESSAGE_LEN: usize = BACKLOG_WAIT_TIME.end;
+const BACKLOG_WAIT_TIME_ACTUAL: Field = 36..40;
+pub const MAXIMAL_STATUS_MESSAGE_LEN: usize = BACKLOG_WAIT_TIME_ACTUAL.end;
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
 #[non_exhaustive]
@@ -39,10 +41,15 @@ pub struct StatusMessage {
     pub lost: u32,
     /// Messages waiting in queue
     pub backlog: u32,
+
+    // Starting here, those fields may not be present in older kernels, hence
+    // the use of Option.
     /// bitmap of kernel audit features
-    pub feature_bitmap: u32,
+    pub feature_bitmap: Option<u32>,
     /// Message queue wait timeout
-    pub backlog_wait_time: u32,
+    pub backlog_wait_time: Option<u32>,
+    /// Time spent waiting while message limit exceeded
+    pub backlog_wait_time_actual: Option<u32>,
 }
 
 impl StatusMessage {
@@ -72,10 +79,10 @@ impl<T: AsRef<[u8]>> StatusMessageBuffer<T> {
 
     fn check_buffer_length(&self) -> Result<(), DecodeError> {
         let len = self.buffer.as_ref().len();
-        if len < STATUS_MESSAGE_LEN {
+        if len < MINIMAL_STATUS_MESSAGE_LEN {
             return Err(format!(
                 "invalid StatusMessageBuffer buffer: length is {len} \
-                instead of {STATUS_MESSAGE_LEN}"
+                instead of at least {MINIMAL_STATUS_MESSAGE_LEN}"
             )
             .into());
         }
@@ -118,12 +125,31 @@ impl<T: AsRef<[u8]>> StatusMessageBuffer<T> {
         NativeEndian::read_u32(&self.buffer.as_ref()[BACKLOG])
     }
 
-    pub fn feature_bitmap(&self) -> u32 {
-        NativeEndian::read_u32(&self.buffer.as_ref()[FEATURE_BITMAP])
+    pub fn feature_bitmap(&self) -> Option<u32> {
+        let buf = self.buffer.as_ref();
+        if buf.len() < FEATURE_BITMAP.end {
+            None
+        } else {
+            Some(NativeEndian::read_u32(&buf[FEATURE_BITMAP]))
+        }
     }
 
-    pub fn backlog_wait_time(&self) -> u32 {
-        NativeEndian::read_u32(&self.buffer.as_ref()[BACKLOG_WAIT_TIME])
+    pub fn backlog_wait_time(&self) -> Option<u32> {
+        let buf = self.buffer.as_ref();
+        if buf.len() < BACKLOG_WAIT_TIME.end {
+            None
+        } else {
+            Some(NativeEndian::read_u32(&buf[BACKLOG_WAIT_TIME]))
+        }
+    }
+
+    pub fn backlog_wait_time_actual(&self) -> Option<u32> {
+        let buf = self.buffer.as_ref();
+        if buf.len() < BACKLOG_WAIT_TIME_ACTUAL.end {
+            None
+        } else {
+            Some(NativeEndian::read_u32(&buf[BACKLOG_WAIT_TIME_ACTUAL]))
+        }
     }
 }
 
@@ -161,17 +187,24 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> StatusMessageBuffer<T> {
     }
 
     pub fn set_feature_bitmap(&mut self, value: u32) {
-        NativeEndian::write_u32(
-            &mut self.buffer.as_mut()[FEATURE_BITMAP],
-            value,
-        )
+        let buf = &mut self.buffer.as_mut();
+        if buf.len() >= FEATURE_BITMAP.end {
+            NativeEndian::write_u32(&mut buf[FEATURE_BITMAP], value)
+        }
     }
 
     pub fn set_backlog_wait_time(&mut self, value: u32) {
-        NativeEndian::write_u32(
-            &mut self.buffer.as_mut()[BACKLOG_WAIT_TIME],
-            value,
-        )
+        let buf = &mut self.buffer.as_mut();
+        if buf.len() >= BACKLOG_WAIT_TIME.end {
+            NativeEndian::write_u32(&mut buf[BACKLOG_WAIT_TIME], value)
+        }
+    }
+
+    pub fn set_backlog_wait_time_actual(&mut self, value: u32) {
+        let buf = &mut self.buffer.as_mut();
+        if buf.len() >= BACKLOG_WAIT_TIME_ACTUAL.end {
+            NativeEndian::write_u32(&mut buf[BACKLOG_WAIT_TIME_ACTUAL], value)
+        }
     }
 }
 
@@ -189,13 +222,14 @@ impl<T: AsRef<[u8]>> Parseable<StatusMessageBuffer<T>> for StatusMessage {
             backlog: buf.backlog(),
             feature_bitmap: buf.feature_bitmap(),
             backlog_wait_time: buf.backlog_wait_time(),
+            backlog_wait_time_actual: buf.backlog_wait_time_actual(),
         })
     }
 }
 
 impl Emitable for StatusMessage {
     fn buffer_len(&self) -> usize {
-        STATUS_MESSAGE_LEN
+        MAXIMAL_STATUS_MESSAGE_LEN
     }
 
     fn emit(&self, buffer: &mut [u8]) {
@@ -208,7 +242,14 @@ impl Emitable for StatusMessage {
         buffer.set_backlog_limit(self.backlog_limit);
         buffer.set_lost(self.lost);
         buffer.set_backlog(self.backlog);
-        buffer.set_feature_bitmap(self.feature_bitmap);
-        buffer.set_backlog_wait_time(self.backlog_wait_time);
+        if let Some(feature_bitmap) = self.feature_bitmap {
+            buffer.set_feature_bitmap(feature_bitmap);
+        }
+        if let Some(backlog_wait_time) = self.backlog_wait_time {
+            buffer.set_backlog_wait_time(backlog_wait_time);
+        }
+        if let Some(backlog_wait_time_actual) = self.backlog_wait_time_actual {
+            buffer.set_backlog_wait_time_actual(backlog_wait_time_actual);
+        }
     }
 }