@adeeliore/p2p-lan-signaling 0.1.0

package/plugin/templates/ios/OfflineSignalingHost.swift

@@ -0,0 +1,703 @@
+import CryptoKit
+import Foundation
+import Network
+import React
+
+@objc(OfflineSignalingHost)
+final class OfflineSignalingHost: NSObject {
+  private let manager = IosOfflineSignalingHostManager()
+
+  @objc
+  static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+
+  @objc(startHost:roomId:displayName:roomSecret:resolver:rejecter:)
+  func startHost(
+    _ port: NSNumber,
+    roomId: String?,
+    displayName: String?,
+    roomSecret: String?,
+    resolver resolve: RCTPromiseResolveBlock,
+    rejecter reject: RCTPromiseRejectBlock
+  ) {
+    do {
+      resolve(try manager.start(port: port.intValue, roomId: roomId, displayName: displayName, roomSecret: roomSecret).dictionary)
+    } catch {
+      reject("offline_host_start_failed", error.localizedDescription, error)
+    }
+  }
+
+  @objc(stopHost:rejecter:)
+  func stopHost(_ resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) {
+    manager.stop()
+    resolve(nil)
+  }
+
+  @objc(getStatus:rejecter:)
+  func getStatus(_ resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) {
+    resolve(manager.status.dictionary)
+  }
+
+  @objc(discoverHosts:resolver:rejecter:)
+  func discoverHosts(_ timeoutMs: NSNumber, resolver resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) {
+    resolve(manager.discover(timeoutMs: timeoutMs.intValue).map { $0.dictionary })
+  }
+}
+
+private struct IosOfflineHostStatus {
+  let running: Bool
+  let hostAddress: String?
+  let port: Int?
+  let url: String?
+  let roomId: String?
+  let serviceName: String?
+  let serviceType: String?
+
+  var dictionary: [String: Any?] {
+    [
+      "running": running,
+      "hostAddress": hostAddress,
+      "port": port,
+      "url": url,
+      "roomId": roomId,
+      "serviceName": serviceName,
+      "serviceType": serviceType
+    ]
+  }
+}
+
+private struct IosOfflineDiscoveredHost {
+  let serviceName: String
+  let serviceType: String
+  let hostAddress: String
+  let port: Int
+  let url: String
+  let roomId: String?
+  let displayName: String?
+
+  var dictionary: [String: Any?] {
+    [
+      "serviceName": serviceName,
+      "serviceType": serviceType,
+      "hostAddress": hostAddress,
+      "port": port,
+      "url": url,
+      "roomId": roomId,
+      "displayName": displayName
+    ]
+  }
+}
+
+private enum IosOfflineSecurityPolicy {
+  static let maxParticipants = 10
+  static let maxTextFrameBytes = 65_536
+  static let sessionPattern = "^[A-Za-z0-9_-]{8,64}$"
+  static let clientPattern = "^[A-Za-z0-9_-]{3,64}$"
+
+  static func isValidSessionId(_ value: String) -> Bool {
+    return value.range(of: sessionPattern, options: .regularExpression) != nil
+  }
+
+  static func isValidClientId(_ value: String) -> Bool {
+    return value.range(of: clientPattern, options: .regularExpression) != nil
+  }
+}
+
+private enum IosOfflineSignalingContract {
+  static let moduleName = "OfflineSignalingHost"
+  static let serviceType = "_drawin._tcp"
+  static let bonjourServiceType = "\(serviceType)."
+  static let bonjourDomain = "local."
+  static let websocketPath = "/ws"
+  static let querySessionId = "sessionId"
+  static let queryClientId = "clientId"
+  static let queryAccessToken = "accessToken"
+  static let queryRoomSecret = "roomSecret"
+  static let txtRoomId = "roomId"
+  static let txtDisplayName = "displayName"
+  static let defaultFallbackPort: UInt16 = 8090
+  static let handshakeReadBufferBytes = 4096
+  static let discoveryMinTimeoutMs = 500
+  static let discoveryMaxTimeoutMs = 10_000
+  static let serviceResolveTimeoutSeconds: TimeInterval = 2
+}
+
+private final class IosOfflineSignalingHostManager {
+  private let queue = DispatchQueue(label: "drawin.offline.host.manager")
+  private let discovery = IosLanServiceDiscovery()
+  private var server: IosOfflineSignalingServer?
+
+  var status: IosOfflineHostStatus {
+    queue.sync {
+      server?.status ?? IosOfflineHostStatus(
+        running: false,
+        hostAddress: nil,
+        port: nil,
+        url: nil,
+        roomId: nil,
+        serviceName: nil,
+        serviceType: IosOfflineSignalingContract.serviceType
+      )
+    }
+  }
+
+  func start(port: Int, roomId: String?, displayName: String?, roomSecret: String?) throws -> IosOfflineHostStatus {
+    try queue.sync {
+      if let existing = server, existing.matches(port: port, roomId: roomId, displayName: displayName, roomSecret: roomSecret) {
+        return existing.status
+      }
+      server?.stop()
+      let next = IosOfflineSignalingServer(port: port, roomId: roomId, displayName: displayName, roomSecret: roomSecret, discovery: discovery)
+      server = next
+      return try next.start()
+    }
+  }
+
+  func stop() {
+    queue.sync {
+      server?.stop()
+      server = nil
+    }
+  }
+
+  func discover(timeoutMs: Int) -> [IosOfflineDiscoveredHost] {
+    discovery.discover(timeoutMs: timeoutMs)
+  }
+}
+
+private final class IosOfflineSignalingServer {
+  private let requestedPort: Int
+  private let roomId: String?
+  private let displayName: String?
+  private let roomSecret: String?
+  private let discovery: IosLanServiceDiscovery
+  private let queue = DispatchQueue(label: "drawin.offline.host.server")
+  private let router = IosOfflineSignalingRouter()
+  private var listener: NWListener?
+  private var clients: [ObjectIdentifier: IosOfflineSignalingClient] = [:]
+  private var running = false
+  private var hostAddress: String?
+  private var actualPort: Int?
+
+  init(port: Int, roomId: String?, displayName: String?, roomSecret: String?, discovery: IosLanServiceDiscovery) {
+    self.requestedPort = port
+    self.roomId = roomId
+    self.displayName = displayName
+    self.roomSecret = roomSecret
+    self.discovery = discovery
+  }
+
+  var status: IosOfflineHostStatus {
+    let address = hostAddress
+    let port = actualPort ?? requestedPort
+    return IosOfflineHostStatus(
+      running: running,
+      hostAddress: address,
+      port: running ? port : nil,
+      url: running && address != nil ? "ws://\(address!):\(port)" : nil,
+      roomId: roomId,
+      serviceName: running ? serviceName : nil,
+      serviceType: IosOfflineSignalingContract.serviceType
+    )
+  }
+
+  var serviceName: String {
+    if let displayName, !displayName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+      return displayName
+    }
+    return "Drawin \(roomId?.isEmpty == false ? roomId! : String(requestedPort))"
+  }
+
+  func matches(port: Int, roomId: String?, displayName: String?, roomSecret: String?) -> Bool {
+    requestedPort == port && self.roomId == roomId && self.displayName == displayName && self.roomSecret == roomSecret
+  }
+
+  func start() throws -> IosOfflineHostStatus {
+    guard !running else { return status }
+    let nwPort = NWEndpoint.Port(rawValue: UInt16(requestedPort)) ?? NWEndpoint.Port(rawValue: IosOfflineSignalingContract.defaultFallbackPort)!
+    let listener = try NWListener(using: .tcp, on: nwPort)
+    self.listener = listener
+    self.hostAddress = IosNetworkAddressResolver.resolveIpv4Address()
+    self.actualPort = Int(listener.port?.rawValue ?? nwPort.rawValue)
+
+    listener.newConnectionHandler = { [weak self] connection in
+      self?.queue.async {
+        guard let self, self.running else {
+          connection.cancel()
+          return
+        }
+        let client = IosOfflineSignalingClient(connection: connection, router: self.router, roomSecret: self.roomSecret)
+        self.clients[ObjectIdentifier(client)] = client
+        client.onClose = { [weak self, weak client] in
+          guard let self, let client else { return }
+          self.queue.async {
+            self.router.unregister(client)
+            self.clients.removeValue(forKey: ObjectIdentifier(client))
+          }
+        }
+        client.start()
+      }
+    }
+
+    running = true
+    listener.start(queue: queue)
+    discovery.register(serviceName: serviceName, port: actualPort ?? requestedPort, roomId: roomId, displayName: displayName)
+    return status
+  }
+
+  func stop() {
+    guard running else { return }
+    running = false
+    discovery.unregister()
+    clients.values.forEach { $0.close() }
+    clients.removeAll()
+    listener?.cancel()
+    listener = nil
+  }
+}
+
+private final class IosOfflineSignalingClient {
+  private let connection: NWConnection
+  private let router: IosOfflineSignalingRouter
+  private let roomSecret: String?
+  private let sendQueue = DispatchQueue(label: "drawin.offline.host.client.send")
+  private var handshakeBuffer = Data()
+  private var frameBuffer = Data()
+  private var closed = false
+
+  var sessionId: String?
+  var clientId: String?
+  var onClose: (() -> Void)?
+
+  init(connection: NWConnection, router: IosOfflineSignalingRouter, roomSecret: String?) {
+    self.connection = connection
+    self.router = router
+    self.roomSecret = roomSecret
+  }
+
+  func start() {
+    connection.stateUpdateHandler = { [weak self] state in
+      if case .failed = state { self?.close() }
+      if case .cancelled = state { self?.close() }
+    }
+    connection.start(queue: DispatchQueue(label: "drawin.offline.host.client"))
+    readHandshake()
+  }
+
+  func attach(sessionId: String, clientId: String) {
+    self.sessionId = sessionId
+    self.clientId = clientId
+  }
+
+  func send(_ message: String) {
+    guard !closed else { return }
+    let data = IosWebSocketFrameCodec.encodeText(message)
+    sendQueue.async { [weak self] in
+      self?.connection.send(content: data, completion: .contentProcessed { error in
+        if error != nil { self?.close() }
+      })
+    }
+  }
+
+  func close() {
+    guard !closed else { return }
+    closed = true
+    connection.cancel()
+    onClose?()
+  }
+
+  private func readHandshake() {
+    connection.receive(minimumIncompleteLength: 1, maximumLength: IosOfflineSignalingContract.handshakeReadBufferBytes) { [weak self] data, _, isComplete, error in
+      guard let self else { return }
+      if error != nil || isComplete {
+        self.close()
+        return
+      }
+      if let data { self.handshakeBuffer.append(data) }
+      guard let headerEnd = self.handshakeBuffer.range(of: Data("\r\n\r\n".utf8)) else {
+        self.readHandshake()
+        return
+      }
+      let headerData = self.handshakeBuffer[..<headerEnd.upperBound]
+      let remaining = self.handshakeBuffer[headerEnd.upperBound...]
+      do {
+        let request = try IosWebSocketHandshake.accept(headerData: Data(headerData), connection: self.connection, roomSecret: self.roomSecret)
+        self.router.register(sessionId: request.sessionId, requestedClientId: request.clientId, client: self)
+        if !remaining.isEmpty {
+          self.frameBuffer.append(remaining)
+          self.consumeFrames()
+        }
+        self.readFrames()
+      } catch {
+        self.close()
+      }
+    }
+  }
+
+  private func readFrames() {
+    connection.receive(minimumIncompleteLength: 1, maximumLength: IosOfflineSecurityPolicy.maxTextFrameBytes) { [weak self] data, _, isComplete, error in
+      guard let self else { return }
+      if error != nil || isComplete {
+        self.close()
+        return
+      }
+      if let data {
+        self.frameBuffer.append(data)
+        self.consumeFrames()
+      }
+      self.readFrames()
+    }
+  }
+
+  private func consumeFrames() {
+    while true {
+      switch IosWebSocketFrameCodec.decodeText(from: &frameBuffer) {
+      case .message(let message):
+        router.handleClientMessage(client: self, rawMessage: message)
+      case .closed:
+        close()
+        return
+      case .needMoreData:
+        return
+      }
+    }
+  }
+}
+
+private final class IosOfflineSignalingRouter {
+  private var sessions: [String: [String: IosOfflineSignalingClient]] = [:]
+  private let lock = NSLock()
+
+  func register(sessionId: String, requestedClientId: String?, client: IosOfflineSignalingClient) {
+    lock.lock()
+    defer { lock.unlock() }
+
+    guard IosOfflineSecurityPolicy.isValidSessionId(sessionId) else {
+      client.send(error(code: "invalid_session_id", message: "Invalid session id"))
+      client.close()
+      return
+    }
+    var session = sessions[sessionId] ?? [:]
+    guard session.count < IosOfflineSecurityPolicy.maxParticipants else {
+      client.send(error(code: "session_full", message: "Session is full"))
+      client.close()
+      return
+    }
+    let clientId = resolveClientId(session: session, requestedClientId: requestedClientId)
+    guard IosOfflineSecurityPolicy.isValidClientId(clientId) else {
+      client.send(error(code: "invalid_client_id", message: "Invalid client id"))
+      client.close()
+      return
+    }
+
+    client.attach(sessionId: sessionId, clientId: clientId)
+    let peers = session.keys.map { ["clientId": $0] }
+    session[clientId] = client
+    sessions[sessionId] = session
+    client.send(json(["type": "welcome", "sessionId": sessionId, "clientId": clientId, "peers": peers]))
+    broadcastExcept(sessionId: sessionId, exceptClientId: clientId, message: json(["type": "peer-joined", "sessionId": sessionId, "clientId": clientId]))
+  }
+
+  func unregister(_ client: IosOfflineSignalingClient) {
+    lock.lock()
+    defer { lock.unlock() }
+    guard let sessionId = client.sessionId, let clientId = client.clientId, var session = sessions[sessionId] else { return }
+    session.removeValue(forKey: clientId)
+    if session.isEmpty {
+      sessions.removeValue(forKey: sessionId)
+      return
+    }
+    sessions[sessionId] = session
+    broadcast(sessionId: sessionId, message: json(["type": "peer-left", "sessionId": sessionId, "clientId": clientId]))
+  }
+
+  func handleClientMessage(client: IosOfflineSignalingClient, rawMessage: String) {
+    guard !rawMessage.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+          let data = rawMessage.data(using: .utf8),
+          let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+          let type = object["type"] as? String else {
+      return
+    }
+    switch type {
+    case "ping":
+      client.send(json(["type": "pong"]))
+    case "offer", "answer", "ice":
+      relay(client: client, type: type, object: object)
+    default:
+      client.send(error(code: "unsupported_message", message: "Unsupported signaling message type: \(type)"))
+    }
+  }
+
+  private func relay(client: IosOfflineSignalingClient, type: String, object: [String: Any]) {
+    lock.lock()
+    defer { lock.unlock() }
+    guard let sessionId = client.sessionId, let from = client.clientId, let to = object["to"] as? String else { return }
+    guard IosOfflineSecurityPolicy.isValidClientId(to) else {
+      client.send(error(code: "invalid_to", message: "Invalid relay target"))
+      return
+    }
+    guard let target = sessions[sessionId]?[to] else {
+      client.send(error(code: "peer_not_found", message: "Peer not found: \(to)"))
+      return
+    }
+    var message: [String: Any] = ["type": type, "sessionId": sessionId, "from": from, "to": to]
+    if let payload = object["payload"] { message["payload"] = payload }
+    target.send(json(message))
+  }
+
+  private func broadcast(sessionId: String, message: String) {
+    sessions[sessionId]?.values.forEach { $0.send(message) }
+  }
+
+  private func broadcastExcept(sessionId: String, exceptClientId: String, message: String) {
+    sessions[sessionId]?.filter { $0.key != exceptClientId }.values.forEach { $0.send(message) }
+  }
+
+  private func resolveClientId(session: [String: IosOfflineSignalingClient], requestedClientId: String?) -> String {
+    let base = requestedClientId?.isEmpty == false ? requestedClientId! : "user-\(UUID().uuidString.prefix(4).lowercased())"
+    guard IosOfflineSecurityPolicy.isValidClientId(base) else {
+      return "user-\(UUID().uuidString.prefix(4).lowercased())"
+    }
+    if session[base] == nil { return base }
+    var suffix = 2
+    while session["\(base)-\(suffix)"] != nil { suffix += 1 }
+    return "\(base)-\(suffix)"
+  }
+
+  private func error(code: String, message: String) -> String {
+    json(["type": "error", "code": code, "message": message])
+  }
+
+  private func json(_ object: Any) -> String {
+    let data = (try? JSONSerialization.data(withJSONObject: object)) ?? Data("{}".utf8)
+    return String(data: data, encoding: .utf8) ?? "{}"
+  }
+}
+
+private struct IosWebSocketHandshakeRequest {
+  let sessionId: String
+  let clientId: String?
+}
+
+private enum IosWebSocketHandshake {
+  static let guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+  static func accept(headerData: Data, connection: NWConnection, roomSecret: String?) throws -> IosWebSocketHandshakeRequest {
+    guard let headerText = String(data: headerData, encoding: .utf8) else {
+      throw NSError(domain: "OfflineSignalingHost", code: 1)
+    }
+    let lines = headerText.components(separatedBy: "\r\n")
+    guard let requestLine = lines.first else { throw NSError(domain: "OfflineSignalingHost", code: 2) }
+    let parts = requestLine.split(separator: " ")
+    guard parts.count >= 2 else { throw NSError(domain: "OfflineSignalingHost", code: 3) }
+    let path = String(parts[1])
+    let headers = Dictionary(uniqueKeysWithValues: lines.dropFirst().compactMap { line -> (String, String)? in
+      guard let separator = line.firstIndex(of: ":") else { return nil }
+      return (line[..<separator].lowercased(), line[line.index(after: separator)...].trimmingCharacters(in: .whitespaces))
+    })
+    guard let key = headers["sec-websocket-key"] else { throw NSError(domain: "OfflineSignalingHost", code: 4) }
+    let digest = Insecure.SHA1.hash(data: Data((key + guid).utf8))
+    let acceptKey = Data(digest).base64EncodedString()
+    let response = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: \(acceptKey)\r\n\r\n"
+    connection.send(content: Data(response.utf8), completion: .contentProcessed { _ in })
+
+    guard let components = URLComponents(string: "ws://localhost\(path)"),
+          components.path == IosOfflineSignalingContract.websocketPath else {
+      throw NSError(domain: "OfflineSignalingHost", code: 5)
+    }
+    let query = Dictionary(uniqueKeysWithValues: (components.queryItems ?? []).map { ($0.name, $0.value ?? "") })
+    let sessionId = query[IosOfflineSignalingContract.querySessionId]?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+    guard IosOfflineSecurityPolicy.isValidSessionId(sessionId) else {
+      throw NSError(domain: "OfflineSignalingHost", code: 6)
+    }
+    let clientId = query[IosOfflineSignalingContract.queryClientId]?.trimmingCharacters(in: .whitespacesAndNewlines)
+    if let clientId, !clientId.isEmpty, !IosOfflineSecurityPolicy.isValidClientId(clientId) {
+      throw NSError(domain: "OfflineSignalingHost", code: 7)
+    }
+    if let roomSecret, !roomSecret.isEmpty {
+      let providedSecret = query[IosOfflineSignalingContract.queryAccessToken] ?? query[IosOfflineSignalingContract.queryRoomSecret]
+      guard providedSecret == roomSecret else { throw NSError(domain: "OfflineSignalingHost", code: 8) }
+    }
+    return IosWebSocketHandshakeRequest(sessionId: sessionId, clientId: clientId?.isEmpty == false ? clientId : nil)
+  }
+}
+
+private enum IosWebSocketDecodeResult {
+  case message(String)
+  case closed
+  case needMoreData
+}
+
+private enum IosWebSocketFrameCodec {
+  static func decodeText(from buffer: inout Data) -> IosWebSocketDecodeResult {
+    guard buffer.count >= 2 else { return .needMoreData }
+    let first = buffer[buffer.startIndex]
+    let second = buffer[buffer.index(after: buffer.startIndex)]
+    let opcode = first & 0x0F
+    let masked = (second & 0x80) != 0
+    var offset = 2
+    var length = Int(second & 0x7F)
+    if length == 126 {
+      guard buffer.count >= offset + 2 else { return .needMoreData }
+      length = (Int(buffer[offset]) << 8) | Int(buffer[offset + 1])
+      offset += 2
+    } else if length == 127 {
+      guard buffer.count >= offset + 8 else { return .needMoreData }
+      var longLength = 0
+      for _ in 0..<8 {
+        longLength = (longLength << 8) | Int(buffer[offset])
+        offset += 1
+      }
+      length = longLength
+    }
+    guard length <= IosOfflineSecurityPolicy.maxTextFrameBytes else { return .closed }
+    let maskLength = masked ? 4 : 0
+    guard buffer.count >= offset + maskLength + length else { return .needMoreData }
+    var mask: [UInt8] = []
+    if masked {
+      mask = Array(buffer[offset..<offset + 4])
+      offset += 4
+    }
+    var payload = Array(buffer[offset..<offset + length])
+    if masked {
+      for index in payload.indices {
+        payload[index] = payload[index] ^ mask[index % 4]
+      }
+    }
+    buffer.removeSubrange(buffer.startIndex..<buffer.index(buffer.startIndex, offsetBy: offset + length))
+    if opcode == 0x8 { return .closed }
+    if opcode != 0x1 { return .message("") }
+    return .message(String(bytes: payload, encoding: .utf8) ?? "")
+  }
+
+  static func encodeText(_ message: String) -> Data {
+    let payload = Array(message.utf8)
+    var data = Data([0x81])
+    if payload.count < 126 {
+      data.append(UInt8(payload.count))
+    } else if payload.count <= 65_535 {
+      data.append(126)
+      data.append(UInt8((payload.count >> 8) & 0xFF))
+      data.append(UInt8(payload.count & 0xFF))
+    } else {
+      data.append(127)
+      let count = UInt64(payload.count)
+      for shift in stride(from: 56, through: 0, by: -8) {
+        data.append(UInt8((count >> UInt64(shift)) & 0xFF))
+      }
+    }
+    data.append(contentsOf: payload)
+    return data
+  }
+}
+
+private final class IosLanServiceDiscovery: NSObject, NetServiceBrowserDelegate, NetServiceDelegate {
+  private var service: NetService?
+  private var browser: NetServiceBrowser?
+  private var pendingResolve: [NetService] = []
+  private var results: [IosOfflineDiscoveredHost] = []
+  private var semaphore: DispatchSemaphore?
+  private let lock = NSLock()
+
+  func register(serviceName: String, port: Int, roomId: String?, displayName: String?) {
+    unregister()
+    let next = NetService(domain: IosOfflineSignalingContract.bonjourDomain, type: IosOfflineSignalingContract.bonjourServiceType, name: serviceName, port: Int32(port))
+    var txt: [String: Data] = [:]
+    if let roomId, !roomId.isEmpty { txt[IosOfflineSignalingContract.txtRoomId] = Data(roomId.utf8) }
+    if let displayName, !displayName.isEmpty { txt[IosOfflineSignalingContract.txtDisplayName] = Data(displayName.utf8) }
+    next.setTXTRecord(NetService.data(fromTXTRecord: txt))
+    next.delegate = self
+    next.publish(options: [])
+    service = next
+  }
+
+  func unregister() {
+    service?.stop()
+    service = nil
+  }
+
+  func discover(timeoutMs: Int) -> [IosOfflineDiscoveredHost] {
+    let sem = DispatchSemaphore(value: 0)
+    DispatchQueue.main.async {
+      self.lock.lock()
+      self.results = []
+      self.pendingResolve = []
+      self.lock.unlock()
+      let browser = NetServiceBrowser()
+      self.browser = browser
+      browser.delegate = self
+      self.semaphore = sem
+      browser.searchForServices(ofType: IosOfflineSignalingContract.bonjourServiceType, inDomain: IosOfflineSignalingContract.bonjourDomain)
+    }
+    _ = sem.wait(timeout: .now() + .milliseconds(max(IosOfflineSignalingContract.discoveryMinTimeoutMs, min(timeoutMs, IosOfflineSignalingContract.discoveryMaxTimeoutMs))))
+    DispatchQueue.main.async {
+      self.browser?.stop()
+      self.browser = nil
+      self.semaphore = nil
+    }
+    lock.lock()
+    let snapshot = results
+    lock.unlock()
+    return Array(Dictionary(grouping: snapshot, by: { "\($0.url):\($0.roomId ?? "")" }).compactMap { $0.value.first })
+  }
+
+  func netServiceBrowser(_ browser: NetServiceBrowser, didFind service: NetService, moreComing: Bool) {
+    service.delegate = self
+    pendingResolve.append(service)
+    service.resolve(withTimeout: IosOfflineSignalingContract.serviceResolveTimeoutSeconds)
+  }
+
+  func netServiceDidResolveAddress(_ sender: NetService) {
+    let host = sender.hostName?.trimmingCharacters(in: CharacterSet(charactersIn: ".")) ?? sender.hostName ?? ""
+    guard sender.port > 0, !host.isEmpty else { return }
+    let txt = NetService.dictionary(fromTXTRecord: sender.txtRecordData() ?? Data())
+    let roomId = txt[IosOfflineSignalingContract.txtRoomId].flatMap { String(data: $0, encoding: .utf8) } ?? parseRoomId(sender.name)
+    let displayName = txt[IosOfflineSignalingContract.txtDisplayName].flatMap { String(data: $0, encoding: .utf8) }
+    lock.lock()
+    results.append(IosOfflineDiscoveredHost(
+      serviceName: sender.name,
+      serviceType: sender.type,
+      hostAddress: host,
+      port: sender.port,
+      url: "ws://\(host):\(sender.port)",
+      roomId: roomId,
+      displayName: displayName
+    ))
+    lock.unlock()
+  }
+
+  func netServiceBrowserDidStopSearch(_ browser: NetServiceBrowser) {
+    semaphore?.signal()
+  }
+
+  private func parseRoomId(_ serviceName: String) -> String? {
+    serviceName.range(of: "ROOM-[A-Z0-9]+", options: .regularExpression).map { String(serviceName[$0]) }
+  }
+}
+
+private enum IosNetworkAddressResolver {
+  static func resolveIpv4Address() -> String? {
+    var addresses: [String] = []
+    var interfaces: UnsafeMutablePointer<ifaddrs>?
+    guard getifaddrs(&interfaces) == 0, let first = interfaces else { return nil }
+    defer { freeifaddrs(interfaces) }
+    var cursor: UnsafeMutablePointer<ifaddrs>? = first
+    while cursor != nil {
+      defer { cursor = cursor?.pointee.ifa_next }
+      guard let interface = cursor?.pointee,
+            let address = interface.ifa_addr,
+            address.pointee.sa_family == UInt8(AF_INET) else {
+        continue
+      }
+      let name = String(cString: interface.ifa_name)
+      guard name == "en0" || name.hasPrefix("en") else { continue }
+      var addr = address.pointee
+      var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+      getnameinfo(&addr, socklen_t(address.pointee.sa_len), &hostname, socklen_t(hostname.count), nil, 0, NI_NUMERICHOST)
+      let value = String(cString: hostname)
+      if !value.isEmpty && value != "127.0.0.1" { addresses.append(value) }
+    }
+    return addresses.first { $0.hasPrefix("192.168.") || $0.hasPrefix("10.") || $0.hasPrefix("172.") } ?? addresses.first
+  }
+}