From e3782a7f99519f4a7889f29661eb983ccec562eb Mon Sep 17 00:00:00 2001 From: Andreas Kling Date: Mon, 22 Jun 2020 21:35:22 +0200 Subject: [PATCH] ImageDecoder: Add a new service for out-of-process image decoding :^) The new ImageDecoder service (available for members of "image" via /tmp/portal/image) allows you to decode images in a separate process. This will allow programs to confidently load untrusted images, since the bulk of the security concerns are sandboxed to a separate process. The only API right now is a synchronous IPC DecodeImage() call that takes a shbuf with encoded image data and returns a shared buffer and metadata for the decoded image. It also comes with a very simple library for interfacing with the ImageDecoder service: LibImageDecoderClient. The name is a bit of a mouthful but I guess we can rename it later if we think of something nicer to call it. There's obviously a bit of overhead to spawning a separate process for every image decode, so this is mostly only appropriate for untrusted images (e.g stuff downloaded from the web) and not necessary for trusted local images (e.g stuff in /res) --- Base/etc/SystemServer.ini | 9 ++ Base/etc/group | 1 + Base/etc/passwd | 1 + Libraries/CMakeLists.txt | 1 + Libraries/LibGfx/Bitmap.cpp | 53 ++++++--- Libraries/LibGfx/Bitmap.h | 28 ++++- .../LibImageDecoderClient/CMakeLists.txt | 11 ++ Libraries/LibImageDecoderClient/Client.cpp | 88 +++++++++++++++ Libraries/LibImageDecoderClient/Client.h | 52 +++++++++ Services/CMakeLists.txt | 1 + Services/ImageDecoder/CMakeLists.txt | 12 +++ Services/ImageDecoder/ClientConnection.cpp | 102 ++++++++++++++++++ Services/ImageDecoder/ClientConnection.h | 55 ++++++++++ Services/ImageDecoder/Forward.h | 34 ++++++ Services/ImageDecoder/ImageDecoderClient.ipc | 4 + Services/ImageDecoder/ImageDecoderServer.ipc | 7 ++ Services/ImageDecoder/main.cpp | 51 +++++++++ 17 files changed, 491 insertions(+), 19 deletions(-) create mode 100644 Libraries/LibImageDecoderClient/CMakeLists.txt create mode 100644 Libraries/LibImageDecoderClient/Client.cpp create mode 100644 Libraries/LibImageDecoderClient/Client.h create mode 100644 Services/ImageDecoder/CMakeLists.txt create mode 100644 Services/ImageDecoder/ClientConnection.cpp create mode 100644 Services/ImageDecoder/ClientConnection.h create mode 100644 Services/ImageDecoder/Forward.h create mode 100644 Services/ImageDecoder/ImageDecoderClient.ipc create mode 100644 Services/ImageDecoder/ImageDecoderServer.ipc create mode 100644 Services/ImageDecoder/main.cpp diff --git a/Base/etc/SystemServer.ini b/Base/etc/SystemServer.ini index 0f2d12a3dfb..e24dd6c914c 100644 --- a/Base/etc/SystemServer.ini +++ b/Base/etc/SystemServer.ini @@ -16,6 +16,15 @@ BootModes=graphical MultiInstance=1 AcceptSocketConnections=1 +[ImageDecoder] +Socket=/tmp/portal/image +SocketPermissions=660 +Lazy=1 +User=image +BootModes=graphical +MultiInstance=1 +AcceptSocketConnections=1 + [LookupServer] Socket=/tmp/portal/lookup SocketPermissions=660 diff --git a/Base/etc/group b/Base/etc/group index 5dd2b89ac34..374eeca8aa4 100644 --- a/Base/etc/group +++ b/Base/etc/group @@ -9,4 +9,5 @@ notify:x:12:anon window:x:13:anon,notify clipboard:x:14:anon,notify webcontent:x:15:anon +image:x:16:anon,webcontent users:x:100:anon diff --git a/Base/etc/passwd b/Base/etc/passwd index d52852ce2cd..7179b42dd8a 100644 --- a/Base/etc/passwd +++ b/Base/etc/passwd @@ -5,5 +5,6 @@ notify:x:12:12:NotificationServer,,,:/:/bin/false window:x:13:13:WindowServer,,,:/:/bin/false clipboard:x:14:14:Clipboard,,,:/:/bin/false webcontent:x:15:15:WebContent,,,:/:/bin/false +image:x:16:16:ImageDecoder,,,:/:/bin/false anon:x:100:100:Anonymous,,,:/home/anon:/bin/sh nona:x:200:200:Nona,,,:/home/nona:/bin/sh diff --git a/Libraries/CMakeLists.txt b/Libraries/CMakeLists.txt index 9d5eb6703ce..41e3fedb565 100644 --- a/Libraries/CMakeLists.txt +++ b/Libraries/CMakeLists.txt @@ -9,6 +9,7 @@ add_subdirectory(LibGfx) add_subdirectory(LibGUI) add_subdirectory(LibHTTP) add_subdirectory(LibIPC) +add_subdirectory(LibImageDecoderClient) add_subdirectory(LibJS) add_subdirectory(LibKeyboard) add_subdirectory(LibLine) diff --git a/Libraries/LibGfx/Bitmap.cpp b/Libraries/LibGfx/Bitmap.cpp index d1d34069d66..03831bafab2 100644 --- a/Libraries/LibGfx/Bitmap.cpp +++ b/Libraries/LibGfx/Bitmap.cpp @@ -28,13 +28,13 @@ #include #include #include -#include #include +#include #include +#include #include #include #include -#include #include #include #include @@ -71,7 +71,7 @@ Bitmap::Bitmap(BitmapFormat format, const IntSize& size, Purgeable purgeable) { ASSERT(!m_size.is_empty()); ASSERT(!size_would_overflow(format, size)); - allocate_palette_from_format(format); + allocate_palette_from_format(format, {}); int map_flags = purgeable == Purgeable::Yes ? (MAP_PURGEABLE | MAP_PRIVATE) : (MAP_ANONYMOUS | MAP_PRIVATE); m_data = (RGBA32*)mmap_with_name(nullptr, size_in_bytes(), PROT_READ | PROT_WRITE, map_flags, 0, 0, String::format("GraphicsBitmap [%dx%d]", width(), height()).characters()); ASSERT(m_data && m_data != (void*)-1); @@ -103,25 +103,35 @@ Bitmap::Bitmap(BitmapFormat format, const IntSize& size, size_t pitch, RGBA32* d , m_format(format) { ASSERT(!size_would_overflow(format, size)); - allocate_palette_from_format(format); + allocate_palette_from_format(format, {}); } RefPtr Bitmap::create_with_shared_buffer(BitmapFormat format, NonnullRefPtr&& shared_buffer, const IntSize& size) { if (size_would_overflow(format, size)) return nullptr; - return adopt(*new Bitmap(format, move(shared_buffer), size)); + return adopt(*new Bitmap(format, move(shared_buffer), size, {})); } -Bitmap::Bitmap(BitmapFormat format, NonnullRefPtr&& shared_buffer, const IntSize& size) +RefPtr Bitmap::create_with_shared_buffer(BitmapFormat format, NonnullRefPtr&& shared_buffer, const IntSize& size, const Vector& palette) +{ + if (size_would_overflow(format, size)) + return nullptr; + return adopt(*new Bitmap(format, move(shared_buffer), size, palette)); +} + +Bitmap::Bitmap(BitmapFormat format, NonnullRefPtr&& shared_buffer, const IntSize& size, const Vector& palette) : m_size(size) , m_data((RGBA32*)shared_buffer->data()) , m_pitch(round_up_to_power_of_two(size.width() * sizeof(RGBA32), 16)) , m_format(format) , m_shared_buffer(move(shared_buffer)) { - ASSERT(!is_indexed(format)); + ASSERT(!is_indexed() || !palette.is_empty()); ASSERT(!size_would_overflow(format, size)); + + if (is_indexed(m_format)) + allocate_palette_from_format(m_format, palette); } RefPtr Bitmap::rotated(Gfx::RotationDirection rotation_direction) const @@ -175,7 +185,7 @@ RefPtr Bitmap::to_bitmap_backed_by_shared_buffer() const if (m_shared_buffer) return *this; auto buffer = SharedBuffer::create_with_size(size_in_bytes()); - auto bitmap = Bitmap::create_with_shared_buffer(m_format, *buffer, m_size); + auto bitmap = Bitmap::create_with_shared_buffer(m_format, *buffer, m_size, palette_to_vector()); if (!bitmap) return nullptr; memcpy(buffer->data(), scanline(0), size_in_bytes()); @@ -249,17 +259,26 @@ ShareableBitmap Bitmap::to_shareable_bitmap(pid_t peer_pid) const return ShareableBitmap(*bitmap); } -void Bitmap::allocate_palette_from_format(BitmapFormat format) +void Bitmap::allocate_palette_from_format(BitmapFormat format, const Vector& source_palette) { - if (format == BitmapFormat::Indexed1) { - m_palette = new RGBA32[2]; - } else if (format == BitmapFormat::Indexed2) { - m_palette = new RGBA32[4]; - } else if (format == BitmapFormat::Indexed4) { - m_palette = new RGBA32[16]; - } else if (format == BitmapFormat::Indexed8) { - m_palette = new RGBA32[256]; + size_t size = palette_size(format); + if (size == 0) + return; + m_palette = new RGBA32[size]; + if (!source_palette.is_empty()) { + ASSERT(source_palette.size() == size); + memcpy(m_palette, source_palette.data(), size * sizeof(RGBA32)); } } +Vector Bitmap::palette_to_vector() const +{ + Vector vector; + auto size = palette_size(m_format); + vector.ensure_capacity(size); + for (size_t i = 0; i < size; ++i) + vector.unchecked_append(palette_color(i).value()); + return vector; +} + } diff --git a/Libraries/LibGfx/Bitmap.h b/Libraries/LibGfx/Bitmap.h index b6fac7fffeb..999130fb23a 100644 --- a/Libraries/LibGfx/Bitmap.h +++ b/Libraries/LibGfx/Bitmap.h @@ -65,6 +65,7 @@ public: static RefPtr create_wrapper(BitmapFormat, const IntSize&, size_t pitch, RGBA32*); static RefPtr load_from_file(const StringView& path); static RefPtr create_with_shared_buffer(BitmapFormat, NonnullRefPtr&&, const IntSize&); + static RefPtr create_with_shared_buffer(BitmapFormat, NonnullRefPtr&&, const IntSize&, const Vector& palette); static bool is_path_a_supported_image_format(const StringView& path) { #define __ENUMERATE_IMAGE_FORMAT(Name, Ext) \ @@ -102,12 +103,35 @@ public: SharedBuffer* shared_buffer() { return m_shared_buffer.ptr(); } const SharedBuffer* shared_buffer() const { return m_shared_buffer.ptr(); } + ALWAYS_INLINE bool is_indexed() const + { + return is_indexed(m_format); + } + ALWAYS_INLINE static bool is_indexed(BitmapFormat format) { return format == BitmapFormat::Indexed8 || format == BitmapFormat::Indexed4 || format == BitmapFormat::Indexed2 || format == BitmapFormat::Indexed1; } + size_t palette_size(BitmapFormat format) const + { + switch (format) { + case BitmapFormat::Indexed1: + return 2; + case BitmapFormat::Indexed2: + return 4; + case BitmapFormat::Indexed4: + return 16; + case BitmapFormat::Indexed8: + return 256; + default: + return 0; + } + } + + Vector palette_to_vector() const; + static unsigned bpp_for_format(BitmapFormat format) { switch (format) { @@ -186,9 +210,9 @@ private: Yes }; Bitmap(BitmapFormat, const IntSize&, Purgeable); Bitmap(BitmapFormat, const IntSize&, size_t pitch, RGBA32*); - Bitmap(BitmapFormat, NonnullRefPtr&&, const IntSize&); + Bitmap(BitmapFormat, NonnullRefPtr&&, const IntSize&, const Vector& palette); - void allocate_palette_from_format(BitmapFormat); + void allocate_palette_from_format(BitmapFormat, const Vector& source_palette ); IntSize m_size; RGBA32* m_data { nullptr }; diff --git a/Libraries/LibImageDecoderClient/CMakeLists.txt b/Libraries/LibImageDecoderClient/CMakeLists.txt new file mode 100644 index 00000000000..72a5ab29346 --- /dev/null +++ b/Libraries/LibImageDecoderClient/CMakeLists.txt @@ -0,0 +1,11 @@ +set(SOURCES + Client.cpp +) + +set(GENERATED_SOURCES + ../../Services/ImageDecoder/ImageDecoderClientEndpoint.h + ../../Services/ImageDecoder/ImageDecoderServerEndpoint.h +) + +serenity_lib(LibImageDecoderClient imagedecoderclient) +target_link_libraries(LibImageDecoderClient LibIPC LibGfx) diff --git a/Libraries/LibImageDecoderClient/Client.cpp b/Libraries/LibImageDecoderClient/Client.cpp new file mode 100644 index 00000000000..9aa7b2a4cd5 --- /dev/null +++ b/Libraries/LibImageDecoderClient/Client.cpp @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2020, Andreas Kling + * 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 +#include + +namespace ImageDecoderClient { + +Client::Client() + : IPC::ServerConnection(*this, "/tmp/portal/image") +{ + handshake(); +} + +void Client::handshake() +{ + auto response = send_sync(getpid()); + set_my_client_id(response->client_id()); + set_server_pid(response->server_pid()); +} + +void Client::handle(const Messages::ImageDecoderClient::Dummy&) +{ +} + +RefPtr Client::decode_image(const ByteBuffer& encoded_data) +{ + if (encoded_data.is_empty()) + return nullptr; + + auto encoded_buffer = SharedBuffer::create_with_size(encoded_data.size()); + if (!encoded_buffer) { + dbg() << "Could not allocate encoded shbuf"; + return nullptr; + } + + memcpy(encoded_buffer->data(), encoded_data.data(), encoded_data.size()); + + encoded_buffer->seal(); + encoded_buffer->share_with(server_pid()); + + auto response = send_sync(encoded_buffer->shbuf_id(), encoded_data.size()); + auto bitmap_format = (Gfx::BitmapFormat)response->bitmap_format(); + if (bitmap_format == Gfx::BitmapFormat::Invalid) { +#ifdef IMAGE_DECODER_CLIENT_DEBUG + dbg() << "Response image was invalid"; +#endif + return nullptr; + } + + if (response->size().is_empty()) { + dbg() << "Response image was empty"; + return nullptr; + } + + auto decoded_buffer = SharedBuffer::create_from_shbuf_id(response->decoded_shbuf_id()); + if (!decoded_buffer) { + dbg() << "Could not map decoded image shbuf_id=" << response->decoded_shbuf_id(); + return nullptr; + } + + return Gfx::Bitmap::create_with_shared_buffer(bitmap_format, decoded_buffer.release_nonnull(), response->size(), response->palette()); +} + +} diff --git a/Libraries/LibImageDecoderClient/Client.h b/Libraries/LibImageDecoderClient/Client.h new file mode 100644 index 00000000000..7eeace6b22d --- /dev/null +++ b/Libraries/LibImageDecoderClient/Client.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2020, Andreas Kling + * 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 +#include +#include +#include + +namespace ImageDecoderClient { + +class Client + : public IPC::ServerConnection + , public ImageDecoderClientEndpoint { + C_OBJECT(Client); + +public: + virtual void handshake() override; + + RefPtr decode_image(const ByteBuffer&); + +private: + Client(); + + virtual void handle(const Messages::ImageDecoderClient::Dummy&) override; +}; + +} diff --git a/Services/CMakeLists.txt b/Services/CMakeLists.txt index 364c7ea574d..71a343a009d 100644 --- a/Services/CMakeLists.txt +++ b/Services/CMakeLists.txt @@ -1,6 +1,7 @@ add_subdirectory(AudioServer) add_subdirectory(Clipboard) add_subdirectory(DHCPClient) +add_subdirectory(ImageDecoder) add_subdirectory(LaunchServer) add_subdirectory(LookupServer) add_subdirectory(NotificationServer) diff --git a/Services/ImageDecoder/CMakeLists.txt b/Services/ImageDecoder/CMakeLists.txt new file mode 100644 index 00000000000..ce9ad077fc4 --- /dev/null +++ b/Services/ImageDecoder/CMakeLists.txt @@ -0,0 +1,12 @@ +compile_ipc(ImageDecoderServer.ipc ImageDecoderServerEndpoint.h) +compile_ipc(ImageDecoderClient.ipc ImageDecoderClientEndpoint.h) + +set(SOURCES + ClientConnection.cpp + main.cpp + ImageDecoderServerEndpoint.h + ImageDecoderClientEndpoint.h +) + +serenity_bin(ImageDecoder) +target_link_libraries(ImageDecoder LibIPC LibGfx) diff --git a/Services/ImageDecoder/ClientConnection.cpp b/Services/ImageDecoder/ClientConnection.cpp new file mode 100644 index 00000000000..ce7ec85d6b3 --- /dev/null +++ b/Services/ImageDecoder/ClientConnection.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2020, Andreas Kling + * 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 +#include +#include +#include +#include +#include +#include + +namespace ImageDecoder { + +static HashMap> s_connections; + +ClientConnection::ClientConnection(Core::LocalSocket& socket, int client_id) + : IPC::ClientConnection(*this, socket, client_id) +{ + s_connections.set(client_id, *this); +} + +ClientConnection::~ClientConnection() +{ +} + +void ClientConnection::die() +{ + s_connections.remove(client_id()); + exit(0); +} + +OwnPtr ClientConnection::handle(const Messages::ImageDecoderServer::Greet& message) +{ + set_client_pid(message.client_pid()); + return make(client_id(), getpid()); +} + +OwnPtr ClientConnection::handle(const Messages::ImageDecoderServer::DecodeImage& message) +{ + auto encoded_buffer = SharedBuffer::create_from_shbuf_id(message.encoded_shbuf_id()); + if (!encoded_buffer) { +#ifdef IMAGE_DECODER_DEBUG + dbg() << "Could not map encoded data buffer"; +#endif + return nullptr; + } + + if (message.encoded_size() > (size_t)encoded_buffer->size()) { +#ifdef IMAGE_DECODER_DEBUG + dbg() << "Encoded buffer is smaller than encoded size"; +#endif + return nullptr; + } + +#ifdef IMAGE_DECODER_DEBUG + dbg() << "Trying to decode " << message.encoded_size() << " bytes of image(?) data in shbuf_id=" << message.encoded_shbuf_id() << " (shbuf size: " << encoded_buffer->size() << ")"; +#endif + + auto decoder = Gfx::ImageDecoder::create((const u8*)encoded_buffer->data(), message.encoded_size()); + auto bitmap = decoder->bitmap(); + + if (!bitmap) { +#ifdef IMAGE_DECODER_DEBUG + dbg() << "Could not decode image from encoded data"; +#endif + return make(-1, Gfx::IntSize(), (i32)Gfx::BitmapFormat::Invalid, Vector()); + } + + // FIXME: We should fix ShareableBitmap so you can send it in responses as well as requests.. + m_shareable_bitmap = bitmap->to_bitmap_backed_by_shared_buffer(); + m_shareable_bitmap->shared_buffer()->share_with(client_pid()); + Vector palette; + if (m_shareable_bitmap->is_indexed()) { + palette = m_shareable_bitmap->palette_to_vector(); + } + return make(m_shareable_bitmap->shbuf_id(), m_shareable_bitmap->size(), (i32)m_shareable_bitmap->format(), palette); +} + +} diff --git a/Services/ImageDecoder/ClientConnection.h b/Services/ImageDecoder/ClientConnection.h new file mode 100644 index 00000000000..3b47ed18945 --- /dev/null +++ b/Services/ImageDecoder/ClientConnection.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2020, Andreas Kling + * 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 +#include +#include +#include +#include + +namespace ImageDecoder { + +class ClientConnection final + : public IPC::ClientConnection + , public ImageDecoderServerEndpoint { + C_OBJECT(ClientConnection); + +public: + explicit ClientConnection(Core::LocalSocket&, int client_id); + ~ClientConnection() override; + + virtual void die() override; + +private: + virtual OwnPtr handle(const Messages::ImageDecoderServer::Greet&) override; + virtual OwnPtr handle(const Messages::ImageDecoderServer::DecodeImage&) override; + + RefPtr m_shareable_bitmap; +}; + +} diff --git a/Services/ImageDecoder/Forward.h b/Services/ImageDecoder/Forward.h new file mode 100644 index 00000000000..e43ca839609 --- /dev/null +++ b/Services/ImageDecoder/Forward.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2020, Andreas Kling + * 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 + +namespace WebContent { + +class ClientConnection; +class PageHost; + +} diff --git a/Services/ImageDecoder/ImageDecoderClient.ipc b/Services/ImageDecoder/ImageDecoderClient.ipc new file mode 100644 index 00000000000..49dc3862c25 --- /dev/null +++ b/Services/ImageDecoder/ImageDecoderClient.ipc @@ -0,0 +1,4 @@ +endpoint ImageDecoderClient = 7002 +{ + Dummy() =| +} diff --git a/Services/ImageDecoder/ImageDecoderServer.ipc b/Services/ImageDecoder/ImageDecoderServer.ipc new file mode 100644 index 00000000000..295454282fb --- /dev/null +++ b/Services/ImageDecoder/ImageDecoderServer.ipc @@ -0,0 +1,7 @@ +endpoint ImageDecoderServer = 7001 +{ + Greet(i32 client_pid) => (i32 client_id, i32 server_pid) + + DecodeImage(i32 encoded_shbuf_id, u32 encoded_size) => (i32 decoded_shbuf_id, Gfx::IntSize size, i32 bitmap_format, Vector palette) + +} diff --git a/Services/ImageDecoder/main.cpp b/Services/ImageDecoder/main.cpp new file mode 100644 index 00000000000..1ee15b14960 --- /dev/null +++ b/Services/ImageDecoder/main.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2020, Andreas Kling + * 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 +#include +#include +#include + +int main(int, char**) +{ + Core::EventLoop event_loop; + if (pledge("stdio shared_buffer unix", nullptr) < 0) { + perror("pledge"); + return 1; + } + if (unveil(nullptr, nullptr) < 0) { + perror("unveil"); + return 1; + } + + auto socket = Core::LocalSocket::take_over_accepted_socket_from_system_server(); + IPC::new_client_connection(*socket, 1); + if (pledge("stdio shared_buffer", nullptr) < 0) { + perror("pledge"); + return 1; + } + return event_loop.exec(); +}