passepartout-apple/Passepartout-iOS/Scenes/ConfigurationViewController...

467 lines
16 KiB
Swift
Raw Normal View History

2018-10-11 07:13:19 +00:00
//
// ConfigurationViewController.swift
// Passepartout-iOS
//
// Created by Davide De Rosa on 9/2/18.
2019-03-09 10:44:44 +00:00
// Copyright (c) 2019 Davide De Rosa. All rights reserved.
2018-10-11 07:13:19 +00:00
//
2018-11-03 21:33:30 +00:00
// https://github.com/passepartoutvpn
2018-10-11 07:13:19 +00:00
//
// This file is part of Passepartout.
//
// Passepartout is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Passepartout is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Passepartout. If not, see <http://www.gnu.org/licenses/>.
//
import UIKit
import TunnelKit
import SwiftyBeaver
2019-03-18 10:52:19 +00:00
import Passepartout_Core
private let log = SwiftyBeaver.self
2018-10-11 07:13:19 +00:00
class ConfigurationViewController: UIViewController, TableModelHost {
@IBOutlet private weak var tableView: UITableView!
private lazy var itemRefresh = UIBarButtonItem(barButtonSystemItem: .refresh, target: self, action: #selector(refresh))
var initialConfiguration: SessionProxy.Configuration!
2018-10-11 07:13:19 +00:00
private lazy var configuration: SessionProxy.ConfigurationBuilder = initialConfiguration.builder()
2018-10-11 07:13:19 +00:00
var originalConfigurationURL: URL?
private var isEditable: Bool {
return originalConfigurationURL != nil
}
2018-10-11 07:13:19 +00:00
weak var delegate: ConfigurationModificationDelegate?
// MARK: TableModelHost
lazy var model: TableModel<SectionType, RowType> = {
let model: TableModel<SectionType, RowType> = TableModel()
// sections
model.add(.communication)
if isEditable {
model.add(.reset)
}
2018-10-11 07:13:19 +00:00
model.add(.tls)
model.add(.compression)
2019-04-13 07:30:53 +00:00
model.add(.network)
2018-10-11 07:13:19 +00:00
model.add(.other)
// headers
model.setHeader(L10n.Configuration.Sections.Communication.header, for: .communication)
model.setHeader(L10n.Configuration.Sections.Tls.header, for: .tls)
model.setHeader(L10n.Configuration.Sections.Compression.header, for: .compression)
2019-04-13 07:30:53 +00:00
model.setHeader(L10n.Configuration.Sections.Network.header, for: .network)
2018-10-11 07:13:19 +00:00
model.setHeader(L10n.Configuration.Sections.Other.header, for: .other)
// footers
if isEditable {
model.setFooter(L10n.Configuration.Sections.Reset.footer, for: .reset)
2018-10-11 07:13:19 +00:00
}
// rows
model.set([.cipher, .digest], in: .communication)
if isEditable {
model.set([.resetOriginal], in: .reset)
}
model.set([.client, .tlsWrapping, .eku], in: .tls)
model.set([.compressionFraming, .compressionAlgorithm], in: .compression)
2019-04-13 07:30:53 +00:00
var networkRows: [RowType]
if let dnsServers = configuration.dnsServers {
2019-04-13 07:30:53 +00:00
networkRows = [RowType](repeating: .dnsServer, count: dnsServers.count)
} else {
2019-04-13 07:30:53 +00:00
networkRows = []
}
networkRows.insert(.defaultGateway, at: 0)
2019-04-13 07:30:53 +00:00
networkRows.append(.dnsDomain)
networkRows.append(.httpProxy)
networkRows.append(.httpsProxy)
model.set(networkRows, in: .network)
model.set([.keepAlive, .renegSeconds, .randomEndpoint], in: .other)
2018-10-11 07:13:19 +00:00
return model
}()
func reloadModel() {
}
// MARK: UIViewController
override func awakeFromNib() {
super.awakeFromNib()
applyDetailTitle(Theme.current)
}
override func viewDidLoad() {
super.viewDidLoad()
2018-10-11 07:13:19 +00:00
guard let _ = initialConfiguration else {
fatalError("Initial configuration not set")
}
guard isEditable else {
tableView.allowsSelection = false
return
}
itemRefresh.isEnabled = false
navigationItem.rightBarButtonItem = itemRefresh
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
if let ip = tableView.indexPathForSelectedRow {
tableView.deselectRow(at: ip, animated: true)
}
}
// MARK: Actions
private func resetOriginalConfiguration() {
2018-10-27 09:36:41 +00:00
guard let originalURL = originalConfigurationURL else {
log.warning("Resetting with no original configuration set? Bad table model?")
return
}
let parsingResult: ConfigurationParser.Result
do {
2018-11-10 09:29:51 +00:00
parsingResult = try ConfigurationParser.parsed(fromURL: originalURL)
} catch let e {
2018-10-27 08:55:50 +00:00
log.error("Could not parse original configuration: \(e)")
return
}
2018-11-10 09:29:51 +00:00
configuration = parsingResult.configuration.builder()
itemRefresh.isEnabled = !configuration.canCommunicate(with: initialConfiguration)
2018-11-10 09:29:51 +00:00
initialConfiguration = parsingResult.configuration
tableView.reloadData()
delegate?.configuration(didUpdate: initialConfiguration)
}
2018-10-11 07:13:19 +00:00
@IBAction private func refresh() {
guard isEditable else {
return
}
initialConfiguration = configuration.build()
itemRefresh.isEnabled = false
delegate?.configurationShouldReinstall()
}
}
// MARK: -
extension ConfigurationViewController: UITableViewDataSource, UITableViewDelegate {
enum SectionType: Int {
case communication
case reset
2018-10-11 07:13:19 +00:00
case tls
case compression
2019-04-13 07:30:53 +00:00
case network
2018-10-11 07:13:19 +00:00
case other
}
enum RowType: Int {
case cipher
case digest
case resetOriginal
2018-10-11 07:13:19 +00:00
case client
case tlsWrapping
case eku
case compressionFraming
2018-10-11 07:13:19 +00:00
case compressionAlgorithm
case defaultGateway
case dnsServer
case dnsDomain
2019-04-13 07:30:53 +00:00
case httpProxy
case httpsProxy
2018-10-11 07:13:19 +00:00
case keepAlive
case renegSeconds
case randomEndpoint
2018-10-11 07:13:19 +00:00
}
func numberOfSections(in tableView: UITableView) -> Int {
return model.count
}
func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
return model.header(for: section)
}
func tableView(_ tableView: UITableView, titleForFooterInSection section: Int) -> String? {
return model.footer(for: section)
}
func tableView(_ tableView: UITableView, heightForHeaderInSection section: Int) -> CGFloat {
return model.headerHeight(for: section)
}
2018-10-11 07:13:19 +00:00
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return model.count(for: section)
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let row = model.row(at: indexPath)
let V = L10n.Configuration.Cells.self
2018-10-11 07:13:19 +00:00
let cell = Cells.setting.dequeue(from: tableView, for: indexPath)
if !isEditable {
cell.accessoryType = .none
}
cell.isTappable = isEditable
switch row {
case .cipher:
cell.leftText = L10n.Configuration.Cells.Cipher.caption
cell.rightText = configuration.fallbackCipher.description
2018-10-11 07:13:19 +00:00
case .digest:
cell.leftText = L10n.Configuration.Cells.Digest.caption
cell.rightText = configuration.fallbackDigest.description
2018-10-11 07:13:19 +00:00
case .resetOriginal:
cell.leftText = L10n.Configuration.Cells.ResetOriginal.caption
cell.applyAction(Theme.current)
2018-10-11 07:13:19 +00:00
case .client:
cell.leftText = L10n.Configuration.Cells.Client.caption
cell.rightText = (configuration.clientCertificate != nil) ? L10n.Configuration.Cells.Client.Value.enabled : L10n.Configuration.Cells.Client.Value.disabled
cell.accessoryType = .none
cell.isTappable = false
case .tlsWrapping:
cell.leftText = L10n.Configuration.Cells.TlsWrapping.caption
if let strategy = configuration.tlsWrap?.strategy {
switch strategy {
case .auth:
cell.rightText = V.TlsWrapping.Value.auth
case .crypt:
cell.rightText = V.TlsWrapping.Value.crypt
}
} else {
cell.rightText = V.All.Value.disabled
}
2018-10-11 07:13:19 +00:00
cell.accessoryType = .none
cell.isTappable = false
case .eku:
cell.leftText = V.Eku.caption
cell.rightText = (configuration.checksEKU ?? false) ? V.All.Value.enabled : V.All.Value.disabled
cell.accessoryType = .none
cell.isTappable = false
case .compressionFraming:
cell.leftText = L10n.Configuration.Cells.CompressionFraming.caption
cell.rightText = configuration.fallbackCompressionFraming.cellDescription
cell.accessoryType = .none
cell.isTappable = false
case .compressionAlgorithm:
cell.leftText = L10n.Configuration.Cells.CompressionAlgorithm.caption
if let compressionAlgorithm = configuration.compressionAlgorithm {
cell.rightText = compressionAlgorithm.cellDescription
} else {
cell.rightText = V.All.Value.disabled
}
cell.accessoryType = .none
cell.isTappable = false
case .defaultGateway:
cell.leftText = L10n.Configuration.Cells.DefaultGateway.caption
if let policies = configuration.routingPolicies {
cell.rightText = policies.map { $0.rawValue }.joined(separator: " / ")
} else {
cell.rightText = V.All.Value.none
}
cell.accessoryType = .none
cell.isTappable = false
case .dnsServer:
guard let dnsServers = configuration.dnsServers else {
fatalError("Showing DNS section without any custom server")
}
cell.leftText = L10n.Configuration.Cells.DnsServer.caption
cell.rightText = dnsServers[indexPath.row - 1]
cell.accessoryType = .none
cell.isTappable = false
case .dnsDomain:
cell.leftText = L10n.Configuration.Cells.DnsDomain.caption
2019-04-13 07:30:53 +00:00
cell.rightText = configuration.searchDomain ?? L10n.Configuration.Cells.All.Value.none
cell.accessoryType = .none
cell.isTappable = false
2018-10-11 07:13:19 +00:00
2019-04-13 07:30:53 +00:00
case .httpProxy:
cell.leftText = L10n.Configuration.Cells.ProxyHttp.caption
cell.rightText = configuration.httpProxy?.description ?? L10n.Configuration.Cells.All.Value.none
cell.accessoryType = .none
cell.isTappable = false
case .httpsProxy:
cell.leftText = L10n.Configuration.Cells.ProxyHttps.caption
cell.rightText = configuration.httpsProxy?.description ?? L10n.Configuration.Cells.All.Value.none
cell.accessoryType = .none
cell.isTappable = false
2018-10-11 07:13:19 +00:00
case .keepAlive:
cell.leftText = L10n.Configuration.Cells.KeepAlive.caption
if let keepAlive = configuration.keepAliveInterval, keepAlive > 0 {
cell.rightText = V.KeepAlive.Value.seconds(Int(keepAlive))
2018-10-11 07:13:19 +00:00
} else {
cell.rightText = V.All.Value.disabled
2018-10-11 07:13:19 +00:00
}
cell.accessoryType = .none
cell.isTappable = false
case .renegSeconds:
cell.leftText = L10n.Configuration.Cells.RenegotiationSeconds.caption
if let reneg = configuration.renegotiatesAfter, reneg > 0 {
cell.rightText = V.RenegotiationSeconds.Value.after(TimeInterval(reneg).localized)
2018-10-11 07:13:19 +00:00
} else {
cell.rightText = V.All.Value.disabled
2018-10-11 07:13:19 +00:00
}
cell.accessoryType = .none
cell.isTappable = false
case .randomEndpoint:
cell.leftText = V.RandomEndpoint.caption
cell.rightText = (configuration.randomizeEndpoint ?? false) ? V.All.Value.enabled : V.All.Value.disabled
cell.accessoryType = .none
cell.isTappable = false
2018-10-11 07:13:19 +00:00
}
return cell
}
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
guard isEditable else {
fatalError("Table should not allow selection when isEditable is false")
}
let settingCell = tableView.cellForRow(at: indexPath) as? SettingTableViewCell
2018-10-11 07:13:19 +00:00
switch model.row(at: indexPath) {
case .cipher:
let vc = OptionViewController<SessionProxy.Cipher>()
vc.title = settingCell?.leftText
2018-10-11 07:13:19 +00:00
vc.options = [.aes128cbc, .aes192cbc, .aes256cbc, .aes128gcm, .aes192gcm, .aes256gcm]
vc.selectedOption = configuration.cipher
vc.descriptionBlock = { $0.description }
vc.selectionBlock = { [weak self] in
self?.configuration.cipher = $0
self?.popAndCheckRefresh()
}
navigationController?.pushViewController(vc, animated: true)
case .digest:
let vc = OptionViewController<SessionProxy.Digest>()
vc.title = settingCell?.leftText
2018-10-11 07:13:19 +00:00
vc.options = [.sha1, .sha224, .sha256, .sha384, .sha512]
vc.selectedOption = configuration.digest
vc.descriptionBlock = { $0.description }
vc.selectionBlock = { [weak self] in
self?.configuration.digest = $0
self?.popAndCheckRefresh()
}
navigationController?.pushViewController(vc, animated: true)
// case .compressionFraming:
// let vc = OptionViewController<SessionProxy.CompressionFraming>()
// vc.title = settingCell?.leftText
// vc.options = [.disabled, .compLZO, .compress]
// vc.selectedOption = configuration.compressionFraming
// vc.descriptionBlock = { $0.cellDescription }
// vc.selectionBlock = { [weak self] in
// self?.configuration.compressionFraming = $0
// self?.popAndCheckRefresh()
// }
// navigationController?.pushViewController(vc, animated: true)
2018-10-11 07:13:19 +00:00
case .resetOriginal:
tableView.deselectRow(at: indexPath, animated: true)
resetOriginalConfiguration()
2018-10-11 07:13:19 +00:00
default:
break
}
}
// MARK: Helpers
private func popAndCheckRefresh() {
itemRefresh.isEnabled = !configuration.canCommunicate(with: initialConfiguration)
tableView.reloadData()
navigationController?.popViewController(animated: true)
delegate?.configuration(didUpdate: configuration.build())
}
}
// MARK: -
private extension SessionProxy.CompressionFraming {
var cellDescription: String {
let V = L10n.Configuration.Cells.self
2018-10-11 07:13:19 +00:00
switch self {
case .disabled:
return V.All.Value.disabled
2018-10-11 07:13:19 +00:00
case .compLZO:
return V.CompressionFraming.Value.lzo
2018-10-11 07:13:19 +00:00
case .compress:
return V.CompressionFraming.Value.compress
2018-10-11 07:13:19 +00:00
}
}
}
private extension SessionProxy.CompressionAlgorithm {
var cellDescription: String {
let V = L10n.Configuration.Cells.self
switch self {
case .disabled:
return V.All.Value.disabled
case .LZO:
return V.CompressionAlgorithm.Value.lzo
case .other:
return V.CompressionAlgorithm.Value.other
}
}
}