[lldb-vscode] Make server mode work on Windows

[zturner]

Summary

For historical reasons, Windows unfortunately doesn't support using sockets in standard system calls like read/write, which means that they also can't be buffered with a FILE*. This violates some fundamental assumptions of how lldb-vscode was written, so fixing it requires some replumbing of the guts. I introduced an abstraction called IOStream which basically knows whether the descriptor is a socket or a non-socket, and then delegates to the appropriate underlying APIs accordingly. This means calling read/write on stdin/stdout and calling recv/send on sockets. Luckily this same strategy will also work on non-Windows platforms, so the abstractions needed aren't too egregious.

lldb/trunk/tools/lldb-vscode/CMakeLists.txt

 # We need to include the llvm components we depend on manually, as liblldb does
 # not re-export those.
 set(LLVM_LINK_COMPONENTS Support)
 add_lldb_tool(lldb-vscode
   lldb-vscode.cpp
   BreakpointBase.cpp
   ExceptionBreakpoint.cpp
   FunctionBreakpoint.cpp
+  IOStream.cpp
   JSONUtils.cpp
   LLDBUtils.cpp
   SourceBreakpoint.cpp
   VSCode.cpp
 
   LINK_LIBS
     liblldb
     ${host_lib}

lldb/trunk/tools/lldb-vscode/IOStream.h

+//===-- IOStream.h ----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDBVSCODE_IOSTREAM_H_
+#define LLDBVSCODE_IOSTREAM_H_
+
+#if defined(_WIN32)
+// We need to #define NOMINMAX in order to skip `min()` and `max()` macro
+// definitions that conflict with other system headers.
+// We also need to #undef GetObject (which is defined to GetObjectW) because
+// the JSON code we use also has methods named `GetObject()` and we conflict
+// against these.
+#define NOMINMAX
+#include <windows.h>
+#else
+typedef int SOCKET;
+#endif
+
+#include "llvm/ADT/StringRef.h"
+
+#include <fstream>
+#include <string>
+
+// Windows requires different system calls for dealing with sockets and other
+// types of files, so we can't simply have one code path that just uses read
+// and write everywhere.  So we need an abstraction in order to allow us to
+// treat them identically.
+namespace lldb_vscode {
+struct StreamDescriptor {
+  StreamDescriptor();
+  ~StreamDescriptor();
+  StreamDescriptor(StreamDescriptor &&other);
+
+  StreamDescriptor &operator=(StreamDescriptor &&other);
+
+  static StreamDescriptor from_socket(SOCKET s, bool close);
+  static StreamDescriptor from_file(int fd, bool close);
+
+  bool m_is_socket = false;
+  bool m_close = false;
+  union {
+    int m_fd;
+    SOCKET m_socket;
+  };
+};
+
+struct InputStream {
+  StreamDescriptor descriptor;
+
+  bool read_full(std::ofstream *log, size_t length, std::string &text);
+
+  bool read_line(std::ofstream *log, std::string &line);
+
+  bool read_expected(std::ofstream *log, llvm::StringRef expected);
+};
+
+struct OutputStream {
+  StreamDescriptor descriptor;
+
+  bool write_full(llvm::StringRef str);
+};
+} // namespace lldb_vscode
+
+#endif

lldb/trunk/tools/lldb-vscode/IOStream.cpp

+//===-- IOStream.cpp --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "IOStream.h"
+
+#if defined(_WIN32)
+#include <io.h>
+#else
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#endif
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+using namespace lldb_vscode;
+
+StreamDescriptor::StreamDescriptor() {}
+
+StreamDescriptor::StreamDescriptor(StreamDescriptor &&other) {
+  *this = std::move(other);
+}
+
+StreamDescriptor::~StreamDescriptor() {
+  if (!m_close)
+    return;
+
+  if (m_is_socket)
+#if defined(_WIN32)
+    ::closesocket(m_socket);
+#else
+    ::close(m_socket);
+#endif
+  else
+    ::close(m_fd);
+}
+
+StreamDescriptor &StreamDescriptor::operator=(StreamDescriptor &&other) {
+  m_close = other.m_close;
+  other.m_close = false;
+  m_is_socket = other.m_is_socket;
+  if (m_is_socket)
+    m_socket = other.m_socket;
+  else
+    m_fd = other.m_fd;
+  return *this;
+}
+
+StreamDescriptor StreamDescriptor::from_socket(SOCKET s, bool close) {
+  StreamDescriptor sd;
+  sd.m_is_socket = true;
+  sd.m_socket = s;
+  sd.m_close = close;
+  return sd;
+}
+
+StreamDescriptor StreamDescriptor::from_file(int fd, bool close) {
+  StreamDescriptor sd;
+  sd.m_is_socket = false;
+  sd.m_fd = fd;
+  sd.m_close = close;
+  return sd;
+}
+
+bool OutputStream::write_full(llvm::StringRef str) {
+  while (!str.empty()) {
+    int bytes_written = 0;
+    if (descriptor.m_is_socket)
+      bytes_written = ::send(descriptor.m_socket, str.data(), str.size(), 0);
+    else
+      bytes_written = ::write(descriptor.m_fd, str.data(), str.size());
+
+    if (bytes_written < 0) {
+      if (errno == EINTR || errno == EAGAIN)
+        continue;
+      return false;
+    }
+    str = str.drop_front(bytes_written);
+  }
+
+  return true;
+}
+
+bool InputStream::read_full(std::ofstream *log, size_t length,
+                            std::string &text) {
+  std::string data;
+  data.resize(length);
+
+  char *ptr = &data[0];
+  while (length != 0) {
+    int bytes_read = 0;
+    if (descriptor.m_is_socket)
+      bytes_read = ::recv(descriptor.m_socket, ptr, length, 0);
+    else
+      bytes_read = ::read(descriptor.m_fd, ptr, length);
+
+    if (bytes_read < 0) {
+      int reason = 0;
+#if defined(_WIN32)
+      if (descriptor.m_is_socket)
+        reason = WSAGetLastError();
+      else
+        reason = errno;
+#else
+      reason = errno;
+      if (reason == EINTR || reason == EAGAIN)
+        continue;
+#endif
+
+      if (log)
+        *log << "Error " << reason << " reading from input file.\n";
+      return false;
+    }
+
+    assert(bytes_read <= length);
+    ptr += bytes_read;
+    length -= bytes_read;
+  }
+  text += data;
+  return true;
+}
+
+bool InputStream::read_line(std::ofstream *log, std::string &line) {
+  line.clear();
+  while (true) {
+    if (!read_full(log, 1, line))
+      return false;
+
+    if (llvm::StringRef(line).endswith("\r\n"))
+      break;
+  }
+  line.erase(line.size() - 2);
+  return true;
+}
+
+bool InputStream::read_expected(std::ofstream *log, llvm::StringRef expected) {
+  std::string result;
+  if (!read_full(log, expected.size(), result))
+    return false;
+  if (expected != result) {
+    if (log)
+      *log << "Warning: Expected '" << expected.str() << "', got '" << result
+           << "\n";
+  }
+  return true;
+}

lldb/trunk/tools/lldb-vscode/VSCode.h

 #include <set>
 #include <stdio.h>
 #include <thread>
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBCommunication.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBInstructionList.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 
 #include "ExceptionBreakpoint.h"
 #include "FunctionBreakpoint.h"
+#include "IOStream.h"
 #include "SourceBreakpoint.h"
 #include "SourceReference.h"
 
 #define VARREF_LOCALS (int64_t)1
 #define VARREF_GLOBALS (int64_t)2
 #define VARREF_REGS (int64_t)3
 #define VARREF_FIRST_VAR_IDX (int64_t)4
 #define VARREF_IS_SCOPE(v) (VARREF_LOCALS <= 1 && v < VARREF_FIRST_VAR_IDX)
 #define VARIDX_TO_VARREF(i) ((i) + VARREF_FIRST_VAR_IDX)
 #define VARREF_TO_VARIDX(v) ((v)-VARREF_FIRST_VAR_IDX)
 #define NO_TYPENAME "<no-type>"
 
 namespace lldb_vscode {
 
 typedef llvm::DenseMap<uint32_t, SourceBreakpoint> SourceBreakpointMap;
 typedef llvm::StringMap<FunctionBreakpoint> FunctionBreakpointMap;
 enum class OutputType { Console, Stdout, Stderr, Telemetry };
 
 struct VSCode {
-  FILE *in;
-  FILE *out;
+  InputStream input;
+  OutputStream output;
   lldb::SBDebugger debugger;
   lldb::SBTarget target;
   lldb::SBAttachInfo attach_info;
   lldb::SBLaunchInfo launch_info;
   lldb::SBValueList variables;
   lldb::SBBroadcaster broadcaster;
   int64_t num_regs;
   int64_t num_locals;
struct VSCode {
   bool stop_at_entry;
   // Keep track of the last stop thread index IDs as threads won't go away
   // unless we send a "thread" event to indicate the thread exited.
   llvm::DenseSet<lldb::tid_t> thread_ids;
   VSCode();
   ~VSCode();
   VSCode(const VSCode &rhs) = delete;
   void operator=(const VSCode &rhs) = delete;
-  void CloseInputStream();
-  void CloseOutputStream();
   int64_t GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const;
   ExceptionBreakpoint *GetExceptionBreakpoint(const std::string &filter);
   ExceptionBreakpoint *GetExceptionBreakpoint(const lldb::break_id_t bp_id);
   //----------------------------------------------------------------------
   // Send the JSON in "json_str" to the "out" stream. Correctly send the
   // "Content-Length:" field followed by the length, followed by the raw
   // JSON bytes.
   //----------------------------------------------------------------------

lldb/trunk/tools/lldb-vscode/VSCode.cpp

 //===-- VSCode.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdarg.h>
 #include <fstream>
 #include <mutex>
 
-#include "VSCode.h"
 #include "LLDBUtils.h"
+#include "VSCode.h"
+#include "llvm/Support/FormatVariadic.h"
 
 #if defined(_WIN32)
-#include <io.h>
+#define NOMINMAX
+#include <Windows.h>
 #include <fcntl.h>
+#include <io.h>
 #endif
 
 using namespace lldb_vscode;
 
 namespace {
   inline bool IsEmptyLine(llvm::StringRef S) {
     return S.ltrim().empty();
   }
 } // namespace
 
 namespace lldb_vscode {
 
 VSCode g_vsc;
 
 VSCode::VSCode()
-    : in(stdin), out(stdout), launch_info(nullptr), variables(),
-      broadcaster("lldb-vscode"), num_regs(0), num_locals(0), num_globals(0),
-      log(), exception_breakpoints(
-                 {{"cpp_catch", "C++ Catch", lldb::eLanguageTypeC_plus_plus},
-                  {"cpp_throw", "C++ Throw", lldb::eLanguageTypeC_plus_plus},
-                  {"objc_catch", "Objective C Catch", lldb::eLanguageTypeObjC},
-                  {"objc_throw", "Objective C Throw", lldb::eLanguageTypeObjC},
-                  {"swift_catch", "Swift Catch", lldb::eLanguageTypeSwift},
-                  {"swift_throw", "Swift Throw", lldb::eLanguageTypeSwift}}),
+    : launch_info(nullptr), variables(), broadcaster("lldb-vscode"),
+      num_regs(0), num_locals(0), num_globals(0), log(),
+      exception_breakpoints(
       focus_tid(LLDB_INVALID_THREAD_ID), sent_terminated_event(false),
       stop_at_entry(false) {
   const char *log_file_path = getenv("LLDBVSCODE_LOG");
 #if defined(_WIN32)
 // Windows opens stdout and stdin in text mode which converts \n to 13,10
 // while the value is just 10 on Darwin/Linux. Setting the file mode to binary
 // fixes this.
   assert(_setmode(fileno(stdout), _O_BINARY));
   assert(_setmode(fileno(stdin), _O_BINARY));
 #endif
   if (log_file_path)
     log.reset(new std::ofstream(log_file_path));
 }
 
 VSCode::~VSCode() {
-  CloseInputStream();
-  CloseOutputStream();
-}
-
-void VSCode::CloseInputStream() {
-  if (in != stdin) {
-    fclose(in);
-    in = nullptr;
-  }
-}
-
-void VSCode::CloseOutputStream() {
-  if (out != stdout) {
-    fclose(out);
-    out = nullptr;
-  }
 }
 
 int64_t VSCode::GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const {
   auto pos = source_map.find(sourceReference);
   if (pos != source_map.end())
     return pos->second.GetLineForPC(pc);
   return 0;
 }

 }
 
 //----------------------------------------------------------------------
 // Send the JSON in "json_str" to the "out" stream. Correctly send the
 // "Content-Length:" field followed by the length, followed by the raw
 // JSON bytes.
 //----------------------------------------------------------------------
 void VSCode::SendJSON(const std::string &json_str) {
-  fprintf(out, "Content-Length: %u\r\n\r\n%s", (uint32_t)json_str.size(),
-          json_str.c_str());
-  fflush(out);
+  output.write_full("Content-Length: ");
+  output.write_full(llvm::utostr(json_str.size()));
+  output.write_full("\r\n\r\n");
+  output.write_full(json_str);
+
   if (log) {
     *log << "<-- " << std::endl
          << "Content-Length: " << json_str.size() << "\r\n\r\n"
          << json_str << std::endl;
   }
 }
 
 //----------------------------------------------------------------------
 // Serialize the JSON value into a string and send the JSON packet to
 // the "out" stream.
 //----------------------------------------------------------------------
 void VSCode::SendJSON(const llvm::json::Value &json) {
   std::string s;
   llvm::raw_string_ostream strm(s);
   strm << json;
   static std::mutex mutex;
   std::lock_guard<std::mutex> locker(mutex);
   SendJSON(strm.str());
 }
 
 //----------------------------------------------------------------------
 // Read a JSON packet from the "in" stream.
 //----------------------------------------------------------------------
 std::string VSCode::ReadJSON() {
-  static std::string header("Content-Length: ");
-
-  uint32_t packet_len = 0;
+  std::string length_str;
   std::string json_str;
-  char line[1024];
+  int length;
+
+  if (!input.read_expected(log.get(), "Content-Length: "))
+    return json_str;
+
+  if (!input.read_line(log.get(), length_str))
+    return json_str;
+
+  if (!llvm::to_integer(length_str, length))
+    return json_str;
+
+  if (!input.read_expected(log.get(), "\r\n"))
+    return json_str;
+
+  if (!input.read_full(log.get(), length, json_str))
+    return json_str;
 
-  while (fgets(line, sizeof(line), in)) {
-    if (strncmp(line, header.data(), header.size()) == 0) {
-      packet_len = atoi(line + header.size());
-      if (fgets(line, sizeof(line), in)) {
-        if (!IsEmptyLine(line))
-          if (log)
-            *log << "warning: expected empty line but got: \"" << line << "\""
-                 << std::endl;
-        break;
-      }
-    } else {
-      if (log)
-        *log << "warning: expected \"" << header << "\" but got: \"" << line
-             << "\"" << std::endl;
-    }
-  }
-  // This is followed by two windows newline sequences ("\r\n\r\n") so eat
-  // two the newline sequences
-  if (packet_len > 0) {
-    json_str.resize(packet_len);
-    auto bytes_read = fread(&json_str[0], 1, packet_len, in);
-    if (bytes_read < packet_len) {
-      if (log)
-        *log << "error: read fewer bytes (" << bytes_read
-             << ") than requested (" << packet_len << ")" << std::endl;
-      json_str.erase(bytes_read);
-    }
-    if (log) {
-      *log << "--> " << std::endl;
-      *log << header << packet_len << "\r\n\r\n" << json_str << std::endl;
-    }
-  }
   return json_str;
 }
 
 //----------------------------------------------------------------------
 // "OutputEvent": {
 //   "allOf": [ { "$ref": "#/definitions/Event" }, {
 //     "type": "object",
 //     "description": "Event message for 'output' event type. The event

lldb/trunk/tools/lldb-vscode/lldb-vscode.cpp

 // We need to #define NOMINMAX in order to skip `min()` and `max()` macro
 // definitions that conflict with other system headers.
 // We also need to #undef GetObject (which is defined to GetObjectW) because
 // the JSON code we use also has methods named `GetObject()` and we conflict
 // against these.
 #define NOMINMAX
 #include <windows.h>
 #undef GetObject
+#include <io.h>
 #else
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>
 #endif
 
 #include <algorithm>
 #include <chrono>

 #include "VSCode.h"
 
 #if defined(_WIN32)
 #define PATH_MAX MAX_PATH
 typedef int socklen_t;
 constexpr const char *dev_null_path = "nul";
 
 #else
-typedef int SOCKET;
 constexpr const char *dev_null_path = "/dev/null";
 
 #endif
 
 using namespace lldb_vscode;
 
 namespace {
 
 typedef void (*RequestCallback)(const llvm::json::Object &command);
 
 enum LaunchMethod { Launch, Attach, AttachForSuspendedLaunch };
 
 enum VSCodeBroadcasterBits { eBroadcastBitStopEventThread = 1u << 0 };
 
-int AcceptConnection(int portno) {
+SOCKET AcceptConnection(int portno) {
   // Accept a socket connection from any host on "portno".
-  int newsockfd = -1;
+  SOCKET newsockfd = -1;
   struct sockaddr_in serv_addr, cli_addr;
   SOCKET sockfd = socket(AF_INET, SOCK_STREAM, 0);
   if (sockfd < 0) {
     if (g_vsc.log)
       *g_vsc.log << "error: opening socket (" << strerror(errno) << ")"
                  << std::endl;
   } else {
     memset((char *)&serv_addr, 0, sizeof(serv_addr));
if (strcmp(arg, "-g") == 0) {
       printf("Paused waiting for debugger to attach (pid = %i)...\n", getpid());
       pause();
     } else {
 #else
     {
 #endif
       int portno = atoi(arg);
       printf("Listening on port %i...\n", portno);
-      int socket_fd = AcceptConnection(portno);
+      SOCKET socket_fd = AcceptConnection(portno);
       if (socket_fd >= 0) {
-        // We must open two FILE objects, one for reading and one for writing
-        // the FILE objects have a mutex in them that won't allow reading and
-        // writing to the socket stream.
-        g_vsc.in = fdopen(socket_fd, "r");
-        g_vsc.out = fdopen(socket_fd, "w");
-        if (g_vsc.in == nullptr || g_vsc.out == nullptr) {
-          if (g_vsc.log)
-            *g_vsc.log << "fdopen failed (" << strerror(errno) << ")"
-                       << std::endl;
-          exit(1);
-        }
+        g_vsc.input.descriptor = StreamDescriptor::from_socket(socket_fd, true);
+        g_vsc.output.descriptor =
+            StreamDescriptor::from_socket(socket_fd, false);
       } else {
         exit(1);
       }
     }
+  } else {
+    g_vsc.input.descriptor = StreamDescriptor::from_file(fileno(stdin), false);
+    g_vsc.output.descriptor =
+        StreamDescriptor::from_file(fileno(stdout), false);
   }
   auto request_handlers = GetRequestHandlers();
   uint32_t packet_idx = 0;
   while (true) {
     std::string json = g_vsc.ReadJSON();
     if (json.empty())
       break;
 

lldb/trunk/tools/lldb-vscode/package.json

"debuggers": [
             "objective-c",
             "objectpascal",
             "pascal",
             "rust",
             "swift"
           ]
         },
         "program": "./bin/lldb-vscode",
+        "windows": {
+          "program": "./bin/lldb-vscode.exe"
+        },
         "configurationAttributes": {
           "launch": {
             "required": [
               "program"
             ],
             "properties": {
               "program": {
                 "type": "string",