syscall: support udp multicast

Signed-off-by: rayylee <[email protected]>

modules/axnet/Cargo.toml

@@ -44,7 +44,7 @@ features = [
   "medium-ethernet",
   "medium-ip",
   "proto-ipv4",
-  "socket-raw", "socket-icmp", "socket-udp", "socket-tcp", "socket-dns",
+  "socket-raw", "socket-icmp", "socket-udp", "socket-tcp", "socket-dns", "proto-igmp",
   # "fragmentation-buffer-size-65536", "proto-ipv4-fragmentation",
   # "reassembly-buffer-size-65536", "reassembly-buffer-count-32",
   # "assembler-max-segment-count-32",

modules/axnet/src/smoltcp_impl/udp.rs

@@ -1,4 +1,5 @@
 use core::net::SocketAddr;
+use core::ops::DerefMut;
 use core::sync::atomic::{AtomicBool, Ordering};
 
 use axerrno::{ax_err, ax_err_type, AxError, AxResult};
@@ -7,6 +8,11 @@ use axio::{PollState, Read, Write};
 use axsync::Mutex;
 use spin::RwLock;
 
+use crate::net_impl::{current_time_nanos, NANOS_PER_MICROS};
+use crate::net_impl::{LOOPBACK, LOOPBACK_DEV};
+use smoltcp::time::Instant;
+use smoltcp::wire::IpAddress as IpAddr;
+
 use smoltcp::iface::SocketHandle;
 use smoltcp::socket::udp::{self, BindError, SendError};
 use smoltcp::wire::{IpEndpoint, IpListenEndpoint};
@@ -190,11 +196,11 @@ impl UdpSocket {
 
     /// Close the socket.
     pub fn shutdown(&self) -> AxResult {
+        SOCKET_SET.poll_interfaces();
         SOCKET_SET.with_socket_mut::<udp::Socket, _, _>(self.handle, |socket| {
             debug!("UDP socket {}: shutting down", self.handle);
             socket.close();
         });
-        SOCKET_SET.poll_interfaces();
         Ok(())
     }
 
@@ -213,6 +219,21 @@ impl UdpSocket {
             })
         })
     }
+
+    pub fn set_socket_ttl(&self, ttl: u8) {
+        SOCKET_SET.with_socket_mut::<udp::Socket, _, _>(self.handle, |socket| {
+            socket.set_hop_limit(Some(ttl))
+        });
+    }
+
+    pub fn add_membership(&self, multicast_addr: IpAddr, interface_addr: IpAddr) {
+        let timestamp = Instant::from_micros_const((current_time_nanos() / NANOS_PER_MICROS) as i64);
+        error!(
+            ">>> setsockopt IP_ADD_MEMBERSHIP: multiaddr: {}, interfaceaddr: {}",
+            multicast_addr, interface_addr
+        );
+        let _ = LOOPBACK.lock().join_multicast_group(LOOPBACK_DEV.lock().deref_mut(), multicast_addr, timestamp);
+    }
 }
 
 /// Private methods

ulib/axstarry/src/syscall_fs/imp/io.rs

@@ -418,9 +418,6 @@ pub fn syscall_open(args: [usize; 6]) -> SyscallResult {
 pub fn syscall_close(args: [usize; 6]) -> SyscallResult {
     let fd = args[0];
     info!("Into syscall_close. fd: {}", fd);
-
-    error!(">>> Into syscall_close. fd: {}", fd);
-
     let process = current_process();
     let mut fd_table = process.fd_manager.fd_table.lock();
     if fd >= fd_table.len() {

ulib/axstarry/src/syscall_net/imp.rs

@@ -322,10 +322,18 @@ pub fn syscall_sendto(args: [usize; 6]) -> SyscallResult {
     } else {
         None
     };
+
     let inner = socket.inner.lock();
     let send_result = match &*inner {
         SocketInner::Udp(s) => {
-            error!(">>> udp sendto ");
+            error!(">>>- pid:{} udp sendto ({}) ", curr.pid(), buf.len());
+            let valid_utf8_strings = extract_valid_utf8(&buf);
+            for s in valid_utf8_strings {
+                if s.len() > 0 {
+                    error!(">>>- pid:{} udp sendto: {}", curr.pid(), s);
+                }
+            }
+
             // udp socket not bound
             if s.local_addr().is_err() {
                 s.bind(into_core_sockaddr(SocketAddr::new_ipv4(
@@ -431,6 +439,7 @@ pub fn syscall_recvfrom(args: [usize; 6]) -> SyscallResult {
     }
     let buf = unsafe { from_raw_parts_mut(buf, len) };
     info!("recv addr: {:?}", socket.name().unwrap());
+
     match socket.recv_from(buf) {
         Ok((len, addr)) => {
             info!("socket {fd} recv {len} bytes from {addr:?}");
@@ -483,15 +492,21 @@ pub fn syscall_set_sock_opt(args: [usize; 6]) -> SyscallResult {
     let opt = unsafe { from_raw_parts(opt_value, opt_len as usize) };
 
     match level {
-        SocketOptionLevel::IP => Ok(0),
+        SocketOptionLevel::IP => {
+            let Ok(option) = IpOption::try_from(opt_name) else {
+                warn!("[setsockopt()] option {opt_name} not supported in socket level");
+                return Ok(0);
+            };
+
+            option.set(socket, opt)
+        }
         SocketOptionLevel::Socket => {
             let Ok(option) = SocketOption::try_from(opt_name) else {
                 warn!("[setsockopt()] option {opt_name} not supported in socket level");
                 return Ok(0);
             };
 
-            option.set(socket, opt);
-            Ok(0)
+            option.set(socket, opt)
         }
         SocketOptionLevel::Tcp => {
             let Ok(option) = TcpSocketOption::try_from(opt_name) else {