Services: Move to Userland/Services/

Userland/Services/TelnetServer/CMakeLists.txt

@@ -0,0 +1,8 @@
+set(SOURCES
+    Client.cpp
+    main.cpp
+    Parser.cpp
+)
+
+serenity_bin(TelnetServer)
+target_link_libraries(TelnetServer LibCore)

Userland/Services/TelnetServer/Client.cpp

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "Client.h"
+#include <AK/ByteBuffer.h>
+#include <AK/MemoryStream.h>
+#include <AK/String.h>
+#include <AK/StringBuilder.h>
+#include <AK/StringView.h>
+#include <AK/Types.h>
+#include <LibCore/Notifier.h>
+#include <LibCore/TCPSocket.h>
+#include <stdio.h>
+#include <unistd.h>
+
+Client::Client(int id, RefPtr<Core::TCPSocket> socket, int ptm_fd)
+    : m_id(id)
+    , m_socket(move(socket))
+    , m_ptm_fd(ptm_fd)
+    , m_ptm_notifier(Core::Notifier::construct(ptm_fd, Core::Notifier::Read))
+{
+    m_socket->on_ready_to_read = [this] { drain_socket(); };
+    m_ptm_notifier->on_ready_to_read = [this] { drain_pty(); };
+    m_parser.on_command = [this](const Command& command) { handle_command(command); };
+    m_parser.on_data = [this](const StringView& data) { handle_data(data); };
+    m_parser.on_error = [this]() { handle_error(); };
+    send_commands({
+        { CMD_WILL, SUB_SUPPRESS_GO_AHEAD },
+        { CMD_WILL, SUB_ECHO },
+        { CMD_DO, SUB_SUPPRESS_GO_AHEAD },
+        { CMD_DONT, SUB_ECHO },
+    });
+}
+
+void Client::drain_socket()
+{
+    NonnullRefPtr<Client> protect(*this);
+    while (m_socket->can_read()) {
+        auto buf = m_socket->read(1024);
+
+        m_parser.write(buf);
+
+        if (m_socket->eof()) {
+            quit();
+            break;
+        }
+    }
+}
+
+void Client::drain_pty()
+{
+    u8 buffer[BUFSIZ];
+    ssize_t nread = read(m_ptm_fd, buffer, sizeof(buffer));
+    if (nread < 0) {
+        perror("read(ptm)");
+        quit();
+        return;
+    }
+    if (nread == 0) {
+        quit();
+        return;
+    }
+    send_data(StringView(buffer, (size_t)nread));
+}
+
+void Client::handle_data(const StringView& data)
+{
+    write(m_ptm_fd, data.characters_without_null_termination(), data.length());
+}
+
+void Client::handle_command(const Command& command)
+{
+    switch (command.command) {
+    case CMD_DO:
+        // no response - we've already advertised our options, and none of
+        // them can be disabled (or re-enabled) after connecting.
+        break;
+    case CMD_DONT:
+        // no response - we only "support" two options (echo and suppress
+        // go-ahead), and both of them are always enabled.
+        break;
+    case CMD_WILL:
+        switch (command.subcommand) {
+        case SUB_ECHO:
+            // we always want to be the ones in control of the output. tell
+            // the client to disable local echo.
+            send_command({ CMD_DONT, SUB_ECHO });
+            break;
+        case SUB_SUPPRESS_GO_AHEAD:
+            send_command({ CMD_DO, SUB_SUPPRESS_GO_AHEAD });
+            break;
+        default:
+            // don't respond to unknown commands
+            break;
+        }
+        break;
+    case CMD_WONT:
+        // no response - we don't care about anything the client says they
+        // won't do.
+        break;
+    }
+}
+
+void Client::handle_error()
+{
+    quit();
+}
+
+void Client::send_data(StringView data)
+{
+    bool fast = true;
+    for (size_t i = 0; i < data.length(); i++) {
+        u8 c = data[i];
+        if (c == '\n' || c == 0xff)
+            fast = false;
+    }
+
+    if (fast) {
+        m_socket->write(data);
+        return;
+    }
+
+    StringBuilder builder;
+    for (size_t i = 0; i < data.length(); i++) {
+        u8 c = data[i];
+
+        switch (c) {
+        case '\n':
+            builder.append("\r\n");
+            break;
+        case IAC:
+            builder.append("\xff\xff");
+            break;
+        default:
+            builder.append(c);
+            break;
+        }
+    }
+
+    m_socket->write(builder.to_string());
+}
+
+void Client::send_command(Command command)
+{
+    send_commands({ command });
+}
+
+void Client::send_commands(Vector<Command> commands)
+{
+    auto buffer = ByteBuffer::create_uninitialized(commands.size() * 3);
+    OutputMemoryStream stream { buffer };
+
+    for (auto& command : commands)
+        stream << (u8)IAC << command.command << command.subcommand;
+
+    ASSERT(stream.is_end());
+    m_socket->write(buffer.data(), buffer.size());
+}
+
+void Client::quit()
+{
+    m_ptm_notifier->set_enabled(false);
+    close(m_ptm_fd);
+    m_socket->close();
+    if (on_exit)
+        on_exit();
+}

Userland/Services/TelnetServer/Client.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/String.h>
+#include <AK/StringView.h>
+#include <AK/Types.h>
+#include <LibCore/Notifier.h>
+#include <LibCore/TCPSocket.h>
+
+#include "Command.h"
+#include "Parser.h"
+
+class Client : public RefCounted<Client> {
+public:
+    static NonnullRefPtr<Client> create(int id, RefPtr<Core::TCPSocket> socket, int ptm_fd)
+    {
+        return adopt(*new Client(id, move(socket), ptm_fd));
+    }
+
+    Function<void()> on_exit;
+
+protected:
+    Client(int id, RefPtr<Core::TCPSocket> socket, int ptm_fd);
+
+    void drain_socket();
+    void drain_pty();
+    void handle_data(const StringView&);
+    void handle_command(const Command& command);
+    void handle_error();
+    void send_data(StringView str);
+    void send_command(Command command);
+    void send_commands(Vector<Command> commands);
+    void quit();
+
+private:
+    // client id
+    int m_id { 0 };
+    // client resources
+    RefPtr<Core::TCPSocket> m_socket;
+    Parser m_parser;
+    // pty resources
+    int m_ptm_fd { -1 };
+    RefPtr<Core::Notifier> m_ptm_notifier;
+};

Userland/Services/TelnetServer/Command.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/String.h>
+#include <AK/StringBuilder.h>
+#include <AK/Types.h>
+
+#define CMD_WILL 0xfb
+#define CMD_WONT 0xfc
+#define CMD_DO 0xfd
+#define CMD_DONT 0xfe
+#define SUB_ECHO 0x01
+#define SUB_SUPPRESS_GO_AHEAD 0x03
+
+struct Command {
+    u8 command;
+    u8 subcommand;
+
+    String to_string() const
+    {
+        StringBuilder builder;
+
+        switch (command) {
+        case CMD_WILL:
+            builder.append("WILL");
+            break;
+        case CMD_WONT:
+            builder.append("WONT");
+            break;
+        case CMD_DO:
+            builder.append("DO");
+            break;
+        case CMD_DONT:
+            builder.append("DONT");
+            break;
+        default:
+            builder.append(String::format("UNKNOWN<%02x>", command));
+            break;
+        }
+
+        builder.append(" ");
+
+        switch (subcommand) {
+        case SUB_ECHO:
+            builder.append("ECHO");
+            break;
+        case SUB_SUPPRESS_GO_AHEAD:
+            builder.append("SUPPRESS_GO_AHEAD");
+            break;
+        default:
+            builder.append(String::format("UNKNOWN<%02x>", subcommand));
+            break;
+        }
+
+        return builder.to_string();
+    };
+};

Userland/Services/TelnetServer/Parser.cpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <AK/Function.h>
+#include <AK/String.h>
+#include <AK/Types.h>
+
+#include "Parser.h"
+
+void Parser::write(const StringView& data)
+{
+    for (size_t i = 0; i < data.length(); i++) {
+        u8 ch = data[i];
+
+        switch (m_state) {
+        case State::Free:
+            switch (ch) {
+            case IAC:
+                m_state = State::ReadCommand;
+                break;
+            case '\r':
+                if (on_data)
+                    on_data("\n");
+                break;
+            default:
+                if (on_data)
+                    on_data(StringView(&ch, 1));
+                break;
+            }
+            break;
+        case State::ReadCommand:
+            switch (ch) {
+            case IAC: {
+                m_state = State::Free;
+                if (on_data)
+                    on_data("\xff");
+                break;
+            }
+            case CMD_WILL:
+            case CMD_WONT:
+            case CMD_DO:
+            case CMD_DONT:
+                m_command = ch;
+                m_state = State::ReadSubcommand;
+                break;
+            default:
+                m_state = State::Error;
+                if (on_error)
+                    on_error();
+                break;
+            }
+            break;
+        case State::ReadSubcommand: {
+            auto command = m_command;
+            m_command = 0;
+            m_state = State::Free;
+            if (on_command)
+                on_command({ command, ch });
+            break;
+        }
+        case State::Error:
+            // ignore everything
+            break;
+        }
+    }
+}

Userland/Services/TelnetServer/Parser.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/Function.h>
+#include <AK/String.h>
+#include <AK/StringView.h>
+#include <AK/Types.h>
+
+#include "Command.h"
+
+#define IAC 0xff
+
+class Parser {
+public:
+    Function<void(const Command&)> on_command;
+    Function<void(const StringView&)> on_data;
+    Function<void()> on_error;
+
+    void write(const StringView&);
+
+protected:
+    enum State {
+        Free,
+        ReadCommand,
+        ReadSubcommand,
+        Error,
+    };
+
+    void write(const String& str);
+
+private:
+    State m_state { State::Free };
+    u8 m_command { 0 };
+};

Userland/Services/TelnetServer/main.cpp

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "Client.h"
+#include <AK/ByteBuffer.h>
+#include <AK/HashMap.h>
+#include <AK/IPv4Address.h>
+#include <AK/String.h>
+#include <AK/StringBuilder.h>
+#include <AK/Types.h>
+#include <LibCore/ArgsParser.h>
+#include <LibCore/EventLoop.h>
+#include <LibCore/TCPServer.h>
+#include <LibCore/TCPSocket.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+
+static void run_command(int ptm_fd, String command)
+{
+    pid_t pid = fork();
+    if (pid == 0) {
+        const char* tty_name = ptsname(ptm_fd);
+        if (!tty_name) {
+            perror("ptsname");
+            exit(1);
+        }
+        close(ptm_fd);
+        int pts_fd = open(tty_name, O_RDWR);
+        if (pts_fd < 0) {
+            perror("open");
+            exit(1);
+        }
+
+        // NOTE: It's okay if this fails.
+        [[maybe_unused]] auto rc = ioctl(0, TIOCNOTTY);
+
+        close(0);
+        close(1);
+        close(2);
+
+        rc = dup2(pts_fd, 0);
+        if (rc < 0) {
+            perror("dup2");
+            exit(1);
+        }
+        rc = dup2(pts_fd, 1);
+        if (rc < 0) {
+            perror("dup2");
+            exit(1);
+        }
+        rc = dup2(pts_fd, 2);
+        if (rc < 0) {
+            perror("dup2");
+            exit(1);
+        }
+        rc = close(pts_fd);
+        if (rc < 0) {
+            perror("close");
+            exit(1);
+        }
+        rc = ioctl(0, TIOCSCTTY);
+        if (rc < 0) {
+            perror("ioctl(TIOCSCTTY)");
+            exit(1);
+        }
+        const char* args[4] = { "/bin/Shell", nullptr, nullptr, nullptr };
+        if (!command.is_empty()) {
+            args[1] = "-c";
+            args[2] = command.characters();
+        }
+        const char* envs[] = { "TERM=xterm", "PATH=/bin:/usr/bin:/usr/local/bin", nullptr };
+        rc = execve("/bin/Shell", const_cast<char**>(args), const_cast<char**>(envs));
+        if (rc < 0) {
+            perror("execve");
+            exit(1);
+        }
+        ASSERT_NOT_REACHED();
+    }
+}
+
+int main(int argc, char** argv)
+{
+    int port = 23;
+    const char* command = "";
+
+    Core::ArgsParser args_parser;
+    args_parser.add_option(port, "Port to listen on", nullptr, 'p', "port");
+    args_parser.add_option(command, "Program to run on connection", nullptr, 'c', "command");
+    args_parser.parse(argc, argv);
+
+    if ((u16)port != port) {
+        warnln("Invalid port number: {}", port);
+        exit(1);
+    }
+
+    Core::EventLoop event_loop;
+    auto server = Core::TCPServer::construct();
+
+    if (!server->listen({}, port)) {
+        warnln("Listening on 0.0.0.0:{} failed", port);
+        exit(1);
+    }
+
+    HashMap<int, NonnullRefPtr<Client>> clients;
+    int next_id = 0;
+
+    server->on_ready_to_accept = [&next_id, &clients, &server, command] {
+        int id = next_id++;
+
+        auto client_socket = server->accept();
+        if (!client_socket) {
+            perror("accept");
+            return;
+        }
+
+        int ptm_fd = posix_openpt(O_RDWR);
+        if (ptm_fd < 0) {
+            perror("posix_openpt");
+            client_socket->close();
+            return;
+        }
+        if (grantpt(ptm_fd) < 0) {
+            perror("grantpt");
+            client_socket->close();
+            return;
+        }
+        if (unlockpt(ptm_fd) < 0) {
+            perror("unlockpt");
+            client_socket->close();
+            return;
+        }
+
+        run_command(ptm_fd, command);
+
+        auto client = Client::create(id, move(client_socket), ptm_fd);
+        client->on_exit = [&clients, id] { clients.remove(id); };
+        clients.set(id, client);
+    };
+
+    int rc = event_loop.exec();
+    if (rc != 0) {
+        fprintf(stderr, "event loop exited badly; rc=%d", rc);
+        exit(1);
+    }
+
+    return 0;
+}