Move name from interface to tunnel

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>

WireGuard/Shared/LegacyConfigMigration.swift

@@ -96,7 +96,7 @@ struct LegacyInterfaceConfiguration: LegacyModel {
     let dns: [LegacyDNSServer]
 
     var migrated: InterfaceConfiguration {
-        var interface = InterfaceConfiguration(name: name, privateKey: privateKey)
+        var interface = InterfaceConfiguration(privateKey: privateKey)
         interface.addresses = addresses.migrated
         interface.listenPort = listenPort
         interface.mtu = mtu
@@ -167,7 +167,7 @@ final class LegacyTunnelConfiguration: LegacyModel {
     let peers: [LegacyPeerConfiguration]
 
     var migrated: TunnelConfiguration {
-        return TunnelConfiguration(interface: interface.migrated, peers: peers.migrated)
+        return TunnelConfiguration(name: interface.name, interface: interface.migrated, peers: peers.migrated)
     }
 }
 

WireGuard/Shared/Model/InterfaceConfiguration.swift

@@ -4,18 +4,16 @@
 import Foundation
 
 struct InterfaceConfiguration {
-    var name: String?
     var privateKey: Data
     var addresses = [IPAddressRange]()
     var listenPort: UInt16?
     var mtu: UInt16?
     var dns = [DNSServer]()
 
-    init(name: String?, privateKey: Data) {
-        self.name = name
-        self.privateKey = privateKey
+    init(privateKey: Data) {
         if privateKey.count != TunnelConfiguration.keyLength {
             fatalError("Invalid private key")
         }
+        self.privateKey = privateKey
     }
 }

WireGuard/Shared/Model/TunnelConfiguration.swift

@@ -4,14 +4,16 @@
 import Foundation
 
 final class TunnelConfiguration {
+    var name: String?
     var interface: InterfaceConfiguration
     let peers: [PeerConfiguration]
 
     static let keyLength = 32
 
-    init(interface: InterfaceConfiguration, peers: [PeerConfiguration]) {
+    init(name: String?, interface: InterfaceConfiguration, peers: [PeerConfiguration]) {
         self.interface = interface
         self.peers = peers
+        self.name = name
 
         let peerPublicKeysArray = peers.map { $0.publicKey }
         let peerPublicKeysSet = Set<Data>(peerPublicKeysArray)

WireGuard/Shared/NETunnelProviderProtocol+Extension.swift

@@ -27,13 +27,14 @@ extension NETunnelProviderProtocol {
             serverAddress = "Multiple endpoints"
         }
 
-        username = tunnelConfiguration.interface.name
+        //TODO(roopc): Why are we doing this? Just for kicks? Is it useful? Seems needless.
+        username = tunnelConfiguration.name
     }
 
-    func tunnelConfiguration(name: String?) -> TunnelConfiguration? {
+    func asTunnelConfiguration(called name: String? = nil) -> TunnelConfiguration? {
         migrateConfigurationIfNeeded()
         guard let serializedConfig = providerConfiguration?[Keys.wgQuickConfig.rawValue] as? String else { return nil }
-        return try? TunnelConfiguration(serializedConfig, name: name)
+        return try? TunnelConfiguration(fromWgQuickConfig: serializedConfig, called: name)
     }
 
 }

WireGuard/Shared/TunnelConfiguration+WgQuickConfig.swift

@@ -20,8 +20,8 @@ extension TunnelConfiguration {
         case invalidPeer
     }
 
-    //swiftlint:disable:next cyclomatic_complexity function_body_length
-    convenience init(_ wgQuickConfig: String, name: String?) throws {
+    //swiftlint:disable:next function_body_length cyclomatic_complexity
+    convenience init(fromWgQuickConfig wgQuickConfig: String, called name: String? = nil) throws {
         var interfaceConfiguration: InterfaceConfiguration?
         var peerConfigurations = [PeerConfiguration]()
 
@@ -62,7 +62,7 @@ extension TunnelConfiguration {
             if isLastLine || lowercasedLine == "[interface]" || lowercasedLine == "[peer]" {
                 // Previous section has ended; process the attributes collected so far
                 if parserState == .inInterfaceSection {
-                    guard let interface = TunnelConfiguration.collate(interfaceAttributes: attributes, name: name) else { throw ParseError.invalidInterface }
+                    guard let interface = TunnelConfiguration.collate(interfaceAttributes: attributes) else { throw ParseError.invalidInterface }
                     guard interfaceConfiguration == nil else { throw ParseError.multipleInterfaces }
                     interfaceConfiguration = interface
                 } else if parserState == .inPeerSection {
@@ -87,7 +87,7 @@ extension TunnelConfiguration {
         }
 
         if let interfaceConfiguration = interfaceConfiguration {
-            self.init(interface: interfaceConfiguration, peers: peerConfigurations)
+            self.init(name: name, interface: interfaceConfiguration, peers: peerConfigurations)
         } else {
             throw ParseError.noInterface
         }
@@ -133,11 +133,11 @@ extension TunnelConfiguration {
     }
 
     //swiftlint:disable:next cyclomatic_complexity
-    private static func collate(interfaceAttributes attributes: [String: String], name: String?) -> InterfaceConfiguration? {
+    private static func collate(interfaceAttributes attributes: [String: String]) -> InterfaceConfiguration? {
         // required wg fields
         guard let privateKeyString = attributes["privatekey"] else { return nil }
         guard let privateKey = Data(base64Encoded: privateKeyString), privateKey.count == TunnelConfiguration.keyLength else { return nil }
-        var interface = InterfaceConfiguration(name: name, privateKey: privateKey)
+        var interface = InterfaceConfiguration(privateKey: privateKey)
         // other wg fields
         if let listenPortString = attributes["listenport"] {
             guard let listenPort = UInt16(listenPortString) else { return nil }