itsscb/smoltcp
1
0
Fork 0
mirror of https://github.com/smoltcp-rs/smoltcp.git synced 2025-10-02 15:15:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

wire: Rename ipv4 protocol to next_header.

Browse Source 
This improves v4/v6 consistency at the cost of slightly deviating from RFC names.
This commit is contained in:
Dario Nieuwenhuis 2021-12-11 02:27:53 +01:00
parent 52628e2d4e
commit 028b4466ff
11 changed files with 107 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
benches/bench.rs
View File

@ -85,7 +85,7 @@ mod wire {
let repr = Ipv4Repr { let repr = Ipv4Repr {
src_addr: Ipv4Address([192, 168, 1, 1]), src_addr: Ipv4Address([192, 168, 1, 1]),
dst_addr: Ipv4Address([192, 168, 1, 2]), dst_addr: Ipv4Address([192, 168, 1, 2]),
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: 100, payload_len: 100,
hop_limit: 64, hop_limit: 64,
}; };

50
src/iface/interface.rs
View File

@ -1592,7 +1592,7 @@ impl<'a> InterfaceInner<'a> {
#[cfg(feature = "socket-dhcpv4")] #[cfg(feature = "socket-dhcpv4")]
{ {
if ipv4_repr.protocol == IpProtocol::Udp && self.hardware_addr.is_some() { if ipv4_repr.next_header == IpProtocol::Udp && self.hardware_addr.is_some() {
// First check for source and dest ports, then do `UdpRepr::parse` if they match. // First check for source and dest ports, then do `UdpRepr::parse` if they match.
// This way we avoid validating the UDP checksum twice for all non-DHCP UDP packets (one here, one in `process_udp`) // This way we avoid validating the UDP checksum twice for all non-DHCP UDP packets (one here, one in `process_udp`)
let udp_packet = UdpPacket::new_checked(ip_payload)?; let udp_packet = UdpPacket::new_checked(ip_payload)?;
@ -1637,7 +1637,7 @@ impl<'a> InterfaceInner<'a> {
} }
} }
match ipv4_repr.protocol { match ipv4_repr.next_header {
IpProtocol::Icmp => self.process_icmpv4(sockets, ip_repr, ip_payload), IpProtocol::Icmp => self.process_icmpv4(sockets, ip_repr, ip_payload),
#[cfg(feature = "proto-igmp")] #[cfg(feature = "proto-igmp")]
@ -2027,7 +2027,7 @@ impl<'a> InterfaceInner<'a> {
let ipv4_reply_repr = Ipv4Repr { let ipv4_reply_repr = Ipv4Repr {
src_addr: ipv4_repr.dst_addr, src_addr: ipv4_repr.dst_addr,
dst_addr: ipv4_repr.src_addr, dst_addr: ipv4_repr.src_addr,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: icmp_repr.buffer_len(), payload_len: icmp_repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}; };
@ -2040,7 +2040,7 @@ impl<'a> InterfaceInner<'a> {
let ipv4_reply_repr = Ipv4Repr { let ipv4_reply_repr = Ipv4Repr {
src_addr: src_addr, src_addr: src_addr,
dst_addr: ipv4_repr.src_addr, dst_addr: ipv4_repr.src_addr,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: icmp_repr.buffer_len(), payload_len: icmp_repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}; };
@ -2619,7 +2619,7 @@ impl<'a> InterfaceInner<'a> {
src_addr: iface_addr, src_addr: iface_addr,
// Send to the group being reported // Send to the group being reported
dst_addr: group_addr, dst_addr: group_addr,
protocol: IpProtocol::Igmp, next_header: IpProtocol::Igmp,
payload_len: igmp_repr.buffer_len(), payload_len: igmp_repr.buffer_len(),
hop_limit: 1, hop_limit: 1,
// TODO: add Router Alert IPv4 header option. See // TODO: add Router Alert IPv4 header option. See
@ -2638,7 +2638,7 @@ impl<'a> InterfaceInner<'a> {
Ipv4Repr { Ipv4Repr {
src_addr: iface_addr, src_addr: iface_addr,
dst_addr: Ipv4Address::MULTICAST_ALL_ROUTERS, dst_addr: Ipv4Address::MULTICAST_ALL_ROUTERS,
protocol: IpProtocol::Igmp, next_header: IpProtocol::Igmp,
payload_len: igmp_repr.buffer_len(), payload_len: igmp_repr.buffer_len(),
hop_limit: 1, hop_limit: 1,
}, },
@ -2766,7 +2766,7 @@ mod test {
let repr = IpRepr::Ipv4(Ipv4Repr { let repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]), src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
dst_addr: Ipv4Address::BROADCAST, dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Unknown(0x0c), next_header: IpProtocol::Unknown(0x0c),
payload_len: 0, payload_len: 0,
hop_limit: 0x40, hop_limit: 0x40,
}); });
@ -2825,7 +2825,7 @@ mod test {
let repr = IpRepr::Ipv4(Ipv4Repr { let repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]), src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]), dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
protocol: IpProtocol::Unknown(0x0c), next_header: IpProtocol::Unknown(0x0c),
payload_len: 0, payload_len: 0,
hop_limit: 0x40, hop_limit: 0x40,
}); });
@ -2841,7 +2841,7 @@ mod test {
header: Ipv4Repr { header: Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]), src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]), dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
protocol: IpProtocol::Unknown(12), next_header: IpProtocol::Unknown(12),
payload_len: 0, payload_len: 0,
hop_limit: 64, hop_limit: 64,
}, },
@ -2852,7 +2852,7 @@ mod test {
Ipv4Repr { Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]), src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]), dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: icmp_repr.buffer_len(), payload_len: icmp_repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}, },
@ -2942,7 +2942,7 @@ mod test {
let ip_repr = IpRepr::Ipv4(Ipv4Repr { let ip_repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]), src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]), dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(), payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 64, hop_limit: 64,
}); });
@ -2966,7 +2966,7 @@ mod test {
header: Ipv4Repr { header: Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]), src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]), dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(), payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 64, hop_limit: 64,
}, },
@ -2976,7 +2976,7 @@ mod test {
Ipv4Repr { Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]), src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]), dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: icmp_repr.buffer_len(), payload_len: icmp_repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}, },
@ -2995,7 +2995,7 @@ mod test {
let ip_repr = IpRepr::Ipv4(Ipv4Repr { let ip_repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]), src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
dst_addr: Ipv4Address::BROADCAST, dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(), payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 64, hop_limit: 64,
}); });
@ -3066,7 +3066,7 @@ mod test {
let ip_repr = IpRepr::Ipv4(Ipv4Repr { let ip_repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: src_ip, src_addr: src_ip,
dst_addr: Ipv4Address::BROADCAST, dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(), payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 0x40, hop_limit: 0x40,
}); });
@ -3126,7 +3126,7 @@ mod test {
let ipv4_repr = Ipv4Repr { let ipv4_repr = Ipv4Repr {
src_addr: src_ipv4_addr, src_addr: src_ipv4_addr,
dst_addr: Ipv4Address::BROADCAST, dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
hop_limit: 64, hop_limit: 64,
payload_len: icmpv4_repr.buffer_len(), payload_len: icmpv4_repr.buffer_len(),
}; };
@ -3154,7 +3154,7 @@ mod test {
let expected_ipv4_repr = Ipv4Repr { let expected_ipv4_repr = Ipv4Repr {
src_addr: our_ipv4_addr, src_addr: our_ipv4_addr,
dst_addr: src_ipv4_addr, dst_addr: src_ipv4_addr,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
hop_limit: 64, hop_limit: 64,
payload_len: expected_icmpv4_repr.buffer_len(), payload_len: expected_icmpv4_repr.buffer_len(),
}; };
@ -3212,7 +3212,7 @@ mod test {
let ip_repr = Ipv4Repr { let ip_repr = Ipv4Repr {
src_addr: src_addr, src_addr: src_addr,
dst_addr: dst_addr, dst_addr: dst_addr,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
hop_limit: 64, hop_limit: 64,
payload_len: udp_repr.header_len() + MAX_PAYLOAD_LEN, payload_len: udp_repr.header_len() + MAX_PAYLOAD_LEN,
}; };
@ -3251,7 +3251,7 @@ mod test {
let expected_ip_repr = Ipv4Repr { let expected_ip_repr = Ipv4Repr {
src_addr: dst_addr, src_addr: dst_addr,
dst_addr: src_addr, dst_addr: src_addr,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
hop_limit: 64, hop_limit: 64,
payload_len: expected_icmp_repr.buffer_len(), payload_len: expected_icmp_repr.buffer_len(),
}; };
@ -3561,7 +3561,7 @@ mod test {
let ipv4_repr = Ipv4Repr { let ipv4_repr = Ipv4Repr {
src_addr: Ipv4Address::new(0x7f, 0x00, 0x00, 0x02), src_addr: Ipv4Address::new(0x7f, 0x00, 0x00, 0x02),
dst_addr: Ipv4Address::new(0x7f, 0x00, 0x00, 0x01), dst_addr: Ipv4Address::new(0x7f, 0x00, 0x00, 0x01),
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: 24, payload_len: 24,
hop_limit: 64, hop_limit: 64,
}; };
@ -3734,7 +3734,7 @@ mod test {
let reports = recv_igmp(&mut iface, timestamp); let reports = recv_igmp(&mut iface, timestamp);
assert_eq!(reports.len(), 2); assert_eq!(reports.len(), 2);
for (i, group_addr) in groups.iter().enumerate() { for (i, group_addr) in groups.iter().enumerate() {
assert_eq!(reports[i].0.protocol, IpProtocol::Igmp); assert_eq!(reports[i].0.next_header, IpProtocol::Igmp);
assert_eq!(reports[i].0.dst_addr, *group_addr); assert_eq!(reports[i].0.dst_addr, *group_addr);
assert_eq!( assert_eq!(
reports[i].1, reports[i].1,
@ -3778,7 +3778,7 @@ mod test {
let leaves = recv_igmp(&mut iface, timestamp); let leaves = recv_igmp(&mut iface, timestamp);
assert_eq!(leaves.len(), 2); assert_eq!(leaves.len(), 2);
for (i, group_addr) in groups.iter().cloned().enumerate() { for (i, group_addr) in groups.iter().cloned().enumerate() {
assert_eq!(leaves[i].0.protocol, IpProtocol::Igmp); assert_eq!(leaves[i].0.next_header, IpProtocol::Igmp);
assert_eq!(leaves[i].0.dst_addr, Ipv4Address::MULTICAST_ALL_ROUTERS); assert_eq!(leaves[i].0.dst_addr, Ipv4Address::MULTICAST_ALL_ROUTERS);
assert_eq!(leaves[i].1, IgmpRepr::LeaveGroup { group_addr }); assert_eq!(leaves[i].1, IgmpRepr::LeaveGroup { group_addr });
} }
@ -3824,7 +3824,7 @@ mod test {
let ipv4_repr = Ipv4Repr { let ipv4_repr = Ipv4Repr {
src_addr: src_addr, src_addr: src_addr,
dst_addr: dst_addr, dst_addr: dst_addr,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
hop_limit: 64, hop_limit: 64,
payload_len: udp_repr.header_len() + PAYLOAD_LEN, payload_len: udp_repr.header_len() + PAYLOAD_LEN,
}; };
@ -3894,7 +3894,7 @@ mod test {
let ipv4_repr = Ipv4Repr { let ipv4_repr = Ipv4Repr {
src_addr: src_addr, src_addr: src_addr,
dst_addr: dst_addr, dst_addr: dst_addr,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
hop_limit: 64, hop_limit: 64,
payload_len: udp_repr.header_len() + PAYLOAD_LEN, payload_len: udp_repr.header_len() + PAYLOAD_LEN,
}; };
@ -3985,7 +3985,7 @@ mod test {
let ipv4_repr = Ipv4Repr { let ipv4_repr = Ipv4Repr {
src_addr: src_addr, src_addr: src_addr,
dst_addr: dst_addr, dst_addr: dst_addr,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
hop_limit: 64, hop_limit: 64,
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(), payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
}; };

12
src/socket/dhcpv4.rs
View File

@ -427,7 +427,7 @@ impl Dhcpv4Socket {
let mut ipv4_repr = Ipv4Repr { let mut ipv4_repr = Ipv4Repr {
src_addr: Ipv4Address::UNSPECIFIED, src_addr: Ipv4Address::UNSPECIFIED,
dst_addr: Ipv4Address::BROADCAST, dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 0, // filled right before emit payload_len: 0, // filled right before emit
hop_limit: 64, hop_limit: 64,
}; };
@ -606,7 +606,7 @@ mod test {
let _ = s let _ = s
.socket .socket
.dispatch(&mut s.cx, |_, (mut ip_repr, udp_repr, dhcp_repr)| { .dispatch(&mut s.cx, |_, (mut ip_repr, udp_repr, dhcp_repr)| {
assert_eq!(ip_repr.protocol, IpProtocol::Udp); assert_eq!(ip_repr.next_header, IpProtocol::Udp);
assert_eq!( assert_eq!(
ip_repr.payload_len, ip_repr.payload_len,
udp_repr.header_len() + dhcp_repr.buffer_len() udp_repr.header_len() + dhcp_repr.buffer_len()
@ -671,7 +671,7 @@ mod test {
const IP_BROADCAST: Ipv4Repr = Ipv4Repr { const IP_BROADCAST: Ipv4Repr = Ipv4Repr {
src_addr: Ipv4Address::UNSPECIFIED, src_addr: Ipv4Address::UNSPECIFIED,
dst_addr: Ipv4Address::BROADCAST, dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 0, payload_len: 0,
hop_limit: 64, hop_limit: 64,
}; };
@ -679,7 +679,7 @@ mod test {
const IP_SERVER_BROADCAST: Ipv4Repr = Ipv4Repr { const IP_SERVER_BROADCAST: Ipv4Repr = Ipv4Repr {
src_addr: SERVER_IP, src_addr: SERVER_IP,
dst_addr: Ipv4Address::BROADCAST, dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 0, payload_len: 0,
hop_limit: 64, hop_limit: 64,
}; };
@ -687,7 +687,7 @@ mod test {
const IP_RECV: Ipv4Repr = Ipv4Repr { const IP_RECV: Ipv4Repr = Ipv4Repr {
src_addr: SERVER_IP, src_addr: SERVER_IP,
dst_addr: MY_IP, dst_addr: MY_IP,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 0, payload_len: 0,
hop_limit: 64, hop_limit: 64,
}; };
@ -695,7 +695,7 @@ mod test {
const IP_SEND: Ipv4Repr = Ipv4Repr { const IP_SEND: Ipv4Repr = Ipv4Repr {
src_addr: MY_IP, src_addr: MY_IP,
dst_addr: SERVER_IP, dst_addr: SERVER_IP,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 0, payload_len: 0,
hop_limit: 64, hop_limit: 64,
}; };

14
src/socket/icmp.rs
View File

@ -453,7 +453,7 @@ impl<'a> IcmpSocket<'a> {
let ip_repr = IpRepr::Ipv4(Ipv4Repr { let ip_repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address::default(), src_addr: Ipv4Address::default(),
dst_addr: ipv4_addr, dst_addr: ipv4_addr,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: repr.buffer_len(), payload_len: repr.buffer_len(),
hop_limit: hop_limit, hop_limit: hop_limit,
}); });
@ -549,7 +549,7 @@ mod test_ipv4 {
static LOCAL_IPV4_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr { static LOCAL_IPV4_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address::UNSPECIFIED, src_addr: Ipv4Address::UNSPECIFIED,
dst_addr: REMOTE_IPV4, dst_addr: REMOTE_IPV4,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: 24, payload_len: 24,
hop_limit: 0x40, hop_limit: 0x40,
}); });
@ -557,7 +557,7 @@ mod test_ipv4 {
static REMOTE_IPV4_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr { static REMOTE_IPV4_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr {
src_addr: REMOTE_IPV4, src_addr: REMOTE_IPV4,
dst_addr: LOCAL_IPV4, dst_addr: LOCAL_IPV4,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: 24, payload_len: 24,
hop_limit: 0x40, hop_limit: 0x40,
}); });
@ -650,7 +650,7 @@ mod test_ipv4 {
IpRepr::Ipv4(Ipv4Repr { IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address::UNSPECIFIED, src_addr: Ipv4Address::UNSPECIFIED,
dst_addr: REMOTE_IPV4, dst_addr: REMOTE_IPV4,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: ECHOV4_REPR.buffer_len(), payload_len: ECHOV4_REPR.buffer_len(),
hop_limit: 0x2a, hop_limit: 0x2a,
}) })
@ -741,7 +741,7 @@ mod test_ipv4 {
header: Ipv4Repr { header: Ipv4Repr {
src_addr: LOCAL_IPV4, src_addr: LOCAL_IPV4,
dst_addr: REMOTE_IPV4, dst_addr: REMOTE_IPV4,
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: 12, payload_len: 12,
hop_limit: 0x40, hop_limit: 0x40,
}, },
@ -750,7 +750,7 @@ mod test_ipv4 {
let ip_repr = IpRepr::Unspecified { let ip_repr = IpRepr::Unspecified {
src_addr: REMOTE_IPV4.into(), src_addr: REMOTE_IPV4.into(),
dst_addr: LOCAL_IPV4.into(), dst_addr: LOCAL_IPV4.into(),
protocol: IpProtocol::Icmp, next_header: IpProtocol::Icmp,
payload_len: icmp_repr.buffer_len(), payload_len: icmp_repr.buffer_len(),
hop_limit: 0x40, hop_limit: 0x40,
}; };
@ -1018,7 +1018,7 @@ mod test_ipv6 {
let ip_repr = IpRepr::Unspecified { let ip_repr = IpRepr::Unspecified {
src_addr: REMOTE_IPV6.into(), src_addr: REMOTE_IPV6.into(),
dst_addr: LOCAL_IPV6.into(), dst_addr: LOCAL_IPV6.into(),
protocol: IpProtocol::Icmpv6, next_header: IpProtocol::Icmpv6,
payload_len: icmp_repr.buffer_len(), payload_len: icmp_repr.buffer_len(),
hop_limit: 0x40, hop_limit: 0x40,
}; };

12
src/socket/raw.rs
View File

@ -205,7 +205,7 @@ impl<'a> RawSocket<'a> {
if ip_repr.version() != self.ip_version { if ip_repr.version() != self.ip_version {
return false; return false;
} }
if ip_repr.protocol() != self.ip_protocol { if ip_repr.next_header() != self.ip_protocol {
return false; return false;
} }
@ -244,7 +244,7 @@ impl<'a> RawSocket<'a> {
F: FnOnce(&mut Context, (IpRepr, &[u8])) -> Result<()>, F: FnOnce(&mut Context, (IpRepr, &[u8])) -> Result<()>,
{ {
fn prepare<'a>( fn prepare<'a>(
protocol: IpProtocol, next_header: IpProtocol,
buffer: &'a mut [u8], buffer: &'a mut [u8],
_checksum_caps: &ChecksumCapabilities, _checksum_caps: &ChecksumCapabilities,
) -> Result<(IpRepr, &'a [u8])> { ) -> Result<(IpRepr, &'a [u8])> {
@ -252,7 +252,7 @@ impl<'a> RawSocket<'a> {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
IpVersion::Ipv4 => { IpVersion::Ipv4 => {
let mut packet = Ipv4Packet::new_checked(buffer)?; let mut packet = Ipv4Packet::new_checked(buffer)?;
if packet.protocol() != protocol { if packet.next_header() != next_header {
return Err(Error::Unaddressable); return Err(Error::Unaddressable);
} }
if _checksum_caps.ipv4.tx() { if _checksum_caps.ipv4.tx() {
@ -270,7 +270,7 @@ impl<'a> RawSocket<'a> {
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
IpVersion::Ipv6 => { IpVersion::Ipv6 => {
let packet = Ipv6Packet::new_checked(buffer)?; let packet = Ipv6Packet::new_checked(buffer)?;
if packet.next_header() != protocol { if packet.next_header() != next_header {
return Err(Error::Unaddressable); return Err(Error::Unaddressable);
} }
let packet = Ipv6Packet::new_unchecked(&*packet.into_inner()); let packet = Ipv6Packet::new_unchecked(&*packet.into_inner());
@ -358,7 +358,7 @@ mod test {
pub const HEADER_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr { pub const HEADER_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address([10, 0, 0, 1]), src_addr: Ipv4Address([10, 0, 0, 1]),
dst_addr: Ipv4Address([10, 0, 0, 2]), dst_addr: Ipv4Address([10, 0, 0, 2]),
protocol: IpProtocol::Unknown(IP_PROTO), next_header: IpProtocol::Unknown(IP_PROTO),
payload_len: 4, payload_len: 4,
hop_limit: 64, hop_limit: 64,
}); });
@ -521,7 +521,7 @@ mod test {
assert_eq!(socket.dispatch(&mut cx, |_, _| unreachable!()), Ok(())); assert_eq!(socket.dispatch(&mut cx, |_, _| unreachable!()), Ok(()));
let mut wrong_protocol = ipv4_locals::PACKET_BYTES; let mut wrong_protocol = ipv4_locals::PACKET_BYTES;
Ipv4Packet::new_unchecked(&mut wrong_protocol).set_protocol(IpProtocol::Tcp); Ipv4Packet::new_unchecked(&mut wrong_protocol).set_next_header(IpProtocol::Tcp);
assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(())); assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(()));
assert_eq!(socket.dispatch(&mut cx, |_, _| unreachable!()), Ok(())); assert_eq!(socket.dispatch(&mut cx, |_, _| unreachable!()), Ok(()));

20
src/socket/tcp.rs
View File

@ -1140,7 +1140,7 @@ impl<'a> TcpSocket<'a> {
let ip_reply_repr = IpRepr::Unspecified { let ip_reply_repr = IpRepr::Unspecified {
src_addr: ip_repr.dst_addr(), src_addr: ip_repr.dst_addr(),
dst_addr: ip_repr.src_addr(), dst_addr: ip_repr.src_addr(),
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: reply_repr.buffer_len(), payload_len: reply_repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}; };
@ -2139,7 +2139,7 @@ impl<'a> TcpSocket<'a> {
let mut ip_repr = IpRepr::Unspecified { let mut ip_repr = IpRepr::Unspecified {
src_addr: self.local_endpoint.addr, src_addr: self.local_endpoint.addr,
dst_addr: self.remote_endpoint.addr, dst_addr: self.remote_endpoint.addr,
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
hop_limit: self.hop_limit.unwrap_or(64), hop_limit: self.hop_limit.unwrap_or(64),
payload_len: 0, payload_len: 0,
} }
@ -2443,7 +2443,7 @@ mod test {
const SEND_IP_TEMPL: IpRepr = IpRepr::Unspecified { const SEND_IP_TEMPL: IpRepr = IpRepr::Unspecified {
src_addr: MOCK_IP_ADDR_1, src_addr: MOCK_IP_ADDR_1,
dst_addr: MOCK_IP_ADDR_2, dst_addr: MOCK_IP_ADDR_2,
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: 20, payload_len: 20,
hop_limit: 64, hop_limit: 64,
}; };
@ -2463,7 +2463,7 @@ mod test {
const _RECV_IP_TEMPL: IpRepr = IpRepr::Unspecified { const _RECV_IP_TEMPL: IpRepr = IpRepr::Unspecified {
src_addr: MOCK_IP_ADDR_1, src_addr: MOCK_IP_ADDR_1,
dst_addr: MOCK_IP_ADDR_2, dst_addr: MOCK_IP_ADDR_2,
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: 20, payload_len: 20,
hop_limit: 64, hop_limit: 64,
}; };
@ -2518,7 +2518,7 @@ mod test {
let ip_repr = IpRepr::Unspecified { let ip_repr = IpRepr::Unspecified {
src_addr: MOCK_IP_ADDR_2, src_addr: MOCK_IP_ADDR_2,
dst_addr: MOCK_IP_ADDR_1, dst_addr: MOCK_IP_ADDR_1,
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: repr.buffer_len(), payload_len: repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}; };
@ -2547,7 +2547,7 @@ mod test {
.dispatch(&mut socket.cx, |_, (ip_repr, tcp_repr)| { .dispatch(&mut socket.cx, |_, (ip_repr, tcp_repr)| {
let ip_repr = ip_repr.lower(&[IpCidr::new(LOCAL_END.addr, 24)]).unwrap(); let ip_repr = ip_repr.lower(&[IpCidr::new(LOCAL_END.addr, 24)]).unwrap();
assert_eq!(ip_repr.protocol(), IpProtocol::Tcp); assert_eq!(ip_repr.next_header(), IpProtocol::Tcp);
assert_eq!(ip_repr.src_addr(), MOCK_IP_ADDR_1); assert_eq!(ip_repr.src_addr(), MOCK_IP_ADDR_1);
assert_eq!(ip_repr.dst_addr(), MOCK_IP_ADDR_2); assert_eq!(ip_repr.dst_addr(), MOCK_IP_ADDR_2);
assert_eq!(ip_repr.payload_len(), tcp_repr.buffer_len()); assert_eq!(ip_repr.payload_len(), tcp_repr.buffer_len());
@ -2641,7 +2641,7 @@ mod test {
fn socket_syn_sent_with_buffer_sizes(tx_len: usize, rx_len: usize) -> TestSocket { fn socket_syn_sent_with_buffer_sizes(tx_len: usize, rx_len: usize) -> TestSocket {
let mut s = socket_with_buffer_sizes(tx_len, rx_len); let mut s = socket_with_buffer_sizes(tx_len, rx_len);
s.state = State::SynSent; s.state = State::SynSent;
s.local_endpoint = IpEndpoint::new(MOCK_UNSPECIFIED, LOCAL_PORT); s.local_endpoint = LOCAL_END;
s.remote_endpoint = REMOTE_END; s.remote_endpoint = REMOTE_END;
s.local_seq_no = LOCAL_SEQ; s.local_seq_no = LOCAL_SEQ;
s.remote_last_seq = LOCAL_SEQ; s.remote_last_seq = LOCAL_SEQ;
@ -6948,7 +6948,7 @@ mod test {
let ip_repr = IpRepr::Unspecified { let ip_repr = IpRepr::Unspecified {
src_addr: MOCK_IP_ADDR_2, src_addr: MOCK_IP_ADDR_2,
dst_addr: MOCK_IP_ADDR_1, dst_addr: MOCK_IP_ADDR_1,
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: tcp_repr.buffer_len(), payload_len: tcp_repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}; };
@ -6957,7 +6957,7 @@ mod test {
let ip_repr_wrong_src = IpRepr::Unspecified { let ip_repr_wrong_src = IpRepr::Unspecified {
src_addr: MOCK_IP_ADDR_3, src_addr: MOCK_IP_ADDR_3,
dst_addr: MOCK_IP_ADDR_1, dst_addr: MOCK_IP_ADDR_1,
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: tcp_repr.buffer_len(), payload_len: tcp_repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}; };
@ -6966,7 +6966,7 @@ mod test {
let ip_repr_wrong_dst = IpRepr::Unspecified { let ip_repr_wrong_dst = IpRepr::Unspecified {
src_addr: MOCK_IP_ADDR_2, src_addr: MOCK_IP_ADDR_2,
dst_addr: MOCK_IP_ADDR_3, dst_addr: MOCK_IP_ADDR_3,
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: tcp_repr.buffer_len(), payload_len: tcp_repr.buffer_len(),
hop_limit: 64, hop_limit: 64,
}; };

10
src/socket/udp.rs
View File

@ -362,7 +362,7 @@ impl<'a> UdpSocket<'a> {
let ip_repr = IpRepr::Unspecified { let ip_repr = IpRepr::Unspecified {
src_addr: endpoint.addr, src_addr: endpoint.addr,
dst_addr: remote_endpoint.addr, dst_addr: remote_endpoint.addr,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: repr.header_len() + payload_buf.len(), payload_len: repr.header_len() + payload_buf.len(),
hop_limit: hop_limit, hop_limit: hop_limit,
}; };
@ -423,7 +423,7 @@ mod test {
pub const LOCAL_IP_REPR: IpRepr = IpRepr::Unspecified { pub const LOCAL_IP_REPR: IpRepr = IpRepr::Unspecified {
src_addr: MOCK_IP_ADDR_1, src_addr: MOCK_IP_ADDR_1,
dst_addr: MOCK_IP_ADDR_2, dst_addr: MOCK_IP_ADDR_2,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 8 + 6, payload_len: 8 + 6,
hop_limit: 64, hop_limit: 64,
}; };
@ -446,7 +446,7 @@ mod test {
(IpAddress::Ipv4(src), IpAddress::Ipv4(dst)) => IpRepr::Ipv4(Ipv4Repr { (IpAddress::Ipv4(src), IpAddress::Ipv4(dst)) => IpRepr::Ipv4(Ipv4Repr {
src_addr: src, src_addr: src,
dst_addr: dst, dst_addr: dst,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 8 + 6, payload_len: 8 + 6,
hop_limit: 64, hop_limit: 64,
}), }),
@ -655,7 +655,7 @@ mod test {
IpRepr::Unspecified { IpRepr::Unspecified {
src_addr: MOCK_IP_ADDR_1, src_addr: MOCK_IP_ADDR_1,
dst_addr: MOCK_IP_ADDR_2, dst_addr: MOCK_IP_ADDR_2,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 8 + 6, payload_len: 8 + 6,
hop_limit: 0x2a, hop_limit: 0x2a,
} }
@ -687,7 +687,7 @@ mod test {
(IpAddress::Ipv4(src), IpAddress::Ipv4(dst)) => IpRepr::Ipv4(Ipv4Repr { (IpAddress::Ipv4(src), IpAddress::Ipv4(dst)) => IpRepr::Ipv4(Ipv4Repr {
src_addr: src, src_addr: src,
dst_addr: dst, dst_addr: dst,
protocol: IpProtocol::Udp, next_header: IpProtocol::Udp,
payload_len: 8 + 6, payload_len: 8 + 6,
hop_limit: 64, hop_limit: 64,
}), }),

2
src/wire/icmpv4.rs
View File

@ -417,7 +417,7 @@ impl<'a> Repr<'a> {
header: Ipv4Repr { header: Ipv4Repr {
src_addr: ip_packet.src_addr(), src_addr: ip_packet.src_addr(),
dst_addr: ip_packet.dst_addr(), dst_addr: ip_packet.dst_addr(),
protocol: ip_packet.protocol(), next_header: ip_packet.next_header(),
payload_len: payload.len(), payload_len: payload.len(),
hop_limit: ip_packet.hop_limit(), hop_limit: ip_packet.hop_limit(),
}, },

68
src/wire/ip.rs
View File

@ -516,7 +516,7 @@ pub enum Repr {
Unspecified { Unspecified {
src_addr: Address, src_addr: Address,
dst_addr: Address, dst_addr: Address,
protocol: Protocol, next_header: Protocol,
payload_len: usize, payload_len: usize,
hop_limit: u8, hop_limit: u8,
}, },
@ -574,12 +574,12 @@ impl Repr {
} }
} }
/// Return the protocol. /// Return the next header (protocol).
pub fn protocol(&self) -> Protocol { pub fn next_header(&self) -> Protocol {
match *self { match *self {
Repr::Unspecified { protocol, .. } => protocol, Repr::Unspecified { next_header, .. } => next_header,
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
Repr::Ipv4(repr) => repr.protocol, Repr::Ipv4(repr) => repr.next_header,
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
Repr::Ipv6(repr) => repr.next_header, Repr::Ipv6(repr) => repr.next_header,
} }
@ -658,14 +658,14 @@ impl Repr {
&Repr::Unspecified { &Repr::Unspecified {
src_addr: src_addr @ Address::Unspecified, src_addr: src_addr @ Address::Unspecified,
dst_addr: Address::Ipv4(dst_addr), dst_addr: Address::Ipv4(dst_addr),
protocol, next_header,
payload_len, payload_len,
hop_limit, hop_limit,
} }
| &Repr::Unspecified { | &Repr::Unspecified {
src_addr: src_addr @ Address::Ipv4(_), src_addr: src_addr @ Address::Ipv4(_),
dst_addr: Address::Ipv4(dst_addr), dst_addr: Address::Ipv4(dst_addr),
protocol, next_header,
payload_len, payload_len,
hop_limit, hop_limit,
} if src_addr.is_unspecified() => { } if src_addr.is_unspecified() => {
@ -683,7 +683,7 @@ impl Repr {
Ok(Repr::Ipv4(Ipv4Repr { Ok(Repr::Ipv4(Ipv4Repr {
src_addr: src_addr.ok_or(Error::Unaddressable)?, src_addr: src_addr.ok_or(Error::Unaddressable)?,
dst_addr, dst_addr,
protocol, next_header,
payload_len, payload_len,
hop_limit, hop_limit,
})) }))
@ -693,14 +693,14 @@ impl Repr {
&Repr::Unspecified { &Repr::Unspecified {
src_addr: src_addr @ Address::Unspecified, src_addr: src_addr @ Address::Unspecified,
dst_addr: Address::Ipv6(dst_addr), dst_addr: Address::Ipv6(dst_addr),
protocol, next_header: protocol,
payload_len, payload_len,
hop_limit, hop_limit,
} }
| &Repr::Unspecified { | &Repr::Unspecified {
src_addr: src_addr @ Address::Ipv6(_), src_addr: src_addr @ Address::Ipv6(_),
dst_addr: Address::Ipv6(dst_addr), dst_addr: Address::Ipv6(dst_addr),
protocol, next_header: protocol,
payload_len, payload_len,
hop_limit, hop_limit,
} if src_addr.is_unspecified() => { } if src_addr.is_unspecified() => {
@ -728,13 +728,13 @@ impl Repr {
&Repr::Unspecified { &Repr::Unspecified {
src_addr: Address::Ipv4(src_addr), src_addr: Address::Ipv4(src_addr),
dst_addr: Address::Ipv4(dst_addr), dst_addr: Address::Ipv4(dst_addr),
protocol, next_header: protocol,
payload_len, payload_len,
hop_limit, hop_limit,
} => Ok(Repr::Ipv4(Ipv4Repr { } => Ok(Repr::Ipv4(Ipv4Repr {
src_addr: src_addr, src_addr: src_addr,
dst_addr: dst_addr, dst_addr: dst_addr,
protocol: protocol, next_header: protocol,
payload_len: payload_len, payload_len: payload_len,
hop_limit, hop_limit,
})), })),
@ -743,7 +743,7 @@ impl Repr {
&Repr::Unspecified { &Repr::Unspecified {
src_addr: Address::Ipv6(src_addr), src_addr: Address::Ipv6(src_addr),
dst_addr: Address::Ipv6(dst_addr), dst_addr: Address::Ipv6(dst_addr),
protocol, next_header: protocol,
payload_len, payload_len,
hop_limit, hop_limit,
} => Ok(Repr::Ipv6(Ipv6Repr { } => Ok(Repr::Ipv6(Ipv6Repr {
@ -869,14 +869,14 @@ pub mod checksum {
pub fn pseudo_header( pub fn pseudo_header(
src_addr: &Address, src_addr: &Address,
dst_addr: &Address, dst_addr: &Address,
protocol: Protocol, next_header: Protocol,
length: u32, length: u32,
) -> u16 { ) -> u16 {
match (src_addr, dst_addr) { match (src_addr, dst_addr) {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
(&Address::Ipv4(src_addr), &Address::Ipv4(dst_addr)) => { (&Address::Ipv4(src_addr), &Address::Ipv4(dst_addr)) => {
let mut proto_len = [0u8; 4]; let mut proto_len = [0u8; 4];
proto_len[1] = protocol.into(); proto_len[1] = next_header.into();
NetworkEndian::write_u16(&mut proto_len[2..4], length as u16); NetworkEndian::write_u16(&mut proto_len[2..4], length as u16);
combine(&[ combine(&[
@ -889,7 +889,7 @@ pub mod checksum {
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
(&Address::Ipv6(src_addr), &Address::Ipv6(dst_addr)) => { (&Address::Ipv6(src_addr), &Address::Ipv6(dst_addr)) => {
let mut proto_len = [0u8; 8]; let mut proto_len = [0u8; 8];
proto_len[7] = protocol.into(); proto_len[7] = next_header.into();
NetworkEndian::write_u32(&mut proto_len[0..4], length); NetworkEndian::write_u32(&mut proto_len[0..4], length);
combine(&[ combine(&[
data(src_addr.as_bytes()), data(src_addr.as_bytes()),
@ -932,7 +932,7 @@ pub fn pretty_print_ip_payload<T: Into<Repr>>(
let checksum_caps = ChecksumCapabilities::ignored(); let checksum_caps = ChecksumCapabilities::ignored();
let repr = ip_repr.into(); let repr = ip_repr.into();
match repr.protocol() { match repr.next_header() {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
Protocol::Icmp => { Protocol::Icmp => {
indent.increase(f)?; indent.increase(f)?;
@ -1033,7 +1033,7 @@ pub(crate) mod test {
macro_rules! generate_common_tests { macro_rules! generate_common_tests {
($name:ident, $repr:ident, $ip_repr:path, $ip_addr:path, ($name:ident, $repr:ident, $ip_repr:path, $ip_addr:path,
$addr_from:path, $nxthdr:ident, $bytes_a:expr, $bytes_b:expr, $addr_from:path, $bytes_a:expr, $bytes_b:expr,
$unspecified:expr) => { $unspecified:expr) => {
mod $name { mod $name {
use super::*; use super::*;
@ -1049,7 +1049,7 @@ pub(crate) mod test {
Repr::Unspecified { Repr::Unspecified {
src_addr: $ip_addr(ip_addr_a), src_addr: $ip_addr(ip_addr_a),
dst_addr: $ip_addr(ip_addr_b), dst_addr: $ip_addr(ip_addr_b),
protocol: proto, next_header: proto,
hop_limit: 0x2a, hop_limit: 0x2a,
payload_len, payload_len,
} }
@ -1057,7 +1057,7 @@ pub(crate) mod test {
Ok($ip_repr($repr { Ok($ip_repr($repr {
src_addr: ip_addr_a, src_addr: ip_addr_a,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 0x2a, hop_limit: 0x2a,
payload_len payload_len
})) }))
@ -1067,7 +1067,7 @@ pub(crate) mod test {
Repr::Unspecified { Repr::Unspecified {
src_addr: IpAddress::Unspecified, src_addr: IpAddress::Unspecified,
dst_addr: $ip_addr(ip_addr_b), dst_addr: $ip_addr(ip_addr_b),
protocol: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
} }
@ -1079,7 +1079,7 @@ pub(crate) mod test {
Repr::Unspecified { Repr::Unspecified {
src_addr: IpAddress::Unspecified, src_addr: IpAddress::Unspecified,
dst_addr: $ip_addr(ip_addr_b), dst_addr: $ip_addr(ip_addr_b),
protocol: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
} }
@ -1087,7 +1087,7 @@ pub(crate) mod test {
Ok($ip_repr($repr { Ok($ip_repr($repr {
src_addr: ip_addr_a, src_addr: ip_addr_a,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
})) }))
@ -1097,7 +1097,7 @@ pub(crate) mod test {
Repr::Unspecified { Repr::Unspecified {
src_addr: $ip_addr($unspecified), src_addr: $ip_addr($unspecified),
dst_addr: $ip_addr(ip_addr_b), dst_addr: $ip_addr(ip_addr_b),
protocol: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
} }
@ -1105,7 +1105,7 @@ pub(crate) mod test {
Ok($ip_repr($repr { Ok($ip_repr($repr {
src_addr: ip_addr_a, src_addr: ip_addr_a,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
})) }))
@ -1115,7 +1115,7 @@ pub(crate) mod test {
Repr::Unspecified { Repr::Unspecified {
src_addr: $ip_addr($unspecified), src_addr: $ip_addr($unspecified),
dst_addr: $ip_addr(ip_addr_b), dst_addr: $ip_addr(ip_addr_b),
protocol: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
} }
@ -1123,7 +1123,7 @@ pub(crate) mod test {
Ok($ip_repr($repr { Ok($ip_repr($repr {
src_addr: $unspecified, src_addr: $unspecified,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
})) }))
@ -1133,7 +1133,7 @@ pub(crate) mod test {
$ip_repr($repr { $ip_repr($repr {
src_addr: ip_addr_a, src_addr: ip_addr_a,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 255, hop_limit: 255,
payload_len payload_len
}) })
@ -1141,7 +1141,7 @@ pub(crate) mod test {
Ok($ip_repr($repr { Ok($ip_repr($repr {
src_addr: ip_addr_a, src_addr: ip_addr_a,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 255, hop_limit: 255,
payload_len payload_len
})) }))
@ -1151,7 +1151,7 @@ pub(crate) mod test {
$ip_repr($repr { $ip_repr($repr {
src_addr: $unspecified, src_addr: $unspecified,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 255, hop_limit: 255,
payload_len payload_len
}) })
@ -1163,7 +1163,7 @@ pub(crate) mod test {
$ip_repr($repr { $ip_repr($repr {
src_addr: $unspecified, src_addr: $unspecified,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
}) })
@ -1171,7 +1171,7 @@ pub(crate) mod test {
Ok($ip_repr($repr { Ok($ip_repr($repr {
src_addr: ip_addr_a, src_addr: ip_addr_a,
dst_addr: ip_addr_b, dst_addr: ip_addr_b,
$nxthdr: proto, next_header: proto,
hop_limit: 64, hop_limit: 64,
payload_len payload_len
})) }))
@ -1186,7 +1186,6 @@ pub(crate) mod test {
Repr::Ipv4, Repr::Ipv4,
IpAddress::Ipv4, IpAddress::Ipv4,
Ipv4Address::from_bytes, Ipv4Address::from_bytes,
protocol,
$addr_bytes_a, $addr_bytes_a,
$addr_bytes_b, $addr_bytes_b,
Ipv4Address::UNSPECIFIED Ipv4Address::UNSPECIFIED
@ -1199,7 +1198,6 @@ pub(crate) mod test {
Repr::Ipv6, Repr::Ipv6,
IpAddress::Ipv6, IpAddress::Ipv6,
Ipv6Address::from_bytes, Ipv6Address::from_bytes,
next_header,
$addr_bytes_a, $addr_bytes_a,
$addr_bytes_b, $addr_bytes_b,
Ipv6Address::UNSPECIFIED Ipv6Address::UNSPECIFIED
@ -1224,7 +1222,7 @@ pub(crate) mod test {
Repr::Unspecified { Repr::Unspecified {
src_addr: Address::Ipv6(Ipv6Address::UNSPECIFIED), src_addr: Address::Ipv6(Ipv6Address::UNSPECIFIED),
dst_addr: Address::Ipv4(Ipv4Address::UNSPECIFIED), dst_addr: Address::Ipv4(Ipv4Address::UNSPECIFIED),
protocol: IpProtocol::Icmpv6, next_header: IpProtocol::Icmpv6,
hop_limit: 0xff, hop_limit: 0xff,
payload_len: 0, payload_len: 0,
} }

24
src/wire/ipv4.rs
View File

@ -396,9 +396,9 @@ impl<T: AsRef<[u8]>> Packet<T> {
data[field::TTL] data[field::TTL]
} }
/// Return the protocol field. /// Return the next_header (protocol) field.
#[inline] #[inline]
pub fn protocol(&self) -> Protocol { pub fn next_header(&self) -> Protocol {
let data = self.buffer.as_ref(); let data = self.buffer.as_ref();
Protocol::from(data[field::PROTOCOL]) Protocol::from(data[field::PROTOCOL])
} }
@ -532,9 +532,9 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
data[field::TTL] = value data[field::TTL] = value
} }
/// Set the protocol field. /// Set the next header (protocol) field.
#[inline] #[inline]
pub fn set_protocol(&mut self, value: Protocol) { pub fn set_next_header(&mut self, value: Protocol) {
let data = self.buffer.as_mut(); let data = self.buffer.as_mut();
data[field::PROTOCOL] = value.into() data[field::PROTOCOL] = value.into()
} }
@ -591,7 +591,7 @@ impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
pub struct Repr { pub struct Repr {
pub src_addr: Address, pub src_addr: Address,
pub dst_addr: Address, pub dst_addr: Address,
pub protocol: Protocol, pub next_header: Protocol,
pub payload_len: usize, pub payload_len: usize,
pub hop_limit: u8, pub hop_limit: u8,
} }
@ -626,7 +626,7 @@ impl Repr {
Ok(Repr { Ok(Repr {
src_addr: packet.src_addr(), src_addr: packet.src_addr(),
dst_addr: packet.dst_addr(), dst_addr: packet.dst_addr(),
protocol: packet.protocol(), next_header: packet.next_header(),
payload_len: payload_len, payload_len: payload_len,
hop_limit: packet.hop_limit(), hop_limit: packet.hop_limit(),
}) })
@ -656,7 +656,7 @@ impl Repr {
packet.set_dont_frag(true); packet.set_dont_frag(true);
packet.set_frag_offset(0); packet.set_frag_offset(0);
packet.set_hop_limit(self.hop_limit); packet.set_hop_limit(self.hop_limit);
packet.set_protocol(self.protocol); packet.set_next_header(self.next_header);
packet.set_src_addr(self.src_addr); packet.set_src_addr(self.src_addr);
packet.set_dst_addr(self.dst_addr); packet.set_dst_addr(self.dst_addr);
@ -681,7 +681,7 @@ impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
" src={} dst={} proto={} hop_limit={}", " src={} dst={} proto={} hop_limit={}",
self.src_addr(), self.src_addr(),
self.dst_addr(), self.dst_addr(),
self.protocol(), self.next_header(),
self.hop_limit() self.hop_limit()
)?; )?;
if self.version() != 4 { if self.version() != 4 {
@ -720,7 +720,7 @@ impl fmt::Display for Repr {
write!( write!(
f, f,
"IPv4 src={} dst={} proto={}", "IPv4 src={} dst={} proto={}",
self.src_addr, self.dst_addr, self.protocol self.src_addr, self.dst_addr, self.next_header
) )
} }
} }
@ -777,7 +777,7 @@ mod test {
assert!(packet.dont_frag()); assert!(packet.dont_frag());
assert_eq!(packet.frag_offset(), 0x203 * 8); assert_eq!(packet.frag_offset(), 0x203 * 8);
assert_eq!(packet.hop_limit(), 0x1a); assert_eq!(packet.hop_limit(), 0x1a);
assert_eq!(packet.protocol(), Protocol::Icmp); assert_eq!(packet.next_header(), Protocol::Icmp);
assert_eq!(packet.checksum(), 0xd56e); assert_eq!(packet.checksum(), 0xd56e);
assert_eq!(packet.src_addr(), Address([0x11, 0x12, 0x13, 0x14])); assert_eq!(packet.src_addr(), Address([0x11, 0x12, 0x13, 0x14]));
assert_eq!(packet.dst_addr(), Address([0x21, 0x22, 0x23, 0x24])); assert_eq!(packet.dst_addr(), Address([0x21, 0x22, 0x23, 0x24]));
@ -800,7 +800,7 @@ mod test {
packet.set_dont_frag(true); packet.set_dont_frag(true);
packet.set_frag_offset(0x203 * 8); packet.set_frag_offset(0x203 * 8);
packet.set_hop_limit(0x1a); packet.set_hop_limit(0x1a);
packet.set_protocol(Protocol::Icmp); packet.set_next_header(Protocol::Icmp);
packet.set_src_addr(Address([0x11, 0x12, 0x13, 0x14])); packet.set_src_addr(Address([0x11, 0x12, 0x13, 0x14]));
packet.set_dst_addr(Address([0x21, 0x22, 0x23, 0x24])); packet.set_dst_addr(Address([0x21, 0x22, 0x23, 0x24]));
packet.fill_checksum(); packet.fill_checksum();
@ -844,7 +844,7 @@ mod test {
Repr { Repr {
src_addr: Address([0x11, 0x12, 0x13, 0x14]), src_addr: Address([0x11, 0x12, 0x13, 0x14]),
dst_addr: Address([0x21, 0x22, 0x23, 0x24]), dst_addr: Address([0x21, 0x22, 0x23, 0x24]),
protocol: Protocol::Icmp, next_header: Protocol::Icmp,
payload_len: 4, payload_len: 4,
hop_limit: 64, hop_limit: 64,
} }

2
src/wire/mod.rs
View File

@ -50,7 +50,7 @@ use smoltcp::wire::*;
let repr = Ipv4Repr { let repr = Ipv4Repr {
src_addr: Ipv4Address::new(10, 0, 0, 1), src_addr: Ipv4Address::new(10, 0, 0, 1),
dst_addr: Ipv4Address::new(10, 0, 0, 2), dst_addr: Ipv4Address::new(10, 0, 0, 2),
protocol: IpProtocol::Tcp, next_header: IpProtocol::Tcp,
payload_len: 10, payload_len: 10,
hop_limit: 64 hop_limit: 64
}; };