Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Remove check macro #840

Closed
wants to merge 2 commits into from
Closed

Remove check macro #840

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
0e98746
remove check macro
thvdveld Sep 12, 2023
9a850cf
make sure a PAN ID is set for the tests
thvdveld Sep 12, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 12 additions & 11 deletions src/iface/interface/ethernet.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,3 @@
use super::check;
use super::DispatchError;
use super::EthernetPacket;
use super::FragmentsBuffer;
Expand All @@ -17,35 +16,37 @@ impl InterfaceInner {
meta: crate::phy::PacketMeta,
frame: &'frame [u8],
fragments: &'frame mut FragmentsBuffer,
) -> Option<EthernetPacket<'frame>> {
let eth_frame = check!(EthernetFrame::new_checked(frame));
) -> crate::wire::Result<Option<EthernetPacket<'frame>>> {
let eth_frame = EthernetFrame::new_checked(frame)?;

// Ignore any packets not directed to our hardware address or any of the multicast groups.
if !eth_frame.dst_addr().is_broadcast()
&& !eth_frame.dst_addr().is_multicast()
&& HardwareAddress::Ethernet(eth_frame.dst_addr()) != self.hardware_addr
{
return None;
return Ok(None);
}

match eth_frame.ethertype() {
#[cfg(feature = "proto-ipv4")]
EthernetProtocol::Arp => self.process_arp(self.now, &eth_frame),
#[cfg(feature = "proto-ipv4")]
EthernetProtocol::Ipv4 => {
let ipv4_packet = check!(Ipv4Packet::new_checked(eth_frame.payload()));
let ipv4_packet = Ipv4Packet::new_checked(eth_frame.payload())?;

self.process_ipv4(sockets, meta, &ipv4_packet, fragments)
.map(EthernetPacket::Ip)
Ok(self
.process_ipv4(sockets, meta, &ipv4_packet, fragments)?
.map(EthernetPacket::Ip))
}
#[cfg(feature = "proto-ipv6")]
EthernetProtocol::Ipv6 => {
let ipv6_packet = check!(Ipv6Packet::new_checked(eth_frame.payload()));
self.process_ipv6(sockets, meta, &ipv6_packet)
.map(EthernetPacket::Ip)
let ipv6_packet = Ipv6Packet::new_checked(eth_frame.payload())?;
Ok(self
.process_ipv6(sockets, meta, &ipv6_packet)?
.map(EthernetPacket::Ip))
}
// Drop all other traffic.
_ => None,
_ => Ok(None),
}
}

Expand Down
12 changes: 6 additions & 6 deletions src/iface/interface/ieee802154.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,12 +10,12 @@ impl InterfaceInner {
meta: PacketMeta,
sixlowpan_payload: &'payload [u8],
_fragments: &'output mut FragmentsBuffer,
) -> Option<IpPacket<'output>> {
let ieee802154_frame = check!(Ieee802154Frame::new_checked(sixlowpan_payload));
let ieee802154_repr = check!(Ieee802154Repr::parse(&ieee802154_frame));
) -> crate::wire::Result<Option<IpPacket<'output>>> {
let ieee802154_frame = Ieee802154Frame::new_checked(sixlowpan_payload)?;
let ieee802154_repr = Ieee802154Repr::parse(&ieee802154_frame)?;

if ieee802154_repr.frame_type != Ieee802154FrameType::Data {
return None;
return Ok(None);
}

// Drop frames when the user has set a PAN id and the PAN id from frame is not equal to this
Expand All @@ -29,14 +29,14 @@ impl InterfaceInner {
"IEEE802.15.4: dropping {:?} because not our PAN id (or not broadcast)",
ieee802154_repr
);
return None;
return Ok(None);
}

match ieee802154_frame.payload() {
Some(payload) => {
self.process_sixlowpan(sockets, meta, &ieee802154_repr, payload, _fragments)
}
None => None,
None => Ok(None),
}
}

Expand Down
10 changes: 5 additions & 5 deletions src/iface/interface/igmp.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
use super::{check, IgmpReportState, Interface, InterfaceInner, IpPacket};
use super::{IgmpReportState, Interface, InterfaceInner, IpPacket};
use crate::phy::{Device, PacketMeta};
use crate::time::{Duration, Instant};
use crate::wire::*;
Expand Down Expand Up @@ -231,9 +231,9 @@ impl InterfaceInner {
&mut self,
ipv4_repr: Ipv4Repr,
ip_payload: &'frame [u8],
) -> Option<IpPacket<'frame>> {
let igmp_packet = check!(IgmpPacket::new_checked(ip_payload));
let igmp_repr = check!(IgmpRepr::parse(&igmp_packet));
) -> crate::wire::Result<Option<IpPacket<'frame>>> {
let igmp_packet = IgmpPacket::new_checked(ip_payload)?;
let igmp_repr = IgmpRepr::parse(&igmp_packet)?;

// FIXME: report membership after a delay
match igmp_repr {
Expand Down Expand Up @@ -284,6 +284,6 @@ impl InterfaceInner {
IgmpRepr::LeaveGroup { .. } => (),
}

None
Ok(None)
}
}
91 changes: 45 additions & 46 deletions src/iface/interface/ipv4.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,12 +17,12 @@ impl InterfaceInner {
meta: PacketMeta,
ipv4_packet: &Ipv4PacketWire<&'a [u8]>,
frag: &'a mut FragmentsBuffer,
) -> Option<IpPacket<'a>> {
let ipv4_repr = check!(Ipv4Repr::parse(ipv4_packet, &self.caps.checksum));
) -> crate::wire::Result<Option<IpPacket<'a>>> {
let ipv4_repr = Ipv4Repr::parse(ipv4_packet, &self.caps.checksum)?;
if !self.is_unicast_v4(ipv4_repr.src_addr) && !ipv4_repr.src_addr.is_unspecified() {
// Discard packets with non-unicast source addresses but allow unspecified
net_debug!("non-unicast or unspecified source address");
return None;
return Ok(None);
}

#[cfg(feature = "proto-ipv4-fragmentation")]
Expand All @@ -34,29 +34,32 @@ impl InterfaceInner {
Ok(f) => f,
Err(_) => {
net_debug!("No available packet assembler for fragmented packet");
return None;
return Ok(None);
}
};

if !ipv4_packet.more_frags() {
// This is the last fragment, so we know the total size
check!(f.set_total_size(
if let Err(e) = f.set_total_size(
ipv4_packet.total_len() as usize - ipv4_packet.header_len() as usize
+ ipv4_packet.frag_offset() as usize,
));
) {
net_trace!("fragmentation error: {}", e);
return Ok(None);
}
}

if let Err(e) = f.add(ipv4_packet.payload(), ipv4_packet.frag_offset() as usize) {
net_debug!("fragmentation error: {:?}", e);
return None;
return Ok(None);
}

// NOTE: according to the standard, the total length needs to be
// recomputed, as well as the checksum. However, we don't really use
// the IPv4 header after the packet is reassembled.
match f.assemble() {
Some(payload) => payload,
None => return None,
None => return Ok(None),
}
} else {
ipv4_packet.payload()
Expand All @@ -78,7 +81,7 @@ impl InterfaceInner {
if ipv4_repr.next_header == IpProtocol::Udp
&& matches!(self.caps.medium, Medium::Ethernet)
{
let udp_packet = check!(UdpPacket::new_checked(ip_payload));
let udp_packet = UdpPacket::new_checked(ip_payload)?;
if let Some(dhcp_socket) = sockets
.items_mut()
.find_map(|i| dhcpv4::Socket::downcast_mut(&mut i.socket))
Expand All @@ -89,16 +92,12 @@ impl InterfaceInner {
&& udp_packet.dst_port() == dhcp_socket.client_port
{
let (src_addr, dst_addr) = (ip_repr.src_addr(), ip_repr.dst_addr());
let udp_repr = check!(UdpRepr::parse(
&udp_packet,
&src_addr,
&dst_addr,
&self.caps.checksum
));
let udp_repr =
UdpRepr::parse(&udp_packet, &src_addr, &dst_addr, &self.caps.checksum)?;
let udp_payload = udp_packet.payload();

dhcp_socket.process(self, &ipv4_repr, &udp_repr, udp_payload);
return None;
return Ok(None);
}
}
}
Expand All @@ -117,7 +116,7 @@ impl InterfaceInner {
.lookup(&IpAddress::Ipv4(ipv4_repr.dst_addr), self.now)
.map_or(true, |router_addr| !self.has_ip_addr(router_addr))
{
return None;
return Ok(None);
}
}

Expand All @@ -129,13 +128,13 @@ impl InterfaceInner {

#[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
IpProtocol::Udp => {
let udp_packet = check!(UdpPacket::new_checked(ip_payload));
let udp_repr = check!(UdpRepr::parse(
let udp_packet = UdpPacket::new_checked(ip_payload)?;
let udp_repr = UdpRepr::parse(
&udp_packet,
&ipv4_repr.src_addr.into(),
&ipv4_repr.dst_addr.into(),
&self.checksum_caps(),
));
)?;

self.process_udp(
sockets,
Expand All @@ -151,7 +150,7 @@ impl InterfaceInner {
#[cfg(feature = "socket-tcp")]
IpProtocol::Tcp => self.process_tcp(sockets, ip_repr, ip_payload),

_ if handled_by_raw_socket => None,
_ if handled_by_raw_socket => Ok(None),

_ => {
// Send back as much of the original payload as we can.
Expand All @@ -172,9 +171,9 @@ impl InterfaceInner {
&mut self,
timestamp: Instant,
eth_frame: &EthernetFrame<&'frame [u8]>,
) -> Option<EthernetPacket<'frame>> {
let arp_packet = check!(ArpPacket::new_checked(eth_frame.payload()));
let arp_repr = check!(ArpRepr::parse(&arp_packet));
) -> crate::wire::Result<Option<EthernetPacket<'frame>>> {
let arp_packet = ArpPacket::new_checked(eth_frame.payload())?;
let arp_repr = ArpRepr::parse(&arp_packet)?;

match arp_repr {
ArpRepr::EthernetIpv4 {
Expand All @@ -186,24 +185,24 @@ impl InterfaceInner {
} => {
// Only process ARP packets for us.
if !self.has_ip_addr(target_protocol_addr) {
return None;
return Ok(None);
}

// Only process REQUEST and RESPONSE.
if let ArpOperation::Unknown(_) = operation {
net_debug!("arp: unknown operation code");
return None;
return Ok(None);
}

// Discard packets with non-unicast source addresses.
if !source_protocol_addr.is_unicast() || !source_hardware_addr.is_unicast() {
net_debug!("arp: non-unicast source address");
return None;
return Ok(None);
}

if !self.in_same_network(&IpAddress::Ipv4(source_protocol_addr)) {
net_debug!("arp: source IP address not in same network as us");
return None;
return Ok(None);
}

// Fill the ARP cache from any ARP packet aimed at us (both request or response).
Expand All @@ -219,15 +218,15 @@ impl InterfaceInner {
if operation == ArpOperation::Request {
let src_hardware_addr = self.hardware_addr.ethernet_or_panic();

Some(EthernetPacket::Arp(ArpRepr::EthernetIpv4 {
Ok(Some(EthernetPacket::Arp(ArpRepr::EthernetIpv4 {
operation: ArpOperation::Reply,
source_hardware_addr: src_hardware_addr,
source_protocol_addr: target_protocol_addr,
target_hardware_addr: source_hardware_addr,
target_protocol_addr: source_protocol_addr,
}))
})))
} else {
None
Ok(None)
}
}
}
Expand All @@ -238,9 +237,9 @@ impl InterfaceInner {
_sockets: &mut SocketSet,
ip_repr: IpRepr,
ip_payload: &'frame [u8],
) -> Option<IpPacket<'frame>> {
let icmp_packet = check!(Icmpv4Packet::new_checked(ip_payload));
let icmp_repr = check!(Icmpv4Repr::parse(&icmp_packet, &self.caps.checksum));
) -> crate::wire::Result<Option<IpPacket<'frame>>> {
let icmp_packet = Icmpv4Packet::new_checked(ip_payload)?;
let icmp_repr = Icmpv4Repr::parse(&icmp_packet, &self.caps.checksum)?;

#[cfg(feature = "socket-icmp")]
let mut handled_by_icmp_socket = false;
Expand Down Expand Up @@ -277,26 +276,26 @@ impl InterfaceInner {
}

// Ignore any echo replies.
Icmpv4Repr::EchoReply { .. } => None,
Icmpv4Repr::EchoReply { .. } => Ok(None),

// Don't report an error if a packet with unknown type
// has been handled by an ICMP socket
#[cfg(feature = "socket-icmp")]
_ if handled_by_icmp_socket => None,
_ if handled_by_icmp_socket => Ok(None),

// FIXME: do something correct here?
_ => None,
_ => Ok(None),
}
}

pub(super) fn icmpv4_reply<'frame, 'icmp: 'frame>(
&self,
ipv4_repr: Ipv4Repr,
icmp_repr: Icmpv4Repr<'icmp>,
) -> Option<IpPacket<'frame>> {
) -> crate::wire::Result<Option<IpPacket<'frame>>> {
if !self.is_unicast_v4(ipv4_repr.src_addr) {
// Do not send ICMP replies to non-unicast sources
None
Ok(None)
} else if self.is_unicast_v4(ipv4_repr.dst_addr) {
// Reply as normal when src_addr and dst_addr are both unicast
let ipv4_reply_repr = Ipv4Repr {
Expand All @@ -306,10 +305,10 @@ impl InterfaceInner {
payload_len: icmp_repr.buffer_len(),
hop_limit: 64,
};
Some(IpPacket::new_ipv4(
Ok(Some(IpPacket::new_ipv4(
ipv4_reply_repr,
IpPayload::Icmpv4(icmp_repr),
))
)))
} else if self.is_broadcast_v4(ipv4_repr.dst_addr) {
// Only reply to broadcasts for echo replies and not other ICMP messages
match icmp_repr {
Expand All @@ -322,17 +321,17 @@ impl InterfaceInner {
payload_len: icmp_repr.buffer_len(),
hop_limit: 64,
};
Some(IpPacket::new_ipv4(
Ok(Some(IpPacket::new_ipv4(
ipv4_reply_repr,
IpPayload::Icmpv4(icmp_repr),
))
)))
}
None => None,
None => Ok(None),
},
_ => None,
_ => Ok(None),
}
} else {
None
Ok(None)
}
}

Expand Down
Loading
Loading