allow unknown bits for forward compatibility (#485)

* allow unknown bits for forward compatibility

Fixes #484

Signed-off-by: Onur Özkan <work@onurozkan.dev>

* remove ParseError::InvalidFlag

Signed-off-by: Onur Özkan <work@onurozkan.dev>

---------

Signed-off-by: Onur Özkan <work@onurozkan.dev>

Author: onur-ozkan

mavlink-bindgen/src/parser.rs

@@ -1200,8 +1200,8 @@ impl MavField {
                     let enum_name_ident = format_ident!("{}", enum_name);
                     quote! {
                         #tmp
-                        #name = #enum_name_ident::from_bits(tmp as <#enum_name_ident as Flags>::Bits)
-                            .ok_or(::mavlink_core::error::ParserError::InvalidFlag { flag_type: #enum_name, value: tmp as u64 })?;
+                        // Keep unknown bits for forward compatibility.
+                        #name = #enum_name_ident::from_bits_retain(tmp as <#enum_name_ident as Flags>::Bits);
                     }
                 } else {
                     panic!("Display option not implemented");

mavlink-bindgen/tests/snapshots/e2e_snapshots__mav_bool.xml@mav_bool.rs.snap

@@ -90,19 +90,9 @@ impl MessageData for BOOL_TEST_MESSAGE_DATA {
         };
         let mut __struct = Self::default();
         let tmp = buf.get_u8()?;
-        __struct.bool_uint8 = MavBool::from_bits(tmp as <MavBool as Flags>::Bits).ok_or(
-            ::mavlink_core::error::ParserError::InvalidFlag {
-                flag_type: "MavBool",
-                value: tmp as u64,
-            },
-        )?;
+        __struct.bool_uint8 = MavBool::from_bits_retain(tmp as <MavBool as Flags>::Bits);
         let tmp = buf.get_i8()?;
-        __struct.bool_int8 = MavBool::from_bits(tmp as <MavBool as Flags>::Bits).ok_or(
-            ::mavlink_core::error::ParserError::InvalidFlag {
-                flag_type: "MavBool",
-                value: tmp as u64,
-            },
-        )?;
+        __struct.bool_int8 = MavBool::from_bits_retain(tmp as <MavBool as Flags>::Bits);
         Ok(__struct)
     }
     fn ser(&self, version: MavlinkVersion, bytes: &mut [u8]) -> usize {

mavlink-core/src/error.rs

@@ -6,8 +6,6 @@ use std::error::Error;
 /// Error while parsing a MAVLink message
 #[derive(Debug)]
 pub enum ParserError {
-    /// Bit flag for this type is invalid
-    InvalidFlag { flag_type: &'static str, value: u64 },
     /// Enum value for this enum type does not exist
     InvalidEnum { enum_type: &'static str, value: u64 },
     /// Message ID does not exist in this message set
@@ -25,10 +23,6 @@ impl From<bytes::Error> for ParserError {
 impl Display for ParserError {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         match self {
-            Self::InvalidFlag { flag_type, value } => write!(
-                f,
-                "Invalid flag value for flag type {flag_type:?}, got {value:?}"
-            ),
             Self::InvalidEnum { enum_type, value } => write!(
                 f,
                 "Invalid enum value for enum type {enum_type:?}, got {value:?}"

mavlink-core/src/lib.rs

@@ -232,7 +232,6 @@ pub trait MessageData: Sized {
     /// # Errors
     ///
     /// Will return [`ParserError::InvalidEnum`] on a nonexistent enum value and
-    /// [`ParserError::InvalidFlag`] on an invalid bitflag value
     fn deser(version: MavlinkVersion, payload: &[u8]) -> Result<Self, ParserError>;
 }
 

mavlink/tests/invalid_value_test.rs

@@ -3,7 +3,7 @@ mod test_shared;
 #[cfg(feature = "dialect-common")]
 mod helper_tests {
     use mavlink::{
-        MavlinkVersion, MessageData, calculate_crc,
+        MessageData, calculate_crc,
         dialects::common::MavMessage,
         error::{MessageReadError, ParserError},
         peek_reader::PeekReader,
@@ -38,36 +38,36 @@ mod helper_tests {
     }
 
     #[test]
-    fn test_invalid_bitflag() {
-        use mavlink::dialects::common::HIL_ACTUATOR_CONTROLS_DATA;
+    fn test_unknown_bitflag_bits_are_preserved() {
+        use mavlink::dialects::common::{
+            MavFrame, PositionTargetTypemask, SET_POSITION_TARGET_GLOBAL_INT_DATA,
+        };
 
-        let msg = HIL_ACTUATOR_CONTROLS_DATA::DEFAULT;
-        let mut invalid_flag_buf = [0; 1 + 9 + HIL_ACTUATOR_CONTROLS_DATA::ENCODED_LEN + 2];
-        let len = msg.ser(
-            MavlinkVersion::V2,
-            &mut invalid_flag_buf[10..10 + HIL_ACTUATOR_CONTROLS_DATA::ENCODED_LEN],
-        );
-        invalid_flag_buf[0] = mavlink::MAV_STX_V2;
-        invalid_flag_buf[1] = len as u8;
-        invalid_flag_buf[7] = HIL_ACTUATOR_CONTROLS_DATA::ID as u8;
-        // set flags to an invalid HilActuatorControlsFlags value
-        invalid_flag_buf[1 + 9 + 8..1 + 9 + 16].copy_from_slice(&u64::MAX.to_le_bytes());
-        // update crc
-        let crc = calculate_crc(
-            &invalid_flag_buf[1..1 + 9 + len],
-            HIL_ACTUATOR_CONTROLS_DATA::EXTRA_CRC,
-        );
-        invalid_flag_buf[1 + 9 + len..1 + 9 + len + 2].copy_from_slice(&crc.to_le_bytes());
+        let send_msg = SET_POSITION_TARGET_GLOBAL_INT_DATA {
+            coordinate_frame: MavFrame::MAV_FRAME_GLOBAL,
+            // Regression test for https://github.com/mavlink/rust-mavlink/issues/484
+            type_mask: PositionTargetTypemask::from_bits_retain(65016),
+            ..SET_POSITION_TARGET_GLOBAL_INT_DATA::DEFAULT
+        };
 
-        let result = mavlink::read_v2_msg::<MavMessage, _>(&mut PeekReader::new(
-            invalid_flag_buf.as_slice(),
-        ));
-        assert!(matches!(
-            result,
-            Err(MessageReadError::Parse(ParserError::InvalidFlag {
-                flag_type: "HilActuatorControlsFlags",
-                value: u64::MAX
-            }))
-        ));
+        let mut buffer = [0u8; 280];
+        let mut writer: &mut [u8] = &mut buffer;
+
+        mavlink::write_v2_msg(
+            &mut writer,
+            crate::test_shared::COMMON_MSG_HEADER,
+            &MavMessage::SET_POSITION_TARGET_GLOBAL_INT(send_msg),
+        )
+        .expect("failed to serialize SET_POSITION_TARGET_GLOBAL_INT");
+
+        let mut reader = PeekReader::new(buffer.as_slice());
+        let (_header, recv_msg) = mavlink::read_v2_msg::<MavMessage, _>(&mut reader)
+            .expect("failed to parse SET_POSITION_TARGET_GLOBAL_INT with unknown bitmask bits");
+
+        let MavMessage::SET_POSITION_TARGET_GLOBAL_INT(recv_msg) = recv_msg else {
+            panic!("decoded wrong message type");
+        };
+
+        assert_eq!(recv_msg.type_mask.bits(), 65016);
     }
 }