Skip to content

Commit

Permalink
Calculate IP payload length from the total length field.
Browse files Browse the repository at this point in the history 
Before this commit, IP payload length was calculated by subtracting
the IP header length from the total underlying buffer length, which
fails if the underlying buffer has padding, e.g. like Ethernet
does.
@whitequark
whitequark committed Jan 14, 2017
1 parent ea02b58 commit 41f9426
Showing 7 changed files with 114 additions and 96 deletions.
59 changes: 29 additions & 30 deletions src/iface/ethernet.rs
View file
Original file line number Diff line number Diff line change
@@ -170,24 +170,25 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
Ipv4Repr { dst_addr, .. } if !self.has_protocol_addr(dst_addr) => (),

// Respond to ICMP packets.
Ipv4Repr { protocol: IpProtocol::Icmp, src_addr, dst_addr } => {
Ipv4Repr { protocol: IpProtocol::Icmp, src_addr, dst_addr, .. } => {
let icmp_packet = try!(Icmpv4Packet::new(ipv4_packet.payload()));
let icmp_repr = try!(Icmpv4Repr::parse(&icmp_packet));
match icmp_repr {
// Respond to echo requests.
Icmpv4Repr::EchoRequest {
ident, seq_no, data
} => {
let ipv4_reply_repr = Ipv4Repr {
src_addr: dst_addr,
dst_addr: src_addr,
protocol: IpProtocol::Icmp
};
let icmp_reply_repr = Icmpv4Repr::EchoReply {
ident: ident,
seq_no: seq_no,
data: data
};
let ipv4_reply_repr = Ipv4Repr {
src_addr: dst_addr,
dst_addr: src_addr,
protocol: IpProtocol::Icmp,
payload_len: icmp_reply_repr.buffer_len()
};
response = Response::Icmpv4(ipv4_reply_repr, icmp_reply_repr)
}

@@ -200,7 +201,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
},

// Try dispatching a packet to a socket.
Ipv4Repr { src_addr, dst_addr, protocol } => {
Ipv4Repr { src_addr, dst_addr, protocol, .. } => {
let mut handled = false;
for socket in sockets.iter_mut() {
let ip_repr = IpRepr::Ipv4(ipv4_repr);
@@ -228,11 +229,6 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
if !handled && protocol == IpProtocol::Tcp {
let tcp_packet = try!(TcpPacket::new(ipv4_packet.payload()));

let ipv4_reply_repr = Ipv4Repr {
src_addr: dst_addr,
dst_addr: src_addr,
protocol: IpProtocol::Tcp
};
let tcp_reply_repr = TcpRepr {
src_port: tcp_packet.dst_port(),
dst_port: tcp_packet.src_port(),
@@ -243,6 +239,12 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
window_len: 0,
payload: &[]
};
let ipv4_reply_repr = Ipv4Repr {
src_addr: dst_addr,
dst_addr: src_addr,
protocol: IpProtocol::Tcp,
payload_len: tcp_reply_repr.buffer_len()
};
response = Response::Tcpv4(ipv4_reply_repr, tcp_reply_repr);
} else if !handled {
let reason;
@@ -255,16 +257,16 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
let mut data = [0; 8];
data.copy_from_slice(&ipv4_packet.payload()[0..8]);

let ipv4_reply_repr = Ipv4Repr {
src_addr: dst_addr,
dst_addr: src_addr,
protocol: IpProtocol::Icmp
};
let icmp_reply_repr = Icmpv4Repr::DstUnreachable {
reason: reason,
header: ipv4_repr,
length: ipv4_packet.payload().len(),
data: data
reason: reason,
header: ipv4_repr,
data: data
};
let ipv4_reply_repr = Ipv4Repr {
src_addr: dst_addr,
dst_addr: src_addr,
protocol: IpProtocol::Icmp,
payload_len: icmp_reply_repr.buffer_len()
};
response = Response::Icmpv4(ipv4_reply_repr, icmp_reply_repr)
}
@@ -277,24 +279,23 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
}

macro_rules! ip_response {
($tx_buffer:ident, $frame:ident, $ip_repr:ident, $length:expr) => ({
($tx_buffer:ident, $frame:ident, $ip_repr:ident) => ({
let dst_hardware_addr =
match self.arp_cache.lookup(&$ip_repr.dst_addr.into()) {
None => return Err(Error::Unaddressable),
Some(hardware_addr) => hardware_addr
};

let payload_len = $length;
let frame_len = EthernetFrame::<&[u8]>::buffer_len($ip_repr.buffer_len() +
payload_len);
$ip_repr.payload_len);
$tx_buffer = try!(self.device.transmit(frame_len));
$frame = try!(EthernetFrame::new(&mut $tx_buffer));
$frame.set_src_addr(self.hardware_addr);
$frame.set_dst_addr(dst_hardware_addr);
$frame.set_ethertype(EthernetProtocol::Ipv4);

let mut ip_packet = try!(Ipv4Packet::new($frame.payload_mut()));
$ip_repr.emit(&mut ip_packet, payload_len);
$ip_repr.emit(&mut ip_packet);
ip_packet
})
}
@@ -320,8 +321,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
Response::Icmpv4(ip_repr, icmp_repr) => {
let mut tx_buffer;
let mut frame;
let mut ip_packet = ip_response!(tx_buffer, frame, ip_repr,
icmp_repr.buffer_len());
let mut ip_packet = ip_response!(tx_buffer, frame, ip_repr);
let mut icmp_packet = try!(Icmpv4Packet::new(ip_packet.payload_mut()));
icmp_repr.emit(&mut icmp_packet);
Ok(())
@@ -330,8 +330,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
Response::Tcpv4(ip_repr, tcp_repr) => {
let mut tx_buffer;
let mut frame;
let mut ip_packet = ip_response!(tx_buffer, frame, ip_repr,
tcp_repr.buffer_len());
let mut ip_packet = ip_response!(tx_buffer, frame, ip_repr);
let mut tcp_packet = try!(TcpPacket::new(ip_packet.payload_mut()));
tcp_repr.emit(&mut tcp_packet,
&IpAddress::Ipv4(ip_repr.src_addr),
@@ -372,7 +371,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
frame.set_dst_addr(dst_hardware_addr);
frame.set_ethertype(EthernetProtocol::Ipv4);

repr.emit(frame.payload_mut(), payload.buffer_len());
repr.emit(frame.payload_mut());

let mut ip_packet = try!(Ipv4Packet::new(frame.payload_mut()));
payload.emit(&repr, ip_packet.payload_mut());
20 changes: 11 additions & 9 deletions src/socket/tcp.rs
View file
Original file line number Diff line number Diff line change
@@ -513,7 +513,7 @@ impl<'a> TcpSocket<'a> {
payload: &[u8]) -> Result<(), Error> {
if ip_repr.protocol() != IpProtocol::Tcp { return Err(Error::Rejected) }

let packet = try!(TcpPacket::new(payload));
let packet = try!(TcpPacket::new(&payload[..ip_repr.payload_len()]));
let repr = try!(TcpRepr::parse(&packet, &ip_repr.src_addr(), &ip_repr.dst_addr()));

// Reject packets with a wrong destination.
@@ -749,11 +749,6 @@ impl<'a> TcpSocket<'a> {
where F: FnMut(&IpRepr, &IpPayload) -> Result<R, Error> {
if self.remote_endpoint.is_unspecified() { return Err(Error::Exhausted) }

let ip_repr = IpRepr::Unspecified {
src_addr: self.local_endpoint.addr,
dst_addr: self.remote_endpoint.addr,
protocol: IpProtocol::Tcp,
};
let mut repr = TcpRepr {
src_port: self.local_endpoint.port,
dst_port: self.remote_endpoint.port,
@@ -864,6 +859,12 @@ impl<'a> TcpSocket<'a> {
repr.ack_number = Some(ack_number);
self.remote_last_ack = ack_number;

let ip_repr = IpRepr::Unspecified {
src_addr: self.local_endpoint.addr,
dst_addr: self.remote_endpoint.addr,
protocol: IpProtocol::Tcp,
payload_len: repr.buffer_len()
};
emit(&ip_repr, &repr)
} else {
Err(Error::Exhausted)
@@ -963,9 +964,10 @@ mod test {
let mut packet = TcpPacket::new(&mut buffer).unwrap();
repr.emit(&mut packet, &REMOTE_IP, &LOCAL_IP);
let ip_repr = IpRepr::Unspecified {
src_addr: REMOTE_IP,
dst_addr: LOCAL_IP,
protocol: IpProtocol::Tcp
src_addr: REMOTE_IP,
dst_addr: LOCAL_IP,
protocol: IpProtocol::Tcp,
payload_len: repr.buffer_len()
};
socket.process(timestamp, &ip_repr, &packet.into_inner()[..])
}
17 changes: 9 additions & 8 deletions src/socket/udp.rs
View file
Original file line number Diff line number Diff line change
@@ -196,7 +196,7 @@ impl<'a, 'b> UdpSocket<'a, 'b> {
payload: &[u8]) -> Result<(), Error> {
if ip_repr.protocol() != IpProtocol::Udp { return Err(Error::Rejected) }

let packet = try!(UdpPacket::new(payload));
let packet = try!(UdpPacket::new(&payload[..ip_repr.payload_len()]));
let repr = try!(UdpRepr::parse(&packet, &ip_repr.src_addr(), &ip_repr.dst_addr()));

if repr.dst_port != self.endpoint.port { return Err(Error::Rejected) }
@@ -219,17 +219,18 @@ impl<'a, 'b> UdpSocket<'a, 'b> {
let packet_buf = try!(self.tx_buffer.dequeue().map_err(|()| Error::Exhausted));
net_trace!("udp:{}:{}: sending {} octets",
self.endpoint, packet_buf.endpoint, packet_buf.size);
let ip_repr = IpRepr::Unspecified {
src_addr: self.endpoint.addr,
dst_addr: packet_buf.endpoint.addr,
protocol: IpProtocol::Udp
};
let payload = UdpRepr {
let repr = UdpRepr {
src_port: self.endpoint.port,
dst_port: packet_buf.endpoint.port,
payload: &packet_buf.as_ref()[..]
};
emit(&ip_repr, &payload)
let ip_repr = IpRepr::Unspecified {
src_addr: self.endpoint.addr,
dst_addr: packet_buf.endpoint.addr,
protocol: IpProtocol::Udp,
payload_len: repr.buffer_len()
};
emit(&ip_repr, &repr)
}
}

8 changes: 2 additions & 6 deletions src/wire/icmpv4.rs
View file
Original file line number Diff line number Diff line change
@@ -352,7 +352,6 @@ pub enum Repr<'a> {
DstUnreachable {
reason: DstUnreachable,
header: Ipv4Repr,
length: usize,
data: [u8; 8]
},
#[doc(hidden)]
@@ -389,12 +388,9 @@ impl<'a> Repr<'a> {
if payload.len() < data.len() { return Err(Error::Truncated) }
data.copy_from_slice(&payload[0..8]);

let length = ip_packet.total_len() as usize - ip_packet.header_len() as usize;

Ok(Repr::DstUnreachable {
reason: DstUnreachable::from(code),
header: ip_repr,
length: length,
data: data
})
}
@@ -439,13 +435,13 @@ impl<'a> Repr<'a> {
packet.data_mut()[..data_len].copy_from_slice(&data[..data_len])
},

&Repr::DstUnreachable { reason, header, length, data } => {
&Repr::DstUnreachable { reason, header, data } => {
packet.set_msg_type(Message::DstUnreachable);
packet.set_msg_code(reason.into());

let mut ip_packet = Ipv4Packet::new(packet.data_mut())
.expect("undersized data");
header.emit(&mut ip_packet, length);
header.emit(&mut ip_packet);
let mut payload = &mut ip_packet.into_inner()[header.buffer_len()..];
payload.copy_from_slice(&data[..])
}
38 changes: 25 additions & 13 deletions src/wire/ip.rs
View file
Original file line number Diff line number Diff line change
@@ -120,9 +120,10 @@ impl From<u16> for Endpoint {
#[derive(Debug, Clone)]
pub enum IpRepr {
Unspecified {
src_addr: Address,
dst_addr: Address,
protocol: Protocol
src_addr: Address,
dst_addr: Address,
protocol: Protocol,
payload_len: usize
},
Ipv4(Ipv4Repr),
#[doc(hidden)]
@@ -157,6 +158,15 @@ impl IpRepr {
}
}

/// Return the payload length.
pub fn payload_len(&self) -> usize {
match self {
&IpRepr::Unspecified { payload_len, .. } => payload_len,
&IpRepr::Ipv4(repr) => repr.payload_len,
&IpRepr::__Nonexhaustive => unreachable!()
}
}

/// Convert an unspecified representation into a concrete one, or return
/// `Err(Error::Unaddressable)` if not possible.
///
@@ -168,19 +178,20 @@ impl IpRepr {
&IpRepr::Unspecified {
src_addr: Address::Ipv4(src_addr),
dst_addr: Address::Ipv4(dst_addr),
protocol
protocol, payload_len
} => {
Ok(IpRepr::Ipv4(Ipv4Repr {
src_addr: src_addr,
dst_addr: dst_addr,
protocol: protocol
src_addr: src_addr,
dst_addr: dst_addr,
protocol: protocol,
payload_len: payload_len
}))
}

&IpRepr::Unspecified {
src_addr: Address::Unspecified,
dst_addr: Address::Ipv4(dst_addr),
protocol
protocol, payload_len
} => {
let mut src_addr = None;
for addr in fallback_src_addrs {
@@ -193,9 +204,10 @@ impl IpRepr {
}
}
Ok(IpRepr::Ipv4(Ipv4Repr {
src_addr: try!(src_addr.ok_or(Error::Unaddressable)),
dst_addr: dst_addr,
protocol: protocol
src_addr: try!(src_addr.ok_or(Error::Unaddressable)),
dst_addr: dst_addr,
protocol: protocol,
payload_len: payload_len
}))
}

@@ -225,12 +237,12 @@ impl IpRepr {
///
/// # Panics
/// This function panics if invoked on an unspecified representation.
pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, buffer: T, payload_len: usize) {
pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, buffer: T) {
match self {
&IpRepr::Unspecified { .. } => panic!("unspecified IP representation"),
&IpRepr::Ipv4(repr) => {
let mut packet = Ipv4Packet::new(buffer).expect("undersized buffer");
repr.emit(&mut packet, payload_len)
repr.emit(&mut packet)
}
&IpRepr::__Nonexhaustive => unreachable!()
}
55 changes: 31 additions & 24 deletions src/wire/ipv4.rs
View file
Original file line number Diff line number Diff line change
@@ -367,9 +367,10 @@ impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> Packet<&'a mut T> {
/// A high-level representation of an Internet Protocol version 4 packet header.
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub struct Repr {
pub src_addr: Address,
pub dst_addr: Address,
pub protocol: Protocol
pub src_addr: Address,
pub dst_addr: Address,
pub protocol: Protocol,
pub payload_len: usize
}

impl Repr {
@@ -391,9 +392,10 @@ impl Repr {
// All ECN values are acceptable, since ECN requires opt-in from both endpoints.
// All TTL values are acceptable, since we do not perform routing.
Ok(Repr {
src_addr: packet.src_addr(),
dst_addr: packet.dst_addr(),
protocol: packet.protocol()
src_addr: packet.src_addr(),
dst_addr: packet.dst_addr(),
protocol: packet.protocol(),
payload_len: payload_len
})
}

@@ -404,13 +406,12 @@ impl Repr {
}

/// Emit a high-level representation into an Internet Protocol version 4 packet.
pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>,
payload_len: usize) {
pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
packet.set_version(4);
packet.set_header_len(field::DST_ADDR.end as u8);
packet.set_dscp(0);
packet.set_ecn(0);
let total_len = packet.header_len() as u16 + payload_len as u16;
let total_len = packet.header_len() as u16 + self.payload_len as u16;
packet.set_total_len(total_len);
packet.set_ident(0);
packet.clear_flags();
@@ -476,36 +477,41 @@ use super::pretty_print::{PrettyPrint, PrettyIndent};
impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
fn pretty_print(buffer: &AsRef<[u8]>, f: &mut fmt::Formatter,
indent: &mut PrettyIndent) -> fmt::Result {
let ip_packet = match Packet::new(buffer) {
let (ip_repr, payload) = match Packet::new(buffer) {
Err(err) => return write!(f, "{}({})\n", indent, err),
Ok(ip_packet) => ip_packet
Ok(ip_packet) => {
match Repr::parse(&ip_packet) {
Err(err) => return write!(f, "{}{} ({})\n", indent, ip_packet, err),
Ok(ip_repr) => (ip_repr, &ip_packet.payload()[..ip_repr.payload_len])
}
}
};
try!(write!(f, "{}{}\n", indent, ip_packet));
try!(write!(f, "{}{}\n", indent, ip_repr));

indent.increase();
match ip_packet.protocol() {
match ip_repr.protocol {
Protocol::Icmp =>
super::Icmpv4Packet::<&[u8]>::pretty_print(&ip_packet.payload(), f, indent),
super::Icmpv4Packet::<&[u8]>::pretty_print(&payload, f, indent),
Protocol::Udp => {
match super::UdpPacket::new(&ip_packet.payload()) {
match super::UdpPacket::new(payload) {
Err(err) => write!(f, "{}({})\n", indent, err),
Ok(udp_packet) => {
match super::UdpRepr::parse(&udp_packet,
&IpAddress::from(ip_packet.src_addr()),
&IpAddress::from(ip_packet.dst_addr())) {
&IpAddress::from(ip_repr.src_addr),
&IpAddress::from(ip_repr.dst_addr)) {
Err(err) => write!(f, "{}{} ({})\n", indent, udp_packet, err),
Ok(udp_repr) => write!(f, "{}{}\n", indent, udp_repr)
}
}
}
}
Protocol::Tcp => {
match super::TcpPacket::new(&ip_packet.payload()) {
match super::TcpPacket::new(payload) {
Err(err) => write!(f, "{}({})\n", indent, err),
Ok(tcp_packet) => {
match super::TcpRepr::parse(&tcp_packet,
&IpAddress::from(ip_packet.src_addr()),
&IpAddress::from(ip_packet.dst_addr())) {
&IpAddress::from(ip_repr.src_addr),
&IpAddress::from(ip_repr.dst_addr)) {
Err(err) => write!(f, "{}{} ({})\n", indent, tcp_packet, err),
Ok(tcp_repr) => write!(f, "{}{}\n", indent, tcp_repr)
}
@@ -592,9 +598,10 @@ mod test {

fn packet_repr() -> Repr {
Repr {
src_addr: Address([0x11, 0x12, 0x13, 0x14]),
dst_addr: Address([0x21, 0x22, 0x23, 0x24]),
protocol: Protocol::Icmp
src_addr: Address([0x11, 0x12, 0x13, 0x14]),
dst_addr: Address([0x21, 0x22, 0x23, 0x24]),
protocol: Protocol::Icmp,
payload_len: 4
}
}

@@ -610,7 +617,7 @@ mod test {
let repr = packet_repr();
let mut bytes = vec![0; repr.buffer_len() + REPR_PAYLOAD_BYTES.len()];
let mut packet = Packet::new(&mut bytes).unwrap();
repr.emit(&mut packet, REPR_PAYLOAD_BYTES.len());
repr.emit(&mut packet);
packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_BYTES);
assert_eq!(&packet.into_inner()[..], &REPR_PACKET_BYTES[..]);
}
13 changes: 7 additions & 6 deletions src/wire/mod.rs
View file
Original file line number Diff line number Diff line change
@@ -29,17 +29,18 @@
```rust
use smoltcp::wire::*;
let repr = Ipv4Repr {
src_addr: Ipv4Address::new(10, 0, 0, 1),
dst_addr: Ipv4Address::new(10, 0, 0, 2),
protocol: IpProtocol::Tcp
src_addr: Ipv4Address::new(10, 0, 0, 1),
dst_addr: Ipv4Address::new(10, 0, 0, 2),
protocol: IpProtocol::Tcp,
payload_len: 10
};
let mut buffer = vec![0; repr.buffer_len()];
let mut buffer = vec![0; repr.buffer_len() + 10];
{ // emission
let mut packet = Ipv4Packet::new(&mut buffer).unwrap();
repr.emit(&mut packet, /*payload size*/ 0);
repr.emit(&mut packet);
}
{ // parsing
let mut packet = Ipv4Packet::new(&buffer).unwrap();
let packet = Ipv4Packet::new(&buffer).unwrap();
let parsed = Ipv4Repr::parse(&packet).unwrap();
assert_eq!(repr, parsed);
}

0 comments on commit 41f9426

Please sign in to comment.