Alessio Nossa
303 lines
12 KiB
Swift
303 lines
12 KiB
Swift
// SPDX-License-Identifier: MIT
|
|
// Copyright © 2018-2021 WireGuard LLC. All Rights Reserved.
|
|
|
|
import Intents
|
|
|
|
class IntentHandling: NSObject {
|
|
|
|
public enum IntentError: Error {
|
|
case failedDecode
|
|
case wrongTunnel
|
|
case unknown
|
|
}
|
|
|
|
var tunnelsManager: TunnelsManager?
|
|
|
|
var onTunnelsManagerReady: ((TunnelsManager) -> Void)?
|
|
|
|
var onTunnelStatusActivationReturn: ((Bool) -> Void)?
|
|
|
|
override init() {
|
|
super.init()
|
|
|
|
TunnelsManager.create { [weak self] result in
|
|
guard let self = self else { return }
|
|
|
|
switch result {
|
|
case .failure(let error):
|
|
wg_log(.error, message: error.localizedDescription)
|
|
case .success(let tunnelsManager):
|
|
self.tunnelsManager = tunnelsManager
|
|
|
|
self.tunnelsManager?.activationDelegate = self
|
|
|
|
self.onTunnelsManagerReady?(tunnelsManager)
|
|
self.onTunnelsManagerReady = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
init(tunnelsManager: TunnelsManager) {
|
|
super.init()
|
|
|
|
self.tunnelsManager = tunnelsManager
|
|
}
|
|
}
|
|
|
|
extension IntentHandling {
|
|
|
|
private func allTunnelNames(completion: @escaping ([String]?) -> Void) {
|
|
let getTunnelsNameBlock: (TunnelsManager) -> Void = { tunnelsManager in
|
|
let tunnelsNames = tunnelsManager.mapTunnels { $0.name }
|
|
return completion(tunnelsNames)
|
|
}
|
|
|
|
if let tunnelsManager = tunnelsManager {
|
|
getTunnelsNameBlock(tunnelsManager)
|
|
} else {
|
|
if onTunnelsManagerReady != nil {
|
|
wg_log(.error, message: "Overriding onTunnelsManagerReady action in allTunnelNames function. This should not happen.")
|
|
}
|
|
onTunnelsManagerReady = getTunnelsNameBlock
|
|
}
|
|
}
|
|
|
|
private func allTunnelPeers(for tunnelName: String, completion: @escaping (Result<[String], IntentError>) -> Void) {
|
|
let getPeersFromConfigBlock: (TunnelsManager) -> Void = { tunnelsManager in
|
|
guard let tunnel = tunnelsManager.tunnel(named: tunnelName) else {
|
|
return completion(.failure(.wrongTunnel))
|
|
}
|
|
|
|
guard let publicKeys = tunnel.tunnelConfiguration?.peers.map({ $0.publicKey.base64Key }) else {
|
|
return completion(.failure(.unknown))
|
|
}
|
|
return completion(.success(publicKeys))
|
|
}
|
|
|
|
if let tunnelsManager = tunnelsManager {
|
|
getPeersFromConfigBlock(tunnelsManager)
|
|
} else {
|
|
if onTunnelsManagerReady != nil {
|
|
wg_log(.error, message: "Overriding onTunnelsManagerReady action in allTunnelPeers function. This should not happen.")
|
|
}
|
|
onTunnelsManagerReady = getPeersFromConfigBlock
|
|
}
|
|
}
|
|
}
|
|
|
|
extension IntentHandling: GetPeersIntentHandling {
|
|
|
|
@available(iOSApplicationExtension 14.0, *)
|
|
func provideTunnelOptionsCollection(for intent: GetPeersIntent, with completion: @escaping (INObjectCollection<NSString>?, Error?) -> Void) {
|
|
|
|
self.allTunnelNames { tunnelsNames in
|
|
let tunnelsNamesObjects = (tunnelsNames ?? []).map { NSString(string: $0) }
|
|
|
|
let objectCollection = INObjectCollection(items: tunnelsNamesObjects)
|
|
completion(objectCollection, nil)
|
|
}
|
|
}
|
|
|
|
func handle(intent: GetPeersIntent, completion: @escaping (GetPeersIntentResponse) -> Void) {
|
|
guard let tunnel = intent.tunnel else {
|
|
return completion(GetPeersIntentResponse(code: .failure, userActivity: nil))
|
|
}
|
|
|
|
self.allTunnelPeers(for: tunnel) { peersResult in
|
|
switch peersResult {
|
|
case .success(let peers):
|
|
let response = GetPeersIntentResponse(code: .success, userActivity: nil)
|
|
response.peersPublicKeys = peers
|
|
completion(response)
|
|
|
|
case .failure(let error):
|
|
switch error {
|
|
case .wrongTunnel:
|
|
completion(GetPeersIntentResponse(code: .wrongTunnel, userActivity: nil))
|
|
default:
|
|
completion(GetPeersIntentResponse(code: .failure, userActivity: nil))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
extension IntentHandling: UpdateConfigurationIntentHandling {
|
|
|
|
@available(iOSApplicationExtension 14.0, *)
|
|
func provideTunnelOptionsCollection(for intent: UpdateConfigurationIntent, with completion: @escaping (INObjectCollection<NSString>?, Error?) -> Void) {
|
|
self.allTunnelNames { tunnelsNames in
|
|
let tunnelsNamesObjects = (tunnelsNames ?? []).map { NSString(string: $0) }
|
|
|
|
let objectCollection = INObjectCollection(items: tunnelsNamesObjects)
|
|
completion(objectCollection, nil)
|
|
}
|
|
}
|
|
|
|
func handle(intent: UpdateConfigurationIntent, completion: @escaping (UpdateConfigurationIntentResponse) -> Void) {
|
|
// Due to an Apple bug (https://developer.apple.com/forums/thread/96020) we can't update VPN
|
|
// configuration from extensions at the moment, so we should handle the action in the app.
|
|
// We check that the configuration update data is valid and then launch the main app.
|
|
|
|
guard let tunnelName = intent.tunnel,
|
|
let configurationString = intent.configuration else {
|
|
wg_log(.error, message: "Failed to get informations to update the configuration")
|
|
completion(UpdateConfigurationIntentResponse(code: .failure, userActivity: nil))
|
|
return
|
|
}
|
|
|
|
var configurations: [String: [String: String]]
|
|
|
|
let configurationsData = Data(configurationString.utf8)
|
|
do {
|
|
// Make sure this JSON is in the format we expect
|
|
if let decodedJson = try JSONSerialization.jsonObject(with: configurationsData, options: []) as? [String: [String: String]] {
|
|
configurations = decodedJson
|
|
} else {
|
|
throw IntentError.failedDecode
|
|
}
|
|
} catch _ {
|
|
wg_log(.error, message: "Failed to decode configuration data in JSON format for \(tunnelName)")
|
|
completion(UpdateConfigurationIntentResponse(code: .wrongConfiguration, userActivity: nil))
|
|
return
|
|
}
|
|
|
|
var activity: NSUserActivity?
|
|
if let bundleIdentifier = Bundle.main.bundleIdentifier {
|
|
activity = NSUserActivity(activityType: "\(bundleIdentifier).activity.update-tunnel-config")
|
|
activity?.userInfo = ["TunnelName": tunnelName,
|
|
"Configuration": configurations]
|
|
}
|
|
|
|
completion(UpdateConfigurationIntentResponse(code: .continueInApp, userActivity: activity))
|
|
}
|
|
|
|
}
|
|
|
|
extension IntentHandling: SetTunnelStatusIntentHandling {
|
|
|
|
@available(iOSApplicationExtension 14.0, *)
|
|
func provideTunnelOptionsCollection(for intent: SetTunnelStatusIntent, with completion: @escaping (INObjectCollection<NSString>?, Error?) -> Void) {
|
|
|
|
self.allTunnelNames { tunnelsNames in
|
|
let tunnelsNamesObjects = (tunnelsNames ?? []).map { NSString(string: $0) }
|
|
|
|
let objectCollection = INObjectCollection(items: tunnelsNamesObjects)
|
|
completion(objectCollection, nil)
|
|
}
|
|
}
|
|
|
|
func handle(intent: SetTunnelStatusIntent, completion: @escaping (SetTunnelStatusIntentResponse) -> Void) {
|
|
guard let tunnelName = intent.tunnel else {
|
|
return completion(SetTunnelStatusIntentResponse(code: .failure, userActivity: nil))
|
|
}
|
|
|
|
let setTunnelStatusResultBlock: (Bool) -> Void = { result in
|
|
if result {
|
|
completion(SetTunnelStatusIntentResponse(code: .success, userActivity: nil))
|
|
} else {
|
|
completion(SetTunnelStatusIntentResponse(code: .failure, userActivity: nil))
|
|
}
|
|
}
|
|
|
|
let updateStatusBlock: (TunnelsManager) -> Void = { tunnelsManager in
|
|
guard let tunnel = tunnelsManager.tunnel(named: tunnelName) else {
|
|
completion(SetTunnelStatusIntentResponse(code: .failure, userActivity: nil))
|
|
return
|
|
}
|
|
|
|
let operation = intent.operation
|
|
let isOn: Bool
|
|
|
|
if operation == .toggle {
|
|
switch tunnel.status {
|
|
case .inactive:
|
|
isOn = true
|
|
case .active:
|
|
isOn = false
|
|
default:
|
|
wg_log(.error, message: "SetTunnelStatusIntent action cannot be executed due to the current state of \(tunnelName) tunnel: \(tunnel.status)")
|
|
completion(SetTunnelStatusIntentResponse(code: .failure, userActivity: nil))
|
|
return
|
|
}
|
|
|
|
} else if operation == .turn {
|
|
if (tunnel.status == .inactive) || (tunnel.status == .active) {
|
|
isOn = (intent.state == .on)
|
|
|
|
if (isOn && tunnel.status == .active) || (!isOn && tunnel.status == .inactive) {
|
|
wg_log(.debug, message: "Tunnel \(tunnelName) is already \(isOn ? "active" : "inactive")")
|
|
completion(SetTunnelStatusIntentResponse(code: .success, userActivity: nil))
|
|
return
|
|
}
|
|
} else {
|
|
wg_log(.error, message: "SetTunnelStatusIntent action cannot be executed due to the current state of \(tunnelName) tunnel: \(tunnel.status)")
|
|
completion(SetTunnelStatusIntentResponse(code: .failure, userActivity: nil))
|
|
return
|
|
}
|
|
|
|
} else {
|
|
wg_log(.error, message: "Invalid 'operation' option in action")
|
|
completion(SetTunnelStatusIntentResponse(code: .failure, userActivity: nil))
|
|
return
|
|
}
|
|
|
|
if tunnel.hasOnDemandRules {
|
|
tunnelsManager.setOnDemandEnabled(isOn, on: tunnel) { error in
|
|
guard error == nil else {
|
|
wg_log(.error, message: "Error setting OnDemand status: \(error!.localizedDescription).")
|
|
completion(SetTunnelStatusIntentResponse(code: .failure, userActivity: nil))
|
|
return
|
|
}
|
|
|
|
if !isOn {
|
|
tunnelsManager.startDeactivation(of: tunnel)
|
|
}
|
|
|
|
completion(SetTunnelStatusIntentResponse(code: .success, userActivity: nil))
|
|
}
|
|
} else {
|
|
if isOn {
|
|
self.onTunnelStatusActivationReturn = setTunnelStatusResultBlock
|
|
tunnelsManager.startActivation(of: tunnel)
|
|
} else {
|
|
tunnelsManager.startDeactivation(of: tunnel)
|
|
completion(SetTunnelStatusIntentResponse(code: .success, userActivity: nil))
|
|
}
|
|
}
|
|
}
|
|
|
|
if let tunnelsManager = tunnelsManager {
|
|
updateStatusBlock(tunnelsManager)
|
|
} else {
|
|
if onTunnelsManagerReady != nil {
|
|
wg_log(.error, message: "Overriding onTunnelsManagerReady action in allTunnelPeers function. This should not happen.")
|
|
}
|
|
onTunnelsManagerReady = updateStatusBlock
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
extension IntentHandling: TunnelsManagerActivationDelegate {
|
|
func tunnelActivationAttemptFailed(tunnel: TunnelContainer, error: TunnelsManagerActivationAttemptError) {
|
|
wg_log(.error, message: "Tunnel Activation Attempt Failed with error: \(error.localizedDescription)")
|
|
self.onTunnelStatusActivationReturn?(false)
|
|
}
|
|
|
|
func tunnelActivationAttemptSucceeded(tunnel: TunnelContainer) {
|
|
// Nothing to do, we wait tunnelActivationSucceeded to be sure all activation logic has been executed
|
|
}
|
|
|
|
func tunnelActivationFailed(tunnel: TunnelContainer, error: TunnelsManagerActivationError) {
|
|
wg_log(.error, message: "Tunnel Activation Failed with error: \(error.localizedDescription)")
|
|
self.onTunnelStatusActivationReturn?(false)
|
|
}
|
|
|
|
func tunnelActivationSucceeded(tunnel: TunnelContainer) {
|
|
self.onTunnelStatusActivationReturn?(true)
|
|
}
|
|
|
|
}
|