Fixup

Author: daniel-noland

src/tc/filters/cls_flower.rs

@@ -381,8 +381,8 @@ impl Nla for TcFilterFlowerOption {
             Self::KeyEncIpTosMask(_) => 1,
             Self::KeyEncIpTtl(_) => 1,
             Self::KeyEncIpTtlMask(_) => 1,
-            Self::KeyEncOpts(opts) => opts.buffer_len(),
-            Self::KeyEncOptsMask(opts) => opts.buffer_len(),
+            Self::KeyEncOpts(opts) => opts.value_len(),
+            Self::KeyEncOptsMask(opts) => opts.value_len(),
             Self::InHwCount(_) => 4,
             Self::KeyPortSrcMin(_) => 2,
             Self::KeyPortSrcMax(_) => 2,
@@ -740,8 +740,8 @@ impl Nla for TcFilterFlowerOption {
             Self::KeyEncIpTtlMask(ttl) => {
                 buffer.copy_from_slice(ttl.to_be_bytes().as_slice());
             }
-            Self::KeyEncOpts(opts) => opts.emit(buffer),
-            Self::KeyEncOptsMask(opts) => opts.emit(buffer),
+            Self::KeyEncOpts(opts) => opts.emit_value(buffer),
+            Self::KeyEncOptsMask(opts) => opts.emit_value(buffer),
             Self::InHwCount(count) => {
                 NativeEndian::write_u32(buffer, *count);
             }

src/tc/filters/flower/encap/geneve.rs

@@ -211,10 +211,24 @@ impl Nla for Options {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::tc::{TcMessage, TcMessageBuffer};
     use netlink_packet_utils::Emitable;
 
+    use crate::net::ethernet::Ethertype;
+    use crate::tc::flower::encap::Options::Geneve;
+    use crate::tc::flower::encap::OptionsList;
+    use crate::tc::TcAttribute;
+    use crate::tc::TcFilterFlowerOption::{
+        KeyEncOpts, KeyEncOptsMask, KeyEthType,
+    };
+    use crate::tc::TcOption::Flower;
+    use crate::tc::{
+        TcFilterFlowerOption, TcFlowerOptionFlags, TcHandle, TcHeader,
+        TcMessage, TcMessageBuffer,
+    };
+    use crate::AddressFamily;
+
+    use super::*;
+
     #[test]
     fn class_parse_back_zero() {
         let example = Class::new(0);
@@ -305,13 +319,58 @@ mod tests {
         assert_eq!(example, parsed);
     }
 
+    const RAW_CAP: &str = "000000003900000000000000f2ffffff080000000b000100666c6f776572000054000200200054001c0001000600010000010000050002000100000008000300abcdef01200055001c00010006000100ffff000005000200ff00000008000300ffffffff08001600000000000600080008000000";
+
+    fn expected_message() -> TcMessage {
+        TcMessage {
+            header: TcHeader {
+                family: AddressFamily::Unspec,
+                index: 57,
+                handle: TcHandle { major: 0, minor: 0 },
+                parent: TcHandle {
+                    major: 65535,
+                    minor: 65522,
+                },
+                info: 8,
+            },
+            attributes: vec![
+                TcAttribute::Kind("flower".to_string()),
+                TcAttribute::Options(vec![
+                    Flower(KeyEncOpts(OptionsList(Geneve(vec![
+                        Options::Class(Class::new(1)),
+                        Options::Type(Type::new(1)),
+                        Options::Data(Data::new(vec![0xabcdef01])),
+                    ])))),
+                    Flower(KeyEncOptsMask(OptionsList(Geneve(vec![
+                        Options::Class(Class::new(65535)),
+                        Options::Type(Type::new(255)),
+                        Options::Data(Data::new(vec![4294967295])),
+                    ])))),
+                    Flower(TcFilterFlowerOption::Flags(
+                        TcFlowerOptionFlags::empty(),
+                    )),
+                    Flower(KeyEthType(Ethertype::IPv4)),
+                ]),
+            ],
+        }
+    }
+
     #[test]
-    fn parse_captured() {
-        let raw_cap = "000000003900000000000000f2ffffff080000000b000100666c6f776572000054000200200054001c0001000600010000010000050002000100000008000300abcdef01200055001c00010006000100ffff000005000200ff00000008000300ffffffff08001600000000000600080008000000";
-        let raw_cap = hex::decode(raw_cap).unwrap();
+    fn captured_parses_as_expected() {
+        let raw_cap = hex::decode(RAW_CAP).unwrap();
+        let expected = expected_message();
         let parsed =
             TcMessage::parse(&TcMessageBuffer::new_checked(&raw_cap).unwrap())
                 .unwrap();
-        println!("{:?}", parsed);
+        assert_eq!(expected, parsed);
+    }
+
+    #[test]
+    fn expected_emits_as_captured() {
+        let raw_cap = hex::decode(RAW_CAP).unwrap();
+        let expected = expected_message();
+        let mut buffer = vec![0; expected.buffer_len()];
+        expected.emit(&mut buffer);
+        assert_eq!(raw_cap, buffer);
     }
 }