@mentra/glasses-media 3.3.0-dev.820 → 3.3.0-dev.821

package/ios/CoreKit/Sources/GlassesMediaCore/HotspotInterfacePolicy.swift

@@ -18,10 +18,14 @@ public struct HotspotInterfaceAddress: Equatable {
 public struct HotspotInterfaceSnapshot: Equatable {
     public let links: [String: Int]
     public let addresses: [HotspotInterfaceAddress]
+    /// Attached interfaces whose `AF_LINK` type is `IFT_ETHER`. Apple platforms report Wi-Fi and
+    /// wired Ethernet this way; cellular, VPN tunnel and loopback links have other types.
+    public let ethernetLinks: Set<String>
 
-    public init(links: [String: Int], addresses: [HotspotInterfaceAddress]) {
+    public init(links: [String: Int], addresses: [HotspotInterfaceAddress], ethernetLinks: Set<String> = []) {
         self.links = links
         self.addresses = addresses
+        self.ethernetLinks = ethernetLinks
     }
 }
 
@@ -87,6 +91,13 @@ public struct HotspotWifiIdentity: Equatable {
             detached.insert(name)
         }
     }
+
+    /// Pin a binding chosen from hotspot client evidence (see `HotspotInterfacePolicy.select`)
+    /// as this session's Wi-Fi interface. It then ends exactly like a reported one.
+    public mutating func adopt(_ binding: HotspotInterfaceBinding) {
+        guard !rejected.contains(binding.interface), !detached.contains(binding.interface) else { return }
+        trusted[binding.interface] = binding.index
+    }
 }
 
 /// Wi-Fi is not always `en0`: a Mac can have built-in Ethernet on `en0` and Wi-Fi on `en1`.
@@ -96,11 +107,33 @@ public enum HotspotInterfacePolicy {
     /// The unique up IPv4 address, on an interface this session trusts as Wi-Fi and that is still
     /// attached with the same index, that can be the hotspot client. With a BLE-reported gateway
     /// it must be a valid client on that gateway's /24. Missing or ambiguous candidates return nil.
+    ///
+    /// A phone on cellular has no Wi-Fi path when the join starts, and after association iOS
+    /// leaves the internet-less glasses AP out of both paths, so no Wi-Fi report ever arrives.
+    /// Only when the session has no trusted Wi-Fi interface, the hotspot client address is the
+    /// evidence instead: the unique valid client of the BLE gateway's /24 on an attached
+    /// Ethernet-type link that no path has reported as non-Wi-Fi. Callers bind it only after the
+    /// glasses SSID matched, then require a connection from it to reach the gateway, and must
+    /// `adopt` it so the session pins that interface.
     public static func select(snapshot: HotspotInterfaceSnapshot, identity: HotspotWifiIdentity,
                               gateway: String?) -> HotspotInterfaceBinding?
+    {
+        if !identity.trusted.isEmpty {
+            return unique(snapshot, gateway: gateway) { identity.trusted[$0] }
+        }
+        guard let gateway else { return nil }
+        return unique(snapshot, gateway: gateway) { name in
+            guard snapshot.ethernetLinks.contains(name), !identity.rejected.contains(name),
+                  !identity.detached.contains(name) else { return nil }
+            return snapshot.links[name]
+        }
+    }
+
+    private static func unique(_ snapshot: HotspotInterfaceSnapshot, gateway: String?,
+                               index eligibleIndex: (String) -> Int?) -> HotspotInterfaceBinding?
     {
         let bindings = Set(snapshot.addresses.compactMap { row -> HotspotInterfaceBinding? in
-            guard let index = identity.trusted[row.name], snapshot.links[row.name] == index,
+            guard let index = eligibleIndex(row.name), snapshot.links[row.name] == index,
                   row.isUp, LocalMediaPolicy.isPrivate(row.ipv4) else { return nil }
             if let gateway, !LocalMediaPolicy.isHotspotClientAddress(row.ipv4, gateway: gateway) { return nil }
             return HotspotInterfaceBinding(interface: row.name, index: index, address: row.ipv4)

package/ios/GlassesHotspotNetwork.swift

@@ -257,6 +257,8 @@ public final class GlassesHotspotNetwork {
     /// a Wi-Fi type constraint on a usable hotspot route. Both paths' interface types feed one
     /// session identity (HotspotWifiIdentity): a positive Wi-Fi report outlives later omission
     /// only while the same interface stays attached; contrary reports and replacement fail closed.
+    /// A phone that starts on cellular never gets a report; HotspotInterfacePolicy then uses
+    /// the hotspot client address as the evidence.
     private func startInterfaceMonitors(generation gen: Int) {
         interfaceMonitors.forEach { $0.cancel() }
         let monitors = [NWPathMonitor(requiredInterfaceType: .wifi), NWPathMonitor()]
@@ -318,8 +320,10 @@ public final class GlassesHotspotNetwork {
     }
 
     private func bind(_ selected: HotspotInterfaceBinding) {
+        let evidence = wifiIdentity.trusted[selected.interface] == selected.index ? "wifi_report" : "hotspot_client"
+        wifiIdentity.adopt(selected)
         binding = selected
-        logger.info("HOTSPOT_JOIN address_verified interface=\(selected.interface, privacy: .public)")
+        logger.info("HOTSPOT_JOIN address_verified interface=\(selected.interface, privacy: .public) evidence=\(evidence, privacy: .public)")
     }
 
     /// Interface names and their IPv4 addresses only; never credentials or SSIDs.
@@ -327,8 +331,11 @@ public final class GlassesHotspotNetwork {
         let snapshot = observeInterfaces()
         let wifi = Set(wifiIdentity.trusted.keys)
         let addresses = snapshot.addresses.filter { wifi.contains($0.name) }.map { "\($0.name)=\($0.ipv4)" }
+        let other = snapshot.addresses.filter { !wifi.contains($0.name) && LocalMediaPolicy.isPrivate($0.ipv4) }
+            .map { "\($0.name)\(snapshot.ethernetLinks.contains($0.name) ? "" : "(non-ethernet)")=\($0.ipv4)" }
         return "Wi-Fi interfaces=\(wifi.isEmpty ? "none" : wifi.sorted().joined(separator: ",")), " +
-            "Wi-Fi IPv4=\(addresses.isEmpty ? "none" : addresses.sorted().joined(separator: ","))"
+            "Wi-Fi IPv4=\(addresses.isEmpty ? "none" : addresses.sorted().joined(separator: ",")), " +
+            "other private IPv4=\(other.isEmpty ? "none" : other.sorted().joined(separator: ","))"
     }
 
     private func waitForLocalAccess(address: String, generation gen: Int) {
@@ -376,14 +383,16 @@ public final class GlassesHotspotNetwork {
         replies.forEach { $0() }
     }
 
-    /// Every attached interface's kernel index (its AF_LINK row) and every IPv4 address with its
-    /// interface name and up state. Selection belongs to HotspotInterfacePolicy; an interface
-    /// name alone never identifies Wi-Fi. A failed read yields an empty sample, which fails closed.
+    /// Every attached interface's kernel index and link type (its AF_LINK row) and every IPv4
+    /// address with its interface name and up state. Selection belongs to HotspotInterfacePolicy;
+    /// an interface name alone never identifies Wi-Fi. A failed read yields an empty sample, which
+    /// fails closed.
     static func interfaceSnapshot() -> HotspotInterfaceSnapshot {
         var interfaces: UnsafeMutablePointer<ifaddrs>?
         guard getifaddrs(&interfaces) == 0 else { return HotspotInterfaceSnapshot(links: [:], addresses: []) }
         defer { freeifaddrs(interfaces) }
         var links: [String: Int] = [:]
+        var ethernetLinks: Set<String> = []
         var rows: [HotspotInterfaceAddress] = []
         var cursor = interfaces
         while let item = cursor {
@@ -392,8 +401,13 @@ public final class GlassesHotspotNetwork {
             guard let address = value.ifa_addr else { continue }
             let name = String(cString: value.ifa_name)
             if address.pointee.sa_family == UInt8(AF_LINK) {
-                let index = address.withMemoryRebound(to: sockaddr_dl.self, capacity: 1) { Int($0.pointee.sdl_index) }
-                if index > 0 { links[name] = index }
+                let (index, type) = address.withMemoryRebound(to: sockaddr_dl.self, capacity: 1) {
+                    (Int($0.pointee.sdl_index), Int32($0.pointee.sdl_type))
+                }
+                if index > 0 {
+                    links[name] = index
+                    if type == IFT_ETHER { ethernetLinks.insert(name) }
+                }
                 continue
             }
             guard address.pointee.sa_family == UInt8(AF_INET) else { continue }
@@ -401,6 +415,6 @@ public final class GlassesHotspotNetwork {
             guard getnameinfo(address, socklen_t(address.pointee.sa_len), &host, socklen_t(host.count), nil, 0, NI_NUMERICHOST) == 0 else { continue }
             rows.append(HotspotInterfaceAddress(name: name, isUp: value.ifa_flags & UInt32(IFF_UP) != 0, ipv4: String(cString: host)))
         }
-        return HotspotInterfaceSnapshot(links: links, addresses: rows)
+        return HotspotInterfaceSnapshot(links: links, addresses: rows, ethernetLinks: ethernetLinks)
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/glasses-media",
-  "version": "3.3.0-dev.820",
+  "version": "3.3.0-dev.821",
   "description": "Shared native glasses media receivers and local network transport",
   "license": "MIT",
   "author": "Mentra Community",