Add Loopback Socket

src/interface/comm.rs

@@ -639,3 +639,10 @@ pub fn kernel_select(
 
     return result;
 }
+
+pub fn get_loopback_path(port: u16) -> String {
+    let mut path = String::from("tmp/loopback");
+    path.push_str(&port.to_string());
+
+    path
+}

src/safeposix/syscalls/net_calls.rs

@@ -56,6 +56,8 @@ use super::net_constants::*;
 use super::sys_constants::*;
 use crate::interface;
 use crate::interface::errnos::{syscall_error, Errno};
+use crate::interface::GenIpaddr;
+use crate::interface::GenSockaddr;
 use crate::safeposix::cage::{FileDescriptor::*, *};
 use crate::safeposix::filesystem::*;
 use crate::safeposix::net::*;
@@ -445,7 +447,32 @@ impl Cage {
         let res = match sockhandle.domain {
             AF_UNIX => self.bind_inner_socket_unix(sockhandle, &mut newsockaddr),
             AF_INET | AF_INET6 => {
-                self.bind_inner_socket_inet(sockhandle, &mut newsockaddr, prereserved)
+                let loopback_addr = u32::from_ne_bytes([127, 0, 0, 7]);
+                match newsockaddr.addr() {
+                    interface::GenIpaddr::V4(addr) => {
+                        if addr.s_addr == loopback_addr {
+                            // this is the loopback address, and we need to fake it into a domain socket
+
+                            let path = interface::get_loopback_path(newsockaddr.port());
+                            newsockaddr = GenSockaddr::Unix(interface::new_sockaddr_unix(AF_UNIX as u16, path.as_bytes()));
+
+                            sockhandle.domain = AF_UNIX;
+
+                            // self.bind_inner_socket_inet(sockhandle, &mut newsockaddr, prereserved)
+                            let ret = self.bind_inner_socket_unix(sockhandle, &mut newsockaddr);
+
+                            ret
+
+                        } else {
+                            // not loopback adddress
+                            self.bind_inner_socket_inet(sockhandle, &mut newsockaddr, prereserved)
+                        }
+                    },
+                    _ => {
+                        // we do not want to handle ipv6 loopback for now
+                        self.bind_inner_socket_inet(sockhandle, &mut newsockaddr, prereserved)
+                    }
+                }
             }
             _ => {
                 return syscall_error(Errno::EINVAL, "bind", "Unsupported domain provided");
@@ -890,6 +917,7 @@ impl Cage {
                     //by other threads accessing other fields
                     let sock_tmp = sockfdobj.handle.clone();
                     let mut sockhandle = sock_tmp.write();
+
                     //Possible address families are Unix, V4, V6
                     //Error occurs if remoteaddr's address family does not match
                     //the domain of the socket pointed to by fd
@@ -901,12 +929,27 @@ impl Cage {
                         );
                     }
 
+                    let mut remoteaddr_final = remoteaddr.clone();
+
+                    if remoteaddr.get_family() == AF_INET as u16 {
+                        let loopback_addr = u32::from_ne_bytes([127, 0, 0, 7]);
+                        let addr = remoteaddr.addr();
+                        if let interface::GenIpaddr::V4(addr) = addr {
+                            if addr.s_addr == loopback_addr {
+                                sockhandle.domain = AF_UNIX;
+                                let path = interface::get_loopback_path(remoteaddr.port());
+
+                                remoteaddr_final = GenSockaddr::Unix(interface::new_sockaddr_unix(AF_UNIX as u16, path.as_bytes()));
+                            }
+                        }
+                    }
+
                     match sockhandle.protocol {
                         IPPROTO_UDP => {
-                            return self.connect_udp(&mut *sockhandle, sockfdobj, remoteaddr)
+                            return self.connect_udp(&mut *sockhandle, sockfdobj, &remoteaddr_final)
                         }
                         IPPROTO_TCP => {
-                            return self.connect_tcp(&mut *sockhandle, sockfdobj, remoteaddr)
+                            return self.connect_tcp(&mut *sockhandle, sockfdobj, &remoteaddr_final)
                         }
                         _ => {
                             return syscall_error(

src/tests/ipc_tests.rs

@@ -352,6 +352,94 @@ pub mod ipc_tests {
         lindrustfinalize();
     }
 
+    #[test]
+    pub fn ut_lind_ipc_loopback_socket() {
+        // acquiring a lock on TESTMUTEX prevents other tests from running concurrently,
+        // and also performs clean env setup
+        let _thelock = setup::lock_and_init();
+
+        let cage = interface::cagetable_getref(1);
+
+        let serversockfd = cage.socket_syscall(AF_INET, SOCK_STREAM, 0);
+
+        // create a INET address
+        let port: u16 = generate_random_port();
+
+        let sockaddr = interface::SockaddrV4 {
+            sin_family: AF_INET as u16,
+            sin_port: port.to_le(),
+            sin_addr: interface::V4Addr {
+                s_addr: u32::from_ne_bytes([127, 0, 0, 7]),
+            },
+            padding: 0,
+        };
+        let socket = interface::GenSockaddr::V4(sockaddr); //127.0.0.7 from bytes above
+
+        assert_eq!(cage.bind_syscall(serversockfd, &socket), 0);
+        assert_eq!(cage.listen_syscall(serversockfd, 4), 0);
+
+        let barrier = interface::RustRfc::new(std::sync::Barrier::new(2));
+        let barrier_clone = barrier.clone();
+
+        assert_eq!(cage.fork_syscall(2), 0); // used for pipe thread
+
+        // client 1 connects to the server to send and recv data
+        let threadclient = interface::helper_thread(move || {
+            let cage2 = interface::cagetable_getref(2);
+            // assert_eq!(cage2.close_syscall(serversockfd), 0);
+
+            let clientsockfd = cage2.socket_syscall(AF_INET, SOCK_STREAM, 0);
+
+            // connect to server
+            assert_eq!(cage2.connect_syscall(clientsockfd, &socket), 0);
+
+            // send message to server
+            assert_eq!(cage2.send_syscall(clientsockfd, str2cbuf("test"), 4, 0), 4);
+
+            interface::sleep(interface::RustDuration::from_millis(1));
+
+            // receive message from server
+            let mut buf = sizecbuf(4);
+            assert_eq!(cage2.recv_syscall(clientsockfd, buf.as_mut_ptr(), 4, 0), 4);
+            assert_eq!(cbuf2str(&buf), "test");
+
+            assert_eq!(cage2.close_syscall(clientsockfd), 0);
+
+            barrier_clone.wait();
+
+            cage2.exit_syscall(EXIT_SUCCESS);
+        });
+
+        let mut sockgarbage =
+            interface::GenSockaddr::V4(interface::SockaddrV4::default());
+
+        let sockfd = cage.accept_syscall(serversockfd as i32, &mut sockgarbage);
+        assert!(sockfd > 0);
+
+        let mut buf = sizecbuf(4);
+        let mut recvresult: i32;
+        loop {
+            // receive message from peer
+            recvresult = cage.recv_syscall(sockfd as i32, buf.as_mut_ptr(), 4, 0);
+            if recvresult != -libc::EINTR {
+                break; // if the error was EINTR, retry the
+                       // syscall
+            }
+        }
+
+        assert!(cbuf2str(&buf) == "test");
+
+        // send message to server
+        assert_eq!(cage.send_syscall(sockfd, str2cbuf("test"), 4, 0), 4);
+
+        barrier.wait();
+
+        threadclient.join().unwrap();
+
+        assert_eq!(cage.exit_syscall(EXIT_SUCCESS), EXIT_SUCCESS);
+        lindrustfinalize();
+    }
+
     // support for retrying writes in case the system doesn't write all bytes at
     // once
     #[test]