syscall::net: add connect syscall

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From fb279173f0a97399a112bd8a5c2d3ec96f450374 Mon Sep 17 00:00:00 2001
+From f76727cfa3db5f15b030a3cdc4535ea1eea31ac4 Mon Sep 17 00:00:00 2001
 From: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>
 Date: Thu, 10 Feb 2022 19:12:25 +1100
 Subject: [PATCH] yes
@@ -10,9 +10,9 @@ Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>
  sysdeps/aero/generic/aero.cpp       | 12 ++++-
  sysdeps/aero/generic/filesystem.cpp | 79 ++++++++++++++++++++++++++---
  sysdeps/aero/generic/signals.cpp    |  8 ++-
- sysdeps/aero/generic/sockets.cpp    | 28 ++++++++++
+ sysdeps/aero/generic/sockets.cpp    | 38 ++++++++++++++
  sysdeps/aero/include/aero/syscall.h | 12 +++++
- 7 files changed, 131 insertions(+), 13 deletions(-)
+ 7 files changed, 141 insertions(+), 13 deletions(-)
 
 diff --git a/.gitignore b/.gitignore
 index dbb35e8b..20c8d4c3 100644
@@ -210,10 +210,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..e4040629 100644
+index e69de29b..c1375859 100644
 --- a/sysdeps/aero/generic/sockets.cpp
 +++ b/sysdeps/aero/generic/sockets.cpp
-@@ -0,0 +1,28 @@
+@@ -0,0 +1,38 @@
 +#include <mlibc/all-sysdeps.hpp>
 +#include <mlibc/thread-entry.hpp>
 +
@@ -241,6 +241,16 @@ index e69de29b..e4040629 100644
 +
 +    return 0;
 +}
++
++int sys_connect(int fd, const struct sockaddr *addr_ptr, socklen_t addr_length) {
++    auto result = syscall(SYS_CONNECT, fd, addr_ptr, (sc_word_t)addr_length);
++
++    if (result < 0) {
++        return -result;
++    }
++
++    return 0;
++}
 +} // namespace mlibc
 diff --git a/sysdeps/aero/include/aero/syscall.h b/sysdeps/aero/include/aero/syscall.h
 index 07b1b51b..ef797e40 100644

src/aero_kernel/src/fs/inode.rs

@@ -19,8 +19,7 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use aero_syscall::MMapFlags;
-use aero_syscall::{OpenFlags, SocketAddr};
+use aero_syscall::{MMapFlags, OpenFlags};
 
 use alloc::string::String;
 use alloc::sync::Arc;
@@ -30,6 +29,7 @@ use alloc::vec::Vec;
 use spin::Once;
 
 use crate::mem::paging::PhysFrame;
+use crate::socket::SocketAddr;
 use crate::utils::sync::Mutex;
 use crate::utils::Downcastable;
 
@@ -147,7 +147,11 @@ pub trait INodeInterface: Send + Sync + Downcastable {
 
     // Socket operations
     fn bind(&self, _address: SocketAddr, _length: usize) -> Result<()> {
-        Err(FileSystemError::NotSupported)
+        Err(FileSystemError::NotSocket)
+    }
+
+    fn connect(&self, _address: SocketAddr, _length: usize) -> Result<()> {
+        Err(FileSystemError::NotSocket)
     }
 }
 

src/aero_kernel/src/fs/mod.rs

@@ -132,20 +132,22 @@ pub enum FileSystemError {
     Interrupted,
     TooSmall,
     InvalidPath,
+    NotSocket,
 }
 
 impl From<FileSystemError> for AeroSyscallError {
     fn from(error: FileSystemError) -> Self {
         match error {
-            FileSystemError::NotSupported => AeroSyscallError::EACCES,
-            FileSystemError::EntryExists => AeroSyscallError::EEXIST,
-            FileSystemError::EntryNotFound => AeroSyscallError::ENOENT,
-            FileSystemError::Busy => AeroSyscallError::EBUSY,
-            FileSystemError::NotDirectory => AeroSyscallError::ENOTDIR,
-            FileSystemError::IsPipe => AeroSyscallError::ESPIPE,
-            FileSystemError::Interrupted => AeroSyscallError::EINTR,
-            FileSystemError::TooSmall => AeroSyscallError::E2BIG,
-            FileSystemError::InvalidPath => AeroSyscallError::EINVAL,
+            FileSystemError::NotSupported => Self::EACCES,
+            FileSystemError::EntryExists => Self::EEXIST,
+            FileSystemError::EntryNotFound => Self::ENOENT,
+            FileSystemError::Busy => Self::EBUSY,
+            FileSystemError::NotDirectory => Self::ENOTDIR,
+            FileSystemError::IsPipe => Self::ESPIPE,
+            FileSystemError::Interrupted => Self::EINTR,
+            FileSystemError::TooSmall => Self::E2BIG,
+            FileSystemError::InvalidPath => Self::EINVAL,
+            FileSystemError::NotSocket => Self::ENOTSOCK,
         }
     }
 }

src/aero_kernel/src/socket/mod.rs

@@ -17,4 +17,25 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
+use aero_syscall::*;
+
+use crate::mem::paging::VirtAddr;
+
+#[derive(Debug)]
+pub enum SocketAddr<'a> {
+    Unix(&'a SocketAddrUnix),
+    INet(&'a SocketAddrInet),
+}
+
+impl<'a> SocketAddr<'a> {
+    pub fn from_family(address: VirtAddr, family: u32) -> Option<Self> {
+        match family {
+            AF_UNIX => Some(SocketAddr::Unix(address.read_mut::<SocketAddrUnix>()?)),
+            AF_INET => Some(SocketAddr::INet(address.read_mut::<SocketAddrInet>()?)),
+
+            _ => None,
+        }
+    }
+}
+
 pub mod unix;

src/aero_kernel/src/socket/unix.rs

@@ -17,7 +17,6 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
-use aero_syscall::SocketAddr;
 use alloc::{
     string::String,
     sync::{Arc, Weak},
@@ -29,6 +28,8 @@ use crate::fs::{
     FileSystemError, Path, Result,
 };
 
+use super::SocketAddr;
+
 pub struct UnixSocket {
     weak: Weak<UnixSocket>,
 }
@@ -86,4 +87,8 @@ impl INodeInterface for UnixSocket {
             Err(FileSystemError::NotSupported)
         }
     }
+
+    fn connect(&self, _address: SocketAddr, _length: usize) -> Result<()> {
+        todo!("{_address:?}")
+    }
 }

src/aero_kernel/src/syscall/mod.rs

@@ -210,6 +210,7 @@ pub fn generic_do_syscall(
 
         SYS_SOCKET => net::socket(b, c, d),
         SYS_BIND => net::bind(b, c, d),
+        SYS_CONNECT => net::connect(b, c, d),
 
         SYS_GETTIME => time::gettime(b, c),
         SYS_SLEEP => time::sleep(b),

src/aero_kernel/src/syscall/net.rs

@@ -1,14 +1,45 @@
 use aero_syscall::*;
 
-use crate::{fs::inode::DirEntry, socket::unix::*, userland::scheduler};
+use crate::fs::inode::DirEntry;
+use crate::mem::paging::VirtAddr;
+
+use crate::socket::unix::*;
+use crate::socket::SocketAddr;
+
+use crate::userland::scheduler;
+
+/// Creates a [`SocketAddr`] from the provided userland socket structure address. This
+/// is done by looking at the family field present in every socket address structure.
+fn socket_addr_from_addr<'sys>(address: VirtAddr) -> Result<SocketAddr<'sys>, AeroSyscallError> {
+    let family = address
+        .read_mut::<u32>()
+        .ok_or(AeroSyscallError::EINVAL)?
+        .clone();
+
+    Ok(SocketAddr::from_family(address, family).ok_or(AeroSyscallError::EINVAL)?)
+}
+
+/// Connects the socket referred to by the file descriptor, to the specified address.
+#[aero_proc::syscall]
+pub fn connect(fd: usize, address: usize, length: usize) -> Result<usize, AeroSyscallError> {
+    let address = socket_addr_from_addr(VirtAddr::new(address as u64))?;
+    let file = scheduler::get_scheduler()
+        .current_task()
+        .file_table
+        .get_handle(fd)
+        .ok_or(AeroSyscallError::EINVAL)?;
+
+    file.inode().connect(address, length)?;
+    Ok(0)
+}
 
 #[aero_proc::syscall]
 pub fn socket(
     domain: usize,
     socket_type: usize,
     protocol: usize,
 ) -> Result<usize, AeroSyscallError> {
-    let socket = match (domain, socket_type, protocol) {
+    let socket = match (domain as u32, socket_type, protocol) {
         (AF_UNIX, SOCK_STREAM, 0) => UnixSocket::new(),
         (_, _, _) => {
             log::warn!(
@@ -28,20 +59,10 @@ pub fn socket(
     Ok(fd)
 }
 
-// TODO: Figure out how to handle this.
 #[aero_proc::syscall]
 pub fn bind(fd: usize, address: usize, length: usize) -> Result<usize, AeroSyscallError> {
-    let family = unsafe { *(address as *const i32) };
-    let address = match family as usize {
-        AF_UNIX => SocketAddr::Unix(unsafe { &*(address as *const SocketAddrUnix) }),
-
-        _ => {
-            log::warn!("unsupported address family: {}", family);
-            return Err(AeroSyscallError::EINVAL);
-        }
-    };
+    let address = socket_addr_from_addr(VirtAddr::new(address as u64))?;
 
-    // let address = unsafe { &*(address as *const SocketAddr) };
     let current_task = scheduler::get_scheduler().current_task();
     let file = current_task.file_table.get_handle(fd);
 

src/aero_syscall/src/lib.rs

@@ -674,11 +674,6 @@ pub struct SocketAddrInet {
     pub padding: [u8; 8],
 }
 
-pub enum SocketAddr<'a> {
-    Unix(&'a SocketAddrUnix),
-    Inet(&'a SocketAddrInet),
-}
-
 // constants for the socket types:
 //
 // mlibc/sysdeps/aero/include/abi-bits/socket.h
@@ -689,21 +684,21 @@ pub const SOCK_STREAM: usize = 4;
 pub const SOCK_NONBLOCK: usize = 0x10000;
 pub const SOCK_CLOEXEC: usize = 0x20000;
 
-pub const PF_INET: usize = 1;
-pub const PF_INET6: usize = 2;
-pub const PF_UNIX: usize = 3;
-pub const PF_LOCAL: usize = 3;
-pub const PF_UNSPEC: usize = 4;
-pub const PF_NETLINK: usize = 5;
-pub const PF_BRIDGE: usize = 6;
-
-pub const AF_INET: usize = PF_INET;
-pub const AF_INET6: usize = PF_INET6;
-pub const AF_UNIX: usize = PF_UNIX;
-pub const AF_LOCAL: usize = PF_LOCAL;
-pub const AF_UNSPEC: usize = PF_UNSPEC;
-pub const AF_NETLINK: usize = PF_NETLINK;
-pub const AF_BRIDGE: usize = PF_BRIDGE;
+pub const PF_INET: u32 = 1;
+pub const PF_INET6: u32 = 2;
+pub const PF_UNIX: u32 = 3;
+pub const PF_LOCAL: u32 = 3;
+pub const PF_UNSPEC: u32 = 4;
+pub const PF_NETLINK: u32 = 5;
+pub const PF_BRIDGE: u32 = 6;
+
+pub const AF_INET: u32 = PF_INET;
+pub const AF_INET6: u32 = PF_INET6;
+pub const AF_UNIX: u32 = PF_UNIX;
+pub const AF_LOCAL: u32 = PF_LOCAL;
+pub const AF_UNSPEC: u32 = PF_UNSPEC;
+pub const AF_NETLINK: u32 = PF_NETLINK;
+pub const AF_BRIDGE: u32 = PF_BRIDGE;
 
 pub fn sys_socket(
     domain: usize,
@@ -719,21 +714,6 @@ pub fn sys_listen(fd: usize, backlog: usize) -> Result<usize, AeroSyscallError>
     isize_as_syscall_result(value as _)
 }
 
-pub fn sys_accept(
-    fd: usize,
-    address: &mut SocketAddr,
-    length: &mut u32,
-) -> Result<usize, AeroSyscallError> {
-    let value = syscall3(
-        prelude::SYS_ACCEPT,
-        fd,
-        address as *const SocketAddr as usize,
-        length as *mut u32 as usize,
-    );
-
-    isize_as_syscall_result(value as _)
-}
-
 pub fn sys_unlink(fd: usize, path: &str, flags: OpenFlags) -> Result<usize, AeroSyscallError> {
     let value = syscall4(
         prelude::SYS_UNLINK,