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
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)
}
}
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
}
}
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)
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)
}
}
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]()
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 {
}
if let interfaceConfiguration = interfaceConfiguration {
- self.init(interface: interfaceConfiguration, peers: peerConfigurations)
+ self.init(name: name, interface: interfaceConfiguration, peers: peerConfigurations)
} else {
throw ParseError.noInterface
}
}
//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 }
}
func add(tunnelConfiguration: TunnelConfiguration, activateOnDemandSetting: ActivateOnDemandSetting = ActivateOnDemandSetting.defaultSetting, completionHandler: @escaping (WireGuardResult<TunnelContainer>) -> Void) {
- let tunnelName = tunnelConfiguration.interface.name ?? ""
+ let tunnelName = tunnelConfiguration.name ?? ""
if tunnelName.isEmpty {
completionHandler(.failure(TunnelsManagerError.tunnelNameEmpty))
return
let tunnelProviderManager = NETunnelProviderManager()
tunnelProviderManager.protocolConfiguration = NETunnelProviderProtocol(tunnelConfiguration: tunnelConfiguration)
- tunnelProviderManager.localizedDescription = tunnelConfiguration.interface.name
+ tunnelProviderManager.localizedDescription = tunnelConfiguration.name
tunnelProviderManager.isEnabled = true
activateOnDemandSetting.apply(on: tunnelProviderManager)
}
func modify(tunnel: TunnelContainer, tunnelConfiguration: TunnelConfiguration, activateOnDemandSetting: ActivateOnDemandSetting, completionHandler: @escaping (TunnelsManagerError?) -> Void) {
- let tunnelName = tunnelConfiguration.interface.name ?? ""
+ let tunnelName = tunnelConfiguration.name ?? ""
if tunnelName.isEmpty {
completionHandler(TunnelsManagerError.tunnelNameEmpty)
return
}
tunnelProviderManager.protocolConfiguration = NETunnelProviderProtocol(tunnelConfiguration: tunnelConfiguration)
- tunnelProviderManager.localizedDescription = tunnelConfiguration.interface.name
+ tunnelProviderManager.localizedDescription = tunnelConfiguration.name
tunnelProviderManager.isEnabled = true
let isActivatingOnDemand = !tunnelProviderManager.isOnDemandEnabled && activateOnDemandSetting.isActivateOnDemandEnabled
private var lastTunnelConnectionStatus: NEVPNStatus?
var tunnelConfiguration: TunnelConfiguration? {
- return (tunnelProvider.protocolConfiguration as? NETunnelProviderProtocol)?.tunnelConfiguration(name: tunnelProvider.localizedDescription)
+ return (tunnelProvider.protocolConfiguration as? NETunnelProviderProtocol)?.asTunnelConfiguration(called: tunnelProvider.localizedDescription)
}
var activateOnDemandSetting: ActivateOnDemandSetting {
var scratchpad = [InterfaceField: String]()
var fieldsWithError = Set<InterfaceField>()
var validatedConfiguration: InterfaceConfiguration?
+ var validatedName: String?
subscript(field: InterfaceField) -> String {
get {
populateScratchpad()
}
validatedConfiguration = nil
+ validatedName = nil
if stringValue.isEmpty {
scratchpad.removeValue(forKey: field)
} else {
func populateScratchpad() {
// Populate the scratchpad from the configuration object
guard let config = validatedConfiguration else { return }
- scratchpad[.name] = config.name
+ guard let name = validatedName else { return }
+ scratchpad[.name] = name
scratchpad[.privateKey] = config.privateKey.base64EncodedString()
scratchpad[.publicKey] = config.publicKey.base64EncodedString()
if !config.addresses.isEmpty {
}
//swiftlint:disable:next cyclomatic_complexity function_body_length
- func save() -> SaveResult<InterfaceConfiguration> {
- if let validatedConfiguration = validatedConfiguration {
+ func save() -> SaveResult<(String, InterfaceConfiguration)> {
+ if let config = validatedConfiguration, let name = validatedName {
// It's already validated and saved
- return .saved(validatedConfiguration)
+ return .saved((name, config))
}
fieldsWithError.removeAll()
guard let name = scratchpad[.name]?.trimmingCharacters(in: .whitespacesAndNewlines), (!name.isEmpty) else {
fieldsWithError.insert(.privateKey)
return .error(tr("alertInvalidInterfaceMessagePrivateKeyInvalid"))
}
- var config = InterfaceConfiguration(name: name, privateKey: privateKey)
+ var config = InterfaceConfiguration(privateKey: privateKey)
var errorMessages = [String]()
if let addressesString = scratchpad[.addresses] {
var addresses = [IPAddressRange]()
guard errorMessages.isEmpty else { return .error(errorMessages.first!) }
validatedConfiguration = config
- return .saved(config)
+ validatedName = name
+ return .saved((name, config))
}
func filterFieldsWithValueOrControl(interfaceFields: [InterfaceField]) -> [InterfaceField] {
var peersData = [PeerData]()
if let tunnelConfiguration = tunnelConfiguration {
interfaceData.validatedConfiguration = tunnelConfiguration.interface
+ interfaceData.validatedName = tunnelConfiguration.name
for (index, peerConfiguration) in tunnelConfiguration.peers.enumerated() {
let peerData = PeerData(index: index)
peerData.validatedConfiguration = peerConfiguration
return .error(tr("alertInvalidPeerMessagePublicKeyDuplicated"))
}
- let tunnelConfiguration = TunnelConfiguration(interface: interfaceConfiguration, peers: peerConfigurations)
+ let tunnelConfiguration = TunnelConfiguration(name: interfaceConfiguration.0, interface: interfaceConfiguration.1, peers: peerConfigurations)
return .saved(tunnelConfiguration)
}
}
}
func scanDidComplete(withCode code: String) {
- let scannedTunnelConfiguration = try? TunnelConfiguration(code, name: "Scanned")
+ let scannedTunnelConfiguration = try? TunnelConfiguration(fromWgQuickConfig: code, called: "Scanned")
guard let tunnelConfiguration = scannedTunnelConfiguration else {
scanDidEncounterError(title: tr("alertScanQRCodeInvalidQRCodeTitle"), message: tr("alertScanQRCodeInvalidQRCodeMessage"))
return
})
alert.addAction(UIAlertAction(title: tr("actionSave"), style: .default) { [weak self] _ in
guard let title = alert.textFields?[0].text?.trimmingCharacters(in: .whitespacesAndNewlines), !title.isEmpty else { return }
- tunnelConfiguration.interface.name = title
+ tunnelConfiguration.name = title
if let self = self {
self.delegate?.addScannedQRCode(tunnelConfiguration: tunnelConfiguration, qrScanViewController: self) {
self.dismiss(animated: true, completion: nil)
let tunnelSaveResult = tunnelViewModel.save()
switch tunnelSaveResult {
case .error(let errorMessage):
- let alertTitle = (tunnelViewModel.interfaceData.validatedConfiguration == nil) ?
+ let alertTitle = (tunnelViewModel.interfaceData.validatedConfiguration == nil || tunnelViewModel.interfaceData.validatedName == nil) ?
tr("alertInvalidInterfaceTitle") : tr("alertInvalidPeerTitle")
ErrorPresenter.showErrorAlert(title: alertTitle, message: errorMessage, from: self)
tableView.reloadData() // Highlight erroring fields
} else /* if (url.pathExtension == "conf") -- we assume everything else is a conf */ {
let fileBaseName = url.deletingPathExtension().lastPathComponent.trimmingCharacters(in: .whitespacesAndNewlines)
if let fileContents = try? String(contentsOf: url),
- let tunnelConfiguration = try? TunnelConfiguration(fileContents, name: fileBaseName) {
+ let tunnelConfiguration = try? TunnelConfiguration(fromWgQuickConfig: fileContents, called: fileBaseName) {
tunnelsManager.add(tunnelConfiguration: tunnelConfiguration) { [weak self] result in
if let error = result.error {
ErrorPresenter.showErrorAlert(error: error, from: self, onPresented: completionHandler)
var lastTunnelName: String = ""
for tunnelConfiguration in tunnelConfigurations {
if let contents = tunnelConfiguration.asWgQuickConfig().data(using: .utf8) {
- let name = tunnelConfiguration.interface.name ?? ""
+ let name = tunnelConfiguration.name ?? "untitled"
if name.isEmpty || name == lastTunnelName { continue }
inputsToArchiver.append((fileName: "\(name).conf", contents: contents))
lastTunnelName = name
continue
}
guard let fileContents = String(data: file.contents, encoding: .utf8) else { continue }
- guard let tunnelConfig = try? TunnelConfiguration(fileContents, name: file.fileBaseName) else { continue }
+ guard let tunnelConfig = try? TunnelConfiguration(fromWgQuickConfig: fileContents, called: file.fileBaseName) else { continue }
configs[index] = tunnelConfig
}
DispatchQueue.main.async { completion(.success(configs)) }
let errorNotifier = ErrorNotifier(activationAttemptId: activationAttemptId, tunnelProvider: self)
guard let tunnelProviderProtocol = protocolConfiguration as? NETunnelProviderProtocol,
- let tunnelConfiguration = tunnelProviderProtocol.tunnelConfiguration(name: nil) else {
+ let tunnelConfiguration = tunnelProviderProtocol.asTunnelConfiguration() else {
errorNotifier.notify(PacketTunnelProviderError.savedProtocolConfigurationIsInvalid)
startTunnelCompletionHandler(PacketTunnelProviderError.savedProtocolConfigurationIsInvalid)
return
projects / thirdparty / wireguard-apple.git / commitdiff
