apps: Add socket-test

This is only implemented in tmpfs.

apps/CMakeLists.txt

@@ -42,3 +42,4 @@ luna_app(cp.cpp cp)
 luna_app(kill.cpp kill)
 luna_app(gol.cpp gol)
 luna_app(buffer-test.cpp buffer-test)
+luna_app(socket-test.cpp socket-test)

apps/socket-test.cpp

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+int main()
+{
+    int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (sockfd < 0)
+    {
+        perror("socket");
+        return 0;
+    }
+
+    struct sockaddr_un un;
+    un.sun_family = AF_UNIX;
+    strncpy(un.sun_path, "/tmp/local.sock", sizeof(un.sun_path));
+
+    if (bind(sockfd, (struct sockaddr*)&un, sizeof(un)) < 0)
+    {
+        perror("bind");
+        return 1;
+    }
+}

kernel/CMakeLists.txt

@@ -41,11 +41,13 @@ set(SOURCES
     src/sys/mount.cpp
     src/sys/resource.cpp
     src/sys/signal.cpp
+    src/sys/socket.cpp
     src/fs/VFS.cpp
     src/fs/Pipe.cpp
     src/fs/Mount.cpp
     src/fs/MBR.cpp
     src/fs/GPT.cpp
+    src/net/UnixSocket.cpp
     src/fs/tmpfs/FileSystem.cpp
     src/fs/tmpfs/Inode.cpp
     src/fs/ext2/FileSystem.cpp

kernel/src/fs/VFS.h

@@ -17,6 +17,7 @@ namespace VFS
         BlockDevice,
         Symlink,
         FIFO,
+        Socket,
     };
 
     class Inode;
@@ -34,6 +35,11 @@ namespace VFS
 
         virtual Result<SharedPtr<Inode>> create_symlink_inode(StringView link) = 0;
 
+        virtual Result<u64> allocate_inode_number()
+        {
+            return err(ENOTSUP);
+        }
+
         virtual Result<void> set_mount_dir(SharedPtr<Inode> parent) = 0;
 
         virtual Result<void> reset_mount_dir() = 0;

kernel/src/fs/devices/ConsoleDevice.cpp

@@ -49,13 +49,7 @@ Result<usize> ConsoleDevice::read(u8* buf, usize, usize length) const
 {
     TRY(handle_background_process_group(false, SIGTTIN));
 
-    if (length > m_input_buffer.size()) length = m_input_buffer.size();
-
-    memcpy(buf, m_input_buffer.data(), length);
-
-    memmove(m_input_buffer.data(), m_input_buffer.data() + length, m_input_buffer.size() - length);
-
-    m_input_buffer.try_resize(m_input_buffer.size() - length).release_value();
+    length = m_input_buffer.dequeue_data(buf, length);
 
     if (!length && m_may_read_without_blocking) m_may_read_without_blocking = false;
 

kernel/src/fs/tmpfs/FileSystem.cpp

@@ -16,6 +16,11 @@ namespace TmpFS
         return (SharedPtr<VFS::FileSystem>)fs;
     }
 
+    Result<u64> FileSystem::allocate_inode_number()
+    {
+        return m_next_inode_number++;
+    }
+
     Result<SharedPtr<VFS::Inode>> FileSystem::create_file_inode()
     {
         SharedPtr<FileInode> inode = TRY(make_shared<FileInode>());

kernel/src/fs/tmpfs/FileSystem.h

@@ -18,6 +18,8 @@ namespace TmpFS
         Result<SharedPtr<VFS::Inode>> create_device_inode(u32 major, u32 minor) override;
         Result<SharedPtr<VFS::Inode>> create_symlink_inode(StringView link) override;
 
+        Result<u64> allocate_inode_number() override;
+
         Result<void> set_mount_dir(SharedPtr<VFS::Inode> parent) override;
 
         Result<void> reset_mount_dir() override;

kernel/src/net/Socket.h

@@ -0,0 +1,114 @@
+#pragma once
+#include "fs/VFS.h"
+#include <bits/socket.h>
+
+class Socket : public VFS::FileInode
+{
+  public:
+    Socket() = default;
+
+    VFS::InodeType type() const override
+    {
+        return VFS::InodeType::Socket;
+    }
+
+    void set_fs(VFS::FileSystem* fs)
+    {
+        m_fs = fs;
+    }
+
+    void set_inode_number(usize inum)
+    {
+        m_inode_number = inum;
+    }
+
+    VFS::FileSystem* fs() const override
+    {
+        return m_fs;
+    }
+
+    usize inode_number() const override
+    {
+        return m_inode_number;
+    }
+
+    Result<usize> read(u8* buf, usize, usize length) const override
+    {
+        return recv(buf, length, 0);
+    }
+
+    Result<usize> write(const u8* buf, usize, usize length) override
+    {
+        return send(buf, length, 0);
+    }
+
+    virtual Result<usize> send(const u8*, usize, int) = 0;
+
+    virtual Result<usize> recv(u8*, usize, int) const = 0;
+
+    virtual Result<void> bind(SharedPtr<Socket>, struct sockaddr*, socklen_t) = 0;
+    virtual Result<void> connect(struct sockaddr*, socklen_t) = 0;
+
+    Result<void> truncate(usize) override
+    {
+        return err(EINVAL);
+    }
+
+    usize size() const override
+    {
+        return 0;
+    }
+
+    mode_t mode() const override
+    {
+        return m_mode;
+    }
+
+    u32 uid() const override
+    {
+        return m_uid;
+    }
+
+    u32 gid() const override
+    {
+        return m_gid;
+    }
+
+    nlink_t nlinks() const override
+    {
+        return (nlink_t)m_nlinks;
+    }
+
+    Result<void> chmod(mode_t mode) override
+    {
+        m_mode = mode;
+        return {};
+    }
+
+    Result<void> chown(u32 uid, u32 gid) override
+    {
+        m_uid = uid;
+        m_gid = gid;
+        return {};
+    }
+
+    void did_link() override
+    {
+        m_nlinks++;
+    }
+
+    void did_unlink() override
+    {
+        m_nlinks--;
+    }
+
+    virtual ~Socket() = default;
+
+  protected:
+    VFS::FileSystem* m_fs;
+    usize m_inode_number { 0 };
+    mode_t m_mode;
+    u32 m_uid { 0 };
+    u32 m_gid { 0 };
+    u32 m_nlinks { 0 };
+};

kernel/src/net/UnixSocket.cpp

@@ -0,0 +1,104 @@
+#include "net/UnixSocket.h"
+#include <luna/PathParser.h>
+#include <thread/Scheduler.h>
+
+UnixSocket::UnixSocket()
+{
+}
+
+UnixSocket::UnixSocket(UnixSocket* peer) : m_state(State::Connected), m_peer(peer)
+{
+}
+
+UnixSocket::~UnixSocket()
+{
+    if (m_peer)
+    {
+        m_peer->m_peer = nullptr;
+        m_peer->m_state = State::Reset;
+    }
+}
+
+void UnixSocket::connect_to_peer(UnixSocket* peer)
+{
+    m_peer = peer;
+    m_state = State::Connected;
+}
+
+Result<usize> UnixSocket::send(const u8* buf, usize length, int)
+{
+    if (m_state == State::Reset) return err(ECONNRESET);
+    if (m_state != State::Connected) return err(ENOTCONN);
+
+    check(m_peer);
+
+    TRY(m_peer->m_data.append_data(buf, length));
+
+    return length;
+}
+
+Result<usize> UnixSocket::recv(u8* buf, usize length, int) const
+{
+    if (m_state == State::Reset) return err(ECONNRESET);
+    if (m_state != State::Connected) return err(ENOTCONN);
+
+    return m_data.dequeue_data(buf, length);
+}
+
+static Result<void> bind_socket_to_fs(const char* path, Credentials auth, SharedPtr<VFS::Inode> working_directory,
+                                      SharedPtr<UnixSocket> socket)
+{
+    auto parent_path = TRY(PathParser::dirname(path));
+
+    auto parent_inode = TRY(VFS::resolve_path(parent_path.chars(), auth, working_directory));
+
+    if (!VFS::can_write(parent_inode, auth)) return err(EACCES);
+
+    auto child_name = TRY(PathParser::basename(path));
+
+    TRY(VFS::validate_filename(child_name.view()));
+
+    socket->set_inode_number(TRY(parent_inode->fs()->allocate_inode_number()));
+    socket->set_fs(parent_inode->fs());
+
+    return parent_inode->add_entry(socket, child_name.chars());
+}
+
+Result<void> UnixSocket::bind(SharedPtr<Socket> socket, struct sockaddr* addr, socklen_t addrlen)
+{
+    if (!addr) return err(EDESTADDRREQ);
+    if (addr->sa_family != AF_UNIX) return err(EAFNOSUPPORT);
+    if ((usize)addrlen > sizeof(sockaddr_un)) return err(EINVAL);
+
+    if (m_state == State::Connected) return err(EISCONN);
+    if (m_state != State::Inactive) return err(EINVAL);
+
+    struct sockaddr_un* un_address = (struct sockaddr_un*)addr;
+
+    String path = TRY(String::from_string_view(
+        StringView::from_fixed_size_cstring(un_address->sun_path, addrlen - sizeof(sa_family_t))));
+
+    auto* current = Scheduler::current();
+
+    socket->chmod(0777 & ~current->umask);
+    socket->chown(current->auth.euid, current->auth.egid);
+
+    auto rc = bind_socket_to_fs(path.chars(), current->auth, current->current_directory, socket);
+    if (rc.has_error())
+    {
+        if (rc.error() == EEXIST) return err(EADDRINUSE);
+        return rc.release_error();
+    }
+
+    memcpy(&m_addr, un_address, addrlen);
+    m_addrlen = addrlen;
+
+    m_state = State::Bound;
+
+    return {};
+}
+
+Result<void> UnixSocket::connect(struct sockaddr*, socklen_t)
+{
+    return err(ENOSYS);
+}

kernel/src/net/UnixSocket.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "net/Socket.h"
+#include <luna/Buffer.h>
+#include <luna/String.h>
+#include <sys/un.h>
+
+class UnixSocket : public Socket
+{
+  public:
+    UnixSocket();
+    UnixSocket(UnixSocket* peer);
+
+    bool blocking() const override
+    {
+        return !m_data.size();
+    }
+
+    Result<usize> send(const u8*, usize, int) override;
+    Result<usize> recv(u8*, usize, int) const override;
+
+    Result<void> bind(SharedPtr<Socket>, struct sockaddr*, socklen_t) override;
+    Result<void> connect(struct sockaddr*, socklen_t) override;
+
+    void connect_to_peer(UnixSocket* peer);
+
+    virtual ~UnixSocket();
+
+  private:
+    enum State
+    {
+        Inactive,
+        Bound,
+        Listening,
+        Connecting,
+        Connected,
+        Reset,
+    };
+
+    State m_state = State::Inactive;
+    UnixSocket* m_peer;
+
+    mutable Buffer m_data;
+
+    struct sockaddr_un m_addr = { .sun_family = AF_UNIX, .sun_path = {} };
+    socklen_t m_addrlen = sizeof(sa_family_t);
+};

kernel/src/sys/open.cpp

@@ -55,6 +55,8 @@ Result<u64> sys_openat(Registers*, SyscallArgs args)
     // This should only be possible if O_NOFOLLOW was in flags.
     if (inode->type() == VFS::InodeType::Symlink) return err(ELOOP);
 
+    if (inode->type() == VFS::InodeType::Socket) return err(ENXIO);
+
     if (flags & O_TMPFILE)
     {
         if (inode->type() != VFS::InodeType::Directory) return err(EINVAL);

kernel/src/sys/socket.cpp

@@ -0,0 +1,49 @@
+#include "net/Socket.h"
+#include "memory/MemoryManager.h"
+#include "net/UnixSocket.h"
+#include "sys/Syscall.h"
+#include "thread/Scheduler.h"
+#include <bits/open-flags.h>
+
+Result<u64> sys_socket(Registers*, SyscallArgs args)
+{
+    int domain = (int)args[0];
+    int type = (int)args[1];
+    // protocol is not used for now.
+
+    if (type != SOCK_STREAM) return err(EPROTOTYPE);
+    if (domain != AF_UNIX) return err(EAFNOSUPPORT);
+
+    auto socket = TRY(make_shared<UnixSocket>());
+
+    auto* current = Scheduler::current();
+
+    int fd = TRY(current->allocate_fd(0));
+
+    current->fd_table[fd] = FileDescriptor { socket, 0, O_RDWR };
+
+    return fd;
+}
+
+Result<u64> sys_bind(Registers*, SyscallArgs args)
+{
+    int sockfd = (int)args[0];
+    struct sockaddr* addr = (struct sockaddr*)args[1];
+    socklen_t addrlen = (socklen_t)args[2];
+
+    struct sockaddr_storage storage;
+    if ((usize)addrlen > sizeof(storage)) return err(EINVAL);
+    if (!MemoryManager::copy_from_user(addr, &storage, addrlen)) return err(EFAULT);
+
+    auto* current = Scheduler::current();
+
+    auto inode = TRY(current->resolve_fd(sockfd))->inode;
+
+    if (inode->type() != VFS::InodeType::Socket) return err(ENOTSOCK);
+
+    auto socket = (SharedPtr<Socket>)inode;
+
+    TRY(socket->bind(socket, (struct sockaddr*)&storage, addrlen));
+
+    return 0;
+}

kernel/src/sys/stat.cpp

@@ -18,6 +18,7 @@ static mode_t make_mode(mode_t mode, VFS::InodeType type)
     case VFS::InodeType::BlockDevice: result |= S_IFBLK; break;
     case VFS::InodeType::Symlink: result |= S_IFLNK; break;
     case VFS::InodeType::FIFO: result |= S_IFIFO; break;
+    case VFS::InodeType::Socket: result |= S_IFSOCK; break;
     default: break;
     }
 

libc/CMakeLists.txt

@@ -31,6 +31,7 @@ set(SOURCES
     src/sys/mount.cpp
     src/sys/pstat.cpp
     src/sys/resource.cpp
+    src/sys/socket.cpp
 )
 
 if(${LUNA_ARCH} STREQUAL "x86_64")

libc/include/bits/modes.h

@@ -10,6 +10,7 @@
 #define S_IFBLK 030000
 #define S_IFDIR 040000
 #define S_IFCHR 050000
+#define S_IFSOCK 060000
 
 #define __CHECK_TYPE(mode, type) (((mode)&S_IFMT) == type)
 
@@ -19,6 +20,7 @@
 #define S_ISBLK(mode) __CHECK_TYPE(mode, S_IFBLK)
 #define S_ISLNK(mode) __CHECK_TYPE(mode, S_IFLNK)
 #define S_ISFIFO(mode) __CHECK_TYPE(mode, S_IFIFO)
+#define S_ISSOCK(mode) __CHECK_TYPE(mode, S_IFSOCK)
 
 #define S_IRWXU 0700
 #define S_IRUSR 0400

libc/include/bits/socket.h

@@ -0,0 +1,30 @@
+/* bits/socket.h: Socket-related types and structures. */
+
+#ifndef _BITS_SOCKET_H
+#define _BITS_SOCKET_H
+
+typedef int socklen_t;
+typedef unsigned sa_family_t;
+
+struct sockaddr
+{
+    sa_family_t sa_family;
+    char sa_data[4];
+};
+
+struct sockaddr_storage
+{
+    sa_family_t ss_family;
+    union {
+        char _sun_path[108]; // AF_UNIX
+    };
+};
+
+#define SOCK_STREAM 0
+
+#define AF_UNSPEC 0
+#define AF_UNIX 1
+#define AF_INET 2
+#define AF_INET6 3
+
+#endif

libc/include/sys/socket.h

@@ -0,0 +1,23 @@
+/* sys/socket.h: Communication sockets. */
+
+#ifndef _SYS_SOCKET_H
+#define _SYS_SOCKET_H
+
+#include <bits/socket.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /* Create a new socket and return a file descriptor pointing to it. */
+    int socket(int domain, int type, int protocol);
+
+    /* Bind a socket to an address. */
+    int bind(int sockfd, struct sockaddr* addr, socklen_t addrlen);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libc/include/sys/un.h

@@ -0,0 +1,14 @@
+/* sys/un.h: The sockaddr_un structure for AF_UNIX sockets. */
+
+#ifndef _SYS_UN_H
+#define _SYS_UN_H
+
+#include <bits/socket.h>
+
+struct sockaddr_un
+{
+    sa_family_t sun_family;
+    char sun_path[108];
+};
+
+#endif

libc/src/sys/socket.cpp

@@ -0,0 +1,19 @@
+#include <bits/errno-return.h>
+#include <sys/socket.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+extern "C"
+{
+    int socket(int domain, int type, int protocol)
+    {
+        long rc = syscall(SYS_socket, domain, type, protocol);
+        __errno_return(rc, int);
+    }
+
+    int bind(int sockfd, struct sockaddr* addr, socklen_t addrlen)
+    {
+        long rc = syscall(SYS_bind, sockfd, addr, addrlen);
+        __errno_return(rc, int);
+    }
+}

libluna/include/luna/Buffer.h

@@ -21,6 +21,8 @@ class Buffer
 
     Result<void> append_data(const u8* data, usize size);
 
+    usize dequeue_data(u8* data, usize size);
+
     u8* data()
     {
         return m_data;

libluna/include/luna/Syscall.h

@@ -7,7 +7,7 @@
                 _e(fstatat) _e(chdir) _e(getcwd) _e(unlinkat) _e(uname) _e(sethostname) _e(dup2) _e(pipe) _e(mount)    \
                     _e(umount) _e(pstat) _e(getrusage) _e(symlinkat) _e(readlinkat) _e(umask) _e(linkat) _e(faccessat) \
                         _e(pivot_root) _e(sigreturn) _e(sigaction) _e(kill) _e(sigprocmask) _e(setpgid) _e(isatty)     \
-                            _e(getpgid)
+                            _e(getpgid) _e(socket) _e(bind)
 
 enum Syscalls
 {

libluna/include/luna/SystemError.h

@@ -45,11 +45,15 @@
 #define EOVERFLOW 75    // Value too large for defined data type
 #define EILSEQ 84       // Invalid or incomplete multibyte or wide character
 #define ENOTSOCK 88     // Socket operation on non-socket
+#define EDESTADDRREQ 89 // Destination address required
+#define EPROTOTYPE 91   // Protocol wrong type for socket
 #define ENOTSUP 95      // Operation not supported
 #define EOPNOTSUPP 95   // Operation not supported
+#define EAFNOSUPPORT 97 // Address family not supported by protocol
 #define EADDRINUSE 98   // Address already in use
 #define ENETRESET 102   // Network dropped connection on reset
 #define ECONNRESET 104  // Connection reset by peer
 #define EISCONN 106     // Transport endpoint is already connected
+#define ENOTCONN 107    // Transport endpoint is not connected
 #define ETIMEDOUT 110   // Connection timed out
 #define EALREADY 114    // Operation already in progress

libluna/src/Buffer.cpp

@@ -53,6 +53,20 @@ Result<void> Buffer::append_data(const u8* data, usize size)
     return {};
 }
 
+usize Buffer::dequeue_data(u8* data, usize size)
+{
+    if (size > m_size) size = m_size;
+    if (!size) return 0;
+
+    memcpy(data, m_data, size);
+
+    memmove(m_data, m_data + size, m_size - size);
+
+    m_size -= size;
+
+    return size;
+}
+
 u8* Buffer::release_data()
 {
     u8* data = m_data;

libluna/src/SystemError.cpp

@@ -56,6 +56,10 @@ const char* error_string(int error)
     case EISCONN: return "Transport endpoint is already connected";
     case ETIMEDOUT: return "Connection timed out";
     case EALREADY: return "Operation already in progress";
+    case EDESTADDRREQ: return "Destination address required";
+    case EPROTOTYPE: return "Protocol wrong type for socket";
+    case EAFNOSUPPORT: return "Address family not supported by protocol";
+    case ENOTCONN: return "Transport endpoint is not connected";
     default: return "Unknown error";
     }
 }

libos/src/Mode.cpp

@@ -21,6 +21,7 @@ namespace os
         if (S_ISBLK(mode)) return 'b';
         if (S_ISLNK(mode)) return 'l';
         if (S_ISFIFO(mode)) return 'p';
+        if (S_ISSOCK(mode)) return 's';
 
         return '?';
     }