react-native-queue-player 1.2.0 → 2.0.1

package/ios/Cast/Core/MediaHTTPConnection.swift

@@ -1,349 +0,0 @@
-import Foundation
-import Network
-
-/// Resolution of an HTTP `Range` header against a known file size.
-enum MediaByteRange: Equatable {
-  /// No Range header, or one the server ignores (malformed / invalid
-  /// bounds) — serve the whole file with `200`.
-  case full
-  /// A satisfiable single range with inclusive bounds — serve `206`.
-  case partial(start: Int64, end: Int64)
-  /// A syntactically-valid range that starts past EOF — serve `416`.
-  case unsatisfiable
-}
-
-/// Parsed view of an incoming request: the method, the request target,
-/// and the one header the file server acts on (`Range`). Built from the
-/// raw header block (everything before the `\r\n\r\n` terminator).
-struct MediaHTTPRequest: Equatable {
-  let method: String
-  let path: String
-  let rangeHeader: String?
-
-  /// The `<token>` from a `/media/<32-hex>` path, or `nil` when the path
-  /// is anything else. The token is both the routing key (which file) and
-  /// the access secret (high-entropy, unenumerable) for the LAN-reachable
-  /// server.
-  var mediaToken: String? {
-    let prefix = "/media/"
-    guard path.hasPrefix(prefix) else { return nil }
-    let token = String(path.dropFirst(prefix.count))
-    guard token.count == 32,
-          token.allSatisfy({ ($0 >= "0" && $0 <= "9") || ($0 >= "a" && $0 <= "f") })
-    else { return nil }
-    return token
-  }
-
-  init?(headerData: Data) {
-    guard let text = String(data: headerData, encoding: .utf8) else { return nil }
-    var lines = text.components(separatedBy: "\r\n")
-    guard !lines.isEmpty else { return nil }
-    let requestLine = lines.removeFirst().split(separator: " ")
-    guard requestLine.count >= 2 else { return nil }
-    self.method = String(requestLine[0]).uppercased()
-    // Strip any query string — the file path never carries one, and the
-    // token match below expects the bare path.
-    let target = String(requestLine[1])
-    self.path = target.split(separator: "?", maxSplits: 1).first.map(String.init) ?? target
-
-    var range: String?
-    for line in lines where !line.isEmpty {
-      guard let colon = line.firstIndex(of: ":") else { continue }
-      let name = line[line.startIndex..<colon].trimmingCharacters(in: .whitespaces).lowercased()
-      if name == "range" {
-        range = String(line[line.index(after: colon)...]).trimmingCharacters(in: .whitespaces)
-      }
-    }
-    self.rangeHeader = range
-  }
-}
-
-/// Serves one local file over a single `NWConnection` as HTTP/1.1:
-/// `GET`/`HEAD` on `/media/<token>` with `Range` support (the Cast
-/// receiver byte-range probes + seeks). One responder per accepted
-/// connection; it owns the connection, runs all I/O on a dedicated serial
-/// queue, streams the body in bounded chunks (no whole-file buffering),
-/// and reports completion via `onFinished` so the owner can drop it.
-final class MediaHTTPConnection {
-
-  private let connection: NWConnection
-  private let registry: MediaTokenRegistry
-  private let onFinished: () -> Void
-  private let queue: DispatchQueue
-  /// In-flight body-streaming task, cancelled when the client hangs up so
-  /// we stop reading a range the receiver has abandoned.
-  private var streamTask: Task<Void, Never>?
-  private let stateLock = NSLock()
-  private var finished = false
-
-  /// Bound on the accumulated request header so a stalled/malicious client
-  /// can't grow the buffer without limit.
-  private static let maxHeaderBytes = 64 * 1024
-  /// Body streaming chunk — keeps memory flat for large offline files.
-  private static let chunkBytes = 256 * 1024
-  private static let headerTerminator = Data("\r\n\r\n".utf8)
-
-  init(
-    connection: NWConnection,
-    registry: MediaTokenRegistry,
-    onFinished: @escaping () -> Void
-  ) {
-    self.connection = connection
-    self.registry = registry
-    self.onFinished = onFinished
-    self.queue = DispatchQueue(label: "queueplayer.cast.mediaserver.conn")
-  }
-
-  func start() {
-    connection.stateUpdateHandler = { [weak self] state in
-      guard let self = self else { return }
-      switch state {
-      case .ready:
-        self.readRequest(buffer: Data())
-      case .failed(let error):
-        // A receiver cancelling a range connection it no longer needs
-        // arrives here as a reset — expected churn, not an error.
-        if !Self.isBenignDisconnect(error) {
-          NSLog("[LocalMediaServer] connection failed: \(error)")
-        }
-        self.cancel()
-      case .cancelled:
-        self.finish()
-      default:
-        break
-      }
-    }
-    connection.start(queue: queue)
-  }
-
-  /// Cancel the connection + any in-flight streaming. Idempotent.
-  func cancel() {
-    stateLock.lock()
-    let task = streamTask
-    streamTask = nil
-    stateLock.unlock()
-    task?.cancel()
-    connection.cancel()
-  }
-
-  // MARK: - Request
-
-  private func readRequest(buffer: Data) {
-    connection.receive(minimumIncompleteLength: 1, maximumLength: 16 * 1024) {
-      [weak self] data, _, isComplete, error in
-      guard let self = self else { return }
-      if error != nil {
-        self.cancel()
-        return
-      }
-      var buf = buffer
-      if let data = data { buf.append(data) }
-      // Bound the header accumulation right after the append so a client
-      // that never sends `\r\n\r\n` can't grow the buffer past the cap.
-      if buf.count > Self.maxHeaderBytes {
-        self.respondError(status: 431, reason: "Request Header Fields Too Large")
-        return
-      }
-      guard let terminator = Self.firstRange(of: Self.headerTerminator, in: buf) else {
-        if isComplete {
-          self.cancel()
-        } else {
-          self.readRequest(buffer: buf)
-        }
-        return
-      }
-      let headerData = buf.subdata(in: buf.startIndex..<terminator.lowerBound)
-      guard let request = MediaHTTPRequest(headerData: headerData) else {
-        self.respondError(status: 400, reason: "Bad Request")
-        return
-      }
-      self.serve(request)
-    }
-  }
-
-  private func serve(_ request: MediaHTTPRequest) {
-    guard request.method == "GET" || request.method == "HEAD" else {
-      respondError(status: 405, reason: "Method Not Allowed")
-      return
-    }
-    guard let token = request.mediaToken, let media = registry.resolve(token) else {
-      respondError(status: 404, reason: "Not Found")
-      return
-    }
-    let fm = FileManager.default
-    var isDir: ObjCBool = false
-    guard fm.fileExists(atPath: media.fileURL.path, isDirectory: &isDir), !isDir.boolValue,
-          let attrs = try? fm.attributesOfItem(atPath: media.fileURL.path),
-          let size = (attrs[.size] as? NSNumber)?.int64Value
-    else {
-      respondError(status: 404, reason: "Not Found")
-      return
-    }
-
-    let isHead = request.method == "HEAD"
-    switch Self.resolveRange(request.rangeHeader, fileSize: size) {
-    case .full:
-      let head = Self.headFull(contentType: media.contentType, fileSize: size)
-      sendBodyAfterHead(head, fileURL: media.fileURL, start: 0, end: max(0, size - 1), include: size > 0 && !isHead)
-    case .partial(let start, let end):
-      let head = Self.headPartial(contentType: media.contentType, start: start, end: end, fileSize: size)
-      sendBodyAfterHead(head, fileURL: media.fileURL, start: start, end: end, include: !isHead)
-    case .unsatisfiable:
-      sendHeadOnly(Self.headUnsatisfiable(fileSize: size))
-    }
-  }
-
-  // MARK: - Response
-
-  private func sendHeadOnly(_ head: String) {
-    connection.send(content: Data(head.utf8), completion: .contentProcessed { [weak self] _ in
-      self?.cancel()
-    })
-  }
-
-  /// Send the header block, then (when `include`) stream the inclusive
-  /// `[start, end]` byte range from `fileURL` in bounded chunks. A `HEAD`
-  /// or an empty body sends the head and closes.
-  private func sendBodyAfterHead(_ head: String, fileURL: URL, start: Int64, end: Int64, include: Bool) {
-    let task = Task { [weak self] in
-      guard let self = self else { return }
-      do {
-        try await self.send(Data(head.utf8))
-        if include {
-          try await self.streamFile(fileURL, start: start, end: end)
-        }
-        self.cancel()
-      } catch {
-        // A client disconnect mid-stream surfaces as a send/read failure —
-        // normal churn for cancelled range requests, just clean up.
-        self.cancel()
-      }
-    }
-    stateLock.lock()
-    streamTask = task
-    stateLock.unlock()
-  }
-
-  private func streamFile(_ fileURL: URL, start: Int64, end: Int64) async throws {
-    let handle = try FileHandle(forReadingFrom: fileURL)
-    defer { try? handle.close() }
-    try handle.seek(toOffset: UInt64(start))
-    var remaining = end - start + 1
-    while remaining > 0 {
-      if Task.isCancelled { return }
-      let want = Int(min(Int64(Self.chunkBytes), remaining))
-      guard let chunk = try handle.read(upToCount: want), !chunk.isEmpty else { return }
-      try await send(chunk)
-      remaining -= Int64(chunk.count)
-    }
-  }
-
-  private func send(_ data: Data) async throws {
-    try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
-      connection.send(content: data, completion: .contentProcessed { error in
-        if let error = error { cont.resume(throwing: error) } else { cont.resume(returning: ()) }
-      })
-    }
-  }
-
-  private func respondError(status: Int, reason: String) {
-    sendHeadOnly(Self.headError(status: status, reason: reason))
-  }
-
-  private func finish() {
-    stateLock.lock()
-    if finished { stateLock.unlock(); return }
-    finished = true
-    let task = streamTask
-    streamTask = nil
-    stateLock.unlock()
-    task?.cancel()
-    onFinished()
-  }
-
-  // MARK: - Range resolution (pure)
-
-  /// Resolve an HTTP `Range` header against `fileSize`. Single-range only
-  /// (the Cast receiver never sends multi-range); a multi-range header
-  /// resolves to its first range. Per RFC 7233 a malformed / inverted
-  /// range is ignored (`.full`, i.e. `200`); a syntactically-valid range
-  /// starting at or past EOF is `.unsatisfiable` (`416`).
-  static func resolveRange(_ header: String?, fileSize: Int64) -> MediaByteRange {
-    guard fileSize > 0 else { return .full }
-    guard let raw = header?.lowercased(), raw.hasPrefix("bytes=") else { return .full }
-    let spec = raw.dropFirst("bytes=".count)
-    let firstSpec = spec.split(separator: ",").first.map(String.init) ?? ""
-    guard let dash = firstSpec.firstIndex(of: "-") else { return .full }
-    let startStr = firstSpec[firstSpec.startIndex..<dash].trimmingCharacters(in: .whitespaces)
-    let endStr = firstSpec[firstSpec.index(after: dash)...].trimmingCharacters(in: .whitespaces)
-
-    if startStr.isEmpty {
-      // Suffix form `-N`: the last N bytes.
-      guard let suffix = Int64(endStr), suffix > 0 else { return .unsatisfiable }
-      let start = max(0, fileSize - suffix)
-      return .partial(start: start, end: fileSize - 1)
-    }
-    guard let start = Int64(startStr), start >= 0 else { return .full }
-    if start >= fileSize { return .unsatisfiable }
-    if endStr.isEmpty {
-      return .partial(start: start, end: fileSize - 1)
-    }
-    guard let end = Int64(endStr) else { return .full }
-    if end < start { return .full }
-    return .partial(start: start, end: min(end, fileSize - 1))
-  }
-
-  // MARK: - Header builders (pure)
-
-  static func headFull(contentType: String, fileSize: Int64) -> String {
-    "HTTP/1.1 200 OK\r\n"
-      + "Content-Type: \(contentType)\r\n"
-      + "Content-Length: \(fileSize)\r\n"
-      + "Accept-Ranges: bytes\r\n"
-      + "Connection: close\r\n\r\n"
-  }
-
-  static func headPartial(contentType: String, start: Int64, end: Int64, fileSize: Int64) -> String {
-    "HTTP/1.1 206 Partial Content\r\n"
-      + "Content-Type: \(contentType)\r\n"
-      + "Content-Range: bytes \(start)-\(end)/\(fileSize)\r\n"
-      + "Content-Length: \(end - start + 1)\r\n"
-      + "Accept-Ranges: bytes\r\n"
-      + "Connection: close\r\n\r\n"
-  }
-
-  static func headUnsatisfiable(fileSize: Int64) -> String {
-    "HTTP/1.1 416 Range Not Satisfiable\r\n"
-      + "Content-Range: bytes */\(fileSize)\r\n"
-      + "Content-Length: 0\r\n"
-      + "Connection: close\r\n\r\n"
-  }
-
-  static func headError(status: Int, reason: String) -> String {
-    "HTTP/1.1 \(status) \(reason)\r\n"
-      + "Content-Length: 0\r\n"
-      + "Connection: close\r\n\r\n"
-  }
-
-  // MARK: - Helpers
-
-  static func firstRange(of needle: Data, in haystack: Data) -> Range<Int>? {
-    guard needle.count <= haystack.count, !needle.isEmpty else { return nil }
-    let upper = haystack.count - needle.count
-    var i = haystack.startIndex
-    while i <= upper {
-      if haystack[i..<(i + needle.count)].elementsEqual(needle) {
-        return i..<(i + needle.count)
-      }
-      i += 1
-    }
-    return nil
-  }
-
-  private static func isBenignDisconnect(_ error: NWError) -> Bool {
-    if case .posix(let code) = error {
-      return code == .ECONNRESET || code == .ENOTCONN || code == .EPIPE || code == .ECANCELED
-    }
-    return false
-  }
-}