LibCore: Add CLocalServer, a server-only local socket class.

Instead of trying to support both client and server in CLocalSocket, let's
have a specialized server class.

The basic usage is:

    CLocalServer server;
    server.listen("/tmp/name-of-portal");
    server.on_ready_to_accept = [&] {
        CLocalSocket* client = server.accept();
        ...
    };

This will make things a lot simpler, since an accepting socket doesn't need
half of the stuff that a regular CIODevice provides. :^)

Libraries/LibCore/CLocalServer.cpp

@@ -0,0 +1,54 @@
+#include <LibCore/CLocalServer.h>
+#include <LibCore/CLocalSocket.h>
+#include <LibCore/CNotifier.h>
+#include <stdio.h>
+#include <sys/socket.h>
+
+CLocalServer::CLocalServer(CObject* parent)
+    : CObject(parent)
+{
+    m_fd = socket(AF_LOCAL, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
+    ASSERT(m_fd >= 0);
+}
+
+CLocalServer::~CLocalServer()
+{
+}
+
+bool CLocalServer::listen(const String& address)
+{
+    if (m_listening)
+        return false;
+
+    int rc;
+
+    auto socket_address = CSocketAddress::local(address);
+    auto un = socket_address.to_sockaddr_un();
+    rc = ::bind(m_fd, (const sockaddr*)&un, sizeof(un));
+    ASSERT(rc == 0);
+
+    rc = ::listen(m_fd, 5);
+    ASSERT(rc == 0);
+    m_listening = true;
+
+    m_notifier = make<CNotifier>(m_fd, CNotifier::Event::Read);
+    m_notifier->on_ready_to_read = [this] {
+        if (on_ready_to_accept)
+            on_ready_to_accept();
+    };
+    return true;
+}
+
+CLocalSocket* CLocalServer::accept()
+{
+    ASSERT(m_listening);
+    sockaddr_un un;
+    socklen_t un_size = sizeof(un);
+    int accepted_fd = ::accept(m_fd, (sockaddr*)&un, &un_size);
+    if (accepted_fd < 0) {
+        perror("accept");
+        return nullptr;
+    }
+
+    return new CLocalSocket({}, accepted_fd);
+}

Libraries/LibCore/CLocalServer.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <LibCore/CNotifier.h>
+#include <LibCore/CObject.h>
+
+class CLocalSocket;
+
+class CLocalServer : public CObject {
+    C_OBJECT(CLocalServer)
+public:
+    explicit CLocalServer(CObject* parent = nullptr);
+    virtual ~CLocalServer() override;
+
+    bool is_listening() const { return m_listening; }
+    bool listen(const String& address);
+
+    CLocalSocket* accept();
+
+    Function<void()> on_ready_to_accept;
+
+private:
+    int m_fd { -1 };
+    bool m_listening { false };
+    OwnPtr<CNotifier> m_notifier;
+};

Libraries/LibCore/CLocalSocket.cpp

@@ -2,6 +2,14 @@
 #include <sys/socket.h>
 #include <errno.h>
 
+CLocalSocket::CLocalSocket(Badge<CLocalServer>, int fd, CObject* parent)
+    : CSocket(CSocket::Type::Local, parent)
+{
+    set_fd(fd);
+    set_mode(CIODevice::ReadWrite);
+    set_error(0);
+}
+
 CLocalSocket::CLocalSocket(CObject* parent)
     : CSocket(CSocket::Type::Local, parent)
 {

Libraries/LibCore/CLocalSocket.h

@@ -1,10 +1,15 @@
 #pragma once
+
+#include <AK/Badge.h>
 #include <LibCore/CSocket.h>
 
+class CLocalServer;
+
 class CLocalSocket final : public CSocket {
     C_OBJECT(CLocalSocket)
 public:
     explicit CLocalSocket(CObject* parent = nullptr);
+    CLocalSocket(Badge<CLocalServer>, int fd, CObject* parent = nullptr);
     virtual ~CLocalSocket() override;
 
     virtual bool bind(const CSocketAddress&) override;

Libraries/LibCore/Makefile

@@ -7,6 +7,7 @@ OBJS = \
     CFile.o \
     CSocket.o \
     CLocalSocket.o \
+    CLocalServer.o \
     CTCPSocket.o \
     CElapsedTimer.o \
     CNotifier.o \