Merge pull request #24 from reflyable/udp+dns

equation314 · web-flow · commit 6e419682f647 · 2023-04-22T16:28:59.000+08:00
Add udp and dns support 添加udp和dns支持
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -8,6 +8,7 @@ members = [
     "apps/fs/shell",
     "apps/net/echoserver",
     "apps/net/httpclient",
+    "apps/net/udpserver",
     "apps/net/httpserver",
     "apps/task/parallel",
     "apps/task/sleep",
diff --git a/README.md b/README.md
@@ -17,7 +17,7 @@ ArceOS was inspired a lot by [Unikraft](https://github.com/unikraft/unikraft).
 * [x] Multi-thread
 * [x] Cooperative/preemptive scheduler
 * [x] VirtIO net/blk/gpu drivers
-* [x] TCP net stack using [smoltcp](https://github.com/smoltcp-rs/smoltcp)
+* [x] TCP/UDP net stack using [smoltcp](https://github.com/smoltcp-rs/smoltcp)
 * [x] Synchronization/Mutex
 * [x] SMP scheduling with single run queue
 * [x] File system
diff --git a/apps/net/httpclient/Cargo.toml b/apps/net/httpclient/Cargo.toml
@@ -2,9 +2,12 @@
 name = "arceos-httpclient"
 version = "0.1.0"
 edition = "2021"
-authors = ["Yuekai Jia <equation618@gmail.com>"]
-
+authors = ["Yuekai Jia <equation618@gmail.com>", "Dashuai Wu <wudashuaijss@foxmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 libax = { path = "../../../ulib/libax", features = ["paging", "net"] }
+
+[features]
+default = []
+dns = []
diff --git a/apps/net/httpclient/expect_info.out b/apps/net/httpclient/expect_info.out
@@ -25,6 +25,8 @@ created net interface "eth0":
 Initialize interrupt handlers...
 Primary CPU 0 init OK.
 Hello, simple http client!
+IP:
+
 HTTP/1.1 200 OK
 Server: nginx
 Date:
@@ -33,5 +35,6 @@ Content-Length:
 Connection: keep-alive
 Access-Control-Allow-Origin: *
 Cache-Control: no-cache, no-store, must-revalidate
+
 ^[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+
 Shutting down...
diff --git a/apps/net/httpclient/expect_info_dns.out b/apps/net/httpclient/expect_info_dns.out
@@ -0,0 +1,40 @@
+smp = 1
+build_mode = release
+log_level = info
+
+Primary CPU 0 started,
+Found physcial memory regions:
+ .text (READ | EXECUTE | RESERVED)
+ .rodata (READ | RESERVED)
+ .data (READ | WRITE | RESERVED)
+ .percpu (READ | WRITE | RESERVED)
+ boot stack (READ | WRITE | RESERVED)
+ .bss (READ | WRITE | RESERVED)
+ free memory (READ | WRITE | FREE)
+Initialize global memory allocator...
+Initialize kernel page table...
+Initialize device drivers...
+created a new Net device: "virtio-net"
+Initialize network subsystem...
+number of NICs: 1
+  NIC 0: "virtio-net"
+created net interface "eth0":
+  ether:    52-54-00-12-34-56
+  ip:       10.0.2.15/24
+  gateway:  10.0.2.2
+Initialize interrupt handlers...
+Primary CPU 0 init OK.
+Hello, simple http client!
+ident.me IP:
+
+HTTP/1.1 200 OK
+Server: nginx
+Date:
+Content-Type: text/plain
+Content-Length:
+Connection: keep-alive
+Access-Control-Allow-Origin: *
+Cache-Control: no-cache, no-store, must-revalidate
+
+^[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+
+Shutting down...
diff --git a/apps/net/httpclient/src/main.rs b/apps/net/httpclient/src/main.rs
@@ -4,28 +4,39 @@
 #[macro_use]
 extern crate libax;
 
-use core::str::FromStr;
+extern crate alloc;
 
+use alloc::vec::Vec;
 use libax::io::{self, prelude::*};
-use libax::net::{IpAddr, TcpStream};
+use libax::net::{SocketAddr, TcpStream, ToSocketAddrs};
 
-const DEST_IP: &str = "49.12.234.183"; // ident.me
+const DEST_HOST: &str = "ident.me";
+const DEST_IP: &str = "49.12.234.183";
 const REQUEST: &str = "\
 GET / HTTP/1.1\r\n\
 Host: ident.me\r\n\
 Accept: */*\r\n\
 \r\n";
 
+fn get_addr() -> SocketAddr {
+    let dest = if cfg!(feature = "dns") {
+        print!("{} ", DEST_HOST);
+        DEST_HOST
+    } else {
+        DEST_IP
+    };
+    let addr_iter = (dest, 80).to_socket_addrs().unwrap().collect::<Vec<_>>();
+    println!("IP:{}\n", addr_iter[0].addr);
+    addr_iter[0]
+}
+
 fn client() -> io::Result {
-    let (addr, port) = (IpAddr::from_str(DEST_IP).unwrap(), 80);
-    let mut stream = TcpStream::connect((addr, port).into())?;
+    let mut stream = TcpStream::connect(get_addr())?;
     stream.write(REQUEST.as_bytes())?;
-
-    let mut buf = [0; 1024];
+    let mut buf = [0; 2048];
     let n = stream.read(&mut buf)?;
     let response = core::str::from_utf8(&buf[..n]).unwrap();
-    println!("{}", response);
-
+    println!("{}", response); // longer response need to handle tcp package problems.
     Ok(())
 }
 
diff --git a/apps/net/httpclient/test_cmd b/apps/net/httpclient/test_cmd
@@ -1 +1,2 @@
 test_one "LOG=info NET=y" "expect_info.out"
+test_one "LOG=info NET=y APP_FEATURES=dns" "expect_info_dns.out"
diff --git a/apps/net/udpserver/Cargo.toml b/apps/net/udpserver/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "arceos-udpserver"
+version = "0.1.0"
+edition = "2021"
+authors = ["Dashuai Wu <wudashuaijss@foxmail.com>"]
+
+[dependencies]
+libax = { path = "../../../ulib/libax", features = ["paging", "multitask", "net"] }
diff --git a/apps/net/udpserver/src/main.rs b/apps/net/udpserver/src/main.rs
@@ -0,0 +1,40 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate libax;
+extern crate alloc;
+
+use core::str::FromStr;
+
+use libax::io;
+use libax::net::{IpAddr, UdpSocket};
+
+const LOCAL_IP: &str = "10.0.2.15";
+const LOCAL_PORT: u16 = 5555;
+
+fn receive_loop() -> io::Result {
+    let (addr, port) = (IpAddr::from_str(LOCAL_IP).unwrap(), LOCAL_PORT);
+    let socket = UdpSocket::bind((addr, port).into())?;
+    println!("listen on: {}", socket.local_addr().unwrap());
+    let mut buf = [0u8; 1024];
+    loop {
+        match socket.recv_from(&mut buf) {
+            Ok((size, addr)) => {
+                println!("recv: {}Bytes from {}", size, addr);
+                let mid = core::str::from_utf8(&buf).unwrap();
+                println!("{}", mid);
+                let mid = ["response_", mid].join("");
+                socket.send_to(mid.as_bytes(), addr)?;
+                buf = [0u8; 1024];
+            }
+            Err(e) => return Err(e),
+        };
+    }
+}
+
+#[no_mangle]
+fn main() {
+    println!("Hello, simple udp client!");
+    receive_loop().expect("test udp client failed");
+}
diff --git a/crates/memory_addr/src/lib.rs b/crates/memory_addr/src/lib.rs
@@ -223,7 +223,7 @@ impl VirtAddr {
         align_offset(self.0, align.into())
     }
 
-    ///Checks whether the address has the demanded alignment.
+    /// Checks whether the address has the demanded alignment.
     ///
     /// See the [`is_aligned`] function for more information.
     #[inline]
diff --git a/modules/axnet/Cargo.toml b/modules/axnet/Cargo.toml
@@ -31,5 +31,5 @@ features = [
   "alloc", "log",   # no std
   "medium-ethernet",
   "proto-ipv4",
-  "socket-raw", "socket-icmp", "socket-udp", "socket-tcp",
+  "socket-raw", "socket-icmp", "socket-udp", "socket-tcp", "socket-dns"
 ]
diff --git a/modules/axnet/src/lib.rs b/modules/axnet/src/lib.rs
@@ -1,14 +1,16 @@
 //! [ArceOS](https://github.com/rcore-os/arceos) network module.
 //!
-//! It provides unified networking primitives for TCP (UDP is WIP) communication
+//! It provides unified networking primitives for TCP/UDP communication
 //! using various underlying network stacks. Currently, only [smoltcp] is
 //! supported.
 //!
 //! # Organization
 //!
 //! - [`TcpSocket`]: A TCP socket that provides POSIX-like APIs.
+//! - [`UdpSocket`]: A UDP socket that provides POSIX-like APIs.
 //! - [`IpAddr`], [`Ipv4Addr`]: IP addresses (either v4 or v6) and IPv4 addresses.
 //! - [`SocketAddr`]: IP address with a port number.
+//! - [`resolve_socket_addr`]: Function for DNS query.
 //!
 //! # Cargo Features
 //!
@@ -31,7 +33,9 @@ cfg_if::cfg_if! {
     }
 }
 
+pub use self::net_impl::resolve_socket_addr;
 pub use self::net_impl::TcpSocket;
+pub use self::net_impl::UdpSocket;
 pub use smoltcp::wire::{IpAddress as IpAddr, IpEndpoint as SocketAddr, Ipv4Address as Ipv4Addr};
 
 use axdriver::NetDevices;
diff --git a/modules/axnet/src/smoltcp_impl/dns.rs b/modules/axnet/src/smoltcp_impl/dns.rs
@@ -0,0 +1,86 @@
+use alloc::vec::Vec;
+use axerrno::{ax_err_type, AxError, AxResult};
+
+use smoltcp::iface::SocketHandle;
+use smoltcp::socket::dns::{self, GetQueryResultError, StartQueryError};
+use smoltcp::wire::{DnsQueryType, IpAddress};
+
+use super::{SocketSetWrapper, ETH0, SOCKET_SET};
+
+/// A DNS socket.
+struct DnsSocket {
+    handle: Option<SocketHandle>,
+}
+
+impl DnsSocket {
+    #[allow(clippy::new_without_default)]
+    /// Creates a new DNS socket.
+    pub fn new() -> Self {
+        let socket = SocketSetWrapper::new_dns_socket();
+        let handle = Some(SOCKET_SET.add(socket));
+        Self { handle }
+    }
+
+    #[allow(dead_code)]
+    /// Update the list of DNS servers, will replace all existing servers.
+    pub fn update_servers(self, servers: &[smoltcp::wire::IpAddress]) {
+        SOCKET_SET.with_socket_mut::<dns::Socket, _, _>(self.handle.unwrap(), |socket| {
+            socket.update_servers(servers)
+        });
+    }
+
+    /// Query a address with given DNS query type.
+    pub fn query(&self, name: &str, query_type: DnsQueryType) -> AxResult<Vec<IpAddress>> {
+        // let local_addr = self.local_addr.unwrap_or_else(f);
+        let handle = self.handle.ok_or_else(|| ax_err_type!(InvalidInput))?;
+        let iface = &ETH0.iface;
+        let query_handle = SOCKET_SET
+            .with_socket_mut::<dns::Socket, _, _>(handle, |socket| {
+                socket.start_query(iface.lock().context(), name, query_type)
+            })
+            .map_err(|e| match e {
+                StartQueryError::NoFreeSlot => {
+                    ax_err_type!(ResourceBusy, "socket query() failed: no free slot")
+                }
+                StartQueryError::InvalidName => {
+                    ax_err_type!(InvalidInput, "socket query() failed: invalid name")
+                }
+                StartQueryError::NameTooLong => {
+                    ax_err_type!(InvalidInput, "socket query() failed: too long name")
+                }
+            })?;
+        loop {
+            SOCKET_SET.poll_interfaces();
+            match SOCKET_SET.with_socket_mut::<dns::Socket, _, _>(handle, |socket| {
+                socket.get_query_result(query_handle).map_err(|e| match e {
+                    GetQueryResultError::Pending => AxError::Again,
+                    GetQueryResultError::Failed => {
+                        ax_err_type!(ConnectionRefused, "socket query() failed")
+                    }
+                })
+            }) {
+                Ok(n) => {
+                    debug!("here");
+                    SOCKET_SET.poll_interfaces();
+                    return Ok(n.to_vec());
+                }
+                Err(AxError::Again) => axtask::yield_now(),
+                Err(e) => return Err(e),
+            }
+        }
+    }
+}
+
+impl Drop for DnsSocket {
+    fn drop(&mut self) {
+        if let Some(handle) = self.handle {
+            SOCKET_SET.remove(handle);
+        }
+    }
+}
+
+/// Public function for DNS query.
+pub fn resolve_socket_addr(name: &str) -> AxResult<alloc::vec::Vec<IpAddress>> {
+    let socket = DnsSocket::new();
+    socket.query(name, DnsQueryType::A)
+}
diff --git a/modules/axnet/src/smoltcp_impl/mod.rs b/modules/axnet/src/smoltcp_impl/mod.rs
@@ -1,5 +1,7 @@
+mod dns;
 mod listen_table;
 mod tcp;
+mod udp;
 
 use alloc::{collections::VecDeque, vec};
 use core::cell::RefCell;
@@ -18,17 +20,21 @@ use smoltcp::wire::{EthernetAddress, HardwareAddress, IpAddress, IpCidr};
 
 use self::listen_table::ListenTable;
 
+pub use self::dns::resolve_socket_addr;
 pub use self::tcp::TcpSocket;
+pub use self::udp::UdpSocket;
 
 const IP: IpAddress = IpAddress::v4(10, 0, 2, 15); // QEMU user networking default IP
 const GATEWAY: IpAddress = IpAddress::v4(10, 0, 2, 2); // QEMU user networking gateway
+const DNS_SEVER: IpAddress = IpAddress::v4(8, 8, 8, 8);
 const IP_PREFIX: u8 = 24;
 
 const RANDOM_SEED: u64 = 0xA2CE_05A2_CE05_A2CE;
 
 const TCP_RX_BUF_LEN: usize = 4096;
 const TCP_TX_BUF_LEN: usize = 4096;
-
+const UDP_RX_BUF_LEN: usize = 4096;
+const UDP_TX_BUF_LEN: usize = 4096;
 const RX_BUF_QUEUE_SIZE: usize = 64;
 const LISTEN_QUEUE_SIZE: usize = 512;
 
@@ -61,6 +67,22 @@ impl<'a> SocketSetWrapper<'a> {
         socket::tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer)
     }
 
+    pub fn new_udp_socket() -> socket::udp::Socket<'a> {
+        let udp_rx_buffer = socket::udp::PacketBuffer::new(
+            vec![socket::udp::PacketMetadata::EMPTY; 8],
+            vec![0; UDP_RX_BUF_LEN],
+        );
+        let udp_tx_buffer = socket::udp::PacketBuffer::new(
+            vec![socket::udp::PacketMetadata::EMPTY; 8],
+            vec![0; UDP_TX_BUF_LEN],
+        );
+        socket::udp::Socket::new(udp_rx_buffer, udp_tx_buffer)
+    }
+
+    pub fn new_dns_socket() -> socket::dns::Socket<'a> {
+        socket::dns::Socket::new(&[DNS_SEVER], vec![])
+    }
+
     pub fn add<T: AnySocket<'a>>(&self, socket: T) -> SocketHandle {
         let handle = self.0.lock().add(socket);
         debug!("socket {}: created", handle);
diff --git a/modules/axnet/src/smoltcp_impl/udp.rs b/modules/axnet/src/smoltcp_impl/udp.rs
diff --git a/scripts/make/qemu.mk b/scripts/make/qemu.mk
diff --git a/ulib/libax/src/net/mod.rs b/ulib/libax/src/net/mod.rs
diff --git a/ulib/libax/src/net/socket_addr.rs b/ulib/libax/src/net/socket_addr.rs
diff --git a/ulib/libax/src/net/udp.rs b/ulib/libax/src/net/udp.rs

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`	`1`	`test_one "LOG=info NET=y" "expect_info.out"`
	`2`	`+test_one "LOG=info NET=y APP_FEATURES=dns" "expect_info_dns.out"`