Rewrite in pure Swift

.github/workflows/swift.yml

@@ -0,0 +1,69 @@
+name: Swift
+on: [push]
+jobs:
+
+  # macOS is a compile target only, on both architectures: macos-15 is Apple
+  # Silicon and macos-15-intel is the x86_64 image that replaced the retired
+  # macos-13. The test suite needs a session bus and D-Bus is not part of macOS,
+  # so the suite is run on Linux, where a real bus is available. The tests are
+  # still *built* here, so they cannot rot out of compiling on Darwin.
+  macos:
+    name: macOS (${{ matrix.arch }}, ${{ matrix.config }})
+    strategy:
+      # One failing cell should not hide the others: knowing which
+      # architecture and configuration combinations fail is the whole
+      # point of the matrix when diagnosing platform-specific behavior.
+      fail-fast: false
+      matrix:
+        arch: ["arm64", "x86_64"]
+        config: ["debug", "release"]
+        include:
+          - arch: arm64
+            runner: macos-15
+          - arch: x86_64
+            runner: macos-15-intel
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 30
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Swift Version
+      run: swift --version
+    - name: Build
+      run: swift build -c ${{ matrix.config }}
+    - name: Build tests
+      # `-enable-testing` is on by default only for debug. The tests use `@testable import`,
+      # and `swift test` passes the flag itself, but a plain build in release does not.
+      run: swift build -c ${{ matrix.config }} --build-tests -Xswiftc -enable-testing
+
+  # x86_64 on the standard hosted runner, arm64 on ubuntu-24.04-arm, which is a
+  # real ARM64 machine rather than a cross-compilation target, so the suite runs
+  # there too. Docker pulls the matching architecture of the same Swift images.
+  linux:
+    name: Linux (${{ matrix.arch }}, ${{ matrix.container }}, ${{ matrix.config }}, ${{ matrix.options || 'static' }})
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: ["x86_64", "arm64"]
+        container: ["swift:6.2.3", "swift:6.3.3"]
+        config: ["debug", "release"]
+        options: ["", "SWIFT_BUILD_DYNAMIC_LIBRARY=1"]
+        include:
+          - arch: x86_64
+            runner: ubuntu-latest
+          - arch: arm64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
+    container: ${{ matrix.container }}-jammy
+    timeout-minutes: 30
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Swift Version
+      run: swift --version
+    - name: Install D-Bus
+      run: apt-get update -qq && apt-get install -y --no-install-recommends dbus
+    - name: Build
+      run: ${{ matrix.options }} swift build -c ${{ matrix.config }}
+    - name: Test
+      run: dbus-run-session -- env ${{ matrix.options }} swift test -c ${{ matrix.config }} --no-parallel

Package.swift

@@ -1,27 +1,34 @@
-// swift-tools-version:4.1
+// swift-tools-version:6.0
 import PackageDescription
+import class Foundation.ProcessInfo
+
+// force building as dynamic library
+let dynamicLibrary = ProcessInfo.processInfo.environment["SWIFT_BUILD_DYNAMIC_LIBRARY"] != nil
+let libraryType: PackageDescription.Product.Library.LibraryType? = dynamicLibrary ? .dynamic : nil
 
 let package = Package(
     name: "DBus",
+    platforms: [
+        .macOS(.v13),
+    ],
     products: [
         .library(
             name: "DBus",
-            targets: [
-                "DBus"
-            ]
+            type: libraryType,
+            targets: ["DBus"]
         )
     ],
     dependencies: [
         .package(
-            url: "https://github.com/PureSwift/CDBus.git",
-            .branch("master")
+            url: "https://github.com/PureSwift/Socket.git",
+            branch: "fix/stale-readiness"
         )
     ],
     targets: [
         .target(
             name: "DBus",
             dependencies: [
-                //"CDBus"
+                "Socket"
             ]
         ),
         .testTarget(
@@ -30,6 +37,5 @@ let package = Package(
                 "DBus"
             ]
         )
-        ],
-    swiftLanguageVersions: [5]
+    ]
 )

README.md

@@ -1,2 +1,152 @@
 # DBus
-Swift library for D-Bus
+
+Pure Swift library for D-Bus. No `libdbus`, no C implementation — the wire format, the SASL
+handshake and the transport are all implemented in Swift.
+
+## Requirements
+
+- Swift 6.0+
+- Linux (or any platform with a D-Bus daemon reachable over a Unix socket)
+
+Depends on [PureSwift/Socket](https://github.com/PureSwift/Socket) for async sockets.
+
+> The manifest currently points at a local `../Socket` checkout, which carries three changes not
+> yet upstream: `SCM_RIGHTS` ancillary data support that file-descriptor passing is built on, and
+> two socket-monitor fixes — deferred poll results being applied to a reused descriptor, and a
+> never-connected socket being torn down because an unconnected socket polls as `POLLHUP`.
+
+## Usage
+
+```swift
+import DBus
+
+let connection = try await DBusConnection.connect(to: .session)
+
+let reply = try await connection.send(
+    DBusMessage(methodCall: DBusMessage.MethodCall(
+        destination: DBusBusName(rawValue: "org.freedesktop.DBus")!,
+        path: DBusObjectPath(rawValue: "/org/freedesktop/DBus")!,
+        interface: DBusInterface(rawValue: "org.freedesktop.DBus")!,
+        method: DBusMember(rawValue: "ListNames")!
+    ))
+)
+
+if case let .array(names)? = reply.arguments.first {
+    for name in names.compactMap({ $0.stringValue }) {
+        print(name)
+    }
+}
+
+await connection.close()
+```
+
+An error reply is thrown as a `DBusError` carrying its `org.freedesktop.DBus.Error.*` name;
+framing and marshalling failures are thrown as `DBusProtocolError`.
+
+### File descriptors
+
+A `UNIX_FD` argument carries a real descriptor. On the wire it is marshalled as an index into
+the descriptors sent out of band, so the value you pass is the descriptor itself:
+
+```swift
+try await connection.callMethod(
+    destination: name,
+    path: path,
+    interface: interface,
+    method: DBusMember(rawValue: "Accept")!,
+    arguments: [.fileDescriptor(.init(rawValue: myFileDescriptor))]
+)
+```
+
+The peer receives its own descriptor referring to the same open file, and **owns it**: close it
+when finished. Sending requires the peer to have agreed to `NEGOTIATE_UNIX_FD`, which
+`unixFileDescriptorsSupported` reports.
+
+### Signals
+
+A connection receives no broadcast signals until it installs a match rule. `signals(matching:)`
+installs one and yields matching messages until the stream is dropped, which removes it again.
+
+```swift
+let signals = try await connection.signals(matching: .nameOwnerChanged())
+
+for await signal in signals {
+    print(signal.arguments)
+}
+```
+
+### Exporting an object
+
+```swift
+let counter = DBusInterfaceImplementation(
+    name: DBusInterface(rawValue: "com.example.Counter")!,
+    methods: [
+        .init(name: DBusMember(rawValue: "Increment")!,
+              outputSignature: DBusSignature(rawValue: "u")!,
+              handler: { _ in [.uint32(await state.increment())] })
+    ],
+    properties: [
+        .init(name: "Total", type: .uint32, access: .read,
+              get: { .uint32(await state.total) })
+    ]
+)
+
+await connection.export(DBusExportedObject([counter]),
+                        at: DBusObjectPath(rawValue: "/com/example/Counter")!)
+
+try await connection.requestName(DBusBusName(rawValue: "com.example.Counter")!)
+```
+
+`org.freedesktop.DBus.Peer`, `.Introspectable` and `.Properties` are answered automatically:
+introspection XML is generated from the declared methods, properties and signals.
+
+## Design
+
+`DBusMessage` and every value type are `Sendable` structs. `DBusConnection` is an actor that owns
+the socket, runs the read loop and matches replies to calls by serial. Nothing wraps a C pointer,
+so there is no reference counting to get wrong.
+
+Values are modelled by `DBusMessageArgument`, which covers every D-Bus type including `variant`
+and `dict`. Array element types are stored explicitly rather than inferred, so an empty array
+still marshals with the right signature.
+
+Names are validated on construction by hand-written parsers: `DBusObjectPath`, `DBusInterface`,
+`DBusMember`, `DBusBusName` and `DBusSignature`.
+
+## Status
+
+Implemented:
+
+- Message marshalling and unmarshalling, both byte orders
+- Bus address parsing (`unix:path=`, `unix:abstract=`, `unix:runtime=yes`, percent escaping)
+- Unix socket transport, including the Linux abstract namespace
+- SASL `EXTERNAL` and `ANONYMOUS`, plus `NEGOTIATE_UNIX_FD`
+- Method calls and replies, with timeouts
+- Bus daemon API: name registration and queries, `AddMatch` / `RemoveMatch`
+- Match rules, with spec-correct encoding and local matching
+- Signal subscriptions as `AsyncStream`
+- Server side: object export, method dispatch, signal emission
+- `org.freedesktop.DBus.Peer`, `.Introspectable` and `.Properties`
+- SASL `DBUS_COOKIE_SHA1`, with a pure-Swift SHA-1
+- `tcp:` and `nonce-tcp:` transports, IPv4 and IPv6
+- Unix file descriptor passing, via `SCM_RIGHTS`
+
+- Parsing introspection XML into a typed node model
+
+Not yet implemented:
+
+- Code generation from introspection XML
+
+## Tests
+
+```sh
+swift test
+```
+
+Written with [Swift Testing](https://github.com/swiftlang/swift-testing). The suites that need a
+live bus are marked `.enabled(if: hasSessionBus)`, so they report as skipped rather than passing
+when no bus socket is present.
+
+## License
+
+MIT. See [LICENSE](LICENSE).