Add client -> server hello message

fixes #36

Author: fredemmott

OTDIPC-TestClient/DarwinTransport.cpp

@@ -7,79 +7,86 @@
 #include <print>
 #include <string>
 
+#include <cerrno>
 #include <pwd.h>
 #include <sys/un.h>
-#include <cerrno>
 #include <sysdir.h>
 #include <wordexp.h>
 
 #include "PosixSocket.hpp"
 
-namespace
-{
-    std::expected<std::filesystem::path, std::string> GetApplicationSupportPath() noexcept
-    {
-        char appSupport[PATH_MAX];
-        {
-            auto state = sysdir_start_search_path_enumeration(SYSDIR_DIRECTORY_APPLICATION_SUPPORT, SYSDIR_DOMAIN_MASK_USER);
-            state = sysdir_get_next_search_path_enumeration(state, appSupport);
-        }
+namespace {
+std::expected<std::filesystem::path, std::string>
+GetApplicationSupportPath() noexcept {
+  char appSupport[PATH_MAX];
+  {
+    auto state = sysdir_start_search_path_enumeration(
+      SYSDIR_DIRECTORY_APPLICATION_SUPPORT, SYSDIR_DOMAIN_MASK_USER);
+    state = sysdir_get_next_search_path_enumeration(state, appSupport);
+  }
 
-        if (!appSupport[0]) {
-            return std::unexpected{"Failed to find Application Support directory"};
-        }
+  if (!appSupport[0]) {
+    return std::unexpected {"Failed to find Application Support directory"};
+  }
 
-        // Expand `~/Library/...` to `/Users/..../Library/...`
-        wordexp_t p {};
-        if (const auto ret = wordexp(appSupport, &p, WRDE_NOCMD); ret != 0) {
-            return std::unexpected{std::format("wordexp failed: {} - {}", errno, strerror(errno))};
-        }
-        std::string expandedAppSupport;
-        for (auto i = 0; i < p.we_wordc; ++i) {
-            if (i == 0) {
-                expandedAppSupport = p.we_wordv[i];
-            } else {
-                expandedAppSupport = std::format("{} {}", expandedAppSupport, p.we_wordv[i]);
-            }
-        }
-        wordfree(&p);
-        return std::filesystem::path{expandedAppSupport};
+  // Expand `~/Library/...` to `/Users/..../Library/...`
+  wordexp_t p {};
+  if (const auto ret = wordexp(appSupport, &p, WRDE_NOCMD); ret != 0) {
+    return std::unexpected {
+      std::format("wordexp failed: {} - {}", errno, strerror(errno))};
+  }
+  std::string expandedAppSupport;
+  for (auto i = 0; i < p.we_wordc; ++i) {
+    if (i == 0) {
+      expandedAppSupport = p.we_wordv[i];
+    } else {
+      expandedAppSupport
+        = std::format("{} {}", expandedAppSupport, p.we_wordv[i]);
     }
+  }
+  wordfree(&p);
+  return std::filesystem::path {expandedAppSupport};
 }
+}// namespace
 
-std::expected<std::unique_ptr<Transport>, std::string> Transport::Open() noexcept
-{
-    return DarwinTransport::Open();
+std::expected<std::unique_ptr<Transport>, std::string>
+Transport::Open() noexcept {
+  return DarwinTransport::Open();
 }
 
-std::expected<std::unique_ptr<Transport>, std::string> DarwinTransport::Open() noexcept
-{
-    const auto appSupport = GetApplicationSupportPath();
-    if (!appSupport) {
-        return std::unexpected{appSupport.error()};
-    }
-    const auto path = GetSocketPath(*appSupport);
-    if (!path)
-    {
-        return std::unexpected{path.error()};
-    }
+std::expected<std::unique_ptr<Transport>, std::string>
+DarwinTransport::Open() noexcept {
+  const auto appSupport = GetApplicationSupportPath();
+  if (!appSupport) {
+    return std::unexpected {appSupport.error()};
+  }
+  const auto path = GetSocketPath(*appSupport);
+  if (!path) {
+    return std::unexpected {path.error()};
+  }
 
-    auto fd = PosixSocket::ConnectToUnixSocket(*path);
-    if (!fd) {
-        return std::unexpected{fd.error()};
-    }
+  auto fd = PosixSocket::ConnectToUnixSocket(*path);
+  if (!fd) {
+    return std::unexpected {fd.error()};
+  }
+
+  std::println("Connected to unix domain socket: {}", path->string());
+  return std::unique_ptr<DarwinTransport> {new DarwinTransport(*std::move(fd))};
+}
 
-    std::println("Connected to unix domain socket: {}", path->string());
-    return std::unique_ptr<DarwinTransport>{new DarwinTransport(*std::move(fd))};
+std::expected<size_t, std::string> DarwinTransport::Read(
+  void* buffer,
+  const size_t bufferSize) noexcept {
+  return PosixSocket::Read(*mFD, buffer, bufferSize);
 }
 
-std::expected<size_t, std::string> DarwinTransport::Read(void* buffer, const size_t bufferSize) noexcept
-{
-    return PosixSocket::Read(*mFD, buffer, bufferSize);
+std::expected<void, std::string> DarwinTransport::Write(
+  const void* buffer,
+  const size_t bufferSize) noexcept {
+  return PosixSocket::Write(*mFD, buffer, bufferSize);
 }
 
-DarwinTransport::DarwinTransport(unique_fd fd) noexcept : mFD(std::move(fd))
-{
+DarwinTransport::DarwinTransport(unique_fd fd) noexcept : mFD(std::move(fd)) {
 }
 
 DarwinTransport::~DarwinTransport() = default;

OTDIPC-TestClient/DarwinTransport.hpp

@@ -10,17 +10,20 @@
 #include <memory>
 #include <string>
 
-class DarwinTransport final : public Transport
-{
-public:
-    DarwinTransport() = delete;
-    ~DarwinTransport() override;
+class DarwinTransport final : public Transport {
+ public:
+  DarwinTransport() = delete;
+  ~DarwinTransport() override;
 
-    static std::expected<std::unique_ptr<Transport>, std::string> Open() noexcept;
-    std::expected<size_t, std::string> Read(void* buffer, size_t bufferSize) noexcept override;
+  static std::expected<std::unique_ptr<Transport>, std::string> Open() noexcept;
+  std::expected<size_t, std::string> Read(
+    void* buffer,
+    size_t bufferSize) noexcept override;
+  std::expected<void, std::string> Write(
+    void const* buffer,
+    size_t bufferSize) noexcept override;
 
-private:
-
-    explicit DarwinTransport(unique_fd fd) noexcept;
-    unique_fd mFD{};
+ private:
+  explicit DarwinTransport(unique_fd fd) noexcept;
+  unique_fd mFD {};
 };

OTDIPC-TestClient/LinuxTransport.cpp

@@ -7,66 +7,66 @@
 #include <print>
 #include <string>
 
+#include <cerrno>
 #include <pwd.h>
 #include <sys/un.h>
-#include <cerrno>
 #include "PosixSocket.hpp"
 
+namespace {
+std::expected<std::filesystem::path, std::string>
+GetApplicationSupportPath() noexcept {
+  if (const auto dataDir = getenv("XDG_DATA_HOME")) {
+    return dataDir;
+  }
 
-namespace
-{
-    std::expected<std::filesystem::path, std::string> GetApplicationSupportPath() noexcept
-    {
-        if (const auto dataDir = getenv("XDG_DATA_HOME"))
-        {
-            return dataDir;
-        }
+  auto home = getenv("HOME");
+  if (!home) {
+    home = getpwuid(getuid())->pw_dir;
+  }
 
-        auto home = getenv("HOME");
-        if (!home) {
-            home = getpwuid(getuid())->pw_dir;
-        }
-
-        return std::filesystem::path{home} / ".local" / "share";
-    }
+  return std::filesystem::path {home} / ".local" / "share";
 }
+}// namespace
 
-std::expected<std::unique_ptr<Transport>, std::string> Transport::Open() noexcept
-{
-    return LinuxTransport::Open();
+std::expected<std::unique_ptr<Transport>, std::string>
+Transport::Open() noexcept {
+  return LinuxTransport::Open();
 }
 
-std::expected<std::unique_ptr<Transport>, std::string> LinuxTransport::Open() noexcept
-{
-    const auto appSupport = GetApplicationSupportPath();
-    if (!appSupport)
-    {
-        return std::unexpected{appSupport.error()};
-    }
-    const auto path = GetSocketPath(*appSupport);
-    if (!path)
-    {
-        return std::unexpected{path.error()};
-    }
-
-    auto fd = PosixSocket::ConnectToUnixSocket(*path);
-    if (!fd) {
-        return std::unexpected{fd.error()};
-    }
-
-    std::println("Connected to unix socket at `{}`", path->string());
+std::expected<std::unique_ptr<Transport>, std::string>
+LinuxTransport::Open() noexcept {
+  const auto appSupport = GetApplicationSupportPath();
+  if (!appSupport) {
+    return std::unexpected {appSupport.error()};
+  }
+  const auto path = GetSocketPath(*appSupport);
+  if (!path) {
+    return std::unexpected {path.error()};
+  }
+
+  auto fd = PosixSocket::ConnectToUnixSocket(*path);
+  if (!fd) {
+    return std::unexpected {fd.error()};
+  }
+
+  std::println("Connected to unix socket at `{}`", path->string());
+
+  return std::unique_ptr<LinuxTransport> {new LinuxTransport(*std::move(fd))};
+}
 
-    return std::unique_ptr<LinuxTransport>{new LinuxTransport(*std::move(fd))};
+std::expected<size_t, std::string> LinuxTransport::Read(
+  void* buffer,
+  const size_t bufferSize) noexcept {
+  return PosixSocket::Read(*mFD, buffer, bufferSize);
 }
 
-std::expected<size_t, std::string> LinuxTransport::Read(void *buffer, const size_t bufferSize) noexcept
-{
-    return PosixSocket::Read(*mFD, buffer, bufferSize);
+std::expected<void, std::string> LinuxTransport::Write(
+  const void* buffer,
+  const size_t bufferSize) noexcept {
+  return PosixSocket::Write(*mFD, buffer, bufferSize);
 }
 
-LinuxTransport::LinuxTransport(unique_fd fd) noexcept : mFD(std::move(fd))
-{
+LinuxTransport::LinuxTransport(unique_fd fd) noexcept : mFD(std::move(fd)) {
 }
 
 LinuxTransport::~LinuxTransport() = default;
-

OTDIPC-TestClient/LinuxTransport.hpp

@@ -5,22 +5,26 @@
 #include "Transport.hpp"
 
 #include <expected>
-#include <utility>
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "unique_fd.hpp"
 
-class LinuxTransport final : public Transport
-{
-public:
-    LinuxTransport() = delete;
-    ~LinuxTransport() final;
+class LinuxTransport final : public Transport {
+ public:
+  LinuxTransport() = delete;
+  ~LinuxTransport() final;
 
-    static std::expected<std::unique_ptr<Transport>, std::string> Open() noexcept;
-    std::expected<size_t, std::string> Read(void *buffer, size_t bufferSize) noexcept override;
+  static std::expected<std::unique_ptr<Transport>, std::string> Open() noexcept;
+  std::expected<size_t, std::string> Read(
+    void* buffer,
+    size_t bufferSize) noexcept override;
+  std::expected<void, std::string> Write(
+    void const* buffer,
+    size_t bufferSize) noexcept override;
 
-private:
-    explicit LinuxTransport(unique_fd fd) noexcept;
-    unique_fd mFD{};
+ private:
+  explicit LinuxTransport(unique_fd fd) noexcept;
+  unique_fd mFD {};
 };

OTDIPC-TestClient/OTDIPC-TestClient.cpp

@@ -237,6 +237,18 @@ int main() {
   static_assert(sizeof(buffer) >= sizeof(State));
   const auto header = reinterpret_cast<const Header* const>(buffer);
 
+  {
+    const auto dbgMessage = reinterpret_cast<DebugMessage*>(buffer);
+    *dbgMessage = {};
+    constexpr std::string_view kMessage = "Hello from OTDIPC-TestClient";
+    dbgMessage->header.size = sizeof(Header) + kMessage.size();
+    memcpy(dbgMessage->data, kMessage.data(), kMessage.size());
+    if (const auto written = (*connection)->Write(buffer, dbgMessage->header.size); !written) {
+      std::cerr << "Failed to write client hello: " << written.error() << std::endl;
+      return EXIT_FAILURE;
+    }
+  }
+
   const ScopedAlternateBuffer useAlternateBuffer;
 
   while (true) {