DHCP server bugfixing and logging

src/asynch/dhcp.rs

@@ -87,8 +87,8 @@ pub trait Socket {
 pub struct RawSocketFactory<R> {
     stack: R,
     interface: Option<u32>,
-    client_port: Option<u16>,
-    server_port: Option<u16>,
+    local_port: Option<u16>,
+    remote_port: Option<u16>,
 }
 
 impl<R> RawSocketFactory<R>
@@ -98,18 +98,18 @@ where
     pub const fn new(
         stack: R,
         interface: Option<u32>,
-        client_port: Option<u16>,
-        server_port: Option<u16>,
+        local_port: Option<u16>,
+        remote_port: Option<u16>,
     ) -> Self {
-        if client_port.is_none() && server_port.is_none() {
-            panic!("Either the client, or the sererver port, or both should be specified");
+        if local_port.is_none() && remote_port.is_none() {
+            panic!("Either the local, or the remote port, or both should be specified");
         }
 
         Self {
             stack,
             interface,
-            client_port,
-            server_port,
+            local_port,
+            remote_port,
         }
     }
 }
@@ -123,7 +123,7 @@ where
     type Socket = R::Socket;
 
     fn raw_ports(&self) -> (Option<u16>, Option<u16>) {
-        (self.client_port, self.server_port)
+        (self.local_port, self.remote_port)
     }
 
     async fn connect(&self) -> Result<Self::Socket, Self::Error> {
@@ -501,6 +501,8 @@ pub mod server {
 
     use embedded_nal_async::Ipv4Addr;
 
+    use log::info;
+
     pub use super::*;
 
     #[derive(Clone, Debug)]
@@ -525,6 +527,8 @@ pub mod server {
 
     impl<const N: usize> Server<N> {
         pub fn new(conf: &Configuration) -> Self {
+            info!("Creating DHCP server with configuration {conf:?}");
+
             Self {
                 server: dhcp::server::Server {
                     ip: conf.ip,
@@ -555,7 +559,7 @@ pub mod server {
 
                 if let Some(reply) = self
                     .server
-                    .handle_bootp_request(f.raw_ports().1, buf, len)?
+                    .handle_bootp_request(f.raw_ports().0, buf, len)?
                 {
                     socket.send(reply).await.map_err(Error::Io)?;
                 }

src/asynch/stdnal.rs

@@ -7,6 +7,7 @@ use futures_lite::io::{AsyncReadExt, AsyncWriteExt};
 
 use embedded_io::ErrorType;
 use embedded_io_async::{Read, Write};
+use log::warn;
 use no_std_net::{Ipv4Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 
 use embedded_nal_async::{
@@ -165,6 +166,8 @@ impl UdpStack for StdUdpStack {
     ) -> Result<(SocketAddr, Self::UniquelyBound), Self::Error> {
         let socket = Async::<UdpSocket>::bind(to_std_addr(local))?;
 
+        socket.as_ref().set_broadcast(true)?;
+
         Ok((
             to_nal_addr(socket.as_ref().local_addr()?),
             StdUdpSocket(socket),
@@ -359,11 +362,15 @@ impl UnconnectedUdp for StdUdpSocket {
     async fn send(
         &mut self,
         local: SocketAddr,
-        remote: SocketAddr,
+        mut remote: SocketAddr,
         data: &[u8],
     ) -> Result<(), Self::Error> {
         assert!(local == to_nal_addr(self.0.as_ref().local_addr()?));
 
+        remote = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::BROADCAST, 68));
+
+        warn!("Send to: {remote}");
+
         let mut offset = 0;
 
         loop {
@@ -383,6 +390,8 @@ impl UnconnectedUdp for StdUdpSocket {
     ) -> Result<(usize, SocketAddr, SocketAddr), Self::Error> {
         let (len, addr) = self.0.recv_from(buffer).await?;
 
+        warn!("Received from: {addr}");
+
         Ok((
             len,
             to_nal_addr(self.0.as_ref().local_addr()?),

src/dhcp.rs

@@ -462,9 +462,8 @@ impl<'a> Options<'a> {
                         let option = match *code {
                             DhcpOption::CODE_ROUTER => (!gateways.is_empty())
                                 .then_some(DhcpOption::Router(Ipv4Addrs::new(gateways))),
-                            DhcpOption::CODE_DNS => {
-                                (!dns.is_empty()).then_some(DhcpOption::Router(Ipv4Addrs::new(dns)))
-                            }
+                            DhcpOption::CODE_DNS => (!dns.is_empty())
+                                .then_some(DhcpOption::DomainNameServer(Ipv4Addrs::new(dns))),
                             DhcpOption::CODE_SUBNET => subnet.map(DhcpOption::SubnetMask),
                             _ => None,
                         };
@@ -959,6 +958,8 @@ pub mod server {
 
     use embassy_time::{Duration, Instant};
 
+    use log::{info, trace};
+
     use super::*;
 
     #[derive(Clone, Debug)]
@@ -1000,6 +1001,8 @@ pub mod server {
             };
 
             if let Some((raw_hdrs, request)) = request {
+                trace!("Got packet {request:?}");
+
                 if !request.reply {
                     let mt = request.options.iter().find_map(|option| {
                         if let DhcpOption::MessageType(mt) = option {
@@ -1021,6 +1024,8 @@ pub mod server {
                         if server_identifier == Some(self.ip)
                             || server_identifier.is_none() && matches!(mt, MessageType::Discover)
                         {
+                            info!("Packet is for us, will process, message type {mt:?}");
+
                             let mut opt_buf = Options::buf();
 
                             let reply = match mt {
@@ -1124,7 +1129,7 @@ pub mod server {
             ip: Option<Ipv4Addr>,
             buf: &'a mut [DhcpOption<'a>],
         ) -> Packet<'a> {
-            request.new_reply(
+            let reply = request.new_reply(
                 ip,
                 request.options.reply(
                     mt,
@@ -1135,7 +1140,11 @@ pub mod server {
                     &self.dns,
                     buf,
                 ),
-            )
+            );
+
+            info!("Reply: {reply:?}");
+
+            reply
         }
 
         fn is_available(&self, mac: &[u8; 16], addr: Ipv4Addr) -> bool {