Adds BSK support for the transparent proxy network extension

Sources/NetworkProtection/PacketTunnelProvider.swift

@@ -25,6 +25,8 @@
 import NetworkExtension
 import UserNotifications
 
+// swiftlint:disable file_length
+
 // swiftlint:disable:next type_body_length
 open class PacketTunnelProvider: NEPacketTunnelProvider {
 
@@ -341,10 +343,6 @@
         try loadAuthToken(from: options)
     }
 
-    open func prepareToConnect(using provider: NETunnelProviderProtocol?) {
-        // no-op
-    }
-
     open func loadVendorOptions(from provider: NETunnelProviderProtocol?) throws {
         let vendorOptions = provider?.providerConfiguration
 
@@ -459,6 +457,17 @@
             .store(in: &cancellables)
     }
 
+    // MARK: - Overrideable Connection Events
+
+    open func prepareToConnect(using provider: NETunnelProviderProtocol?) {
+        // no-op: abstract method to be overridden in subclass
+    }
+
+    @MainActor
+    open func handleConnected(with tunnelConfiguration: TunnelConfiguration) {
+        // no-op: abstract method to be overridden in subclass
+    }
+
     // MARK: - Tunnel Start
 
     open override func startTunnel(options: [String: NSObject]?, completionHandler: @escaping (Error?) -> Void) {
@@ -576,17 +585,21 @@
                 return
             }
 
-            Task { [weak self] in
+            Task { @MainActor [weak self] in
                 // It's important to call this completion handler before running the tester
                 // as if we don't, the tester will just fail.  It seems like the connection
                 // won't fully work until the completion handler is called.
                 completionHandler(nil)
 
+                guard let self else { return }
+
+                self.handleConnected(with: tunnelConfiguration)
+
                 do {
                     let startReason: AdapterStartReason = onDemand ? .onDemand : .manual
-                    try await self?.handleAdapterStarted(startReason: startReason)
+                    try await self.handleAdapterStarted(startReason: startReason)
                 } catch {
-                    self?.cancelTunnelWithError(error)
+                    self.cancelTunnelWithError(error)
                     return
                 }
             }
@@ -1154,5 +1167,4 @@
     public var debugDescription: String {
         errorDescription!
     }
-
 }

Sources/NetworkProtection/Session/ConnectionSessionUtilities.swift

@@ -59,7 +59,8 @@ public class ConnectionSessionUtilities {
     /// Retrieves a session from a `NEVPNStatusDidChange` notification.
     ///
     public static func session(from notification: Notification) -> NETunnelProviderSession? {
-        guard let session = (notification.object as? NETunnelProviderSession) else {
+        guard let session = (notification.object as? NETunnelProviderSession),
+              session.manager is NETunnelProviderManager else {
             return nil
         }
 

Sources/NetworkProtection/Status/ConnectionStatusObserver/ConnectionStatusObserverThroughSession.swift

@@ -66,7 +66,12 @@ public class ConnectionStatusObserverThroughSession: ConnectionStatusObserver {
     }
 
     private func startObservers() {
-        notificationCenter.publisher(for: .NEVPNConfigurationChange).sink { _ in
+        notificationCenter.publisher(for: .NEVPNConfigurationChange).sink { notification in
+            guard let session = ConnectionSessionUtilities.session(from: notification),
+                  session.manager is NETunnelProviderManager else {
+                return
+            }
+
             Task {
                 // As crazy as it seems, this calls fixes an issue with tunnel session
                 // having a nil manager, when in theory it should never be `nil`.  I don't know