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
v0.7.x
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)
.unwrap();
let mut icmp_packet = $packet_type::new(icmp_payload);
let mut icmp_packet = $packet_type::new_unchecked(icmp_payload);
(icmp_repr, icmp_packet)
}}
}
@ -168,13 +168,14 @@ fn main() {
match remote_addr {
IpAddress::Ipv4(_) => {
let icmp_packet = Icmpv4Packet::new(&payload);
let icmp_repr = Icmpv4Repr::parse(&icmp_packet, &device_caps.checksum).unwrap();
let icmp_packet = Icmpv4Packet::new_checked(&payload).unwrap();
let icmp_repr =
Icmpv4Repr::parse(&icmp_packet, &device_caps.checksum).unwrap();
get_icmp_pong!(Icmpv4Repr, icmp_repr, payload,
waiting_queue, remote_addr, timestamp, received);
}
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,
&icmp_packet, &device_caps.checksum).unwrap();
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_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);
})
},
@ -1084,7 +1084,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
Packet::Icmpv4((ipv4_repr, icmpv4_repr)) => {
self.dispatch_ip(tx_token, timestamp, IpRepr::Ipv4(ipv4_repr),
|_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")]
@ -1092,7 +1092,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
self.dispatch_ip(tx_token, timestamp, IpRepr::Ipv6(ipv6_repr),
|ip_repr, payload| {
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")]
@ -1104,7 +1104,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
#[cfg(feature = "socket-udp")]
Packet::Udp((ip_repr, udp_repr)) => {
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(),
&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(),
&checksum_caps);
})
@ -1148,7 +1148,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
let tx_len = EthernetFrame::<&[u8]>::buffer_len(buffer_len);
tx_token.consume(timestamp, tx_len, |tx_buffer| {
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);
f(frame);
@ -1254,7 +1254,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
frame.set_dst_addr(EthernetAddress::BROADCAST);
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)
@ -1282,7 +1282,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
self.dispatch_ip(tx_token, timestamp, ip_repr, |ip_repr, payload| {
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)
@ -1419,12 +1419,12 @@ mod test {
});
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_src_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]));
frame.set_ethertype(EthernetProtocol::Ipv4);
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
@ -1457,12 +1457,12 @@ mod test {
// emit the above repr to a 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_src_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]));
frame.set_ethertype(EthernetProtocol::Ipv4);
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
@ -1508,8 +1508,8 @@ mod test {
let mut udp_bytes_unicast = vec![0u8; 20];
let mut udp_bytes_broadcast = vec![0u8; 20];
let mut packet_unicast = UdpPacket::new(&mut udp_bytes_unicast);
let mut packet_broadcast = UdpPacket::new(&mut udp_bytes_broadcast);
let mut packet_unicast = UdpPacket::new_unchecked(&mut udp_bytes_unicast);
let mut packet_broadcast = UdpPacket::new_unchecked(&mut udp_bytes_broadcast);
let udp_repr = UdpRepr {
src_port: 67,
@ -1596,7 +1596,7 @@ mod test {
let udp_socket = UdpSocket::new(rx_buffer, tx_buffer);
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);
@ -1686,7 +1686,7 @@ mod test {
payload: &[0x2a; MAX_PAYLOAD_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());
#[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
let ip_repr = Ipv4Repr {
@ -1767,12 +1767,12 @@ mod test {
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_src_addr(remote_hw_addr);
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);
}
@ -1816,14 +1816,15 @@ mod test {
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_src_addr(remote_hw_addr);
frame.set_ethertype(EthernetProtocol::Ipv6);
{
ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default());
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());
}
@ -1869,12 +1870,12 @@ mod test {
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_src_addr(remote_hw_addr);
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);
}
@ -1916,7 +1917,7 @@ mod test {
// Ensure the ident we bound to and the ident of the packet are the same.
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 };
echo_repr.emit(&mut packet, &ChecksumCapabilities::default());
let icmp_data = &packet.into_inner()[..];
@ -1990,7 +1991,7 @@ mod test {
};
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);
frame.set_dst_addr(EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]));
frame.set_src_addr(remote_hw_addr);
@ -1998,21 +1999,22 @@ mod test {
ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default());
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_header_len(0);
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);
}
{
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);
}
}
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 {

56
src/socket/icmp.rs
View File

@ -256,7 +256,7 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
#[cfg(feature = "proto-ipv4")]
(&Endpoint::Udp(endpoint), &IcmpRepr::Ipv4(Icmpv4Repr::DstUnreachable { data, .. }))
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) {
Ok(repr) => endpoint.port == repr.src_port,
Err(_) => false,
@ -265,7 +265,7 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
#[cfg(feature = "proto-ipv6")]
(&Endpoint::Udp(endpoint), &IcmpRepr::Ipv6(Icmpv6Repr::DstUnreachable { data, .. }))
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) {
Ok(repr) => endpoint.port == repr.src_port,
Err(_) => false,
@ -275,12 +275,16 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
// Echo Request/Reply with the identifier field matching the endpoint
// port.
#[cfg(feature = "proto-ipv4")]
(&Endpoint::Ident(bound_ident), &IcmpRepr::Ipv4(Icmpv4Repr::EchoRequest { ident, .. })) |
(&Endpoint::Ident(bound_ident), &IcmpRepr::Ipv4(Icmpv4Repr::EchoReply { ident, .. })) =>
(&Endpoint::Ident(bound_ident),
&IcmpRepr::Ipv4(Icmpv4Repr::EchoRequest { ident, .. })) |
(&Endpoint::Ident(bound_ident),
&IcmpRepr::Ipv4(Icmpv4Repr::EchoReply { ident, .. })) =>
ident == bound_ident,
#[cfg(feature = "proto-ipv6")]
(&Endpoint::Ident(bound_ident), &IcmpRepr::Ipv6(Icmpv6Repr::EchoRequest { ident, .. })) |
(&Endpoint::Ident(bound_ident), &IcmpRepr::Ipv6(Icmpv6Repr::EchoReply { ident, .. })) =>
(&Endpoint::Ident(bound_ident),
&IcmpRepr::Ipv6(Icmpv6Repr::EchoRequest { ident, .. })) |
(&Endpoint::Ident(bound_ident),
&IcmpRepr::Ipv6(Icmpv6Repr::EchoReply { ident, .. })) =>
ident == bound_ident,
_ => false,
}
@ -291,17 +295,21 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
match icmp_repr {
#[cfg(feature = "proto-ipv4")]
&IcmpRepr::Ipv4(ref icmp_repr) => {
let packet_buf = self.rx_buffer.enqueue(icmp_repr.buffer_len(), ip_repr.src_addr())?;
icmp_repr.emit(&mut Icmpv4Packet::new(packet_buf), &ChecksumCapabilities::default());
let packet_buf = self.rx_buffer.enqueue(icmp_repr.buffer_len(),
ip_repr.src_addr())?;
icmp_repr.emit(&mut Icmpv4Packet::new_unchecked(packet_buf),
&ChecksumCapabilities::default());
net_trace!("{}:{}: receiving {} octets",
self.meta.handle, icmp_repr.buffer_len(), packet_buf.len());
},
#[cfg(feature = "proto-ipv6")]
&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(),
&mut Icmpv6Packet::new(packet_buf), &ChecksumCapabilities::default());
&mut Icmpv6Packet::new_unchecked(packet_buf),
&ChecksumCapabilities::default());
net_trace!("{}:{}: receiving {} octets",
self.meta.handle, icmp_repr.buffer_len(), packet_buf.len());
@ -321,7 +329,7 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
match *remote_endpoint {
#[cfg(feature = "proto-ipv4")]
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 ip_repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address::default(),
@ -334,7 +342,7 @@ impl<'a, 'b> IcmpSocket<'a, 'b> {
},
#[cfg(feature = "proto-ipv6")]
IpAddress::Ipv6(ipv6_addr) => {
let packet = Icmpv6Packet::new(&*packet_buf);
let packet = Icmpv6Packet::new_unchecked(&*packet_buf);
let src_addr = Ipv6Address::default();
let repr = Icmpv6Repr::parse(&src_addr.into(), &ipv6_addr.into(), &packet, &ChecksumCapabilities::ignored())?;
let ip_repr = IpRepr::Ipv6(Ipv6Repr {
@ -443,7 +451,7 @@ mod test_ipv4 {
assert!(socket.can_send());
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);
assert_eq!(socket.send_slice(&packet.into_inner()[..], REMOTE_IPV4.into()), Ok(()));
@ -473,7 +481,7 @@ mod test_ipv4 {
let caps = DeviceCapabilities::default();
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);
s.set_hop_limit(Some(0x2a));
@ -502,7 +510,7 @@ mod test_ipv4 {
let caps = DeviceCapabilities::default();
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);
let data = &packet.into_inner()[..];
@ -526,7 +534,7 @@ mod test_ipv4 {
let caps = DeviceCapabilities::default();
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 {
ident: 0x4321,
seq_no: 0x5678,
@ -547,7 +555,7 @@ mod test_ipv4 {
let caps = DeviceCapabilities::default();
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);
let data = &packet.into_inner()[..];
@ -581,7 +589,7 @@ mod test_ipv4 {
assert!(socket.can_recv());
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);
assert_eq!(socket.recv(), Ok((&packet.into_inner()[..], REMOTE_IPV4.into())));
assert!(!socket.can_recv());
@ -642,7 +650,7 @@ mod test_ipv6 {
assert!(socket.can_send());
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);
assert_eq!(socket.send_slice(&packet.into_inner()[..], REMOTE_IPV6.into()), Ok(()));
@ -672,7 +680,7 @@ mod test_ipv6 {
let caps = DeviceCapabilities::default();
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);
s.set_hop_limit(Some(0x2a));
@ -701,7 +709,7 @@ mod test_ipv6 {
let caps = DeviceCapabilities::default();
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);
let data = &packet.into_inner()[..];
@ -725,7 +733,7 @@ mod test_ipv6 {
let caps = DeviceCapabilities::default();
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 {
ident: 0x4321,
seq_no: 0x5678,
@ -746,7 +754,7 @@ mod test_ipv6 {
let caps = DeviceCapabilities::default();
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);
let data = &packet.into_inner()[..];
@ -780,7 +788,7 @@ mod test_ipv6 {
assert!(socket.can_recv());
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);
assert_eq!(socket.recv(), Ok((&packet.into_inner()[..], REMOTE_IPV6.into())));
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);
}
let packet = Ipv4Packet::new(&*packet.into_inner());
let packet = Ipv4Packet::new_unchecked(&*packet.into_inner());
let ipv4_repr = Ipv4Repr::parse(&packet, checksum_caps)?;
Ok((IpRepr::Ipv4(ipv4_repr), packet.payload()))
}
@ -176,7 +176,7 @@ impl<'a, 'b> RawSocket<'a, 'b> {
IpVersion::Ipv6 => {
let mut packet = Ipv6Packet::new_checked(buffer.as_mut())?;
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)?;
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 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.dispatch(&checksum_caps, |_| unreachable!()),
Ok(()));
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.dispatch(&checksum_caps, |_| unreachable!()),
@ -411,14 +411,14 @@ mod test {
let mut socket = ipv6_locals::socket(buffer(0), buffer(2));
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.dispatch(&checksum_caps, |_| unreachable!()),
Ok(()));
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.dispatch(&checksum_caps, |_| unreachable!()),
@ -434,7 +434,7 @@ mod test {
assert!(!socket.can_recv());
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!(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);
/// be sure to call [new] afterwards.
///
/// [new]: #method.new
/// [new_unchecked]: #method.new_unchecked
pub fn into_inner(mut ref_: Self) -> &'a mut T {
ref_.consumed = true;
ref_.socket

16
src/wire/arp.rs
View File

@ -64,16 +64,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -385,7 +385,7 @@ mod test {
#[test]
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.protocol_type(), Protocol::Ipv4);
assert_eq!(packet.hardware_len(), 6);
@ -400,7 +400,7 @@ mod test {
#[test]
fn test_construct() {
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_protocol_type(Protocol::Ipv4);
packet.set_hardware_len(6);
@ -429,7 +429,7 @@ mod test {
#[test]
fn test_parse() {
let packet = Packet::new(&PACKET_BYTES[..]);
let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
let repr = Repr::parse(&packet).unwrap();
assert_eq!(repr, packet_repr());
}
@ -437,7 +437,7 @@ mod test {
#[test]
fn test_emit() {
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);
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> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -792,7 +792,7 @@ mod test {
#[test]
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.opcode(), OpCode::Request);
assert_eq!(packet.hardware_type(), Hardware::Ethernet);
@ -834,7 +834,7 @@ mod test {
#[test]
fn test_construct_discover() {
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_sname_and_boot_file_to_zero();
packet.set_opcode(OpCode::Request);
@ -889,7 +889,7 @@ mod test {
#[test]
fn test_parse_discover() {
let packet = Packet::new(DISCOVER_BYTES);
let packet = Packet::new_unchecked(DISCOVER_BYTES);
let repr = Repr::parse(&packet).unwrap();
assert_eq!(repr, discover_repr());
}
@ -898,7 +898,7 @@ mod test {
fn test_emit_discover() {
let repr = discover_repr();
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();
let packet = &packet.into_inner()[..];
let packet_len = packet.len();

16
src/wire/ethernet.rs
View File

@ -93,16 +93,16 @@ mod field {
impl<T: AsRef<[u8]>> Frame<T> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Frame<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -317,7 +317,7 @@ mod test_ipv4 {
#[test]
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.src_addr(), Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
assert_eq!(frame.ethertype(), EtherType::Ipv4);
@ -327,7 +327,7 @@ mod test_ipv4 {
#[test]
fn test_construct() {
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_src_addr(Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
frame.set_ethertype(EtherType::Ipv4);
@ -361,7 +361,7 @@ mod test_ipv6 {
#[test]
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.src_addr(), Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
assert_eq!(frame.ethertype(), EtherType::Ipv6);
@ -371,7 +371,7 @@ mod test_ipv6 {
#[test]
fn test_construct() {
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_src_addr(Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
frame.set_ethertype(EtherType::Ipv6);

18
src/wire/icmpv4.rs
View File

@ -188,16 +188,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -478,7 +478,7 @@ impl<'a> Repr<'a> {
packet.set_msg_type(Message::DstUnreachable);
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);
let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
payload.copy_from_slice(&data[..])
@ -566,7 +566,7 @@ mod test {
#[test]
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_code(), 0);
assert_eq!(packet.checksum(), 0x8efe);
@ -579,7 +579,7 @@ mod test {
#[test]
fn test_echo_construct() {
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_code(0);
packet.set_echo_ident(0x1234);
@ -599,7 +599,7 @@ mod test {
#[test]
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();
assert_eq!(repr, echo_packet_repr());
}
@ -608,7 +608,7 @@ mod test {
fn test_echo_emit() {
let repr = echo_packet_repr();
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());
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> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -656,7 +656,7 @@ impl<'a> Repr<'a> {
packet: &mut Packet<&mut T>, checksum_caps: &ChecksumCapabilities)
where T: AsRef<[u8]> + AsMut<[u8]> + ?Sized {
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);
let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
payload.copy_from_slice(&data[..]);
@ -812,7 +812,7 @@ mod test {
#[test]
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_code(), 0);
assert_eq!(packet.checksum(), 0x19b3);
@ -826,7 +826,7 @@ mod test {
#[test]
fn test_echo_construct() {
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_code(0);
packet.set_echo_ident(0x1234);
@ -838,7 +838,7 @@ mod test {
#[test]
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,
&packet, &ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, echo_packet_repr());
@ -848,7 +848,7 @@ mod test {
fn test_echo_emit() {
let repr = echo_packet_repr();
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,
&mut packet, &ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &ECHO_PACKET_BYTES[..]);
@ -856,7 +856,7 @@ mod test {
#[test]
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_code(), 0);
assert_eq!(packet.checksum(), 0x0fc9);
@ -869,7 +869,7 @@ mod test {
#[test]
fn test_too_big_construct() {
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_code(0);
packet.set_pkt_too_big_mtu(1500);
@ -880,7 +880,7 @@ mod test {
#[test]
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,
&packet, &ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, too_big_packet_repr());
@ -890,7 +890,7 @@ mod test {
fn test_too_big_emit() {
let repr = too_big_packet_repr();
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,
&mut packet, &ChecksumCapabilities::default());
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
impl<T: AsRef<[u8]>> Packet<T> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -379,7 +379,7 @@ mod test {
#[test]
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.max_resp_code(), 0);
assert_eq!(packet.checksum(), 0x269);
@ -390,7 +390,7 @@ mod test {
#[test]
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.max_resp_code(), 0);
assert_eq!(packet.checksum(), 0x08da);
@ -402,7 +402,7 @@ mod test {
#[test]
fn test_leave_construct() {
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_max_resp_code(0);
packet.set_group_address(Ipv4Address::from_bytes(&[224, 0, 6, 150]));
@ -413,7 +413,7 @@ mod test {
#[test]
fn test_report_construct() {
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_max_resp_code(0);
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"),
#[cfg(feature = "proto-ipv4")]
&Repr::Ipv4(repr) =>
repr.emit(&mut Ipv4Packet::new(buffer), &_checksum_caps),
repr.emit(&mut Ipv4Packet::new_unchecked(buffer), &_checksum_caps),
#[cfg(feature = "proto-ipv6")]
&Repr::Ipv6(repr) =>
repr.emit(&mut Ipv6Packet::new(buffer)),
repr.emit(&mut Ipv6Packet::new_unchecked(buffer)),
&Repr::__Nonexhaustive =>
unreachable!()
}

26
src/wire/ipv4.rs
View File

@ -241,16 +241,16 @@ mod field {
impl<T: AsRef<[u8]>> Packet<T> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -704,7 +704,7 @@ mod test {
#[test]
fn test_deconstruct() {
let packet = Packet::new(&PACKET_BYTES[..]);
let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
assert_eq!(packet.version(), 4);
assert_eq!(packet.header_len(), 20);
assert_eq!(packet.dscp(), 0);
@ -726,7 +726,7 @@ mod test {
#[test]
fn test_construct() {
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_header_len(20);
packet.clear_flags();
@ -752,9 +752,9 @@ mod test {
bytes.extend(&PACKET_BYTES[..]);
bytes.push(0);
assert_eq!(Packet::new(&bytes).payload().len(),
assert_eq!(Packet::new_unchecked(&bytes).payload().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());
}
@ -762,7 +762,7 @@ mod test {
fn test_total_len_overflow() {
let mut bytes = vec![];
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(),
Error::Truncated);
@ -791,7 +791,7 @@ mod test {
#[test]
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();
assert_eq!(repr, packet_repr());
}
@ -800,10 +800,10 @@ mod test {
fn test_parse_bad_version() {
let mut bytes = vec![0; 24];
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.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));
}
@ -818,7 +818,7 @@ mod test {
fn test_emit() {
let repr = packet_repr();
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());
packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_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> {
/// Create a raw octet buffer with an IPv6 packet structure.
#[inline]
pub fn new(buffer: T) -> Packet<T> {
pub fn new_unchecked(buffer: T) -> Packet<T> {
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
#[inline]
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -930,7 +930,7 @@ mod test {
#[test]
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.version(), 6);
assert_eq!(packet.traffic_class(), 0);
@ -950,7 +950,7 @@ mod test {
#[test]
fn test_packet_construction() {
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
// byte aligned. make sure the setters and getters
// do not interfere with each other.
@ -989,9 +989,9 @@ mod test {
bytes.extend(&REPR_PACKET_BYTES[..]);
bytes.push(0);
assert_eq!(Packet::new(&bytes).payload().len(),
assert_eq!(Packet::new_unchecked(&bytes).payload().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());
}
@ -999,7 +999,7 @@ mod test {
fn test_total_len_overflow() {
let mut bytes = vec![];
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(),
Error::Truncated);
@ -1007,7 +1007,7 @@ mod test {
#[test]
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();
assert_eq!(repr, packet_repr());
}
@ -1015,30 +1015,30 @@ mod test {
#[test]
fn test_repr_parse_bad_version() {
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_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));
}
#[test]
fn test_repr_parse_smaller_than_header() {
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_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));
}
#[test]
fn test_repr_parse_smaller_than_payload() {
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_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));
}
@ -1046,7 +1046,7 @@ mod test {
fn test_basic_repr_emit() {
let repr = packet_repr();
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);
packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_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> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Header<T>> {
let header = Self::new(buffer);
let header = Self::new_unchecked(buffer);
header.check_len()?;
Ok(header)
}
@ -220,20 +220,22 @@ mod test {
#[test]
fn test_check_len() {
// 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
assert_eq!(Ok(()), Header::new(&BYTES_HEADER_MORE_FRAG).check_len());
assert_eq!(Ok(()),
Header::new_unchecked(&BYTES_HEADER_MORE_FRAG).check_len());
}
#[test]
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.frag_offset(), 0);
assert_eq!(header.more_frags(), true);
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.frag_offset(), 320);
assert_eq!(header.more_frags(), false);
@ -242,12 +244,12 @@ mod test {
#[test]
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();
assert_eq!(repr,
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();
assert_eq!(repr,
Repr{ next_header: Protocol::Tcp, frag_offset: 320, more_frags: false, ident: 67890 });
@ -257,20 +259,20 @@ mod test {
fn test_repr_emit() {
let repr = Repr{ next_header: Protocol::Tcp, frag_offset: 0, more_frags: true, ident: 12345 };
let mut bytes = [0u8; 8];
let mut header = Header::new(&mut bytes);
let mut header = Header::new_unchecked(&mut bytes);
repr.emit(&mut header);
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 mut bytes = [0u8; 8];
let mut header = Header::new(&mut bytes);
let mut header = Header::new_unchecked(&mut bytes);
repr.emit(&mut header);
assert_eq!(header.into_inner(), &BYTES_HEADER_LAST_FRAG[0..8]);
}
#[test]
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();
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> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Header<T>> {
let header = Self::new(buffer);
let header = Self::new_unchecked(buffer);
header.check_len()?;
Ok(header)
}
@ -218,28 +218,34 @@ mod test {
#[test]
fn test_check_len() {
// 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
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
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
assert_eq!(Ok(()), Header::new(&REPR_PACKET_PAD4).check_len());
assert_eq!(Ok(()),
Header::new_unchecked(&REPR_PACKET_PAD4).check_len());
// 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
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]
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.header_len(), 0);
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.header_len(), 1);
assert_eq!(header.options(), &REPR_PACKET_PAD12[2..]);
@ -251,15 +257,19 @@ mod test {
bytes.extend(&REPR_PACKET_PAD4[..]);
bytes.push(0);
assert_eq!(Header::new(&bytes).options().len(), REPR_PACKET_PAD4[2..].len());
assert_eq!(Header::new(&mut bytes).options_mut().len(), REPR_PACKET_PAD4[2..].len());
assert_eq!(Header::new_unchecked(&bytes).options().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![];
bytes.extend(&REPR_PACKET_PAD12[..]);
bytes.push(0);
assert_eq!(Header::new(&bytes).options().len(), REPR_PACKET_PAD12[2..].len());
assert_eq!(Header::new(&mut bytes).options_mut().len(), REPR_PACKET_PAD12[2..].len());
assert_eq!(Header::new_unchecked(&bytes).options().len(),
REPR_PACKET_PAD12[2..].len());
assert_eq!(Header::new_unchecked(&mut bytes).options_mut().len(),
REPR_PACKET_PAD12[2..].len());
}
#[test]
@ -267,51 +277,55 @@ mod test {
let mut bytes = vec![];
bytes.extend(&REPR_PACKET_PAD4);
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);
let mut bytes = vec![];
bytes.extend(&REPR_PACKET_PAD12);
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);
}
#[test]
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();
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();
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]
fn test_repr_emit() {
let repr = Repr{ next_header: Protocol::Tcp, length: 0, options: &REPR_PACKET_PAD4[2..] };
let mut bytes = [0u8; 8];
let mut header = Header::new(&mut bytes);
let mut header = Header::new_unchecked(&mut bytes);
repr.emit(&mut header);
assert_eq!(header.into_inner(), &REPR_PACKET_PAD4[..]);
let repr = Repr{ next_header: Protocol::Tcp, length: 1, options: &REPR_PACKET_PAD12[2..] };
let mut bytes = [0u8; 16];
let mut header = Header::new(&mut bytes);
let mut header = Header::new_unchecked(&mut bytes);
repr.emit(&mut header);
assert_eq!(header.into_inner(), &REPR_PACKET_PAD12[..]);
}
#[test]
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();
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();
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> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Ipv6Option<T>> {
let opt = Self::new(buffer);
let opt = Self::new_unchecked(buffer);
opt.check_len()?;
Ok(opt)
}
@ -376,57 +376,64 @@ mod test {
fn test_check_len() {
let bytes = [0u8];
// 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
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
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
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
assert_eq!(Err(Error::Truncated), Ipv6Option::new(&IPV6OPTION_BYTES_UNKNOWN[..4]).check_len());
assert_eq!(Err(Error::Truncated), Ipv6Option::new(&IPV6OPTION_BYTES_UNKNOWN[..1]).check_len());
assert_eq!(Err(Error::Truncated),
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
assert_eq!(Ok(()), Ipv6Option::new(&IPV6OPTION_BYTES_UNKNOWN).check_len());
assert_eq!(Ok(()),
Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN).check_len());
}
#[test]
#[should_panic(expected = "index out of bounds")]
fn test_data_len() {
let opt = Ipv6Option::new(&IPV6OPTION_BYTES_PAD1);
let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1);
opt.data_len();
}
#[test]
fn test_option_deconstruct() {
// 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);
// two octets of padding
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.data_len(), 0);
// 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.data_len(), 1);
assert_eq!(opt.data(), &[0]);
// extra bytes in buffer
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.data_len(), 7);
assert_eq!(opt.data(), &[0, 0, 0, 0, 0, 0, 0]);
// unrecognized option
let bytes: [u8; 1] = [0xff];
let opt = Ipv6Option::new(&bytes);
let opt = Ipv6Option::new_unchecked(&bytes);
assert_eq!(opt.option_type(), Type::Unknown(255));
// unrecognized option without length and data
@ -436,42 +443,42 @@ mod test {
#[test]
fn test_option_parse() {
// 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();
assert_eq!(pad1, Repr::Pad1);
assert_eq!(pad1.buffer_len(), 1);
// 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();
assert_eq!(padn, Repr::PadN(1));
assert_eq!(padn.buffer_len(), 3);
// unrecognized option type
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();
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]
fn test_option_emit() {
let repr = Repr::Pad1;
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);
assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_PAD1);
let repr = Repr::PadN(1);
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);
assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_PADN);
let data = [0u8; 3];
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 opt = Ipv6Option::new(&mut bytes);
let mut opt = Ipv6Option::new_unchecked(&mut bytes);
repr.emit(&mut opt);
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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Header<T>> {
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> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Self> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -459,7 +459,7 @@ mod test {
#[test]
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_code(), 0);
assert_eq!(packet.checksum(), 0x7374);
@ -476,7 +476,7 @@ mod test {
#[test]
fn test_query_construct() {
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_code(0);
packet.set_max_resp_code(0x0400);
@ -494,12 +494,12 @@ mod test {
#[test]
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_code(), 0);
assert_eq!(packet.checksum(), 0x7385);
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.aux_data_len(), 0x00);
assert_eq!(addr_rcrd.num_srcs(), 0x01);
@ -511,13 +511,13 @@ mod test {
#[test]
fn test_record_construct() {
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_code(0);
packet.clear_reserved();
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_aux_data_len(0);
addr_rcrd.set_num_srcs(1);
@ -532,7 +532,7 @@ mod test {
#[test]
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(),
&Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
&packet,
@ -542,7 +542,7 @@ mod test {
#[test]
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(),
&Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
&packet,
@ -553,7 +553,7 @@ mod test {
#[test]
fn test_query_repr_emit() {
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);
repr.emit(&Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
&Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
@ -565,7 +565,7 @@ mod test {
#[test]
fn test_report_repr_emit() {
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);
repr.emit(&Ipv6Address::LINK_LOCAL_ALL_NODES.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,
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
`Packet::check_len`.
The `Packet::new_checked` method is a shorthand for a combination of `Packet::new_unchecked`
and `Packet::check_len`.
When parsing untrusted input, it is *necessary* to use `Packet::new_checked()`;
so long as the buffer is not modified, no accessor will fail.
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];
{ // emission
let mut packet = Ipv4Packet::new(&mut buffer);
let mut packet = Ipv4Packet::new_unchecked(&mut buffer);
repr.emit(&mut packet, &ChecksumCapabilities::default());
}
{ // parsing

34
src/wire/ndisc.rs
View File

@ -305,7 +305,8 @@ impl<'a> Repr<'a> {
if opt.data_len() < 6 {
return Err(Error::Truncated)
} 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 data = &opt.data()[offset + 8 + ip_repr.buffer_len()..];
redirected_hdr = Some(NdiscRedirectedHeader {
@ -375,7 +376,7 @@ impl<'a> Repr<'a> {
packet.set_msg_code(0);
packet.clear_reserved();
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);
}
},
@ -391,17 +392,20 @@ impl<'a> Repr<'a> {
packet.set_retrans_time(retrans_time);
let mut offset = 0;
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);
offset += 8;
}
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);
offset += 8;
}
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)
}
},
@ -412,7 +416,8 @@ impl<'a> Repr<'a> {
packet.clear_reserved();
packet.set_target_addr(target_addr);
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);
}
},
@ -424,7 +429,8 @@ impl<'a> Repr<'a> {
packet.set_neighbor_flags(flags);
packet.set_target_addr(target_addr);
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);
}
},
@ -437,14 +443,16 @@ impl<'a> Repr<'a> {
packet.set_dest_addr(dest_addr);
let offset = match 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);
8
},
None => 0,
};
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);
}
},
@ -485,7 +493,7 @@ mod test {
#[test]
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_code(), 0);
assert_eq!(packet.current_hop_limit(), 64);
@ -499,7 +507,7 @@ mod test {
#[test]
fn test_router_advert_construct() {
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_code(0);
packet.set_current_hop_limit(64);
@ -514,7 +522,7 @@ mod test {
#[test]
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,
&packet, &ChecksumCapabilities::default()).unwrap(),
create_repr());
@ -523,7 +531,7 @@ mod test {
#[test]
fn test_router_advert_repr_emit() {
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,
&mut packet, &ChecksumCapabilities::default());
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.
impl<T: AsRef<[u8]>> NdiscOption<T> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<NdiscOption<T>> {
let opt = Self::new(buffer);
let opt = Self::new_unchecked(buffer);
opt.check_len()?;
Ok(opt)
}
@ -460,7 +460,7 @@ impl<'a> Repr<'a> {
if opt.data_len() < 6 {
Err(Error::Truncated)
} 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)?;
Ok(Repr::RedirectedHeader(RedirectedHeader {
header: ip_repr,
@ -535,7 +535,8 @@ impl<'a> Repr<'a> {
opt.clear_redirected_reserved();
opt.set_option_type(Type::RedirectedHeader);
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);
let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
payload.copy_from_slice(&data[..data_len]);
@ -625,7 +626,7 @@ mod test {
#[test]
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.data_len(), 4);
assert_eq!(opt.prefix_len(), 64);
@ -638,7 +639,7 @@ mod test {
#[test]
fn test_construct() {
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_data_len(4);
opt.set_prefix_len(64);
@ -664,12 +665,12 @@ mod test {
let mut bytes = [0x01, 0x01, 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)));
}
bytes[0] = 0x02;
{
assert_eq!(Repr::parse(&NdiscOption::new(&bytes)),
assert_eq!(Repr::parse(&NdiscOption::new_unchecked(&bytes)),
Ok(Repr::TargetLinkLayerAddr(addr)));
}
}
@ -683,7 +684,7 @@ mod test {
preferred_lifetime: Duration::from_secs(1000),
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]
@ -696,7 +697,7 @@ mod test {
preferred_lifetime: Duration::from_secs(1000),
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);
assert_eq!(&opt.into_inner()[..], &PREFIX_OPT_BYTES[..]);
}
@ -704,6 +705,6 @@ mod test {
#[test]
fn test_repr_parse_mtu() {
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> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -927,7 +927,7 @@ mod test {
#[test]
#[cfg(feature = "proto-ipv4")]
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.dst_port(), 80);
assert_eq!(packet.seq_number(), SeqNumber(0x01234567));
@ -951,7 +951,7 @@ mod test {
#[cfg(feature = "proto-ipv4")]
fn test_construct() {
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_dst_port(80);
packet.set_seq_number(SeqNumber(0x01234567));
@ -976,14 +976,14 @@ mod test {
#[test]
#[cfg(feature = "proto-ipv4")]
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));
}
#[test]
fn test_impossible_len() {
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);
assert_eq!(packet.check_len(), Err(Error::Malformed));
}
@ -1015,7 +1015,7 @@ mod test {
#[test]
#[cfg(feature = "proto-ipv4")]
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();
assert_eq!(repr, packet_repr());
}
@ -1025,7 +1025,7 @@ mod test {
fn test_emit() {
let repr = packet_repr();
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());
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> {
/// 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 }
}
/// 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
pub fn new_checked(buffer: T) -> Result<Packet<T>> {
let packet = Self::new(buffer);
let packet = Self::new_unchecked(buffer);
packet.check_len()?;
Ok(packet)
}
@ -310,7 +310,7 @@ mod test {
#[test]
#[cfg(feature = "proto-ipv4")]
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.dst_port(), 53);
assert_eq!(packet.len(), 12);
@ -323,7 +323,7 @@ mod test {
#[cfg(feature = "proto-ipv4")]
fn test_construct() {
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_dst_port(53);
packet.set_len(12);
@ -336,7 +336,7 @@ mod test {
#[test]
fn test_impossible_len() {
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);
assert_eq!(packet.check_len(), Err(Error::Malformed));
}
@ -345,7 +345,7 @@ mod test {
#[cfg(feature = "proto-ipv4")]
fn test_zero_checksum() {
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_dst_port(31881);
packet.set_len(8);
@ -365,8 +365,9 @@ mod test {
#[test]
#[cfg(feature = "proto-ipv4")]
fn test_parse() {
let packet = Packet::new(&PACKET_BYTES[..]);
let repr = Repr::parse(&packet, &SRC_ADDR.into(), &DST_ADDR.into(), &ChecksumCapabilities::default()).unwrap();
let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
let repr = Repr::parse(&packet, &SRC_ADDR.into(), &DST_ADDR.into(),
&ChecksumCapabilities::default()).unwrap();
assert_eq!(repr, packet_repr());
}
@ -375,8 +376,9 @@ mod test {
fn test_emit() {
let repr = packet_repr();
let mut bytes = vec![0xa5; repr.buffer_len()];
let mut packet = Packet::new(&mut bytes);
repr.emit(&mut packet, &SRC_ADDR.into(), &DST_ADDR.into(), &ChecksumCapabilities::default());
let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&mut packet, &SRC_ADDR.into(), &DST_ADDR.into(),
&ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &PACKET_BYTES[..]);
}
}