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

Merge pull request #459 from smoltcp-rs/dhcp-socket 

DHCP refactor
This commit is contained in:
Dario Nieuwenhuis 2021-05-28 18:54:26 +02:00 committed by GitHub
parent f2231c1cb5 8f1e547b67
commit 360dbc79d4
20 changed files with 783 additions and 617 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/test.yml vendored
View File

@ -73,9 +73,9 @@ jobs:
include:
# defmt doesn't support 1.40
- rust: stable
features: defmt medium-ip medium-ethernet proto-ipv6 proto-ipv6 proto-igmp proto-dhcpv4 socket-raw socket-udp socket-tcp socket-icmp async
features: defmt defmt-trace medium-ip medium-ethernet proto-ipv6 proto-ipv6 proto-igmp proto-dhcpv4 socket-raw socket-udp socket-tcp socket-icmp async
- rust: nightly
features: defmt medium-ip medium-ethernet proto-ipv6 proto-ipv6 proto-igmp proto-dhcpv4 socket-raw socket-udp socket-tcp socket-icmp async
features: defmt defmt-trace medium-ip medium-ethernet proto-ipv6 proto-ipv6 proto-igmp proto-dhcpv4 socket-raw socket-udp socket-tcp socket-icmp async
steps:
- uses: actions/checkout@v2

5
Cargo.toml
View File

@ -39,13 +39,14 @@ verbose = []
"phy-tuntap_interface" = ["std", "libc", "medium-ethernet"]
"proto-ipv4" = []
"proto-igmp" = ["proto-ipv4"]
"proto-dhcpv4" = ["proto-ipv4", "socket-raw", "medium-ethernet"]
"proto-dhcpv4" = ["proto-ipv4"]
"proto-ipv6" = []
"socket" = []
"socket-raw" = ["socket"]
"socket-udp" = ["socket"]
"socket-tcp" = ["socket"]
"socket-icmp" = ["socket"]
"socket-dhcpv4" = ["socket", "medium-ethernet", "proto-dhcpv4"]
"async" = []
defmt-trace = []
@ -59,7 +60,7 @@ default = [
"medium-ethernet", "medium-ip",
"phy-raw_socket", "phy-tuntap_interface",
"proto-ipv4", "proto-igmp", "proto-dhcpv4", "proto-ipv6",
"socket-raw", "socket-icmp", "socket-udp", "socket-tcp",
"socket-raw", "socket-icmp", "socket-udp", "socket-tcp", "socket-dhcpv4",
"async"
]

113
examples/dhcp_client.rs
View File

@ -3,12 +3,13 @@ mod utils;
use std::collections::BTreeMap;
use std::os::unix::io::AsRawFd;
use smoltcp::phy::{Device, Medium, wait as phy_wait};
use log::*;
use smoltcp::{phy::{Device, Medium, wait as phy_wait}, time::Duration};
use smoltcp::wire::{EthernetAddress, Ipv4Address, IpCidr, Ipv4Cidr};
use smoltcp::iface::{NeighborCache, InterfaceBuilder, Routes};
use smoltcp::socket::{SocketSet, RawSocketBuffer, RawPacketMetadata};
use smoltcp::iface::{NeighborCache, InterfaceBuilder, Interface, Routes};
use smoltcp::socket::{SocketSet, Dhcpv4Socket, Dhcpv4Event};
use smoltcp::time::Instant;
use smoltcp::dhcp::Dhcpv4Client;
fn main() {
#[cfg(feature = "log")]
@ -41,65 +42,61 @@ fn main() {
let mut iface = builder.finalize();
let mut sockets = SocketSet::new(vec![]);
let dhcp_rx_buffer = RawSocketBuffer::new(
[RawPacketMetadata::EMPTY; 1],
vec![0; 900]
);
let dhcp_tx_buffer = RawSocketBuffer::new(
[RawPacketMetadata::EMPTY; 1],
vec![0; 600]
);
let mut dhcp = Dhcpv4Client::new(&mut sockets, dhcp_rx_buffer, dhcp_tx_buffer, Instant::now());
let mut prev_cidr = Ipv4Cidr::new(Ipv4Address::UNSPECIFIED, 0);
let mut dhcp_socket = Dhcpv4Socket::new();
// Set a ridiculously short max lease time to show DHCP renews work properly.
// This will cause the DHCP client to start renewing after 5 seconds, and give up the
// lease after 10 seconds if renew hasn't succeeded.
// IMPORTANT: This should be removed in production.
dhcp_socket.set_max_lease_duration(Some(Duration::from_secs(10)));
let dhcp_handle = sockets.add(dhcp_socket);
loop {
let timestamp = Instant::now();
iface.poll(&mut sockets, timestamp)
.map(|_| ())
.unwrap_or_else(|e| println!("Poll: {:?}", e));
let config = dhcp.poll(&mut iface, &mut sockets, timestamp)
.unwrap_or_else(|e| {
println!("DHCP: {:?}", e);
None
});
config.map(|config| {
println!("DHCP config: {:?}", config);
if let Some(cidr) = config.address {
if cidr != prev_cidr {
iface.update_ip_addrs(|addrs| {
addrs.iter_mut().next()
.map(|addr| {
*addr = IpCidr::Ipv4(cidr);
});
});
prev_cidr = cidr;
println!("Assigned a new IPv4 address: {}", cidr);
if let Err(e) = iface.poll(&mut sockets, timestamp) {
debug!("poll error: {}", e);
}
match sockets.get::<Dhcpv4Socket>(dhcp_handle).poll() {
None => {}
Some(Dhcpv4Event::Configured(config)) => {
debug!("DHCP config acquired!");
debug!("IP address: {}", config.address);
set_ipv4_addr(&mut iface, config.address);
if let Some(router) = config.router {
debug!("Default gateway: {}", router);
iface.routes_mut().add_default_ipv4_route(router).unwrap();
} else {
debug!("Default gateway: None");
iface.routes_mut().remove_default_ipv4_route();
}
for (i, s) in config.dns_servers.iter().enumerate() {
if let Some(s) = s {
debug!("DNS server {}: {}", i, s);
}
}
}
config.router.map(|router| iface.routes_mut()
.add_default_ipv4_route(router)
.unwrap()
);
iface.routes_mut()
.update(|routes_map| {
routes_map.get(&IpCidr::new(Ipv4Address::UNSPECIFIED.into(), 0))
.map(|default_route| {
println!("Default gateway: {}", default_route.via_router);
});
});
if config.dns_servers.iter().any(|s| s.is_some()) {
println!("DNS servers:");
for dns_server in config.dns_servers.iter().filter_map(|s| *s) {
println!("- {}", dns_server);
}
Some(Dhcpv4Event::Deconfigured) => {
debug!("DHCP lost config!");
set_ipv4_addr(&mut iface, Ipv4Cidr::new(Ipv4Address::UNSPECIFIED, 0));
iface.routes_mut().remove_default_ipv4_route();
}
});
}
let mut timeout = dhcp.next_poll(timestamp);
iface.poll_delay(&sockets, timestamp)
.map(|sockets_timeout| timeout = sockets_timeout);
phy_wait(fd, Some(timeout))
.unwrap_or_else(|e| println!("Wait: {:?}", e));
phy_wait(fd, iface.poll_delay(&sockets, timestamp)).expect("wait error");
}
}
fn set_ipv4_addr<DeviceT>(iface: &mut Interface<'_, DeviceT>, cidr: Ipv4Cidr)
where DeviceT: for<'d> Device<'d>
{
iface.update_ip_addrs(|addrs| {
let dest = addrs.iter_mut().next().unwrap();
*dest = IpCidr::Ipv4(cidr);
});
}

428
src/dhcp/clientv4.rs
View File

@ -1,428 +0,0 @@
use crate::{Result, Error};
use crate::wire::{IpVersion, IpProtocol, IpEndpoint, IpAddress,
Ipv4Cidr, Ipv4Address, Ipv4Packet, Ipv4Repr,
UdpPacket, UdpRepr,
DhcpPacket, DhcpRepr, DhcpMessageType};
use crate::wire::dhcpv4::field as dhcpv4_field;
use crate::socket::{SocketSet, SocketHandle, RawSocket, RawSocketBuffer};
use crate::phy::{Device, ChecksumCapabilities};
use crate::iface::Interface;
use crate::time::{Instant, Duration};
use super::{UDP_SERVER_PORT, UDP_CLIENT_PORT};
const DISCOVER_TIMEOUT: u64 = 10;
const REQUEST_TIMEOUT: u64 = 1;
const REQUEST_RETRIES: u16 = 15;
const DEFAULT_RENEW_INTERVAL: u32 = 60;
const PARAMETER_REQUEST_LIST: &[u8] = &[
dhcpv4_field::OPT_SUBNET_MASK,
dhcpv4_field::OPT_ROUTER,
dhcpv4_field::OPT_DOMAIN_NAME_SERVER,
];
/// IPv4 configuration data returned by `client.poll()`
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Config {
pub address: Option<Ipv4Cidr>,
pub router: Option<Ipv4Address>,
pub dns_servers: [Option<Ipv4Address>; 3],
}
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
struct RequestState {
retry: u16,
endpoint_ip: Ipv4Address,
server_identifier: Ipv4Address,
requested_ip: Ipv4Address,
}
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
struct RenewState {
endpoint_ip: Ipv4Address,
server_identifier: Ipv4Address,
}
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
enum ClientState {
/// Discovering the DHCP server
Discovering,
/// Requesting an address
Requesting(RequestState),
/// Having an address, refresh it periodically
Renew(RenewState),
}
pub struct Client {
state: ClientState,
raw_handle: SocketHandle,
/// When to send next request
next_egress: Instant,
/// When any existing DHCP address will expire.
lease_expiration: Option<Instant>,
transaction_id: u32,
}
/// DHCP client with a RawSocket.
///
/// To provide memory for the dynamic IP address, configure your
/// `Interface` with one of `ip_addrs` and the `ipv4_gateway` being
/// `Ipv4Address::UNSPECIFIED`. You must also assign this `0.0.0.0/0`
/// while the client's state is `Discovering`. Hence, the `poll()`
/// method returns a corresponding `Config` struct in this case.
///
/// You must call `dhcp_client.poll()` after `iface.poll()` to send
/// and receive DHCP packets.
impl Client {
/// # Usage
/// ```rust
/// use smoltcp::socket::{SocketSet, RawSocketBuffer, RawPacketMetadata};
/// use smoltcp::dhcp::Dhcpv4Client;
/// use smoltcp::time::Instant;
///
/// let mut sockets = SocketSet::new(vec![]);
/// let dhcp_rx_buffer = RawSocketBuffer::new(
/// [RawPacketMetadata::EMPTY; 1],
/// vec![0; 600]
/// );
/// let dhcp_tx_buffer = RawSocketBuffer::new(
/// [RawPacketMetadata::EMPTY; 1],
/// vec![0; 600]
/// );
/// let mut dhcp = Dhcpv4Client::new(
/// &mut sockets,
/// dhcp_rx_buffer, dhcp_tx_buffer,
/// Instant::now()
/// );
/// ```
pub fn new<'a>(sockets: &mut SocketSet<'a>, rx_buffer: RawSocketBuffer<'a>, tx_buffer: RawSocketBuffer<'a>, now: Instant) -> Self
{
let raw_socket = RawSocket::new(IpVersion::Ipv4, IpProtocol::Udp, rx_buffer, tx_buffer);
let raw_handle = sockets.add(raw_socket);
Client {
state: ClientState::Discovering,
raw_handle,
next_egress: now,
transaction_id: 1,
lease_expiration: None,
}
}
/// When to send next packet
///
/// Useful for suspending execution after polling.
pub fn next_poll(&self, now: Instant) -> Duration {
self.next_egress - now
}
/// Process incoming packets on the contained RawSocket, and send
/// DHCP requests when timeouts are ready.
///
/// Applying the obtained network configuration is left to the
/// user.
///
/// A Config can be returned from any valid DHCP reply. The client
/// performs no bookkeeping on configuration or their changes.
pub fn poll<DeviceT>(&mut self,
iface: &mut Interface<DeviceT>, sockets: &mut SocketSet,
now: Instant
) -> Result<Option<Config>>
where
DeviceT: for<'d> Device<'d>,
{
let checksum_caps = iface.device().capabilities().checksum;
let mut raw_socket = sockets.get::<RawSocket>(self.raw_handle);
// Process incoming
let config = {
match raw_socket.recv()
.and_then(|packet| parse_udp(packet, &checksum_caps)) {
Ok((IpEndpoint {
addr: IpAddress::Ipv4(src_ip),
port: UDP_SERVER_PORT,
}, IpEndpoint {
addr: _,
port: UDP_CLIENT_PORT,
}, payload)) =>
self.ingress(iface, now, payload, &src_ip),
Ok(_) =>
return Err(Error::Unrecognized),
Err(Error::Exhausted) =>
None,
Err(e) =>
return Err(e),
}
};
if config.is_some() {
// Return a new config immediately so that addresses can
// be configured that are required by egress().
Ok(config)
} else {
// Send requests
if raw_socket.can_send() && now >= self.next_egress {
self.egress(iface, &mut *raw_socket, &checksum_caps, now)
} else {
Ok(None)
}
}
}
fn ingress<DeviceT>(&mut self,
iface: &mut Interface<DeviceT>, now: Instant,
data: &[u8], src_ip: &Ipv4Address
) -> Option<Config>
where
DeviceT: for<'d> Device<'d>,
{
let dhcp_packet = match DhcpPacket::new_checked(data) {
Ok(dhcp_packet) => dhcp_packet,
Err(e) => {
net_debug!("DHCP invalid pkt from {}: {:?}", src_ip, e);
return None;
}
};
let dhcp_repr = match DhcpRepr::parse(&dhcp_packet) {
Ok(dhcp_repr) => dhcp_repr,
Err(e) => {
net_debug!("DHCP error parsing pkt from {}: {:?}", src_ip, e);
return None;
}
};
let mac = iface.ethernet_addr();
if dhcp_repr.client_hardware_address != mac { return None }
if dhcp_repr.transaction_id != self.transaction_id { return None }
let server_identifier = match dhcp_repr.server_identifier {
Some(server_identifier) => server_identifier,
None => return None,
};
net_debug!("DHCP recv {:?} from {} ({})", dhcp_repr.message_type, src_ip, server_identifier);
// once we receive the ack, we can pass the config to the user
let config = if dhcp_repr.message_type == DhcpMessageType::Ack {
let lease_duration = dhcp_repr.lease_duration.unwrap_or(DEFAULT_RENEW_INTERVAL * 2);
self.lease_expiration = Some(now + Duration::from_secs(lease_duration.into()));
// RFC 2131 indicates clients should renew a lease halfway through its expiration.
self.next_egress = now + Duration::from_secs((lease_duration / 2).into());
let address = dhcp_repr.subnet_mask
.and_then(|mask| IpAddress::Ipv4(mask).to_prefix_len())
.map(|prefix_len| Ipv4Cidr::new(dhcp_repr.your_ip, prefix_len));
let router = dhcp_repr.router;
let dns_servers = dhcp_repr.dns_servers
.unwrap_or([None; 3]);
Some(Config { address, router, dns_servers })
} else {
None
};
match self.state {
ClientState::Discovering
if dhcp_repr.message_type == DhcpMessageType::Offer =>
{
self.next_egress = now;
let r_state = RequestState {
retry: 0,
endpoint_ip: *src_ip,
server_identifier,
requested_ip: dhcp_repr.your_ip // use the offered ip
};
Some(ClientState::Requesting(r_state))
}
ClientState::Requesting(ref r_state)
if dhcp_repr.message_type == DhcpMessageType::Ack &&
server_identifier == r_state.server_identifier =>
{
let p_state = RenewState {
endpoint_ip: *src_ip,
server_identifier,
};
Some(ClientState::Renew(p_state))
}
_ => None
}.map(|new_state| self.state = new_state);
config
}
fn egress<DeviceT: for<'d> Device<'d>>(&mut self, iface: &mut Interface<DeviceT>, raw_socket: &mut RawSocket, checksum_caps: &ChecksumCapabilities, now: Instant) -> Result<Option<Config>> {
// Reset after maximum amount of retries
let retries_exceeded = match self.state {
ClientState::Requesting(ref mut r_state) if r_state.retry >= REQUEST_RETRIES => {
net_debug!("DHCP request retries exceeded, restarting discovery");
true
}
_ => false
};
let lease_expired = self.lease_expiration.map_or(false, |expiration| now >= expiration);
if lease_expired || retries_exceeded {
self.reset(now);
// Return a config now so that user code assigns the
// 0.0.0.0/0 address, which will be used sending a DHCP
// discovery packet in the next call to egress().
return Ok(Some(Config {
address: Some(Ipv4Cidr::new(Ipv4Address::UNSPECIFIED, 0)),
router: None,
dns_servers: [None; 3],
}));
}
// Prepare sending next packet
self.transaction_id += 1;
let mac = iface.ethernet_addr();
let mut dhcp_repr = DhcpRepr {
message_type: DhcpMessageType::Discover,
transaction_id: self.transaction_id,
client_hardware_address: mac,
client_ip: Ipv4Address::UNSPECIFIED,
your_ip: Ipv4Address::UNSPECIFIED,
server_ip: Ipv4Address::UNSPECIFIED,
router: None,
subnet_mask: None,
relay_agent_ip: Ipv4Address::UNSPECIFIED,
broadcast: true,
requested_ip: None,
client_identifier: Some(mac),
server_identifier: None,
parameter_request_list: Some(PARAMETER_REQUEST_LIST),
max_size: Some(raw_socket.payload_recv_capacity() as u16),
lease_duration: None,
dns_servers: None,
};
let mut send_packet = |iface, endpoint, dhcp_repr| {
send_packet(iface, raw_socket, &endpoint, &dhcp_repr, checksum_caps)
.map(|()| None)
};
match self.state {
ClientState::Discovering => {
self.next_egress = now + Duration::from_secs(DISCOVER_TIMEOUT);
let endpoint = IpEndpoint {
addr: Ipv4Address::BROADCAST.into(),
port: UDP_SERVER_PORT,
};
net_trace!("DHCP send discover to {}: {:?}", endpoint, dhcp_repr);
send_packet(iface, endpoint, dhcp_repr)
}
ClientState::Requesting(ref mut r_state) => {
r_state.retry += 1;
self.next_egress = now + Duration::from_secs(REQUEST_TIMEOUT);
let endpoint = IpEndpoint {
addr: Ipv4Address::BROADCAST.into(),
port: UDP_SERVER_PORT,
};
dhcp_repr.message_type = DhcpMessageType::Request;
dhcp_repr.broadcast = false;
dhcp_repr.requested_ip = Some(r_state.requested_ip);
dhcp_repr.server_identifier = Some(r_state.server_identifier);
net_trace!("DHCP send request to {} = {:?}", endpoint, dhcp_repr);
send_packet(iface, endpoint, dhcp_repr)
}
ClientState::Renew(ref mut p_state) => {
self.next_egress = now + Duration::from_secs(DEFAULT_RENEW_INTERVAL.into());
let endpoint = IpEndpoint {
addr: p_state.endpoint_ip.into(),
port: UDP_SERVER_PORT,
};
let client_ip = iface.ipv4_addr().unwrap_or(Ipv4Address::UNSPECIFIED);
dhcp_repr.message_type = DhcpMessageType::Request;
dhcp_repr.client_ip = client_ip;
dhcp_repr.broadcast = false;
net_trace!("DHCP send renew to {}: {:?}", endpoint, dhcp_repr);
send_packet(iface, endpoint, dhcp_repr)
}
}
}
/// Reset state and restart discovery phase.
///
/// Use this to speed up acquisition of an address in a new
/// network if a link was down and it is now back up.
///
/// You *must* configure a `0.0.0.0` address on your interface
/// before the next call to `poll()`!
pub fn reset(&mut self, now: Instant) {
net_trace!("DHCP reset");
self.state = ClientState::Discovering;
self.next_egress = now;
self.lease_expiration = None;
}
}
fn send_packet<DeviceT: for<'d> Device<'d>>(iface: &mut Interface<DeviceT>, raw_socket: &mut RawSocket, endpoint: &IpEndpoint, dhcp_repr: &DhcpRepr, checksum_caps: &ChecksumCapabilities) -> Result<()> {
let mut dhcp_payload_buf = [0; 320];
assert!(dhcp_repr.buffer_len() <= dhcp_payload_buf.len());
let dhcp_payload = &mut dhcp_payload_buf[0..dhcp_repr.buffer_len()];
{
let mut dhcp_packet = DhcpPacket::new_checked(&mut dhcp_payload[..])?;
dhcp_repr.emit(&mut dhcp_packet)?;
}
let udp_repr = UdpRepr {
src_port: UDP_CLIENT_PORT,
dst_port: endpoint.port,
payload: dhcp_payload,
};
let src_addr = iface.ipv4_addr().unwrap();
let dst_addr = match endpoint.addr {
IpAddress::Ipv4(addr) => addr,
_ => return Err(Error::Illegal),
};
let ipv4_repr = Ipv4Repr {
src_addr,
dst_addr,
protocol: IpProtocol::Udp,
payload_len: udp_repr.buffer_len(),
hop_limit: 64,
};
let mut packet = raw_socket.send(
ipv4_repr.buffer_len() + udp_repr.buffer_len()
)?;
{
let mut ipv4_packet = Ipv4Packet::new_unchecked(&mut packet);
ipv4_repr.emit(&mut ipv4_packet, &checksum_caps);
}
{
let mut udp_packet = UdpPacket::new_unchecked(
&mut packet[ipv4_repr.buffer_len()..]
);
udp_repr.emit(&mut udp_packet,
&src_addr.into(), &dst_addr.into(),
checksum_caps);
}
Ok(())
}
fn parse_udp<'a>(data: &'a [u8], checksum_caps: &ChecksumCapabilities) -> Result<(IpEndpoint, IpEndpoint, &'a [u8])> {
let ipv4_packet = Ipv4Packet::new_checked(data)?;
let ipv4_repr = Ipv4Repr::parse(&ipv4_packet, &checksum_caps)?;
let udp_packet = UdpPacket::new_checked(ipv4_packet.payload())?;
let udp_repr = UdpRepr::parse(
&udp_packet,
&ipv4_repr.src_addr.into(), &ipv4_repr.dst_addr.into(),
checksum_caps
)?;
let src = IpEndpoint {
addr: ipv4_repr.src_addr.into(),
port: udp_repr.src_port,
};
let dst = IpEndpoint {
addr: ipv4_repr.dst_addr.into(),
port: udp_repr.dst_port,
};
let data = udp_repr.payload;
Ok((src, dst, data))
}

5
src/dhcp/mod.rs
View File

@ -1,5 +0,0 @@
pub const UDP_SERVER_PORT: u16 = 67;
pub const UDP_CLIENT_PORT: u16 = 68;
mod clientv4;
pub use self::clientv4::{Client as Dhcpv4Client, Config as Dhcpv4Config};

173
src/iface/interface.rs
View File

@ -263,9 +263,11 @@ pub(crate) enum IpPacket<'a> {
#[cfg(feature = "socket-raw")]
Raw((IpRepr, &'a [u8])),
#[cfg(feature = "socket-udp")]
Udp((IpRepr, UdpRepr<'a>)),
Udp((IpRepr, UdpRepr, &'a [u8])),
#[cfg(feature = "socket-tcp")]
Tcp((IpRepr, TcpRepr<'a>))
Tcp((IpRepr, TcpRepr<'a>)),
#[cfg(feature = "socket-dhcpv4")]
Dhcpv4((Ipv4Repr, UdpRepr, DhcpRepr<'a>)),
}
impl<'a> IpPacket<'a> {
@ -280,16 +282,18 @@ impl<'a> IpPacket<'a> {
#[cfg(feature = "socket-raw")]
IpPacket::Raw((ip_repr, _)) => ip_repr.clone(),
#[cfg(feature = "socket-udp")]
IpPacket::Udp((ip_repr, _)) => ip_repr.clone(),
IpPacket::Udp((ip_repr, _, _)) => ip_repr.clone(),
#[cfg(feature = "socket-tcp")]
IpPacket::Tcp((ip_repr, _)) => ip_repr.clone(),
#[cfg(feature = "socket-dhcpv4")]
IpPacket::Dhcpv4((ipv4_repr, _, _)) => IpRepr::Ipv4(*ipv4_repr),
}
}
pub(crate) fn emit_payload(&self, _ip_repr: IpRepr, payload: &mut [u8], caps: &DeviceCapabilities) {
match self {
#[cfg(feature = "proto-ipv4")]
IpPacket::Icmpv4((_, icmpv4_repr)) =>
IpPacket::Icmpv4((_, icmpv4_repr)) =>
icmpv4_repr.emit(&mut Icmpv4Packet::new_unchecked(payload), &caps.checksum),
#[cfg(feature = "proto-igmp")]
IpPacket::Igmp((_, igmp_repr)) =>
@ -302,9 +306,11 @@ impl<'a> IpPacket<'a> {
IpPacket::Raw((_, raw_packet)) =>
payload.copy_from_slice(raw_packet),
#[cfg(feature = "socket-udp")]
IpPacket::Udp((_, udp_repr)) =>
IpPacket::Udp((_, udp_repr, inner_payload)) =>
udp_repr.emit(&mut UdpPacket::new_unchecked(payload),
&_ip_repr.src_addr(), &_ip_repr.dst_addr(), &caps.checksum),
&_ip_repr.src_addr(), &_ip_repr.dst_addr(),
inner_payload.len(), |buf| buf.copy_from_slice(inner_payload),
&caps.checksum),
#[cfg(feature = "socket-tcp")]
IpPacket::Tcp((_, mut tcp_repr)) => {
// This is a terrible hack to make TCP performance more acceptable on systems
@ -329,6 +335,13 @@ impl<'a> IpPacket<'a> {
&_ip_repr.src_addr(), &_ip_repr.dst_addr(),
&caps.checksum);
}
#[cfg(feature = "socket-dhcpv4")]
IpPacket::Dhcpv4((_, udp_repr, dhcp_repr)) =>
udp_repr.emit(&mut UdpPacket::new_unchecked(payload),
&_ip_repr.src_addr(), &_ip_repr.dst_addr(),
dhcp_repr.buffer_len(),
|buf| dhcp_repr.emit(&mut DhcpPacket::new_unchecked(buf)).unwrap(),
&caps.checksum),
}
}
}
@ -660,6 +673,14 @@ impl<'a, DeviceT> Interface<'a, DeviceT>
})
}
let _ip_mtu = match _caps.medium {
#[cfg(feature = "medium-ethernet")]
Medium::Ethernet => _caps.max_transmission_unit - EthernetFrame::<&[u8]>::header_len(),
#[cfg(feature = "medium-ip")]
Medium::Ip => _caps.max_transmission_unit,
};
let socket_result =
match *socket {
#[cfg(feature = "socket-raw")]
@ -685,15 +706,14 @@ impl<'a, DeviceT> Interface<'a, DeviceT>
respond!(IpPacket::Udp(response))),
#[cfg(feature = "socket-tcp")]
Socket::Tcp(ref mut socket) => {
let ip_mtu = match _caps.medium {
#[cfg(feature = "medium-ethernet")]
Medium::Ethernet => _caps.max_transmission_unit - EthernetFrame::<&[u8]>::header_len(),
#[cfg(feature = "medium-ip")]
Medium::Ip => _caps.max_transmission_unit,
};
socket.dispatch(timestamp, ip_mtu, |response|
socket.dispatch(timestamp, _ip_mtu, |response|
respond!(IpPacket::Tcp(response)))
}
#[cfg(feature = "socket-dhcpv4")]
Socket::Dhcpv4(ref mut socket) =>
// todo don't unwrap
socket.dispatch(timestamp, inner.ethernet_addr.unwrap(), _ip_mtu, |response|
respond!(IpPacket::Dhcpv4(response))),
};
match (device_result, socket_result) {
@ -880,7 +900,7 @@ impl<'a> InterfaceInner<'a> {
self.neighbor_cache.as_mut().unwrap().fill(ip_addr, eth_frame.src_addr(), timestamp);
}
}
self.process_ipv6(sockets, timestamp, &ipv6_packet).map(|o| o.map(EthernetPacket::Ip))
}
// Drop all other traffic.
@ -1061,6 +1081,34 @@ impl<'a> InterfaceInner<'a> {
#[cfg(not(feature = "socket-raw"))]
let handled_by_raw_socket = false;
#[cfg(feature = "socket-dhcpv4")]
{
if ipv4_repr.protocol == IpProtocol::Udp && self.ethernet_addr.is_some() {
// First check for source and dest ports, then do `UdpRepr::parse` if they match.
// This way we avoid validating the UDP checksum twice for all non-DHCP UDP packets (one here, one in `process_udp`)
let udp_packet = UdpPacket::new_checked(ip_payload)?;
if udp_packet.src_port() == DHCP_SERVER_PORT && udp_packet.dst_port() == DHCP_CLIENT_PORT {
if let Some(mut dhcp_socket) = sockets.iter_mut().filter_map(Dhcpv4Socket::downcast).next() {
let (src_addr, dst_addr) = (ip_repr.src_addr(), ip_repr.dst_addr());
let checksum_caps = self.device_capabilities.checksum.clone();
let udp_repr = UdpRepr::parse(&udp_packet, &src_addr, &dst_addr, &checksum_caps)?;
let udp_payload = udp_packet.payload();
// NOTE(unwrap): we checked for is_some above.
let ethernet_addr = self.ethernet_addr.unwrap();
match dhcp_socket.process(timestamp, ethernet_addr, &ipv4_repr, &udp_repr, udp_payload) {
// The packet is valid and handled by socket.
Ok(()) => return Ok(None),
// The packet is malformed, or the socket buffer is full.
Err(e) => return Err(e)
}
}
}
}
}
if !self.has_ip_addr(ipv4_repr.dst_addr) &&
!self.has_multicast_group(ipv4_repr.dst_addr) &&
!self.is_broadcast_v4(ipv4_repr.dst_addr) {
@ -1439,11 +1487,12 @@ impl<'a> InterfaceInner<'a> {
let udp_packet = UdpPacket::new_checked(ip_payload)?;
let checksum_caps = self.device_capabilities.checksum.clone();
let udp_repr = UdpRepr::parse(&udp_packet, &src_addr, &dst_addr, &checksum_caps)?;
let udp_payload = udp_packet.payload();
for mut udp_socket in sockets.iter_mut().filter_map(UdpSocket::downcast) {
if !udp_socket.accepts(&ip_repr, &udp_repr) { continue }
match udp_socket.process(&ip_repr, &udp_repr) {
match udp_socket.process(&ip_repr, &udp_repr, udp_payload) {
// The packet is valid and handled by socket.
Ok(()) => return Ok(None),
// The packet is malformed, or the socket buffer is full.
@ -1787,6 +1836,13 @@ mod test {
use crate::socket::SocketSet;
use crate::phy::{Loopback, ChecksumCapabilities};
#[allow(unused)]
fn fill_slice(s: &mut [u8], val: u8) {
for x in s.iter_mut() {
*x = val
}
}
fn create_loopback<'a>() -> (Interface<'a, Loopback>, SocketSet<'a>) {
#[cfg(feature = "medium-ethernet")]
return create_loopback_ethernet();
@ -2035,20 +2091,21 @@ mod test {
let udp_repr = UdpRepr {
src_port: 67,
dst_port: 68,
payload: &UDP_PAYLOAD
};
let ip_repr = IpRepr::Ipv4(Ipv4Repr {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
protocol: IpProtocol::Udp,
payload_len: udp_repr.buffer_len(),
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 64
});
// Emit the representations to a packet
udp_repr.emit(&mut packet_unicast, &ip_repr.src_addr(),
&ip_repr.dst_addr(), &ChecksumCapabilities::default());
&ip_repr.dst_addr(),
UDP_PAYLOAD.len(), |buf| buf.copy_from_slice( &UDP_PAYLOAD),
&ChecksumCapabilities::default());
let data = packet_unicast.into_inner();
@ -2060,7 +2117,7 @@ mod test {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
protocol: IpProtocol::Udp,
payload_len: udp_repr.buffer_len(),
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 64
},
data: &data
@ -2085,13 +2142,14 @@ mod test {
src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Udp,
payload_len: udp_repr.buffer_len(),
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 64
});
// Emit the representations to a packet
udp_repr.emit(&mut packet_broadcast, &ip_repr.src_addr(),
&IpAddress::Ipv4(Ipv4Address::BROADCAST),
UDP_PAYLOAD.len(), |buf| buf.copy_from_slice( &UDP_PAYLOAD),
&ChecksumCapabilities::default());
// Ensure that the port unreachable error does not trigger an
@ -2129,7 +2187,6 @@ mod test {
let udp_repr = UdpRepr {
src_port: 67,
dst_port: 68,
payload: &UDP_PAYLOAD
};
#[cfg(feature = "proto-ipv6")]
@ -2137,7 +2194,7 @@ mod test {
src_addr: src_ip,
dst_addr: Ipv6Address::LINK_LOCAL_ALL_NODES,
next_header: IpProtocol::Udp,
payload_len: udp_repr.buffer_len(),
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 0x40
});
#[cfg(all(not(feature = "proto-ipv6"), feature = "proto-ipv4"))]
@ -2145,7 +2202,7 @@ mod test {
src_addr: src_ip,
dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Udp,
payload_len: udp_repr.buffer_len(),
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
hop_limit: 0x40
});
@ -2158,6 +2215,7 @@ mod test {
}
udp_repr.emit(&mut packet, &ip_repr.src_addr(), &ip_repr.dst_addr(),
UDP_PAYLOAD.len(), |buf| buf.copy_from_slice( &UDP_PAYLOAD),
&ChecksumCapabilities::default());
// Packet should be handled by bound UDP socket
@ -2260,18 +2318,19 @@ mod test {
let udp_repr = UdpRepr {
src_port: 67,
dst_port: 68,
payload: &[0x2a; MAX_PAYLOAD_LEN]
};
let mut bytes = vec![0xff; udp_repr.buffer_len()];
let mut bytes = vec![0xff; udp_repr.header_len() + MAX_PAYLOAD_LEN];
let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(), &ChecksumCapabilities::default());
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(),
MAX_PAYLOAD_LEN, |buf| fill_slice(buf, 0x2a),
&ChecksumCapabilities::default());
#[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
let ip_repr = Ipv4Repr {
src_addr: src_addr,
dst_addr: dst_addr,
protocol: IpProtocol::Udp,
hop_limit: 64,
payload_len: udp_repr.buffer_len()
payload_len: udp_repr.header_len() + MAX_PAYLOAD_LEN
};
#[cfg(feature = "proto-ipv6")]
let ip_repr = Ipv6Repr {
@ -2279,7 +2338,7 @@ mod test {
dst_addr: dst_addr,
next_header: IpProtocol::Udp,
hop_limit: 64,
payload_len: udp_repr.buffer_len()
payload_len: udp_repr.header_len() + MAX_PAYLOAD_LEN
};
let payload = packet.into_inner();
@ -2619,7 +2678,7 @@ mod test {
recv_all(&mut iface, timestamp)
.iter()
.filter_map(|frame| {
let ipv4_packet = match caps.medium {
#[cfg(feature = "medium-ethernet")]
Medium::Ethernet => {
@ -2666,11 +2725,11 @@ mod test {
// General query
let timestamp = Instant::now();
const GENERAL_QUERY_BYTES: &[u8] = &[
0x46, 0xc0, 0x00, 0x24, 0xed, 0xb4, 0x00, 0x00,
0x01, 0x02, 0x47, 0x43, 0xac, 0x16, 0x63, 0x04,
0xe0, 0x00, 0x00, 0x01, 0x94, 0x04, 0x00, 0x00,
0x11, 0x64, 0xec, 0x8f, 0x00, 0x00, 0x00, 0x00,
0x02, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x46, 0xc0, 0x00, 0x24, 0xed, 0xb4, 0x00, 0x00,
0x01, 0x02, 0x47, 0x43, 0xac, 0x16, 0x63, 0x04,
0xe0, 0x00, 0x00, 0x01, 0x94, 0x04, 0x00, 0x00,
0x11, 0x64, 0xec, 0x8f, 0x00, 0x00, 0x00, 0x00,
0x02, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
];
{
@ -2722,25 +2781,28 @@ mod test {
let src_addr = Ipv4Address([127, 0, 0, 2]);
let dst_addr = Ipv4Address([127, 0, 0, 1]);
const PAYLOAD_LEN: usize = 10;
let udp_repr = UdpRepr {
src_port: 67,
dst_port: 68,
payload: &[0x2a; 10]
};
let mut bytes = vec![0xff; udp_repr.buffer_len()];
let mut bytes = vec![0xff; udp_repr.header_len() + PAYLOAD_LEN];
let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(), &ChecksumCapabilities::default());
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(),
PAYLOAD_LEN, |buf| fill_slice(buf, 0x2a),
&ChecksumCapabilities::default());
let ipv4_repr = Ipv4Repr {
src_addr: src_addr,
dst_addr: dst_addr,
protocol: IpProtocol::Udp,
hop_limit: 64,
payload_len: udp_repr.buffer_len()
payload_len: udp_repr.header_len() + PAYLOAD_LEN
};
// Emit to frame
let mut bytes = vec![0u8;
ipv4_repr.buffer_len() + udp_repr.buffer_len()
ipv4_repr.buffer_len() + udp_repr.header_len() + PAYLOAD_LEN
];
let frame = {
ipv4_repr.emit(
@ -2751,6 +2813,7 @@ mod test {
&mut bytes[ipv4_repr.buffer_len()..]),
&src_addr.into(),
&dst_addr.into(),
PAYLOAD_LEN, |buf| fill_slice(buf, 0x2a),
&ChecksumCapabilities::default());
Ipv4Packet::new_unchecked(&bytes)
};
@ -2776,25 +2839,28 @@ mod test {
let src_addr = Ipv4Address([127, 0, 0, 2]);
let dst_addr = Ipv4Address([127, 0, 0, 1]);
const PAYLOAD_LEN: usize = 49; // 49 > 48, hence packet will be truncated
let udp_repr = UdpRepr {
src_port: 67,
dst_port: 68,
payload: &[0x2a; 49] // 49 > 48, hence packet will be truncated
};
let mut bytes = vec![0xff; udp_repr.buffer_len()];
let mut bytes = vec![0xff; udp_repr.header_len() + PAYLOAD_LEN];
let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(), &ChecksumCapabilities::default());
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(),
PAYLOAD_LEN, |buf| fill_slice(buf, 0x2a),
&ChecksumCapabilities::default());
let ipv4_repr = Ipv4Repr {
src_addr: src_addr,
dst_addr: dst_addr,
protocol: IpProtocol::Udp,
hop_limit: 64,
payload_len: udp_repr.buffer_len()
payload_len: udp_repr.header_len() + PAYLOAD_LEN
};
// Emit to frame
let mut bytes = vec![0u8;
ipv4_repr.buffer_len() + udp_repr.buffer_len()
ipv4_repr.buffer_len() + udp_repr.header_len() + PAYLOAD_LEN
];
let frame = {
ipv4_repr.emit(
@ -2802,9 +2868,10 @@ mod test {
&ChecksumCapabilities::default());
udp_repr.emit(
&mut UdpPacket::new_unchecked(
&mut bytes[ipv4_repr.buffer_len()..]),
&mut bytes[ipv4_repr.buffer_len()..]),
&src_addr.into(),
&dst_addr.into(),
PAYLOAD_LEN, |buf| fill_slice(buf, 0x2a),
&ChecksumCapabilities::default());
Ipv4Packet::new_unchecked(&bytes)
};
@ -2812,7 +2879,7 @@ mod test {
let frame = iface.inner.process_ipv4(&mut socket_set, Instant::from_millis(0), &frame);
// because the packet could not be handled we should send an Icmp message
assert!(match frame {
assert!(match frame {
Ok(Some(IpPacket::Icmpv4(_))) => true,
_ => false,
});
@ -2853,22 +2920,23 @@ mod test {
let udp_repr = UdpRepr {
src_port: 67,
dst_port: 68,
payload: &UDP_PAYLOAD
};
let mut bytes = vec![0xff; udp_repr.buffer_len()];
let mut bytes = vec![0xff; udp_repr.header_len() + UDP_PAYLOAD.len()];
let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(), &ChecksumCapabilities::default());
udp_repr.emit(&mut packet, &src_addr.into(), &dst_addr.into(),
UDP_PAYLOAD.len(), |buf| buf.copy_from_slice( &UDP_PAYLOAD),
&ChecksumCapabilities::default());
let ipv4_repr = Ipv4Repr {
src_addr: src_addr,
dst_addr: dst_addr,
protocol: IpProtocol::Udp,
hop_limit: 64,
payload_len: udp_repr.buffer_len()
payload_len: udp_repr.header_len() + UDP_PAYLOAD.len()
};
// Emit to frame
let mut bytes = vec![0u8;
ipv4_repr.buffer_len() + udp_repr.buffer_len()
ipv4_repr.buffer_len() + udp_repr.header_len() + UDP_PAYLOAD.len()
];
let frame = {
ipv4_repr.emit(
@ -2876,9 +2944,10 @@ mod test {
&ChecksumCapabilities::default());
udp_repr.emit(
&mut UdpPacket::new_unchecked(
&mut bytes[ipv4_repr.buffer_len()..]),
&mut bytes[ipv4_repr.buffer_len()..]),
&src_addr.into(),
&dst_addr.into(),
UDP_PAYLOAD.len(), |buf| buf.copy_from_slice( &UDP_PAYLOAD),
&ChecksumCapabilities::default());
Ipv4Packet::new_unchecked(&bytes)
};

18
src/iface/route.rs
View File

@ -106,6 +106,24 @@ impl<'a> Routes<'a> {
}
}
/// Remove the default ipv4 gateway
///
/// On success, returns the previous default route, if any.
#[cfg(feature = "proto-ipv4")]
pub fn remove_default_ipv4_route(&mut self) -> Option<Route> {
let cidr = IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0);
self.storage.remove(&cidr)
}
/// Remove the default ipv6 gateway
///
/// On success, returns the previous default route, if any.
#[cfg(feature = "proto-ipv6")]
pub fn remove_default_ipv6_route(&mut self) -> Option<Route> {
let cidr = IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 0), 0);
self.storage.remove(&cidr)
}
pub(crate) fn lookup(&self, addr: &IpAddress, timestamp: Instant) ->
Option<IpAddress> {
assert!(addr.is_unicast());

2
src/lib.rs
View File

@ -121,8 +121,6 @@ pub mod iface;
#[cfg(feature = "socket")]
pub mod socket;
pub mod time;
#[cfg(feature = "proto-dhcpv4")]
pub mod dhcp;
/// The error type for the networking stack.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]

1
src/macros.rs
View File

@ -12,7 +12,6 @@ macro_rules! net_log {
}
#[cfg(not(any(feature = "log", feature = "defmt")))]
#[macro_use]
macro_rules! net_log {
($level:ident, $($arg:expr),*) => { $( let _ = $arg; )* }
}

458
src/socket/dhcpv4.rs Normal file
View File

@ -0,0 +1,458 @@
use crate::{Error, Result};
use crate::wire::{EthernetAddress, IpProtocol, IpAddress,
Ipv4Cidr, Ipv4Address, Ipv4Repr,
UdpRepr, UDP_HEADER_LEN,
DhcpPacket, DhcpRepr, DhcpMessageType, DHCP_CLIENT_PORT, DHCP_SERVER_PORT, DHCP_MAX_DNS_SERVER_COUNT};
use crate::wire::dhcpv4::{field as dhcpv4_field};
use crate::socket::SocketMeta;
use crate::time::{Instant, Duration};
use super::{PollAt, Socket};
const DISCOVER_TIMEOUT: Duration = Duration::from_secs(10);
// timeout doubles every 2 tries.
// total time 5 + 5 + 10 + 10 + 20 = 50s
const REQUEST_TIMEOUT: Duration = Duration::from_secs(5);
const REQUEST_RETRIES: u16 = 5;
const MIN_RENEW_TIMEOUT: Duration = Duration::from_secs(60);
const DEFAULT_LEASE_DURATION: Duration = Duration::from_secs(120);
const PARAMETER_REQUEST_LIST: &[u8] = &[
dhcpv4_field::OPT_SUBNET_MASK,
dhcpv4_field::OPT_ROUTER,
dhcpv4_field::OPT_DOMAIN_NAME_SERVER,
];
/// IPv4 configuration data provided by the DHCP server.
#[derive(Debug, Eq, PartialEq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Config {
/// IP address
pub address: Ipv4Cidr,
/// Router address, also known as default gateway. Does not necessarily
/// match the DHCP server's address.
pub router: Option<Ipv4Address>,
/// DNS servers
pub dns_servers: [Option<Ipv4Address>; DHCP_MAX_DNS_SERVER_COUNT],
}
/// Information on how to reach a DHCP server.
#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
struct ServerInfo {
/// IP address to use as destination in outgoing packets
address: Ipv4Address,
/// Server identifier to use in outgoing packets. Usually equal to server_address,
/// but may differ in some situations (eg DHCP relays)
identifier: Ipv4Address,
}
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
struct DiscoverState {
/// When to send next request
retry_at: Instant,
}
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
struct RequestState {
/// When to send next request
retry_at: Instant,
/// How many retries have been done
retry: u16,
/// Server we're trying to request from
server: ServerInfo,
/// IP address that we're trying to request.
requested_ip: Ipv4Address,
}
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
struct RenewState {
/// Server that gave us the lease
server: ServerInfo,
/// Active network config
config: Config,
/// Renew timer. When reached, we will start attempting
/// to renew this lease with the DHCP server.
/// Must be less or equal than `expires_at`.
renew_at: Instant,
/// Expiration timer. When reached, this lease is no longer valid, so it must be
/// thrown away and the ethernet interface deconfigured.
expires_at: Instant,
}
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
enum ClientState {
/// Discovering the DHCP server
Discovering(DiscoverState),
/// Requesting an address
Requesting(RequestState),
/// Having an address, refresh it periodically.
Renewing(RenewState),
}
/// Return value for the `Dhcpv4Socket::poll` function
pub enum Event<'a> {
/// Configuration has been lost (for example, the lease has expired)
Deconfigured,
/// Configuration has been newly acquired, or modified.
Configured(&'a Config),
}
#[derive(Debug)]
pub struct Dhcpv4Socket {
pub(crate) meta: SocketMeta,
/// State of the DHCP client.
state: ClientState,
/// Set to true on config/state change, cleared back to false by the `config` function.
config_changed: bool,
/// xid of the last sent message.
transaction_id: u32,
/// Max lease duration. If set, it sets a maximum cap to the server-provided lease duration.
/// Useful to react faster to IP configuration changes and to test whether renews work correctly.
max_lease_duration: Option<Duration>,
}
/// DHCP client socket.
///
/// The socket acquires an IP address configuration through DHCP autonomously.
/// You must query the configuration with `.poll()` after every call to `Interface::poll()`,
/// and apply the configuration to the `Interface`.
impl Dhcpv4Socket {
/// Create a DHCPv4 socket
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
Dhcpv4Socket {
meta: SocketMeta::default(),
state: ClientState::Discovering(DiscoverState{
retry_at: Instant::from_millis(0),
}),
config_changed: true,
transaction_id: 1,
max_lease_duration: None,
}
}
pub fn max_lease_duration(&self) -> Option<Duration> {
self.max_lease_duration
}
pub fn set_max_lease_duration(&mut self, max_lease_duration: Option<Duration>) {
self.max_lease_duration = max_lease_duration;
}
pub(crate) fn poll_at(&self) -> PollAt {
let t = match &self.state {
ClientState::Discovering(state) => state.retry_at,
ClientState::Requesting(state) => state.retry_at,
ClientState::Renewing(state) => state.renew_at.min(state.expires_at),
};
PollAt::Time(t)
}
pub(crate) fn process(&mut self, now: Instant, ethernet_addr: EthernetAddress, ip_repr: &Ipv4Repr, repr: &UdpRepr, payload: &[u8]) -> Result<()> {
let src_ip = ip_repr.src_addr;
// This is enforced in interface.rs.
assert!(repr.src_port == DHCP_SERVER_PORT && repr.dst_port == DHCP_CLIENT_PORT);
let dhcp_packet = match DhcpPacket::new_checked(payload) {
Ok(dhcp_packet) => dhcp_packet,
Err(e) => {
net_debug!("DHCP invalid pkt from {}: {:?}", src_ip, e);
return Ok(());
}
};
let dhcp_repr = match DhcpRepr::parse(&dhcp_packet) {
Ok(dhcp_repr) => dhcp_repr,
Err(e) => {
net_debug!("DHCP error parsing pkt from {}: {:?}", src_ip, e);
return Ok(());
}
};
if dhcp_repr.client_hardware_address != ethernet_addr { return Ok(()) }
if dhcp_repr.transaction_id != self.transaction_id { return Ok(()) }
let server_identifier = match dhcp_repr.server_identifier {
Some(server_identifier) => server_identifier,
None => {
net_debug!("DHCP ignoring {:?} because missing server_identifier", dhcp_repr.message_type);
return Ok(());
}
};
net_debug!("DHCP recv {:?} from {} ({})", dhcp_repr.message_type, src_ip, server_identifier);
match (&mut self.state, dhcp_repr.message_type){
(ClientState::Discovering(_state), DhcpMessageType::Offer) => {
if !dhcp_repr.your_ip.is_unicast() {
net_debug!("DHCP ignoring OFFER because your_ip is not unicast");
return Ok(())
}
self.state = ClientState::Requesting(RequestState {
retry_at: now,
retry: 0,
server: ServerInfo {
address: src_ip,
identifier: server_identifier,
},
requested_ip: dhcp_repr.your_ip // use the offered ip
});
}
(ClientState::Requesting(state), DhcpMessageType::Ack) => {
if let Some((config, renew_at, expires_at)) = Self::parse_ack(now, &dhcp_repr, self.max_lease_duration) {
self.config_changed = true;
self.state = ClientState::Renewing(RenewState{
server: state.server,
config,
renew_at,
expires_at,
});
}
}
(ClientState::Requesting(_), DhcpMessageType::Nak) => {
self.reset();
}
(ClientState::Renewing(state), DhcpMessageType::Ack) => {
if let Some((config, renew_at, expires_at)) = Self::parse_ack(now, &dhcp_repr, self.max_lease_duration) {
state.renew_at = renew_at;
state.expires_at = expires_at;
if state.config != config {
self.config_changed = true;
state.config = config;
}
}
}
(ClientState::Renewing(_), DhcpMessageType::Nak) => {
self.reset();
}
_ => {
net_debug!("DHCP ignoring {:?}: unexpected in current state", dhcp_repr.message_type);
}
}
Ok(())
}
fn parse_ack(now: Instant, dhcp_repr: &DhcpRepr, max_lease_duration: Option<Duration>) -> Option<(Config, Instant, Instant)> {
let subnet_mask = match dhcp_repr.subnet_mask {
Some(subnet_mask) => subnet_mask,
None => {
net_debug!("DHCP ignoring ACK because missing subnet_mask");
return None
}
};
let prefix_len = match IpAddress::Ipv4(subnet_mask).to_prefix_len() {
Some(prefix_len) => prefix_len,
None => {
net_debug!("DHCP ignoring ACK because subnet_mask is not a valid mask");
return None
}
};
if !dhcp_repr.your_ip.is_unicast() {
net_debug!("DHCP ignoring ACK because your_ip is not unicast");
return None
}
let mut lease_duration = dhcp_repr.lease_duration.map(|d| Duration::from_secs(d as _)).unwrap_or(DEFAULT_LEASE_DURATION);
if let Some(max_lease_duration) = max_lease_duration {
lease_duration = lease_duration.min(max_lease_duration);
}
// Cleanup the DNS servers list, keeping only unicasts/
// TP-Link TD-W8970 sends 0.0.0.0 as second DNS server if there's only one configured :(
let mut dns_servers = [None; DHCP_MAX_DNS_SERVER_COUNT];
if let Some(received) = dhcp_repr.dns_servers {
let mut i = 0;
for addr in received.iter() {
if let Some(addr) = addr{
if addr.is_unicast() {
// This can never be out-of-bounds since both arrays have length DHCP_MAX_DNS_SERVER_COUNT
dns_servers[i] = Some(*addr);
i += 1;
}
}
}
}
let config = Config{
address: Ipv4Cidr::new(dhcp_repr.your_ip, prefix_len),
router: dhcp_repr.router,
dns_servers: dns_servers
};
// RFC 2131 indicates clients should renew a lease halfway through its expiration.
let renew_at = now + lease_duration / 2;
let expires_at = now + lease_duration;
Some((config, renew_at, expires_at))
}
pub(crate) fn dispatch<F>(&mut self, now: Instant, ethernet_addr: EthernetAddress, ip_mtu: usize, emit: F) -> Result<()>
where F: FnOnce((Ipv4Repr, UdpRepr, DhcpRepr)) -> Result<()> {
// Worst case biggest IPv4 header length.
// 0x0f * 4 = 60 bytes.
const MAX_IPV4_HEADER_LEN: usize = 60;
// We don't directly increment transaction_id because sending the packet
// may fail. We only want to update state after succesfully sending.
let next_transaction_id = self.transaction_id + 1;
let mut dhcp_repr = DhcpRepr {
message_type: DhcpMessageType::Discover,
transaction_id: next_transaction_id,
client_hardware_address: ethernet_addr,
client_ip: Ipv4Address::UNSPECIFIED,
your_ip: Ipv4Address::UNSPECIFIED,
server_ip: Ipv4Address::UNSPECIFIED,
router: None,
subnet_mask: None,
relay_agent_ip: Ipv4Address::UNSPECIFIED,
broadcast: true,
requested_ip: None,
client_identifier: Some(ethernet_addr),
server_identifier: None,
parameter_request_list: Some(PARAMETER_REQUEST_LIST),
max_size: Some((ip_mtu - MAX_IPV4_HEADER_LEN - UDP_HEADER_LEN) as u16),
lease_duration: None,
dns_servers: None,
};
let udp_repr = UdpRepr {
src_port: DHCP_CLIENT_PORT,
dst_port: DHCP_SERVER_PORT,
};
let mut ipv4_repr = Ipv4Repr {
src_addr: Ipv4Address::UNSPECIFIED,
dst_addr: Ipv4Address::BROADCAST,
protocol: IpProtocol::Udp,
payload_len: 0, // filled right before emit
hop_limit: 64,
};
match &mut self.state {
ClientState::Discovering(state) => {
if now < state.retry_at {
return Err(Error::Exhausted)
}
// send packet
net_debug!("DHCP send DISCOVER to {}: {:?}", ipv4_repr.dst_addr, dhcp_repr);
ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
emit((ipv4_repr, udp_repr, dhcp_repr))?;
// Update state AFTER the packet has been successfully sent.
state.retry_at = now + DISCOVER_TIMEOUT;
self.transaction_id = next_transaction_id;
Ok(())
}
ClientState::Requesting(state) => {
if now < state.retry_at {
return Err(Error::Exhausted)
}
if state.retry >= REQUEST_RETRIES {
net_debug!("DHCP request retries exceeded, restarting discovery");
self.reset();
// return Ok so we get polled again
return Ok(())
}
dhcp_repr.message_type = DhcpMessageType::Request;
dhcp_repr.broadcast = false;
dhcp_repr.requested_ip = Some(state.requested_ip);
dhcp_repr.server_identifier = Some(state.server.identifier);
net_debug!("DHCP send request to {}: {:?}", ipv4_repr.dst_addr, dhcp_repr);
ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
emit((ipv4_repr, udp_repr, dhcp_repr))?;
// Exponential backoff: Double every 2 retries.
state.retry_at = now + (REQUEST_TIMEOUT << (state.retry as u32 / 2));
state.retry += 1;
self.transaction_id = next_transaction_id;
Ok(())
}
ClientState::Renewing(state) => {
if state.expires_at <= now {
net_debug!("DHCP lease expired");
self.reset();
// return Ok so we get polled again
return Ok(())
}
if now < state.renew_at {
return Err(Error::Exhausted)
}
ipv4_repr.src_addr = state.config.address.address();
ipv4_repr.dst_addr = state.server.address;
dhcp_repr.message_type = DhcpMessageType::Request;
dhcp_repr.client_ip = state.config.address.address();
dhcp_repr.broadcast = false;
net_debug!("DHCP send renew to {}: {:?}", ipv4_repr.dst_addr, dhcp_repr);
ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
emit((ipv4_repr, udp_repr, dhcp_repr))?;
// In both RENEWING and REBINDING states, if the client receives no
// response to its DHCPREQUEST message, the client SHOULD wait one-half
// of the remaining time until T2 (in RENEWING state) and one-half of
// the remaining lease time (in REBINDING state), down to a minimum of
// 60 seconds, before retransmitting the DHCPREQUEST message.
state.renew_at = now + MIN_RENEW_TIMEOUT.max((state.expires_at - now) / 2);
self.transaction_id = next_transaction_id;
Ok(())
}
}
}
/// Reset state and restart discovery phase.
///
/// Use this to speed up acquisition of an address in a new
/// network if a link was down and it is now back up.
pub fn reset(&mut self) {
net_trace!("DHCP reset");
if let ClientState::Renewing(_) = &self.state {
self.config_changed = true;
}
self.state = ClientState::Discovering(DiscoverState{
retry_at: Instant::from_millis(0),
});
}
/// Query the socket for configuration changes.
///
/// The socket has an internal "configuration changed" flag. If
/// set, this function returns the configuration and resets the flag.
pub fn poll(&mut self) -> Option<Event<'_>> {
if !self.config_changed {
None
} else if let ClientState::Renewing(state) = &self.state {
self.config_changed = false;
Some(Event::Configured(&state.config))
} else {
self.config_changed = false;
Some(Event::Deconfigured)
}
}
}
impl<'a> Into<Socket<'a>> for Dhcpv4Socket {
fn into(self) -> Socket<'a> {
Socket::Dhcpv4(self)
}
}

29
src/socket/icmp.rs
View File

@ -94,12 +94,12 @@ impl<'a> IcmpSocket<'a> {
///
/// The waker is woken on state changes that might affect the return value
/// of `recv` method calls, such as receiving data, or the socket closing.
///
///
/// Notes:
///
/// - Only one waker can be registered at a time. If another waker was previously registered,
/// it is overwritten and will no longer be woken.
/// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
/// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
/// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `recv` has
/// necessarily changed.
#[cfg(feature = "async")]
@ -112,12 +112,12 @@ impl<'a> IcmpSocket<'a> {
/// The waker is woken on state changes that might affect the return value
/// of `send` method calls, such as space becoming available in the transmit
/// buffer, or the socket closing.
///
///
/// Notes:
///
/// - Only one waker can be registered at a time. If another waker was previously registered,
/// it is overwritten and will no longer be woken.
/// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
/// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
/// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `send` has
/// necessarily changed.
#[cfg(feature = "async")]
@ -440,7 +440,7 @@ impl<'a> IcmpSocket<'a> {
_ => Err(Error::Unaddressable)
}
})?;
#[cfg(feature = "async")]
self.tx_waker.wake();
@ -482,8 +482,9 @@ mod tests_common {
pub static UDP_REPR: UdpRepr = UdpRepr {
src_port: 53,
dst_port: 9090,
payload: &[0xff; 10]
};
pub static UDP_PAYLOAD: &[u8] = &[0xff; 10];
}
#[cfg(all(test, feature = "proto-ipv4"))]
@ -644,7 +645,13 @@ mod test_ipv4 {
let mut bytes = [0xff; 18];
let mut packet = UdpPacket::new_unchecked(&mut bytes);
UDP_REPR.emit(&mut packet, &REMOTE_IPV4.into(), &LOCAL_IPV4.into(), &checksum);
UDP_REPR.emit(
&mut packet,
&REMOTE_IPV4.into(),
&LOCAL_IPV4.into(),
UDP_PAYLOAD.len(),
|buf| buf.copy_from_slice(UDP_PAYLOAD),
&checksum);
let data = &packet.into_inner()[..];
@ -843,7 +850,13 @@ mod test_ipv6 {
let mut bytes = [0xff; 18];
let mut packet = UdpPacket::new_unchecked(&mut bytes);
UDP_REPR.emit(&mut packet, &REMOTE_IPV6.into(), &LOCAL_IPV6.into(), &checksum);
UDP_REPR.emit(
&mut packet,
&REMOTE_IPV6.into(),
&LOCAL_IPV6.into(),
UDP_PAYLOAD.len(),
|buf| buf.copy_from_slice(UDP_PAYLOAD),
&checksum);
let data = &packet.into_inner()[..];

11
src/socket/mod.rs
View File

@ -22,6 +22,8 @@ mod icmp;
mod udp;
#[cfg(feature = "socket-tcp")]
mod tcp;
#[cfg(feature = "socket-dhcpv4")]
mod dhcpv4;
mod set;
mod ref_;
@ -53,6 +55,9 @@ pub use self::tcp::{SocketBuffer as TcpSocketBuffer,
State as TcpState,
TcpSocket};
#[cfg(feature = "socket-dhcpv4")]
pub use self::dhcpv4::{Dhcpv4Socket, Config as Dhcpv4Config, Event as Dhcpv4Event};
pub use self::set::{Set as SocketSet, Item as SocketSetItem, Handle as SocketHandle};
pub use self::set::{Iter as SocketSetIter, IterMut as SocketSetIterMut};
@ -91,6 +96,8 @@ pub enum Socket<'a> {
Udp(UdpSocket<'a>),
#[cfg(feature = "socket-tcp")]
Tcp(TcpSocket<'a>),
#[cfg(feature = "socket-dhcpv4")]
Dhcpv4(Dhcpv4Socket),
}
macro_rules! dispatch_socket {
@ -110,6 +117,8 @@ macro_rules! dispatch_socket {
&$( $mut_ )* Socket::Udp(ref $( $mut_ )* $socket) => $code,
#[cfg(feature = "socket-tcp")]
&$( $mut_ )* Socket::Tcp(ref $( $mut_ )* $socket) => $code,
#[cfg(feature = "socket-dhcpv4")]
&$( $mut_ )* Socket::Dhcpv4(ref $( $mut_ )* $socket) => $code,
}
};
}
@ -169,3 +178,5 @@ from_socket!(IcmpSocket<'a>, Icmp);
from_socket!(UdpSocket<'a>, Udp);
#[cfg(feature = "socket-tcp")]
from_socket!(TcpSocket<'a>, Tcp);
#[cfg(feature = "socket-dhcpv4")]
from_socket!(Dhcpv4Socket, Dhcpv4);

18
src/socket/ref_.rs
View File

@ -1,13 +1,5 @@
use core::ops::{Deref, DerefMut};
#[cfg(feature = "socket-raw")]
use crate::socket::RawSocket;
#[cfg(all(feature = "socket-icmp", any(feature = "proto-ipv4", feature = "proto-ipv6")))]
use crate::socket::IcmpSocket;
#[cfg(feature = "socket-udp")]
use crate::socket::UdpSocket;
#[cfg(feature = "socket-tcp")]
use crate::socket::TcpSocket;
/// A trait for tracking a socket usage session.
///
@ -20,13 +12,15 @@ pub trait Session {
}
#[cfg(feature = "socket-raw")]
impl<'a> Session for RawSocket<'a> {}
impl<'a> Session for crate::socket::RawSocket<'a> {}
#[cfg(all(feature = "socket-icmp", any(feature = "proto-ipv4", feature = "proto-ipv6")))]
impl<'a> Session for IcmpSocket<'a> {}
impl<'a> Session for crate::socket::IcmpSocket<'a> {}
#[cfg(feature = "socket-udp")]
impl<'a> Session for UdpSocket<'a> {}
impl<'a> Session for crate::socket::UdpSocket<'a> {}
#[cfg(feature = "socket-tcp")]
impl<'a> Session for TcpSocket<'a> {}
impl<'a> Session for crate::socket::TcpSocket<'a> {}
#[cfg(feature = "socket-dhcpv4")]
impl Session for crate::socket::Dhcpv4Socket {}
/// A smart pointer to a socket.
///

3
src/socket/set.rs
View File

@ -156,6 +156,9 @@ impl<'a> Set<'a> {
} else {
socket.close()
},
#[cfg(feature = "socket-dhcpv4")]
Socket::Dhcpv4(_) =>
may_remove = true,
}
}
if may_remove {

46
src/socket/udp.rs
View File

@ -54,12 +54,12 @@ impl<'a> UdpSocket<'a> {
///
/// The waker is woken on state changes that might affect the return value
/// of `recv` method calls, such as receiving data, or the socket closing.
///
///
/// Notes:
///
/// - Only one waker can be registered at a time. If another waker was previously registered,
/// it is overwritten and will no longer be woken.
/// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
/// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
/// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `recv` has
/// necessarily changed.
#[cfg(feature = "async")]
@ -72,12 +72,12 @@ impl<'a> UdpSocket<'a> {
/// The waker is woken on state changes that might affect the return value
/// of `send` method calls, such as space becoming available in the transmit
/// buffer, or the socket closing.
///
///
/// Notes:
///
/// - Only one waker can be registered at a time. If another waker was previously registered,
/// it is overwritten and will no longer be woken.
/// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
/// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
/// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `send` has
/// necessarily changed.
#[cfg(feature = "async")]
@ -277,13 +277,13 @@ impl<'a> UdpSocket<'a> {
true
}
pub(crate) fn process(&mut self, ip_repr: &IpRepr, repr: &UdpRepr) -> Result<()> {
pub(crate) fn process(&mut self, ip_repr: &IpRepr, repr: &UdpRepr, payload: &[u8]) -> Result<()> {
debug_assert!(self.accepts(ip_repr, repr));
let size = repr.payload.len();
let size = payload.len();
let endpoint = IpEndpoint { addr: ip_repr.src_addr(), port: repr.src_port };
self.rx_buffer.enqueue(size, endpoint)?.copy_from_slice(repr.payload);
self.rx_buffer.enqueue(size, endpoint)?.copy_from_slice(payload);
net_trace!("{}:{}:{}: receiving {} octets",
self.meta.handle, self.endpoint,
@ -296,7 +296,7 @@ impl<'a> UdpSocket<'a> {
}
pub(crate) fn dispatch<F>(&mut self, emit: F) -> Result<()>
where F: FnOnce((IpRepr, UdpRepr)) -> Result<()> {
where F: FnOnce((IpRepr, UdpRepr, &[u8])) -> Result<()> {
let handle = self.handle();
let endpoint = self.endpoint;
let hop_limit = self.hop_limit.unwrap_or(64);
@ -309,16 +309,15 @@ impl<'a> UdpSocket<'a> {
let repr = UdpRepr {
src_port: endpoint.port,
dst_port: remote_endpoint.port,
payload: payload_buf,
};
let ip_repr = IpRepr::Unspecified {
src_addr: endpoint.addr,
dst_addr: remote_endpoint.addr,
protocol: IpProtocol::Udp,
payload_len: repr.buffer_len(),
payload_len: repr.header_len() + payload_buf.len(),
hop_limit: hop_limit,
};
emit((ip_repr, repr))
emit((ip_repr, repr, payload_buf))
})?;
#[cfg(feature = "async")]
@ -379,15 +378,15 @@ mod test {
const LOCAL_UDP_REPR: UdpRepr = UdpRepr {
src_port: LOCAL_PORT,
dst_port: REMOTE_PORT,
payload: b"abcdef"
};
const REMOTE_UDP_REPR: UdpRepr = UdpRepr {
src_port: REMOTE_PORT,
dst_port: LOCAL_PORT,
payload: b"abcdef"
};
const PAYLOAD: &[u8] = b"abcdef";
fn remote_ip_repr() -> IpRepr {
match (MOCK_IP_ADDR_2, MOCK_IP_ADDR_1) {
#[cfg(feature = "proto-ipv4")]
@ -457,16 +456,18 @@ mod test {
assert_eq!(socket.send_slice(b"123456", REMOTE_END), Err(Error::Exhausted));
assert!(!socket.can_send());
assert_eq!(socket.dispatch(|(ip_repr, udp_repr)| {
assert_eq!(socket.dispatch(|(ip_repr, udp_repr, payload)| {
assert_eq!(ip_repr, LOCAL_IP_REPR);
assert_eq!(udp_repr, LOCAL_UDP_REPR);
assert_eq!(payload, PAYLOAD);
Err(Error::Unaddressable)
}), Err(Error::Unaddressable));
assert!(!socket.can_send());
assert_eq!(socket.dispatch(|(ip_repr, udp_repr)| {
assert_eq!(socket.dispatch(|(ip_repr, udp_repr, payload)| {
assert_eq!(ip_repr, LOCAL_IP_REPR);
assert_eq!(udp_repr, LOCAL_UDP_REPR);
assert_eq!(payload, PAYLOAD);
Ok(())
}), Ok(()));
assert!(socket.can_send());
@ -481,12 +482,12 @@ mod test {
assert_eq!(socket.recv(), Err(Error::Exhausted));
assert!(socket.accepts(&remote_ip_repr(), &REMOTE_UDP_REPR));
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR),
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
Ok(()));
assert!(socket.can_recv());
assert!(socket.accepts(&remote_ip_repr(), &REMOTE_UDP_REPR));
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR),
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
Err(Error::Exhausted));
assert_eq!(socket.recv(), Ok((&b"abcdef"[..], REMOTE_END)));
assert!(!socket.can_recv());
@ -499,7 +500,7 @@ mod test {
assert_eq!(socket.peek(), Err(Error::Exhausted));
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR),
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
Ok(()));
assert_eq!(socket.peek(), Ok((&b"abcdef"[..], &REMOTE_END)));
assert_eq!(socket.recv(), Ok((&b"abcdef"[..], REMOTE_END)));
@ -512,7 +513,7 @@ mod test {
assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
assert!(socket.accepts(&remote_ip_repr(), &REMOTE_UDP_REPR));
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR),
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
Ok(()));
let mut slice = [0; 4];
@ -525,7 +526,7 @@ mod test {
let mut socket = socket(buffer(1), buffer(0));
assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR),
assert_eq!(socket.process(&remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
Ok(()));
let mut slice = [0; 4];
@ -543,7 +544,7 @@ mod test {
s.set_hop_limit(Some(0x2a));
assert_eq!(s.send_slice(b"abcdef", REMOTE_END), Ok(()));
assert_eq!(s.dispatch(|(ip_repr, _)| {
assert_eq!(s.dispatch(|(ip_repr, _, _)| {
assert_eq!(ip_repr, IpRepr::Unspecified{
src_addr: MOCK_IP_ADDR_1,
dst_addr: MOCK_IP_ADDR_2,
@ -619,9 +620,8 @@ mod test {
let repr = UdpRepr {
src_port: REMOTE_PORT,
dst_port: LOCAL_PORT,
payload: &[]
};
assert_eq!(socket.process(&remote_ip_repr(), &repr), Ok(()));
assert_eq!(socket.process(&remote_ip_repr(), &repr, &[]), Ok(()));
assert_eq!(socket.recv(), Ok((&[][..], REMOTE_END)));
}
}

28
src/time.rs
View File

@ -232,6 +232,34 @@ impl ops::DivAssign<u32> for Duration {
}
}
impl ops::Shl<u32> for Duration {
type Output = Duration;
fn shl(self, rhs: u32) -> Duration {
Duration::from_millis(self.millis << rhs)
}
}
impl ops::ShlAssign<u32> for Duration {
fn shl_assign(&mut self, rhs: u32) {
self.millis <<= rhs;
}
}
impl ops::Shr<u32> for Duration {
type Output = Duration;
fn shr(self, rhs: u32) -> Duration {
Duration::from_millis(self.millis >> rhs)
}
}
impl ops::ShrAssign<u32> for Duration {
fn shr_assign(&mut self, rhs: u32) {
self.millis >>= rhs;
}
}
impl From<::core::time::Duration> for Duration {
fn from(other: ::core::time::Duration) -> Duration {
Duration::from_millis(

8
src/wire/dhcpv4.rs
View File

@ -6,6 +6,10 @@ use crate::{Error, Result};
use crate::wire::{EthernetAddress, Ipv4Address};
use crate::wire::arp::Hardware;
pub const SERVER_PORT: u16 = 67;
pub const CLIENT_PORT: u16 = 68;
pub const MAX_DNS_SERVER_COUNT: usize = 3;
const DHCP_MAGIC_NUMBER: u32 = 0x63825363;
enum_with_unknown! {
@ -683,7 +687,7 @@ pub struct Repr<'a> {
/// the client is interested in.
pub parameter_request_list: Option<&'a [u8]>,
/// DNS servers
pub dns_servers: Option<[Option<Ipv4Address>; 3]>,
pub dns_servers: Option<[Option<Ipv4Address>; MAX_DNS_SERVER_COUNT]>,
/// The maximum size dhcp packet the interface can receive
pub max_size: Option<u16>,
/// The DHCP IP lease duration, specified in seconds.
@ -777,7 +781,7 @@ impl<'a> Repr<'a> {
parameter_request_list = Some(data);
}
DhcpOption::Other {kind: field::OPT_DOMAIN_NAME_SERVER, data} => {
let mut servers = [None; 3];
let mut servers = [None; MAX_DNS_SERVER_COUNT];
for (server, chunk) in servers.iter_mut().zip(data.chunks(4)) {
*server = Some(Ipv4Address::from_bytes(chunk));
}

2
src/wire/ip.rs
View File

@ -887,7 +887,7 @@ pub fn pretty_print_ip_payload<T: Into<Repr>>(f: &mut fmt::Formatter, indent: &m
&repr.dst_addr(), &checksum_caps) {
Err(err) => write!(f, "{}{} ({})", indent, udp_packet, err),
Ok(udp_repr) => {
write!(f, "{}{}", indent, udp_repr)?;
write!(f, "{}{} len={}", indent, udp_repr, udp_packet.payload().len())?;
let valid = udp_packet.verify_checksum(&repr.src_addr(),
&repr.dst_addr());
format_checksum(f, valid)

8
src/wire/mod.rs
View File

@ -211,7 +211,8 @@ pub use self::mld::{AddressRecord as MldAddressRecord,
Repr as MldRepr};
pub use self::udp::{Packet as UdpPacket,
Repr as UdpRepr};
Repr as UdpRepr,
HEADER_LEN as UDP_HEADER_LEN};
pub use self::tcp::{SeqNumber as TcpSeqNumber,
Packet as TcpPacket,
@ -222,4 +223,7 @@ pub use self::tcp::{SeqNumber as TcpSeqNumber,
#[cfg(feature = "proto-dhcpv4")]
pub use self::dhcpv4::{Packet as DhcpPacket,
Repr as DhcpRepr,
MessageType as DhcpMessageType};
MessageType as DhcpMessageType,
CLIENT_PORT as DHCP_CLIENT_PORT,
SERVER_PORT as DHCP_SERVER_PORT,
MAX_DNS_SERVER_COUNT as DHCP_MAX_DNS_SERVER_COUNT};

40
src/wire/udp.rs
View File

@ -28,6 +28,8 @@ mod field {
}
}
pub const HEADER_LEN: usize = field::CHECKSUM.end;
#[allow(clippy::len_without_is_empty)]
impl<T: AsRef<[u8]>> Packet<T> {
/// Imbue a raw octet buffer with UDP packet structure.
@ -55,13 +57,13 @@ impl<T: AsRef<[u8]>> Packet<T> {
/// [set_len]: #method.set_len
pub fn check_len(&self) -> Result<()> {
let buffer_len = self.buffer.as_ref().len();
if buffer_len < field::CHECKSUM.end {
if buffer_len < HEADER_LEN {
Err(Error::Truncated)
} else {
let field_len = self.len() as usize;
if buffer_len < field_len {
Err(Error::Truncated)
} else if field_len < field::CHECKSUM.end {
} else if field_len < HEADER_LEN {
Err(Error::Malformed)
} else {
Ok(())
@ -201,16 +203,15 @@ impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
/// A high-level representation of an User Datagram Protocol packet.
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Repr<'a> {
pub struct Repr {
pub src_port: u16,
pub dst_port: u16,
pub payload: &'a [u8]
}
impl<'a> Repr<'a> {
impl Repr {
/// Parse an User Datagram Protocol packet and return a high-level representation.
pub fn parse<T>(packet: &Packet<&'a T>, src_addr: &IpAddress, dst_addr: &IpAddress,
checksum_caps: &ChecksumCapabilities) -> Result<Repr<'a>>
pub fn parse<T>(packet: &Packet<&T>, src_addr: &IpAddress, dst_addr: &IpAddress,
checksum_caps: &ChecksumCapabilities) -> Result<Repr>
where T: AsRef<[u8]> + ?Sized {
// Destination port cannot be omitted (but source port can be).
if packet.dst_port() == 0 { return Err(Error::Malformed) }
@ -230,25 +231,26 @@ impl<'a> Repr<'a> {
Ok(Repr {
src_port: packet.src_port(),
dst_port: packet.dst_port(),
payload: packet.payload()
})
}
/// Return the length of a packet that will be emitted from this high-level representation.
pub fn buffer_len(&self) -> usize {
field::CHECKSUM.end + self.payload.len()
/// Return the length of the packet header that will be emitted from this high-level representation.
pub fn header_len(&self) -> usize {
HEADER_LEN
}
/// Emit a high-level representation into an User Datagram Protocol packet.
pub fn emit<T: ?Sized>(&self, packet: &mut Packet<&mut T>,
src_addr: &IpAddress,
dst_addr: &IpAddress,
payload_len: usize,
emit_payload: impl FnOnce(&mut [u8]),
checksum_caps: &ChecksumCapabilities)
where T: AsRef<[u8]> + AsMut<[u8]> {
packet.set_src_port(self.src_port);
packet.set_dst_port(self.dst_port);
packet.set_len((field::CHECKSUM.end + self.payload.len()) as u16);
packet.payload_mut().copy_from_slice(self.payload);
packet.set_len((HEADER_LEN + payload_len) as u16);
emit_payload(packet.payload_mut());
if checksum_caps.udp.tx() {
packet.fill_checksum(src_addr, dst_addr)
@ -268,10 +270,9 @@ impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
}
}
impl<'a> fmt::Display for Repr<'a> {
impl fmt::Display for Repr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "UDP src={} dst={} len={}",
self.src_port, self.dst_port, self.payload.len())
write!(f, "UDP src={} dst={}", self.src_port, self.dst_port)
}
}
@ -361,11 +362,10 @@ mod test {
}
#[cfg(feature = "proto-ipv4")]
fn packet_repr() -> Repr<'static> {
fn packet_repr() -> Repr {
Repr {
src_port: 48896,
dst_port: 53,
payload: &PAYLOAD_BYTES
}
}
@ -382,9 +382,11 @@ mod test {
#[cfg(feature = "proto-ipv4")]
fn test_emit() {
let repr = packet_repr();
let mut bytes = vec![0xa5; repr.buffer_len()];
let mut bytes = vec![0xa5; repr.header_len() + PAYLOAD_BYTES.len()];
let mut packet = Packet::new_unchecked(&mut bytes);
repr.emit(&mut packet, &SRC_ADDR.into(), &DST_ADDR.into(),
PAYLOAD_BYTES.len(),
|payload| payload.copy_from_slice(&PAYLOAD_BYTES),
&ChecksumCapabilities::default());
assert_eq!(&packet.into_inner()[..], &PACKET_BYTES[..]);
}