1 use crate::*;
2 
3 /// Deprecated use [`crate::NetHeaders`] instead.
4 #[deprecated(since = "0.14.0", note = "`IpHeader` was renamed to `NetHeaders`")]
5 pub type IpHeader = NetHeaders;
6 
7 /// Headers on the network layer (e.g. IP, ARP, ...).
8 #[derive(Clone, Debug, Eq, PartialEq)]
9 #[allow(clippy::large_enum_variant)]
10 pub enum NetHeaders {
11     /// IPv4 header & extension headers.
12     Ipv4(Ipv4Header, Ipv4Extensions),
13     /// IPv6 header & extension headers.
14     Ipv6(Ipv6Header, Ipv6Extensions),
15 }
16 
17 impl NetHeaders {
18     /// Returns references to the IPv4 header & extensions if the header contains IPv4 values.
ipv4_ref(&self) -> Option<(&Ipv4Header, &Ipv4Extensions)>19     pub fn ipv4_ref(&self) -> Option<(&Ipv4Header, &Ipv4Extensions)> {
20         if let NetHeaders::Ipv4(header, exts) = self {
21             Some((header, exts))
22         } else {
23             None
24         }
25     }
26 
27     /// Returns references to the IPv6 header & extensions if the header contains IPv6 values.
ipv6_ref(&self) -> Option<(&Ipv6Header, &Ipv6Extensions)>28     pub fn ipv6_ref(&self) -> Option<(&Ipv6Header, &Ipv6Extensions)> {
29         if let NetHeaders::Ipv6(header, exts) = self {
30             Some((header, exts))
31         } else {
32             None
33         }
34     }
35 
36     /// Returns the size when the header & extension headers are serialized
header_len(&self) -> usize37     pub fn header_len(&self) -> usize {
38         use crate::NetHeaders::*;
39         match *self {
40             Ipv4(ref header, ref extensions) => header.header_len() + extensions.header_len(),
41             Ipv6(_, ref extensions) => Ipv6Header::LEN + extensions.header_len(),
42         }
43     }
44 }
45 
46 impl From<IpHeaders> for NetHeaders {
47     #[inline]
from(value: IpHeaders) -> Self48     fn from(value: IpHeaders) -> Self {
49         match value {
50             IpHeaders::Ipv4(h, e) => NetHeaders::Ipv4(h, e),
51             IpHeaders::Ipv6(h, e) => NetHeaders::Ipv6(h, e),
52         }
53     }
54 }
55 
56 #[cfg(test)]
57 mod tests {
58     use crate::*;
59     use alloc::format;
60 
61     #[test]
debug()62     fn debug() {
63         let h = Ipv4Header {
64             ..Default::default()
65         };
66         let e = Ipv4Extensions {
67             ..Default::default()
68         };
69         let n = NetHeaders::Ipv4(h.clone(), e.clone());
70         assert_eq!(format!("{n:?}"), format!("Ipv4({h:?}, {e:?})"));
71     }
72 
73     #[test]
clone_eq()74     fn clone_eq() {
75         let n = NetHeaders::Ipv4(Default::default(), Default::default());
76         assert_eq!(n, n.clone())
77     }
78 
79     #[test]
ipv4_ref()80     fn ipv4_ref() {
81         // ipv4
82         {
83             let h: Ipv4Header = Default::default();
84             let e: Ipv4Extensions = Default::default();
85             let s = NetHeaders::Ipv4(h.clone(), e.clone());
86             assert_eq!(s.ipv4_ref(), Some((&h, &e)));
87         }
88         // ipv6
89         {
90             let h: Ipv6Header = Default::default();
91             let e: Ipv6Extensions = Default::default();
92             let s = NetHeaders::Ipv6(h.clone(), e.clone());
93             assert_eq!(s.ipv4_ref(), None);
94         }
95     }
96 
97     #[test]
ipv6_ref()98     fn ipv6_ref() {
99         // ipv4
100         {
101             let h: Ipv4Header = Default::default();
102             let e: Ipv4Extensions = Default::default();
103             let s = NetHeaders::Ipv4(h.clone(), e.clone());
104             assert_eq!(s.ipv6_ref(), None);
105         }
106         // ipv6
107         {
108             let h: Ipv6Header = Default::default();
109             let e: Ipv6Extensions = Default::default();
110             let s = NetHeaders::Ipv6(h.clone(), e.clone());
111             assert_eq!(s.ipv6_ref(), Some((&h, &e)));
112         }
113     }
114 
115     #[test]
header_len()116     fn header_len() {
117         // ipv4
118         {
119             let h: Ipv4Header = Default::default();
120             let e: Ipv4Extensions = Default::default();
121             let s = NetHeaders::Ipv4(h.clone(), e.clone());
122             assert_eq!(s.header_len(), h.header_len() + e.header_len());
123         }
124         // ipv6
125         {
126             let h: Ipv6Header = Default::default();
127             let e: Ipv6Extensions = Default::default();
128             let s = NetHeaders::Ipv6(h.clone(), e.clone());
129             assert_eq!(s.header_len(), h.header_len() + e.header_len());
130         }
131     }
132 
133     #[test]
from()134     fn from() {
135         // ipv4
136         {
137             let h: Ipv4Header = Default::default();
138             let e: Ipv4Extensions = Default::default();
139             let s = IpHeaders::Ipv4(h.clone(), e.clone());
140             let a: NetHeaders = s.clone().into();
141             assert_eq!(a, NetHeaders::Ipv4(h.clone(), e.clone()));
142         }
143         // ipv6
144         {
145             let h: Ipv6Header = Default::default();
146             let e: Ipv6Extensions = Default::default();
147             let s = IpHeaders::Ipv6(h.clone(), e.clone());
148             let a: NetHeaders = s.clone().into();
149             assert_eq!(a, NetHeaders::Ipv6(h.clone(), e.clone()));
150         }
151     }
152 }
153