socket: more socket work

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

aero.py

@@ -524,7 +524,7 @@ def run_in_emulator(args, iso_path):
 
     qemu_args = ['-cdrom', iso_path,
                  '-M', 'q35',
-                 '-m', '5G',
+                 '-m', '6G',
                  '-smp', '5',
                  '-serial', 'stdio']
 

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From 24a4e9494f8b2d78936d08ffdfe4cf84cf35e76b Mon Sep 17 00:00:00 2001
+From 796581911f51ff414a2fa03e53fd470a1f440329 Mon Sep 17 00:00:00 2001
 From: Andy-Python-Programmer <[email protected]>
 Date: Fri, 8 Jul 2022 12:32:32 +1000
 Subject: [PATCH] yes
@@ -8,12 +8,13 @@ Signed-off-by: Andy-Python-Programmer <[email protected]>
  .gitignore                            |   2 +
  options/ansi/generic/stdlib-stubs.cpp | 142 +++++++++++++++++++++-----
  options/glibc/generic/execinfo.cpp    |   5 +-
+ options/posix/generic/sys-uio.cpp     |   5 +
  options/rtdl/generic/linker.cpp       |   2 +-
  sysdeps/aero/generic/aero.cpp         |  38 +++----
  sysdeps/aero/generic/filesystem.cpp   |  25 ++++-
  sysdeps/aero/generic/sockets.cpp      |  77 +++++++++++++-
  sysdeps/aero/include/aero/syscall.h   |   4 +
- 8 files changed, 241 insertions(+), 54 deletions(-)
+ 9 files changed, 246 insertions(+), 54 deletions(-)
 
 diff --git a/.gitignore b/.gitignore
 index fdd60a00..9f811f47 100644
@@ -195,6 +196,22 @@ index 3474615e..10a2109e 100644
  }
 
  char **backtrace_symbols(void *const *, int) {
+diff --git a/options/posix/generic/sys-uio.cpp b/options/posix/generic/sys-uio.cpp
+index b1623525..a5f3e893 100644
+--- a/options/posix/generic/sys-uio.cpp
++++ b/options/posix/generic/sys-uio.cpp
+@@ -17,6 +17,11 @@ ssize_t readv(int, const struct iovec *, int) {
+ }
+ 
+ ssize_t writev(int fd, const struct iovec *iovs, int iovc) {
++	if (iovc == 0) {
++		errno = EAGAIN;
++		return -1;
++	}
++
+ 	__ensure(iovc);
+ 
+ 	ssize_t written = 0;
 diff --git a/options/rtdl/generic/linker.cpp b/options/rtdl/generic/linker.cpp
 index 6716ef4f..e5ec8cff 100644
 --- a/options/rtdl/generic/linker.cpp

src/aero_kernel/src/drivers/tty.rs

@@ -253,6 +253,10 @@ impl INodeInterface for Tty {
             state.parser.advance(&mut performer, *character);
         }
 
+        log::debug!("TTY::write_at(): {}", unsafe {
+            core::str::from_utf8_unchecked(buffer)
+        });
+
         Ok(buffer.len())
     }
 

src/aero_kernel/src/fs/inode.rs

@@ -232,7 +232,7 @@ pub trait INodeInterface: Send + Sync {
         Err(FileSystemError::NotSocket)
     }
 
-    fn recv(&self, _message_header: &mut MessageHeader) -> Result<()> {
+    fn recv(&self, _message_header: &mut MessageHeader) -> Result<usize> {
         Err(FileSystemError::NotSocket)
     }
 

src/aero_kernel/src/fs/mod.rs

@@ -134,6 +134,8 @@ pub enum FileSystemError {
     InvalidPath,
     NotSocket,
     ConnectionRefused,
+    NotConnected,
+    WouldBlock,
 }
 
 impl From<FileSystemError> for SyscallError {
@@ -151,6 +153,8 @@ impl From<FileSystemError> for SyscallError {
             FileSystemError::NotSocket => Self::ENOTSOCK,
             FileSystemError::ConnectionRefused => Self::ECONNREFUSED,
             FileSystemError::IsDir => Self::EISDIR,
+            FileSystemError::NotConnected => Self::ENOTCONN,
+            FileSystemError::WouldBlock => Self::EAGAIN,
         }
     }
 }

src/aero_kernel/src/socket/unix.rs

@@ -87,6 +87,7 @@ struct UnixSocketInner {
     listening: bool,
     peer: Option<Arc<UnixSocket>>,
     connected: bool,
+    address: SocketAddrUnix,
 }
 
 pub struct UnixSocket {
@@ -110,9 +111,22 @@ impl UnixSocket {
         })
     }
 
+    pub fn set_address(&self, address: SocketAddrUnix) {
+        self.inner.lock_irq().address = address;
+    }
+
+    pub fn get_address(&self) -> SocketAddrUnix {
+        self.inner.lock_irq().address.clone()
+    }
+
     pub fn sref(&self) -> Arc<Self> {
         self.weak.upgrade().unwrap()
     }
+
+    /// Returns wether the socket is connected or not.
+    pub fn is_connected(&self) -> bool {
+        self.inner.lock_irq().connected
+    }
 }
 
 impl INodeInterface for UnixSocket {
@@ -160,6 +174,7 @@ impl INodeInterface for UnixSocket {
 
         // create the socket inode.
         DirEntry::from_socket_inode(fs::lookup_path(parent)?, String::from(name), self.sref())?;
+        self.set_address(address.clone());
 
         Ok(())
     }
@@ -204,7 +219,11 @@ impl INodeInterface for UnixSocket {
             return Err(FileSystemError::ConnectionRefused);
         }
 
-        let mut this = self.wq.block_on(&self.inner, |e| e.backlog.len() != 0)?;
+        let mut this = self.inner.lock_irq();
+
+        if this.backlog.len() == 0 {
+            return Err(FileSystemError::WouldBlock);
+        }
 
         let peer = this
             .backlog
@@ -224,12 +243,31 @@ impl INodeInterface for UnixSocket {
             peer_data.connected = true;
         }
 
+        sock.set_address(peer.get_address());
+
         peer.wq.notify_complete();
         Ok(sock)
     }
 
-    fn recv(&self, _message_header: &mut MessageHeader) -> Result<()> {
-        Ok(())
+    fn recv(&self, header: &mut MessageHeader) -> Result<usize> {
+        if !self.is_connected() {
+            return Err(FileSystemError::NotConnected);
+        }
+
+        let size = header.iovecs().iter().map(|e| e.len()).sum::<usize>();
+
+        let mut buffer = self.wq.block_on(&self.buffer, |e| e.len() >= size)?;
+        log::trace!("UnixSocket::recv(): recieved total of {size} bytes");
+
+        header
+            .name_mut::<SocketAddrUnix>()
+            .map(|e| *e = self.inner.lock_irq().peer.as_ref().unwrap().get_address());
+
+        Ok(header
+            .iovecs_mut()
+            .iter_mut()
+            .map(|iovec| buffer.read_data(iovec.as_mut_slice()))
+            .sum::<usize>())
     }
 
     fn poll(&self, table: Option<&mut PollTable>) -> Result<PollFlags> {

src/aero_kernel/src/syscall/net.rs

@@ -67,8 +67,7 @@ pub fn sock_recv(
         .get_handle(sockfd)
         .ok_or(SyscallError::EINVAL)?;
 
-    socket.inode().recv(header)?;
-    Ok(0)
+    Ok(socket.inode().recv(header)?)
 }
 
 /// Marks the socket as a passive socket (i.e. as a socket that will be used to accept incoming

src/aero_kernel/src/userland/vm.rs

@@ -1084,7 +1084,7 @@ impl VmProtected {
     }
 
     fn fork_from(&mut self, parent: &Vm) {
-        let data = parent.inner.lock();
+        let data = parent.inner.lock_irq();
 
         // Copy over all of the mappings from the parent into the child.
         self.mappings = data.mappings.clone();

src/aero_kernel/src/utils/buffer.rs

@@ -34,6 +34,11 @@ impl Buffer {
         !self.data.is_empty()
     }
 
+    /// Returns the size of the buffer.
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
     pub fn read_data(&mut self, buffer: &mut [u8]) -> usize {
         // nothing to read
         if self.data.is_empty() {

src/aero_syscall/src/lib.rs

@@ -666,13 +666,24 @@ pub fn sys_sethostname(name: &str) -> Result<usize, SyscallError> {
 }
 
 // Sockets
+pub trait SocketAddr: Send + Sync {}
+
 #[derive(Debug, Clone)]
 #[repr(C)]
 pub struct SocketAddrUnix {
     pub family: u32,
     pub path: [u8; 108],
 }
 
+impl Default for SocketAddrUnix {
+    fn default() -> Self {
+        Self {
+            family: AF_UNIX,
+            path: [0; 108],
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 #[repr(C)]
 pub struct SocketAddrInet {
@@ -682,6 +693,9 @@ pub struct SocketAddrInet {
     pub padding: [u8; 8],
 }
 
+impl SocketAddr for SocketAddrUnix {}
+impl SocketAddr for SocketAddrInet {}
+
 // constants for the socket types:
 //
 // mlibc/sysdeps/aero/include/abi-bits/socket.h

src/aero_syscall/src/socket.rs

@@ -1,8 +1,12 @@
+use crate::SocketAddr;
+
 // sysdeps/aero/include/abi-bits/socket.h
 #[derive(Debug)]
 #[repr(C)]
 pub struct MessageHeader {
-    name: *const u8,
+    /// Pointer to the socket address structure.
+    name: *mut u8,
+    /// Size of the socket address structure.
     name_len: usize,
 
     iovec: *mut IoVec, // todo: use Option<NonNull<IoVec>>
@@ -14,10 +18,49 @@ pub struct MessageHeader {
     flags: i32, // todo: use ffi::c_int
 }
 
+impl MessageHeader {
+    pub fn name_mut<T: SocketAddr>(&mut self) -> Option<&mut T> {
+        if self.name.is_null() {
+            return None;
+        }
+
+        assert!(self.name_len == core::mem::size_of::<T>());
+
+        // SAFETY: We know that the `name` pointer is valid and we have an exclusive reference to it.
+        // The size of name is checked above with the size of `T` and `T` is a `SocketAddr` so, its
+        // safe to create a mutable reference of `T` from the ptr.
+        unsafe { Some(&mut *(self.name as *mut T)) }
+    }
+
+    pub fn iovecs(&self) -> &[IoVec] {
+        // SAFETY: We know that the `iovec` pointer is valid, initialized.
+        unsafe { core::slice::from_raw_parts(self.iovec, self.iovec_len as usize) }
+    }
+
+    pub fn iovecs_mut(&mut self) -> &mut [IoVec] {
+        // SAFETY: We know that the `iovec` pointer is valid, initialized and we have
+        // exclusive access so, its safe to construct a mutable slice from it.
+        unsafe { core::slice::from_raw_parts_mut(self.iovec, self.iovec_len as usize) }
+    }
+}
+
 // options/posix/include/bits/posix/iovec.h
 #[derive(Debug)]
 #[repr(C)]
 pub struct IoVec {
-    base: *mut u8,
+    base: *mut u8, // todo: use Option<NonNull<u8>>
     len: usize,
 }
+
+impl IoVec {
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        // SAFETY: We know that the `base` pointer is valid, initialized and we have
+        // exclusive access so, its safe to construct a mutable slice from it.
+        unsafe { core::slice::from_raw_parts_mut(self.base, self.len) }
+    }
+
+    /// Returns the length of the I/O vector.
+    pub fn len(&self) -> usize {
+        self.len
+    }
+}