Move logic to extension: Move model files to Shared

Signed-off-by: Roopesh Chander <roop@roopc.net>

WireGuard/Shared/Model/Configuration.swift

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+// Copyright © 2018 WireGuard LLC. All Rights Reserved.
+
+import Foundation
+
+@available(OSX 10.14, iOS 12.0, *)
+class TunnelConfiguration: Codable {
+    var interface: InterfaceConfiguration
+    var peers: [PeerConfiguration] = []
+    init(interface: InterfaceConfiguration) {
+        self.interface = interface
+    }
+}
+
+@available(OSX 10.14, iOS 12.0, *)
+struct InterfaceConfiguration: Codable {
+    var name: String
+    var privateKey: Data
+    var addresses: [IPAddressRange] = []
+    var listenPort: UInt16?
+    var mtu: UInt16?
+    var dns: [DNSServer] = []
+
+    var publicKey: Data {
+        return Curve25519.generatePublicKey(fromPrivateKey: privateKey)
+    }
+
+    init(name: String, privateKey: Data) {
+        self.name = name
+        self.privateKey = privateKey
+        if (name.isEmpty) { fatalError("Empty name") }
+        if (privateKey.count != 32) { fatalError("Invalid private key") }
+    }
+}
+
+@available(OSX 10.14, iOS 12.0, *)
+struct PeerConfiguration: Codable {
+    var publicKey: Data
+    var preSharedKey: Data? {
+        didSet(value) {
+            if let value = value {
+                if (value.count != 32) { fatalError("Invalid preshared key") }
+            }
+        }
+    }
+    var allowedIPs: [IPAddressRange] = []
+    var endpoint: Endpoint?
+    var persistentKeepAlive: UInt16?
+
+    init(publicKey: Data) {
+        self.publicKey = publicKey
+        if (publicKey.count != 32) { fatalError("Invalid public key") }
+    }
+}

WireGuard/Shared/Model/DNSServer.swift

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+// Copyright © 2018 WireGuard LLC. All Rights Reserved.
+
+import Foundation
+import Network
+
+@available(OSX 10.14, iOS 12.0, *)
+struct DNSServer {
+    let address: IPAddress
+}
+
+// MARK: Converting to and from String
+// For use in the UI
+
+extension DNSServer {
+    init?(from addressString: String) {
+        if let addr = IPv4Address(addressString) {
+            address = addr
+        } else if let addr = IPv6Address(addressString) {
+            address = addr
+        } else {
+            return nil
+        }
+    }
+    func stringRepresentation() -> String {
+        return "\(address)"
+    }
+}
+
+// MARK: Codable
+// For serializing to disk
+
+@available(OSX 10.14, iOS 12.0, *)
+extension DNSServer: Codable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(address.rawValue)
+    }
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        var data = try container.decode(Data.self)
+        let ipAddressFromData: IPAddress? = {
+            switch (data.count) {
+            case 4: return IPv4Address(data)
+            case 16: return IPv6Address(data)
+            default: return nil
+            }
+        }()
+        guard let ipAddress = ipAddressFromData else {
+            throw DecodingError.invalidData
+        }
+        address = ipAddress
+    }
+    enum DecodingError: Error {
+        case invalidData
+    }
+}

WireGuard/Shared/Model/Endpoint.swift

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: MIT
+// Copyright © 2018 WireGuard LLC. All Rights Reserved.
+
+import Foundation
+import Network
+
+@available(OSX 10.14, iOS 12.0, *)
+struct Endpoint {
+    let host: NWEndpoint.Host
+    let port: NWEndpoint.Port
+}
+
+// MARK: Converting to and from String
+// For use in the UI
+
+extension Endpoint {
+    init?(from string: String) {
+        // Separation of host and port is based on 'parse_endpoint' function in
+        // https://git.zx2c4.com/WireGuard/tree/src/tools/config.c
+        guard (!string.isEmpty) else { return nil }
+        let startOfPort: String.Index
+        let hostString: String
+        if (string.first! == "[") {
+            // Look for IPv6-style endpoint, like [::1]:80
+            let startOfHost = string.index(after: string.startIndex)
+            guard let endOfHost = string.dropFirst().firstIndex(of: "]") else { return nil }
+            let afterEndOfHost = string.index(after: endOfHost)
+            guard (string[afterEndOfHost] == ":") else { return nil }
+            startOfPort = string.index(after: afterEndOfHost)
+            hostString = String(string[startOfHost ..< endOfHost])
+        } else {
+            // Look for an IPv4-style endpoint, like 127.0.0.1:80
+            guard let endOfHost = string.firstIndex(of: ":") else { return nil }
+            startOfPort = string.index(after: endOfHost)
+            hostString = String(string[string.startIndex ..< endOfHost])
+        }
+        guard let endpointPort = NWEndpoint.Port(String(string[startOfPort ..< string.endIndex])) else { return nil }
+        let invalidCharacterIndex = hostString.unicodeScalars.firstIndex { (c) -> Bool in
+            return !CharacterSet.urlHostAllowed.contains(c)
+        }
+        guard (invalidCharacterIndex == nil) else { return nil }
+        host = NWEndpoint.Host(hostString)
+        port = endpointPort
+    }
+    func stringRepresentation() -> String {
+        switch (host) {
+        case .name(let hostname, _):
+            return "\(hostname):\(port)"
+        case .ipv4(let address):
+            return "\(address):\(port)"
+        case .ipv6(let address):
+            return "[\(address)]:\(port)"
+        }
+    }
+}
+
+// MARK: Codable
+// For serializing to disk
+
+@available(OSX 10.14, iOS 12.0, *)
+extension Endpoint: Codable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(self.stringRepresentation())
+    }
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let endpointString = try container.decode(String.self)
+        guard let endpoint = Endpoint(from: endpointString) else {
+            throw DecodingError.invalidData
+        }
+        self = endpoint
+    }
+    enum DecodingError: Error {
+        case invalidData
+    }
+}
+
+extension Endpoint {
+    func hasHostAsIPAddress() -> Bool {
+        switch (host) {
+        case .name(_, _):
+            return false
+        case .ipv4(_):
+            return true
+        case .ipv6(_):
+            return true
+        }
+    }
+}

WireGuard/Shared/Model/IPAddressRange.swift

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+// Copyright © 2018 WireGuard LLC. All Rights Reserved.
+
+import Foundation
+import Network
+
+@available(OSX 10.14, iOS 12.0, *)
+struct IPAddressRange {
+    let address: IPAddress
+    var networkPrefixLength: UInt8
+}
+
+// MARK: Converting to and from String
+// For use in the UI
+
+extension IPAddressRange {
+    init?(from string: String) {
+        let endOfIPAddress = string.lastIndex(of: "/") ?? string.endIndex
+        let addressString = String(string[string.startIndex ..< endOfIPAddress])
+        let address: IPAddress
+        if let addr = IPv4Address(addressString) {
+            address = addr
+        } else if let addr = IPv6Address(addressString) {
+            address = addr
+        } else {
+            return nil
+        }
+        let maxNetworkPrefixLength: UInt8 = (address is IPv4Address) ? 32 : 128
+        var networkPrefixLength: UInt8
+        if (endOfIPAddress < string.endIndex) { // "/" was located
+            let indexOfNetworkPrefixLength = string.index(after: endOfIPAddress)
+            guard (indexOfNetworkPrefixLength < string.endIndex) else { return nil }
+            let networkPrefixLengthSubstring = string[indexOfNetworkPrefixLength ..< string.endIndex]
+            guard let npl = UInt8(networkPrefixLengthSubstring) else { return nil }
+            networkPrefixLength = min(npl, maxNetworkPrefixLength)
+        } else {
+            networkPrefixLength = maxNetworkPrefixLength
+        }
+        self.address = address
+        self.networkPrefixLength = networkPrefixLength
+    }
+    func stringRepresentation() -> String {
+        return "\(address)/\(networkPrefixLength)"
+    }
+}
+
+// MARK: Codable
+// For serializing to disk
+
+@available(OSX 10.14, iOS 12.0, *)
+extension IPAddressRange: Codable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        let addressDataLength: Int
+        if address is IPv4Address {
+            addressDataLength = 4
+        } else if address is IPv6Address {
+            addressDataLength = 16
+        } else {
+            fatalError()
+        }
+        var data = Data(capacity: addressDataLength + 1)
+        data.append(address.rawValue)
+        data.append(networkPrefixLength)
+        try container.encode(data)
+    }
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        var data = try container.decode(Data.self)
+        networkPrefixLength = data.removeLast()
+        let ipAddressFromData: IPAddress? = {
+            switch (data.count) {
+            case 4: return IPv4Address(data)
+            case 16: return IPv6Address(data)
+            default: return nil
+            }
+        }()
+        guard let ipAddress = ipAddressFromData else {
+            throw DecodingError.invalidData
+        }
+        address = ipAddress
+    }
+    enum DecodingError: Error {
+        case invalidData
+    }
+}