Atmosphere/libraries/libstratosphere/source/htcs/htcs_socket.cpp

/*
 * Copyright (c) 2018-2020 Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <stratosphere.hpp>
#include "client/htcs_session.hpp"
#include "client/htcs_virtual_socket_collection.hpp"

namespace ams::htcs {

    namespace {

        constinit bool g_initialized = false;
        constinit bool g_enable_disconnection_emulation = false;

        constinit AllocateFunction g_allocate_function     = nullptr;
        constinit DeallocateFunction g_deallocate_function = nullptr;

        constinit void *g_buffer = nullptr;
        constinit size_t g_buffer_size = 0;

        constinit os::TlsSlot g_tls_slot;

        constinit tma::IHtcsManager *g_manager = nullptr;
        constinit tma::IHtcsManager *g_monitor = nullptr;

        constinit client::VirtualSocketCollection *g_sockets = nullptr;

        void SetLastError(uintptr_t error_code) {
            os::SetTlsValue(g_tls_slot, error_code);
        }

        void InitializeImpl(void *buffer, size_t buffer_size, int num_sessions) {
            /* Check the session count. */
            AMS_ASSERT(0 < num_sessions && num_sessions <= SessionCountMax);

            /* Initialize the manager and monitor. */
            client::InitializeSessionManager(std::addressof(g_manager), std::addressof(g_monitor), num_sessions);

            /* Register the process. */
            const sf::ClientProcessId process_id{0};
            R_ABORT_UNLESS(g_manager->RegisterProcessId(process_id));
            R_ABORT_UNLESS(g_monitor->MonitorManager(process_id));

            /* Allocate a tls slot for our last error. */
            os::SdkAllocateTlsSlot(std::addressof(g_tls_slot), nullptr);

            /* Setup the virtual socket collection. */
            AMS_ASSERT(buffer != nullptr);
            g_sockets = reinterpret_cast<client::VirtualSocketCollection *>(buffer);
            std::construct_at(g_sockets);
            g_sockets->Init(static_cast<u8 *>(buffer) + sizeof(*g_sockets), buffer_size - sizeof(*g_sockets));

            /* Mark initialized. */
            g_initialized = true;
        }

        void InitializeImpl(AllocateFunction allocate, DeallocateFunction deallocate, int num_sessions, int num_sockets) {
            /* Check the session count. */
            AMS_ASSERT(0 < num_sessions && num_sessions <= SessionCountMax);

            /* Set the allocation functions. */
            g_allocate_function   = allocate;
            g_deallocate_function = deallocate;

            /* Allocate a buffer. */
            g_buffer_size = sizeof(client::VirtualSocketCollection) + client::VirtualSocketCollection::GetWorkingMemorySize(num_sockets);
            g_buffer      = g_allocate_function(g_buffer_size);

            /* Initialize. */
            InitializeImpl(g_buffer, g_buffer_size, num_sessions);
        }

    }

    bool IsInitialized() {
        return g_initialized;
    }

    size_t GetWorkingMemorySize(int num_sockets) {
        AMS_ASSERT(num_sockets <= SocketCountMax);
        return sizeof(client::VirtualSocketCollection) + client::VirtualSocketCollection::GetWorkingMemorySize(num_sockets);
    }

    void Initialize(AllocateFunction allocate, DeallocateFunction deallocate, int num_sessions) {
        /* Check that we're not already initialized. */
        AMS_ASSERT(!IsInitialized());

        /* Configure disconnection emulation. */
        g_enable_disconnection_emulation = true;

        /* Initialize. */
        InitializeImpl(allocate, deallocate, num_sessions, htcs::SocketCountMax);
    }

    void Initialize(void *buffer, size_t buffer_size) {
        /* Check that we're not already initialized. */
        AMS_ASSERT(!IsInitialized());

        /* Configure disconnection emulation. */
        g_enable_disconnection_emulation = true;

        /* Initialize. */
        InitializeImpl(buffer, buffer_size, htcs::SessionCountMax);
    }

    void InitializeForDisableDisconnectionEmulation(AllocateFunction allocate, DeallocateFunction deallocate, int num_sessions) {
        /* Check that we're not already initialized. */
        AMS_ASSERT(!IsInitialized());

        /* Configure disconnection emulation. */
        g_enable_disconnection_emulation = false;

        /* Initialize. */
        InitializeImpl(allocate, deallocate, num_sessions, htcs::SocketCountMax);
    }

    void InitializeForDisableDisconnectionEmulation(void *buffer, size_t buffer_size) {
        /* Check that we're not already initialized. */
        AMS_ASSERT(!IsInitialized());

        /* Configure disconnection emulation. */
        g_enable_disconnection_emulation = false;

        /* Initialize. */
        InitializeImpl(buffer, buffer_size, htcs::SessionCountMax);
    }

    void InitializeForSystem(void *buffer, size_t buffer_size, int num_sessions) {
        /* Check that we're not already initialized. */
        AMS_ASSERT(!IsInitialized());

        /* Configure disconnection emulation. */
        g_enable_disconnection_emulation = true;

        /* Initialize. */
        InitializeImpl(buffer, buffer_size, num_sessions);
    }

    void Finalize() {
        /* Check that we're initialized. */
        AMS_ASSERT(IsInitialized());

        /* Set not initialized. */
        g_initialized = false;

        /* Destroy the virtual socket collection. */
        std::destroy_at(g_sockets);
        g_sockets = nullptr;

        /* Free the buffer, if we have one. */
        if (g_buffer != nullptr) {
            g_deallocate_function(g_buffer, g_buffer_size);
            g_buffer      = nullptr;
            g_buffer_size = 0;
        }

        /* Free the tls slot. */
        os::FreeTlsSlot(g_tls_slot);

        /* Release the manager objects. */
        sf::ReleaseSharedObject(g_manager);
        sf::ReleaseSharedObject(g_monitor);
        g_manager = nullptr;
        g_monitor = nullptr;

        /* Finalize the htcs client sessions. */
        client::FinalizeSessionManager();
    }

    const HtcsPeerName GetPeerNameAny() {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Get name. */
        HtcsPeerName name;
        g_manager->GetPeerNameAny(std::addressof(name));

        return name;
    }

    const HtcsPeerName GetDefaultHostName() {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Get name. */
        HtcsPeerName name;
        g_manager->GetDefaultHostName(std::addressof(name));

        return name;
    }

    s32 GetLastError() {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        return static_cast<s32>(os::GetTlsValue(g_tls_slot));
    }

    s32 Socket() {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Socket(error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    s32 Close(s32 desc) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Close(desc, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    s32 Connect(s32 desc, const SockAddrHtcs *address) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Check that the address family is correct. */
        AMS_ASSERT(address->family == HTCS_AF_HTCS);

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Connect(desc, address, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    s32 Bind(s32 desc, const SockAddrHtcs *address) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Check that the address family is correct. */
        AMS_ASSERT(address->family == HTCS_AF_HTCS);

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Bind(desc, address, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    s32 Listen(s32 desc, s32 backlog_count) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Listen(desc, backlog_count, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    s32 Accept(s32 desc, SockAddrHtcs *address) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Ensure we have an address. */
        SockAddrHtcs tmp;
        if (address == nullptr) {
            address = std::addressof(tmp);
        }

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Accept(desc, address, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    s32 Shutdown(s32 desc, s32 how) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Shutdown(desc, how, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    s32 Fcntl(s32 desc, s32 command, s32 value) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Fcntl(desc, command, value, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    s32 Select(s32 count, FdSet *read, FdSet *write, FdSet *exception, TimeVal *timeout) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Check that we have some form of input. */
        if (read == nullptr && write == nullptr && exception == nullptr) {
            SetLastError(static_cast<uintptr_t>(HTCS_EINVAL));
            return -1;
        }

        /* Check that the timeout is valid. */
        if (timeout != nullptr && (timeout->tv_sec < 0 || timeout->tv_usec < 0)) {
            SetLastError(static_cast<uintptr_t>(HTCS_EINVAL));
            return -1;
        }

        /* Perform the operation. */
        s32 error_code = 0;
        const s32 ret = g_sockets->Select(read, write, exception, timeout, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    ssize_t Recv(s32 desc, void *buffer, size_t buffer_size, s32 flags) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Perform the operation. */
        s32 error_code = 0;
        const ssize_t ret = g_sockets->Recv(desc, buffer, buffer_size, flags, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    ssize_t Send(s32 desc, const void *buffer, size_t buffer_size, s32 flags) {
        /* Check that we have a manager. */
        AMS_ASSERT(g_manager != nullptr);

        /* Check that we have a socket collection. */
        AMS_ASSERT(g_sockets != nullptr);

        /* Perform the operation. */
        s32 error_code = 0;
        const ssize_t ret = g_sockets->Send(desc, buffer, buffer_size, flags, error_code);
        if (ret < 0) {
            SetLastError(static_cast<uintptr_t>(error_code));
        }

        return ret;
    }

    void FdSetZero(FdSet *set) {
        AMS_ASSERT(set != nullptr);

        std::memset(set, 0, sizeof(*set));
    }

    void FdSetSet(s32 fd, FdSet *set) {
        AMS_ASSERT(set != nullptr);

        for (auto i = 0; i < FdSetSize; ++i) {
            if (set->fds[i] == 0) {
                set->fds[i] = fd;
                break;
            }
        }
    }

    void FdSetClr(s32 fd, FdSet *set) {
        AMS_ASSERT(set != nullptr);

        for (auto i = 0; i < FdSetSize; ++i) {
            if (set->fds[i] == fd) {
                std::memcpy(set->fds + i, set->fds + i + 1, (FdSetSize - (i + 1)) * sizeof(fd));
                set->fds[FdSetSize - 1] = 0;
                break;
            }
        }
    }

    bool FdSetIsSet(s32 fd, const FdSet *set) {
        AMS_ASSERT(set != nullptr);

        for (auto i = 0; i < FdSetSize; ++i) {
            if (set->fds[i] == fd) {
                return true;
            }
        }

        return false;
    }

    namespace client {

        sf::SharedPointer<tma::ISocket> socket(s32 &last_error) {
            sf::SharedPointer<tma::ISocket> socket = nullptr;
            R_ABORT_UNLESS(g_manager->CreateSocket(std::addressof(last_error), std::addressof(socket), g_enable_disconnection_emulation));
            return socket;
        }

        s32 close(sf::SharedPointer<tma::ISocket> socket, s32 &last_error) {
            s32 res;
            socket->Close(std::addressof(last_error), std::addressof(res));
            return res;
        }

        s32 bind(sf::SharedPointer<tma::ISocket> socket, const htcs::SockAddrHtcs *address, s32 &last_error) {
            /* Create null-terminated address. */
            htcs::SockAddrHtcs null_terminated_address;
            null_terminated_address.family = address->family;
            util::Strlcpy(null_terminated_address.peer_name.name, address->peer_name.name, PeerNameBufferLength);
            util::Strlcpy(null_terminated_address.port_name.name, address->port_name.name, PortNameBufferLength);

            s32 res;
            socket->Bind(std::addressof(last_error), std::addressof(res), null_terminated_address);
            return res;
        }

        s32 listen(sf::SharedPointer<tma::ISocket> socket, s32 backlog_count, s32 &last_error) {
            s32 res;
            socket->Listen(std::addressof(last_error), std::addressof(res), backlog_count);
            return res;
        }

        sf::SharedPointer<tma::ISocket> accept(sf::SharedPointer<tma::ISocket> socket, htcs::SockAddrHtcs *address, s32 &last_error) {
            /* Begin the accept. */
            sf::SharedPointer<tma::ISocket> res = nullptr;
            u32 task_id = 0;
            sf::CopyHandle event_handle;
            if (R_SUCCEEDED(socket->AcceptStart(std::addressof(task_id), std::addressof(event_handle)))) {
                /* Create system event. */
                os::SystemEventType event;
                os::AttachReadableHandleToSystemEvent(std::addressof(event), event_handle.GetValue(), true, os::EventClearMode_ManualClear);

                /* When we're done, clean up the event. */
                ON_SCOPE_EXIT { os::DestroySystemEvent(std::addressof(event)); };

                /* Wait for the accept to finish. */
                os::WaitSystemEvent(std::addressof(event));

                /* End the accept. */
                socket->AcceptResults(std::addressof(last_error), std::addressof(res), address, task_id);
            } else {
                /* Set error. */
                last_error = HTCS_EINTR;
            }

            /* Sleep, if an error occurred. */
            if (last_error != HTCS_ENONE) {
                os::SleepThread(TimeSpan::FromMilliSeconds(1));
            }

            return res;
        }

        s32 fcntl(sf::SharedPointer<tma::ISocket> socket, s32 command, s32 value, s32 &last_error) {
            s32 res;
            socket->Fcntl(std::addressof(last_error), std::addressof(res), command, value);
            return res;
        }

        s32 shutdown(sf::SharedPointer<tma::ISocket> socket, s32 how, s32 &last_error) {
            s32 res;
            socket->Shutdown(std::addressof(last_error), std::addressof(res), how);
            return res;
        }

        s32 connect(sf::SharedPointer<tma::ISocket> socket, const htcs::SockAddrHtcs *address, s32 &last_error) {
            /* Create null-terminated address. */
            htcs::SockAddrHtcs null_terminated_address;
            null_terminated_address.family = address->family;
            util::Strlcpy(null_terminated_address.peer_name.name, address->peer_name.name, PeerNameBufferLength);
            util::Strlcpy(null_terminated_address.port_name.name, address->port_name.name, PortNameBufferLength);

            s32 res;
            socket->Connect(std::addressof(last_error), std::addressof(res), null_terminated_address);
            return res;
        }

        s32 select(s32 * const read, s32 &num_read, s32 * const write, s32 &num_write, s32 * const except, s32 &num_except, htcs::TimeVal *timeout, s32 &last_error) {
            /* Determine the timeout values. */
            s64 tv_sec  = -1;
            s64 tv_usec = -1;
            if (timeout != nullptr) {
                tv_sec  = timeout->tv_sec;
                tv_usec = timeout->tv_usec;
            }

            using InArray  = sf::InMapAliasArray<s32>;
            using OutArray = sf::OutMapAliasArray<s32>;

            /* Begin the select. */
            s32 res = -1;
            u32 task_id = 0;
            sf::CopyHandle event_handle;
            if (R_SUCCEEDED(g_manager->StartSelect(std::addressof(task_id), std::addressof(event_handle), InArray(read, num_read), InArray(write, num_write), InArray(except, num_except), tv_sec, tv_usec))) {
                /* Create system event. */
                os::SystemEventType event;
                os::AttachReadableHandleToSystemEvent(std::addressof(event), event_handle.GetValue(), true, os::EventClearMode_ManualClear);

                /* When we're done, clean up the event. */
                ON_SCOPE_EXIT { os::DestroySystemEvent(std::addressof(event)); };

                /* Wait for the select to finish. */
                os::WaitSystemEvent(std::addressof(event));

                /* End the select. */
                g_manager->EndSelect(std::addressof(last_error), std::addressof(res), OutArray(read, num_read), OutArray(write, num_write), OutArray(except, num_except), task_id);
            } else {
                /* Set error. */
                last_error = HTCS_EINTR;
                os::SleepThread(TimeSpan::FromMilliSeconds(1));
            }

            return res;
        }

        namespace {

            constexpr size_t MaximumBufferSizeForSmallTransfer = 0xDFE0;

            ssize_t recvLarge(sf::SharedPointer<tma::ISocket> socket, void *buffer, size_t buffer_size, s32 flags, s32 &last_error) {
                /* Setup. */
                s64 res = -1;
                last_error = HTCS_EINTR;

                /* Start the receive. */
                u32 task_id = 0;
                sf::CopyHandle event_handle;
                if (R_SUCCEEDED(socket->StartRecv(std::addressof(task_id), std::addressof(event_handle), static_cast<s64>(buffer_size), flags))) {
                    /* Create system event. */
                    os::SystemEventType event;
                    os::AttachReadableHandleToSystemEvent(std::addressof(event), event_handle.GetValue(), true, os::EventClearMode_ManualClear);

                    /* When we're done, clean up the event. */
                    ON_SCOPE_EXIT { os::DestroySystemEvent(std::addressof(event)); };

                    /* Wait for the receive to finish. */
                    os::WaitSystemEvent(std::addressof(event));

                    /* End the receive. */
                    socket->EndRecv(std::addressof(last_error), std::addressof(res), sf::OutAutoSelectBuffer(buffer, buffer_size), task_id);
                } else {
                    /* Set error. */
                    last_error = HTCS_EINTR;
                    os::SleepThread(TimeSpan::FromMilliSeconds(1));
                }

                return static_cast<ssize_t>(res);
            }

            ssize_t sendLarge(sf::SharedPointer<tma::ISocket> socket, const void *buffer, size_t buffer_size, s32 flags, s32 &last_error) {
                /* Setup. */
                s64 res = -1;
                last_error = HTCS_EINTR;

                /* Start the send. */
                u32 task_id = 0;
                s64 max_size = 0;
                sf::CopyHandle event_handle;
                if (R_SUCCEEDED(socket->StartSend(std::addressof(task_id), std::addressof(event_handle), std::addressof(max_size), static_cast<s64>(buffer_size), flags))) {
                    /* Create system event. */
                    os::SystemEventType event;
                    os::AttachReadableHandleToSystemEvent(std::addressof(event), event_handle.GetValue(), true, os::EventClearMode_ManualClear);

                    /* When we're done, clean up the event. */
                    ON_SCOPE_EXIT { os::DestroySystemEvent(std::addressof(event)); };

                    /* Send all the data. */
                    bool done = false;
                    size_t sent = 0;
                    while (sent < buffer_size) {
                        /* Determine how much to send, this iteration. */
                        const u8 *cur = static_cast<const u8 *>(buffer) + sent;
                        const s64 cur_size = std::min(max_size, static_cast<s64>(buffer_size - sent));

                        /* Continue sending data. */
                        s64 cur_sent = 0;
                        bool wait = false;
                        const Result result = socket->ContinueSend(std::addressof(cur_sent), std::addressof(wait), sf::InNonSecureAutoSelectBuffer(cur, cur_size), task_id);
                        if (cur_sent <= 0 || R_FAILED(result)) {
                            done = true;
                            break;
                        }

                        /* Wait if we should. */
                        if (wait) {
                            os::WaitSystemEvent(std::addressof(event));
                            os::ClearSystemEvent(std::addressof(event));
                        }

                        /* Advance. */
                        sent += cur_sent;
                    }

                    /* Wait for the send to finish. */
                    if (!done) {
                        os::WaitSystemEvent(std::addressof(event));
                    }

                    /* End the send. */
                    socket->EndSend(std::addressof(last_error), std::addressof(res), task_id);
                } else {
                    /* Set error. */
                    last_error = HTCS_EINTR;
                    os::SleepThread(TimeSpan::FromMilliSeconds(1));
                }

                return static_cast<ssize_t>(res);
            }

        }

        ssize_t recv(sf::SharedPointer<tma::ISocket> socket, void *buffer, size_t buffer_size, s32 flags, s32 &last_error) {
            /* Determine how much to receive. */
            size_t recv_size = buffer_size;

            if ((flags & HTCS_MSG_WAITALL) == 0) {
                recv_size = std::min(MaximumBufferSizeForSmallTransfer, buffer_size);
            }

            /* Perform a large receive, if we have to. */
            if (recv_size > MaximumBufferSizeForSmallTransfer) {
                return recvLarge(socket, buffer, recv_size, flags, last_error);
            }

            /* Start the receive. */
            s64 res = -1;
            u32 task_id = 0;
            sf::CopyHandle event_handle;
            if (R_SUCCEEDED(socket->RecvStart(std::addressof(task_id), std::addressof(event_handle), static_cast<s32>(recv_size), flags))) {
                /* Create system event. */
                os::SystemEventType event;
                os::AttachReadableHandleToSystemEvent(std::addressof(event), event_handle.GetValue(), true, os::EventClearMode_ManualClear);

                /* When we're done, clean up the event. */
                ON_SCOPE_EXIT { os::DestroySystemEvent(std::addressof(event)); };

                /* Wait for the receive to finish. */
                os::WaitSystemEvent(std::addressof(event));

                /* End the receive. */
                socket->RecvResults(std::addressof(last_error), std::addressof(res), sf::OutAutoSelectBuffer(buffer, recv_size), task_id);
            } else {
                /* Set error. */
                last_error = HTCS_EINTR;
                os::SleepThread(TimeSpan::FromMilliSeconds(1));
            }

            return static_cast<ssize_t>(res);
        }

        ssize_t send(sf::SharedPointer<tma::ISocket> socket, const void *buffer, size_t buffer_size, s32 flags, s32 &last_error) {
            /* Perform a large send, if we have to. */
            if (buffer_size > MaximumBufferSizeForSmallTransfer) {
                return sendLarge(socket, buffer, buffer_size, flags, last_error);
            }

            /* Start the send. */
            s64 res = -1;
            u32 task_id = 0;
            sf::CopyHandle event_handle;
            if (R_SUCCEEDED(socket->SendStart(std::addressof(task_id), std::addressof(event_handle), sf::InNonSecureAutoSelectBuffer(buffer, buffer_size), flags))) {
                /* Create system event. */
                os::SystemEventType event;
                os::AttachReadableHandleToSystemEvent(std::addressof(event), event_handle.GetValue(), true, os::EventClearMode_ManualClear);

                /* When we're done, clean up the event. */
                ON_SCOPE_EXIT { os::DestroySystemEvent(std::addressof(event)); };

                /* Wait for the send to finish. */
                os::WaitSystemEvent(std::addressof(event));

                /* End the send. */
                socket->SendResults(std::addressof(last_error), std::addressof(res), task_id);
            } else {
                /* Set error. */
                last_error = HTCS_EINTR;
                os::SleepThread(TimeSpan::FromMilliSeconds(1));
            }

            return static_cast<ssize_t>(res);
        }

    }

}