Sync code with mobile client

swift/extension/VPNExtension/FileLogger.swift

@@ -24,7 +24,9 @@ final class Log {
     /// The category for this logger instance (usually class name), e.g. "PacketTunnelProvider"
     let category: String
     private let systemLogger: Logger
+#if os(macOS)
     private let fileLogger = FileLogger.shared
+#endif
 
     init(category: String) {
         self.category = category
@@ -36,29 +38,40 @@ final class Log {
 
     func debug(_ message: String) {
         systemLogger.debug("\(message, privacy: .public)")
+#if os(macOS)
         fileLogger.log(level: .debug, message: message, category: category)
+#endif
     }
 
     func info(_ message: String) {
         systemLogger.info("\(message, privacy: .public)")
+#if os(macOS)
         fileLogger.log(level: .info, message: message, category: category)
+#endif
     }
 
     func warning(_ message: String) {
         systemLogger.warning("\(message, privacy: .public)")
+#if os(macOS)
         fileLogger.log(level: .warning, message: message, category: category)
+#endif
     }
 
     func error(_ message: String) {
         systemLogger.error("\(message, privacy: .public)")
+#if os(macOS)
         fileLogger.log(level: .error, message: message, category: category)
+#endif
     }
 
     func flush() {
+#if os(macOS)
         fileLogger.flush()
+#endif
     }
 }
 
+#if os(macOS)
 /// A file-based logger that writes to an App Group shared container.
 /// This allows the main rust app to read logs from the network extension.
 /// Use the `Log` class instead of this directly for unified logging.
@@ -235,3 +248,4 @@ final class FileLogger {
         return logFileURL?.path
     }
 }
+#endif

swift/extension/VPNExtension/PacketTunnelProvider.swift

@@ -20,13 +20,29 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
         }
 
         guard let protocolConfig = self.protocolConfiguration as? NETunnelProviderProtocol,
-            let providerConfig = protocolConfig.providerConfiguration,
-            let tunnelConfig = try? TunnelConfiguration.from(dictionary: providerConfig)
+              let providerConfig = protocolConfig.providerConfiguration
+        else {
+          log.error("Failed to parse provider configuration")
+          completionHandler(WireGuardTunnelError.invalidTunnelConfiguration)
+          return
+        }
+
+#if os(macOS)
+        guard let tunnelConfig = try? TunnelConfiguration.from(dictionary: providerConfig)
+        else {
+            log.error("Failed to parse tunnel configuration")
+            completionHandler(WireGuardTunnelError.invalidTunnelConfiguration)
+            return
+        }
+#else
+        guard let startData = try? TunnelStartData.from(dictionary: providerConfig)
         else {
             log.error("Failed to parse tunnel configuration")
             completionHandler(WireGuardTunnelError.invalidTunnelConfiguration)
             return
         }
+        let tunnelConfig = TunnelConfiguration(fromStartData: startData)
+#endif
 
         let networkSettings = tunnelConfig.asNetworkSettings()
         self.setTunnelNetworkSettings(networkSettings) { error in

swift/plugin/Sources/Defguard/TunnelConfiguration.swift

@@ -124,6 +124,61 @@ final class TunnelConfiguration: Codable {
         return (ipv4IncludedRoutes, ipv6IncludedRoutes)
     }
 
+#if os(iOS)
+    /// Helper function allowing to parse comma-separated string of addresses.
+    private func parseAddresses(fromString string: String) -> [IpAddrMask] {
+        var addresses: [IpAddrMask] = []
+
+        for addr in string.split(separator: ",").map({
+            String($0.trimmingCharacters(in: .whitespaces))
+        }) {
+            if let addr_mask = IpAddrMask(fromString: addr) {
+                addresses.append(addr_mask)
+            }
+        }
+
+        return addresses
+    }
+
+    init(fromStartData startData: TunnelStartData) {
+        name = startData.locationName
+        privateKey = startData.privateKey
+        let peer = Peer(publicKey: startData.publicKey)
+        peers = [peer]
+
+        addresses = self.parseAddresses(fromString: startData.address)
+
+        // DNS settings
+        let dnsRecords = startData.dns?.split(separator: ",").map {
+            $0.trimmingCharacters(in: .whitespaces)
+        } ?? []
+        if !dnsRecords.isEmpty {
+            for record in dnsRecords {
+                if IPv4Address(record) != nil || IPv6Address(record) != nil {
+                    dns.append(record)
+                } else {
+                    dnsSearch.append(record)
+                }
+            }
+        }
+
+        // Peer settings
+        peer.preSharedKey = startData.presharedKey
+        peer.endpoint = Endpoint(from: startData.endpoint)
+        peer.persistentKeepAlive = UInt16(startData.keepalive)
+        peer.allowedIPs =
+        switch startData.traffic {
+            case .All:
+                [
+                    IpAddrMask(address: IPv4Address.any, cidr: 0),
+                    IpAddrMask(address: IPv6Address.any, cidr: 0),
+                ]
+            case .Predefined:
+                self.parseAddresses(fromString: startData.allowedIps)
+        }
+    }
+#endif
+
     /// Client connection expects one peer, so check for that.
     func isValidForClientConnection() -> Bool {
         return peers.count == 1