protocol LegacyModel: Decodable {
associatedtype Model
-
+
var migrated: Model { get }
}
struct LegacyDNSServer: LegacyModel {
let address: IPAddress
-
+
var migrated: DNSServer {
return DNSServer(address: address)
}
-
+
init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
var data = try container.decode(Data.self)
}
address = ipAddress
}
-
+
enum DecodingError: Error {
case invalidData
}
struct LegacyEndpoint: LegacyModel {
let host: Network.NWEndpoint.Host
let port: Network.NWEndpoint.Port
-
+
var migrated: Endpoint {
return Endpoint(host: host, port: port)
}
-
+
public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
let endpointString = try container.decode(String.self)
host = NWEndpoint.Host(hostString)
port = endpointPort
}
-
+
enum DecodingError: Error {
case invalidData
}
let listenPort: UInt16?
let mtu: UInt16?
let dns: [LegacyDNSServer]
-
+
var migrated: InterfaceConfiguration {
var interface = InterfaceConfiguration(name: name, privateKey: privateKey)
interface.addresses = addresses.migrated
struct LegacyIPAddressRange: LegacyModel {
let address: IPAddress
let networkPrefixLength: UInt8
-
+
var migrated: IPAddressRange {
return IPAddressRange(address: address, networkPrefixLength: networkPrefixLength)
}
-
+
public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
var data = try container.decode(Data.self)
guard let ipAddress = ipAddressFromData else { throw DecodingError.invalidData }
address = ipAddress
}
-
+
enum DecodingError: Error {
case invalidData
}
let allowedIPs: [LegacyIPAddressRange]
let endpoint: LegacyEndpoint?
let persistentKeepAlive: UInt16?
-
+
var migrated: PeerConfiguration {
var configuration = PeerConfiguration(publicKey: publicKey)
configuration.preSharedKey = preSharedKey
final class LegacyTunnelConfiguration: LegacyModel {
let interface: LegacyInterfaceConfiguration
let peers: [LegacyPeerConfiguration]
-
+
var migrated: TunnelConfiguration {
return TunnelConfiguration(interface: interface.migrated, peers: peers.migrated)
}
}
extension NETunnelProviderProtocol {
-
+
@discardableResult
func migrateConfigurationIfNeeded() -> Bool {
guard let configurationVersion = providerConfiguration?["tunnelConfigurationVersion"] as? Int else { return false }
}
return true
}
-
+
private func migrateFromConfigurationV1() {
guard let serializedTunnelConfiguration = providerConfiguration?["tunnelConfiguration"] as? Data else { return }
- guard let configuration = try? JSONDecoder().decode(LegacyTunnelConfiguration.self, from: serializedTunnelConfiguration) else { return }
+ guard let configuration = try? JSONDecoder().decode(LegacyTunnelConfiguration.self, from: serializedTunnelConfiguration) else { return }
providerConfiguration = [Keys.wgQuickConfig.rawValue: configuration.migrated.asWgQuickConfig()]
}
-
+
}
enum LoggerError: Error {
case openFailure
}
-
+
static var global: Logger?
var log: OpaquePointer
struct DNSServer {
let address: IPAddress
-
+
init(address: IPAddress) {
self.address = address
}
var stringRepresentation: String {
return "\(address)"
}
-
+
init?(from addressString: String) {
if let addr = IPv4Address(addressString) {
address = addr
struct Endpoint {
let host: NWEndpoint.Host
let port: NWEndpoint.Port
-
+
init(host: NWEndpoint.Host, port: NWEndpoint.Port) {
self.host = host
self.port = port
return "[\(address)]:\(port)"
}
}
-
+
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
struct IPAddressRange {
let address: IPAddress
var networkPrefixLength: UInt8
-
+
init(address: IPAddress, networkPrefixLength: UInt8) {
self.address = address
self.networkPrefixLength = networkPrefixLength
var stringRepresentation: String {
return "\(address)/\(networkPrefixLength)"
}
-
+
init?(from string: String) {
guard let parsed = IPAddressRange.parseAddressString(string) else { return nil }
address = parsed.0
networkPrefixLength = parsed.1
}
-
+
private static func parseAddressString(_ string: String) -> (IPAddress, UInt8)? {
let endOfIPAddress = string.lastIndex(of: "/") ?? string.endIndex
let addressString = String(string[string.startIndex ..< endOfIPAddress])
} else {
return nil
}
-
+
let maxNetworkPrefixLength: UInt8 = address is IPv4Address ? 32 : 128
var networkPrefixLength: UInt8
if endOfIPAddress < string.endIndex { // "/" was located
} else {
networkPrefixLength = maxNetworkPrefixLength
}
-
+
return (address, networkPrefixLength)
}
}
var listenPort: UInt16?
var mtu: UInt16?
var dns = [DNSServer]()
-
+
init(name: String?, privateKey: Data) {
self.name = name
self.privateKey = privateKey
var allowedIPs = [IPAddressRange]()
var endpoint: Endpoint?
var persistentKeepAlive: UInt16?
-
+
init(publicKey: Data) {
self.publicKey = publicKey
if publicKey.count != TunnelConfiguration.keyLength {
private var tunnelNameKey: Void?
extension NETunnelProviderProtocol {
-
+
enum Keys: String {
case wgQuickConfig = "WgQuickConfig"
}
-
+
convenience init?(tunnelConfiguration: TunnelConfiguration) {
self.init()
-
+
let appId = Bundle.main.bundleIdentifier!
providerBundleIdentifier = "\(appId).network-extension"
providerConfiguration = [Keys.wgQuickConfig.rawValue: tunnelConfiguration.asWgQuickConfig()]
-
+
let endpoints = tunnelConfiguration.peers.compactMap { $0.endpoint }
if endpoints.count == 1 {
serverAddress = endpoints[0].stringRepresentation
} else {
serverAddress = "Multiple endpoints"
}
-
+
username = tunnelConfiguration.interface.name
}
-
+
func tunnelConfiguration(name: String?) -> TunnelConfiguration? {
migrateConfigurationIfNeeded()
guard let serializedConfig = providerConfiguration?[Keys.wgQuickConfig.rawValue] as? String else { return nil }
return try? TunnelConfiguration(serializedConfig, name: name)
}
-
+
}
import Foundation
extension String {
-
+
func splitToArray(separator: Character = ",", trimmingCharacters: CharacterSet? = nil) -> [String] {
return split(separator: separator)
.map {
}
}
}
-
+
}
extension Optional where Wrapped == String {
-
+
func splitToArray(separator: Character = ",", trimmingCharacters: CharacterSet? = nil) -> [String] {
switch self {
case .none:
return wrapped.splitToArray(separator: separator, trimmingCharacters: trimmingCharacters)
}
}
-
+
}
import Foundation
extension TunnelConfiguration {
-
+
enum ParserState {
case inInterfaceSection
case inPeerSection
case notInASection
}
-
+
enum ParseError: Error {
case invalidLine(_ line: String.SubSequence)
case noInterface
case multiplePeersWithSamePublicKey
case invalidPeer
}
-
+
//swiftlint:disable:next cyclomatic_complexity function_body_length
convenience init(_ wgQuickConfig: String, name: String?) throws {
var interfaceConfiguration: InterfaceConfiguration?
var peerConfigurations = [PeerConfiguration]()
-
+
let lines = wgQuickConfig.split(separator: "\n")
-
+
var parserState = ParserState.notInASection
var attributes = [String: String]()
-
+
for (lineIndex, line) in lines.enumerated() {
var trimmedLine: String
if let commentRange = line.range(of: "#") {
} else {
trimmedLine = String(line)
}
-
+
trimmedLine = trimmedLine.trimmingCharacters(in: .whitespaces)
-
+
guard !trimmedLine.isEmpty else { continue }
let lowercasedLine = line.lowercased()
-
+
if let equalsIndex = line.firstIndex(of: "=") {
// Line contains an attribute
let key = line[..<equalsIndex].trimmingCharacters(in: .whitespaces).lowercased()
} else if lowercasedLine != "[interface]" && lowercasedLine != "[peer]" {
throw ParseError.invalidLine(line)
}
-
+
let isLastLine = lineIndex == lines.count - 1
-
+
if isLastLine || lowercasedLine == "[interface]" || lowercasedLine == "[peer]" {
// Previous section has ended; process the attributes collected so far
if parserState == .inInterfaceSection {
peerConfigurations.append(peer)
}
}
-
+
if lowercasedLine == "[interface]" {
parserState = .inInterfaceSection
attributes.removeAll()
attributes.removeAll()
}
}
-
+
let peerPublicKeysArray = peerConfigurations.map { $0.publicKey }
let peerPublicKeysSet = Set<Data>(peerPublicKeysArray)
if peerPublicKeysArray.count != peerPublicKeysSet.count {
throw ParseError.multiplePeersWithSamePublicKey
}
-
+
if let interfaceConfiguration = interfaceConfiguration {
self.init(interface: interfaceConfiguration, peers: peerConfigurations)
} else {
throw ParseError.noInterface
}
}
-
+
func asWgQuickConfig() -> String {
var output = "[Interface]\n"
output.append("PrivateKey = \(interface.privateKey.base64EncodedString())\n")
if let mtu = interface.mtu {
output.append("MTU = \(mtu)\n")
}
-
+
for peer in peers {
output.append("\n[Peer]\n")
output.append("PublicKey = \(peer.publicKey.base64EncodedString())\n")
output.append("PersistentKeepalive = \(persistentKeepAlive)\n")
}
}
-
+
return output
}
-
+
//swiftlint:disable:next cyclomatic_complexity
private static func collate(interfaceAttributes attributes: [String: String], name: String?) -> InterfaceConfiguration? {
// required wg fields
}
return interface
}
-
+
//swiftlint:disable:next cyclomatic_complexity
private static func collate(peerAttributes attributes: [String: String]) -> PeerConfiguration? {
// required wg fields
}
return peer
}
-
+
}
enum TunnelsManagerActivationError: WireGuardAppError {
case activationFailed(wasOnDemandEnabled: Bool)
case activationFailedWithExtensionError(title: String, message: String, wasOnDemandEnabled: Bool)
-
+
var alertText: AlertText {
switch self {
case .activationFailed(let wasOnDemandEnabled):
case reasserting // Not a possible state at present
case restarting // Restarting tunnel (done after saving modifications to an active tunnel)
case waiting // Waiting for another tunnel to be brought down
-
+
init(from systemStatus: NEVPNStatus) {
switch systemStatus {
case .connected:
completionHandler(.failure(TunnelsManagerError.systemErrorOnListingTunnels(systemError: error)))
return
}
-
+
let tunnelManagers = managers ?? []
tunnelManagers.forEach { tunnelManager in
if (tunnelManager.protocolConfiguration as? NETunnelProviderProtocol)?.migrateConfigurationIfNeeded() == true {
completionHandler(.failure(TunnelsManagerError.systemErrorOnAddTunnel(systemError: error!)))
return
}
-
+
guard let self = self else { return }
-
+
let tunnel = TunnelContainer(tunnel: tunnelProviderManager)
self.tunnels.append(tunnel)
self.tunnels.sort { $0.name < $1.name }
tunnelProviderManager.protocolConfiguration = NETunnelProviderProtocol(tunnelConfiguration: tunnelConfiguration)
tunnelProviderManager.localizedDescription = (tunnelConfiguration).interface.name
tunnelProviderManager.isEnabled = true
-
+
let isActivatingOnDemand = !tunnelProviderManager.isOnDemandEnabled && activateOnDemandSetting.isActivateOnDemandEnabled
activateOnDemandSetting.apply(on: tunnelProviderManager)
return
}
guard let self = self else { return }
-
+
if isNameChanged {
let oldIndex = self.tunnels.firstIndex(of: tunnel)!
self.tunnels.sort { $0.name < $1.name }
var tunnelConfiguration: TunnelConfiguration? {
return (tunnelProvider.protocolConfiguration as? NETunnelProviderProtocol)?.tunnelConfiguration(name: tunnelProvider.localizedDescription)
}
-
+
var activateOnDemandSetting: ActivateOnDemandSetting {
return ActivateOnDemandSetting(from: tunnelProvider)
}
-
+
init(tunnel: NETunnelProviderManager) {
name = tunnel.localizedDescription ?? "Unnamed"
let status = TunnelStatus(from: tunnel.connection.status)
button.titleLabel?.adjustsFontForContentSizeCategory = true
return button
}()
-
+
override var intrinsicContentSize: CGSize {
let buttonSize = button.intrinsicContentSize
return CGSize(width: buttonSize.width + 32, height: buttonSize.height + 16)
}
-
+
var title: String {
get { return button.title(for: .normal) ?? "" }
set(value) { button.setTitle(value, for: .normal) }
}
-
+
var onTapped: (() -> Void)?
-
+
init() {
super.init(frame: CGRect.zero)
-
+
layer.borderWidth = 1
layer.cornerRadius = 5
layer.borderColor = button.tintColor.cgColor
-
+
addSubview(button)
button.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
button.centerXAnchor.constraint(equalTo: centerXAnchor),
button.centerYAnchor.constraint(equalTo: centerYAnchor)
])
-
+
button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
}
-
+
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
@objc func buttonTapped() {
onTapped?()
}
-
+
}
set(value) { button.tintColor = value ? .red : buttonStandardTintColor }
}
var onTapped: (() -> Void)?
-
+
let button: UIButton = {
let button = UIButton(type: .system)
button.titleLabel?.font = UIFont.preferredFont(forTextStyle: .body)
button.titleLabel?.adjustsFontForContentSizeCategory = true
return button
}()
-
+
var buttonStandardTintColor: UIColor
-
+
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
buttonStandardTintColor = button.tintColor
super.init(style: style, reuseIdentifier: reuseIdentifier)
-
+
contentView.addSubview(button)
button.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
contentView.layoutMarginsGuide.bottomAnchor.constraint(equalTo: button.bottomAnchor),
button.centerXAnchor.constraint(equalTo: contentView.centerXAnchor)
])
-
+
button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
}
-
+
@objc func buttonTapped() {
onTapped?()
}
-
+
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
override func prepareForReuse() {
super.prepareForReuse()
buttonText = ""
accessoryType = isChecked ? .checkmark : .none
}
}
-
+
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
isChecked = false
super.init(style: .default, reuseIdentifier: reuseIdentifier)
}
-
+
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
override func prepareForReuse() {
super.prepareForReuse()
message = ""
import UIKit
class KeyValueCell: UITableViewCell {
-
+
let keyLabel: UILabel = {
let keyLabel = UILabel()
keyLabel.font = UIFont.preferredFont(forTextStyle: .body)
keyLabel.textAlignment = .left
return keyLabel
}()
-
+
let valueLabelScrollView: UIScrollView = {
let scrollView = UIScrollView(frame: .zero)
scrollView.isDirectionalLockEnabled = true
scrollView.showsVerticalScrollIndicator = false
return scrollView
}()
-
+
let valueTextField: UITextField = {
let valueTextField = UITextField()
valueTextField.textAlignment = .right
valueTextField.textColor = .gray
return valueTextField
}()
-
+
var copyableGesture = true
var key: String {
get { return valueTextField.keyboardType }
set(value) { valueTextField.keyboardType = value }
}
-
+
var isValueValid = true {
didSet {
if isValueValid {
}
}
}
-
+
var isStackedHorizontally = false
var isStackedVertically = false
var contentSizeBasedConstraints = [NSLayoutConstraint]()
-
+
var onValueChanged: ((String) -> Void)?
var onValueBeingEdited: ((String) -> Void)?
-
+
private var textFieldValueOnBeginEditing: String = ""
-
+
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
super.init(style: style, reuseIdentifier: reuseIdentifier)
-
+
contentView.addSubview(keyLabel)
keyLabel.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
keyLabel.leftAnchor.constraint(equalTo: contentView.layoutMarginsGuide.leftAnchor),
keyLabel.topAnchor.constraint(equalToSystemSpacingBelow: contentView.layoutMarginsGuide.topAnchor, multiplier: 0.5)
])
-
+
valueTextField.delegate = self
valueLabelScrollView.addSubview(valueTextField)
valueTextField.translatesAutoresizingMaskIntoConstraints = false
let expandToFitValueLabelConstraint = NSLayoutConstraint(item: valueTextField, attribute: .width, relatedBy: .equal, toItem: valueLabelScrollView, attribute: .width, multiplier: 1, constant: 0)
expandToFitValueLabelConstraint.priority = .defaultLow + 1
expandToFitValueLabelConstraint.isActive = true
-
+
contentView.addSubview(valueLabelScrollView)
-
+
contentView.addSubview(valueLabelScrollView)
valueLabelScrollView.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
valueLabelScrollView.rightAnchor.constraint(equalTo: contentView.layoutMarginsGuide.rightAnchor),
contentView.layoutMarginsGuide.bottomAnchor.constraint(equalToSystemSpacingBelow: valueLabelScrollView.bottomAnchor, multiplier: 0.5)
])
-
+
keyLabel.setContentCompressionResistancePriority(.defaultHigh + 1, for: .horizontal)
keyLabel.setContentHuggingPriority(.defaultHigh, for: .horizontal)
valueLabelScrollView.setContentHuggingPriority(.defaultLow, for: .horizontal)
-
+
let gestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleTapGesture(_:)))
addGestureRecognizer(gestureRecognizer)
isUserInteractionEnabled = true
-
+
configureForContentSize()
}
-
+
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
func configureForContentSize() {
var constraints = [NSLayoutConstraint]()
if traitCollection.preferredContentSizeCategory.isAccessibilityCategory {
contentSizeBasedConstraints = constraints
}
}
-
+
@objc func handleTapGesture(_ recognizer: UIGestureRecognizer) {
if !copyableGesture {
return
}
guard recognizer.state == .recognized else { return }
-
+
if let recognizerView = recognizer.view,
let recognizerSuperView = recognizerView.superview, recognizerView.becomeFirstResponder() {
let menuController = UIMenuController.shared
menuController.setMenuVisible(true, animated: true)
}
}
-
+
override var canBecomeFirstResponder: Bool {
return true
}
-
+
override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
return (action == #selector(UIResponderStandardEditActions.copy(_:)))
}
-
+
override func copy(_ sender: Any?) {
UIPasteboard.general.string = valueTextField.text
}
-
+
override func prepareForReuse() {
super.prepareForReuse()
copyableGesture = true
}
extension KeyValueCell: UITextFieldDelegate {
-
+
func textFieldDidBeginEditing(_ textField: UITextField) {
textFieldValueOnBeginEditing = textField.text ?? ""
isValueValid = true
}
-
+
func textFieldDidEndEditing(_ textField: UITextField) {
let isModified = textField.text ?? "" != textFieldValueOnBeginEditing
guard isModified else { return }
onValueChanged?(textField.text ?? "")
}
-
+
func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
if let onValueBeingEdited = onValueBeingEdited {
let modifiedText = ((textField.text ?? "") as NSString).replacingCharacters(in: range, with: string)
}
return true
}
-
+
}
textLabel?.textColor = value ? .black : .gray
}
}
-
+
var onSwitchToggled: ((Bool) -> Void)?
-
+
let switchView = UISwitch()
-
+
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
super.init(style: .default, reuseIdentifier: reuseIdentifier)
-
+
accessoryView = switchView
switchView.addTarget(self, action: #selector(switchToggled), for: .valueChanged)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
@objc func switchToggled() {
onSwitchToggled?(switchView.isOn)
}
-
+
override func prepareForReuse() {
super.prepareForReuse()
isEnabled = true
import UIKit
class TunnelEditKeyValueCell: KeyValueCell {
-
+
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
super.init(style: style, reuseIdentifier: reuseIdentifier)
-
+
keyLabel.textAlignment = .right
valueTextField.textAlignment = .left
-
+
let widthRatioConstraint = NSLayoutConstraint(item: keyLabel, attribute: .width, relatedBy: .equal, toItem: self, attribute: .width, multiplier: 0.4, constant: 0)
// In case the key doesn't fit into 0.4 * width,
// set a CR priority > the 0.4-constraint's priority.
widthRatioConstraint.priority = .defaultHigh + 1
widthRatioConstraint.isActive = true
}
-
+
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
}
class TunnelEditEditableKeyValueCell: TunnelEditKeyValueCell {
-
+
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
super.init(style: style, reuseIdentifier: reuseIdentifier)
-
+
copyableGesture = false
valueTextField.textColor = .black
valueTextField.isEnabled = true
valueLabelScrollView.isScrollEnabled = false
valueTextField.widthAnchor.constraint(equalTo: valueLabelScrollView.widthAnchor).isActive = true
}
-
+
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
}
}
}
var onSwitchToggled: ((Bool) -> Void)?
-
+
let nameLabel: UILabel = {
let nameLabel = UILabel()
nameLabel.font = UIFont.preferredFont(forTextStyle: .body)
nameLabel.numberOfLines = 0
return nameLabel
}()
-
+
let busyIndicator: UIActivityIndicatorView = {
let busyIndicator = UIActivityIndicatorView(style: .gray)
busyIndicator.hidesWhenStopped = true
return busyIndicator
}()
-
+
let statusSwitch = UISwitch()
-
+
private var statusObservationToken: AnyObject?
private var nameObservationToken: AnyObject?
-
+
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
super.init(style: style, reuseIdentifier: reuseIdentifier)
-
+
contentView.addSubview(statusSwitch)
statusSwitch.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
statusSwitch.centerYAnchor.constraint(equalTo: contentView.centerYAnchor),
contentView.rightAnchor.constraint(equalTo: statusSwitch.rightAnchor)
])
-
+
contentView.addSubview(busyIndicator)
busyIndicator.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
busyIndicator.centerYAnchor.constraint(equalTo: contentView.centerYAnchor),
statusSwitch.leftAnchor.constraint(equalToSystemSpacingAfter: busyIndicator.rightAnchor, multiplier: 1)
])
-
+
contentView.addSubview(nameLabel)
nameLabel.translatesAutoresizingMaskIntoConstraints = false
nameLabel.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
busyIndicator.leftAnchor.constraint(equalToSystemSpacingAfter: nameLabel.rightAnchor, multiplier: 1),
bottomAnchorConstraint
])
-
+
accessoryType = .disclosureIndicator
-
+
statusSwitch.addTarget(self, action: #selector(switchToggled), for: .valueChanged)
}
-
+
@objc func switchToggled() {
onSwitchToggled?(statusSwitch.isOn)
}
-
+
private func update(from status: TunnelStatus?) {
guard let status = status else {
reset()
}
}
}
-
+
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
private func reset() {
statusSwitch.isOn = false
statusSwitch.isUserInteractionEnabled = false
busyIndicator.stopAnimating()
}
-
+
override func prepareForReuse() {
super.prepareForReuse()
reset()
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
guard let logo = tableView.tableFooterView else { return }
-
+
let bottomPadding = max(tableView.layoutMargins.bottom, 10)
let fullHeight = max(tableView.contentSize.height, tableView.bounds.size.height - tableView.layoutMargins.top - bottomPadding)
-
+
let imageAspectRatio = logo.intrinsicContentSize.width / logo.intrinsicContentSize.height
-
+
var height = tableView.estimatedRowHeight * 1.5
var width = height * imageAspectRatio
let maxWidth = view.bounds.size.width - max(tableView.layoutMargins.left + tableView.layoutMargins.right, 20)
width = maxWidth
height = width / imageAspectRatio
}
-
+
let needsReload = height != logo.frame.height
-
+
logo.frame = CGRect(x: (view.bounds.size.width - width) / 2, y: fullHeight - height, width: width, height: height)
-
+
if needsReload {
tableView.tableFooterView = logo
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
-
+
deinit {
onDemandStatusObservationToken = nil
statusObservationToken = nil
private func statusCell(for tableView: UITableView, at indexPath: IndexPath) -> UITableViewCell {
let cell: SwitchCell = tableView.dequeueReusableCell(for: indexPath)
-
+
let statusUpdate: (SwitchCell, TunnelStatus) -> Void = { cell, status in
let text: String
switch status {
}
cell.isEnabled = status == .active || status == .inactive
}
-
+
statusUpdate(cell, tunnel.status)
statusObservationToken = tunnel.observe(\.status) { [weak cell] tunnel, _ in
guard let cell = cell else { return }
statusUpdate(cell, tunnel.status)
}
-
+
cell.onSwitchToggled = { [weak self] isOn in
guard let self = self else { return }
if isOn {
tableView.register(TunnelListCell.self)
return tableView
}()
-
+
let centeredAddButton: BorderedTextButton = {
let button = BorderedTextButton()
button.title = tr("tunnelsListCenteredAddTunnelButtonTitle")
button.isHidden = true
return button
}()
-
+
let busyIndicator: UIActivityIndicatorView = {
let busyIndicator = UIActivityIndicatorView(style: .gray)
busyIndicator.hidesWhenStopped = true
return busyIndicator
}()
-
+
override func loadView() {
view = UIView()
view.backgroundColor = .white
-
+
tableView.dataSource = self
tableView.delegate = self
-
+
view.addSubview(tableView)
tableView.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
busyIndicator.centerXAnchor.constraint(equalTo: view.centerXAnchor),
busyIndicator.centerYAnchor.constraint(equalTo: view.centerYAnchor)
])
-
+
view.addSubview(centeredAddButton)
centeredAddButton.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
centeredAddButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
centeredAddButton.centerYAnchor.constraint(equalTo: view.centerYAnchor)
])
-
+
centeredAddButton.onTapped = { [weak self] in
guard let self = self else { return }
self.addButtonTapped(sender: self.centeredAddButton)
}
-
+
busyIndicator.startAnimating()
}
-
+
override func viewDidLoad() {
super.viewDidLoad()
func setTunnelsManager(tunnelsManager: TunnelsManager) {
self.tunnelsManager = tunnelsManager
tunnelsManager.tunnelsListDelegate = self
-
+
busyIndicator.stopAnimating()
tableView.reloadData()
centeredAddButton.isHidden = tunnelsManager.numberOfTunnels() > 0
@objc func addButtonTapped(sender: AnyObject) {
guard tunnelsManager != nil else { return }
-
+
let alert = UIAlertController(title: "", message: tr("addTunnelMenuHeader"), preferredStyle: .actionSheet)
let importFileAction = UIAlertAction(title: tr("addTunnelMenuImportFile"), style: .default) { [weak self] _ in
self?.presentViewControllerForFileImport()
@objc func settingsButtonTapped(sender: UIBarButtonItem) {
guard tunnelsManager != nil else { return }
-
+
let settingsVC = SettingsTableViewController(tunnelsManager: tunnelsManager)
let settingsNC = UINavigationController(rootViewController: settingsVC)
settingsNC.modalPresentationStyle = .formSheet
protocol WireGuardAppError: Error {
typealias AlertText = (title: String, message: String)
-
+
var alertText: AlertText { get }
}
extension DNSResolver {
// Based on DNS resolution code by Jason Donenfeld <jason@zx2c4.com>
// in parse_endpoint() in src/tools/config.c in the WireGuard codebase
-
+
//swiftlint:disable:next cyclomatic_complexity
private static func resolveSync(endpoint: Endpoint) -> Endpoint? {
switch endpoint.host {
}
class PacketTunnelProvider: NEPacketTunnelProvider {
-
+
private var wgHandle: Int32?
private var networkMonitor: NWPathMonitor?
private var lastFirstInterface: NWInterface?
projects / thirdparty / wireguard-apple.git / commitdiff
