VPN: Fix DNS resolution API

WireGuard/WireGuard/VPN/DNSResolver.swift

@@ -5,19 +5,34 @@ import Network
 import Foundation
 
 class DNSResolver {
-    let endpoints: [Endpoint]
+    let endpoints: [Endpoint?]
 
-    init(endpoints: [Endpoint]) {
+    init(endpoints: [Endpoint?]) {
         self.endpoints = endpoints
     }
 
-    func resolve(completionHandler: @escaping ([Endpoint?]) -> Void) {
+    func resolve(completionHandler: @escaping ([Endpoint?]?) -> Void) {
         let endpoints = self.endpoints
         DispatchQueue.global(qos: .userInitiated).async {
-            var resolvedEndpoints = Array<Endpoint?>(repeating: nil, count: endpoints.count)
+            var resolvedEndpoints: [Endpoint?] = []
-            for (i, endpoint) in endpoints.enumerated() {
+            var isError = false
-                let resolvedEndpoint = DNSResolver.resolveSync(endpoint: endpoint)
+            for endpoint in endpoints {
-                resolvedEndpoints[i] = resolvedEndpoint
+                if let endpoint = endpoint {
+                    if let resolvedEndpoint = DNSResolver.resolveSync(endpoint: endpoint) {
+                        resolvedEndpoints.append(resolvedEndpoint)
+                    } else {
+                        isError = true
+                        break
+                    }
+                } else {
+                    resolvedEndpoints.append(nil)
+                }
+            }
+            if (isError) {
+                DispatchQueue.main.async {
+                    completionHandler(nil)
+                }
+                return
             }
             DispatchQueue.main.async {
                 completionHandler(resolvedEndpoints)

WireGuard/WireGuard/VPN/TunnelsManager.swift

@@ -256,13 +256,14 @@ class TunnelContainer: NSObject {
     fileprivate func activate(completionHandler: @escaping (Bool) -> Void) {
         assert(status == .inactive)
         guard let tunnelConfiguration = tunnelConfiguration() else { fatalError() }
-        let endpoints = tunnelConfiguration.peers.compactMap { $0.endpoint }
+        let endpoints = tunnelConfiguration.peers.map { $0.endpoint }
         let dnsResolver = DNSResolver(endpoints: endpoints)
         assert(self.dnsResolver == nil)
         self.dnsResolver = dnsResolver
         status = .resolvingEndpointDomains
         dnsResolver.resolve { [weak self] endpoints in
-            guard (!endpoints.contains { $0 == nil }) else {
+            guard let endpoints = endpoints else {
+                // TODO: Show error message
                 completionHandler(false)
                 return
             }