@annadata/capacitor-mqtt-quic 0.1.0

package/ios/Sources/MqttQuicPlugin/QUIC/NGTCP2Client.swift

@@ -0,0 +1,262 @@
+//
+// NGTCP2Client.swift
+// MqttQuicPlugin
+//
+// ngtcp2-based QUIC client implementation.
+// Replaces QuicClientStub when ngtcp2 is built and linked.
+//
+// Build Requirements:
+// - ngtcp2 static library (libngtcp2.a)
+// - nghttp3 static library (libnghttp3.a)
+// - OpenSSL 3.0+ or BoringSSL for TLS 1.3
+// - iOS 15.0+ (for Network framework)
+//
+
+import Foundation
+
+/// ngtcp2-based QUIC client implementation
+public final class NGTCP2Client: QuicClientProtocol {
+    
+    // MARK: - Properties
+    
+    /// Native ngtcp2 client handle
+    fileprivate var clientHandle: UnsafeMutableRawPointer?
+    
+    /// Connection state
+    private var isConnected: Bool = false
+    
+    /// Host and port for connection
+    private var host: String?
+    private var port: UInt16?
+    
+    /// Active streams
+    private var streams: [UInt64: NGTCP2Stream] = [:]
+    private let streamLock = NSLock()
+    
+    // MARK: - Initialization
+    
+    public init() {
+        clientHandle = ngtcp2_client_create()
+    }
+    
+    deinit {
+        // Cleanup
+        Task {
+            try? await close()
+        }
+    }
+    
+    // MARK: - QuicClientProtocol Implementation
+    
+    public func connect(host: String, port: UInt16) async throws {
+        guard !isConnected else {
+            throw NGTCP2Error.alreadyConnected
+        }
+
+        self.host = host
+        self.port = port
+
+        guard let handle = clientHandle else {
+            throw NGTCP2Error.quicError("native handle not initialized")
+        }
+
+        let alpn = "mqtt"
+        let rv = host.withCString { hostPtr in
+            alpn.withCString { alpnPtr in
+                ngtcp2_client_connect(handle, hostPtr, port, alpnPtr)
+            }
+        }
+        if rv != 0 {
+            throw NGTCP2Error.quicError(lastErrorMessage())
+        }
+
+        isConnected = true
+    }
+    
+    public func openStream() async throws -> QuicStreamProtocol {
+        guard isConnected else {
+            throw NGTCP2Error.notConnected
+        }
+        
+        streamLock.lock()
+        defer { streamLock.unlock() }
+        
+        guard let handle = clientHandle else {
+            throw NGTCP2Error.clientDisconnected
+        }
+
+        let streamId = ngtcp2_client_open_stream(handle)
+        if streamId < 0 {
+            throw NGTCP2Error.quicError(lastErrorMessage())
+        }
+
+        let stream = NGTCP2Stream(streamId: UInt64(streamId), client: self)
+        streams[UInt64(streamId)] = stream
+        
+        return stream
+    }
+    
+    public func close() async throws {
+        if !isConnected {
+            if let handle = clientHandle {
+                _ = ngtcp2_client_close(handle)
+                ngtcp2_client_destroy(handle)
+                clientHandle = nil
+            }
+            return
+        }
+
+        // Close all streams
+        streamLock.lock()
+        let activeStreams = Array(streams.values)
+        streams.removeAll()
+        streamLock.unlock()
+        
+        for stream in activeStreams {
+            try? await stream.close()
+        }
+
+        if let handle = clientHandle {
+            _ = ngtcp2_client_close(handle)
+            ngtcp2_client_destroy(handle)
+            clientHandle = nil
+        }
+        
+        isConnected = false
+    }
+    
+    // MARK: - Internal Methods (for NGTCP2Stream)
+    
+    /// Send data on a stream (called by NGTCP2Stream)
+    internal func sendStreamData(streamId: UInt64, data: Data) async throws {
+        guard isConnected else {
+            throw NGTCP2Error.notConnected
+        }
+
+        guard let handle = clientHandle else {
+            throw NGTCP2Error.clientDisconnected
+        }
+
+        let result = data.withUnsafeBytes { buffer in
+            ngtcp2_client_write_stream(handle,
+                                       Int64(streamId),
+                                       buffer.bindMemory(to: UInt8.self).baseAddress,
+                                       data.count,
+                                       0)
+        }
+        if result != 0 {
+            throw NGTCP2Error.quicError(lastErrorMessage())
+        }
+    }
+    
+    /// Receive data from a stream (called by packet receive handler)
+    internal func receiveStreamData(streamId: UInt64, data: Data) {
+        // Native layer delivers stream data directly; no-op here.
+        _ = data
+    }
+    
+    private func lastErrorMessage() -> String {
+        guard let handle = clientHandle, let cStr = ngtcp2_client_last_error(handle) else {
+            return "unknown QUIC error"
+        }
+        return String(cString: cStr)
+    }
+}
+
+// MARK: - NGTCP2Stream Implementation
+
+/// ngtcp2-based QUIC stream
+internal final class NGTCP2Stream: QuicStreamProtocol {
+    let streamId: UInt64
+    private weak var client: NGTCP2Client?
+    private var isClosed: Bool = false
+    
+    init(streamId: UInt64, client: NGTCP2Client) {
+        self.streamId = streamId
+        self.client = client
+    }
+    
+    func read(maxBytes: Int) async throws -> Data {
+        guard !isClosed else {
+            throw NGTCP2Error.streamClosed
+        }
+        guard let client = client else {
+            throw NGTCP2Error.clientDisconnected
+        }
+        guard let handle = client.clientHandle else {
+            throw NGTCP2Error.clientDisconnected
+        }
+
+        while !isClosed {
+            var buffer = [UInt8](repeating: 0, count: maxBytes)
+            let nread = buffer.withUnsafeMutableBytes { rawBuffer -> Int in
+                let ptr = rawBuffer.bindMemory(to: UInt8.self).baseAddress
+                return ngtcp2_client_read_stream(handle, Int64(streamId), ptr, maxBytes)
+            }
+            if nread < 0 {
+                throw NGTCP2Error.quicError(client.lastErrorMessage())
+            }
+            if nread > 0 {
+                return Data(buffer.prefix(Int(nread)))
+            }
+            try await Task.sleep(nanoseconds: 5_000_000) // 5ms backoff
+        }
+        return Data()
+    }
+    
+    func write(_ data: Data) async throws {
+        guard !isClosed else {
+            throw NGTCP2Error.streamClosed
+        }
+        
+        guard let client = client else {
+            throw NGTCP2Error.clientDisconnected
+        }
+        
+        try await client.sendStreamData(streamId: streamId, data: data)
+    }
+    
+    func close() async throws {
+        isClosed = true
+
+        if let client = client, let handle = client.clientHandle {
+            _ = ngtcp2_client_close_stream(handle, Int64(streamId))
+        }
+    }
+    
+    /// Called by client when data is received for this stream
+    func receiveData(_ data: Data) {
+        _ = data
+    }
+}
+
+// MARK: - Error Types
+
+public enum NGTCP2Error: Error, LocalizedError {
+    case notConnected
+    case alreadyConnected
+    case connectionCancelled
+    case streamClosed
+    case clientDisconnected
+    case tlsError(String)
+    case quicError(String)
+    
+    public var errorDescription: String? {
+        switch self {
+        case .notConnected:
+            return "QUIC client is not connected"
+        case .alreadyConnected:
+            return "QUIC client is already connected"
+        case .connectionCancelled:
+            return "QUIC connection was cancelled"
+        case .streamClosed:
+            return "QUIC stream is closed"
+        case .clientDisconnected:
+            return "QUIC client is disconnected"
+        case .tlsError(let message):
+            return "TLS error: \(message)"
+        case .quicError(let message):
+            return "QUIC error: \(message)"
+        }
+    }
+}

package/ios/Sources/MqttQuicPlugin/QUIC/QuicClientStub.swift

@@ -0,0 +1,66 @@
+//
+// QuicClientStub.swift
+// MqttQuicPlugin
+//
+// Stub QUIC client for Phase 2. Replace with ngtcp2-backed implementation when
+// ngtcp2 is built for iOS (see README). Uses in-memory stream for testing.
+//
+
+import Foundation
+
+/// Stub stream: buffers read/write in memory. Used when ngtcp2 is not linked.
+public final class QuicStreamStub: QuicStreamProtocol {
+    public let streamId: UInt64
+    private let buffer: MockStreamBuffer
+
+    public init(streamId: UInt64, buffer: MockStreamBuffer) {
+        self.streamId = streamId
+        self.buffer = buffer
+    }
+
+    public func read(maxBytes: Int) async throws -> Data {
+        let reader = MockStreamReader(buffer: buffer)
+        return try await reader.read(maxBytes: maxBytes)
+    }
+
+    public func write(_ data: Data) async throws {
+        let writer = MockStreamWriter(buffer: buffer)
+        try await writer.write(data)
+    }
+
+    public func close() async throws {
+        buffer.isClosed = true
+    }
+}
+
+/// Stub QUIC client. connect() succeeds without network; openStream() returns a stub stream.
+/// Phase 2 proper: use ngtcp2_conn_client_new, TLS 1.3, NWConnection for UDP.
+/// Pass initialReadData (e.g. CONNACK) to simulate server response for testing.
+public final class QuicClientStub: QuicClientProtocol {
+    private var streamId: UInt64 = 0
+    private var buffer: MockStreamBuffer?
+    private var _stream: QuicStreamStub?
+    private let initialReadData: Data
+
+    public init(initialReadData: Data = Data()) {
+        self.initialReadData = initialReadData
+    }
+
+    public func connect(host: String, port: UInt16) async throws {
+        buffer = MockStreamBuffer(initialReadData: initialReadData)
+        streamId = 0
+    }
+
+    public func openStream() async throws -> QuicStreamProtocol {
+        guard let buf = buffer else { throw NSError(domain: "QuicClientStub", code: -1, userInfo: [NSLocalizedDescriptionKey: "Not connected"]) }
+        let s = QuicStreamStub(streamId: streamId, buffer: buf)
+        streamId += 1
+        _stream = s
+        return s
+    }
+
+    public func close() async throws {
+        _stream = nil
+        buffer = nil
+    }
+}

package/ios/Sources/MqttQuicPlugin/QUIC/QuicTypes.swift

@@ -0,0 +1,23 @@
+//
+// QuicTypes.swift
+// MqttQuicPlugin
+//
+// QUIC transport types. Phase 2: ngtcp2 client + single bidirectional stream.
+//
+
+import Foundation
+
+/// Represents a single QUIC bidirectional stream (one per MQTT connection).
+public protocol QuicStreamProtocol: AnyObject {
+    var streamId: UInt64 { get }
+    func read(maxBytes: Int) async throws -> Data
+    func write(_ data: Data) async throws
+    func close() async throws
+}
+
+/// QUIC client: connect, TLS handshake, open one bidirectional stream.
+public protocol QuicClientProtocol: AnyObject {
+    func connect(host: String, port: UInt16) async throws
+    func openStream() async throws -> QuicStreamProtocol
+    func close() async throws
+}

package/ios/Sources/MqttQuicPlugin/Resources/mqttquic_ca.pem

@@ -0,0 +1,5 @@
+# Replace this file with your CA certificate bundle (PEM).
+# Example:
+# -----BEGIN CERTIFICATE-----
+# ...
+# -----END CERTIFICATE-----

package/ios/Sources/MqttQuicPlugin/Transport/QUICStreamAdapter.swift

@@ -0,0 +1,50 @@
+//
+// QUICStreamAdapter.swift
+// MqttQuicPlugin
+//
+// StreamReader/StreamWriter over QUIC stream. Mirrors NGTCP2StreamReader/NGTCP2StreamWriter.
+//
+
+import Foundation
+
+/// MQTTStreamReader over a QuicStream.
+public final class QUICStreamReader: MQTTStreamReaderProtocol {
+    private let stream: QuicStreamProtocol
+
+    public init(stream: QuicStreamProtocol) {
+        self.stream = stream
+    }
+
+    public func read(maxBytes: Int) async throws -> Data {
+        try await stream.read(maxBytes: maxBytes)
+    }
+
+    public func readexactly(_ n: Int) async throws -> Data {
+        var acc = Data()
+        while acc.count < n {
+            let chunk = try await stream.read(maxBytes: n - acc.count)
+            if chunk.isEmpty { throw MQTTProtocolError.insufficientData("readexactly") }
+            acc.append(chunk)
+        }
+        return acc
+    }
+}
+
+/// MQTTStreamWriter over a QuicStream.
+public final class QUICStreamWriter: MQTTStreamWriterProtocol {
+    private let stream: QuicStreamProtocol
+
+    public init(stream: QuicStreamProtocol) {
+        self.stream = stream
+    }
+
+    public func write(_ data: Data) async throws {
+        try await stream.write(data)
+    }
+
+    public func drain() async throws {}
+
+    public func close() async throws {
+        try await stream.close()
+    }
+}

package/ios/Sources/MqttQuicPlugin/Transport/StreamTransport.swift

@@ -0,0 +1,105 @@
+//
+// StreamTransport.swift
+// MqttQuicPlugin
+//
+// Transport abstraction: StreamReader-like and StreamWriter-like.
+// Phase 2 will implement these over QUIC streams; Phase 1 uses mocks for tests.
+//
+
+import Foundation
+
+/// StreamReader-like interface: read(n), readexactly(n).
+/// Async where applicable (Phase 2 uses async).
+public protocol MQTTStreamReaderProtocol: AnyObject {
+    func read(maxBytes: Int) async throws -> Data
+    func readexactly(_ n: Int) async throws -> Data
+}
+
+/// StreamWriter-like interface: write(data), drain(), close().
+public protocol MQTTStreamWriterProtocol: AnyObject {
+    func write(_ data: Data) async throws
+    func drain() async throws
+    func close() async throws
+}
+
+// MARK: - Mock implementations (Phase 1 unit tests)
+
+/// In-memory buffer for mock read/write.
+public final class MockStreamBuffer {
+    public private(set) var readBuffer: Data
+    public private(set) var writeBuffer: Data
+    public var isClosed: Bool = false
+
+    public init(initialReadData: Data = Data()) {
+        self.readBuffer = initialReadData
+        self.writeBuffer = Data()
+    }
+
+    public func appendRead(_ data: Data) {
+        readBuffer.append(data)
+    }
+
+    public func consumeRead(maxBytes: Int) -> Data {
+        let n = min(maxBytes, readBuffer.count)
+        let out = readBuffer.prefix(n)
+        readBuffer = readBuffer.dropFirst(n)
+        return Data(out)
+    }
+
+    public func consumeWrite() -> Data {
+        let d = writeBuffer
+        writeBuffer = Data()
+        return d
+    }
+}
+
+/// Mock reader: reads from MockStreamBuffer.
+public final class MockStreamReader: MQTTStreamReaderProtocol {
+    private let buffer: MockStreamBuffer
+
+    public init(buffer: MockStreamBuffer) {
+        self.buffer = buffer
+    }
+
+    public func read(maxBytes: Int) async throws -> Data {
+        if buffer.isClosed && buffer.readBuffer.isEmpty {
+            return Data()
+        }
+        let n = min(maxBytes, buffer.readBuffer.count)
+        guard n > 0 else {
+            try await Task.sleep(nanoseconds: 1_000_000) // 1ms
+            return try await read(maxBytes: maxBytes)
+        }
+        return buffer.consumeRead(maxBytes: n)
+    }
+
+    public func readexactly(_ n: Int) async throws -> Data {
+        var acc = Data()
+        while acc.count < n {
+            if buffer.isClosed { throw MQTTProtocolError.insufficientData("stream closed") }
+            let chunk = try await read(maxBytes: n - acc.count)
+            if chunk.isEmpty { throw MQTTProtocolError.insufficientData("readexactly") }
+            acc.append(chunk)
+        }
+        return acc
+    }
+}
+
+/// Mock writer: appends to MockStreamBuffer.
+public final class MockStreamWriter: MQTTStreamWriterProtocol {
+    private let buffer: MockStreamBuffer
+
+    public init(buffer: MockStreamBuffer) {
+        self.buffer = buffer
+    }
+
+    public func write(_ data: Data) async throws {
+        buffer.writeBuffer.append(data)
+    }
+
+    public func drain() async throws {}
+
+    public func close() async throws {
+        buffer.isClosed = true
+    }
+}

package/ios/Tests/MQTTProtocolTests.swift

@@ -0,0 +1,82 @@
+//
+// MQTTProtocolTests.swift
+// Unit tests for MQTT encode/decode. Run via Xcode test target or Swift Package.
+//
+
+import XCTest
+@testable import MqttQuicPlugin
+
+final class MQTTProtocolTests: XCTestCase {
+
+    func testEncodeDecodeRemainingLength() throws {
+        for (len, bytes) in [(0, 1), (127, 1), (128, 2), (16383, 2), (16384, 3), (2_097_151, 3), (2_097_152, 4)] {
+            let enc = try MQTTProtocol.encodeRemainingLength(len)
+            XCTAssertEqual(enc.count, bytes, "length \(len)")
+            let (dec, _) = try MQTTProtocol.decodeRemainingLength(Data(enc), offset: 0)
+            XCTAssertEqual(dec, len)
+        }
+    }
+
+    func testEncodeDecodeString() throws {
+        let s = "hello/mqtt"
+        let enc = try MQTTProtocol.encodeString(s)
+        XCTAssertEqual(enc.count, 2 + s.utf8.count)
+        let (dec, _) = try MQTTProtocol.decodeString(enc, offset: 0)
+        XCTAssertEqual(dec, s)
+    }
+
+    func testBuildConnect() throws {
+        let data = try MQTTProtocol.buildConnect(clientId: "test-client", username: "u", password: "p", keepalive: 90, cleanSession: true)
+        XCTAssertGreaterThanOrEqual(data.count, 10)
+        XCTAssertEqual(data[0], MQTTMessageType.CONNECT.rawValue)
+    }
+
+    func testBuildConnack() {
+        let data = MQTTProtocol.buildConnack(returnCode: MQTTConnAckCode.accepted.rawValue)
+        XCTAssertEqual(data.count, 4)
+        XCTAssertEqual(data[0], MQTTMessageType.CONNACK.rawValue)
+        XCTAssertEqual(data[3], MQTTConnAckCode.accepted.rawValue)
+    }
+
+    func testBuildPublish() throws {
+        let payload = Data("hello".utf8)
+        let data = try MQTTProtocol.buildPublish(topic: "a/b", payload: payload, qos: 0, retain: false)
+        XCTAssertEqual(data[0] & 0xF0, MQTTMessageType.PUBLISH.rawValue)
+    }
+
+    func testBuildSubscribeAndSuback() throws {
+        let sub = try MQTTProtocol.buildSubscribe(packetId: 1, topic: "t/1", qos: 0)
+        XCTAssertEqual(sub[0], MQTTMessageType.SUBSCRIBE.rawValue | 0x02)
+
+        let suback = MQTTProtocol.buildSuback(packetId: 1, returnCode: 0)
+        XCTAssertEqual(suback[0], MQTTMessageType.SUBACK.rawValue)
+        let (pid, rc, _) = try MQTTProtocol.parseSuback(suback, offset: 2) // skip fixed header (2 bytes)
+        XCTAssertEqual(pid, 1)
+        XCTAssertEqual(rc, 0)
+    }
+
+    func testBuildPingreqPingrespDisconnect() {
+        let pr = MQTTProtocol.buildPingreq()
+        XCTAssertEqual(pr[0], MQTTMessageType.PINGREQ.rawValue)
+        let ps = MQTTProtocol.buildPingresp()
+        XCTAssertEqual(ps[0], MQTTMessageType.PINGRESP.rawValue)
+        let dc = MQTTProtocol.buildDisconnect()
+        XCTAssertEqual(dc[0], MQTTMessageType.DISCONNECT.rawValue)
+    }
+
+    func testMockStreamReaderWriter() async throws {
+        let buf = MockStreamBuffer(initialReadData: Data([1, 2, 3, 4, 5]))
+        let reader = MockStreamReader(buffer: buf)
+        let writer = MockStreamWriter(buffer: buf)
+
+        let r1 = try await reader.read(maxBytes: 2)
+        XCTAssertEqual(r1, Data([1, 2]))
+        let r2 = try await reader.readexactly(3)
+        XCTAssertEqual(r2, Data([3, 4, 5]))
+
+        try await writer.write(Data([6, 7, 8]))
+        try await writer.drain()
+        let written = buf.consumeWrite()
+        XCTAssertEqual(written, Data([6, 7, 8]))
+    }
+}