Host: support character devices on POSIX platforms

Introduce a new `HandleChannel` type that creates a channel from a handle.  This
allows us to create a channel to a serial port device.  Wire this up in main to
get a channel to the physical device, enabling serial port support.

Author: compnerd

BUILD

@@ -252,6 +252,7 @@ filegroup(
             "Headers/DebugServer2/Target/Windows/Thread.h",
         ],
         ("@platforms//os:android", "@platforms//os:freebsd", "@platforms//os:linux", "@platforms//os:macos"): [
+            "Headers/DebugServer2/Host/POSIX/HandleChannel.h",
             "Headers/DebugServer2/Host/POSIX/PTrace.h",
             "Headers/DebugServer2/Host/POSIX/ProcessSpawner.h",
             "Headers/DebugServer2/Target/POSIX/Process.h",
@@ -402,6 +403,7 @@ filegroup(
         ],
         ("@platforms//os:android", "@platforms//os:freebsd", "@platforms//os:linux", "@platforms//os:macos"): [
             "Sources/Host/POSIX/File.cpp",
+            "Sources/Host/POSIX/HandleChannel.cpp",
             "Sources/Host/POSIX/Platform.cpp",
             "Sources/Host/POSIX/ProcessSpawner.cpp",
             "Sources/Host/POSIX/PTrace.cpp",

CMakeLists.txt

@@ -275,6 +275,7 @@ else()
   # Assumes that any non-Windows platform is POSIX.
   target_sources(ds2 PRIVATE
     Sources/Host/POSIX/File.cpp
+    Sources/Host/POSIX/HandleChannel.cpp
     Sources/Host/POSIX/Platform.cpp
     Sources/Host/POSIX/ProcessSpawner.cpp
     Sources/Host/POSIX/PTrace.cpp

Headers/DebugServer2/Host/POSIX/HandleChannel.h

@@ -0,0 +1,38 @@
+// Copyright 2022 Saleem Abdulrasool <[email protected]>
+
+#pragma once
+
+#include "DebugServer2/Host/Channel.h"
+
+namespace ds2 {
+namespace Host {
+
+class HandleChannel : public Channel {
+  int fd_;
+
+public:
+  HandleChannel() : fd_(-1) {}
+  HandleChannel(int fd);
+  ~HandleChannel() override;
+
+  HandleChannel(const HandleChannel &) = delete;
+  HandleChannel(HandleChannel &&other) : fd_(other.fd_) {
+    other.fd_ = -1;
+  }
+
+public:
+  void close() override;
+
+public:
+  bool connected() const override { return fd_ >= 0; }
+
+public:
+  bool wait(int ms = -1) override;
+
+public:
+  ssize_t send(void const *buffer, size_t length) override;
+  ssize_t receive(void *buffer, size_t length) override;
+};
+
+}
+}

Sources/Host/POSIX/HandleChannel.cpp

@@ -0,0 +1,63 @@
+// Copyright 2022 Saleem Abdulrasool <[email protected]>
+
+#include "DebugServer2/Host/POSIX/HandleChannel.h"
+
+#include <fcntl.h>
+#include <poll.h>
+
+namespace ds2 {
+namespace Host {
+
+HandleChannel::HandleChannel(int fd) : fd_(fd) {
+  int flags = ::fcntl(fd_, F_GETFL, 0);
+  ::fcntl(fd_, F_SETFL, flags | O_NONBLOCK);
+}
+
+HandleChannel::~HandleChannel() {
+  close();
+}
+
+void HandleChannel::close() {
+  if (fd_ >= 0)
+    ::close(fd_);
+  fd_ = -1;
+}
+
+bool HandleChannel::wait(int ms) {
+  if (fd_ < 0)
+    return false;
+
+  struct pollfd fds;
+  fds.fd = fd_;
+  fds.events = POLLIN;
+  int nfds = ::poll(&fds, 1, ms);
+  return nfds == 1 && (fds.revents & POLLIN);
+}
+
+ssize_t HandleChannel::send(void const *buffer, size_t length) {
+  if (fd_ < 0)
+    return -1;
+
+  if (ssize_t nwritten =
+          ::write(fd_, reinterpret_cast<const char *>(buffer), length);
+      nwritten > 0)
+    return nwritten;
+
+  close();
+  return -1;
+}
+
+ssize_t HandleChannel::receive(void *buffer, size_t length) {
+  if (fd_ < 0)
+    return -1;
+
+  if (length == 0)
+    return 0;
+
+  ssize_t nread = ::read(fd_, reinterpret_cast<char *>(buffer), length);
+  if (nread == 0)
+    close();
+  return nread > 0 ? nread : 0;
+}
+}
+}

Sources/main.cpp

@@ -17,6 +17,9 @@
 #include "DebugServer2/Host/Platform.h"
 #include "DebugServer2/Host/QueueChannel.h"
 #include "DebugServer2/Host/Socket.h"
+#if defined(OS_POSIX)
+#include "DebugServer2/Host/POSIX/HandleChannel.h"
+#endif
 #include "DebugServer2/Utils/Daemon.h"
 #include "DebugServer2/Utils/Log.h"
 #include "DebugServer2/Utils/OptParse.h"
@@ -197,10 +200,10 @@ static std::unique_ptr<Socket> CreateSocket(std::string const &arg,
   DS2_UNREACHABLE();
 }
 
-static int RunDebugServer(Socket *socket, SessionDelegate *impl) {
+static int RunDebugServer(ds2::Host::Channel *channel, SessionDelegate *impl) {
   Session session(gGDBCompat ? ds2::GDBRemote::kCompatibilityModeGDB
                              : ds2::GDBRemote::kCompatibilityModeLLDB);
-  QueueChannel qchannel(socket);
+  QueueChannel qchannel(channel);
   SessionThread thread(&qchannel, &session);
 
   session.setDelegate(impl);
@@ -392,6 +395,9 @@ static int GdbserverMain(int argc, char **argv) {
   bool reverse = opts.getBool("reverse-connect");
 
   std::unique_ptr<Socket> socket;
+#if defined(OS_POSIX)
+  std::unique_ptr<ds2::Host::HandleChannel> device;
+#endif
 
   switch (connection_type) {
   case channel_type::named_pipe:
@@ -419,6 +425,15 @@ static int GdbserverMain(int argc, char **argv) {
     }
     break;
 
+  case channel_type::file_descriptor:
+#if defined(OS_POSIX)
+    socket = CreateFDSocket(fd);
+#else
+    (void)fd;
+    DS2BUG("connecting with file descriptor is not supported on this platform");
+#endif
+    break;
+
   case channel_type::character_device:
 #if defined(OS_POSIX)
     if (std::filesystem::exists(address))
@@ -444,24 +459,33 @@ static int GdbserverMain(int argc, char **argv) {
     }
 #endif
 
-    [[fallthrough]];
+    device = std::make_unique<ds2::Host::HandleChannel>(fd);
+    break;
 #else
     DS2BUG("connecting with chardev is not supported on this platform");
 #endif
+  }
+
+  if (gDaemonize) {
+    ds2::Utils::Daemonize();
+  }
+
+  ds2::Host::Channel *channel;
+  switch (connection_type) {
   case channel_type::file_descriptor:
+  case channel_type::named_pipe:
+  case channel_type::network:
+    channel = (fd >= 0 || reverse) ? socket.get() : socket->accept().get();
+    break;
+  case channel_type::character_device:
 #if defined(OS_POSIX)
-    socket = CreateFDSocket(fd);
+    channel = device.get();
 #else
-    (void)fd;
-    DS2BUG("connecting with file descriptor is not supported on this platform");
+    DS2BUG("connecting with chardev is not supported on this platform");
 #endif
     break;
   }
 
-  if (gDaemonize) {
-    ds2::Utils::Daemonize();
-  }
-
   std::unique_ptr<DebugSessionImpl> impl;
 
   if (attachPid > 0)
@@ -471,13 +495,7 @@ static int GdbserverMain(int argc, char **argv) {
   else
     impl = ds2::make_unique<DebugSessionImpl>();
 
-#if defined(OS_POSIX)
-  return RunDebugServer(
-      (fd >= 0 || reverse) ? socket.get() : socket->accept().get(), impl.get());
-#else
-  return RunDebugServer(reverse ? socket.get() : socket->accept().get(),
-                        impl.get());
-#endif
+  return RunDebugServer(channel, impl.get());
 }
 
 #if !defined(OS_WIN32)