renet/renet
renet
/
renet
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename `new` method on Packet types to `new_checked`. 

Fixes #195.

Closes: #254
Approved by: dlrobertson
This commit is contained in:
whitequark 2018-07-11 00:22:43 +00:00 committed by Homu
parent 8a214f3850
commit 5bcb358eb5
24 changed files with 325 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
examples/ping.rs
View File

@ -35,7 +35,7 @@ macro_rules! send_icmp_ping {
.send(icmp_repr.buffer_len(), $remote_addr) .send(icmp_repr.buffer_len(), $remote_addr)
.unwrap(); .unwrap();
let mut icmp_packet = $packet_type::new(icmp_payload); let mut icmp_packet = $packet_type::new_unchecked(icmp_payload);
(icmp_repr, icmp_packet) (icmp_repr, icmp_packet)
}} }}
} }
@ -168,13 +168,14 @@ fn main() {
match remote_addr { match remote_addr {
IpAddress::Ipv4(_) => { IpAddress::Ipv4(_) => {
let icmp_packet = Icmpv4Packet::new(&payload); let icmp_packet = Icmpv4Packet::new_checked(&payload).unwrap();
let icmp_repr = Icmpv4Repr::parse(&icmp_packet, &device_caps.checksum).unwrap(); let icmp_repr =
Icmpv4Repr::parse(&icmp_packet, &device_caps.checksum).unwrap();
get_icmp_pong!(Icmpv4Repr, icmp_repr, payload, get_icmp_pong!(Icmpv4Repr, icmp_repr, payload,
waiting_queue, remote_addr, timestamp, received); waiting_queue, remote_addr, timestamp, received);
} }
IpAddress::Ipv6(_) => { IpAddress::Ipv6(_) => {
let icmp_packet = Icmpv6Packet::new(&payload); let icmp_packet = Icmpv6Packet::new_checked(&payload).unwrap();
let icmp_repr = Icmpv6Repr::parse(&remote_addr, &src_ipv6, let icmp_repr = Icmpv6Repr::parse(&remote_addr, &src_ipv6,
&icmp_packet, &device_caps.checksum).unwrap(); &icmp_packet, &device_caps.checksum).unwrap();
get_icmp_pong!(Icmpv6Repr, icmp_repr, payload, get_icmp_pong!(Icmpv6Repr, icmp_repr, payload,

58
src/iface/ethernet.rs
View File

@ -1076,7 +1076,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
frame.set_dst_addr(dst_hardware_addr); frame.set_dst_addr(dst_hardware_addr);
frame.set_ethertype(EthernetProtocol::Arp); frame.set_ethertype(EthernetProtocol::Arp);
let mut packet = ArpPacket::new(frame.payload_mut()); let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
arp_repr.emit(&mut packet); arp_repr.emit(&mut packet);
}) })
}, },
@ -1084,7 +1084,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
Packet::Icmpv4((ipv4_repr, icmpv4_repr)) => { Packet::Icmpv4((ipv4_repr, icmpv4_repr)) => {
self.dispatch_ip(tx_token, timestamp, IpRepr::Ipv4(ipv4_repr), self.dispatch_ip(tx_token, timestamp, IpRepr::Ipv4(ipv4_repr),
|_ip_repr, payload| { |_ip_repr, payload| {
icmpv4_repr.emit(&mut Icmpv4Packet::new(payload), &checksum_caps); icmpv4_repr.emit(&mut Icmpv4Packet::new_unchecked(payload), &checksum_caps);
}) })
} }
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
@ -1092,7 +1092,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
self.dispatch_ip(tx_token, timestamp, IpRepr::Ipv6(ipv6_repr), self.dispatch_ip(tx_token, timestamp, IpRepr::Ipv6(ipv6_repr),
|ip_repr, payload| { |ip_repr, payload| {
icmpv6_repr.emit(&ip_repr.src_addr(), &ip_repr.dst_addr(), icmpv6_repr.emit(&ip_repr.src_addr(), &ip_repr.dst_addr(),
&mut Icmpv6Packet::new(payload), &checksum_caps); &mut Icmpv6Packet::new_unchecked(payload), &checksum_caps);
}) })
} }
#[cfg(feature = "socket-raw")] #[cfg(feature = "socket-raw")]
@ -1104,7 +1104,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
#[cfg(feature = "socket-udp")] #[cfg(feature = "socket-udp")]
Packet::Udp((ip_repr, udp_repr)) => { Packet::Udp((ip_repr, udp_repr)) => {
self.dispatch_ip(tx_token, timestamp, ip_repr, |ip_repr, payload| { self.dispatch_ip(tx_token, timestamp, ip_repr, |ip_repr, payload| {
udp_repr.emit(&mut UdpPacket::new(payload), udp_repr.emit(&mut UdpPacket::new_unchecked(payload),
&ip_repr.src_addr(), &ip_repr.dst_addr(), &ip_repr.src_addr(), &ip_repr.dst_addr(),
&checksum_caps); &checksum_caps);
}) })
@ -1132,7 +1132,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
} }
} }
tcp_repr.emit(&mut TcpPacket::new(payload), tcp_repr.emit(&mut TcpPacket::new_unchecked(payload),
&ip_repr.src_addr(), &ip_repr.dst_addr(), &ip_repr.src_addr(), &ip_repr.dst_addr(),
&checksum_caps); &checksum_caps);
}) })
@ -1148,7 +1148,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
let tx_len = EthernetFrame::<&[u8]>::buffer_len(buffer_len); let tx_len = EthernetFrame::<&[u8]>::buffer_len(buffer_len);
tx_token.consume(timestamp, tx_len, |tx_buffer| { tx_token.consume(timestamp, tx_len, |tx_buffer| {
debug_assert!(tx_buffer.as_ref().len() == tx_len); debug_assert!(tx_buffer.as_ref().len() == tx_len);
let mut frame = EthernetFrame::new(tx_buffer.as_mut()); let mut frame = EthernetFrame::new_unchecked(tx_buffer.as_mut());
frame.set_src_addr(self.ethernet_addr); frame.set_src_addr(self.ethernet_addr);
f(frame); f(frame);
@ -1254,7 +1254,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
frame.set_dst_addr(EthernetAddress::BROADCAST); frame.set_dst_addr(EthernetAddress::BROADCAST);
frame.set_ethertype(EthernetProtocol::Arp); frame.set_ethertype(EthernetProtocol::Arp);
arp_repr.emit(&mut ArpPacket::new(frame.payload_mut())) arp_repr.emit(&mut ArpPacket::new_unchecked(frame.payload_mut()))
})?; })?;
Err(Error::Unaddressable) Err(Error::Unaddressable)
@ -1282,7 +1282,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
self.dispatch_ip(tx_token, timestamp, ip_repr, |ip_repr, payload| { self.dispatch_ip(tx_token, timestamp, ip_repr, |ip_repr, payload| {
solicit.emit(&ip_repr.src_addr(), &ip_repr.dst_addr(), solicit.emit(&ip_repr.src_addr(), &ip_repr.dst_addr(),
&mut Icmpv6Packet::new(payload), &checksum_caps); &mut Icmpv6Packet::new_unchecked(payload), &checksum_caps);
})?; })?;
Err(Error::Unaddressable) Err(Error::Unaddressable)
@ -1419,12 +1419,12 @@ mod test {
}); });
let frame = { let frame = {
let mut frame = EthernetFrame::new(&mut eth_bytes); let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
frame.set_dst_addr(EthernetAddress::BROADCAST); frame.set_dst_addr(EthernetAddress::BROADCAST);
frame.set_src_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00])); frame.set_src_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]));
frame.set_ethertype(EthernetProtocol::Ipv4); frame.set_ethertype(EthernetProtocol::Ipv4);
repr.emit(frame.payload_mut(), &ChecksumCapabilities::default()); repr.emit(frame.payload_mut(), &ChecksumCapabilities::default());
EthernetFrame::new(&*frame.into_inner()) EthernetFrame::new_unchecked(&*frame.into_inner())
}; };
// Ensure that the unknown protocol frame does not trigger an // Ensure that the unknown protocol frame does not trigger an
@ -1457,12 +1457,12 @@ mod test {
// emit the above repr to a frame // emit the above repr to a frame
let frame = { let frame = {
let mut frame = EthernetFrame::new(&mut eth_bytes); let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
frame.set_dst_addr(EthernetAddress([0x00, 0x00, 0x00, 0x00, 0x00, 0x00])); frame.set_dst_addr(EthernetAddress([0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
frame.set_src_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00])); frame.set_src_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]));
frame.set_ethertype(EthernetProtocol::Ipv4); frame.set_ethertype(EthernetProtocol::Ipv4);
repr.emit(frame.payload_mut(), &ChecksumCapabilities::default()); repr.emit(frame.payload_mut(), &ChecksumCapabilities::default());
EthernetFrame::new(&*frame.into_inner()) EthernetFrame::new_unchecked(&*frame.into_inner())
}; };
// The expected Destination Unreachable response due to the // The expected Destination Unreachable response due to the
@ -1508,8 +1508,8 @@ mod test {
let mut udp_bytes_unicast = vec![0u8; 20]; let mut udp_bytes_unicast = vec![0u8; 20];
let mut udp_bytes_broadcast = vec![0u8; 20]; let mut udp_bytes_broadcast = vec![0u8; 20];
let mut packet_unicast = UdpPacket::new(&mut udp_bytes_unicast); let mut packet_unicast = UdpPacket::new_unchecked(&mut udp_bytes_unicast);
let mut packet_broadcast = UdpPacket::new(&mut udp_bytes_broadcast); let mut packet_broadcast = UdpPacket::new_unchecked(&mut udp_bytes_broadcast);
let udp_repr = UdpRepr { let udp_repr = UdpRepr {
src_port: 67, src_port: 67,
@ -1596,7 +1596,7 @@ mod test {
let udp_socket = UdpSocket::new(rx_buffer, tx_buffer); let udp_socket = UdpSocket::new(rx_buffer, tx_buffer);
let mut udp_bytes = vec![0u8; 13]; let mut udp_bytes = vec![0u8; 13];
let mut packet = UdpPacket::new(&mut udp_bytes); let mut packet = UdpPacket::new_unchecked(&mut udp_bytes);
let socket_handle = socket_set.add(udp_socket); let socket_handle = socket_set.add(udp_socket);
@ -1686,7 +1686,7 @@ mod test {
payload: &[0x2a; MAX_PAYLOAD_LEN] payload: &[0x2a; MAX_PAYLOAD_LEN]
}; };
let mut bytes = vec![0xff; udp_repr.buffer_len()]; let mut bytes = vec![0xff; udp_repr.buffer_len()];
let mut packet = UdpPacket::new(&mut bytes[..]); let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(), &ChecksumCapabilities::default()); udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(), &ChecksumCapabilities::default());
#[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))] #[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
let ip_repr = Ipv4Repr { let ip_repr = Ipv4Repr {
@ -1767,12 +1767,12 @@ mod test {
target_protocol_addr: local_ip_addr, target_protocol_addr: local_ip_addr,
}; };
let mut frame = EthernetFrame::new(&mut eth_bytes); let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
frame.set_dst_addr(EthernetAddress::BROADCAST); frame.set_dst_addr(EthernetAddress::BROADCAST);
frame.set_src_addr(remote_hw_addr); frame.set_src_addr(remote_hw_addr);
frame.set_ethertype(EthernetProtocol::Arp); frame.set_ethertype(EthernetProtocol::Arp);
{ {
let mut packet = ArpPacket::new(frame.payload_mut()); let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
repr.emit(&mut packet); repr.emit(&mut packet);
} }
@ -1816,14 +1816,15 @@ mod test {
payload_len: solicit.buffer_len() payload_len: solicit.buffer_len()
}); });
let mut frame = EthernetFrame::new(&mut eth_bytes); let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
frame.set_dst_addr(EthernetAddress([0x33, 0x33, 0x00, 0x00, 0x00, 0x00])); frame.set_dst_addr(EthernetAddress([0x33, 0x33, 0x00, 0x00, 0x00, 0x00]));
frame.set_src_addr(remote_hw_addr); frame.set_src_addr(remote_hw_addr);
frame.set_ethertype(EthernetProtocol::Ipv6); frame.set_ethertype(EthernetProtocol::Ipv6);
{ {
ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default()); ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default());
solicit.emit(&remote_ip_addr.into(), &local_ip_addr.solicited_node().into(), solicit.emit(&remote_ip_addr.into(), &local_ip_addr.solicited_node().into(),
&mut Icmpv6Packet::new(&mut frame.payload_mut()[ip_repr.buffer_len()..]), &mut Icmpv6Packet::new_unchecked(
&mut frame.payload_mut()[ip_repr.buffer_len()..]),
&ChecksumCapabilities::default()); &ChecksumCapabilities::default());
} }
@ -1869,12 +1870,12 @@ mod test {
target_protocol_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x03]), target_protocol_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x03]),
}; };
let mut frame = EthernetFrame::new(&mut eth_bytes); let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
frame.set_dst_addr(EthernetAddress::BROADCAST); frame.set_dst_addr(EthernetAddress::BROADCAST);
frame.set_src_addr(remote_hw_addr); frame.set_src_addr(remote_hw_addr);
frame.set_ethertype(EthernetProtocol::Arp); frame.set_ethertype(EthernetProtocol::Arp);
{ {
let mut packet = ArpPacket::new(frame.payload_mut()); let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
repr.emit(&mut packet); repr.emit(&mut packet);
} }
@ -1916,7 +1917,7 @@ mod test {
// Ensure the ident we bound to and the ident of the packet are the same. // Ensure the ident we bound to and the ident of the packet are the same.
let mut bytes = [0xff; 24]; let mut bytes = [0xff; 24];
let mut packet = Icmpv4Packet::new(&mut bytes); let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
let echo_repr = Icmpv4Repr::EchoRequest{ ident, seq_no, data: echo_data }; let echo_repr = Icmpv4Repr::EchoRequest{ ident, seq_no, data: echo_data };
echo_repr.emit(&mut packet, &ChecksumCapabilities::default()); echo_repr.emit(&mut packet, &ChecksumCapabilities::default());
let icmp_data = &packet.into_inner()[..]; let icmp_data = &packet.into_inner()[..];
@ -1990,7 +1991,7 @@ mod test {
}; };
let frame = { let frame = {
let mut frame = EthernetFrame::new(&mut eth_bytes); let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
let ip_repr = IpRepr::Ipv6(ipv6_repr); let ip_repr = IpRepr::Ipv6(ipv6_repr);
frame.set_dst_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00])); frame.set_dst_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]));
frame.set_src_addr(remote_hw_addr); frame.set_src_addr(remote_hw_addr);
@ -1998,21 +1999,22 @@ mod test {
ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default()); ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default());
let mut offset = ipv6_repr.buffer_len(); let mut offset = ipv6_repr.buffer_len();
{ {
let mut hbh_pkt = Ipv6HopByHopHeader::new(&mut frame.payload_mut()[offset..]); let mut hbh_pkt =
Ipv6HopByHopHeader::new_unchecked(&mut frame.payload_mut()[offset..]);
hbh_pkt.set_next_header(IpProtocol::Unknown(0x0c)); hbh_pkt.set_next_header(IpProtocol::Unknown(0x0c));
hbh_pkt.set_header_len(0); hbh_pkt.set_header_len(0);
offset += 8; offset += 8;
{ {
let mut pad_pkt = Ipv6Option::new(&mut hbh_pkt.options_mut()[..]); let mut pad_pkt = Ipv6Option::new_unchecked(&mut hbh_pkt.options_mut()[..]);
Ipv6OptionRepr::PadN(3).emit(&mut pad_pkt); Ipv6OptionRepr::PadN(3).emit(&mut pad_pkt);
} }
{ {
let mut pad_pkt = Ipv6Option::new(&mut hbh_pkt.options_mut()[5..]); let mut pad_pkt = Ipv6Option::new_unchecked(&mut hbh_pkt.options_mut()[5..]);
Ipv6OptionRepr::Pad1.emit(&mut pad_pkt); Ipv6OptionRepr::Pad1.emit(&mut pad_pkt);
} }
} }
frame.payload_mut()[offset..].copy_from_slice(&payload); frame.payload_mut()[offset..].copy_from_slice(&payload);
EthernetFrame::new(&*frame.into_inner()) EthernetFrame::new_unchecked(&*frame.into_inner())
}; };
let reply_icmp_repr = Icmpv6Repr::ParamProblem { let reply_icmp_repr = Icmpv6Repr::ParamProblem {

56
src/socket/icmp.rs
View File

@ -256,7 +256,7 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
(&Endpoint::Udp(endpoint), &IcmpRepr::Ipv4(Icmpv4Repr::DstUnreachable { data, .. })) (&Endpoint::Udp(endpoint), &IcmpRepr::Ipv4(Icmpv4Repr::DstUnreachable { data, .. }))
if endpoint.addr.is_unspecified() || endpoint.addr == ip_repr.dst_addr() => { if endpoint.addr.is_unspecified() || endpoint.addr == ip_repr.dst_addr() => {
let packet = UdpPacket::new(data); let packet = UdpPacket::new_unchecked(data);
match UdpRepr::parse(&packet, &ip_repr.src_addr(), &ip_repr.dst_addr(), cksum) { match UdpRepr::parse(&packet, &ip_repr.src_addr(), &ip_repr.dst_addr(), cksum) {
Ok(repr) => endpoint.port == repr.src_port, Ok(repr) => endpoint.port == repr.src_port,
Err(_) => false, Err(_) => false,
@ -265,7 +265,7 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
(&Endpoint::Udp(endpoint), &IcmpRepr::Ipv6(Icmpv6Repr::DstUnreachable { data, .. })) (&Endpoint::Udp(endpoint), &IcmpRepr::Ipv6(Icmpv6Repr::DstUnreachable { data, .. }))
if endpoint.addr.is_unspecified() || endpoint.addr == ip_repr.dst_addr() => { if endpoint.addr.is_unspecified() || endpoint.addr == ip_repr.dst_addr() => {
let packet = UdpPacket::new(data); let packet = UdpPacket::new_unchecked(data);
match UdpRepr::parse(&packet, &ip_repr.src_addr(), &ip_repr.dst_addr(), cksum) { match UdpRepr::parse(&packet, &ip_repr.src_addr(), &ip_repr.dst_addr(), cksum) {
Ok(repr) => endpoint.port == repr.src_port, Ok(repr) => endpoint.port == repr.src_port,
Err(_) => false, Err(_) => false,
@ -275,12 +275,16 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
// Echo Request/Reply with the identifier field matching the endpoint // Echo Request/Reply with the identifier field matching the endpoint
// port. // port.
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
(&Endpoint::Ident(bound_ident), &IcmpRepr::Ipv4(Icmpv4Repr::EchoRequest { ident, .. })) | (&Endpoint::Ident(bound_ident),
(&Endpoint::Ident(bound_ident), &IcmpRepr::Ipv4(Icmpv4Repr::EchoReply { ident, .. })) => &IcmpRepr::Ipv4(Icmpv4Repr::EchoRequest { ident, .. })) |
(&Endpoint::Ident(bound_ident),
&IcmpRepr::Ipv4(Icmpv4Repr::EchoReply { ident, .. })) =>
ident == bound_ident, ident == bound_ident,
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
(&Endpoint::Ident(bound_ident), &IcmpRepr::Ipv6(Icmpv6Repr::EchoRequest { ident, .. })) | (&Endpoint::Ident(bound_ident),
(&Endpoint::Ident(bound_ident), &IcmpRepr::Ipv6(Icmpv6Repr::EchoReply { ident, .. })) => &IcmpRepr::Ipv6(Icmpv6Repr::EchoRequest { ident, .. })) |
(&Endpoint::Ident(bound_ident),
&IcmpRepr::Ipv6(Icmpv6Repr::EchoReply { ident, .. })) =>
ident == bound_ident, ident == bound_ident,
_ => false, _ => false,
} }
@ -291,17 +295,21 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
match icmp_repr { match icmp_repr {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
&IcmpRepr::Ipv4(ref icmp_repr) => { &IcmpRepr::Ipv4(ref icmp_repr) => {
let packet_buf = self.rx_buffer.enqueue(icmp_repr.buffer_len(), ip_repr.src_addr())?; let packet_buf = self.rx_buffer.enqueue(icmp_repr.buffer_len(),
icmp_repr.emit(&mut Icmpv4Packet::new(packet_buf), &ChecksumCapabilities::default()); ip_repr.src_addr())?;
icmp_repr.emit(&mut Icmpv4Packet::new_unchecked(packet_buf),
&ChecksumCapabilities::default());
net_trace!("{}:{}: receiving {} octets", net_trace!("{}:{}: receiving {} octets",
self.meta.handle, icmp_repr.buffer_len(), packet_buf.len()); self.meta.handle, icmp_repr.buffer_len(), packet_buf.len());
}, },
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
&IcmpRepr::Ipv6(ref icmp_repr) => { &IcmpRepr::Ipv6(ref icmp_repr) => {
let packet_buf = self.rx_buffer.enqueue(icmp_repr.buffer_len(), ip_repr.src_addr())?; let packet_buf = self.rx_buffer.enqueue(icmp_repr.buffer_len(),
ip_repr.src_addr())?;
icmp_repr.emit(&ip_repr.src_addr(), &ip_repr.dst_addr(), icmp_repr.emit(&ip_repr.src_addr(), &ip_repr.dst_addr(),
&mut Icmpv6Packet::new(packet_buf), &ChecksumCapabilities::default()); &mut Icmpv6Packet::new_unchecked(packet_buf),
&ChecksumCapabilities::default());
net_trace!("{}:{}: receiving {} octets", net_trace!("{}:{}: receiving {} octets",
self.meta.handle, icmp_repr.buffer_len(), packet_buf.len()); self.meta.handle, icmp_repr.buffer_len(), packet_buf.len());
@ -321,7 +329,7 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
match *remote_endpoint { match *remote_endpoint {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
IpAddress::Ipv4(ipv4_addr) => { IpAddress::Ipv4(ipv4_addr) => {
let packet = Icmpv4Packet::new(&*packet_buf); let packet = Icmpv4Packet::new_unchecked(&*packet_buf);
let repr = Icmpv4Repr::parse(&packet, &ChecksumCapabilities::ignored())?; let repr = Icmpv4Repr::parse(&packet, &ChecksumCapabilities::ignored())?;
let ip_repr = IpRepr::Ipv4(Ipv4Repr { let ip_repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address::default(), src_addr: Ipv4Address::default(),
@ -334,7 +342,7 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
}, },
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
IpAddress::Ipv6(ipv6_addr) => { IpAddress::Ipv6(ipv6_addr) => {
let packet = Icmpv6Packet::new(&*packet_buf); let packet = Icmpv6Packet::new_unchecked(&*packet_buf);
let src_addr = Ipv6Address::default(); let src_addr = Ipv6Address::default();
let repr = Icmpv6Repr::parse(&src_addr.into(), &ipv6_addr.into(), &packet, &ChecksumCapabilities::ignored())?; let repr = Icmpv6Repr::parse(&src_addr.into(), &ipv6_addr.into(), &packet, &ChecksumCapabilities::ignored())?;
let ip_repr = IpRepr::Ipv6(Ipv6Repr { let ip_repr = IpRepr::Ipv6(Ipv6Repr {
@ -443,7 +451,7 @@ mod test_ipv4 {
assert!(socket.can_send()); assert!(socket.can_send());
let mut bytes = [0xff; 24]; let mut bytes = [0xff; 24];
let mut packet = Icmpv4Packet::new(&mut bytes); let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
ECHOV4_REPR.emit(&mut packet, &caps.checksum); ECHOV4_REPR.emit(&mut packet, &caps.checksum);
assert_eq!(socket.send_slice(&packet.into_inner()[..], REMOTE_IPV4.into()), Ok(())); assert_eq!(socket.send_slice(&packet.into_inner()[..], REMOTE_IPV4.into()), Ok(()));
@ -473,7 +481,7 @@ mod test_ipv4 {
let caps = DeviceCapabilities::default(); let caps = DeviceCapabilities::default();
let mut bytes = [0xff; 24]; let mut bytes = [0xff; 24];
let mut packet = Icmpv4Packet::new(&mut bytes); let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
ECHOV4_REPR.emit(&mut packet, &caps.checksum); ECHOV4_REPR.emit(&mut packet, &caps.checksum);
s.set_hop_limit(Some(0x2a)); s.set_hop_limit(Some(0x2a));
@ -502,7 +510,7 @@ mod test_ipv4 {
let caps = DeviceCapabilities::default(); let caps = DeviceCapabilities::default();
let mut bytes = [0xff; 24]; let mut bytes = [0xff; 24];
let mut packet = Icmpv4Packet::new(&mut bytes); let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
ECHOV4_REPR.emit(&mut packet, &caps.checksum); ECHOV4_REPR.emit(&mut packet, &caps.checksum);
let data = &packet.into_inner()[..]; let data = &packet.into_inner()[..];
@ -526,7 +534,7 @@ mod test_ipv4 {
let caps = DeviceCapabilities::default(); let caps = DeviceCapabilities::default();
let mut bytes = [0xff; 20]; let mut bytes = [0xff; 20];
let mut packet = Icmpv4Packet::new(&mut bytes); let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
let icmp_repr = Icmpv4Repr::EchoRequest { let icmp_repr = Icmpv4Repr::EchoRequest {
ident: 0x4321, ident: 0x4321,
seq_no: 0x5678, seq_no: 0x5678,
@ -547,7 +555,7 @@ mod test_ipv4 {
let caps = DeviceCapabilities::default(); let caps = DeviceCapabilities::default();
let mut bytes = [0xff; 18]; let mut bytes = [0xff; 18];
let mut packet = UdpPacket::new(&mut bytes); let mut packet = UdpPacket::new_unchecked(&mut bytes);
UDP_REPR.emit(&mut packet, &REMOTE_IPV4.into(), &LOCAL_IPV4.into(), &caps.checksum); UDP_REPR.emit(&mut packet, &REMOTE_IPV4.into(), &LOCAL_IPV4.into(), &caps.checksum);
let data = &packet.into_inner()[..]; let data = &packet.into_inner()[..];
@ -581,7 +589,7 @@ mod test_ipv4 {
assert!(socket.can_recv()); assert!(socket.can_recv());
let mut bytes = [0x00; 46]; let mut bytes = [0x00; 46];
let mut packet = Icmpv4Packet::new(&mut bytes[..]); let mut packet = Icmpv4Packet::new_unchecked(&mut bytes[..]);
icmp_repr.emit(&mut packet, &caps.checksum); icmp_repr.emit(&mut packet, &caps.checksum);
assert_eq!(socket.recv(), Ok((&packet.into_inner()[..], REMOTE_IPV4.into()))); assert_eq!(socket.recv(), Ok((&packet.into_inner()[..], REMOTE_IPV4.into())));
assert!(!socket.can_recv()); assert!(!socket.can_recv());
@ -642,7 +650,7 @@ mod test_ipv6 {
assert!(socket.can_send()); assert!(socket.can_send());
let mut bytes = vec![0xff; 24]; let mut bytes = vec![0xff; 24];
let mut packet = Icmpv6Packet::new(&mut bytes); let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
ECHOV6_REPR.emit(&LOCAL_IPV6.into(), &REMOTE_IPV6.into(), &mut packet, &caps.checksum); ECHOV6_REPR.emit(&LOCAL_IPV6.into(), &REMOTE_IPV6.into(), &mut packet, &caps.checksum);
assert_eq!(socket.send_slice(&packet.into_inner()[..], REMOTE_IPV6.into()), Ok(())); assert_eq!(socket.send_slice(&packet.into_inner()[..], REMOTE_IPV6.into()), Ok(()));
@ -672,7 +680,7 @@ mod test_ipv6 {
let caps = DeviceCapabilities::default(); let caps = DeviceCapabilities::default();
let mut bytes = vec![0xff; 24]; let mut bytes = vec![0xff; 24];
let mut packet = Icmpv6Packet::new(&mut bytes); let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
ECHOV6_REPR.emit(&LOCAL_IPV6.into(), &REMOTE_IPV6.into(), &mut packet, &caps.checksum); ECHOV6_REPR.emit(&LOCAL_IPV6.into(), &REMOTE_IPV6.into(), &mut packet, &caps.checksum);
s.set_hop_limit(Some(0x2a)); s.set_hop_limit(Some(0x2a));
@ -701,7 +709,7 @@ mod test_ipv6 {
let caps = DeviceCapabilities::default(); let caps = DeviceCapabilities::default();
let mut bytes = [0xff; 24]; let mut bytes = [0xff; 24];
let mut packet = Icmpv6Packet::new(&mut bytes); let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
ECHOV6_REPR.emit(&LOCAL_IPV6.into(), &REMOTE_IPV6.into(), &mut packet, &caps.checksum); ECHOV6_REPR.emit(&LOCAL_IPV6.into(), &REMOTE_IPV6.into(), &mut packet, &caps.checksum);
let data = &packet.into_inner()[..]; let data = &packet.into_inner()[..];
@ -725,7 +733,7 @@ mod test_ipv6 {
let caps = DeviceCapabilities::default(); let caps = DeviceCapabilities::default();
let mut bytes = [0xff; 20]; let mut bytes = [0xff; 20];
let mut packet = Icmpv6Packet::new(&mut bytes); let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
let icmp_repr = Icmpv6Repr::EchoRequest { let icmp_repr = Icmpv6Repr::EchoRequest {
ident: 0x4321, ident: 0x4321,
seq_no: 0x5678, seq_no: 0x5678,
@ -746,7 +754,7 @@ mod test_ipv6 {
let caps = DeviceCapabilities::default(); let caps = DeviceCapabilities::default();
let mut bytes = [0xff; 18]; let mut bytes = [0xff; 18];
let mut packet = UdpPacket::new(&mut bytes); let mut packet = UdpPacket::new_unchecked(&mut bytes);
UDP_REPR.emit(&mut packet, &REMOTE_IPV6.into(), &LOCAL_IPV6.into(), &caps.checksum); UDP_REPR.emit(&mut packet, &REMOTE_IPV6.into(), &LOCAL_IPV6.into(), &caps.checksum);
let data = &packet.into_inner()[..]; let data = &packet.into_inner()[..];
@ -780,7 +788,7 @@ mod test_ipv6 {
assert!(socket.can_recv()); assert!(socket.can_recv());
let mut bytes = [0x00; 66]; let mut bytes = [0x00; 66];
let mut packet = Icmpv6Packet::new(&mut bytes[..]); let mut packet = Icmpv6Packet::new_unchecked(&mut bytes[..]);
icmp_repr.emit(&LOCAL_IPV6.into(), &REMOTE_IPV6.into(), &mut packet, &caps.checksum); icmp_repr.emit(&LOCAL_IPV6.into(), &REMOTE_IPV6.into(), &mut packet, &caps.checksum);
assert_eq!(socket.recv(), Ok((&packet.into_inner()[..], REMOTE_IPV6.into()))); assert_eq!(socket.recv(), Ok((&packet.into_inner()[..], REMOTE_IPV6.into())));
assert!(!socket.can_recv()); assert!(!socket.can_recv());

14
src/socket/raw.rs
View File

@ -168,7 +168,7 @@ impl<'a, 'b> RawSocket<'a, 'b> {
packet.set_checksum(0); packet.set_checksum(0);
} }
let packet = Ipv4Packet::new(&*packet.into_inner()); let packet = Ipv4Packet::new_unchecked(&*packet.into_inner());
let ipv4_repr = Ipv4Repr::parse(&packet, checksum_caps)?; let ipv4_repr = Ipv4Repr::parse(&packet, checksum_caps)?;
Ok((IpRepr::Ipv4(ipv4_repr), packet.payload())) Ok((IpRepr::Ipv4(ipv4_repr), packet.payload()))
} }
@ -176,7 +176,7 @@ impl<'a, 'b> RawSocket<'a, 'b> {
IpVersion::Ipv6 => { IpVersion::Ipv6 => {
let mut packet = Ipv6Packet::new_checked(buffer.as_mut())?; let mut packet = Ipv6Packet::new_checked(buffer.as_mut())?;
if packet.next_header() != protocol { return Err(Error::Unaddressable) } if packet.next_header() != protocol { return Err(Error::Unaddressable) }
let packet = Ipv6Packet::new(&*packet.into_inner()); let packet = Ipv6Packet::new_unchecked(&*packet.into_inner());
let ipv6_repr = Ipv6Repr::parse(&packet)?; let ipv6_repr = Ipv6Repr::parse(&packet)?;
Ok((IpRepr::Ipv6(ipv6_repr), packet.payload())) Ok((IpRepr::Ipv6(ipv6_repr), packet.payload()))
} }
@ -393,14 +393,14 @@ mod test {
let mut socket = ipv4_locals::socket(buffer(0), buffer(2)); let mut socket = ipv4_locals::socket(buffer(0), buffer(2));
let mut wrong_version = ipv4_locals::PACKET_BYTES.clone(); let mut wrong_version = ipv4_locals::PACKET_BYTES.clone();
Ipv4Packet::new(&mut wrong_version).set_version(6); Ipv4Packet::new_unchecked(&mut wrong_version).set_version(6);
assert_eq!(socket.send_slice(&wrong_version[..]), Ok(())); assert_eq!(socket.send_slice(&wrong_version[..]), Ok(()));
assert_eq!(socket.dispatch(&checksum_caps, |_| unreachable!()), assert_eq!(socket.dispatch(&checksum_caps, |_| unreachable!()),
Ok(())); Ok(()));
let mut wrong_protocol = ipv4_locals::PACKET_BYTES.clone(); let mut wrong_protocol = ipv4_locals::PACKET_BYTES.clone();
Ipv4Packet::new(&mut wrong_protocol).set_protocol(IpProtocol::Tcp); Ipv4Packet::new_unchecked(&mut wrong_protocol).set_protocol(IpProtocol::Tcp);
assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(())); assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(()));
assert_eq!(socket.dispatch(&checksum_caps, |_| unreachable!()), assert_eq!(socket.dispatch(&checksum_caps, |_| unreachable!()),
@ -411,14 +411,14 @@ mod test {
let mut socket = ipv6_locals::socket(buffer(0), buffer(2)); let mut socket = ipv6_locals::socket(buffer(0), buffer(2));
let mut wrong_version = ipv6_locals::PACKET_BYTES.clone(); let mut wrong_version = ipv6_locals::PACKET_BYTES.clone();
Ipv6Packet::new(&mut wrong_version[..]).set_version(4); Ipv6Packet::new_unchecked(&mut wrong_version[..]).set_version(4);
assert_eq!(socket.send_slice(&wrong_version[..]), Ok(())); assert_eq!(socket.send_slice(&wrong_version[..]), Ok(()));
assert_eq!(socket.dispatch(&checksum_caps, |_| unreachable!()), assert_eq!(socket.dispatch(&checksum_caps, |_| unreachable!()),
Ok(())); Ok(()));
let mut wrong_protocol = ipv6_locals::PACKET_BYTES.clone(); let mut wrong_protocol = ipv6_locals::PACKET_BYTES.clone();
Ipv6Packet::new(&mut wrong_protocol[..]).set_next_header(IpProtocol::Tcp); Ipv6Packet::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(&checksum_caps, |_| unreachable!()), assert_eq!(socket.dispatch(&checksum_caps, |_| unreachable!()),
@ -434,7 +434,7 @@ mod test {
assert!(!socket.can_recv()); assert!(!socket.can_recv());
let mut cksumd_packet = ipv4_locals::PACKET_BYTES.clone(); let mut cksumd_packet = ipv4_locals::PACKET_BYTES.clone();
Ipv4Packet::new(&mut cksumd_packet).fill_checksum(); Ipv4Packet::new_unchecked(&mut cksumd_packet).fill_checksum();
assert_eq!(socket.recv(), Err(Error::Exhausted)); assert_eq!(socket.recv(), Err(Error::Exhausted));
assert!(socket.accepts(&ipv4_locals::HEADER_REPR)); assert!(socket.accepts(&ipv4_locals::HEADER_REPR));

2
src/socket/ref_.rs
View File

@ -55,7 +55,7 @@ impl<'a, T: Session + 'a> Ref<'a, T> {
/// map a `&mut SocketRef<'a, XSocket>` to a `&'a mut XSocket` (note the lifetimes); /// map a `&mut SocketRef<'a, XSocket>` to a `&'a mut XSocket` (note the lifetimes);
/// be sure to call [new] afterwards. /// be sure to call [new] afterwards.
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
pub fn into_inner(mut ref_: Self) -> &'a mut T { pub fn into_inner(mut ref_: Self) -> &'a mut T {
ref_.consumed = true; ref_.consumed = true;
ref_.socket ref_.socket

16
src/wire/arp.rs
View File

@ -64,16 +64,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with ARP packet structure. /// Imbue a raw octet buffer with ARP packet structure.
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -385,7 +385,7 @@ mod test {
#[test] #[test]
fn test_deconstruct() { fn test_deconstruct() {
let packet = Packet::new(&PACKET_BYTES[..]); let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
assert_eq!(packet.hardware_type(), Hardware::Ethernet); assert_eq!(packet.hardware_type(), Hardware::Ethernet);
assert_eq!(packet.protocol_type(), Protocol::Ipv4); assert_eq!(packet.protocol_type(), Protocol::Ipv4);
assert_eq!(packet.hardware_len(), 6); assert_eq!(packet.hardware_len(), 6);
@ -400,7 +400,7 @@ mod test {
#[test] #[test]
fn test_construct() { fn test_construct() {
let mut bytes = vec![0xa5; 28]; let mut bytes = vec![0xa5; 28];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_hardware_type(Hardware::Ethernet); packet.set_hardware_type(Hardware::Ethernet);
packet.set_protocol_type(Protocol::Ipv4); packet.set_protocol_type(Protocol::Ipv4);
packet.set_hardware_len(6); packet.set_hardware_len(6);
@ -429,7 +429,7 @@ mod test {
#[test] #[test]
fn test_parse() { fn test_parse() {
let packet = Packet::new(&PACKET_BYTES[..]); let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
let repr = Repr::parse(&packet).unwrap(); let repr = Repr::parse(&packet).unwrap();
assert_eq!(repr, packet_repr()); assert_eq!(repr, packet_repr());
} }
@ -437,7 +437,7 @@ mod test {
#[test] #[test]
fn test_emit() { fn test_emit() {
let mut bytes = vec![0xa5; 28]; let mut bytes = vec![0xa5; 28];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet_repr().emit(&mut packet); packet_repr().emit(&mut packet);
assert_eq!(&packet.into_inner()[..], &PACKET_BYTES[..]); assert_eq!(&packet.into_inner()[..], &PACKET_BYTES[..]);
} }

16
src/wire/dhcpv4.rs
View File

@ -280,16 +280,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with DHCP packet structure. /// Imbue a raw octet buffer with DHCP packet structure.
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -792,7 +792,7 @@ mod test {
#[test] #[test]
fn test_deconstruct_discover() { fn test_deconstruct_discover() {
let packet = Packet::new(DISCOVER_BYTES); let packet = Packet::new_unchecked(DISCOVER_BYTES);
assert_eq!(packet.magic_number(), MAGIC_COOKIE); assert_eq!(packet.magic_number(), MAGIC_COOKIE);
assert_eq!(packet.opcode(), OpCode::Request); assert_eq!(packet.opcode(), OpCode::Request);
assert_eq!(packet.hardware_type(), Hardware::Ethernet); assert_eq!(packet.hardware_type(), Hardware::Ethernet);
@ -834,7 +834,7 @@ mod test {
#[test] #[test]
fn test_construct_discover() { fn test_construct_discover() {
let mut bytes = vec![0xa5; 272]; let mut bytes = vec![0xa5; 272];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_magic_number(MAGIC_COOKIE); packet.set_magic_number(MAGIC_COOKIE);
packet.set_sname_and_boot_file_to_zero(); packet.set_sname_and_boot_file_to_zero();
packet.set_opcode(OpCode::Request); packet.set_opcode(OpCode::Request);
@ -889,7 +889,7 @@ mod test {
#[test] #[test]
fn test_parse_discover() { fn test_parse_discover() {
let packet = Packet::new(DISCOVER_BYTES); let packet = Packet::new_unchecked(DISCOVER_BYTES);
let repr = Repr::parse(&packet).unwrap(); let repr = Repr::parse(&packet).unwrap();
assert_eq!(repr, discover_repr()); assert_eq!(repr, discover_repr());
} }
@ -898,7 +898,7 @@ mod test {
fn test_emit_discover() { fn test_emit_discover() {
let repr = discover_repr(); let repr = discover_repr();
let mut bytes = vec![0xa5; repr.buffer_len()]; let mut bytes = vec![0xa5; repr.buffer_len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&mut packet).unwrap(); repr.emit(&mut packet).unwrap();
let packet = &packet.into_inner()[..]; let packet = &packet.into_inner()[..];
let packet_len = packet.len(); let packet_len = packet.len();

16
src/wire/ethernet.rs
View File

@ -93,16 +93,16 @@ mod field {
impl<T: AsRef<[u8]>> Frame<T> { impl<T: AsRef<[u8]>> Frame<T> {
/// Imbue a raw octet buffer with Ethernet frame structure. /// Imbue a raw octet buffer with Ethernet frame structure.
pub fn new(buffer: T) -> Frame<T> { pub fn new_unchecked(buffer: T) -> Frame<T> {
Frame { buffer } Frame { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Frame<T>> { pub fn new_checked(buffer: T) -> Result<Frame<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -317,7 +317,7 @@ mod test_ipv4 {
#[test] #[test]
fn test_deconstruct() { fn test_deconstruct() {
let frame = Frame::new(&FRAME_BYTES[..]); let frame = Frame::new_unchecked(&FRAME_BYTES[..]);
assert_eq!(frame.dst_addr(), Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06])); assert_eq!(frame.dst_addr(), Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]));
assert_eq!(frame.src_addr(), Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16])); assert_eq!(frame.src_addr(), Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
assert_eq!(frame.ethertype(), EtherType::Ipv4); assert_eq!(frame.ethertype(), EtherType::Ipv4);
@ -327,7 +327,7 @@ mod test_ipv4 {
#[test] #[test]
fn test_construct() { fn test_construct() {
let mut bytes = vec![0xa5; 64]; let mut bytes = vec![0xa5; 64];
let mut frame = Frame::new(&mut bytes); let mut frame = Frame::new_unchecked(&mut bytes);
frame.set_dst_addr(Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06])); frame.set_dst_addr(Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]));
frame.set_src_addr(Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16])); frame.set_src_addr(Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
frame.set_ethertype(EtherType::Ipv4); frame.set_ethertype(EtherType::Ipv4);
@ -361,7 +361,7 @@ mod test_ipv6 {
#[test] #[test]
fn test_deconstruct() { fn test_deconstruct() {
let frame = Frame::new(&FRAME_BYTES[..]); let frame = Frame::new_unchecked(&FRAME_BYTES[..]);
assert_eq!(frame.dst_addr(), Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06])); assert_eq!(frame.dst_addr(), Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]));
assert_eq!(frame.src_addr(), Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16])); assert_eq!(frame.src_addr(), Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
assert_eq!(frame.ethertype(), EtherType::Ipv6); assert_eq!(frame.ethertype(), EtherType::Ipv6);
@ -371,7 +371,7 @@ mod test_ipv6 {
#[test] #[test]
fn test_construct() { fn test_construct() {
let mut bytes = vec![0xa5; 54]; let mut bytes = vec![0xa5; 54];
let mut frame = Frame::new(&mut bytes); let mut frame = Frame::new_unchecked(&mut bytes);
frame.set_dst_addr(Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06])); frame.set_dst_addr(Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]));
frame.set_src_addr(Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16])); frame.set_src_addr(Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
frame.set_ethertype(EtherType::Ipv6); frame.set_ethertype(EtherType::Ipv6);

18
src/wire/icmpv4.rs
View File

@ -188,16 +188,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with ICMPv4 packet structure. /// Imbue a raw octet buffer with ICMPv4 packet structure.
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -478,7 +478,7 @@ impl<'a> Repr<'a> {
packet.set_msg_type(Message::DstUnreachable); packet.set_msg_type(Message::DstUnreachable);
packet.set_msg_code(reason.into()); packet.set_msg_code(reason.into());
let mut ip_packet = Ipv4Packet::new(packet.data_mut()); let mut ip_packet = Ipv4Packet::new_unchecked(packet.data_mut());
header.emit(&mut ip_packet, checksum_caps); header.emit(&mut ip_packet, checksum_caps);
let payload = &mut ip_packet.into_inner()[header.buffer_len()..]; let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
payload.copy_from_slice(&data[..]) payload.copy_from_slice(&data[..])
@ -566,7 +566,7 @@ mod test {
#[test] #[test]
fn test_echo_deconstruct() { fn test_echo_deconstruct() {
let packet = Packet::new(&ECHO_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&ECHO_PACKET_BYTES[..]);
assert_eq!(packet.msg_type(), Message::EchoRequest); assert_eq!(packet.msg_type(), Message::EchoRequest);
assert_eq!(packet.msg_code(), 0); assert_eq!(packet.msg_code(), 0);
assert_eq!(packet.checksum(), 0x8efe); assert_eq!(packet.checksum(), 0x8efe);
@ -579,7 +579,7 @@ mod test {
#[test] #[test]
fn test_echo_construct() { fn test_echo_construct() {
let mut bytes = vec![0xa5; 12]; let mut bytes = vec![0xa5; 12];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_msg_type(Message::EchoRequest); packet.set_msg_type(Message::EchoRequest);
packet.set_msg_code(0); packet.set_msg_code(0);
packet.set_echo_ident(0x1234); packet.set_echo_ident(0x1234);
@ -599,7 +599,7 @@ mod test {
#[test] #[test]
fn test_echo_parse() { fn test_echo_parse() {
let packet = Packet::new(&ECHO_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&ECHO_PACKET_BYTES[..]);
let repr = Repr::parse(&packet, &ChecksumCapabilities::default()).unwrap(); let repr = Repr::parse(&packet, &ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, echo_packet_repr()); assert_eq!(repr, echo_packet_repr());
} }
@ -608,7 +608,7 @@ mod test {
fn test_echo_emit() { fn test_echo_emit() {
let repr = echo_packet_repr(); let repr = echo_packet_repr();
let mut bytes = vec![0xa5; repr.buffer_len()]; let mut bytes = vec![0xa5; repr.buffer_len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&mut packet, &ChecksumCapabilities::default()); repr.emit(&mut packet, &ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &ECHO_PACKET_BYTES[..]); assert_eq!(&packet.into_inner()[..], &ECHO_PACKET_BYTES[..]);
} }

26
src/wire/icmpv6.rs
View File

@ -251,16 +251,16 @@ pub(super) mod field {
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with ICMPv6 packet structure. /// Imbue a raw octet buffer with ICMPv6 packet structure.
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -656,7 +656,7 @@ impl<'a> Repr<'a> {
packet: &mut Packet<&mut T>, checksum_caps: &ChecksumCapabilities) packet: &mut Packet<&mut T>, checksum_caps: &ChecksumCapabilities)
where T: AsRef<[u8]> + AsMut<[u8]> + ?Sized { where T: AsRef<[u8]> + AsMut<[u8]> + ?Sized {
fn emit_contained_packet(buffer: &mut [u8], header: Ipv6Repr, data: &[u8]) { fn emit_contained_packet(buffer: &mut [u8], header: Ipv6Repr, data: &[u8]) {
let mut ip_packet = Ipv6Packet::new(buffer); let mut ip_packet = Ipv6Packet::new_unchecked(buffer);
header.emit(&mut ip_packet); header.emit(&mut ip_packet);
let payload = &mut ip_packet.into_inner()[header.buffer_len()..]; let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
payload.copy_from_slice(&data[..]); payload.copy_from_slice(&data[..]);
@ -812,7 +812,7 @@ mod test {
#[test] #[test]
fn test_echo_deconstruct() { fn test_echo_deconstruct() {
let packet = Packet::new(&ECHO_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&ECHO_PACKET_BYTES[..]);
assert_eq!(packet.msg_type(), Message::EchoRequest); assert_eq!(packet.msg_type(), Message::EchoRequest);
assert_eq!(packet.msg_code(), 0); assert_eq!(packet.msg_code(), 0);
assert_eq!(packet.checksum(), 0x19b3); assert_eq!(packet.checksum(), 0x19b3);
@ -826,7 +826,7 @@ mod test {
#[test] #[test]
fn test_echo_construct() { fn test_echo_construct() {
let mut bytes = vec![0xa5; 12]; let mut bytes = vec![0xa5; 12];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_msg_type(Message::EchoRequest); packet.set_msg_type(Message::EchoRequest);
packet.set_msg_code(0); packet.set_msg_code(0);
packet.set_echo_ident(0x1234); packet.set_echo_ident(0x1234);
@ -838,7 +838,7 @@ mod test {
#[test] #[test]
fn test_echo_repr_parse() { fn test_echo_repr_parse() {
let packet = Packet::new(&ECHO_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&ECHO_PACKET_BYTES[..]);
let repr = Repr::parse(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2, let repr = Repr::parse(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2,
&packet, &ChecksumCapabilities::default()).unwrap(); &packet, &ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, echo_packet_repr()); assert_eq!(repr, echo_packet_repr());
@ -848,7 +848,7 @@ mod test {
fn test_echo_emit() { fn test_echo_emit() {
let repr = echo_packet_repr(); let repr = echo_packet_repr();
let mut bytes = vec![0xa5; repr.buffer_len()]; let mut bytes = vec![0xa5; repr.buffer_len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2, repr.emit(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2,
&mut packet, &ChecksumCapabilities::default()); &mut packet, &ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &ECHO_PACKET_BYTES[..]); assert_eq!(&packet.into_inner()[..], &ECHO_PACKET_BYTES[..]);
@ -856,7 +856,7 @@ mod test {
#[test] #[test]
fn test_too_big_deconstruct() { fn test_too_big_deconstruct() {
let packet = Packet::new(&PKT_TOO_BIG_BYTES[..]); let packet = Packet::new_unchecked(&PKT_TOO_BIG_BYTES[..]);
assert_eq!(packet.msg_type(), Message::PktTooBig); assert_eq!(packet.msg_type(), Message::PktTooBig);
assert_eq!(packet.msg_code(), 0); assert_eq!(packet.msg_code(), 0);
assert_eq!(packet.checksum(), 0x0fc9); assert_eq!(packet.checksum(), 0x0fc9);
@ -869,7 +869,7 @@ mod test {
#[test] #[test]
fn test_too_big_construct() { fn test_too_big_construct() {
let mut bytes = vec![0xa5; 60]; let mut bytes = vec![0xa5; 60];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_msg_type(Message::PktTooBig); packet.set_msg_type(Message::PktTooBig);
packet.set_msg_code(0); packet.set_msg_code(0);
packet.set_pkt_too_big_mtu(1500); packet.set_pkt_too_big_mtu(1500);
@ -880,7 +880,7 @@ mod test {
#[test] #[test]
fn test_too_big_repr_parse() { fn test_too_big_repr_parse() {
let packet = Packet::new(&PKT_TOO_BIG_BYTES[..]); let packet = Packet::new_unchecked(&PKT_TOO_BIG_BYTES[..]);
let repr = Repr::parse(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2, let repr = Repr::parse(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2,
&packet, &ChecksumCapabilities::default()).unwrap(); &packet, &ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, too_big_packet_repr()); assert_eq!(repr, too_big_packet_repr());
@ -890,7 +890,7 @@ mod test {
fn test_too_big_emit() { fn test_too_big_emit() {
let repr = too_big_packet_repr(); let repr = too_big_packet_repr();
let mut bytes = vec![0xa5; repr.buffer_len()]; let mut bytes = vec![0xa5; repr.buffer_len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2, repr.emit(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2,
&mut packet, &ChecksumCapabilities::default()); &mut packet, &ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &PKT_TOO_BIG_BYTES[..]); assert_eq!(&packet.into_inner()[..], &PKT_TOO_BIG_BYTES[..]);

16
src/wire/igmp.rs
View File

@ -53,16 +53,16 @@ impl fmt::Display for Message {
/// [RFC 2236]: https://tools.ietf.org/html/rfc2236 /// [RFC 2236]: https://tools.ietf.org/html/rfc2236
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with IGMPv2 packet structure. /// Imbue a raw octet buffer with IGMPv2 packet structure.
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -379,7 +379,7 @@ mod test {
#[test] #[test]
fn test_leave_group_deconstruct() { fn test_leave_group_deconstruct() {
let packet = Packet::new(&LEAVE_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&LEAVE_PACKET_BYTES[..]);
assert_eq!(packet.msg_type(), Message::LeaveGroup); assert_eq!(packet.msg_type(), Message::LeaveGroup);
assert_eq!(packet.max_resp_code(), 0); assert_eq!(packet.max_resp_code(), 0);
assert_eq!(packet.checksum(), 0x269); assert_eq!(packet.checksum(), 0x269);
@ -390,7 +390,7 @@ mod test {
#[test] #[test]
fn test_report_deconstruct() { fn test_report_deconstruct() {
let packet = Packet::new(&REPORT_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&REPORT_PACKET_BYTES[..]);
assert_eq!(packet.msg_type(), Message::MembershipReportV2); assert_eq!(packet.msg_type(), Message::MembershipReportV2);
assert_eq!(packet.max_resp_code(), 0); assert_eq!(packet.max_resp_code(), 0);
assert_eq!(packet.checksum(), 0x08da); assert_eq!(packet.checksum(), 0x08da);
@ -402,7 +402,7 @@ mod test {
#[test] #[test]
fn test_leave_construct() { fn test_leave_construct() {
let mut bytes = vec![0xa5; 8]; let mut bytes = vec![0xa5; 8];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_msg_type(Message::LeaveGroup); packet.set_msg_type(Message::LeaveGroup);
packet.set_max_resp_code(0); packet.set_max_resp_code(0);
packet.set_group_address(Ipv4Address::from_bytes(&[224, 0, 6, 150])); packet.set_group_address(Ipv4Address::from_bytes(&[224, 0, 6, 150]));
@ -413,7 +413,7 @@ mod test {
#[test] #[test]
fn test_report_construct() { fn test_report_construct() {
let mut bytes = vec![0xa5; 8]; let mut bytes = vec![0xa5; 8];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_msg_type(Message::MembershipReportV2); packet.set_msg_type(Message::MembershipReportV2);
packet.set_max_resp_code(0); packet.set_max_resp_code(0);
packet.set_group_address(Ipv4Address::from_bytes(&[225, 0, 0, 37])); packet.set_group_address(Ipv4Address::from_bytes(&[225, 0, 0, 37]));

4
src/wire/ip.rs
View File

@ -684,10 +684,10 @@ impl Repr {
panic!("unspecified IP representation"), panic!("unspecified IP representation"),
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
&Repr::Ipv4(repr) => &Repr::Ipv4(repr) =>
repr.emit(&mut Ipv4Packet::new(buffer), &_checksum_caps), repr.emit(&mut Ipv4Packet::new_unchecked(buffer), &_checksum_caps),
#[cfg(feature = "proto-ipv6")] #[cfg(feature = "proto-ipv6")]
&Repr::Ipv6(repr) => &Repr::Ipv6(repr) =>
repr.emit(&mut Ipv6Packet::new(buffer)), repr.emit(&mut Ipv6Packet::new_unchecked(buffer)),
&Repr::__Nonexhaustive => &Repr::__Nonexhaustive =>
unreachable!() unreachable!()
} }

26
src/wire/ipv4.rs
View File

@ -241,16 +241,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with IPv4 packet structure. /// Imbue a raw octet buffer with IPv4 packet structure.
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -704,7 +704,7 @@ mod test {
#[test] #[test]
fn test_deconstruct() { fn test_deconstruct() {
let packet = Packet::new(&PACKET_BYTES[..]); let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
assert_eq!(packet.version(), 4); assert_eq!(packet.version(), 4);
assert_eq!(packet.header_len(), 20); assert_eq!(packet.header_len(), 20);
assert_eq!(packet.dscp(), 0); assert_eq!(packet.dscp(), 0);
@ -726,7 +726,7 @@ mod test {
#[test] #[test]
fn test_construct() { fn test_construct() {
let mut bytes = vec![0xa5; 30]; let mut bytes = vec![0xa5; 30];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_version(4); packet.set_version(4);
packet.set_header_len(20); packet.set_header_len(20);
packet.clear_flags(); packet.clear_flags();
@ -752,9 +752,9 @@ mod test {
bytes.extend(&PACKET_BYTES[..]); bytes.extend(&PACKET_BYTES[..]);
bytes.push(0); bytes.push(0);
assert_eq!(Packet::new(&bytes).payload().len(), assert_eq!(Packet::new_unchecked(&bytes).payload().len(),
PAYLOAD_BYTES.len()); PAYLOAD_BYTES.len());
assert_eq!(Packet::new(&mut bytes).payload_mut().len(), assert_eq!(Packet::new_unchecked(&mut bytes).payload_mut().len(),
PAYLOAD_BYTES.len()); PAYLOAD_BYTES.len());
} }
@ -762,7 +762,7 @@ mod test {
fn test_total_len_overflow() { fn test_total_len_overflow() {
let mut bytes = vec![]; let mut bytes = vec![];
bytes.extend(&PACKET_BYTES[..]); bytes.extend(&PACKET_BYTES[..]);
Packet::new(&mut bytes).set_total_len(128); Packet::new_unchecked(&mut bytes).set_total_len(128);
assert_eq!(Packet::new_checked(&bytes).unwrap_err(), assert_eq!(Packet::new_checked(&bytes).unwrap_err(),
Error::Truncated); Error::Truncated);
@ -791,7 +791,7 @@ mod test {
#[test] #[test]
fn test_parse() { fn test_parse() {
let packet = Packet::new(&REPR_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&REPR_PACKET_BYTES[..]);
let repr = Repr::parse(&packet, &ChecksumCapabilities::default()).unwrap(); let repr = Repr::parse(&packet, &ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, packet_repr()); assert_eq!(repr, packet_repr());
} }
@ -800,10 +800,10 @@ mod test {
fn test_parse_bad_version() { fn test_parse_bad_version() {
let mut bytes = vec![0; 24]; let mut bytes = vec![0; 24];
bytes.copy_from_slice(&REPR_PACKET_BYTES[..]); bytes.copy_from_slice(&REPR_PACKET_BYTES[..]);
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_version(6); packet.set_version(6);
packet.fill_checksum(); packet.fill_checksum();
let packet = Packet::new(&*packet.into_inner()); let packet = Packet::new_unchecked(&*packet.into_inner());
assert_eq!(Repr::parse(&packet, &ChecksumCapabilities::default()), Err(Error::Malformed)); assert_eq!(Repr::parse(&packet, &ChecksumCapabilities::default()), Err(Error::Malformed));
} }
@ -818,7 +818,7 @@ mod test {
fn test_emit() { fn test_emit() {
let repr = packet_repr(); let repr = packet_repr();
let mut bytes = vec![0xa5; repr.buffer_len() + REPR_PAYLOAD_BYTES.len()]; let mut bytes = vec![0xa5; repr.buffer_len() + REPR_PAYLOAD_BYTES.len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&mut packet, &ChecksumCapabilities::default()); repr.emit(&mut packet, &ChecksumCapabilities::default());
packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_BYTES); packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_BYTES);
assert_eq!(&packet.into_inner()[..], &REPR_PACKET_BYTES[..]); assert_eq!(&packet.into_inner()[..], &REPR_PACKET_BYTES[..]);

34
src/wire/ipv6.rs
View File

@ -378,17 +378,17 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Create a raw octet buffer with an IPv6 packet structure. /// Create a raw octet buffer with an IPv6 packet structure.
#[inline] #[inline]
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
#[inline] #[inline]
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -930,7 +930,7 @@ mod test {
#[test] #[test]
fn test_packet_deconstruction() { fn test_packet_deconstruction() {
let packet = Packet::new(&REPR_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&REPR_PACKET_BYTES[..]);
assert_eq!(packet.check_len(), Ok(())); assert_eq!(packet.check_len(), Ok(()));
assert_eq!(packet.version(), 6); assert_eq!(packet.version(), 6);
assert_eq!(packet.traffic_class(), 0); assert_eq!(packet.traffic_class(), 0);
@ -950,7 +950,7 @@ mod test {
#[test] #[test]
fn test_packet_construction() { fn test_packet_construction() {
let mut bytes = [0xff; 52]; let mut bytes = [0xff; 52];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
// Version, Traffic Class, and Flow Label are not // Version, Traffic Class, and Flow Label are not
// byte aligned. make sure the setters and getters // byte aligned. make sure the setters and getters
// do not interfere with each other. // do not interfere with each other.
@ -989,9 +989,9 @@ mod test {
bytes.extend(&REPR_PACKET_BYTES[..]); bytes.extend(&REPR_PACKET_BYTES[..]);
bytes.push(0); bytes.push(0);
assert_eq!(Packet::new(&bytes).payload().len(), assert_eq!(Packet::new_unchecked(&bytes).payload().len(),
REPR_PAYLOAD_BYTES.len()); REPR_PAYLOAD_BYTES.len());
assert_eq!(Packet::new(&mut bytes).payload_mut().len(), assert_eq!(Packet::new_unchecked(&mut bytes).payload_mut().len(),
REPR_PAYLOAD_BYTES.len()); REPR_PAYLOAD_BYTES.len());
} }
@ -999,7 +999,7 @@ mod test {
fn test_total_len_overflow() { fn test_total_len_overflow() {
let mut bytes = vec![]; let mut bytes = vec![];
bytes.extend(&REPR_PACKET_BYTES[..]); bytes.extend(&REPR_PACKET_BYTES[..]);
Packet::new(&mut bytes).set_payload_len(0x80); Packet::new_unchecked(&mut bytes).set_payload_len(0x80);
assert_eq!(Packet::new_checked(&bytes).unwrap_err(), assert_eq!(Packet::new_checked(&bytes).unwrap_err(),
Error::Truncated); Error::Truncated);
@ -1007,7 +1007,7 @@ mod test {
#[test] #[test]
fn test_repr_parse_valid() { fn test_repr_parse_valid() {
let packet = Packet::new(&REPR_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&REPR_PACKET_BYTES[..]);
let repr = Repr::parse(&packet).unwrap(); let repr = Repr::parse(&packet).unwrap();
assert_eq!(repr, packet_repr()); assert_eq!(repr, packet_repr());
} }
@ -1015,30 +1015,30 @@ mod test {
#[test] #[test]
fn test_repr_parse_bad_version() { fn test_repr_parse_bad_version() {
let mut bytes = vec![0; 40]; let mut bytes = vec![0; 40];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
packet.set_version(4); packet.set_version(4);
packet.set_payload_len(0); packet.set_payload_len(0);
let packet = Packet::new(&*packet.into_inner()); let packet = Packet::new_unchecked(&*packet.into_inner());
assert_eq!(Repr::parse(&packet), Err(Error::Malformed)); assert_eq!(Repr::parse(&packet), Err(Error::Malformed));
} }
#[test] #[test]
fn test_repr_parse_smaller_than_header() { fn test_repr_parse_smaller_than_header() {
let mut bytes = vec![0; 40]; let mut bytes = vec![0; 40];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
packet.set_version(6); packet.set_version(6);
packet.set_payload_len(39); packet.set_payload_len(39);
let packet = Packet::new(&*packet.into_inner()); let packet = Packet::new_unchecked(&*packet.into_inner());
assert_eq!(Repr::parse(&packet), Err(Error::Truncated)); assert_eq!(Repr::parse(&packet), Err(Error::Truncated));
} }
#[test] #[test]
fn test_repr_parse_smaller_than_payload() { fn test_repr_parse_smaller_than_payload() {
let mut bytes = vec![0; 40]; let mut bytes = vec![0; 40];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
packet.set_version(6); packet.set_version(6);
packet.set_payload_len(1); packet.set_payload_len(1);
let packet = Packet::new(&*packet.into_inner()); let packet = Packet::new_unchecked(&*packet.into_inner());
assert_eq!(Repr::parse(&packet), Err(Error::Truncated)); assert_eq!(Repr::parse(&packet), Err(Error::Truncated));
} }
@ -1046,7 +1046,7 @@ mod test {
fn test_basic_repr_emit() { fn test_basic_repr_emit() {
let repr = packet_repr(); let repr = packet_repr();
let mut bytes = vec![0xff; repr.buffer_len() + REPR_PAYLOAD_BYTES.len()]; let mut bytes = vec![0xff; repr.buffer_len() + REPR_PAYLOAD_BYTES.len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&mut packet); repr.emit(&mut packet);
packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_BYTES); packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_BYTES);
assert_eq!(&packet.into_inner()[..], &REPR_PACKET_BYTES[..]); assert_eq!(&packet.into_inner()[..], &REPR_PACKET_BYTES[..]);

28
src/wire/ipv6fragment.rs
View File

@ -35,16 +35,16 @@ mod field {
impl<T: AsRef<[u8]>> Header<T> { impl<T: AsRef<[u8]>> Header<T> {
/// Create a raw octet buffer with an IPv6 Fragment Header structure. /// Create a raw octet buffer with an IPv6 Fragment Header structure.
pub fn new(buffer: T) -> Header<T> { pub fn new_unchecked(buffer: T) -> Header<T> {
Header { buffer } Header { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Header<T>> { pub fn new_checked(buffer: T) -> Result<Header<T>> {
let header = Self::new(buffer); let header = Self::new_unchecked(buffer);
header.check_len()?; header.check_len()?;
Ok(header) Ok(header)
} }
@ -220,20 +220,22 @@ mod test {
#[test] #[test]
fn test_check_len() { fn test_check_len() {
// less than 8 bytes // less than 8 bytes
assert_eq!(Err(Error::Truncated), Header::new(&BYTES_HEADER_MORE_FRAG[..7]).check_len()); assert_eq!(Err(Error::Truncated),
Header::new_unchecked(&BYTES_HEADER_MORE_FRAG[..7]).check_len());
// valid // valid
assert_eq!(Ok(()), Header::new(&BYTES_HEADER_MORE_FRAG).check_len()); assert_eq!(Ok(()),
Header::new_unchecked(&BYTES_HEADER_MORE_FRAG).check_len());
} }
#[test] #[test]
fn test_header_deconstruct() { fn test_header_deconstruct() {
let header = Header::new(&BYTES_HEADER_MORE_FRAG); let header = Header::new_unchecked(&BYTES_HEADER_MORE_FRAG);
assert_eq!(header.next_header(), Protocol::Tcp); assert_eq!(header.next_header(), Protocol::Tcp);
assert_eq!(header.frag_offset(), 0); assert_eq!(header.frag_offset(), 0);
assert_eq!(header.more_frags(), true); assert_eq!(header.more_frags(), true);
assert_eq!(header.ident(), 12345); assert_eq!(header.ident(), 12345);
let header = Header::new(&BYTES_HEADER_LAST_FRAG); let header = Header::new_unchecked(&BYTES_HEADER_LAST_FRAG);
assert_eq!(header.next_header(), Protocol::Tcp); assert_eq!(header.next_header(), Protocol::Tcp);
assert_eq!(header.frag_offset(), 320); assert_eq!(header.frag_offset(), 320);
assert_eq!(header.more_frags(), false); assert_eq!(header.more_frags(), false);
@ -242,12 +244,12 @@ mod test {
#[test] #[test]
fn test_repr_parse_valid() { fn test_repr_parse_valid() {
let header = Header::new(&BYTES_HEADER_MORE_FRAG); let header = Header::new_unchecked(&BYTES_HEADER_MORE_FRAG);
let repr = Repr::parse(&header).unwrap(); let repr = Repr::parse(&header).unwrap();
assert_eq!(repr, assert_eq!(repr,
Repr{ next_header: Protocol::Tcp, frag_offset: 0, more_frags: true, ident: 12345 }); Repr{ next_header: Protocol::Tcp, frag_offset: 0, more_frags: true, ident: 12345 });
let header = Header::new(&BYTES_HEADER_LAST_FRAG); let header = Header::new_unchecked(&BYTES_HEADER_LAST_FRAG);
let repr = Repr::parse(&header).unwrap(); let repr = Repr::parse(&header).unwrap();
assert_eq!(repr, assert_eq!(repr,
Repr{ next_header: Protocol::Tcp, frag_offset: 320, more_frags: false, ident: 67890 }); Repr{ next_header: Protocol::Tcp, frag_offset: 320, more_frags: false, ident: 67890 });
@ -257,20 +259,20 @@ mod test {
fn test_repr_emit() { fn test_repr_emit() {
let repr = Repr{ next_header: Protocol::Tcp, frag_offset: 0, more_frags: true, ident: 12345 }; let repr = Repr{ next_header: Protocol::Tcp, frag_offset: 0, more_frags: true, ident: 12345 };
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
let mut header = Header::new(&mut bytes); let mut header = Header::new_unchecked(&mut bytes);
repr.emit(&mut header); repr.emit(&mut header);
assert_eq!(header.into_inner(), &BYTES_HEADER_MORE_FRAG[0..8]); assert_eq!(header.into_inner(), &BYTES_HEADER_MORE_FRAG[0..8]);
let repr = Repr{ next_header: Protocol::Tcp, frag_offset: 320, more_frags: false, ident: 67890 }; let repr = Repr{ next_header: Protocol::Tcp, frag_offset: 320, more_frags: false, ident: 67890 };
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
let mut header = Header::new(&mut bytes); let mut header = Header::new_unchecked(&mut bytes);
repr.emit(&mut header); repr.emit(&mut header);
assert_eq!(header.into_inner(), &BYTES_HEADER_LAST_FRAG[0..8]); assert_eq!(header.into_inner(), &BYTES_HEADER_LAST_FRAG[0..8]);
} }
#[test] #[test]
fn test_buffer_len() { fn test_buffer_len() {
let header = Header::new(&BYTES_HEADER_MORE_FRAG); let header = Header::new_unchecked(&BYTES_HEADER_MORE_FRAG);
let repr = Repr::parse(&header).unwrap(); let repr = Repr::parse(&header).unwrap();
assert_eq!(repr.buffer_len(), BYTES_HEADER_MORE_FRAG.len()); assert_eq!(repr.buffer_len(), BYTES_HEADER_MORE_FRAG.len());
} }

66
src/wire/ipv6hopbyhop.rs
View File

@ -49,16 +49,16 @@ mod field {
impl<T: AsRef<[u8]>> Header<T> { impl<T: AsRef<[u8]>> Header<T> {
/// Create a raw octet buffer with an IPv6 Hop-by-Hop Options Header structure. /// Create a raw octet buffer with an IPv6 Hop-by-Hop Options Header structure.
pub fn new(buffer: T) -> Header<T> { pub fn new_unchecked(buffer: T) -> Header<T> {
Header { buffer } Header { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Header<T>> { pub fn new_checked(buffer: T) -> Result<Header<T>> {
let header = Self::new(buffer); let header = Self::new_unchecked(buffer);
header.check_len()?; header.check_len()?;
Ok(header) Ok(header)
} }
@ -218,28 +218,34 @@ mod test {
#[test] #[test]
fn test_check_len() { fn test_check_len() {
// zero byte buffer // zero byte buffer
assert_eq!(Err(Error::Truncated), Header::new(&REPR_PACKET_PAD4[..0]).check_len()); assert_eq!(Err(Error::Truncated),
Header::new_unchecked(&REPR_PACKET_PAD4[..0]).check_len());
// no length field // no length field
assert_eq!(Err(Error::Truncated), Header::new(&REPR_PACKET_PAD4[..1]).check_len()); assert_eq!(Err(Error::Truncated),
Header::new_unchecked(&REPR_PACKET_PAD4[..1]).check_len());
// less than 8 bytes // less than 8 bytes
assert_eq!(Err(Error::Truncated), Header::new(&REPR_PACKET_PAD4[..7]).check_len()); assert_eq!(Err(Error::Truncated),
Header::new_unchecked(&REPR_PACKET_PAD4[..7]).check_len());
// valid // valid
assert_eq!(Ok(()), Header::new(&REPR_PACKET_PAD4).check_len()); assert_eq!(Ok(()),
Header::new_unchecked(&REPR_PACKET_PAD4).check_len());
// valid // valid
assert_eq!(Ok(()), Header::new(&REPR_PACKET_PAD12).check_len()); assert_eq!(Ok(()),
Header::new_unchecked(&REPR_PACKET_PAD12).check_len());
// length field value greater than number of bytes // length field value greater than number of bytes
let header: [u8; 8] = [0x06, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]; let header: [u8; 8] = [0x06, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0];
assert_eq!(Err(Error::Truncated), Header::new(&header).check_len()); assert_eq!(Err(Error::Truncated),
Header::new_unchecked(&header).check_len());
} }
#[test] #[test]
fn test_header_deconstruct() { fn test_header_deconstruct() {
let header = Header::new(&REPR_PACKET_PAD4); let header = Header::new_unchecked(&REPR_PACKET_PAD4);
assert_eq!(header.next_header(), Protocol::Tcp); assert_eq!(header.next_header(), Protocol::Tcp);
assert_eq!(header.header_len(), 0); assert_eq!(header.header_len(), 0);
assert_eq!(header.options(), &REPR_PACKET_PAD4[2..]); assert_eq!(header.options(), &REPR_PACKET_PAD4[2..]);
let header = Header::new(&REPR_PACKET_PAD12); let header = Header::new_unchecked(&REPR_PACKET_PAD12);
assert_eq!(header.next_header(), Protocol::Tcp); assert_eq!(header.next_header(), Protocol::Tcp);
assert_eq!(header.header_len(), 1); assert_eq!(header.header_len(), 1);
assert_eq!(header.options(), &REPR_PACKET_PAD12[2..]); assert_eq!(header.options(), &REPR_PACKET_PAD12[2..]);
@ -251,15 +257,19 @@ mod test {
bytes.extend(&REPR_PACKET_PAD4[..]); bytes.extend(&REPR_PACKET_PAD4[..]);
bytes.push(0); bytes.push(0);
assert_eq!(Header::new(&bytes).options().len(), REPR_PACKET_PAD4[2..].len()); assert_eq!(Header::new_unchecked(&bytes).options().len(),
assert_eq!(Header::new(&mut bytes).options_mut().len(), REPR_PACKET_PAD4[2..].len()); REPR_PACKET_PAD4[2..].len());
assert_eq!(Header::new_unchecked(&mut bytes).options_mut().len(),
REPR_PACKET_PAD4[2..].len());
let mut bytes = vec![]; let mut bytes = vec![];
bytes.extend(&REPR_PACKET_PAD12[..]); bytes.extend(&REPR_PACKET_PAD12[..]);
bytes.push(0); bytes.push(0);
assert_eq!(Header::new(&bytes).options().len(), REPR_PACKET_PAD12[2..].len()); assert_eq!(Header::new_unchecked(&bytes).options().len(),
assert_eq!(Header::new(&mut bytes).options_mut().len(), REPR_PACKET_PAD12[2..].len()); REPR_PACKET_PAD12[2..].len());
assert_eq!(Header::new_unchecked(&mut bytes).options_mut().len(),
REPR_PACKET_PAD12[2..].len());
} }
#[test] #[test]
@ -267,51 +277,55 @@ mod test {
let mut bytes = vec![]; let mut bytes = vec![];
bytes.extend(&REPR_PACKET_PAD4); bytes.extend(&REPR_PACKET_PAD4);
let len = bytes.len() as u8; let len = bytes.len() as u8;
Header::new(&mut bytes).set_header_len(len + 1); Header::new_unchecked(&mut bytes).set_header_len(len + 1);
assert_eq!(Header::new_checked(&bytes).unwrap_err(), Error::Truncated); assert_eq!(Header::new_checked(&bytes).unwrap_err(), Error::Truncated);
let mut bytes = vec![]; let mut bytes = vec![];
bytes.extend(&REPR_PACKET_PAD12); bytes.extend(&REPR_PACKET_PAD12);
let len = bytes.len() as u8; let len = bytes.len() as u8;
Header::new(&mut bytes).set_header_len(len + 1); Header::new_unchecked(&mut bytes).set_header_len(len + 1);
assert_eq!(Header::new_checked(&bytes).unwrap_err(), Error::Truncated); assert_eq!(Header::new_checked(&bytes).unwrap_err(), Error::Truncated);
} }
#[test] #[test]
fn test_repr_parse_valid() { fn test_repr_parse_valid() {
let header = Header::new(&REPR_PACKET_PAD4); let header = Header::new_unchecked(&REPR_PACKET_PAD4);
let repr = Repr::parse(&header).unwrap(); let repr = Repr::parse(&header).unwrap();
assert_eq!(repr, Repr{ next_header: Protocol::Tcp, length: 0, options: &REPR_PACKET_PAD4[2..] }); assert_eq!(repr, Repr {
next_header: Protocol::Tcp, length: 0, options: &REPR_PACKET_PAD4[2..]
});
let header = Header::new(&REPR_PACKET_PAD12); let header = Header::new_unchecked(&REPR_PACKET_PAD12);
let repr = Repr::parse(&header).unwrap(); let repr = Repr::parse(&header).unwrap();
assert_eq!(repr, Repr{ next_header: Protocol::Tcp, length: 1, options: &REPR_PACKET_PAD12[2..] }); assert_eq!(repr, Repr {
next_header: Protocol::Tcp, length: 1, options: &REPR_PACKET_PAD12[2..]
});
} }
#[test] #[test]
fn test_repr_emit() { fn test_repr_emit() {
let repr = Repr{ next_header: Protocol::Tcp, length: 0, options: &REPR_PACKET_PAD4[2..] }; let repr = Repr{ next_header: Protocol::Tcp, length: 0, options: &REPR_PACKET_PAD4[2..] };
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
let mut header = Header::new(&mut bytes); let mut header = Header::new_unchecked(&mut bytes);
repr.emit(&mut header); repr.emit(&mut header);
assert_eq!(header.into_inner(), &REPR_PACKET_PAD4[..]); assert_eq!(header.into_inner(), &REPR_PACKET_PAD4[..]);
let repr = Repr{ next_header: Protocol::Tcp, length: 1, options: &REPR_PACKET_PAD12[2..] }; let repr = Repr{ next_header: Protocol::Tcp, length: 1, options: &REPR_PACKET_PAD12[2..] };
let mut bytes = [0u8; 16]; let mut bytes = [0u8; 16];
let mut header = Header::new(&mut bytes); let mut header = Header::new_unchecked(&mut bytes);
repr.emit(&mut header); repr.emit(&mut header);
assert_eq!(header.into_inner(), &REPR_PACKET_PAD12[..]); assert_eq!(header.into_inner(), &REPR_PACKET_PAD12[..]);
} }
#[test] #[test]
fn test_buffer_len() { fn test_buffer_len() {
let header = Header::new(&REPR_PACKET_PAD4); let header = Header::new_unchecked(&REPR_PACKET_PAD4);
let repr = Repr::parse(&header).unwrap(); let repr = Repr::parse(&header).unwrap();
assert_eq!(repr.buffer_len(), REPR_PACKET_PAD4.len()); assert_eq!(repr.buffer_len(), REPR_PACKET_PAD4.len());
let header = Header::new(&REPR_PACKET_PAD12); let header = Header::new_unchecked(&REPR_PACKET_PAD12);
let repr = Repr::parse(&header).unwrap(); let repr = Repr::parse(&header).unwrap();
assert_eq!(repr.buffer_len(), REPR_PACKET_PAD12.len()); assert_eq!(repr.buffer_len(), REPR_PACKET_PAD12.len());
} }

55
src/wire/ipv6option.rs
View File

@ -87,16 +87,16 @@ mod field {
impl<T: AsRef<[u8]>> Ipv6Option<T> { impl<T: AsRef<[u8]>> Ipv6Option<T> {
/// Create a raw octet buffer with an IPv6 Extension Header Option structure. /// Create a raw octet buffer with an IPv6 Extension Header Option structure.
pub fn new(buffer: T) -> Ipv6Option<T> { pub fn new_unchecked(buffer: T) -> Ipv6Option<T> {
Ipv6Option { buffer } Ipv6Option { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Ipv6Option<T>> { pub fn new_checked(buffer: T) -> Result<Ipv6Option<T>> {
let opt = Self::new(buffer); let opt = Self::new_unchecked(buffer);
opt.check_len()?; opt.check_len()?;
Ok(opt) Ok(opt)
} }
@ -376,57 +376,64 @@ mod test {
fn test_check_len() { fn test_check_len() {
let bytes = [0u8]; let bytes = [0u8];
// zero byte buffer // zero byte buffer
assert_eq!(Err(Error::Truncated), Ipv6Option::new(&bytes[..0]).check_len()); assert_eq!(Err(Error::Truncated),
Ipv6Option::new_unchecked(&bytes[..0]).check_len());
// pad1 // pad1
assert_eq!(Ok(()), Ipv6Option::new(&IPV6OPTION_BYTES_PAD1).check_len()); assert_eq!(Ok(()),
Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1).check_len());
// padn with truncated data // padn with truncated data
assert_eq!(Err(Error::Truncated), Ipv6Option::new(&IPV6OPTION_BYTES_PADN[..2]).check_len()); assert_eq!(Err(Error::Truncated),
Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PADN[..2]).check_len());
// padn // padn
assert_eq!(Ok(()), Ipv6Option::new(&IPV6OPTION_BYTES_PADN).check_len()); assert_eq!(Ok(()),
Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PADN).check_len());
// unknown option type with truncated data // unknown option type with truncated data
assert_eq!(Err(Error::Truncated), Ipv6Option::new(&IPV6OPTION_BYTES_UNKNOWN[..4]).check_len()); assert_eq!(Err(Error::Truncated),
assert_eq!(Err(Error::Truncated), Ipv6Option::new(&IPV6OPTION_BYTES_UNKNOWN[..1]).check_len()); Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN[..4]).check_len());
assert_eq!(Err(Error::Truncated),
Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN[..1]).check_len());
// unknown type // unknown type
assert_eq!(Ok(()), Ipv6Option::new(&IPV6OPTION_BYTES_UNKNOWN).check_len()); assert_eq!(Ok(()),
Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN).check_len());
} }
#[test] #[test]
#[should_panic(expected = "index out of bounds")] #[should_panic(expected = "index out of bounds")]
fn test_data_len() { fn test_data_len() {
let opt = Ipv6Option::new(&IPV6OPTION_BYTES_PAD1); let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1);
opt.data_len(); opt.data_len();
} }
#[test] #[test]
fn test_option_deconstruct() { fn test_option_deconstruct() {
// one octet of padding // one octet of padding
let opt = Ipv6Option::new(&IPV6OPTION_BYTES_PAD1); let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1);
assert_eq!(opt.option_type(), Type::Pad1); assert_eq!(opt.option_type(), Type::Pad1);
// two octets of padding // two octets of padding
let bytes: [u8; 2] = [0x1, 0x0]; let bytes: [u8; 2] = [0x1, 0x0];
let opt = Ipv6Option::new(&bytes); let opt = Ipv6Option::new_unchecked(&bytes);
assert_eq!(opt.option_type(), Type::PadN); assert_eq!(opt.option_type(), Type::PadN);
assert_eq!(opt.data_len(), 0); assert_eq!(opt.data_len(), 0);
// three octets of padding // three octets of padding
let opt = Ipv6Option::new(&IPV6OPTION_BYTES_PADN); let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PADN);
assert_eq!(opt.option_type(), Type::PadN); assert_eq!(opt.option_type(), Type::PadN);
assert_eq!(opt.data_len(), 1); assert_eq!(opt.data_len(), 1);
assert_eq!(opt.data(), &[0]); assert_eq!(opt.data(), &[0]);
// extra bytes in buffer // extra bytes in buffer
let bytes: [u8; 10] = [0x1, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff]; let bytes: [u8; 10] = [0x1, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff];
let opt = Ipv6Option::new(&bytes); let opt = Ipv6Option::new_unchecked(&bytes);
assert_eq!(opt.option_type(), Type::PadN); assert_eq!(opt.option_type(), Type::PadN);
assert_eq!(opt.data_len(), 7); assert_eq!(opt.data_len(), 7);
assert_eq!(opt.data(), &[0, 0, 0, 0, 0, 0, 0]); assert_eq!(opt.data(), &[0, 0, 0, 0, 0, 0, 0]);
// unrecognized option // unrecognized option
let bytes: [u8; 1] = [0xff]; let bytes: [u8; 1] = [0xff];
let opt = Ipv6Option::new(&bytes); let opt = Ipv6Option::new_unchecked(&bytes);
assert_eq!(opt.option_type(), Type::Unknown(255)); assert_eq!(opt.option_type(), Type::Unknown(255));
// unrecognized option without length and data // unrecognized option without length and data
@ -436,42 +443,42 @@ mod test {
#[test] #[test]
fn test_option_parse() { fn test_option_parse() {
// one octet of padding // one octet of padding
let opt = Ipv6Option::new(&IPV6OPTION_BYTES_PAD1); let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1);
let pad1 = Repr::parse(&opt).unwrap(); let pad1 = Repr::parse(&opt).unwrap();
assert_eq!(pad1, Repr::Pad1); assert_eq!(pad1, Repr::Pad1);
assert_eq!(pad1.buffer_len(), 1); assert_eq!(pad1.buffer_len(), 1);
// two or more octets of padding // two or more octets of padding
let opt = Ipv6Option::new(&IPV6OPTION_BYTES_PADN); let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PADN);
let padn = Repr::parse(&opt).unwrap(); let padn = Repr::parse(&opt).unwrap();
assert_eq!(padn, Repr::PadN(1)); assert_eq!(padn, Repr::PadN(1));
assert_eq!(padn.buffer_len(), 3); assert_eq!(padn.buffer_len(), 3);
// unrecognized option type // unrecognized option type
let data = [0u8; 3]; let data = [0u8; 3];
let opt = Ipv6Option::new(&IPV6OPTION_BYTES_UNKNOWN); let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN);
let unknown = Repr::parse(&opt).unwrap(); let unknown = Repr::parse(&opt).unwrap();
assert_eq!(unknown, Repr::Unknown { type_: Type::Unknown(255), length: 3, data: &data}); assert_eq!(unknown, Repr::Unknown { type_: Type::Unknown(255), length: 3, data: &data });
} }
#[test] #[test]
fn test_option_emit() { fn test_option_emit() {
let repr = Repr::Pad1; let repr = Repr::Pad1;
let mut bytes = [255u8; 1]; // don't assume bytes are initialized to zero let mut bytes = [255u8; 1]; // don't assume bytes are initialized to zero
let mut opt = Ipv6Option::new(&mut bytes); let mut opt = Ipv6Option::new_unchecked(&mut bytes);
repr.emit(&mut opt); repr.emit(&mut opt);
assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_PAD1); assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_PAD1);
let repr = Repr::PadN(1); let repr = Repr::PadN(1);
let mut bytes = [255u8; 3]; // don't assume bytes are initialized to zero let mut bytes = [255u8; 3]; // don't assume bytes are initialized to zero
let mut opt = Ipv6Option::new(&mut bytes); let mut opt = Ipv6Option::new_unchecked(&mut bytes);
repr.emit(&mut opt); repr.emit(&mut opt);
assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_PADN); assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_PADN);
let data = [0u8; 3]; let data = [0u8; 3];
let repr = Repr::Unknown { type_: Type::Unknown(255), length: 3, data: &data }; let repr = Repr::Unknown { type_: Type::Unknown(255), length: 3, data: &data };
let mut bytes = [254u8; 5]; // don't assume bytes are initialized to zero let mut bytes = [254u8; 5]; // don't assume bytes are initialized to zero
let mut opt = Ipv6Option::new(&mut bytes); let mut opt = Ipv6Option::new_unchecked(&mut bytes);
repr.emit(&mut opt); repr.emit(&mut opt);
assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_UNKNOWN); assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_UNKNOWN);
} }

4
src/wire/ipv6routing.rs
View File

@ -146,9 +146,9 @@ impl<T: AsRef<[u8]>> Header<T> {
Header { buffer } Header { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Header<T>> { pub fn new_checked(buffer: T) -> Result<Header<T>> {
let header = Self::new(buffer); let header = Self::new(buffer);

28
src/wire/mld.rs
View File

@ -172,16 +172,16 @@ pub struct AddressRecord<T: AsRef<[u8]>> {
impl<T: AsRef<[u8]>> AddressRecord<T> { impl<T: AsRef<[u8]>> AddressRecord<T> {
/// Imbue a raw octet buffer with a Address Record structure. /// Imbue a raw octet buffer with a Address Record structure.
pub fn new(buffer: T) -> Self { pub fn new_unchecked(buffer: T) -> Self {
Self { buffer } Self { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Self> { pub fn new_checked(buffer: T) -> Result<Self> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -459,7 +459,7 @@ mod test {
#[test] #[test]
fn test_query_deconstruct() { fn test_query_deconstruct() {
let packet = Packet::new(&QUERY_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&QUERY_PACKET_BYTES[..]);
assert_eq!(packet.msg_type(), Message::MldQuery); assert_eq!(packet.msg_type(), Message::MldQuery);
assert_eq!(packet.msg_code(), 0); assert_eq!(packet.msg_code(), 0);
assert_eq!(packet.checksum(), 0x7374); assert_eq!(packet.checksum(), 0x7374);
@ -476,7 +476,7 @@ mod test {
#[test] #[test]
fn test_query_construct() { fn test_query_construct() {
let mut bytes = vec![0xff; 44]; let mut bytes = vec![0xff; 44];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
packet.set_msg_type(Message::MldQuery); packet.set_msg_type(Message::MldQuery);
packet.set_msg_code(0); packet.set_msg_code(0);
packet.set_max_resp_code(0x0400); packet.set_max_resp_code(0x0400);
@ -494,12 +494,12 @@ mod test {
#[test] #[test]
fn test_record_deconstruct() { fn test_record_deconstruct() {
let packet = Packet::new(&REPORT_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&REPORT_PACKET_BYTES[..]);
assert_eq!(packet.msg_type(), Message::MldReport); assert_eq!(packet.msg_type(), Message::MldReport);
assert_eq!(packet.msg_code(), 0); assert_eq!(packet.msg_code(), 0);
assert_eq!(packet.checksum(), 0x7385); assert_eq!(packet.checksum(), 0x7385);
assert_eq!(packet.nr_mcast_addr_rcrds(), 0x01); assert_eq!(packet.nr_mcast_addr_rcrds(), 0x01);
let addr_rcrd = AddressRecord::new(packet.payload()); let addr_rcrd = AddressRecord::new_unchecked(packet.payload());
assert_eq!(addr_rcrd.record_type(), RecordType::ModeIsInclude); assert_eq!(addr_rcrd.record_type(), RecordType::ModeIsInclude);
assert_eq!(addr_rcrd.aux_data_len(), 0x00); assert_eq!(addr_rcrd.aux_data_len(), 0x00);
assert_eq!(addr_rcrd.num_srcs(), 0x01); assert_eq!(addr_rcrd.num_srcs(), 0x01);
@ -511,13 +511,13 @@ mod test {
#[test] #[test]
fn test_record_construct() { fn test_record_construct() {
let mut bytes = vec![0xff; 44]; let mut bytes = vec![0xff; 44];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
packet.set_msg_type(Message::MldReport); packet.set_msg_type(Message::MldReport);
packet.set_msg_code(0); packet.set_msg_code(0);
packet.clear_reserved(); packet.clear_reserved();
packet.set_nr_mcast_addr_rcrds(1); packet.set_nr_mcast_addr_rcrds(1);
{ {
let mut addr_rcrd = AddressRecord::new(packet.payload_mut()); let mut addr_rcrd = AddressRecord::new_unchecked(packet.payload_mut());
addr_rcrd.set_record_type(RecordType::ModeIsInclude); addr_rcrd.set_record_type(RecordType::ModeIsInclude);
addr_rcrd.set_aux_data_len(0); addr_rcrd.set_aux_data_len(0);
addr_rcrd.set_num_srcs(1); addr_rcrd.set_num_srcs(1);
@ -532,7 +532,7 @@ mod test {
#[test] #[test]
fn test_query_repr_parse() { fn test_query_repr_parse() {
let packet = Packet::new(&QUERY_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&QUERY_PACKET_BYTES[..]);
let repr = Icmpv6Repr::parse(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(), let repr = Icmpv6Repr::parse(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
&Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(), &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
&packet, &packet,
@ -542,7 +542,7 @@ mod test {
#[test] #[test]
fn test_report_repr_parse() { fn test_report_repr_parse() {
let packet = Packet::new(&REPORT_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&REPORT_PACKET_BYTES[..]);
let repr = Icmpv6Repr::parse(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(), let repr = Icmpv6Repr::parse(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
&Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(), &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
&packet, &packet,
@ -553,7 +553,7 @@ mod test {
#[test] #[test]
fn test_query_repr_emit() { fn test_query_repr_emit() {
let mut bytes = [0x2a; 44]; let mut bytes = [0x2a; 44];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
let repr = create_repr(Message::MldQuery); let repr = create_repr(Message::MldQuery);
repr.emit(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(), repr.emit(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
&Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(), &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
@ -565,7 +565,7 @@ mod test {
#[test] #[test]
fn test_report_repr_emit() { fn test_report_repr_emit() {
let mut bytes = [0x2a; 44]; let mut bytes = [0x2a; 44];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
let repr = create_repr(Message::MldReport); let repr = create_repr(Message::MldReport);
repr.emit(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(), repr.emit(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
&Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(), &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),

6
src/wire/mod.rs
View File

@ -23,8 +23,8 @@ returned `Ok(())`, then no accessor or setter method will panic; however, the gu
provided by `Packet::check_len()` may no longer hold after changing certain fields, provided by `Packet::check_len()` may no longer hold after changing certain fields,
which are listed in the documentation for the specific packet. which are listed in the documentation for the specific packet.
The `Packet::new_checked` method is a shorthand for a combination of `Packet::new` and The `Packet::new_checked` method is a shorthand for a combination of `Packet::new_unchecked`
`Packet::check_len`. and `Packet::check_len`.
When parsing untrusted input, it is *necessary* to use `Packet::new_checked()`; When parsing untrusted input, it is *necessary* to use `Packet::new_checked()`;
so long as the buffer is not modified, no accessor will fail. so long as the buffer is not modified, no accessor will fail.
When emitting output, though, it is *incorrect* to use `Packet::new_checked()`; When emitting output, though, it is *incorrect* to use `Packet::new_checked()`;
@ -56,7 +56,7 @@ let repr = Ipv4Repr {
}; };
let mut buffer = vec![0; repr.buffer_len() + repr.payload_len]; let mut buffer = vec![0; repr.buffer_len() + repr.payload_len];
{ // emission { // emission
let mut packet = Ipv4Packet::new(&mut buffer); let mut packet = Ipv4Packet::new_unchecked(&mut buffer);
repr.emit(&mut packet, &ChecksumCapabilities::default()); repr.emit(&mut packet, &ChecksumCapabilities::default());
} }
{ // parsing { // parsing

34
src/wire/ndisc.rs
View File

@ -305,7 +305,8 @@ impl<'a> Repr<'a> {
if opt.data_len() < 6 { if opt.data_len() < 6 {
return Err(Error::Truncated) return Err(Error::Truncated)
} else { } else {
let ip_packet = Ipv6Packet::new(&opt.data()[offset + 8..]); let ip_packet =
Ipv6Packet::new_unchecked(&opt.data()[offset + 8..]);
let ip_repr = Ipv6Repr::parse(&ip_packet)?; let ip_repr = Ipv6Repr::parse(&ip_packet)?;
let data = &opt.data()[offset + 8 + ip_repr.buffer_len()..]; let data = &opt.data()[offset + 8 + ip_repr.buffer_len()..];
redirected_hdr = Some(NdiscRedirectedHeader { redirected_hdr = Some(NdiscRedirectedHeader {
@ -375,7 +376,7 @@ impl<'a> Repr<'a> {
packet.set_msg_code(0); packet.set_msg_code(0);
packet.clear_reserved(); packet.clear_reserved();
if let Some(lladdr) = lladdr { if let Some(lladdr) = lladdr {
let mut opt_pkt = NdiscOption::new(packet.payload_mut()); let mut opt_pkt = NdiscOption::new_unchecked(packet.payload_mut());
NdiscOptionRepr::SourceLinkLayerAddr(lladdr).emit(&mut opt_pkt); NdiscOptionRepr::SourceLinkLayerAddr(lladdr).emit(&mut opt_pkt);
} }
}, },
@ -391,17 +392,20 @@ impl<'a> Repr<'a> {
packet.set_retrans_time(retrans_time); packet.set_retrans_time(retrans_time);
let mut offset = 0; let mut offset = 0;
if let Some(lladdr) = lladdr { if let Some(lladdr) = lladdr {
let mut opt_pkt = NdiscOption::new(packet.payload_mut()); let mut opt_pkt =
NdiscOption::new_unchecked(packet.payload_mut());
NdiscOptionRepr::SourceLinkLayerAddr(lladdr).emit(&mut opt_pkt); NdiscOptionRepr::SourceLinkLayerAddr(lladdr).emit(&mut opt_pkt);
offset += 8; offset += 8;
} }
if let Some(mtu) = mtu { if let Some(mtu) = mtu {
let mut opt_pkt = NdiscOption::new(&mut packet.payload_mut()[offset..]); let mut opt_pkt =
NdiscOption::new_unchecked(&mut packet.payload_mut()[offset..]);
NdiscOptionRepr::Mtu(mtu).emit(&mut opt_pkt); NdiscOptionRepr::Mtu(mtu).emit(&mut opt_pkt);
offset += 8; offset += 8;
} }
if let Some(prefix_info) = prefix_info { if let Some(prefix_info) = prefix_info {
let mut opt_pkt = NdiscOption::new(&mut packet.payload_mut()[offset..]); let mut opt_pkt =
NdiscOption::new_unchecked(&mut packet.payload_mut()[offset..]);
NdiscOptionRepr::PrefixInformation(prefix_info).emit(&mut opt_pkt) NdiscOptionRepr::PrefixInformation(prefix_info).emit(&mut opt_pkt)
} }
}, },
@ -412,7 +416,8 @@ impl<'a> Repr<'a> {
packet.clear_reserved(); packet.clear_reserved();
packet.set_target_addr(target_addr); packet.set_target_addr(target_addr);
if let Some(lladdr) = lladdr { if let Some(lladdr) = lladdr {
let mut opt_pkt = NdiscOption::new(packet.payload_mut()); let mut opt_pkt =
NdiscOption::new_unchecked(packet.payload_mut());
NdiscOptionRepr::SourceLinkLayerAddr(lladdr).emit(&mut opt_pkt); NdiscOptionRepr::SourceLinkLayerAddr(lladdr).emit(&mut opt_pkt);
} }
}, },
@ -424,7 +429,8 @@ impl<'a> Repr<'a> {
packet.set_neighbor_flags(flags); packet.set_neighbor_flags(flags);
packet.set_target_addr(target_addr); packet.set_target_addr(target_addr);
if let Some(lladdr) = lladdr { if let Some(lladdr) = lladdr {
let mut opt_pkt = NdiscOption::new(packet.payload_mut()); let mut opt_pkt =
NdiscOption::new_unchecked(packet.payload_mut());
NdiscOptionRepr::TargetLinkLayerAddr(lladdr).emit(&mut opt_pkt); NdiscOptionRepr::TargetLinkLayerAddr(lladdr).emit(&mut opt_pkt);
} }
}, },
@ -437,14 +443,16 @@ impl<'a> Repr<'a> {
packet.set_dest_addr(dest_addr); packet.set_dest_addr(dest_addr);
let offset = match lladdr { let offset = match lladdr {
Some(lladdr) => { Some(lladdr) => {
let mut opt_pkt = NdiscOption::new(packet.payload_mut()); let mut opt_pkt =
NdiscOption::new_unchecked(packet.payload_mut());
NdiscOptionRepr::TargetLinkLayerAddr(lladdr).emit(&mut opt_pkt); NdiscOptionRepr::TargetLinkLayerAddr(lladdr).emit(&mut opt_pkt);
8 8
}, },
None => 0, None => 0,
}; };
if let Some(redirected_hdr) = redirected_hdr { if let Some(redirected_hdr) = redirected_hdr {
let mut opt_pkt = NdiscOption::new(&mut packet.payload_mut()[offset..]); let mut opt_pkt =
NdiscOption::new_unchecked(&mut packet.payload_mut()[offset..]);
NdiscOptionRepr::RedirectedHeader(redirected_hdr).emit(&mut opt_pkt); NdiscOptionRepr::RedirectedHeader(redirected_hdr).emit(&mut opt_pkt);
} }
}, },
@ -485,7 +493,7 @@ mod test {
#[test] #[test]
fn test_router_advert_deconstruct() { fn test_router_advert_deconstruct() {
let packet = Packet::new(&ROUTER_ADVERT_BYTES[..]); let packet = Packet::new_unchecked(&ROUTER_ADVERT_BYTES[..]);
assert_eq!(packet.msg_type(), Message::RouterAdvert); assert_eq!(packet.msg_type(), Message::RouterAdvert);
assert_eq!(packet.msg_code(), 0); assert_eq!(packet.msg_code(), 0);
assert_eq!(packet.current_hop_limit(), 64); assert_eq!(packet.current_hop_limit(), 64);
@ -499,7 +507,7 @@ mod test {
#[test] #[test]
fn test_router_advert_construct() { fn test_router_advert_construct() {
let mut bytes = vec![0x0; 24]; let mut bytes = vec![0x0; 24];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_msg_type(Message::RouterAdvert); packet.set_msg_type(Message::RouterAdvert);
packet.set_msg_code(0); packet.set_msg_code(0);
packet.set_current_hop_limit(64); packet.set_current_hop_limit(64);
@ -514,7 +522,7 @@ mod test {
#[test] #[test]
fn test_router_advert_repr_parse() { fn test_router_advert_repr_parse() {
let packet = Packet::new(&ROUTER_ADVERT_BYTES[..]); let packet = Packet::new_unchecked(&ROUTER_ADVERT_BYTES[..]);
assert_eq!(Icmpv6Repr::parse(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2, assert_eq!(Icmpv6Repr::parse(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2,
&packet, &ChecksumCapabilities::default()).unwrap(), &packet, &ChecksumCapabilities::default()).unwrap(),
create_repr()); create_repr());
@ -523,7 +531,7 @@ mod test {
#[test] #[test]
fn test_router_advert_repr_emit() { fn test_router_advert_repr_emit() {
let mut bytes = vec![0x2a; 24]; let mut bytes = vec![0x2a; 24];
let mut packet = Packet::new(&mut bytes[..]); let mut packet = Packet::new_unchecked(&mut bytes[..]);
create_repr().emit(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2, create_repr().emit(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2,
&mut packet, &ChecksumCapabilities::default()); &mut packet, &ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &ROUTER_ADVERT_BYTES[..]); assert_eq!(&packet.into_inner()[..], &ROUTER_ADVERT_BYTES[..]);

27
src/wire/ndiscoption.rs
View File

@ -145,16 +145,16 @@ mod field {
/// Core getter methods relevant to any type of NDISC option. /// Core getter methods relevant to any type of NDISC option.
impl<T: AsRef<[u8]>> NdiscOption<T> { impl<T: AsRef<[u8]>> NdiscOption<T> {
/// Create a raw octet buffer with an NDISC Option structure. /// Create a raw octet buffer with an NDISC Option structure.
pub fn new(buffer: T) -> NdiscOption<T> { pub fn new_unchecked(buffer: T) -> NdiscOption<T> {
NdiscOption { buffer } NdiscOption { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<NdiscOption<T>> { pub fn new_checked(buffer: T) -> Result<NdiscOption<T>> {
let opt = Self::new(buffer); let opt = Self::new_unchecked(buffer);
opt.check_len()?; opt.check_len()?;
Ok(opt) Ok(opt)
} }
@ -460,7 +460,7 @@ impl<'a> Repr<'a> {
if opt.data_len() < 6 { if opt.data_len() < 6 {
Err(Error::Truncated) Err(Error::Truncated)
} else { } else {
let ip_packet = Ipv6Packet::new(&opt.data()[field::IP_DATA..]); let ip_packet = Ipv6Packet::new_unchecked(&opt.data()[field::IP_DATA..]);
let ip_repr = Ipv6Repr::parse(&ip_packet)?; let ip_repr = Ipv6Repr::parse(&ip_packet)?;
Ok(Repr::RedirectedHeader(RedirectedHeader { Ok(Repr::RedirectedHeader(RedirectedHeader {
header: ip_repr, header: ip_repr,
@ -535,7 +535,8 @@ impl<'a> Repr<'a> {
opt.clear_redirected_reserved(); opt.clear_redirected_reserved();
opt.set_option_type(Type::RedirectedHeader); opt.set_option_type(Type::RedirectedHeader);
opt.set_data_len((header.buffer_len() + 1 + data_len) as u8); opt.set_data_len((header.buffer_len() + 1 + data_len) as u8);
let mut ip_packet = Ipv6Packet::new(&mut opt.data_mut()[field::IP_DATA..]); let mut ip_packet =
Ipv6Packet::new_unchecked(&mut opt.data_mut()[field::IP_DATA..]);
header.emit(&mut ip_packet); header.emit(&mut ip_packet);
let payload = &mut ip_packet.into_inner()[header.buffer_len()..]; let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
payload.copy_from_slice(&data[..data_len]); payload.copy_from_slice(&data[..data_len]);
@ -625,7 +626,7 @@ mod test {
#[test] #[test]
fn test_deconstruct() { fn test_deconstruct() {
let opt = NdiscOption::new(&PREFIX_OPT_BYTES[..]); let opt = NdiscOption::new_unchecked(&PREFIX_OPT_BYTES[..]);
assert_eq!(opt.option_type(), Type::PrefixInformation); assert_eq!(opt.option_type(), Type::PrefixInformation);
assert_eq!(opt.data_len(), 4); assert_eq!(opt.data_len(), 4);
assert_eq!(opt.prefix_len(), 64); assert_eq!(opt.prefix_len(), 64);
@ -638,7 +639,7 @@ mod test {
#[test] #[test]
fn test_construct() { fn test_construct() {
let mut bytes = [0x00; 32]; let mut bytes = [0x00; 32];
let mut opt = NdiscOption::new(&mut bytes[..]); let mut opt = NdiscOption::new_unchecked(&mut bytes[..]);
opt.set_option_type(Type::PrefixInformation); opt.set_option_type(Type::PrefixInformation);
opt.set_data_len(4); opt.set_data_len(4);
opt.set_prefix_len(64); opt.set_prefix_len(64);
@ -664,12 +665,12 @@ mod test {
let mut bytes = [0x01, 0x01, 0x54, 0x52, 0x00, 0x12, 0x23, 0x34]; let mut bytes = [0x01, 0x01, 0x54, 0x52, 0x00, 0x12, 0x23, 0x34];
let addr = EthernetAddress([0x54, 0x52, 0x00, 0x12, 0x23, 0x34]); let addr = EthernetAddress([0x54, 0x52, 0x00, 0x12, 0x23, 0x34]);
{ {
assert_eq!(Repr::parse(&NdiscOption::new(&bytes)), assert_eq!(Repr::parse(&NdiscOption::new_unchecked(&bytes)),
Ok(Repr::SourceLinkLayerAddr(addr))); Ok(Repr::SourceLinkLayerAddr(addr)));
} }
bytes[0] = 0x02; bytes[0] = 0x02;
{ {
assert_eq!(Repr::parse(&NdiscOption::new(&bytes)), assert_eq!(Repr::parse(&NdiscOption::new_unchecked(&bytes)),
Ok(Repr::TargetLinkLayerAddr(addr))); Ok(Repr::TargetLinkLayerAddr(addr)));
} }
} }
@ -683,7 +684,7 @@ mod test {
preferred_lifetime: Duration::from_secs(1000), preferred_lifetime: Duration::from_secs(1000),
prefix: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1) prefix: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1)
}); });
assert_eq!(Repr::parse(&NdiscOption::new(&PREFIX_OPT_BYTES)), Ok(repr)); assert_eq!(Repr::parse(&NdiscOption::new_unchecked(&PREFIX_OPT_BYTES)), Ok(repr));
} }
#[test] #[test]
@ -696,7 +697,7 @@ mod test {
preferred_lifetime: Duration::from_secs(1000), preferred_lifetime: Duration::from_secs(1000),
prefix: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1) prefix: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1)
}); });
let mut opt = NdiscOption::new(&mut bytes); let mut opt = NdiscOption::new_unchecked(&mut bytes);
repr.emit(&mut opt); repr.emit(&mut opt);
assert_eq!(&opt.into_inner()[..], &PREFIX_OPT_BYTES[..]); assert_eq!(&opt.into_inner()[..], &PREFIX_OPT_BYTES[..]);
} }
@ -704,6 +705,6 @@ mod test {
#[test] #[test]
fn test_repr_parse_mtu() { fn test_repr_parse_mtu() {
let bytes = [0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x05, 0xdc]; let bytes = [0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x05, 0xdc];
assert_eq!(Repr::parse(&NdiscOption::new(&bytes)), Ok(Repr::Mtu(1500))); assert_eq!(Repr::parse(&NdiscOption::new_unchecked(&bytes)), Ok(Repr::Mtu(1500)));
} }
} }

20
src/wire/tcp.rs
View File

@ -107,16 +107,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with TCP packet structure. /// Imbue a raw octet buffer with TCP packet structure.
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -927,7 +927,7 @@ mod test {
#[test] #[test]
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
fn test_deconstruct() { fn test_deconstruct() {
let packet = Packet::new(&PACKET_BYTES[..]); let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
assert_eq!(packet.src_port(), 48896); assert_eq!(packet.src_port(), 48896);
assert_eq!(packet.dst_port(), 80); assert_eq!(packet.dst_port(), 80);
assert_eq!(packet.seq_number(), SeqNumber(0x01234567)); assert_eq!(packet.seq_number(), SeqNumber(0x01234567));
@ -951,7 +951,7 @@ mod test {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
fn test_construct() { fn test_construct() {
let mut bytes = vec![0xa5; PACKET_BYTES.len()]; let mut bytes = vec![0xa5; PACKET_BYTES.len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_src_port(48896); packet.set_src_port(48896);
packet.set_dst_port(80); packet.set_dst_port(80);
packet.set_seq_number(SeqNumber(0x01234567)); packet.set_seq_number(SeqNumber(0x01234567));
@ -976,14 +976,14 @@ mod test {
#[test] #[test]
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
fn test_truncated() { fn test_truncated() {
let packet = Packet::new(&PACKET_BYTES[..23]); let packet = Packet::new_unchecked(&PACKET_BYTES[..23]);
assert_eq!(packet.check_len(), Err(Error::Truncated)); assert_eq!(packet.check_len(), Err(Error::Truncated));
} }
#[test] #[test]
fn test_impossible_len() { fn test_impossible_len() {
let mut bytes = vec![0; 20]; let mut bytes = vec![0; 20];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_header_len(10); packet.set_header_len(10);
assert_eq!(packet.check_len(), Err(Error::Malformed)); assert_eq!(packet.check_len(), Err(Error::Malformed));
} }
@ -1015,7 +1015,7 @@ mod test {
#[test] #[test]
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
fn test_parse() { fn test_parse() {
let packet = Packet::new(&SYN_PACKET_BYTES[..]); let packet = Packet::new_unchecked(&SYN_PACKET_BYTES[..]);
let repr = Repr::parse(&packet, &SRC_ADDR.into(), &DST_ADDR.into(), &ChecksumCapabilities::default()).unwrap(); let repr = Repr::parse(&packet, &SRC_ADDR.into(), &DST_ADDR.into(), &ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, packet_repr()); assert_eq!(repr, packet_repr());
} }
@ -1025,7 +1025,7 @@ mod test {
fn test_emit() { fn test_emit() {
let repr = packet_repr(); let repr = packet_repr();
let mut bytes = vec![0xa5; repr.buffer_len()]; let mut bytes = vec![0xa5; repr.buffer_len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&mut packet, &SRC_ADDR.into(), &DST_ADDR.into(), &ChecksumCapabilities::default()); repr.emit(&mut packet, &SRC_ADDR.into(), &DST_ADDR.into(), &ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &SYN_PACKET_BYTES[..]); assert_eq!(&packet.into_inner()[..], &SYN_PACKET_BYTES[..]);
} }

26
src/wire/udp.rs
View File

@ -29,16 +29,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> { impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with UDP packet structure. /// Imbue a raw octet buffer with UDP packet structure.
pub fn new(buffer: T) -> Packet<T> { pub fn new_unchecked(buffer: T) -> Packet<T> {
Packet { buffer } Packet { buffer }
} }
/// Shorthand for a combination of [new] and [check_len]. /// Shorthand for a combination of [new_unchecked] and [check_len].
/// ///
/// [new]: #method.new /// [new_unchecked]: #method.new_unchecked
/// [check_len]: #method.check_len /// [check_len]: #method.check_len
pub fn new_checked(buffer: T) -> Result<Packet<T>> { pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer); let packet = Self::new_unchecked(buffer);
packet.check_len()?; packet.check_len()?;
Ok(packet) Ok(packet)
} }
@ -310,7 +310,7 @@ mod test {
#[test] #[test]
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
fn test_deconstruct() { fn test_deconstruct() {
let packet = Packet::new(&PACKET_BYTES[..]); let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
assert_eq!(packet.src_port(), 48896); assert_eq!(packet.src_port(), 48896);
assert_eq!(packet.dst_port(), 53); assert_eq!(packet.dst_port(), 53);
assert_eq!(packet.len(), 12); assert_eq!(packet.len(), 12);
@ -323,7 +323,7 @@ mod test {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
fn test_construct() { fn test_construct() {
let mut bytes = vec![0xa5; 12]; let mut bytes = vec![0xa5; 12];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_src_port(48896); packet.set_src_port(48896);
packet.set_dst_port(53); packet.set_dst_port(53);
packet.set_len(12); packet.set_len(12);
@ -336,7 +336,7 @@ mod test {
#[test] #[test]
fn test_impossible_len() { fn test_impossible_len() {
let mut bytes = vec![0; 12]; let mut bytes = vec![0; 12];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_len(4); packet.set_len(4);
assert_eq!(packet.check_len(), Err(Error::Malformed)); assert_eq!(packet.check_len(), Err(Error::Malformed));
} }
@ -345,7 +345,7 @@ mod test {
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
fn test_zero_checksum() { fn test_zero_checksum() {
let mut bytes = vec![0; 8]; let mut bytes = vec![0; 8];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
packet.set_src_port(1); packet.set_src_port(1);
packet.set_dst_port(31881); packet.set_dst_port(31881);
packet.set_len(8); packet.set_len(8);
@ -365,8 +365,9 @@ mod test {
#[test] #[test]
#[cfg(feature = "proto-ipv4")] #[cfg(feature = "proto-ipv4")]
fn test_parse() { fn test_parse() {
let packet = Packet::new(&PACKET_BYTES[..]); let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
let repr = Repr::parse(&packet, &SRC_ADDR.into(), &DST_ADDR.into(), &ChecksumCapabilities::default()).unwrap(); let repr = Repr::parse(&packet, &SRC_ADDR.into(), &DST_ADDR.into(),
&ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, packet_repr()); assert_eq!(repr, packet_repr());
} }
@ -375,8 +376,9 @@ mod test {
fn test_emit() { fn test_emit() {
let repr = packet_repr(); let repr = packet_repr();
let mut bytes = vec![0xa5; repr.buffer_len()]; let mut bytes = vec![0xa5; repr.buffer_len()];
let mut packet = Packet::new(&mut bytes); let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&mut packet, &SRC_ADDR.into(), &DST_ADDR.into(), &ChecksumCapabilities::default()); repr.emit(&mut packet, &SRC_ADDR.into(), &DST_ADDR.into(),
&ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &PACKET_BYTES[..]); assert_eq!(&packet.into_inner()[..], &PACKET_BYTES[..]);
} }
} }