Init commit

2023-07-15 15:03:45 +08:00
commit f441b89efb
122 changed files with 7355 additions and 0 deletions
@@ -0,0 +1,174 @@
+import Foundation
+import Libbox
+import Library
+import NetworkExtension
+
+class PacketTunnelProvider: NEPacketTunnelProvider {
+    private var commandServer: LibboxCommandServer!
+    private var boxService: LibboxBoxService!
+
+    override func startTunnel(options _: [String: NSObject]?) async throws {
+        NSLog("Here I am")
+        do {
+            try FileManager.default.createDirectory(at: FilePath.cacheDirectory, withIntermediateDirectories: true)
+        } catch {
+            writeFatalError("(packet-tunnel) error: create cache directory: \(error.localizedDescription)")
+            return
+        }
+        var error: NSError?
+        LibboxRedirectStderr(FilePath.cacheDirectory.appendingPathComponent("stderr.log").relativePath, &error)
+        if let error {
+            writeError("(packet-tunnel) redirect stderr error: \(error.localizedDescription)")
+        }
+
+        LibboxSetMemoryLimit(!SharedPreferences.disableMemoryLimit)
+
+        commandServer = LibboxNewCommandServer(FilePath.sharedDirectory.relativePath, serverInterface(self), Int32(SharedPreferences.maxLogLines))
+        do {
+            try commandServer.start()
+        } catch {
+            writeFatalError("(packet-tunnel): log server start error: \(error.localizedDescription)")
+            return
+        }
+        writeMessage("(packet-tunnel) log server started")
+
+        do {
+            try FileManager.default.createDirectory(at: FilePath.workingDirectory, withIntermediateDirectories: true)
+        } catch {
+            writeFatalError("(packet-tunnel) error: create working directory: \(error.localizedDescription)")
+            return
+        }
+
+        LibboxSetup(FilePath.workingDirectory.relativePath, FilePath.cacheDirectory.relativePath, -1, -1)
+
+        startService()
+    }
+
+    private func writeMessage(_ message: String) {
+        if let commandServer {
+            commandServer.writeMessage(message)
+        } else {
+            NSLog(message)
+        }
+    }
+
+    private func writeError(_ message: String) {
+        writeMessage(message)
+        #if os(iOS)
+            ServiceNotification.postServiceNotification(title: "Service Error", message: message)
+        #else
+            displayMessage(message) { _ in
+            }
+        #endif
+    }
+
+    private func writeFatalError(_ message: String) {
+        writeError(message)
+        cancelTunnelWithError(NSError(domain: message, code: 0))
+    }
+
+    private func startService() {
+        let profile: Profile?
+        do {
+            profile = try ProfileManager.get(Int64(SharedPreferences.selectedProfileID))
+        } catch {
+            writeFatalError("(packet-tunnel) error: missing default profile: \(error.localizedDescription)")
+            return
+        }
+        guard let profile else {
+            writeFatalError("(packet-tunnel) error: missing default profile")
+            return
+        }
+        let configContent: String
+        do {
+            configContent = try profile.read()
+        } catch {
+            writeFatalError("(packet-tunnel) error: read config file: \(error.localizedDescription)")
+            return
+        }
+        var error: NSError?
+        let service = LibboxNewService(configContent, ExtensionPlatformInterface(self, commandServer), &error)
+        if let error {
+            writeError("(packet-tunnel) error: create service: \(error.localizedDescription)")
+            return
+        }
+        guard let service else {
+            return
+        }
+        do {
+            try service.start()
+        } catch {
+            writeError("(packet-tunnel) error: start service: \(error.localizedDescription)")
+            return
+        }
+        boxService = service
+        commandServer.setService(service)
+        #if os(macOS)
+            Task.detached {
+                SharedPreferences.startedByUser = true
+            }
+        #endif
+    }
+
+    private func stopService() {
+        if let service = boxService {
+            do {
+                try service.close()
+            } catch {
+                writeError("(packet-tunnel) error: stop service: \(error.localizedDescription)")
+            }
+            boxService = nil
+            commandServer.setService(nil)
+        }
+    }
+
+    private func reloadService() {
+        writeMessage("(packet-tunnel) reloading service")
+        reasserting = true
+        defer {
+            reasserting = false
+        }
+        stopService()
+        startService()
+    }
+
+    override func stopTunnel(with reason: NEProviderStopReason) async {
+        writeMessage("(packet-tunnel) stopping, reason: \(reason)")
+        stopService()
+        if let server = commandServer {
+            try? server.close()
+            commandServer = nil
+        }
+        #if os(macOS)
+            if reason == .userInitiated {
+                SharedPreferences.startedByUser = reason == .userInitiated
+            }
+        #endif
+    }
+
+    override func handleAppMessage(_ messageData: Data) async -> Data? {
+        messageData
+    }
+
+    override func sleep() async {}
+
+    override func wake() {}
+
+    private class serverInterface: NSObject, LibboxCommandServerHandlerProtocol {
+        unowned let tunnel: PacketTunnelProvider
+
+        init(_ tunnel: PacketTunnelProvider) {
+            self.tunnel = tunnel
+            super.init()
+        }
+
+        func serviceReload() throws {
+            tunnel.reloadService()
+        }
+
+        func serviceStop() throws {
+            tunnel.stopService()
+            tunnel.writeMessage("(packet-tunnel) debug: service stopped")
+        }
+    }
+}