Clean up EncOpts vs Options

Author: daniel-noland

src/tc/actions/tunnel_key.rs

@@ -11,7 +11,7 @@ use netlink_packet_utils::{
     DecodeError,
 };
 
-use crate::tc::filters::flower::encap::{EncOpts, parse_enc_opts};
+use crate::tc::filters::flower::encap::{Options, parse_enc_opts};
 use crate::tc::{TcActionGenericBuffer};
 use crate::EncKeyId;
 
@@ -167,7 +167,7 @@ pub enum TcActionTunnelKeyOption {
     KeyEncIpv6Src(Ipv6Addr),
     KeyEncDstPort(UdpPort),
     KeyNoChecksum(bool),
-    KeyEncOpts(EncOpts),
+    KeyEncOpts(Options),
     KeyEncTos(Tos),
     KeyEncTtl(Ttl),
     KeyNoFrag,

src/tc/filters/arp.rs

@@ -2,12 +2,6 @@
 ///
 /// [1]: https://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml
 use crate::tc::filters::ethernet::Mac;
-use std::net::Ipv4Addr;
-
-pub type Sip = Ipv4Addr;
-pub type SipMask = Ipv4Addr;
-pub type Tip = Ipv4Addr;
-pub type TipMask = Ipv4Addr;
 
 const RESERVED: u8 = 0;
 const REQUEST: u8 = 1;
@@ -36,7 +30,7 @@ const MAPO_SUNARP: u8 = 23;
 const OP_EXP1: u8 = 24;
 const OP_EXP2: u8 = 25;
 
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Ord, PartialOrd, Hash)]
 #[non_exhaustive]
 #[repr(u8)]
 pub enum Operation {
@@ -143,8 +137,6 @@ impl From<Operation> for u8 {
     }
 }
 
-pub type OperationMask = u8;
-
 pub type Sha = Mac;
 pub type ShaMask = Mac;
 pub type Tha = Mac;

src/tc/filters/cls_flower.rs

@@ -18,7 +18,7 @@ use netlink_packet_utils::{
 };
 
 use crate::tc::filters::ethernet;
-use crate::tc::filters::flower::encap::EncOpts;
+use crate::tc::filters::flower::encap;
 use crate::tc::filters::flower::mpls;
 use crate::tc::{arp, icmpv4, icmpv6, TcAction, TcFlowerOptionFlags, TcHandle};
 use crate::{EncKeyId, IpProtocol};
@@ -141,21 +141,6 @@ impl TcFilterFlower {
     pub const KIND: &'static str = "flower";
 }
 
-pub type AbstractPort = u16;
-pub type IpTos = u8;
-pub type IpTosMask = u8;
-pub type IpTtl = u8;
-pub type IpTtlMask = u8;
-pub type L2tpV3Sid = u32;
-pub type PppProtocol = u16;
-pub type PppoeSid = u16;
-pub type SctpPort = u16;
-pub type Spi = u32;
-pub type SpiMask = u32;
-pub type TcpFlagsMask = u8;
-pub type TcpPort = u16;
-pub type UdpPort = u16;
-
 /// I can't figure out a better type than just `u8` for `CfmOpCode`.
 /// The only reserved values and meanings I was able to find were in
 /// [rfc7319][1], and that only specifies that values 64-95 are expressly
@@ -221,10 +206,10 @@ pub enum TcFilterFlowerOption {
     KeyIpv6SrcMask(Ipv6Addr),
     KeyIpv6Dst(Ipv6Addr),
     KeyIpv6DstMask(Ipv6Addr),
-    KeyTcpSrc(TcpPort),
-    KeyTcpDst(TcpPort),
-    KeyUdpSrc(UdpPort),
-    KeyUdpDst(UdpPort),
+    KeyTcpSrc(u16),
+    KeyTcpDst(u16),
+    KeyUdpSrc(u16),
+    KeyUdpDst(u16),
     Flags(TcFlowerOptionFlags),
     Other(DefaultNla),
     KeyVlanId(ethernet::VlanId),
@@ -239,80 +224,80 @@ pub enum TcFilterFlowerOption {
     KeyEncIpv6SrcMask(Ipv6Addr),
     KeyEncIpv6Dst(Ipv6Addr),
     KeyEncIpv6DstMask(Ipv6Addr),
-    KeyTcpSrcMask(TcpPort),
-    KeyTcpDstMask(TcpPort),
-    KeyUdpSrcMask(UdpPort),
-    KeyUdpDstMask(UdpPort),
-    KeySctpSrcMask(SctpPort),
-    KeySctpDstMask(SctpPort),
-    KeySctpSrc(SctpPort),
-    KeySctpDst(SctpPort),
-    KeyEncUdpSrcPort(UdpPort),
-    KeyEncUdpSrcPortMask(UdpPort),
-    KeyEncUdpDstPort(UdpPort),
-    KeyEncUdpDstPortMask(UdpPort),
+    KeyTcpSrcMask(u16),
+    KeyTcpDstMask(u16),
+    KeyUdpSrcMask(u16),
+    KeyUdpDstMask(u16),
+    KeySctpSrcMask(u16),
+    KeySctpDstMask(u16),
+    KeySctpSrc(u16),
+    KeySctpDst(u16),
+    KeyEncUdpSrcPort(u16),
+    KeyEncUdpSrcPortMask(u16),
+    KeyEncUdpDstPort(u16),
+    KeyEncUdpDstPortMask(u16),
     KeyFlags(FlowerKeyFlags),
     KeyFlagsMask(FlowerKeyFlags),
     KeyIcmpv4Code(icmpv4::Code),
-    KeyIcmpv4CodeMask(icmpv4::CodeMask),
+    KeyIcmpv4CodeMask(u8),
     KeyIcmpv4Type(icmpv4::Type),
-    KeyIcmpv4TypeMask(icmpv4::TypeMask),
+    KeyIcmpv4TypeMask(u8),
     KeyIcmpv6Code(icmpv6::Code),
-    KeyIcmpv6CodeMask(icmpv6::CodeMask),
+    KeyIcmpv6CodeMask(u8),
     KeyIcmpv6Type(icmpv6::Type),
-    KeyIcmpv6TypeMask(icmpv6::TypeMask),
-    KeyArpSip(arp::Sip),
-    KeyArpSipMask(arp::SipMask),
-    KeyArpTip(arp::Tip),
-    KeyArpTipMask(arp::TipMask),
+    KeyIcmpv6TypeMask(u8),
+    KeyArpSip(Ipv4Addr),
+    KeyArpSipMask(Ipv4Addr),
+    KeyArpTip(Ipv4Addr),
+    KeyArpTipMask(Ipv4Addr),
     KeyArpOp(arp::Operation),
-    KeyArpOpMask(arp::OperationMask),
-    KeyArpSha(arp::Sha),
-    KeyArpShaMask(arp::ShaMask),
-    KeyArpTha(arp::Tha),
-    KeyArpThaMask(arp::ThaMask),
-    KeyMplsTtl(mpls::MplsTtl),
+    KeyArpOpMask(u8),
+    KeyArpSha(ethernet::Mac),
+    KeyArpShaMask(ethernet::Mac),
+    KeyArpTha(ethernet::Mac),
+    KeyArpThaMask(ethernet::Mac),
+    KeyMplsTtl(u8),
     KeyMplsBos(mpls::BottomOfStack),
-    KeyMplsTc(mpls::TrafficClass),
+    KeyMplsTc(u8),
     KeyMplsLabel(mpls::Label),
     KeyTcpFlags(TcpFlags),
-    KeyTcpFlagsMask(TcpFlagsMask),
-    KeyIpTos(IpTos),
-    KeyIpTosMask(IpTos),
-    KeyIpTtl(IpTtl),
-    KeyIpTtlMask(IpTtlMask),
+    KeyTcpFlagsMask(u8),
+    KeyIpTos(u8),
+    KeyIpTosMask(u8),
+    KeyIpTtl(u8),
+    KeyIpTtlMask(u8),
     KeyCvlanId(ethernet::VlanId),
     KeyCvlanPrio(ethernet::VlanPrio),
     KeyCvlanEthType(ethernet::Ethertype),
-    KeyEncIpTos(IpTos),
-    KeyEncIpTosMask(IpTosMask),
-    KeyEncIpTtl(IpTtl),
-    KeyEncIpTtlMask(IpTtlMask),
-    KeyEncOpts(EncOpts),
-    KeyEncOptsMask(EncOpts),
-    KeyPortSrcMin(AbstractPort),
-    KeyPortSrcMax(AbstractPort),
-    KeyPortDstMin(AbstractPort),
-    KeyPortDstMax(AbstractPort),
+    KeyEncIpTos(u8),
+    KeyEncIpTosMask(u8),
+    KeyEncIpTtl(u8),
+    KeyEncIpTtlMask(u8),
+    KeyEncOpts(encap::Options),
+    KeyEncOptsMask(encap::Options),
+    KeyPortSrcMin(u16),
+    KeyPortSrcMax(u16),
+    KeyPortDstMin(u16),
+    KeyPortDstMax(u16),
     KeyCtState(ConnectionTrackingFlags),
     KeyCtStateMask(ConnectionTrackingFlags),
-    KeyCtZone(ConnectionTrackingZone),
-    KeyCtZoneMask(ConnectionTrackingZone),
-    KeyCtMark(ConnectionTrackingMark),
-    KeyCtMarkMask(ConnectionTrackingMark),
-    KeyCtLabels(ConnectionTrackingLabel),
-    KeyCtLabelsMask(ConnectionTrackingLabel),
+    KeyCtZone(u16),
+    KeyCtZoneMask(u16),
+    KeyCtMark(u32),
+    KeyCtMarkMask(u32),
+    KeyCtLabels(u128),
+    KeyCtLabelsMask(u128),
     KeyMplsOpts(mpls::Options),
     KeyHash(u32),
     KeyHashMask(u32),
     KeyNumOfVlans(u8),
-    KeyPppoeSid(PppoeSid),
-    KeyPppProto(PppProtocol),
-    KeyL2tpv3Sid(L2tpV3Sid),
+    KeyPppoeSid(u16),
+    KeyPppProto(u16),
+    KeyL2tpv3Sid(u32),
     L2Miss(L2Miss),
     KeyCfm(Vec<CfmAttribute>),
-    KeySpi(Spi),
-    KeySpiMask(SpiMask),
+    KeySpi(u32),
+    KeySpiMask(u32),
     InHwCount(u32),
 }
 
@@ -1007,7 +992,8 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
                 }
                 let id = NativeEndian::read_u16(payload);
                 Self::KeyVlanId(
-                    ethernet::VlanId::try_new(id).context("failed to parse vlan id")?,
+                    ethernet::VlanId::try_new(id)
+                        .context("failed to parse vlan id")?,
                 )
             }
             TCA_FLOWER_KEY_VLAN_PRIO => {
@@ -1460,7 +1446,8 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
                 }
                 let id = NativeEndian::read_u16(payload);
                 Self::KeyCvlanId(
-                    ethernet::VlanId::try_new(id).context("failed to parse cvlan id")?,
+                    ethernet::VlanId::try_new(id)
+                        .context("failed to parse cvlan id")?,
                 )
             }
             TCA_FLOWER_KEY_CVLAN_PRIO => {
@@ -1514,9 +1501,11 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
                 }
                 Self::KeyEncIpTtlMask(payload[0])
             }
-            TCA_FLOWER_KEY_ENC_OPTS => Self::KeyEncOpts(EncOpts::parse(buf)?),
+            TCA_FLOWER_KEY_ENC_OPTS => {
+                Self::KeyEncOpts(encap::Options::parse(buf)?)
+            }
             TCA_FLOWER_KEY_ENC_OPTS_MASK => {
-                Self::KeyEncOptsMask(EncOpts::parse(buf)?)
+                Self::KeyEncOptsMask(encap::Options::parse(buf)?)
             }
             TCA_FLOWER_IN_HW_COUNT => Self::InHwCount(
                 parse_u32(payload)
@@ -1635,10 +1624,6 @@ bitflags! {
     }
 }
 
-type ConnectionTrackingZone = u16;
-type ConnectionTrackingMark = u32;
-type ConnectionTrackingLabel = u128;
-
 fn parse_u128_be(slice: &[u8]) -> Result<u128, DecodeError> {
     if slice.len() != 16 {
         return Err(DecodeError::from("invalid u128 length"));

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

@@ -221,15 +221,15 @@ impl ErspanHwid {
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[non_exhaustive]
-pub enum EncOpts {
+pub enum Options {
     Ver(Version),
     Index(Index),
     Direction(Direction),
     Hwid(ErspanHwid),
     Other(DefaultNla),
 }
 
-impl Nla for EncOpts {
+impl Nla for Options {
     fn value_len(&self) -> usize {
         match self {
             Self::Ver(v) => v.value_len(),
@@ -262,7 +262,7 @@ impl Nla for EncOpts {
 }
 
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
-    for EncOpts
+    for Options
 {
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         Ok(match buf.kind() {

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

@@ -9,7 +9,7 @@ const TCA_FLOWER_KEY_ENC_OPT_GENEVE_DATA: u16 = 3; /* 4 to 128 bytes */
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[non_exhaustive]
-pub enum EncOpts {
+pub enum Options {
     Class(Class),
     Type(Type),
     Data(Data),
@@ -20,7 +20,7 @@ pub enum EncOpts {
 pub struct Class(u16);
 
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
-for EncOpts
+for Options
 {
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         Ok(match buf.kind() {
@@ -167,7 +167,7 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for Data {
     }
 }
 
-impl Nla for EncOpts {
+impl Nla for Options {
     fn value_len(&self) -> usize {
         match self {
             Self::Class(c) => c.value_len(),

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

@@ -16,49 +16,49 @@ const TCA_FLOWER_KEY_ENC_OPT_GTP_QFI: u16 = 2; /* u8 */
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[non_exhaustive]
-pub enum EncOpts {
+pub enum Options {
     PduType(u8),
     Qfi(u8),
     Other(DefaultNla),
 }
 
-impl Nla for EncOpts {
+impl Nla for Options {
     fn value_len(&self) -> usize {
         1
     }
 
     fn kind(&self) -> u16 {
         match self {
-            EncOpts::PduType(_) => TCA_FLOWER_KEY_ENC_OPT_GTP_PDU_TYPE,
-            EncOpts::Qfi(_) => TCA_FLOWER_KEY_ENC_OPT_GTP_QFI,
-            EncOpts::Other(nla) => nla.kind(),
+            Options::PduType(_) => TCA_FLOWER_KEY_ENC_OPT_GTP_PDU_TYPE,
+            Options::Qfi(_) => TCA_FLOWER_KEY_ENC_OPT_GTP_QFI,
+            Options::Other(nla) => nla.kind(),
         }
     }
 
     fn emit_value(&self, buffer: &mut [u8]) {
         match self {
-            EncOpts::PduType(pdu_type) => {
+            Options::PduType(pdu_type) => {
                 buffer[0] = *pdu_type;
             }
-            EncOpts::Qfi(qfi) => {
+            Options::Qfi(qfi) => {
                 buffer[0] = *qfi;
             }
-            EncOpts::Other(nla) => nla.emit_value(buffer),
+            Options::Other(nla) => nla.emit_value(buffer),
         }
     }
 }
 
-impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for EncOpts {
+impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for Options {
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         let payload = buf.value();
         Ok(match buf.kind() {
             TCA_FLOWER_KEY_ENC_OPT_GTP_PDU_TYPE => {
-                EncOpts::PduType(parse_u8(payload)?)
+                Options::PduType(parse_u8(payload)?)
             }
             TCA_FLOWER_KEY_ENC_OPT_GTP_QFI => {
-                EncOpts::Qfi(parse_u8(payload)?)
+                Options::Qfi(parse_u8(payload)?)
             }
-            _ => EncOpts::Other(
+            _ => Options::Other(
                 DefaultNla::parse(buf).context("failed to parse gtp nla")?,
             ),
         })