sockets::unix: partial implement connect, listen

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

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From a649d90c5073ef1f8a9eadb4773fe5f832a3e87c Mon Sep 17 00:00:00 2001
+From 989da4c4aa01ce3ad7a52986f0492a6b565add28 Mon Sep 17 00:00:00 2001
 From: Andy-Python-Programmer <[email protected]>
 Date: Thu, 10 Feb 2022 19:12:25 +1100
 Subject: [PATCH] yes
@@ -10,9 +10,9 @@ Signed-off-by: Andy-Python-Programmer <[email protected]>
  sysdeps/aero/generic/aero.cpp       | 12 +++-
  sysdeps/aero/generic/filesystem.cpp | 97 ++++++++++++++++++++++++++---
  sysdeps/aero/generic/signals.cpp    |  8 ++-
- sysdeps/aero/generic/sockets.cpp    | 48 ++++++++++++++
+ sysdeps/aero/generic/sockets.cpp    | 59 ++++++++++++++++++
  sysdeps/aero/include/aero/syscall.h | 11 ++++
- 7 files changed, 168 insertions(+), 13 deletions(-)
+ 7 files changed, 179 insertions(+), 13 deletions(-)
 
 diff --git a/.gitignore b/.gitignore
 index dbb35e8b..20c8d4c3 100644
@@ -228,10 +228,10 @@ index 3527370c..a6f69fff 100644
  } // namespace mlibc
 \ No newline at end of file
 diff --git a/sysdeps/aero/generic/sockets.cpp b/sysdeps/aero/generic/sockets.cpp
-index e69de29b..4e6bd608 100644
+index e69de29b..b6b18fe7 100644
 --- a/sysdeps/aero/generic/sockets.cpp
 +++ b/sysdeps/aero/generic/sockets.cpp
-@@ -0,0 +1,48 @@
+@@ -0,0 +1,59 @@
 +#include <mlibc/all-sysdeps.hpp>
 +#include <mlibc/thread-entry.hpp>
 +
@@ -279,6 +279,17 @@ index e69de29b..4e6bd608 100644
 +
 +    return 0;
 +}
++
++int sys_accept(int fd, int *newfd) {
++    auto result = syscall(SYS_ACCEPT, fd);
++
++    if (result < 0) {
++        return -result;
++    }
++
++    *newfd = result;
++    return 0;
++}
 +} // namespace mlibc
 diff --git a/sysdeps/aero/include/aero/syscall.h b/sysdeps/aero/include/aero/syscall.h
 index 07b1b51b..6487cd85 100644

src/aero_kernel/src/fs/inode.rs

@@ -157,6 +157,11 @@ pub trait INodeInterface: Send + Sync + Downcastable {
     fn listen(&self, _backlog: usize) -> Result<()> {
         Err(FileSystemError::NotSocket)
     }
+
+    /// Returns the inner UNIX socket inode if bound to one.
+    fn as_unix_socket(&self) -> Result<Arc<dyn INodeInterface>> {
+        Err(FileSystemError::NotSocket)
+    }
 }
 
 /// Structure representing the curcial, characteristics of an inode. The metadata

src/aero_kernel/src/fs/mod.rs

@@ -133,6 +133,7 @@ pub enum FileSystemError {
     TooSmall,
     InvalidPath,
     NotSocket,
+    ConnectionRefused,
 }
 
 impl From<FileSystemError> for AeroSyscallError {
@@ -148,6 +149,7 @@ impl From<FileSystemError> for AeroSyscallError {
             FileSystemError::TooSmall => Self::E2BIG,
             FileSystemError::InvalidPath => Self::EINVAL,
             FileSystemError::NotSocket => Self::ENOTSOCK,
+            FileSystemError::ConnectionRefused => Self::ECONNREFUSED,
         }
     }
 }

src/aero_kernel/src/fs/ramfs.rs

@@ -382,6 +382,15 @@ impl INodeInterface for LockedRamINode {
         ))
     }
 
+    fn as_unix_socket(&self) -> Result<Arc<dyn INodeInterface>> {
+        let this = self.0.read();
+
+        match &this.contents {
+            FileContents::Socket(socket) => Ok(socket.clone()),
+            _ => Err(FileSystemError::NotSocket),
+        }
+    }
+
     #[inline]
     fn weak_filesystem(&self) -> Option<Weak<dyn FileSystem>> {
         Some(self.0.read().filesystem.clone())

src/aero_kernel/src/socket/mod.rs

@@ -36,6 +36,15 @@ impl<'a> SocketAddr<'a> {
             _ => None,
         }
     }
+
+    /// Converts the socket address into a unix socket address. Returns [`None`] if
+    /// the address is not a unix socket address.
+    pub fn as_unix(&self) -> Option<&'a SocketAddrUnix> {
+        match self {
+            SocketAddr::Unix(address) => Some(address),
+            _ => None,
+        }
+    }
 }
 
 pub mod unix;

src/aero_kernel/src/socket/unix.rs

@@ -17,84 +17,138 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
-use alloc::{
-    string::String,
-    sync::{Arc, Weak},
-};
+use aero_syscall::SocketAddrUnix;
+
+use alloc::string::String;
+use alloc::sync::{Arc, Weak};
+use alloc::vec::Vec;
+use spin::RwLock;
 
 use crate::fs;
-use crate::fs::{
-    inode::{DirEntry, FileType, INodeInterface, Metadata},
-    FileSystemError, Path, Result,
-};
+use crate::fs::inode::{DirEntry, FileType, INodeInterface, Metadata};
+use crate::fs::{FileSystemError, Path, Result};
+use crate::utils::downcast;
 
 use super::SocketAddr;
 
+fn path_from_unix_sock<'sock>(address: &'sock SocketAddrUnix) -> Result<&'sock Path> {
+    // The abstract namespace socket allows the creation of a socket
+    // connection which does not require a path to be created.
+    let abstrat_namespaced = address.path[0] == 0;
+    assert!(!abstrat_namespaced);
+
+    let path_len = address
+        .path
+        .iter()
+        .position(|&c| c == 0)
+        .unwrap_or(address.path.len());
+
+    let path_str = core::str::from_utf8(&address.path[..path_len])
+        .ok()
+        .ok_or(FileSystemError::InvalidPath)?;
+
+    Ok(Path::new(path_str))
+}
+
+#[derive(Default)]
+struct UnixSocketBacklog {
+    backlog: Option<Vec<Arc<UnixSocket>>>,
+}
+
+impl UnixSocketBacklog {
+    pub fn push(&mut self, socket: Arc<UnixSocket>) {
+        if let Some(ref mut backlog) = self.backlog {
+            assert!(backlog.len() != backlog.capacity());
+            backlog.push(socket);
+        }
+    }
+
+    pub fn update_capacity(&mut self, capacity: usize) {
+        assert!(
+            self.backlog.is_none(),
+            "UnixSocket::listen() has already been called"
+        );
+
+        self.backlog = Some(Vec::with_capacity(capacity));
+    }
+}
+
+#[derive(Default)]
+struct UnixSocketInner {
+    backlog: UnixSocketBacklog,
+    listening: bool,
+}
+
 pub struct UnixSocket {
+    inner: RwLock<UnixSocketInner>,
     weak: Weak<UnixSocket>,
 }
 
 impl UnixSocket {
     pub fn new() -> Arc<UnixSocket> {
-        Arc::new_cyclic(|weak| UnixSocket { weak: weak.clone() })
+        Arc::new_cyclic(|weak| UnixSocket {
+            inner: RwLock::new(UnixSocketInner::default()),
+            weak: weak.clone(),
+        })
+    }
+
+    pub fn sref(&self) -> Arc<UnixSocket> {
+        self.weak.upgrade().unwrap()
     }
 }
 
 impl INodeInterface for UnixSocket {
     fn metadata(&self) -> Result<Metadata> {
         Ok(Metadata {
-            id: 0, // FIXME: What should this be?
+            id: 0,
             file_type: FileType::Socket,
             size: 0,
             children_len: 0,
         })
     }
 
     fn bind(&self, address: SocketAddr, _length: usize) -> Result<()> {
-        if let SocketAddr::Unix(address) = address {
-            // The abstract namespace socket allows the creation of a socket
-            // connection which does not require a path to be created.
-            let abstrat_namespaced = address.path[0] == 0;
-            assert!(!abstrat_namespaced);
-
-            let path_len = address
-                .path
-                .iter()
-                .position(|&c| c == 0)
-                .unwrap_or(address.path.len());
-
-            let path_str = core::str::from_utf8(&address.path[..path_len])
-                .ok()
-                .ok_or(FileSystemError::InvalidPath)?;
-
-            let path = Path::new(path_str);
-
-            // Ensure that the path is not already in use.
-            if fs::lookup_path(path).is_ok() {
-                return Err(FileSystemError::EntryExists);
-            }
-
-            let (parent, name) = path.parent_and_basename();
-
-            DirEntry::from_socket_inode(
-                fs::lookup_path(parent)?,
-                String::from(name),
-                self.weak.upgrade().unwrap(),
-            )?;
-
-            Ok(())
-        } else {
-            Err(FileSystemError::NotSupported)
+        let address = address.as_unix().ok_or(FileSystemError::NotSupported)?;
+        let path = path_from_unix_sock(address)?;
+
+        // ensure that the provided path is not already in use.
+        if fs::lookup_path(path).is_ok() {
+            return Err(FileSystemError::EntryExists);
         }
+
+        let (parent, name) = path.parent_and_basename();
+
+        // create the socket inode.
+        DirEntry::from_socket_inode(fs::lookup_path(parent)?, String::from(name), self.sref())?;
+
+        Ok(())
     }
 
-    fn connect(&self, _address: SocketAddr, _length: usize) -> Result<()> {
-        log::error!("UnixSocket::connect() is not implemented");
+    fn connect(&self, address: SocketAddr, _length: usize) -> Result<()> {
+        let address = address.as_unix().ok_or(FileSystemError::NotSupported)?;
+        let path = path_from_unix_sock(address)?;
+        let socket = fs::lookup_path(path)?;
+
+        let target = downcast::<dyn INodeInterface, UnixSocket>(&socket.inode().as_unix_socket()?)
+            .ok_or(FileSystemError::NotSocket)?; // NOTE: the provided socket was not a unix socket.
+
+        let mut target = target.inner.write();
+
+        // ensure that the target socket is listening for new connections.
+        if !target.listening {
+            return Err(FileSystemError::ConnectionRefused);
+        }
+
+        target.backlog.push(self.sref());
         Ok(())
     }
 
-    fn listen(&self, _backlog: usize) -> Result<()> {
-        log::error!("UnixSocket::listen() not implemented");
+    fn listen(&self, backlog: usize) -> Result<()> {
+        let mut this = self.inner.write();
+
+        this.backlog.update_capacity(backlog);
+        this.listening = true;
+
         Ok(())
     }
 }

src/aero_kernel/src/syscall/net.rs

@@ -53,9 +53,9 @@ pub fn socket(
     socket_type: usize,
     protocol: usize,
 ) -> Result<usize, AeroSyscallError> {
-    let socket = match (domain as u32, socket_type, protocol) {
-        (AF_UNIX, SOCK_STREAM, 0) => UnixSocket::new(),
-        (_, _, _) => {
+    let socket = match domain as u32 {
+        AF_UNIX => UnixSocket::new(),
+        _ => {
             log::warn!(
                 "unsupported socket type: domain={domain}, socket_type={socket_type}, protocol={protocol}"
             );
@@ -64,11 +64,11 @@ pub fn socket(
         }
     };
 
+    let sockfd_flags = SocketFlags::from_bits_truncate(socket_type).into();
+
     let entry = DirEntry::from_inode(socket);
     let current_task = scheduler::get_scheduler().current_task();
-    let fd = current_task
-        .file_table
-        .open_file(entry, OpenFlags::empty())?;
+    let fd = current_task.file_table.open_file(entry, sockfd_flags)?;
 
     Ok(fd)
 }

src/aero_syscall/src/lib.rs

@@ -680,8 +680,29 @@ pub const SOCK_DGRAM: usize = 1;
 pub const SOCK_RAW: usize = 2;
 pub const SOCK_SEQPACKET: usize = 3;
 pub const SOCK_STREAM: usize = 4;
-pub const SOCK_NONBLOCK: usize = 0x10000;
-pub const SOCK_CLOEXEC: usize = 0x20000;
+
+bitflags::bitflags! {
+    pub struct SocketFlags: usize {
+        const NONBLOCK = 0x10000;
+        const CLOEXEC = 0x20000;
+    }
+}
+
+impl From<SocketFlags> for OpenFlags {
+    fn from(flags: SocketFlags) -> Self {
+        let mut result = OpenFlags::empty();
+
+        if flags.contains(SocketFlags::NONBLOCK) {
+            result.insert(OpenFlags::O_NONBLOCK);
+        }
+
+        if flags.contains(SocketFlags::CLOEXEC) {
+            result.insert(OpenFlags::O_CLOEXEC);
+        }
+
+        result
+    }
+}
 
 pub const PF_INET: u32 = 1;
 pub const PF_INET6: u32 = 2;