Implement non-blocking async DNS resolver

Sources/GRPCHTTP2Core/Client/Resolver/SimpleAsyncDNSResolver.swift

@@ -0,0 +1,240 @@
+/*
+ * Copyright 2024, gRPC Authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Dispatch
+
+#if canImport(Darwin)
+import Darwin
+#elseif os(Linux) || os(FreeBSD) || os(Android)
+#if canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
+import CNIOLinux
+#else
+#error("The GRPCHTTP2Core module was unable to identify your C library.")
+#endif
+
+/// An asynchronous non-blocking DNS resolver built on top of the libc `getaddrinfo` function.
+@available(macOS 10.15, *)
+package enum SimpleAsyncDNSResolver {
+  private static let dispatchQueue = DispatchQueue(
+    label: "io.grpc.SimpleAsyncDNSResolver.dispatchQueue"
+  )
+
+  /// Resolves a hostname  and port number to a list of IP addresses and port numbers.
+  ///
+  /// This method is non-blocking. As calls to `getaddrinfo` are blocking, this method executes `getaddrinfo` in a
+  /// `DispatchQueue` and uses a `CheckedContinuation` to interface with the execution.
+  package static func resolve(host: String, port: Int) async throws -> [SocketAddress] {
+    if Task.isCancelled {
+      return []
+    }
+
+    return try await withCheckedThrowingContinuation { continuation in
+      dispatchQueue.async {
+        do {
+          let result = try Self.resolveBlocking(host: host, port: port)
+          continuation.resume(returning: result)
+        } catch {
+          continuation.resume(throwing: error)
+        }
+      }
+    }
+  }
+
+  /// Resolves a hostname and port number to a list of IP addresses and port numbers.
+  ///
+  /// Calls to `getaddrinfo` are blocking and this method calls `getaddrinfo` directly. Hence, this method is also blocking.
+  private static func resolveBlocking(host: String, port: Int) throws -> [SocketAddress] {
+    var result: UnsafeMutablePointer<addrinfo>?
+    defer {
+      if let result {
+        // Release memory allocated by a successful call to getaddrinfo
+        freeaddrinfo(result)
+      }
+    }
+
+    var hints = addrinfo()
+    hints.ai_socktype = SOCK_STREAM
+    hints.ai_protocol = IPPROTO_TCP
+
+    let errorCode = getaddrinfo(host, String(port), &hints, &result)
+
+    guard errorCode == 0, var result else {
+      throw SimpleAsyncDNSResolverError(code: errorCode)
+    }
+
+    var socketAddressList = [SocketAddress]()
+
+    while true {
+      let addressBytes = UnsafeRawPointer(result.pointee.ai_addr)
+      let socketAddress: SocketAddress?
+
+      switch result.pointee.ai_family {
+      case AF_INET:  // IPv4 address
+        let ipv4NetworkAddressStructure = addressBytes!.load(as: sockaddr_in.self)
+        let ipv4PresentationAddress = Self.convertFromNetworkToPresentationFormat(
+          address: ipv4NetworkAddressStructure.sin_addr,
+          family: AF_INET,
+          length: INET_ADDRSTRLEN
+        )
+
+        socketAddress = .ipv4(
+          .init(
+            host: ipv4PresentationAddress,
+            port: Int(in_port_t(bigEndian: ipv4NetworkAddressStructure.sin_port))
+          )
+        )
+      case AF_INET6:  // IPv6 address
+        let ipv6NetworkAddressStructure = addressBytes!.load(as: sockaddr_in6.self)
+        let ipv6PresentationAddress = Self.convertFromNetworkToPresentationFormat(
+          address: ipv6NetworkAddressStructure.sin6_addr,
+          family: AF_INET6,
+          length: INET6_ADDRSTRLEN
+        )
+
+        socketAddress = .ipv6(
+          .init(
+            host: ipv6PresentationAddress,
+            port: Int(in_port_t(bigEndian: ipv6NetworkAddressStructure.sin6_port))
+          )
+        )
+      default:
+        socketAddress = nil
+      }
+
+      if let socketAddress {
+        socketAddressList.append(socketAddress)
+      }
+
+      guard let nextResult = result.pointee.ai_next else { break }
+      result = nextResult
+    }
+
+    return socketAddressList
+  }
+
+  /// Converts an address from a network format to a presentation format using `inet_ntop`.
+  private static func convertFromNetworkToPresentationFormat<T>(
+    address: T,
+    family: Int32,
+    length: Int32
+  ) -> String {
+    var resultingAddressBytes = [Int8](repeating: 0, count: Int(length))
+
+    return withUnsafePointer(to: address) { addressPtr in
+      return resultingAddressBytes.withUnsafeMutableBufferPointer {
+        (resultingAddressBytesPtr: inout UnsafeMutableBufferPointer<Int8>) -> String in
+
+        // Convert
+        inet_ntop(family, addressPtr, resultingAddressBytesPtr.baseAddress!, socklen_t(length))
+
+        // Create the result string from now-filled resultingAddressBytes.
+        return resultingAddressBytesPtr.baseAddress!.withMemoryRebound(
+          to: UInt8.self,
+          capacity: Int(length)
+        ) { resultingAddressBytesPtr -> String in
+          String(cString: resultingAddressBytesPtr)
+        }
+      }
+    }
+  }
+}
+
+/// `Error` that may be thrown based on the error code returned by `getaddrinfo`.
+package enum SimpleAsyncDNSResolverError: Error {
+  /// Address family for nodename not supported.
+  case addressFamilyForNodenameNotSupported
+
+  /// Temporary failure in name resolution.
+  case temporaryFailure
+
+  /// Invalid value for `ai_flags`.
+  case invalidAIFlags
+
+  /// Invalid value for `hints`.
+  case invalidHints
+
+  /// Non-recoverable failure in name resolution.
+  case nonRecoverableFailure
+
+  /// `ai_family` not supported.
+  case aiFamilyNotSupported
+
+  /// Memory allocation failure.
+  case memoryAllocationFailure
+
+  /// No address associated with nodename.
+  case noAddressAssociatedWithNodename
+
+  /// `hostname` or `servname` not provided, or not known.
+  case hostnameOrServnameNotProvidedOrNotKnown
+
+  /// Argument buffer overflow.
+  case argumentBufferOverflow
+
+  /// Resolved protocol is unknown.
+  case resolvedProtocolIsUnknown
+
+  /// `servname` not supported for `ai_socktype`.
+  case servnameNotSupportedForSocktype
+
+  /// `ai_socktype` not supported.
+  case socktypeNotSupported
+
+  /// System error returned in `errno`.
+  case systemError
+
+  /// Unknown error.
+  case unknown
+
+  package init(code: Int32) {
+    switch code {
+    case EAI_ADDRFAMILY:
+      self = .addressFamilyForNodenameNotSupported
+    case EAI_AGAIN:
+      self = .temporaryFailure
+    case EAI_BADFLAGS:
+      self = .invalidAIFlags
+    case EAI_BADHINTS:
+      self = .invalidHints
+    case EAI_FAIL:
+      self = .nonRecoverableFailure
+    case EAI_FAMILY:
+      self = .aiFamilyNotSupported
+    case EAI_MEMORY:
+      self = .memoryAllocationFailure
+    case EAI_NODATA:
+      self = .noAddressAssociatedWithNodename
+    case EAI_NONAME:
+      self = .hostnameOrServnameNotProvidedOrNotKnown
+    case EAI_OVERFLOW:
+      self = .argumentBufferOverflow
+    case EAI_PROTOCOL:
+      self = .resolvedProtocolIsUnknown
+    case EAI_SERVICE:
+      self = .servnameNotSupportedForSocktype
+    case EAI_SOCKTYPE:
+      self = .socktypeNotSupported
+    case EAI_SYSTEM:
+      self = .systemError
+    default:
+      self = .unknown
+    }
+  }
+}

Tests/GRPCHTTP2CoreTests/Client/Resolver/SimpleAsyncDNSResolverTests.swift

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2024, gRPC Authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import GRPCHTTP2Core
+import XCTest
+
+class SimpleAsyncDNSResolverTests: XCTestCase {
+  func testResolve() async throws {
+    let expectedResult: [SocketAddress] = [
+      .ipv6(host: "::1", port: 80),
+      .ipv4(host: "127.0.0.1", port: 80),
+    ]
+
+    let result = try await SimpleAsyncDNSResolver.resolve(host: "localhost", port: 80)
+
+    XCTAssertEqual(result, expectedResult)
+  }
+}