use bitflags for TcU32OptionsFlags

Author: little-dude

src/tc/filters/cls_u32.rs

@@ -16,8 +16,8 @@ use netlink_packet_utils::{
     DecodeError,
 };
 
-use super::u32_flags::{VecTcU32OptionFlag, VecTcU32SelectorFlag};
-use crate::tc::{TcAction, TcHandle, TcU32OptionFlag, TcU32SelectorFlag};
+use super::u32_flags::{TcU32OptionFlags, VecTcU32SelectorFlag};
+use crate::tc::{TcAction, TcHandle, TcU32SelectorFlag};
 
 const TC_U32_SEL_BUF_LEN: usize = 16;
 const TC_U32_KEY_BUF_LEN: usize = 16;
@@ -55,7 +55,7 @@ pub enum TcFilterU32Option {
     Indev(Vec<u8>),
     Pnct(Vec<u8>),
     Mark(Vec<u8>),
-    Flags(Vec<TcU32OptionFlag>),
+    Flags(TcU32OptionFlags),
     Other(DefaultNla),
 }
 
@@ -86,10 +86,7 @@ impl Nla for TcFilterU32Option {
             Self::Hash(i) | Self::Link(i) | Self::Divisor(i) => {
                 NativeEndian::write_u32(buffer, *i)
             }
-            Self::Flags(v) => NativeEndian::write_u32(
-                buffer,
-                u32::from(&VecTcU32OptionFlag(v.to_vec())),
-            ),
+            Self::Flags(f) => NativeEndian::write_u32(buffer, f.bits()),
             Self::ClassId(i) => NativeEndian::write_u32(buffer, (*i).into()),
             Self::Selector(s) => s.emit(buffer),
             Self::Action(acts) => acts.as_slice().emit(buffer),
@@ -156,13 +153,9 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
             TCA_U32_INDEV => Self::Indev(payload.to_vec()),
             TCA_U32_PCNT => Self::Pnct(payload.to_vec()),
             TCA_U32_MARK => Self::Mark(payload.to_vec()),
-            TCA_U32_FLAGS => Self::Flags(
-                VecTcU32OptionFlag::from(
-                    parse_u32(payload)
-                        .context("failed to parse TCA_U32_FLAGS")?,
-                )
-                .0,
-            ),
+            TCA_U32_FLAGS => Self::Flags(TcU32OptionFlags::from_bits_retain(
+                parse_u32(payload).context("failed to parse TCA_U32_FLAGS")?,
+            )),
             _ => Self::Other(
                 DefaultNla::parse(buf).context("failed to parse u32 nla")?,
             ),

src/tc/filters/mod.rs

@@ -8,4 +8,4 @@ pub use self::cls_u32::{
     TcFilterU32, TcFilterU32Option, TcU32Key, TcU32Selector,
 };
 pub use self::matchall::{TcFilterMatchAll, TcFilterMatchAllOption};
-pub use self::u32_flags::{TcU32OptionFlag, TcU32SelectorFlag};
+pub use self::u32_flags::TcU32SelectorFlag;

src/tc/filters/u32_flags.rs

@@ -70,64 +70,15 @@ const TCA_CLS_FLAGS_IN_HW: u32 = 1 << 2;
 const TCA_CLS_FLAGS_NOT_IN_HW: u32 = 1 << 3;
 const TCA_CLS_FLAGS_VERBOSE: u32 = 1 << 4;
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-#[non_exhaustive]
-pub enum TcU32OptionFlag {
-    SkipHw,
-    SkipSw,
-    InHw,
-    NotInHw,
-    Verbose,
-    Other(u32),
-}
-
-impl From<TcU32OptionFlag> for u32 {
-    fn from(v: TcU32OptionFlag) -> u32 {
-        match v {
-            TcU32OptionFlag::SkipHw => TCA_CLS_FLAGS_SKIP_HW,
-            TcU32OptionFlag::SkipSw => TCA_CLS_FLAGS_SKIP_SW,
-            TcU32OptionFlag::InHw => TCA_CLS_FLAGS_IN_HW,
-            TcU32OptionFlag::NotInHw => TCA_CLS_FLAGS_NOT_IN_HW,
-            TcU32OptionFlag::Verbose => TCA_CLS_FLAGS_VERBOSE,
-            TcU32OptionFlag::Other(i) => i,
-        }
-    }
-}
-
-const ALL_OPTION_FLAGS: [TcU32OptionFlag; 5] = [
-    TcU32OptionFlag::SkipHw,
-    TcU32OptionFlag::SkipSw,
-    TcU32OptionFlag::InHw,
-    TcU32OptionFlag::NotInHw,
-    TcU32OptionFlag::Verbose,
-];
-
-#[derive(Clone, Eq, PartialEq, Debug)]
-pub(crate) struct VecTcU32OptionFlag(pub(crate) Vec<TcU32OptionFlag>);
-
-impl From<u32> for VecTcU32OptionFlag {
-    fn from(d: u32) -> Self {
-        let mut got: u32 = 0;
-        let mut ret = Vec::new();
-        for flag in ALL_OPTION_FLAGS {
-            if (d & (u32::from(flag))) > 0 {
-                ret.push(flag);
-                got += u32::from(flag);
-            }
-        }
-        if got != d {
-            ret.push(TcU32OptionFlag::Other(d - got));
-        }
-        Self(ret)
-    }
-}
-
-impl From<&VecTcU32OptionFlag> for u32 {
-    fn from(v: &VecTcU32OptionFlag) -> u32 {
-        let mut d: u32 = 0;
-        for flag in &v.0 {
-            d += u32::from(*flag);
-        }
-        d
+bitflags! {
+    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+    #[non_exhaustive]
+    pub struct TcU32OptionFlags: u32 {
+        const SkipHw = TCA_CLS_FLAGS_SKIP_HW;
+        const SkipSw = TCA_CLS_FLAGS_SKIP_SW;
+        const InHw = TCA_CLS_FLAGS_IN_HW;
+        const NotInHw = TCA_CLS_FLAGS_NOT_IN_HW;
+        const Verbose = TCA_CLS_FLAGS_VERBOSE;
+        const _ = !0;
     }
 }

src/tc/mod.rs

@@ -18,7 +18,7 @@ pub use self::actions::{
 pub use self::attribute::TcAttribute;
 pub use self::filters::{
     TcFilterMatchAll, TcFilterMatchAllOption, TcFilterU32, TcFilterU32Option,
-    TcU32Key, TcU32OptionFlag, TcU32Selector, TcU32SelectorFlag,
+    TcU32Key, TcU32Selector, TcU32SelectorFlag,
 };
 pub use self::header::{TcHandle, TcHeader, TcMessageBuffer};
 pub use self::message::TcMessage;

src/tc/tests/action_nat.rs

@@ -6,11 +6,11 @@ use netlink_packet_utils::{Emitable, Parseable};
 
 use crate::{
     tc::{
-        TcAction, TcActionAttribute, TcActionGeneric, TcActionNatOption,
-        TcActionOption, TcActionType, TcAttribute, TcFilterU32Option, TcHandle,
-        TcHeader, TcMessage, TcMessageBuffer, TcNat, TcOption, TcStats2,
-        TcStatsBasic, TcStatsQueue, TcU32Key, TcU32OptionFlag, TcU32Selector,
-        TcU32SelectorFlag,
+        filters::u32_flags::TcU32OptionFlags, TcAction, TcActionAttribute,
+        TcActionGeneric, TcActionNatOption, TcActionOption, TcActionType,
+        TcAttribute, TcFilterU32Option, TcHandle, TcHeader, TcMessage,
+        TcMessageBuffer, TcNat, TcOption, TcStats2, TcStatsBasic, TcStatsQueue,
+        TcU32Key, TcU32Selector, TcU32SelectorFlag,
     },
     AddressFamily,
 };
@@ -94,9 +94,9 @@ fn test_get_filter_nat() {
                     }],
                 })),
                 TcOption::U32(TcFilterU32Option::Hash(u32::from_be(0x80))),
-                TcOption::U32(TcFilterU32Option::Flags(vec![
-                    TcU32OptionFlag::NotInHw,
-                ])),
+                TcOption::U32(TcFilterU32Option::Flags(
+                    TcU32OptionFlags::NotInHw,
+                )),
                 TcOption::U32(TcFilterU32Option::Action(vec![TcAction {
                     tab: 1,
                     attributes: vec![

src/tc/tests/filter_u32.rs

@@ -6,9 +6,9 @@ use netlink_packet_utils::{Emitable, Parseable};
 
 use crate::{
     tc::{
-        TcAttribute, TcFilterU32Option, TcHandle, TcHeader, TcMessage,
-        TcMessageBuffer, TcOption, TcU32Key, TcU32OptionFlag, TcU32Selector,
-        TcU32SelectorFlag,
+        filters::u32_flags::TcU32OptionFlags, TcAttribute, TcFilterU32Option,
+        TcHandle, TcHeader, TcMessage, TcMessageBuffer, TcOption, TcU32Key,
+        TcU32Selector, TcU32SelectorFlag,
     },
     AddressFamily,
 };
@@ -93,9 +93,9 @@ fn test_get_filter_u32() {
                     major: 1,
                     minor: 4,
                 })),
-                TcOption::U32(TcFilterU32Option::Flags(vec![
-                    TcU32OptionFlag::NotInHw,
-                ])),
+                TcOption::U32(TcFilterU32Option::Flags(
+                    TcU32OptionFlags::NotInHw,
+                )),
                 TcOption::U32(TcFilterU32Option::Pnct(vec![0; 32])), // TODO
             ]),
         ],