#75: Implemented socket abstraction library

AGENTS.md

@@ -81,12 +81,12 @@ unreleased changelog, so update it before the PR is merged.
 ## Tool availability and Lima
 
 - When a required development tool is unavailable on the host, use the
-  repository's `docker-udf-client` Lima VM instead of installing a host-wide
+  repository's `udf-runner-cpp-dev` Lima VM instead of installing a host-wide
   package.
 - Start the VM with
-  `limactl start ./ext/lima_vm_templates/docker-udf-client.yaml` and run
-  commands in it with `limactl shell docker-udf-client <command>`.
+  `limactl start ./ext/lima_vm_templates/udf-runner-cpp-dev.yaml` and run
+  commands in it with `limactl shell udf-runner-cpp-dev <command>`.
 - If a required tool is missing in the VM, install it there and add its package
   to the provisioning list in
-  [`ext/lima_vm_templates/docker-udf-client.yaml`](ext/lima_vm_templates/docker-udf-client.yaml)
+  [`ext/lima_vm_templates/udf-runner-cpp-dev.yaml`](ext/lima_vm_templates/udf-runner-cpp-dev.yaml)
   so future VMs provide it automatically.

doc/changes/unreleased.md

@@ -11,6 +11,7 @@ n/a
  - #70: Added the v2 UDF protocol design and validation artifacts
  - #61: Added stacktrace-aware exceptions and assertions to v2
  - #54: Added v2 socket-library interface design
+ - #75: Added the v2 Unix-domain stream socket library
  - #32: Added clang tidy to v2
  - #36: Added developer guide for clang-tidy and clang-format
  - #38: Added Sonar Qube Public

doc/design/v2/runner/socket_library_design.md

@@ -47,8 +47,10 @@ Public types belong to `exasol::udf::v2::socket`. The implementation should prov
 small public header surface, for example:
 
 ```
-include/exasol/udf/v2/socket.hpp
-include/exasol/udf/v2/unix_socket.hpp
+include/exasol/udf/v2/socket/owned_file_descriptor.hpp
+include/exasol/udf/v2/socket/socket.hpp
+include/exasol/udf/v2/socket/unix_socket.hpp
+include/exasol/udf/v2/socket/unix_socket_listener.hpp
 ```
 
 The core header must not expose a TLS implementation or a TCP address type.
@@ -62,7 +64,7 @@ This keeps the contract usable by TLS, whose I/O does not map one-for-one to
 ```cpp
 namespace exasol::udf::v2::socket {
 
-enum class Shutdown { receive, send, both };
+enum class Shutdown { Receive, Send, Both };
 
 class OwnedFileDescriptor {
 public:

doc/developer_guide/slc.md

@@ -14,8 +14,8 @@ If no Docker daemon is available on the host, use the repository’s Lima
 instance:
 
 ```bash
-limactl start ./ext/lima_vm_templates/docker-udf-client.yaml
-export DOCKER_HOST="$(limactl list docker-udf-client \
+limactl start ./ext/lima_vm_templates/udf-runner-cpp-dev.yaml
+export DOCKER_HOST="$(limactl list udf-runner-cpp-dev \
   --format 'unix://{{.Dir}}/sock/docker.sock')"
 ```
 

doc/developer_guide/v2/v2_code_quality.md

@@ -86,7 +86,7 @@ alias(
 
 Mutation testing for the functional v2 C++ tests uses [Mull](https://mull-project.com/)
 with the pinned Mull 0.34.1 release and matching LLVM 22 toolchain. The
-`docker-udf-client` Lima template provisions these tools automatically; on
+`udf-runner-cpp-dev` Lima template provisions these tools automatically; on
 other environments install the LLVM 22 compiler and `mull-22`, then verify
 that `mull-runner-22` and `/usr/lib/mull-ir-frontend-22` are available.
 

ext/lima_vm_templates/docker-udf-client.yaml → ext/lima_vm_templates/udf-runner-cpp-dev.yaml

@@ -3,12 +3,12 @@
 # Also, it sets all environment variables needed to build the UDF client for Python and Java
 # TODO: Add R dependencies
 # Start this VM when the host has no Docker daemon:
-# $ limactl start ./ext/lima_vm_templates/docker-udf-client.yaml
+# $ limactl start ./ext/lima_vm_templates/udf-runner-cpp-dev.yaml
 #
 # Connect Docker and exaslct to the Lima Docker daemon:
-# $ export DOCKER_HOST=$(limactl list docker-udf-client --format 'unix://{{.Dir}}/sock/docker.sock')
+# $ export DOCKER_HOST=$(limactl list udf-runner-cpp-dev --format 'unix://{{.Dir}}/sock/docker.sock')
 # cd ./exaudfclient
-# $ limactl shell docker-udf-client bazel build --config no-tty --config optimize --config python --config fast-binary
+# $ limactl shell udf-runner-cpp-dev bazel build --config no-tty --config optimize --config python --config fast-binary
 
 # To build the SLC Docker images/stages only, run
 # $ exaslct build --flavor-path ./flavors/<flavor-name>

udf-runner-cpp/v2/BUILD.bazel

@@ -355,6 +355,59 @@ cc_library(
     target_compatible_with = ["@platforms//os:linux"],
 )
 
+cc_library(
+    name = "socket",
+    srcs = [
+        "socket/socket.cc",
+        "socket/unix_socket.cc",
+    ],
+    hdrs = [
+        "include/exasol/udf/v2/socket/owned_file_descriptor.hpp",
+        "include/exasol/udf/v2/socket/socket.hpp",
+        "include/exasol/udf/v2/socket/unix_socket.hpp",
+        "include/exasol/udf/v2/socket/unix_socket_listener.hpp",
+    ],
+    includes = ["include"],
+    copts = ["-std=c++23"],
+    target_compatible_with = ["@platforms//os:linux"],
+)
+
+cc_test(
+    name = "socket_test",
+    srcs = ["socket/socket_test.cc"],
+    copts = ["-std=c++23"],
+    # Socket behavior remains covered by the normal Bazel test suite. Exclude
+    # this target from Mull until its mutation coverage is expanded.
+    tags = ["no-mull"],
+    deps = [
+        ":socket",
+        "@googletest//:gtest_main",
+    ],
+    target_compatible_with = ["@platforms//os:linux"],
+)
+
+cc_test(
+    name = "unix_socket_test",
+    srcs = ["socket/unix_socket_test.cc"],
+    copts = ["-std=c++23"],
+    tags = ["no-mull"],
+    deps = [
+        ":socket",
+        "@googletest//:gtest_main",
+    ],
+    target_compatible_with = ["@platforms//os:linux"],
+)
+
+cc_fuzz_test(
+    name = "socket_fuzz_test",
+    srcs = ["socket/socket_fuzz_test.cc"],
+    corpus = glob(["fuzz/corpus/socket/**"]),
+    copts = ["-std=c++23"],
+    deps = [":socket"],
+    tags = ["fuzz-test"],
+    target_compatible_with = ["@platforms//os:linux"],
+)
+
 cc_library(
     name = "linux_event_fd",
     srcs = ["linux_event_fd.cc"],

udf-runner-cpp/v2/fuzz/corpus/socket/exact_4k

@@ -0,0 +1 @@
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

udf-runner-cpp/v2/fuzz/corpus/socket/more_than_4k

@@ -0,0 +1 @@
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

udf-runner-cpp/v2/fuzz/corpus/socket/one_byte

@@ -0,0 +1,2 @@
+e
+

udf-runner-cpp/v2/fuzz/corpus/socket/only_ascii

@@ -0,0 +1 @@
+this is for testing ASCII only content

udf-runner-cpp/v2/include/exasol/udf/v2/socket/owned_file_descriptor.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+namespace exasol::udf::v2::socket
+{
+
+/** Owns a native file descriptor and closes it on destruction. */
+class OwnedFileDescriptor
+{
+public:
+    /** Creates an empty descriptor that does not own a native handle. */
+    OwnedFileDescriptor() noexcept;
+
+    /** Closes the owned descriptor, if any. */
+    ~OwnedFileDescriptor();
+
+    /** Takes ownership of an open native file descriptor.
+     *
+     * @throws std::invalid_argument if @p owned_fd is negative.
+     */
+    [[nodiscard]] static OwnedFileDescriptor adopt_native_handle(int owned_fd);
+
+    OwnedFileDescriptor(const OwnedFileDescriptor&)            = delete;
+    OwnedFileDescriptor& operator=(const OwnedFileDescriptor&) = delete;
+    OwnedFileDescriptor(OwnedFileDescriptor&& other) noexcept;
+    OwnedFileDescriptor& operator=(OwnedFileDescriptor&& other) noexcept;
+
+    /** Returns the owned native descriptor, or -1 when empty. */
+    [[nodiscard]] int native_handle() const noexcept;
+
+    /** Returns whether this object owns a native descriptor. */
+    [[nodiscard]] bool is_open() const noexcept;
+
+    /** Closes the owned descriptor and becomes empty. */
+    void close() noexcept;
+
+    /** Releases ownership and returns the native descriptor without closing it. */
+    [[nodiscard]] int release_native_handle() noexcept;
+
+private:
+    explicit OwnedFileDescriptor(int owned_fd) noexcept;
+
+    int file_descriptor = -1;
+};
+
+} // namespace exasol::udf::v2::socket

udf-runner-cpp/v2/include/exasol/udf/v2/socket/socket.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cstddef>
+#include <span>
+
+#include <exasol/udf/v2/socket/owned_file_descriptor.hpp>
+
+namespace exasol::udf::v2::socket
+{
+
+/** Direction used when shutting down part or all of a socket connection. */
+enum class Shutdown
+{
+    Receive,
+    Send,
+    Both,
+};
+
+/** Common interface for owned stream sockets. */
+class Socket
+{
+public:
+    /** Destroys the socket and releases its native descriptor. */
+    virtual ~Socket() = default;
+
+    Socket(const Socket&)            = delete;
+    Socket& operator=(const Socket&) = delete;
+
+    /** Returns the native socket descriptor, or -1 when closed. */
+    [[nodiscard]] virtual int native_handle() const noexcept = 0;
+
+    /** Returns whether the socket owns an open native descriptor. */
+    [[nodiscard]] virtual bool is_open() const noexcept = 0;
+
+    /** Closes the socket. This operation is idempotent. */
+    virtual void close() noexcept = 0;
+
+    /** Releases the native descriptor without closing it. */
+    [[nodiscard]] virtual OwnedFileDescriptor release_native_handle() noexcept = 0;
+
+    /** Shuts down the selected direction of the connection.
+     *
+     * @throws std::system_error if the operating-system shutdown fails.
+     */
+    virtual void shutdown(Shutdown how) = 0;
+
+    /** Reads up to the capacity described by the buffers.
+     *
+     * A successful call may read fewer bytes than requested. A return value of
+     * zero indicates end-of-file.
+     */
+    virtual std::size_t read_some(std::span<const std::span<std::byte>> buffers) = 0;
+
+    /** Writes up to the size described by the buffers.
+     *
+     * A successful call may write fewer bytes than requested.
+     */
+    virtual std::size_t write_some(std::span<const std::span<const std::byte>> buffers) = 0;
+
+    /** Reads into one contiguous buffer. */
+    std::size_t read_some(std::span<std::byte> buffer);
+
+    /** Writes from one contiguous buffer. */
+    std::size_t write_some(std::span<const std::byte> buffer);
+
+protected:
+    Socket()                    = default;
+    Socket(Socket&&)            = default;
+    Socket& operator=(Socket&&) = default;
+};
+
+} // namespace exasol::udf::v2::socket

udf-runner-cpp/v2/include/exasol/udf/v2/socket/unix_socket.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <filesystem>
+
+#include <exasol/udf/v2/socket/socket.hpp>
+
+namespace exasol::udf::v2::socket
+{
+
+/** Owns one connected Unix-domain stream socket. */
+class UnixSocket final : public Socket
+{
+public:
+    using Socket::read_some;
+    using Socket::write_some;
+
+    UnixSocket() noexcept;
+    ~UnixSocket() override;
+
+    UnixSocket(const UnixSocket&)            = delete;
+    UnixSocket& operator=(const UnixSocket&) = delete;
+    UnixSocket(UnixSocket&& other) noexcept;
+    UnixSocket& operator=(UnixSocket&& other) noexcept;
+
+    /** Connects to a Unix-domain socket at @p path.
+     *
+     * @throws std::system_error if socket creation or connection fails.
+     * @throws std::invalid_argument if @p path is not a valid Unix socket path.
+     */
+    [[nodiscard]] static UnixSocket connect(const std::filesystem::path& path);
+
+    /** Takes ownership of an open Unix stream socket descriptor.
+     *
+     * @throws std::system_error if @p owned_fd is closed or is not a Unix stream socket.
+     */
+    [[nodiscard]] static UnixSocket adopt_native_handle(OwnedFileDescriptor owned_fd);
+
+    [[nodiscard]] int native_handle() const noexcept override;
+    [[nodiscard]] bool is_open() const noexcept override;
+    void close() noexcept override;
+    [[nodiscard]] OwnedFileDescriptor release_native_handle() noexcept override;
+    void shutdown(Shutdown how) override;
+    std::size_t read_some(std::span<const std::span<std::byte>> buffers) override;
+    std::size_t write_some(std::span<const std::span<const std::byte>> buffers) override;
+
+private:
+    explicit UnixSocket(OwnedFileDescriptor owned_fd) noexcept;
+
+    OwnedFileDescriptor file_descriptor;
+};
+
+} // namespace exasol::udf::v2::socket