refactor: move sntp to network module

Software/MainBoard/rust/src/network.rs

@@ -1,17 +1,133 @@
+use crate::bail;
+use crate::fat_error::{ContextExt, FatError, FatResult};
 use alloc::string::String;
 use chrono::{DateTime, Utc};
-use core::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+use core::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
+use embassy_net::dns::DnsQueryType;
+use embassy_net::udp::{PacketMetadata, UdpSocket};
 use embassy_net::{Runner, Stack};
-use embassy_time::{Duration, Timer};
+use embassy_time::{Duration, Timer, WithTimeout};
 use edge_dhcp::{
     io::{self, DEFAULT_SERVER_PORT},
     server::{Server, ServerOptions},
 };
 use edge_nal::UdpBind;
 use edge_nal_embassy::{Udp, UdpBuffers};
+use esp_println::println;
 use esp_radio::wifi::Interface;
-use log::{warn, error};
+use log::{info, warn, error};
 use serde::Serialize;
+use sntpc::{NtpContext, NtpTimestampGenerator, NtpUdpSocket, get_time};
+
+const NTP_SERVER: &str = "pool.ntp.org";
+
+#[derive(Copy, Clone, Default)]
+struct Timestamp {
+    stamp: DateTime<Utc>,
+}
+
+impl NtpTimestampGenerator for Timestamp {
+    fn init(&mut self) {
+        self.stamp = DateTime::default();
+    }
+
+    fn timestamp_sec(&self) -> u64 {
+        self.stamp.timestamp() as u64
+    }
+
+    fn timestamp_subsec_micros(&self) -> u32 {
+        self.stamp.timestamp_subsec_micros()
+    }
+}
+
+struct EmbassyNtpSocket<'a, 'b> {
+    socket: &'a UdpSocket<'b>,
+}
+
+impl<'a, 'b> EmbassyNtpSocket<'a, 'b> {
+    fn new(socket: &'a UdpSocket<'b>) -> Self {
+        Self { socket }
+    }
+}
+
+impl NtpUdpSocket for EmbassyNtpSocket<'_, '_> {
+    async fn send_to(&self, buf: &[u8], addr: SocketAddr) -> sntpc::Result<usize> {
+        self.socket
+            .send_to(buf, addr)
+            .await
+            .map_err(|_| sntpc::Error::Network)?;
+        Ok(buf.len())
+    }
+
+    async fn recv_from(&self, buf: &mut [u8]) -> sntpc::Result<(usize, SocketAddr)> {
+        let (len, metadata) = self
+            .socket
+            .recv_from(buf)
+            .await
+            .map_err(|_| sntpc::Error::Network)?;
+        let addr = match metadata.endpoint.addr {
+            embassy_net::IpAddress::Ipv4(ip) => IpAddr::V4(ip),
+            embassy_net::IpAddress::Ipv6(ip) => IpAddr::V6(ip),
+        };
+        Ok((len, SocketAddr::new(addr, metadata.endpoint.port)))
+    }
+}
+
+pub async fn sntp(max_wait_ms: u32, stack: Stack<'_>) -> FatResult<DateTime<Utc>> {
+    println!("start sntp");
+    let mut rx_meta = [PacketMetadata::EMPTY; 16];
+    let mut rx_buffer = [0; 4096];
+    let mut tx_meta = [PacketMetadata::EMPTY; 16];
+    let mut tx_buffer = [0; 4096];
+
+    let mut socket = UdpSocket::new(
+        stack,
+        &mut rx_meta,
+        &mut rx_buffer,
+        &mut tx_meta,
+        &mut tx_buffer,
+    );
+    socket.bind(123).context("Could not bind UDP socket")?;
+
+    let context = NtpContext::new(Timestamp::default());
+    let ntp_socket = EmbassyNtpSocket::new(&socket);
+
+    let ntp_addrs = stack
+        .dns_query(NTP_SERVER, DnsQueryType::A)
+        .await
+        .context("Failed to resolve DNS")?;
+
+    if ntp_addrs.is_empty() {
+        bail!("No IP addresses found for NTP server");
+    }
+    let ntp = ntp_addrs[0];
+    info!("NTP server: {ntp:?}");
+
+    let mut counter = 0;
+    loop {
+        let addr: IpAddr = ntp.into();
+        let timeout = get_time(SocketAddr::from((addr, 123)), &ntp_socket, context)
+            .with_timeout(Duration::from_millis((max_wait_ms / 10) as u64))
+            .await;
+
+        match timeout {
+            Ok(result) => {
+                let time = result?;
+                info!("Time: {time:?}");
+                return DateTime::from_timestamp(time.seconds as i64, 0)
+                    .context("Could not convert Sntp result");
+            }
+            Err(err) => {
+                warn!("sntp timeout, retry: {err:?}");
+                counter += 1;
+                if counter > 10 {
+                    bail!("Failed to get time from NTP server");
+                }
+                Timer::after(Duration::from_millis(100)).await;
+            }
+        }
+    }
+}
 
 #[derive(Serialize, Debug, PartialEq)]
 pub enum SntpMode {