merge upstream

user/apps/ping/src/ping.rs

@@ -101,7 +101,7 @@ impl Ping {
 
         for i in 0..this.config.count {
             let _this = this.clone();
-            let handle = thread::spawn(move||{
+            let handle = thread::spawn(move || {
                 _this.ping(i).unwrap();
             });
             _send.fetch_add(1, Ordering::SeqCst);

user/apps/test-uevent/src/main.rs

@@ -1,7 +1,7 @@
 use libc::{sockaddr,  recvfrom, bind, sendto, socket, AF_NETLINK, SOCK_DGRAM, getpid, c_void};
 use nix::libc;
 use std::os::unix::io::RawFd;
-use std::{ mem, io};
+use std::{io, mem};
 
 #[repr(C)]
 struct Nlmsghdr {
@@ -33,7 +33,11 @@ fn bind_netlink_socket(sock: RawFd) -> io::Result<()> {
     addr.nl_groups = 1;
 
     let ret = unsafe {
-        bind(sock, &addr as *const _ as *const sockaddr, mem::size_of::<libc::sockaddr_nl>() as u32)
+        bind(
+            sock,
+            &addr as *const _ as *const sockaddr,
+            mem::size_of::<libc::sockaddr_nl>() as u32,
+        )
     };
 
     if ret < 0 {
@@ -90,7 +94,10 @@ fn receive_uevent(sock: RawFd) -> io::Result<String> {
     // 检查套接字文件描述符是否有效
     if sock < 0 {
         println!("Invalid socket file descriptor: {}", sock);
-        return Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid socket file descriptor"));
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "Invalid socket file descriptor",
+        ));
     }
 
     let mut buf = [0u8; 1024];
@@ -100,7 +107,10 @@ fn receive_uevent(sock: RawFd) -> io::Result<String> {
     // 检查缓冲区指针和长度是否有效
     if buf.is_empty() {
         println!("Buffer is empty");
-        return Err(io::Error::new(io::ErrorKind::InvalidInput, "Buffer is empty"));
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "Buffer is empty",
+        ));
     }
     let len = unsafe {
         recvfrom(
@@ -122,13 +132,19 @@ fn receive_uevent(sock: RawFd) -> io::Result<String> {
     let nlmsghdr_size = mem::size_of::<Nlmsghdr>();
     if (len as usize) < nlmsghdr_size {
         println!("Received message is too short");
-        return Err(io::Error::new(io::ErrorKind::InvalidData, "Received message is too short"));
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "Received message is too short",
+        ));
     }
 
     let nlmsghdr = unsafe { &*(buf.as_ptr() as *const Nlmsghdr) };
     if nlmsghdr.nlmsg_len as isize > len {
         println!("Received message is incomplete");
-        return Err(io::Error::new(io::ErrorKind::InvalidData, "Received message is incomplete"));
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "Received message is incomplete",
+        ));
     }
 
     let message_data = &buf[nlmsghdr_size..nlmsghdr.nlmsg_len as usize];

user/apps/test_seqpacket/src/main.rs

@@ -1,8 +1,8 @@
-mod seq_socket;
 mod seq_pair;
+mod seq_socket;
 
-use seq_socket::test_seq_socket;
 use seq_pair::test_seq_pair;
+use seq_socket::test_seq_socket;
 
 fn main() -> Result<(), std::io::Error> {
     if let Err(e) = test_seq_socket() {
@@ -187,4 +187,4 @@ fn main() -> Result<(), std::io::Error> {
 //     let len = socket1.read(&mut buf)?;
 //     println!("sock1 receive: {:?}", String::from_utf8_lossy(&buf[..len]));
 //     Ok(())
-// }
+// }

user/apps/test_seqpacket/src/seq_pair.rs

@@ -1,16 +1,17 @@
 use nix::sys::socket::{socketpair, AddressFamily, SockFlag, SockType};
 use std::fs::File;
-use std::io::{Read, Write,Error};
+use std::io::{Error, Read, Write};
 use std::os::fd::FromRawFd;
 
-pub fn test_seq_pair()->Result<(),Error>{
+pub fn test_seq_pair() -> Result<(), Error> {
     // 创建 socket pair
     let (sock1, sock2) = socketpair(
         AddressFamily::Unix,
         SockType::SeqPacket, // 使用 SeqPacket 类型
         None,                // 协议默认
         SockFlag::empty(),
-    ).expect("Failed to create socket pair");
+    )
+    .expect("Failed to create socket pair");
 
     let mut socket1 = unsafe { File::from_raw_fd(sock1) };
     let mut socket2 = unsafe { File::from_raw_fd(sock2) };
@@ -36,4 +37,4 @@ pub fn test_seq_pair()->Result<(),Error>{
     let len = socket1.read(&mut buf)?;
     println!("sock1 receive: {:?}", String::from_utf8_lossy(&buf[..len]));
     Ok(())
-}
+}

user/apps/test_seqpacket/src/seq_socket.rs

@@ -1,16 +1,14 @@
-
 use libc::*;
-use std::{fs, str};
 use std::ffi::CString;
 use std::io::Error;
 use std::mem;
 use std::os::unix::io::RawFd;
+use std::{fs, str};
 
 const SOCKET_PATH: &str = "/test.seqpacket";
 const MSG1: &str = "Hello, Unix SEQPACKET socket from Client!";
 const MSG2: &str = "Hello, Unix SEQPACKET socket from Server!";
 
-
 fn create_seqpacket_socket() -> Result<RawFd, Error> {
     unsafe {
         let fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
@@ -33,7 +31,12 @@ fn bind_socket(fd: RawFd) -> Result<(), Error> {
             addr.sun_path[i] = byte as i8;
         }
 
-        if bind(fd, &addr as *const _ as *const sockaddr, mem::size_of_val(&addr) as socklen_t) == -1 {
+        if bind(
+            fd,
+            &addr as *const _ as *const sockaddr,
+            mem::size_of_val(&addr) as socklen_t,
+        ) == -1
+        {
             return Err(Error::last_os_error());
         }
     }
@@ -68,7 +71,13 @@ fn accept_connection(fd: RawFd) -> Result<RawFd, Error> {
 fn send_message(fd: RawFd, msg: &str) -> Result<(), Error> {
     unsafe {
         let msg_bytes = msg.as_bytes();
-        if send(fd, msg_bytes.as_ptr() as *const libc::c_void, msg_bytes.len(), 0) == -1 {
+        if send(
+            fd,
+            msg_bytes.as_ptr() as *const libc::c_void,
+            msg_bytes.len(),
+            0,
+        ) == -1
+        {
             return Err(Error::last_os_error());
         }
     }
@@ -78,7 +87,12 @@ fn send_message(fd: RawFd, msg: &str) -> Result<(), Error> {
 fn receive_message(fd: RawFd) -> Result<String, Error> {
     let mut buffer = [0; 1024];
     unsafe {
-        let len = recv(fd, buffer.as_mut_ptr() as *mut libc::c_void, buffer.len(), 0);
+        let len = recv(
+            fd,
+            buffer.as_mut_ptr() as *mut libc::c_void,
+            buffer.len(),
+            0,
+        );
         if len == -1 {
             return Err(Error::last_os_error());
         }
@@ -86,70 +100,82 @@ fn receive_message(fd: RawFd) -> Result<String, Error> {
     }
 }
 
-pub fn test_seq_socket() ->Result<(), Error>{
-        // Create and bind the server socket
-        fs::remove_file(&SOCKET_PATH).ok();
+pub fn test_seq_socket() -> Result<(), Error> {
+    // Create and bind the server socket
+    fs::remove_file(&SOCKET_PATH).ok();
 
-        let server_fd = create_seqpacket_socket()?;
-        bind_socket(server_fd)?;
-        listen_socket(server_fd)?;
+    let server_fd = create_seqpacket_socket()?;
+    bind_socket(server_fd)?;
+    listen_socket(server_fd)?;
 
-        // Accept connection in a separate thread
-        let server_thread = std::thread::spawn(move || {
-            let client_fd = accept_connection(server_fd).expect("Failed to accept connection");
-    
-            // Receive and print message
-            let received_msg = receive_message(client_fd).expect("Failed to receive message");
-            println!("Server: Received message: {}", received_msg);
-            
-            send_message(client_fd, MSG2).expect("Failed to send message");
-    
-            // Close client connection
-            unsafe { close(client_fd) };
-        });
-    
-        // Create and connect the client socket
-        let client_fd = create_seqpacket_socket()?;
-        unsafe {
-            let mut addr = sockaddr_un {
-                sun_family: AF_UNIX as u16,
-                sun_path: [0; 108],
-            };
-            let path_cstr = CString::new(SOCKET_PATH).unwrap();
-            let path_bytes = path_cstr.as_bytes();
-            // Convert u8 to i8
-            for (i, &byte) in path_bytes.iter().enumerate() {
-                addr.sun_path[i] = byte as i8;
-            }
-            if connect(client_fd, &addr as *const _ as *const sockaddr, mem::size_of_val(&addr) as socklen_t) == -1 {
-                return Err(Error::last_os_error());
-            }
-        }
-        send_message(client_fd, MSG1)?;
+    // Accept connection in a separate thread
+    let server_thread = std::thread::spawn(move || {
+        let client_fd = accept_connection(server_fd).expect("Failed to accept connection");
+
+        // Receive and print message
         let received_msg = receive_message(client_fd).expect("Failed to receive message");
-        println!("Client: Received message: {}", received_msg);
-        // get peer_name
-        unsafe {
-            let mut addrss = sockaddr_un {
-                sun_family: AF_UNIX as u16,
-                sun_path: [0; 108],
-            };
-            let mut len = mem::size_of_val(&addrss) as socklen_t;
-            let res = getpeername(client_fd, &mut addrss as *mut _ as *mut sockaddr, &mut len);
-            if res == -1 {
-                return Err(Error::last_os_error());
-            }
-            let sun_path = addrss.sun_path.clone();
-            let peer_path:[u8;108] = sun_path.iter().map(|&x| x as u8).collect::<Vec<u8>>().try_into().unwrap();
-            println!("Client: Connected to server at path: {}", String::from_utf8_lossy(&peer_path));
+        println!("Server: Received message: {}", received_msg);
+
+        send_message(client_fd, MSG2).expect("Failed to send message");
 
-        }
-            
-        server_thread.join().expect("Server thread panicked");
-        let received_msg = receive_message(client_fd).expect("Failed to receive message");
-        println!("Client: Received message: {}", received_msg);
         // Close client connection
         unsafe { close(client_fd) };
-        fs::remove_file(&SOCKET_PATH).ok();
-        Ok(())
-}
+    });
+
+    // Create and connect the client socket
+    let client_fd = create_seqpacket_socket()?;
+    unsafe {
+        let mut addr = sockaddr_un {
+            sun_family: AF_UNIX as u16,
+            sun_path: [0; 108],
+        };
+        let path_cstr = CString::new(SOCKET_PATH).unwrap();
+        let path_bytes = path_cstr.as_bytes();
+        // Convert u8 to i8
+        for (i, &byte) in path_bytes.iter().enumerate() {
+            addr.sun_path[i] = byte as i8;
+        }
+        if connect(
+            client_fd,
+            &addr as *const _ as *const sockaddr,
+            mem::size_of_val(&addr) as socklen_t,
+        ) == -1
+        {
+            return Err(Error::last_os_error());
+        }
+    }
+    send_message(client_fd, MSG1)?;
+    let received_msg = receive_message(client_fd).expect("Failed to receive message");
+    println!("Client: Received message: {}", received_msg);
+    // get peer_name
+    unsafe {
+        let mut addrss = sockaddr_un {
+            sun_family: AF_UNIX as u16,
+            sun_path: [0; 108],
+        };
+        let mut len = mem::size_of_val(&addrss) as socklen_t;
+        let res = getpeername(client_fd, &mut addrss as *mut _ as *mut sockaddr, &mut len);
+        if res == -1 {
+            return Err(Error::last_os_error());
+        }
+        let sun_path = addrss.sun_path.clone();
+        let peer_path: [u8; 108] = sun_path
+            .iter()
+            .map(|&x| x as u8)
+            .collect::<Vec<u8>>()
+            .try_into()
+            .unwrap();
+        println!(
+            "Client: Connected to server at path: {}",
+            String::from_utf8_lossy(&peer_path)
+        );
+    }
+
+    server_thread.join().expect("Server thread panicked");
+    let received_msg = receive_message(client_fd).expect("Failed to receive message");
+    println!("Client: Received message: {}", received_msg);
+    // Close client connection
+    unsafe { close(client_fd) };
+    fs::remove_file(&SOCKET_PATH).ok();
+    Ok(())
+}

user/apps/test_unix_stream_socket/src/main.rs

@@ -1,19 +1,19 @@
-use std::io::Error;
-use std::os::fd::RawFd;
-use std::fs;
 use libc::*;
 use std::ffi::CString;
+use std::fs;
+use std::io::Error;
 use std::mem;
+use std::os::fd::RawFd;
 
 const SOCKET_PATH: &str = "/test.stream";
 const MSG1: &str = "Hello, unix stream socket from Client!";
 const MSG2: &str = "Hello, unix stream socket from Server!";
 
-fn create_stream_socket() -> Result<RawFd, Error>{
+fn create_stream_socket() -> Result<RawFd, Error> {
     unsafe {
         let fd = socket(AF_UNIX, SOCK_STREAM, 0);
         if fd == -1 {
-            return Err(Error::last_os_error())
+            return Err(Error::last_os_error());
         }
         Ok(fd)
     }
@@ -31,7 +31,12 @@ fn bind_socket(fd: RawFd) -> Result<(), Error> {
             addr.sun_path[i] = byte as i8;
         }
 
-        if bind(fd, &addr as *const _ as *const sockaddr, mem::size_of_val(&addr) as socklen_t) == -1 {
+        if bind(
+            fd,
+            &addr as *const _ as *const sockaddr,
+            mem::size_of_val(&addr) as socklen_t,
+        ) == -1
+        {
             return Err(Error::last_os_error());
         }
     }
@@ -61,7 +66,13 @@ fn accept_conn(fd: RawFd) -> Result<RawFd, Error> {
 fn send_message(fd: RawFd, msg: &str) -> Result<(), Error> {
     unsafe {
         let msg_bytes = msg.as_bytes();
-        if send(fd, msg_bytes.as_ptr() as *const libc::c_void, msg_bytes.len(), 0)== -1 {
+        if send(
+            fd,
+            msg_bytes.as_ptr() as *const libc::c_void,
+            msg_bytes.len(),
+            0,
+        ) == -1
+        {
             return Err(Error::last_os_error());
         }
     }
@@ -71,7 +82,12 @@ fn send_message(fd: RawFd, msg: &str) -> Result<(), Error> {
 fn recv_message(fd: RawFd) -> Result<String, Error> {
     let mut buffer = [0; 1024];
     unsafe {
-        let len = recv(fd, buffer.as_mut_ptr() as *mut libc::c_void, buffer.len(),0);
+        let len = recv(
+            fd,
+            buffer.as_mut_ptr() as *mut libc::c_void,
+            buffer.len(),
+            0,
+        );
         if len == -1 {
             return Err(Error::last_os_error());
         }
@@ -82,7 +98,7 @@ fn recv_message(fd: RawFd) -> Result<String, Error> {
 fn test_stream() -> Result<(), Error> {
     fs::remove_file(&SOCKET_PATH).ok();
 
-    let server_fd =  create_stream_socket()?;
+    let server_fd = create_stream_socket()?;
     bind_socket(server_fd)?;
     listen_socket(server_fd)?;
 
@@ -95,7 +111,7 @@ fn test_stream() -> Result<(), Error> {
         send_message(client_fd, MSG2).expect("Failed to send message");
         println!("Server send finish");
 
-        unsafe {close(client_fd)};
+        unsafe { close(client_fd) };
     });
 
     let client_fd = create_stream_socket()?;
@@ -111,9 +127,14 @@ fn test_stream() -> Result<(), Error> {
             addr.sun_path[i] = byte as i8;
         }
 
-        if connect(client_fd, &addr as *const _ as *const sockaddr, mem::size_of_val(&addr) as socklen_t) == -1 {
+        if connect(
+            client_fd,
+            &addr as *const _ as *const sockaddr,
+            mem::size_of_val(&addr) as socklen_t,
+        ) == -1
+        {
             return Err(Error::last_os_error());
-        } 
+        }
     }
 
     send_message(client_fd, MSG1)?;
@@ -129,9 +150,16 @@ fn test_stream() -> Result<(), Error> {
             return Err(Error::last_os_error());
         }
         let sun_path = addrss.sun_path.clone();
-        let peer_path:[u8;108] = sun_path.iter().map(|&x| x as u8).collect::<Vec<u8>>().try_into().unwrap();
-        println!("Client: Connected to server at path: {}", String::from_utf8_lossy(&peer_path));
-
+        let peer_path: [u8; 108] = sun_path
+            .iter()
+            .map(|&x| x as u8)
+            .collect::<Vec<u8>>()
+            .try_into()
+            .unwrap();
+        println!(
+            "Client: Connected to server at path: {}",
+            String::from_utf8_lossy(&peer_path)
+        );
     }
 
     server_thread.join().expect("Server thread panicked");
@@ -139,7 +167,7 @@ fn test_stream() -> Result<(), Error> {
     let recv_msg = recv_message(client_fd).expect("Failed to receive message from server");
     println!("Client Received message: {}", recv_msg);
 
-    unsafe {close(client_fd)};
+    unsafe { close(client_fd) };
     fs::remove_file(&SOCKET_PATH).ok();
 
     Ok(())
@@ -148,6 +176,6 @@ fn test_stream() -> Result<(), Error> {
 fn main() {
     match test_stream() {
         Ok(_) => println!("test for unix stream success"),
-        Err(_) => println!("test for unix stream failed")
+        Err(_) => println!("test for unix stream failed"),
     }
-}
+}