1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
//
// PreferencesViewModel.swift
// MullvadVPN
//
// Created by pronebird on 11/10/2021.
// Copyright © 2021 Mullvad VPN AB. All rights reserved.
//
import UIKit
enum CustomDNSPrecondition {
/// Custom DNS can be enabled
case satisfied
/// Custom DNS cannot be enabled as it would conflict with other settings.
case conflictsWithOtherSettings
/// No valid DNS server entries.
case emptyDNSDomains
/// Returns localized description explaining how to enable Custom DNS.
func localizedDescription(isEditing: Bool) -> String? {
return attributedLocalizedDescription(
isEditing: isEditing,
preferredFont: UIFont.systemFont(ofSize: UIFont.systemFontSize)
)?.string
}
/// Returns attributed localized description explaining how to enable Custom DNS.
func attributedLocalizedDescription(isEditing: Bool, preferredFont: UIFont) -> NSAttributedString? {
switch self {
case .satisfied:
return nil
case .emptyDNSDomains:
if isEditing {
return NSAttributedString(markdownString: NSLocalizedString(
"CUSTOM_DNS_NO_DNS_ENTRIES_EDITING_ON_FOOTNOTE",
tableName: "Preferences",
value: "To enable this setting, add at least one server.",
comment: "Foot note displayed if there are no DNS entries and table view is in editing mode."
), font: preferredFont)
} else {
return NSAttributedString(markdownString: NSLocalizedString(
"CUSTOM_DNS_NO_DNS_ENTRIES_EDITING_OFF_FOOTNOTE",
tableName: "Preferences",
value: "Tap **Edit** to add at least one DNS server.",
comment: "Foot note displayed if there are no DNS entries, but table view is not in editing mode."
), font: preferredFont)
}
case .conflictsWithOtherSettings:
return NSAttributedString(markdownString: NSLocalizedString(
"CUSTOM_DNS_DISABLE_ADTRACKER_BLOCKING_FOOTNOTE",
tableName: "Preferences",
value: "Disable **Block ads** and **Block trackers** to activate this setting.",
comment: "Foot note displayed when custom DNS cannot be enabled, because ad/tracker blockers features should be disabled first."
), font: preferredFont)
}
}
}
struct DNSServerEntry: Equatable, Hashable {
var identifier = UUID()
var address: String
}
struct PreferencesViewModel: Equatable {
private(set) var blockAdvertising: Bool
private(set) var blockTracking: Bool
private(set) var enableCustomDNS: Bool
var customDNSDomains: [DNSServerEntry]
mutating func setBlockAdvertising(_ newValue: Bool) {
blockAdvertising = newValue
enableCustomDNS = false
}
mutating func setBlockTracking(_ newValue: Bool) {
blockTracking = newValue
enableCustomDNS = false
}
mutating func setEnableCustomDNS(_ newValue: Bool) {
blockTracking = false
blockAdvertising = false
enableCustomDNS = newValue
}
/// Precondition for enabling Custom DNS.
var customDNSPrecondition: CustomDNSPrecondition {
if blockAdvertising || blockTracking {
return .conflictsWithOtherSettings
} else {
let hasValidDNSDomains = customDNSDomains.contains { entry in
return AnyIPAddress(entry.address) != nil
}
if hasValidDNSDomains {
return .satisfied
} else {
return .emptyDNSDomains
}
}
}
/// Effective state of the custom DNS setting.
var effectiveEnableCustomDNS: Bool {
return customDNSPrecondition == .satisfied && enableCustomDNS
}
init(from dnsSettings: DNSSettings = DNSSettings()) {
blockAdvertising = dnsSettings.blockAdvertising
blockTracking = dnsSettings.blockTracking
enableCustomDNS = dnsSettings.enableCustomDNS
customDNSDomains = dnsSettings.customDNSDomains.map { ipAddress in
return DNSServerEntry(identifier: UUID(), address: "\(ipAddress)")
}
}
/// Produce merged view model keeping entry `identifier` for matching DNS entries.
func merged(_ other: PreferencesViewModel) -> PreferencesViewModel {
var mergedViewModel = PreferencesViewModel()
mergedViewModel.blockAdvertising = other.blockAdvertising
mergedViewModel.blockTracking = other.blockTracking
mergedViewModel.enableCustomDNS = other.enableCustomDNS
var oldDNSDomains = customDNSDomains
for otherEntry in other.customDNSDomains {
let sameEntryIndex = oldDNSDomains.firstIndex { entry in
return entry.address == otherEntry.address
}
if let sameEntryIndex = sameEntryIndex {
let sourceEntry = oldDNSDomains[sameEntryIndex]
mergedViewModel.customDNSDomains.append(sourceEntry)
oldDNSDomains.remove(at: sameEntryIndex)
} else {
mergedViewModel.customDNSDomains.append(otherEntry)
}
}
return mergedViewModel
}
/// Sanitize custom DNS entries.
mutating func sanitizeCustomDNSEntries() {
// Santize DNS domains, drop invalid entries.
customDNSDomains = customDNSDomains.compactMap { entry in
if let canonicalAddress = AnyIPAddress(entry.address) {
var newEntry = entry
newEntry.address = "\(canonicalAddress)"
return newEntry
} else {
return nil
}
}
// Toggle off custom DNS when no domains specified.
if customDNSDomains.isEmpty {
enableCustomDNS = false
}
}
func dnsEntry(entryIdentifier: UUID) -> DNSServerEntry? {
return customDNSDomains.first { entry in
return entry.identifier == entryIdentifier
}
}
/// Returns an index of entry in `customDNSDomains`, otherwise `nil`.
func indexOfDNSEntry(entryIdentifier: UUID) -> Int? {
return customDNSDomains.firstIndex { entry in
return entry.identifier == entryIdentifier
}
}
/// Update the address for the DNS entry with the given UUID.
mutating func updateDNSEntry(entryIdentifier: UUID, newAddress: String) {
guard let index = indexOfDNSEntry(entryIdentifier: entryIdentifier) else { return }
var entry = customDNSDomains[index]
entry.address = newAddress
customDNSDomains[index] = entry
}
/// Converts view model into `DNSSettings`.
func asDNSSettings() -> DNSSettings {
var dnsSettings = DNSSettings()
dnsSettings.blockAdvertising = blockAdvertising
dnsSettings.blockTracking = blockTracking
dnsSettings.enableCustomDNS = enableCustomDNS
dnsSettings.customDNSDomains = customDNSDomains.compactMap { entry in
return AnyIPAddress(entry.address)
}
return dnsSettings
}
/// Returns true if the given string is empty or a valid IP address.
func validateDNSDomainUserInput(_ string: String) -> Bool {
return string.isEmpty || AnyIPAddress(string) != nil
}
}
|
