1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-06-09 17:44:56 +09:00
ladybird/Userland/Libraries/LibIPC/Encoder.h
Andrew Kaster 6d4ba21832 LibIPC+Userland: Make IPC::File always own its file descriptor
Add factory functions to distinguish between when the owner of the File
wants to transfer ownership to the new IPC object (adopt) or to send a
copy of the same fd to the IPC peer (clone).

This behavior is more intuitive than the previous behavior. Previously,
an IPC::File would default to a shallow clone of the file descriptor,
only *actually* calling dup(2) for the fd when encoding or it into an
IPC MessageBuffer. Now the dup(2) for the fd is explicit in the clone_fd
factory function.
2024-04-19 06:34:07 -04:00

184 lines
3.9 KiB
C++

/*
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2023, Tim Flynn <trflynn89@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Concepts.h>
#include <AK/HashMap.h>
#include <AK/StdLibExtras.h>
#include <AK/Variant.h>
#include <LibCore/SharedCircularQueue.h>
#include <LibIPC/Concepts.h>
#include <LibIPC/File.h>
#include <LibIPC/Forward.h>
#include <LibIPC/Message.h>
#include <LibURL/Forward.h>
namespace IPC {
template<typename T>
ErrorOr<void> encode(Encoder&, T const&)
{
static_assert(DependentFalse<T>, "Base IPC::encode() was instantiated");
VERIFY_NOT_REACHED();
}
class Encoder {
public:
explicit Encoder(MessageBuffer& buffer)
: m_buffer(buffer)
{
}
template<typename T>
ErrorOr<void> encode(T const& value);
ErrorOr<void> extend_capacity(size_t capacity)
{
TRY(m_buffer.extend_data_capacity(capacity));
return {};
}
ErrorOr<void> append(u8 const* values, size_t count)
{
TRY(m_buffer.append_data(values, count));
return {};
}
ErrorOr<void> append_file_descriptor(int fd)
{
TRY(m_buffer.append_file_descriptor(fd));
return {};
}
ErrorOr<void> encode_size(size_t size);
private:
MessageBuffer& m_buffer;
};
template<Arithmetic T>
ErrorOr<void> encode(Encoder& encoder, T const& value)
{
TRY(encoder.append(reinterpret_cast<u8 const*>(&value), sizeof(value)));
return {};
}
template<Enum T>
ErrorOr<void> encode(Encoder& encoder, T const& value)
{
return encoder.encode(to_underlying(value));
}
template<>
ErrorOr<void> encode(Encoder&, float const&);
template<>
ErrorOr<void> encode(Encoder&, double const&);
template<>
ErrorOr<void> encode(Encoder&, String const&);
template<>
ErrorOr<void> encode(Encoder&, StringView const&);
template<>
ErrorOr<void> encode(Encoder&, ByteString const&);
template<>
ErrorOr<void> encode(Encoder&, ByteBuffer const&);
template<>
ErrorOr<void> encode(Encoder&, JsonValue const&);
template<>
ErrorOr<void> encode(Encoder&, Duration const&);
template<>
ErrorOr<void> encode(Encoder&, UnixDateTime const&);
template<>
ErrorOr<void> encode(Encoder&, URL::URL const&);
template<>
ErrorOr<void> encode(Encoder&, File const&);
template<>
ErrorOr<void> encode(Encoder&, Empty const&);
template<typename T, size_t N>
ErrorOr<void> encode(Encoder& encoder, Array<T, N> const& array)
{
TRY(encoder.encode_size(array.size()));
for (auto const& value : array)
TRY(encoder.encode(value));
return {};
}
template<Concepts::Vector T>
ErrorOr<void> encode(Encoder& encoder, T const& vector)
{
// NOTE: Do not change this encoding without also updating LibC/netdb.cpp.
TRY(encoder.encode_size(vector.size()));
for (auto const& value : vector)
TRY(encoder.encode(value));
return {};
}
template<Concepts::HashMap T>
ErrorOr<void> encode(Encoder& encoder, T const& hashmap)
{
TRY(encoder.encode_size(hashmap.size()));
for (auto it : hashmap) {
TRY(encoder.encode(it.key));
TRY(encoder.encode(it.value));
}
return {};
}
template<Concepts::SharedSingleProducerCircularQueue T>
ErrorOr<void> encode(Encoder& encoder, T const& queue)
{
TRY(encoder.encode(TRY(IPC::File::clone_fd(queue.fd()))));
return {};
}
template<Concepts::Optional T>
ErrorOr<void> encode(Encoder& encoder, T const& optional)
{
TRY(encoder.encode(optional.has_value()));
if (optional.has_value())
TRY(encoder.encode(optional.value()));
return {};
}
template<Concepts::Variant T>
ErrorOr<void> encode(Encoder& encoder, T const& variant)
{
TRY(encoder.encode(variant.index()));
return variant.visit([&](auto const& value) {
return encoder.encode(value);
});
}
// This must be last so that it knows about the above specializations.
template<typename T>
ErrorOr<void> Encoder::encode(T const& value)
{
return IPC::encode(*this, value);
}
}