Add support for starting and stopping the tunnel

This commit introduces the Tunnel view model object which has
support for asking for permission, starting and stopping the
tunnel. It automatically updates its state and publishes
changes as an ObservableObject.

Apple/App/BurrowApp.swift

@@ -1,10 +1,18 @@
+import NetworkExtension
 import SwiftUI
 
 @main
+@MainActor
 struct BurrowApp: App {
+
+    static let tunnel = Tunnel { manager, proto in
+        proto.serverAddress = "hackclub.com"
+        manager.localizedDescription = "Burrow"
+    }
+
     var body: some Scene {
         WindowGroup {
-            ContentView()
+            TunnelView(tunnel: Self.tunnel)
         }
     }
 }

Apple/App/ContentView.swift

@@ -1,19 +0,0 @@
-import SwiftUI
-
-struct ContentView: View {
-    var body: some View {
-        VStack {
-            Image(systemName: "globe")
-                .imageScale(.large)
-                .foregroundColor(.accentColor)
-            Text("Hello, world!")
-        }
-        .padding()
-    }
-}
-
-struct ContentView_Previews: PreviewProvider {
-    static var previews: some View {
-        ContentView()
-    }
-}

Apple/App/NetworkExtension+Async.swift

@@ -0,0 +1,41 @@
+import NetworkExtension
+
+extension NEVPNManager {
+    func remove() async throws {
+        let _: Void = try await withUnsafeThrowingContinuation { continuation in
+            removeFromPreferences(completionHandler: completion(continuation))
+        }
+    }
+
+    func save() async throws {
+        let _: Void = try await withUnsafeThrowingContinuation { continuation in
+            saveToPreferences(completionHandler: completion(continuation))
+        }
+    }
+}
+
+extension NETunnelProviderManager {
+    class var managers: [NETunnelProviderManager] {
+        get async throws {
+            try await withUnsafeThrowingContinuation { continuation in
+                loadAllFromPreferences { managers, error in
+                    if let error = error {
+                        continuation.resume(throwing: error)
+                    } else {
+                        continuation.resume(returning: managers ?? [])
+                    }
+                }
+            }
+        }
+    }
+}
+
+private func completion(_ continuation: UnsafeContinuation<Void, Error>) -> (Error?) -> Void {
+    return { error in
+        if let error = error {
+            continuation.resume(throwing: error)
+        } else {
+            continuation.resume(returning: ())
+        }
+    }
+}

Apple/App/Status.swift

@@ -0,0 +1,43 @@
+import Foundation
+import NetworkExtension
+
+extension Tunnel {
+    enum Status: CustomStringConvertible, Equatable, Hashable {
+        case unknown
+        case permissionRequired
+        case disabled
+        case connecting
+        case connected(Date)
+        case disconnecting
+        case disconnected
+        case reasserting
+        case invalid
+        case configurationReadWriteFailed
+
+        var description: String {
+            switch self {
+            case .unknown:
+                return "Unknown"
+            case .permissionRequired:
+                return "Permission Required"
+            case .disconnected:
+                return "Disconnected"
+            case .disabled:
+                return "Disabled"
+            case .connecting:
+                return "Connecting"
+            case .connected(_):
+                return "Connected"
+            case .disconnecting:
+                return "Disconnecting"
+            case .reasserting:
+                return "Reasserting"
+            case .invalid:
+                return "Invalid"
+            case .configurationReadWriteFailed:
+                return "System Error"
+            }
+        }
+    }
+}
+

Apple/App/Tunnel.swift

@@ -0,0 +1,135 @@
+import NetworkExtension
+import SwiftUI
+import Combine
+
+@MainActor
+class Tunnel: ObservableObject {
+    @Published private(set) var status: Status = .unknown
+    @Published private var error: NEVPNError?
+
+    private let bundleIdentifier: String
+    private let configure: (NETunnelProviderManager, NETunnelProviderProtocol) -> Void
+    private var tasks: [Task<Void, Error>] = []
+
+    private var managers: [NEVPNManager]? {
+        didSet { status = currentStatus }
+    }
+
+    private var currentStatus: Status {
+        guard let managers = managers else {
+            guard let error = error else {
+                return .unknown
+            }
+
+            switch error.code {
+            case .configurationReadWriteFailed:
+                return .configurationReadWriteFailed
+            default:
+                return .unknown
+            }
+        }
+
+        guard let manager = managers.first else {
+            return .permissionRequired
+        }
+
+        guard manager.isEnabled else {
+            return .disabled
+        }
+
+        return manager.connection.tunnelStatus
+    }
+
+    convenience init(configure: @escaping (NETunnelProviderManager, NETunnelProviderProtocol) -> Void) {
+        self.init("com.hackclub.burrow.network", configure: configure)
+    }
+
+    init(_ bundleIdentifier: String, configure: @escaping (NETunnelProviderManager, NETunnelProviderProtocol) -> Void) {
+        self.bundleIdentifier = bundleIdentifier
+        self.configure = configure
+
+        let statusTask = Task {
+            for try await _ in NotificationCenter.default.notifications(named: .NEVPNStatusDidChange) {
+                status = currentStatus
+            }
+        }
+        let configurationTask = Task {
+            for try await _ in NotificationCenter.default.notifications(named: .NEVPNConfigurationChange) {
+                await update()
+            }
+        }
+        tasks = [statusTask, configurationTask]
+    }
+
+    deinit {
+        tasks.forEach { $0.cancel() }
+    }
+
+    func update() async {
+        do {
+            managers = try await NETunnelProviderManager.managers
+        } catch let error as NEVPNError {
+            self.error = error
+        } catch {
+            print(error)
+        }
+    }
+
+    func configure() async throws {
+        if managers == nil {
+            await update()
+        }
+
+        guard let managers = managers else { return }
+
+        if managers.count > 1 {
+            try await withThrowingTaskGroup(of: Void.self, returning: Void.self) { group in
+                for manager in managers.suffix(from: 1) {
+                    group.addTask { try await manager.remove() }
+                }
+                try await group.waitForAll()
+            }
+        }
+
+        if managers.isEmpty {
+            let manager = NETunnelProviderManager()
+            let proto = NETunnelProviderProtocol()
+            proto.providerBundleIdentifier = bundleIdentifier
+            manager.protocolConfiguration = proto
+            
+            configure(manager, proto)
+            try await manager.save()
+        }
+    }
+
+    func start() throws {
+        guard let manager = managers?.first else { return }
+        try manager.connection.startVPNTunnel()
+    }
+
+    func stop() {
+        guard let manager = managers?.first else { return }
+        manager.connection.stopVPNTunnel()
+    }
+}
+
+private extension NEVPNConnection {
+     var tunnelStatus: Tunnel.Status {
+        switch status {
+        case .connected:
+            return .connected(connectedDate!)
+        case .connecting:
+            return .connecting
+        case .disconnecting:
+            return .disconnecting
+        case .disconnected:
+            return .disconnected
+        case .reasserting:
+            return .reasserting
+        case .invalid:
+            return .invalid
+        @unknown default:
+            return .unknown
+        }
+    }
+}

Apple/App/TunnelView.swift

@@ -0,0 +1,37 @@
+import SwiftUI
+
+struct TunnelView: View {
+
+    @ObservedObject
+    var tunnel: Tunnel
+
+    var body: some View {
+        VStack {
+            Text(verbatim: tunnel.status.description)
+            switch tunnel.status {
+            case .connected(_):
+                Button("Disconnect", action: stop)
+            case .permissionRequired:
+                Button("Allow", action: configure)
+            case .disconnected:
+                Button("Start", action: start)
+            default:
+                EmptyView()
+            }
+        }
+        .task { await tunnel.update() }
+        .padding()
+    }
+
+    private func start() {
+        try? tunnel.start()
+    }
+
+    private func stop() {
+        tunnel.stop()
+    }
+
+    private func configure() {
+        Task { try await tunnel.configure() }
+    }
+}