diff --git a/src/iface/ethernet.rs b/src/iface/ethernet.rs index 9bb74bd..7697c57 100644 --- a/src/iface/ethernet.rs +++ b/src/iface/ethernet.rs @@ -203,8 +203,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> { let mut handled_by_raw_socket = false; for raw_socket in sockets.iter_mut().filter_map( >::try_as_socket) { - match raw_socket.process(timestamp, &IpRepr::Ipv4(ipv4_repr), - ipv4_packet.payload()) { + match raw_socket.process(&ipv4_repr.into(), ipv4_packet.payload()) { // The packet is valid and handled by socket. Ok(()) => handled_by_raw_socket = true, // The packet isn't addressed to the socket, or cannot be accepted by it. @@ -223,7 +222,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> { IpProtocol::Icmp => Self::process_icmpv4(ipv4_repr, ipv4_packet.payload()), IpProtocol::Udp => - Self::process_udpv4(sockets, timestamp, ipv4_repr, ipv4_packet.payload()), + Self::process_udpv4(sockets, ipv4_repr, ipv4_packet.payload()), IpProtocol::Tcp => Self::process_tcp(sockets, timestamp, ipv4_repr.into(), ipv4_packet.payload()), _ if handled_by_raw_socket => @@ -277,14 +276,14 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> { } } - fn process_udpv4<'frame>(sockets: &mut SocketSet, timestamp: u64, + fn process_udpv4<'frame>(sockets: &mut SocketSet, ipv4_repr: Ipv4Repr, ip_payload: &'frame [u8]) -> Result> { let ip_repr = IpRepr::Ipv4(ipv4_repr); for udp_socket in sockets.iter_mut().filter_map( >::try_as_socket) { - match udp_socket.process(timestamp, &ip_repr, ip_payload) { + match udp_socket.process(&ip_repr, ip_payload) { // The packet is valid and handled by socket. Ok(()) => return Ok(Response::Nop), // The packet isn't addressed to the socket. @@ -344,10 +343,10 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> { for socket in sockets.iter_mut() { let result = match socket { &mut Socket::Raw(ref mut socket) => - socket.dispatch(timestamp, &limits, |response| + socket.dispatch(|response| self.dispatch_response(timestamp, Response::Raw(response))), &mut Socket::Udp(ref mut socket) => - socket.dispatch(timestamp, &limits, |response| + socket.dispatch(|response| self.dispatch_response(timestamp, Response::Udp(response))), &mut Socket::Tcp(ref mut socket) => socket.dispatch(timestamp, &limits, |response| diff --git a/src/socket/mod.rs b/src/socket/mod.rs index 9dfa4aa..20826ec 100644 --- a/src/socket/mod.rs +++ b/src/socket/mod.rs @@ -10,8 +10,6 @@ //! The interface implemented by this module uses explicit buffering: you decide on the good //! size for a buffer, allocate it, and let the networking stack use it. -use Result; -use phy::DeviceLimits; use wire::IpRepr; mod raw; diff --git a/src/socket/raw.rs b/src/socket/raw.rs index 5d490e2..45e472c 100644 --- a/src/socket/raw.rs +++ b/src/socket/raw.rs @@ -2,7 +2,6 @@ use core::cmp::min; use managed::Managed; use {Error, Result}; -use phy::DeviceLimits; use wire::{IpVersion, IpProtocol, Ipv4Repr, Ipv4Packet}; use socket::{IpRepr, Socket}; use storage::{Resettable, RingBuffer}; @@ -167,8 +166,7 @@ impl<'a, 'b> RawSocket<'a, 'b> { Ok(length) } - pub(crate) fn process(&mut self, _timestamp: u64, ip_repr: &IpRepr, - payload: &[u8]) -> Result<()> { + pub(crate) fn process(&mut self, ip_repr: &IpRepr, payload: &[u8]) -> Result<()> { if ip_repr.version() != self.ip_version { return Err(Error::Rejected) } if ip_repr.protocol() != self.ip_protocol { return Err(Error::Rejected) } @@ -183,8 +181,7 @@ impl<'a, 'b> RawSocket<'a, 'b> { Ok(()) } - pub(crate) fn dispatch(&mut self, _timestamp: u64, _limits: &DeviceLimits, - emit: F) -> Result<()> + pub(crate) fn dispatch(&mut self, emit: F) -> Result<()> where F: FnOnce((IpRepr, &[u8])) -> Result<()> { fn prepare(protocol: IpProtocol, buffer: &mut [u8]) -> Result<(IpRepr, &[u8])> { match IpVersion::of_packet(buffer.as_ref())? { @@ -273,26 +270,24 @@ mod test { #[test] fn test_send_dispatch() { - let limits = DeviceLimits::default(); - let mut socket = socket(buffer(0), buffer(1)); assert!(socket.can_send()); - assert_eq!(socket.dispatch(0, &limits, |_| unreachable!()), + assert_eq!(socket.dispatch(|_| unreachable!()), Err(Error::Exhausted)); assert_eq!(socket.send_slice(&PACKET_BYTES[..]), Ok(())); assert_eq!(socket.send_slice(b""), Err(Error::Exhausted)); assert!(!socket.can_send()); - assert_eq!(socket.dispatch(0, &limits, |(ip_repr, ip_payload)| { + assert_eq!(socket.dispatch(|(ip_repr, ip_payload)| { assert_eq!(ip_repr, HEADER_REPR); assert_eq!(ip_payload, &PACKET_PAYLOAD); Err(Error::Unaddressable) }), Err(Error::Unaddressable)); /*assert!(!socket.can_send());*/ - assert_eq!(socket.dispatch(0, &limits, |(ip_repr, ip_payload)| { + assert_eq!(socket.dispatch(|(ip_repr, ip_payload)| { assert_eq!(ip_repr, HEADER_REPR); assert_eq!(ip_payload, &PACKET_PAYLOAD); Ok(()) @@ -302,22 +297,20 @@ mod test { #[test] fn test_send_illegal() { - let limits = DeviceLimits::default(); - let mut socket = socket(buffer(0), buffer(1)); let mut wrong_version = PACKET_BYTES.clone(); Ipv4Packet::new(&mut wrong_version).set_version(5); assert_eq!(socket.send_slice(&wrong_version[..]), Ok(())); - assert_eq!(socket.dispatch(0, &limits, |_| unreachable!()), + assert_eq!(socket.dispatch(|_| unreachable!()), Err(Error::Rejected)); let mut wrong_protocol = PACKET_BYTES.clone(); Ipv4Packet::new(&mut wrong_protocol).set_protocol(IpProtocol::Tcp); assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(())); - assert_eq!(socket.dispatch(0, &limits, |_| unreachable!()), + assert_eq!(socket.dispatch(|_| unreachable!()), Err(Error::Rejected)); } @@ -330,11 +323,11 @@ mod test { Ipv4Packet::new(&mut cksumd_packet).fill_checksum(); assert_eq!(socket.recv(), Err(Error::Exhausted)); - assert_eq!(socket.process(0, &HEADER_REPR, &PACKET_PAYLOAD), + assert_eq!(socket.process(&HEADER_REPR, &PACKET_PAYLOAD), Ok(())); assert!(socket.can_recv()); - assert_eq!(socket.process(0, &HEADER_REPR, &PACKET_PAYLOAD), + assert_eq!(socket.process(&HEADER_REPR, &PACKET_PAYLOAD), Err(Error::Exhausted)); assert_eq!(socket.recv(), Ok(&cksumd_packet[..])); assert!(!socket.can_recv()); @@ -344,7 +337,7 @@ mod test { fn test_recv_truncated_slice() { let mut socket = socket(buffer(1), buffer(0)); - assert_eq!(socket.process(0, &HEADER_REPR, &PACKET_PAYLOAD), + assert_eq!(socket.process(&HEADER_REPR, &PACKET_PAYLOAD), Ok(())); let mut slice = [0; 4]; @@ -359,7 +352,7 @@ mod test { let mut buffer = vec![0; 128]; buffer[..PACKET_BYTES.len()].copy_from_slice(&PACKET_BYTES[..]); - assert_eq!(socket.process(0, &HEADER_REPR, &buffer), + assert_eq!(socket.process(&HEADER_REPR, &buffer), Err(Error::Truncated)); } } diff --git a/src/socket/tcp.rs b/src/socket/tcp.rs index 41d5b7d..3c924da 100644 --- a/src/socket/tcp.rs +++ b/src/socket/tcp.rs @@ -729,7 +729,7 @@ impl<'a> TcpSocket<'a> { } pub(crate) fn ack_reply(&self, ip_repr: &IpRepr, repr: &TcpRepr) -> - (IpRepr, TcpRepr<'static>) { + (IpRepr, TcpRepr<'static>) { let (ip_reply_repr, mut reply_repr) = Self::reply(ip_repr, repr); // From RFC793: @@ -743,8 +743,8 @@ impl<'a> TcpSocket<'a> { (ip_reply_repr, reply_repr) } - pub(crate) fn process(&mut self, timestamp: u64, ip_repr: &IpRepr, - payload: &[u8]) -> Result)>> { + pub(crate) fn process(&mut self, timestamp: u64, ip_repr: &IpRepr, payload: &[u8]) -> + Result)>> { debug_assert!(ip_repr.protocol() == IpProtocol::Tcp); if self.state == State::Closed { return Err(Error::Rejected) } @@ -1355,7 +1355,7 @@ mod test { }; fn send(socket: &mut TcpSocket, timestamp: u64, repr: &TcpRepr) -> - Result>> { + Result>> { trace!("send: {}", repr); let mut buffer = vec![0; repr.buffer_len()]; let mut packet = TcpPacket::new(&mut buffer); diff --git a/src/socket/udp.rs b/src/socket/udp.rs index 1e4c808..0c3f43b 100644 --- a/src/socket/udp.rs +++ b/src/socket/udp.rs @@ -2,7 +2,6 @@ use core::cmp::min; use managed::Managed; use {Error, Result}; -use phy::DeviceLimits; use wire::{IpProtocol, IpEndpoint}; use wire::{UdpPacket, UdpRepr}; use socket::{Socket, IpRepr}; @@ -181,8 +180,7 @@ impl<'a, 'b> UdpSocket<'a, 'b> { Ok((length, endpoint)) } - pub(crate) fn process(&mut self, _timestamp: u64, ip_repr: &IpRepr, - payload: &[u8]) -> Result<()> { + pub(crate) fn process(&mut self, ip_repr: &IpRepr, payload: &[u8]) -> Result<()> { debug_assert!(ip_repr.protocol() == IpProtocol::Udp); let packet = UdpPacket::new_checked(&payload[..ip_repr.payload_len()])?; @@ -202,8 +200,7 @@ impl<'a, 'b> UdpSocket<'a, 'b> { Ok(()) } - pub(crate) fn dispatch(&mut self, _timestamp: u64, _limits: &DeviceLimits, - emit: F) -> Result<()> + pub(crate) fn dispatch(&mut self, emit: F) -> Result<()> where F: FnOnce((IpRepr, UdpRepr)) -> Result<()> { let packet_buf = self.tx_buffer.dequeue()?; net_trace!("[{}]{}:{}: sending {} octets", @@ -303,27 +300,25 @@ mod test { #[test] fn test_send_dispatch() { - let limits = DeviceLimits::default(); - let mut socket = socket(buffer(0), buffer(1)); assert_eq!(socket.bind(LOCAL_END), Ok(())); assert!(socket.can_send()); - assert_eq!(socket.dispatch(0, &limits, |_| unreachable!()), + assert_eq!(socket.dispatch(|_| unreachable!()), Err(Error::Exhausted)); assert_eq!(socket.send_slice(b"abcdef", REMOTE_END), Ok(())); assert_eq!(socket.send_slice(b"123456", REMOTE_END), Err(Error::Exhausted)); assert!(!socket.can_send()); - assert_eq!(socket.dispatch(0, &limits, |(ip_repr, udp_repr)| { + assert_eq!(socket.dispatch(|(ip_repr, udp_repr)| { assert_eq!(ip_repr, LOCAL_IP_REPR); assert_eq!(udp_repr, LOCAL_UDP_REPR); Err(Error::Unaddressable) }), Err(Error::Unaddressable)); /*assert!(!socket.can_send());*/ - assert_eq!(socket.dispatch(0, &limits, |(ip_repr, udp_repr)| { + assert_eq!(socket.dispatch(|(ip_repr, udp_repr)| { assert_eq!(ip_repr, LOCAL_IP_REPR); assert_eq!(udp_repr, LOCAL_UDP_REPR); Ok(()) @@ -354,11 +349,11 @@ mod test { assert!(!socket.can_recv()); assert_eq!(socket.recv(), Err(Error::Exhausted)); - assert_eq!(socket.process(0, &REMOTE_IP_REPR, &buffer), + assert_eq!(socket.process(&REMOTE_IP_REPR, &buffer), Ok(())); assert!(socket.can_recv()); - assert_eq!(socket.process(0, &REMOTE_IP_REPR, &buffer), + assert_eq!(socket.process(&REMOTE_IP_REPR, &buffer), Err(Error::Exhausted)); assert_eq!(socket.recv(), Ok((&b"abcdef"[..], REMOTE_END))); assert!(!socket.can_recv()); @@ -371,7 +366,7 @@ mod test { let mut buffer = vec![0; REMOTE_UDP_REPR.buffer_len()]; REMOTE_UDP_REPR.emit(&mut UdpPacket::new(&mut buffer), &LOCAL_IP, &REMOTE_IP); - assert_eq!(socket.process(0, &REMOTE_IP_REPR, &buffer), Ok(())); + assert_eq!(socket.process(&REMOTE_IP_REPR, &buffer), Ok(())); let mut slice = [0; 4]; assert_eq!(socket.recv_slice(&mut slice[..]), Ok((4, REMOTE_END))); @@ -386,7 +381,7 @@ mod test { let udp_repr = UdpRepr { payload: &[0; 100][..], ..REMOTE_UDP_REPR }; let mut buffer = vec![0; udp_repr.buffer_len()]; udp_repr.emit(&mut UdpPacket::new(&mut buffer), &LOCAL_IP, &REMOTE_IP); - assert_eq!(socket.process(0, &REMOTE_IP_REPR, &buffer), + assert_eq!(socket.process(&REMOTE_IP_REPR, &buffer), Err(Error::Truncated)); } }