Implement more packet handling, update naming

Author: MaxDesiatov

[email protected]

@@ -120,30 +120,30 @@ let package = Package(
         .target(name: "WITExtractor"),
         .testTarget(name: "WITExtractorTests", dependencies: ["WITExtractor", "WIT"]),
 
-        .target(name: "LLDBRemoteProtocol",
+        .target(name: "GDBRemoteProtocol",
             dependencies: [
                 .product(name: "NIOCore", package: "swift-nio"),
             ]
         ),
-        .testTarget(name: "LLDBRemoteProtocolTests", dependencies: ["LLDBRemoteProtocol"]),
+        .testTarget(name: "GDBRemoteProtocolTests", dependencies: ["GDBRemoteProtocol"]),
 
         .target(
-            name: "WasmKitLLDBHandler",
+            name: "WasmKitGDBHandler",
             dependencies: [
                 .product(name: "NIOCore", package: "swift-nio"),
                 "WasmKit",
-                "LLDBRemoteProtocol",
+                "GDBRemoteProtocol",
             ],
         ),
 
         .executableTarget(
-            name: "wasmkit-lldb",
+            name: "wasmkit-gdb-tool",
             dependencies: [
                 .product(name: "ArgumentParser", package: "swift-argument-parser"),
                 .product(name: "NIOCore", package: "swift-nio"),
                 .product(name: "NIOPosix", package: "swift-nio"),
-                "LLDBRemoteProtocol",
-                "WasmKitLLDBHandler",
+                "GDBRemoteProtocol",
+                "WasmKitGDBHandler",
             ]
         ),
     ],

Sources/LLDBRemoteProtocol/CommandDecoder.swift renamed to Sources/GDBRemoteProtocol/CommandDecoder.swift

@@ -12,15 +12,15 @@ extension ByteBuffer {
     }
 }
 
-package struct CommandDecoder: ByteToMessageDecoder {
+package struct GDBHostCommandDecoder: ByteToMessageDecoder {
     enum Error: Swift.Error {
         case expectedCommandStart
         case unknownCommandKind(String)
         case expectedChecksum
         case checksumIncorrect
     }
 
-    package typealias InboundOut = Packet<HostCommand>
+    package typealias InboundOut = Packet<GDBHostCommand>
 
     private var accummulatedKind = [UInt8]()
     private var accummulatedArguments = [UInt8]()
@@ -32,12 +32,16 @@ package struct CommandDecoder: ByteToMessageDecoder {
         UInt8(self.accummulatedSum % 256)
     }
 
-    mutating package func decode(buffer: inout ByteBuffer) throws -> Packet<HostCommand>? {
+    mutating package func decode(buffer: inout ByteBuffer) throws -> Packet<GDBHostCommand>? {
         // Command start delimiters.
-        guard
-            buffer.readInteger(as: UInt8.self) == UInt8(ascii: "+")
-                && buffer.readInteger(as: UInt8.self) == UInt8(ascii: "$")
+        let firstStartDelimiter = buffer.readInteger(as: UInt8.self)
+        let secondStartDelimiter = buffer.readInteger(as: UInt8.self)
+        guard firstStartDelimiter == UInt8(ascii: "+")
+                && secondStartDelimiter == UInt8(ascii: "$")
         else {
+            if let firstStartDelimiter, let secondStartDelimiter {
+                print("unexpected delimiter: \(Character(UnicodeScalar(firstStartDelimiter)))\(Character(UnicodeScalar(secondStartDelimiter)))")
+            }
             throw Error.expectedCommandStart
         }
 
@@ -74,7 +78,7 @@ package struct CommandDecoder: ByteToMessageDecoder {
 
         let kindString = String(decoding: self.accummulatedKind, as: UTF8.self)
 
-        if let commandKind = HostCommand.Kind(rawValue: kindString) {
+        if let commandKind = GDBHostCommand.Kind(rawValue: kindString) {
             buffer.moveReaderIndex(forwardBy: 1)
 
             guard let checksumString = buffer.readString(length: 2),

Sources/LLDBRemoteProtocol/HostCommand.swift renamed to Sources/GDBRemoteProtocol/HostCommand.swift

@@ -1,5 +1,7 @@
-/// See https://lldb.llvm.org/resources/lldbgdbremote.html for more details.
-package struct HostCommand: Equatable {
+/// See GDB and LLDB remote protocol documentation for more details:
+/// * https://sourceware.org/gdb/current/onlinedocs/gdb.html/General-Query-Packets.html
+/// * https://lldb.llvm.org/resources/lldbgdbremote.html
+package struct GDBHostCommand: Equatable {
     package enum Kind: Equatable {
         // Currently listed in the order that LLDB sends them in.
         case generalRegisters
@@ -9,6 +11,11 @@ package struct HostCommand: Equatable {
         case isThreadSuffixSupported
         case listThreadsInStopReply
         case hostInfo
+        case vContSupportedActions
+        case isVAttachOrWaitSupported
+        case enableErrorStrings
+        case processInfo
+        case currentThreadID
 
         package init?(rawValue: String) {
             switch rawValue {
@@ -24,6 +31,16 @@ package struct HostCommand: Equatable {
                 self = .listThreadsInStopReply
             case "qHostInfo":
                 self = .hostInfo
+            case "vCont?":
+                self = .vContSupportedActions
+            case "qVAttachOrWaitSupported":
+                self = .isVAttachOrWaitSupported
+            case "QEnableErrorStrings":
+                self = .enableErrorStrings
+            case "qProcessInfo":
+                self = .processInfo
+            case "qC":
+                self = .currentThreadID
             default:
                 return nil
             }

Sources/LLDBRemoteProtocol/Package.swift renamed to Sources/GDBRemoteProtocol/Package.swift

@@ -0,0 +1,35 @@
+import Foundation
+import NIOCore
+
+extension String {
+    fileprivate var appendedChecksum: String.UTF8View {
+        "\(self)#\(String(format:"%02X", self.utf8.reduce(0, { $0 + Int($1) }) % 256))".utf8
+    }
+}
+
+package struct GDBTargetResponseEncoder: MessageToByteEncoder {
+    package init() {}
+    package func encode(data: TargetResponse, out: inout ByteBuffer) throws {
+        if !data.isNoAckModeActive {
+            out.writeInteger(UInt8(ascii: "+"))
+        }
+        out.writeInteger(UInt8(ascii: "$"))
+
+        switch data.kind {
+        case .ok:
+            out.writeBytes("ok#da".utf8)
+
+        case .hostInfo(let info):
+            out.writeBytes(info.map { (key, value) in "\(key):\(value);"}.joined().appendedChecksum)
+
+        case .vContSupportedActions(let actions):
+            out.writeBytes("vCont;\(actions.map(\.rawValue).joined())".appendedChecksum)
+
+        case .raw(let str):
+            out.writeBytes(str.appendedChecksum)
+
+        case .empty:
+            out.writeBytes("".appendedChecksum)
+        }
+    }
+}

Sources/GDBRemoteProtocol/ResponseEncoder.swift

@@ -0,0 +1,27 @@
+/// Actions supported in the `vCont` host command.
+package enum VContActions: String {
+    case `continue` = "c"
+    case continueWithSignal = "C"
+    case step = "s"
+    case stepWithSignal = "S"
+    case stop = "t"
+    case stepInRange = "r"
+}
+
+package struct TargetResponse {
+    package enum Kind {
+        case ok
+        case hostInfo(KeyValuePairs<String, String>)
+        case vContSupportedActions([VContActions])
+        case raw(String)
+        case empty
+    }
+
+    package let kind: Kind
+    package let isNoAckModeActive: Bool
+
+    package init(kind: Kind, isNoAckModeActive: Bool) {
+        self.kind = kind
+        self.isNoAckModeActive = isNoAckModeActive
+    }
+}

Sources/GDBRemoteProtocol/TargetResponse.swift

@@ -1,11 +1,11 @@
-import LLDBRemoteProtocol
+import GDBRemoteProtocol
 import NIOCore
 import WasmKit
 
 import struct Foundation.Date
 
 package final class WasmKitHandler: ChannelInboundHandler {
-    package typealias InboundIn = Packet<HostCommand>
+    package typealias InboundIn = Packet<GDBHostCommand>
     package typealias OutboundOut = TargetResponse
 
     /// Whether `QStartNoAckMode` command was previously sent.
@@ -24,15 +24,36 @@ package final class WasmKitHandler: ChannelInboundHandler {
         switch command.kind {
         case .startNoAckMode, .isThreadSuffixSupported, .listThreadsInStopReply:
             responseKind = .ok
+
+        case .hostInfo:
+            responseKind = .hostInfo([
+                "arch": "wasm32",
+                "ptrsize": "4",
+                "endian": "little",
+                "ostype": "wasip1",
+                "vendor": "WasmKit"
+            ])
+
         case .supportedFeatures:
             responseKind = .raw(command.arguments)
-        default:
+
+        case .vContSupportedActions:
+            responseKind = .vContSupportedActions([.continue, .step, .stop])
+
+        case .isVAttachOrWaitSupported, .enableErrorStrings, .processInfo:
+            responseKind = .empty
+
+        case .currentThreadID:
+            responseKind = .raw("QC 1")
+
+        case .generalRegisters, .firstThreadInfo:
             fatalError()
         }
 
         context.writeAndFlush(
             wrapOutboundOut(.init(kind: responseKind, isNoAckModeActive: self.isNoAckModeActive)),
-            promise: nil)
+            promise: nil
+        )
         if command.kind == .startNoAckMode {
             self.isNoAckModeActive = true
         }

Sources/LLDBRemoteProtocol/ResponseEncoder.swift

@@ -1,8 +1,8 @@
 import ArgumentParser
-import LLDBRemoteProtocol
+import GDBRemoteProtocol
 import NIOCore
 import NIOPosix
-import WasmKitLLDBHandler
+import WasmKitGDBHandler
 
 @main
 struct Entrypoint: ParsableCommand {
@@ -24,8 +24,8 @@ struct Entrypoint: ParsableCommand {
                     // make sure to instantiate your `ChannelHandlers` inside of
                     // the closure as it will be invoked once per connection.
                     try channel.pipeline.syncOperations.addHandlers([
-                        ByteToMessageHandler(CommandDecoder()),
-                        MessageToByteHandler(ResponseEncoder()),
+                        ByteToMessageHandler(GDBHostCommandDecoder()),
+                        MessageToByteHandler(GDBTargetResponseEncoder()),
                         WasmKitHandler(),
                     ])
                 }