mirror of
https://github.com/shadowsocks/ShadowsocksX-NG.git
synced 2026-11-22 05:25:41 +00:00
Global mode now deploys a minimal proxy_all ACL carrying only the fixed local safety rules, so public targets default through Shadowsocks while loopback/RFC1918/link-local/ULA/localhost/*.local/no-dot hosts stay direct for SOCKS, HTTP, and LAN-sharing clients. System proxy exceptions include that fixed scope; IPv6 system-exception limits are documented with the ACL as the routing guarantee. Mode switches keep the full-restart and rollback path. Closes #62
191 lines
6.1 KiB
Swift
191 lines
6.1 KiB
Swift
import Foundation
|
|
|
|
extension ProxyRuntimeController {
|
|
/// The choice persists with the settings snapshot. ACL-backed modes (direct
|
|
/// and global) also deploy and verify the ACL runtime even when system proxy
|
|
/// is off, because manually connected SOCKS and HTTP clients use the same ACL.
|
|
func setProxyMode(_ mode: ProxyMode) async {
|
|
guard ProxyMode.availableModes.contains(mode) else { return }
|
|
guard mode != proxyMode else { return }
|
|
let previousSettings = settings
|
|
let previousMode = proxyMode
|
|
let previousDocument = lastDocument
|
|
let previousState = state
|
|
var next = settings
|
|
next.preferredMode = mode.kind
|
|
do {
|
|
try settingsStore.save(next)
|
|
} catch {
|
|
RuntimeLog.emit(.runtimePersistFailed(detail: String(describing: error)))
|
|
state = .serviceFailed(.persistence)
|
|
return
|
|
}
|
|
settings = next
|
|
proxyMode = mode
|
|
modeChangeGeneration += 1
|
|
let generation = modeChangeGeneration
|
|
|
|
guard settings.agentEnabled, state != .off,
|
|
let currentDocument = lastDocument ?? runtimeFileStore.loadDocument()
|
|
else {
|
|
if settings.systemProxyEnabled { systemProxyState = .pending }
|
|
return
|
|
}
|
|
|
|
let nextDocument = runtimeDocument(currentDocument, for: mode)
|
|
guard nextDocument.aclRuntime != currentDocument.aclRuntime else {
|
|
guard settings.systemProxyEnabled else { return }
|
|
state = .starting
|
|
_ = await presentLaunchHealth(nextDocument)
|
|
return
|
|
}
|
|
|
|
await deployModeTransition(
|
|
nextDocument,
|
|
previousMode: previousMode,
|
|
previousDocument: previousDocument ?? currentDocument,
|
|
previousState: previousState,
|
|
previousSystemProxyEnabled: previousSettings.systemProxyEnabled,
|
|
generation: generation)
|
|
}
|
|
|
|
func runtimeDocument(
|
|
_ document: SslocalRuntimeDocument,
|
|
for mode: ProxyMode
|
|
) -> SslocalRuntimeDocument {
|
|
switch mode {
|
|
case .direct:
|
|
return document.replacingACL(.direct(at: runtimeFileStore.aclFileURL))
|
|
case .global:
|
|
return document.replacingACL(.global(at: runtimeFileStore.aclFileURL))
|
|
case .pac:
|
|
return document.replacingACL(nil)
|
|
}
|
|
}
|
|
|
|
private func deployModeTransition(
|
|
_ document: SslocalRuntimeDocument,
|
|
previousMode: ProxyMode,
|
|
previousDocument: SslocalRuntimeDocument,
|
|
previousState: AgentRunState,
|
|
previousSystemProxyEnabled: Bool,
|
|
generation: Int
|
|
) async {
|
|
guard generation == modeChangeGeneration else { return }
|
|
lastDocument = document
|
|
state = .starting
|
|
guard await execute(.run(document), document: document) else {
|
|
guard generation == modeChangeGeneration else { return }
|
|
await restoreModeTransition(
|
|
previousMode: previousMode,
|
|
previousDocument: previousDocument,
|
|
previousState: previousState,
|
|
previousSystemProxyEnabled: previousSystemProxyEnabled,
|
|
generation: generation)
|
|
return
|
|
}
|
|
|
|
guard generation == modeChangeGeneration else { return }
|
|
let healthy = await presentLaunchHealth(
|
|
document,
|
|
requiresReceipt: true,
|
|
convergeProxyOnSuccess: false,
|
|
preserveProxyOnFailure: true)
|
|
guard generation == modeChangeGeneration else { return }
|
|
guard healthy else {
|
|
await restoreModeTransition(
|
|
previousMode: previousMode,
|
|
previousDocument: previousDocument,
|
|
previousState: previousState,
|
|
previousSystemProxyEnabled: previousSystemProxyEnabled,
|
|
generation: generation)
|
|
return
|
|
}
|
|
|
|
lastDocument = document
|
|
await convergeSystemProxy()
|
|
}
|
|
|
|
private func restoreModeTransition(
|
|
previousMode: ProxyMode,
|
|
previousDocument: SslocalRuntimeDocument,
|
|
previousState: AgentRunState,
|
|
previousSystemProxyEnabled: Bool,
|
|
generation: Int
|
|
) async {
|
|
var persistenceFailed = false
|
|
var restoredSettings = settings
|
|
restoredSettings.preferredMode = previousMode.kind
|
|
do {
|
|
try settingsStore.save(restoredSettings)
|
|
} catch {
|
|
persistenceFailed = true
|
|
RuntimeLog.emit(.runtimePersistFailed(detail: String(describing: error)))
|
|
}
|
|
guard generation == modeChangeGeneration else { return }
|
|
settings = restoredSettings
|
|
proxyMode = previousMode
|
|
lastDocument = previousDocument
|
|
|
|
let expectedDigest = previousDocument.deploymentSHA256
|
|
let currentDocument = runtimeFileStore.loadDocument()
|
|
let receipt = runtimeFileStore.readRuntimeReceipt()
|
|
let wrapper = wrapperState()
|
|
let previousInstanceIsRunning: Bool
|
|
switch wrapper {
|
|
case .running(let pid):
|
|
previousInstanceIsRunning =
|
|
receipt?.processID == pid && receipt?.contractSHA256 == expectedDigest
|
|
case .notRunning:
|
|
previousInstanceIsRunning = false
|
|
}
|
|
if currentDocument != previousDocument || !previousInstanceIsRunning {
|
|
do {
|
|
if currentDocument != previousDocument {
|
|
try runtimeFileStore.write(previousDocument)
|
|
}
|
|
} catch {
|
|
state = .serviceFailed(.runtimeFile)
|
|
await withdrawSystemProxyAfterEntryLoss()
|
|
return
|
|
}
|
|
|
|
if !previousInstanceIsRunning {
|
|
switch wrapper {
|
|
case .running(let pid):
|
|
guard sendSignal(pid, SIGUSR1) == 0 else {
|
|
state = .serviceFailed(.agent)
|
|
await withdrawSystemProxyAfterEntryLoss()
|
|
return
|
|
}
|
|
case .notRunning:
|
|
guard await execute(.run(previousDocument), document: previousDocument) else {
|
|
guard generation == modeChangeGeneration else { return }
|
|
await withdrawSystemProxyAfterEntryLoss()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
guard generation == modeChangeGeneration else { return }
|
|
state = .starting
|
|
let restored = await presentLaunchHealth(
|
|
previousDocument,
|
|
requiresReceipt: true,
|
|
convergeProxyOnSuccess: false)
|
|
guard generation == modeChangeGeneration else { return }
|
|
guard restored else {
|
|
await withdrawSystemProxyAfterEntryLoss()
|
|
return
|
|
}
|
|
|
|
if settings.systemProxyEnabled != previousSystemProxyEnabled {
|
|
await convergeSystemProxy()
|
|
} else {
|
|
state = previousState
|
|
}
|
|
if persistenceFailed { state = .serviceFailed(.persistence) }
|
|
}
|
|
}
|