Fix examples

Cargo.toml

@@ -13,6 +13,7 @@ rust-version = "1.75"
 
 [patch.crates-io]
 embedded-svc = { git = "https://github.com/esp-rs/embedded-svc", branch = "rust-stable" }
+std-embedded-nal-async = { git = "https://gitlab.com/ivmarkov/std-embedded-nal" }
 
 [features]
 default = ["io"]
@@ -33,24 +34,29 @@ edge-std-nal-async = { workspace = true, optional = true }
 embedded-nal-async-xtra = { workspace = true, optional = true }
 
 [dev-dependencies]
+log = "0.4"
 anyhow = "1"
-simple_logger = "2.2"
+env_logger = "0.10"
+embedded-io-async = "0.6"
+embedded-nal-async = "0.7"
+std-embedded-nal-async = "0.1"
+futures-lite = "1"
 
 [[example]]
 name = "captive_portal"
-required-features = ["std", "domain"]
+required-features = ["io", "std"]
 
 [[example]]
 name = "simple"
-required-features = ["std"]
+required-features = ["io", "std"]
 
 [[example]]
 name = "http_client"
-required-features = ["std"]
+required-features = ["io", "std"]
 
 [[example]]
 name = "http_server"
-required-features = ["std"]
+required-features = ["io", "std", "turnoff"]
 
 [workspace]
 members = [

examples/captive_portal.rs

@@ -1,8 +1,32 @@
-use edge_net::captive::{DnsConf, DnsServer};
+use core::time::Duration;
+
+use edge_net::captive::io::run;
+
+use embedded_nal_async::{IpAddr, Ipv4Addr, SocketAddr};
+
+use std_embedded_nal_async::Stack;
+
+use log::*;
+
 fn main() {
-    let mut dns_conf = DnsConf::new("192.168.71.1".parse().unwrap());
-    dns_conf.bind_port = 1053;
-    let mut dns_server = DnsServer::new(dns_conf);
-    dns_server.start().unwrap();
-    loop {}
+    env_logger::init_from_env(
+        env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
+    );
+
+    let stack: Stack = Default::default();
+
+    let mut tx_buf = [0; 1500];
+    let mut rx_buf = [0; 1500];
+
+    info!("Running Captive Portal DNS on UDP port 8853...");
+
+    futures_lite::future::block_on(run(
+        &stack,
+        SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 8853), // Can't use DEFAULT_SOCKET because it uses DNS port 53 which needs root
+        &mut tx_buf,
+        &mut rx_buf,
+        Ipv4Addr::new(192, 168, 0, 1),
+        Duration::from_secs(60),
+    ))
+    .unwrap();
 }

examples/http_client.rs

@@ -1,30 +1,37 @@
-use std::error::Error;
-
-use async_io::block_on;
 use embedded_io_async::Read;
-use embedded_nal_async::TcpConnect;
+use embedded_nal_async::{AddrType, Dns, SocketAddr, TcpConnect};
+
+use edge_net::http::io::{client::ClientConnection, Error};
+use edge_net::http::Method;
+
+use std_embedded_nal_async::Stack;
 
-use edge_net::asynch::http::client::ClientConnection;
-use edge_net::asynch::http::Method;
-use edge_net::asynch::stdnal::StdTcpConnect;
+use log::*;
 
 fn main() {
-    simple_logger::SimpleLogger::new().env().init().unwrap();
+    env_logger::init_from_env(
+        env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
+    );
+
+    let stack: Stack = Default::default();
 
-    block_on(read()).unwrap();
+    futures_lite::future::block_on(read(&stack)).unwrap();
 }
 
-async fn read() -> anyhow::Result<()> {
+async fn read<T: TcpConnect + Dns>(stack: &T) -> Result<(), Error<<T as TcpConnect>::Error>>
+where
+    <T as Dns>::Error: Into<<T as TcpConnect>::Error>,
+{
     println!("About to open an HTTP connection to httpbin.org port 80");
 
-    let connector = StdTcpConnect::new();
+    let ip = stack
+        .get_host_by_name("httpbin.org", AddrType::IPv4)
+        .await
+        .map_err(|e| Error::Io(e.into()))?;
+
     let mut buf = [0_u8; 8192];
 
-    let mut connection = ClientConnection::<1024, _>::new(
-        &mut buf,
-        &connector,
-        "44.194.147.17:80".parse().unwrap(), /*httpbin.org*/
-    );
+    let mut connection = ClientConnection::<1024, _>::new(&mut buf, stack, SocketAddr::new(ip, 80));
 
     for uri in ["/ip", "/headers"] {
         request(&mut connection, uri).await?;
@@ -33,16 +40,12 @@ async fn read() -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn request<'b, const N: usize, T>(
+async fn request<'b, const N: usize, T: TcpConnect>(
     connection: &mut ClientConnection<'b, N, T>,
     uri: &str,
-) -> anyhow::Result<()>
-where
-    T: TcpConnect,
-    T::Error: Error + Send + Sync + 'static,
-{
+) -> Result<(), Error<T::Error>> {
     connection
-        .initiate_request(Method::Get, uri, &[("Host", "34.227.213.82")])
+        .initiate_request(Method::Get, uri, &[("Host", "httpbin.org")])
         .await?;
     connection.initiate_response().await?;
 
@@ -60,11 +63,11 @@ where
         }
     }
 
-    println!(
+    info!(
         "Request to httpbin.org, URI \"{}\" returned:\nBody:\n=================\n{}\n=================\n\n\n\n",
         uri,
         //response.headers(),
-        std::str::from_utf8(&result)?);
+        core::str::from_utf8(&result).unwrap());
 
     Ok(())
 }

examples/http_server.rs

@@ -1,6 +1,3 @@
-#![allow(stable_features)]
-#![feature(async_fn_in_trait)]
-
 use core::future::pending;
 
 use async_io::block_on;
@@ -19,11 +16,9 @@ use embassy_sync::blocking_mutex::raw::RawMutex;
 use embedded_io_async::{Read, Write};
 
 fn main() {
-    simple_logger::SimpleLogger::new()
-        .with_level(LevelFilter::Info)
-        .env()
-        .init()
-        .unwrap();
+    env_logger::init_from_env(
+        env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
+    );
 
     block_on(accept());
 }

examples/simple.rs

@@ -1,19 +1,27 @@
-use async_io::block_on;
 use embedded_io_async::{Read, Write};
-use embedded_nal_async::TcpConnect;
 
-use edge_net::asynch::stdnal::StdTcpConnect;
+use embedded_nal_async::{IpAddr, Ipv4Addr, SocketAddr, TcpConnect};
+
+use log::*;
+
+use std_embedded_nal_async::Stack;
 
 fn main() {
-    block_on(read()).unwrap();
-}
+    env_logger::init_from_env(
+        env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
+    );
 
-async fn read() -> anyhow::Result<()> {
-    println!("About to open a TCP connection to 1.1.1.1 port 80");
+    let stack: Stack = Default::default();
 
-    let connector = StdTcpConnect::new();
+    futures_lite::future::block_on(read(&stack)).unwrap();
+}
+
+async fn read<T: TcpConnect>(stack: &T) -> Result<(), T::Error> {
+    info!("About to open a TCP connection to 1.1.1.1 port 80");
 
-    let mut connection = connector.connect("1.1.1.1:80".parse().unwrap()).await?;
+    let mut connection = stack
+        .connect(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1)), 80))
+        .await?;
 
     connection
         .write_all("GET / HTTP/1.0\n\n".as_bytes())
@@ -33,9 +41,9 @@ async fn read() -> anyhow::Result<()> {
         }
     }
 
-    println!(
+    info!(
         "1.1.1.1 returned:\n=================\n{}\n=================\nSince it returned something, all seems OK!",
-        std::str::from_utf8(&result)?);
+        core::str::from_utf8(&result).unwrap());
 
     Ok(())
 }