Remove NIO dependency (#20)

Motivation:

NIO's ByteBuffer is used as an implementation detail for parsing
responses in the DNSD implementation. However NIO is quite a heavy
dependency so we should avoid it if possible.

Modifications:

- Use `ArraySlice<UInt8>` instead of `ByteBuffer` and remove the
  dependency on SwiftNIO

Result:

No dependency on SwiftNIO

Author: glbrntt

Package.swift

@@ -29,7 +29,6 @@ let package = Package(
         .library(name: "AsyncDNSResolver", targets: ["AsyncDNSResolver"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-nio", .upToNextMajor(from: "2.53.0")),
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
     ],
     targets: [
@@ -49,7 +48,6 @@ let package = Package(
             name: "AsyncDNSResolver",
             dependencies: [
                 "CAsyncDNSResolver",
-                .product(name: "NIOCore", package: "swift-nio"),
             ]
         ),
 

Sources/AsyncDNSResolver/dnssd/DNSResolver_dnssd.swift

@@ -14,7 +14,6 @@
 
 #if canImport(Darwin)
 import dnssd
-import NIOCore
 
 /// ``DNSResolver`` implementation backed by dnssd framework.
 public struct DNSSDDNSResolver: DNSResolver {
@@ -267,7 +266,7 @@ extension DNSSD {
             }
 
             let bufferPtr = UnsafeBufferPointer(start: ptr, count: Int(length))
-            var buffer = ByteBuffer(bytes: bufferPtr)
+            var buffer = Array(bufferPtr)[...]
 
             guard let nameserver = self.readName(&buffer) else {
                 throw AsyncDNSResolver.Error.badResponse("failed to read name")
@@ -290,7 +289,7 @@ extension DNSSD {
             }
 
             let bufferPtr = UnsafeBufferPointer(start: ptr, count: Int(length))
-            var buffer = ByteBuffer(bytes: bufferPtr)
+            var buffer = Array(bufferPtr)[...]
 
             guard let cname = self.readName(&buffer) else {
                 throw AsyncDNSResolver.Error.badResponse("failed to read name")
@@ -313,7 +312,7 @@ extension DNSSD {
             }
 
             let bufferPtr = UnsafeBufferPointer(start: ptr, count: Int(length))
-            var buffer = ByteBuffer(bytes: bufferPtr)
+            var buffer = Array(bufferPtr)[...]
 
             guard let mname = self.readName(&buffer),
                   let rname = self.readName(&buffer),
@@ -350,7 +349,7 @@ extension DNSSD {
             }
 
             let bufferPtr = UnsafeBufferPointer(start: ptr, count: Int(length))
-            var buffer = ByteBuffer(bytes: bufferPtr)
+            var buffer = Array(bufferPtr)[...]
 
             guard let name = self.readName(&buffer) else {
                 throw AsyncDNSResolver.Error.badResponse("failed to read name")
@@ -373,7 +372,7 @@ extension DNSSD {
             }
 
             let bufferPtr = UnsafeBufferPointer(start: ptr, count: Int(length))
-            var buffer = ByteBuffer(bytes: bufferPtr)
+            var buffer = Array(bufferPtr)[...]
 
             guard let priority = buffer.readInteger(as: UInt16.self),
                   let host = self.readName(&buffer) else {
@@ -416,7 +415,7 @@ extension DNSSD {
             }
 
             let bufferPtr = UnsafeBufferPointer(start: ptr, count: Int(length))
-            var buffer = ByteBuffer(bytes: bufferPtr)
+            var buffer = Array(bufferPtr)[...]
 
             guard let priority = buffer.readInteger(as: UInt16.self),
                   let weight = buffer.readInteger(as: UInt16.self),
@@ -440,13 +439,14 @@ extension DNSSD {
 }
 
 extension DNSSDQueryReplyHandler {
-    func readName(_ buffer: inout ByteBuffer) -> String? {
+    func readName(_ buffer: inout ArraySlice<UInt8>) -> String? {
         var parts: [String] = []
         while let length = buffer.readInteger(as: UInt8.self),
               length > 0,
               let part = buffer.readString(length: Int(length)) {
             parts.append(part)
         }
+
         return parts.isEmpty ? nil : parts.joined(separator: ".")
     }
 
@@ -460,4 +460,30 @@ extension DNSSDQueryReplyHandler {
         return record
     }
 }
+
+extension ArraySlice<UInt8> {
+    mutating func readInteger<T: FixedWidthInteger>(as: T.Type = T.self) -> T? {
+        let size = MemoryLayout<T>.size
+        guard self.count >= size else { return nil }
+
+        let value = self.withUnsafeBytes { pointer in
+            var value = T.zero
+            Swift.withUnsafeMutableBytes(of: &value) { valuePointer in
+                valuePointer.copyMemory(from: UnsafeRawBufferPointer(rebasing: pointer[..<size]))
+            }
+            return value.bigEndian
+        }
+
+        self = self.dropFirst(size)
+        return value
+    }
+
+    mutating func readString(length: Int) -> String? {
+        guard self.count >= length else { return nil }
+
+        let prefix = self.prefix(length)
+        self = self.dropFirst(length)
+        return String(decoding: prefix, as: UTF8.self)
+    }
+}
 #endif

Tests/AsyncDNSResolverTests/dnssd/DNSDArraySliceTests.swift

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAsyncDNSResolver open source project
+//
+// Copyright (c) 2024 Apple Inc. and the SwiftAsyncDNSResolver project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftAsyncDNSResolver project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+@testable import AsyncDNSResolver
+import XCTest
+
+#if canImport(Darwin)
+final class DNSDArraySliceTests: XCTestCase {
+    func testReadUnsignedInteger() {
+        // [UInt8(0), UInt16(.max), UInt32(0), UInt64(.max)]
+        let bytes: [UInt8] = [0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255]
+        var slice = bytes[...]
+
+        XCTAssertEqual(slice.readInteger(as: UInt8.self), 0)
+        XCTAssertEqual(slice.readInteger(as: UInt16.self), .max)
+        XCTAssertEqual(slice.readInteger(as: UInt32.self), 0)
+        XCTAssertEqual(slice.readInteger(as: UInt64.self), .max)
+
+        XCTAssertNil(slice.readInteger(as: UInt8.self))
+    }
+
+    func testReadSignedInteger() {
+        // [Int8(0), Int16(-1), Int32(0), Int64(-1)]
+        let bytes: [UInt8] = [0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255]
+        var slice = bytes[...]
+
+        XCTAssertEqual(slice.readInteger(as: Int8.self), 0)
+        XCTAssertEqual(slice.readInteger(as: Int16.self), -1)
+        XCTAssertEqual(slice.readInteger(as: Int32.self), 0)
+        XCTAssertEqual(slice.readInteger(as: Int64.self), -1)
+
+        XCTAssertNil(slice.readInteger(as: Int8.self))
+    }
+
+    func testReadString() {
+        let bytes = Array("hello, world!".utf8)
+        var slice = bytes[...]
+
+        XCTAssertEqual(slice.readString(length: 13), "hello, world!")
+        XCTAssertEqual(slice.readString(length: 0), "")
+        XCTAssertNil(slice.readString(length: 1))
+    }
+}
+#endif