reconnect xpc on each request

ethanndickson · ethanndickson · commit c0a46aa01061 · 2025-02-10T13:36:07.000+11:00
diff --git a/Coder Desktop/Coder Desktop/VPNService.swift b/Coder Desktop/Coder Desktop/VPNService.swift
@@ -73,6 +73,7 @@ final class CoderVPNService: NSObject, VPNService {
                 .unconfigured
             }
         }
+        xpc.connect()
         xpc.getPeerState()
         NotificationCenter.default.addObserver(
             self,
@@ -100,7 +101,7 @@ final class CoderVPNService: NSObject, VPNService {
         }
 
         await startTunnel()
-        // this ping is somewhat load bearing since it causes xpc to init
+        xpc.connect()
         xpc.ping()
         logger.debug("network extension enabled")
     }
diff --git a/Coder Desktop/Coder Desktop/XPCInterface.swift b/Coder Desktop/Coder Desktop/XPCInterface.swift
@@ -6,11 +6,14 @@ import VPNLib
 @objc final class VPNXPCInterface: NSObject, VPNXPCClientCallbackProtocol, @unchecked Sendable {
     private var svc: CoderVPNService
     private let logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "VPNXPCInterface")
-    private let xpc: VPNXPCProtocol
+    private var xpc: VPNXPCProtocol? = nil
 
     init(vpn: CoderVPNService) {
         svc = vpn
+        super.init()
+    }
 
+    func connect() {
         let networkExtDict = Bundle.main.object(forInfoDictionaryKey: "NetworkExtension") as? [String: Any]
         let machServiceName = networkExtDict?["NEMachServiceName"] as? String
         let xpcConn = NSXPCConnection(machServiceName: machServiceName!)
@@ -21,32 +24,32 @@ import VPNLib
         }
         xpc = proxy
 
-        super.init()
-
         xpcConn.exportedObject = self
         xpcConn.invalidationHandler = { [logger] in
             Task { @MainActor in
                 logger.error("XPC connection invalidated.")
+                self.xpc = nil
             }
         }
         xpcConn.interruptionHandler = { [logger] in
             Task { @MainActor in
                 logger.error("XPC connection interrupted.")
+                self.xpc = nil
             }
         }
         xpcConn.resume()
     }
 
     func ping() {
-        xpc.ping {
+        xpc?.ping {
             Task { @MainActor in
                 self.logger.info("Connected to NE over XPC")
             }
         }
     }
 
     func getPeerState() {
-        xpc.getPeerState { data in
+        xpc?.getPeerState { data in
             Task { @MainActor in
                 self.svc.onExtensionPeerState(data)
             }

Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,7 @@ final class CoderVPNService: NSObject, VPNService {`
`73`	`73`	`.unconfigured`
`74`	`74`	`}`
`75`	`75`	`}`
	`76`	`+ xpc.connect()`
`76`	`77`	`xpc.getPeerState()`
`77`	`78`	`NotificationCenter.default.addObserver(`
`78`	`79`	`self,`
`@@ -100,7 +101,7 @@ final class CoderVPNService: NSObject, VPNService {`
`100`	`101`	`}`
`101`	`102`
`102`	`103`	`await startTunnel()`
`103`		`- // this ping is somewhat load bearing since it causes xpc to init`
	`104`	`+ xpc.connect()`
`104`	`105`	`xpc.ping()`
`105`	`106`	`logger.debug("network extension enabled")`
`106`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,14 @@ import VPNLib`
`6`	`6`	`@objc final class VPNXPCInterface: NSObject, VPNXPCClientCallbackProtocol, @unchecked Sendable {`
`7`	`7`	`private var svc: CoderVPNService`
`8`	`8`	`private let logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "VPNXPCInterface")`
`9`		`- private let xpc: VPNXPCProtocol`
	`9`	`+ private var xpc: VPNXPCProtocol? = nil`
`10`	`10`
`11`	`11`	`init(vpn: CoderVPNService) {`
`12`	`12`	`svc = vpn`
	`13`	`+ super.init()`
	`14`	`+ }`
`13`	`15`
	`16`	`+ func connect() {`
`14`	`17`	`let networkExtDict = Bundle.main.object(forInfoDictionaryKey: "NetworkExtension") as? [String: Any]`
`15`	`18`	`let machServiceName = networkExtDict?["NEMachServiceName"] as? String`
`16`	`19`	`let xpcConn = NSXPCConnection(machServiceName: machServiceName!)`
`@@ -21,32 +24,32 @@ import VPNLib`
`21`	`24`	`}`
`22`	`25`	`xpc = proxy`
`23`	`26`
`24`		`- super.init()`
`25`		`-`
`26`	`27`	`xpcConn.exportedObject = self`
`27`	`28`	`xpcConn.invalidationHandler = { [logger] in`
`28`	`29`	`Task { @MainActor in`
`29`	`30`	`logger.error("XPC connection invalidated.")`
	`31`	`+ self.xpc = nil`
`30`	`32`	`}`
`31`	`33`	`}`
`32`	`34`	`xpcConn.interruptionHandler = { [logger] in`
`33`	`35`	`Task { @MainActor in`
`34`	`36`	`logger.error("XPC connection interrupted.")`
	`37`	`+ self.xpc = nil`
`35`	`38`	`}`
`36`	`39`	`}`
`37`	`40`	`xpcConn.resume()`
`38`	`41`	`}`
`39`	`42`
`40`	`43`	`func ping() {`
`41`		`- xpc.ping {`
	`44`	`+ xpc?.ping {`
`42`	`45`	`Task { @MainActor in`
`43`	`46`	`self.logger.info("Connected to NE over XPC")`
`44`	`47`	`}`
`45`	`48`	`}`
`46`	`49`	`}`
`47`	`50`
`48`	`51`	`func getPeerState() {`
`49`		`- xpc.getPeerState { data in`
	`52`	`+ xpc?.getPeerState { data in`
`50`	`53`	`Task { @MainActor in`
`51`	`54`	`self.svc.onExtensionPeerState(data)`
`52`	`55`	`}`