use bitflags for TcU32SelectorFlags

Author: little-dude

src/tc/filters/cls_u32.rs

@@ -16,8 +16,8 @@ use netlink_packet_utils::{
     DecodeError,
 };
 
-use super::u32_flags::{TcU32OptionFlags, VecTcU32SelectorFlag};
-use crate::tc::{TcAction, TcHandle, TcU32SelectorFlag};
+use super::u32_flags::{TcU32OptionFlags, TcU32SelectorFlags};
+use crate::tc::{TcAction, TcHandle};
 
 const TC_U32_SEL_BUF_LEN: usize = 16;
 const TC_U32_KEY_BUF_LEN: usize = 16;
@@ -166,7 +166,7 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
 #[non_exhaustive]
 pub struct TcU32Selector {
-    pub flags: Vec<TcU32SelectorFlag>,
+    pub flags: TcU32SelectorFlags,
     pub offshift: u8,
     pub nkeys: u8,
     pub offmask: u16,
@@ -197,7 +197,7 @@ impl Emitable for TcU32Selector {
 
     fn emit(&self, buffer: &mut [u8]) {
         let mut packet = TcU32SelectorBuffer::new(buffer);
-        packet.set_flags(u8::from(&VecTcU32SelectorFlag(self.flags.to_vec())));
+        packet.set_flags(self.flags.bits());
         packet.set_offshift(self.offshift);
         packet.set_offmask(self.offmask);
         packet.set_off(self.off);
@@ -236,7 +236,7 @@ impl<T: AsRef<[u8]> + ?Sized> Parseable<TcU32SelectorBuffer<&T>>
         }
 
         Ok(Self {
-            flags: VecTcU32SelectorFlag::from(buf.flags()).0,
+            flags: TcU32SelectorFlags::from_bits_retain(buf.flags()),
             offshift: buf.offshift(),
             nkeys,
             offmask: buf.offmask(),

src/tc/filters/mod.rs

@@ -2,10 +2,10 @@
 
 mod cls_u32;
 mod matchall;
-pub(crate) mod u32_flags;
+mod u32_flags;
 
 pub use self::cls_u32::{
     TcFilterU32, TcFilterU32Option, TcU32Key, TcU32Selector,
 };
 pub use self::matchall::{TcFilterMatchAll, TcFilterMatchAllOption};
-pub use self::u32_flags::TcU32SelectorFlag;
+pub use u32_flags::{TcU32OptionFlags, TcU32SelectorFlags};

src/tc/filters/u32_flags.rs

@@ -5,62 +5,15 @@ const TC_U32_OFFSET: u8 = 2;
 const TC_U32_VAROFFSET: u8 = 4;
 const TC_U32_EAT: u8 = 8;
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-#[non_exhaustive]
-pub enum TcU32SelectorFlag {
-    Terminal,
-    Offset,
-    VarOffset,
-    Eat,
-    Other(u8),
-}
-
-impl From<TcU32SelectorFlag> for u8 {
-    fn from(v: TcU32SelectorFlag) -> u8 {
-        match v {
-            TcU32SelectorFlag::Terminal => TC_U32_TERMINAL,
-            TcU32SelectorFlag::Offset => TC_U32_OFFSET,
-            TcU32SelectorFlag::VarOffset => TC_U32_VAROFFSET,
-            TcU32SelectorFlag::Eat => TC_U32_EAT,
-            TcU32SelectorFlag::Other(i) => i,
-        }
-    }
-}
-
-const ALL_SELECTOR_FLAGS: [TcU32SelectorFlag; 4] = [
-    TcU32SelectorFlag::Terminal,
-    TcU32SelectorFlag::Offset,
-    TcU32SelectorFlag::VarOffset,
-    TcU32SelectorFlag::Eat,
-];
-
-#[derive(Clone, Eq, PartialEq, Debug)]
-pub(crate) struct VecTcU32SelectorFlag(pub(crate) Vec<TcU32SelectorFlag>);
-
-impl From<u8> for VecTcU32SelectorFlag {
-    fn from(d: u8) -> Self {
-        let mut got: u8 = 0;
-        let mut ret = Vec::new();
-        for flag in ALL_SELECTOR_FLAGS {
-            if (d & (u8::from(flag))) > 0 {
-                ret.push(flag);
-                got += u8::from(flag);
-            }
-        }
-        if got != d {
-            ret.push(TcU32SelectorFlag::Other(d - got));
-        }
-        Self(ret)
-    }
-}
-
-impl From<&VecTcU32SelectorFlag> for u8 {
-    fn from(v: &VecTcU32SelectorFlag) -> u8 {
-        let mut d: u8 = 0;
-        for flag in &v.0 {
-            d += u8::from(*flag);
-        }
-        d
+bitflags! {
+    #[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
+    #[non_exhaustive]
+    pub struct TcU32SelectorFlags: u8 {
+        const Terminal = TC_U32_TERMINAL;
+        const Offset = TC_U32_OFFSET;
+        const VarOffset = TC_U32_VAROFFSET;
+        const Eat = TC_U32_EAT;
+        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, TcU32Selector, TcU32SelectorFlag,
+    TcU32Key, TcU32Selector,
 };
 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::{
-        filters::u32_flags::TcU32OptionFlags, TcAction, TcActionAttribute,
-        TcActionGeneric, TcActionNatOption, TcActionOption, TcActionType,
-        TcAttribute, TcFilterU32Option, TcHandle, TcHeader, TcMessage,
-        TcMessageBuffer, TcNat, TcOption, TcStats2, TcStatsBasic, TcStatsQueue,
-        TcU32Key, TcU32Selector, TcU32SelectorFlag,
+        filters::{TcU32OptionFlags, TcU32SelectorFlags},
+        TcAction, TcActionAttribute, TcActionGeneric, TcActionNatOption,
+        TcActionOption, TcActionType, TcAttribute, TcFilterU32Option, TcHandle,
+        TcHeader, TcMessage, TcMessageBuffer, TcNat, TcOption, TcStats2,
+        TcStatsBasic, TcStatsQueue, TcU32Key, TcU32Selector,
     },
     AddressFamily,
 };
@@ -76,7 +76,7 @@ fn test_get_filter_nat() {
             TcAttribute::Chain(0),
             TcAttribute::Options(vec![
                 TcOption::U32(TcFilterU32Option::Selector(TcU32Selector {
-                    flags: vec![TcU32SelectorFlag::Terminal],
+                    flags: TcU32SelectorFlags::Terminal,
                     offshift: 0,
                     nkeys: 1,
                     offmask: 0,

src/tc/tests/filter_u32.rs

@@ -6,9 +6,9 @@ use netlink_packet_utils::{Emitable, Parseable};
 
 use crate::{
     tc::{
-        filters::u32_flags::TcU32OptionFlags, TcAttribute, TcFilterU32Option,
-        TcHandle, TcHeader, TcMessage, TcMessageBuffer, TcOption, TcU32Key,
-        TcU32Selector, TcU32SelectorFlag,
+        filters::{TcU32OptionFlags, TcU32SelectorFlags},
+        TcAttribute, TcFilterU32Option, TcHandle, TcHeader, TcMessage,
+        TcMessageBuffer, TcOption, TcU32Key, TcU32Selector,
     },
     AddressFamily,
 };
@@ -63,7 +63,7 @@ fn test_get_filter_u32() {
             TcAttribute::Chain(0),
             TcAttribute::Options(vec![
                 TcOption::U32(TcFilterU32Option::Selector(TcU32Selector {
-                    flags: vec![TcU32SelectorFlag::Terminal],
+                    flags: TcU32SelectorFlags::Terminal,
                     offshift: 0,
                     nkeys: 2,
                     offmask: 0,