@annadata/capacitor-mqtt-quic 0.1.0

package/ios/MqttQuicPlugin.podspec

@@ -0,0 +1,34 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'MqttQuicPlugin'
+  s.version = package['version']
+  s.summary = 'MQTT-over-QUIC Capacitor plugin (iOS)'
+  s.license = package['license']
+  s.homepage = 'https://github.com/annadata/capacitor-mqtt-quic'
+  s.author = 'Annadata'
+  s.source = { :git => 'https://github.com/annadata/capacitor-mqtt-quic', :tag => s.version.to_s }
+  s.source_files = 'Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.resources = ['Sources/MqttQuicPlugin/Resources/*.pem']
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+  s.vendored_libraries = [
+    'libs/libngtcp2.a',
+    'libs/libngtcp2_crypto_quictls.a',
+    'libs/libnghttp3.a',
+    'libs/libssl.a',
+    'libs/libcrypto.a'
+  ]
+  s.public_header_files = 'Sources/**/*.h', 'include/**/*.h'
+  s.private_header_files = 'Sources/**/*.h', 'include/**/*.h'
+  s.header_mappings_dir = 'Sources'
+  s.pod_target_xcconfig = {
+    'HEADER_SEARCH_PATHS' => '$(PODS_ROOT)/MqttQuicPlugin/include/ngtcp2 $(PODS_ROOT)/MqttQuicPlugin/include/nghttp3 $(PODS_ROOT)/MqttQuicPlugin/include/openssl',
+    'LIBRARY_SEARCH_PATHS' => '$(PODS_ROOT)/MqttQuicPlugin/libs',
+    'OTHER_LDFLAGS' => '-lngtcp2 -lngtcp2_crypto_quictls -lnghttp3 -lssl -lcrypto',
+    'SWIFT_ACTIVE_COMPILATION_CONDITIONS' => 'NGTCP2_ENABLED NGHTTP3_ENABLED'
+  }
+end

package/ios/NGTCP2_BUILD_INSTRUCTIONS.md

@@ -0,0 +1,302 @@
+# Building ngtcp2 for iOS
+
+This document provides instructions for building ngtcp2 and OpenSSL for iOS to enable real QUIC transport in the MQTT client.
+
+## Prerequisites
+
+- **Xcode 14+** (for iOS 15+)
+- **CMake 3.20+**
+- **iOS SDK 15.0+**
+- **Git** (for cloning repositories)
+
+**Source layout:** set `PROJECT_DIR` to the `capacitor-mqtt-quic` repo root.
+Build scripts then expect dependencies under:
+- `$PROJECT_DIR/ref-code/ngtcp2`
+- `$PROJECT_DIR/ref-code/nghttp3`
+- `$PROJECT_DIR/ref-code/openssl` (or `$PROJECT_DIR/ref-code.openssl`)
+
+```bash
+export PROJECT_DIR="/Users/annadata/Project_A/annadata-production/ref-code/capacitor-mqtt-quic"
+```
+
+Override with `NGTCP2_SOURCE_DIR`, `NGHTTP3_SOURCE_DIR`, `OPENSSL_SOURCE_DIR`
+if you store sources elsewhere.
+
+## Quick Start
+
+### Option 1: Use Pre-built Libraries (Recommended for Development)
+
+If you have access to pre-built ngtcp2, nghttp3, and OpenSSL libraries:
+
+1. Place `libngtcp2.a` in `ios/libs/`
+2. Place `libnghttp3.a` in `ios/libs/`
+3. Place OpenSSL libraries (`libssl.a`, `libcrypto.a`) in `ios/libs/`
+4. Place headers in `ios/include/ngtcp2/`, `ios/include/nghttp3/`, and `ios/include/openssl/`
+5. Update `MqttQuicPlugin.podspec` to link against these libraries
+
+### Option 2: Build from Source
+
+#### Step 1: Build OpenSSL for iOS (QUIC TLS)
+
+```bash
+cd ios
+./build-openssl.sh --arch arm64 --sdk iphoneos --quictls
+```
+
+This will:
+- Clone quictls (OpenSSL fork with QUIC API) if not present
+- Build static libraries for iOS
+- Install to `ios/install/openssl-ios/`
+- Sync `libssl.a`, `libcrypto.a` to `ios/libs/` and headers to `ios/include/openssl/`
+
+**Note:** For simulator builds, use:
+```bash
+./build-openssl.sh --arch x86_64 --sdk iphonesimulator
+```
+
+#### Step 2: Build nghttp3 for iOS
+
+```bash
+cd ios
+./build-nghttp3.sh \
+  --arch arm64 \
+  --sdk iphoneos
+```
+
+This will:
+- Build nghttp3 static library
+- Install to `ios/build/nghttp3-ios-arm64/install/`
+- Sync `libnghttp3.a` to `ios/libs/` and headers to `ios/include/nghttp3/`
+
+#### Step 3: Build ngtcp2 for iOS
+
+```bash
+cd ios
+./build-ngtcp2.sh \
+  --openssl-path ./install/openssl-ios \
+  --arch arm64 \
+  --sdk iphoneos \
+  --quictls
+```
+
+This will:
+- Build ngtcp2 static library
+- Link against OpenSSL (quictls)
+- Install to `ios/build/ios-arm64/install/`
+- Sync `libngtcp2.a` and `libngtcp2_crypto_quictls.a` to `ios/libs/` and headers to `ios/include/ngtcp2/`
+
+#### Step 4: Build for Multiple Architectures
+
+For a universal library (arm64 + x86_64 for simulator):
+
+```bash
+# Build for device (arm64)
+./build-openssl.sh --arch arm64 --sdk iphoneos --quictls
+./build-nghttp3.sh --arch arm64 --sdk iphoneos
+./build-ngtcp2.sh --openssl-path ./install/openssl-ios --arch arm64 --sdk iphoneos --quictls
+
+# Build for simulator (x86_64)
+./build-openssl.sh --arch x86_64 --sdk iphonesimulator --quictls
+./build-nghttp3.sh --arch x86_64 --sdk iphonesimulator
+./build-ngtcp2.sh --openssl-path ./install/openssl-ios --arch x86_64 --sdk iphonesimulator --quictls
+
+# Create universal library
+lipo -create \
+  build/ios-arm64/install/lib/libngtcp2.a \
+  build/ios-x86_64/install/lib/libngtcp2.a \
+  -output libs/libngtcp2-universal.a
+
+# Create universal nghttp3 library
+lipo -create \
+  build/nghttp3-ios-arm64/install/lib/libnghttp3.a \
+  build/nghttp3-ios-x86_64/install/lib/libnghttp3.a \
+  -output libs/libnghttp3-universal.a
+
+# Create universal ngtcp2_crypto_quictls library
+lipo -create \
+  build/ios-arm64/install/lib/libngtcp2_crypto_quictls.a \
+  build/ios-x86_64/install/lib/libngtcp2_crypto_quictls.a \
+  -output libs/libngtcp2_crypto_quictls-universal.a
+```
+
+## Integration into Xcode Project
+
+### Option A: CocoaPods (Recommended)
+
+Update `ios/MqttQuicPlugin.podspec`:
+
+```ruby
+Pod::Spec.new do |s|
+  # ... existing configuration ...
+  
+  # ngtcp2 static library
+  s.vendored_libraries = 'libs/libngtcp2.a', 'libs/libngtcp2_crypto_quictls.a', 'libs/libnghttp3.a', 'libs/libssl.a', 'libs/libcrypto.a'
+  
+  # Header search paths
+  s.public_header_files = 'Sources/**/*.h'
+  s.private_header_files = 'Sources/**/*.h'
+  s.header_mappings_dir = 'Sources'
+  
+  # Include ngtcp2/nghttp3 headers
+  s.xcconfig = {
+    'HEADER_SEARCH_PATHS' => '$(PODS_ROOT)/MqttQuicPlugin/include/ngtcp2 $(PODS_ROOT)/MqttQuicPlugin/include/nghttp3 $(PODS_ROOT)/MqttQuicPlugin/include/openssl',
+    'LIBRARY_SEARCH_PATHS' => '$(PODS_ROOT)/MqttQuicPlugin/libs',
+    'OTHER_LDFLAGS' => '-lngtcp2 -lngtcp2_crypto_quictls -lnghttp3 -lssl -lcrypto'
+  }
+  
+  # OpenSSL dependency (if using CocoaPods)
+  s.dependency 'OpenSSL-Universal', '~> 3.0'
+end
+```
+
+### Option B: Manual Integration
+
+1. Add `libngtcp2.a` and `libnghttp3.a` to Xcode project
+2. Add header search paths:
+   - `$(SRCROOT)/../ios/include/ngtcp2`
+   - `$(SRCROOT)/../ios/include/nghttp3`
+   - `$(SRCROOT)/../ios/include/openssl`
+3. Link against:
+   - `libngtcp2.a`
+   - `libnghttp3.a`
+   - `libssl.a` (OpenSSL)
+   - `libcrypto.a` (OpenSSL)
+
+## TLS Certificate Verification (QUIC)
+
+QUIC requires TLS 1.3 and certificate verification is **enabled by default**.
+You can bundle a CA PEM and it will be loaded automatically:
+
+- `ios/Sources/MqttQuicPlugin/Resources/mqttquic_ca.pem`
+
+You can also override per call:
+
+```ts
+await MqttQuic.connect({
+  host: 'mqtt.example.com',
+  port: 1884,
+  clientId: 'my-client-id',
+  caFile: '/path/to/ca-bundle.pem',
+  // or caPath: '/path/to/ca-directory'
+});
+```
+
+### How to generate certificates
+
+**Option A: Public CA (Let’s Encrypt)**  
+You do not bundle `mqttquic_ca.pem` (the OS already trusts public CAs).
+
+```bash
+sudo apt-get update
+sudo apt-get install -y certbot
+sudo certbot certonly --standalone -d mqtt.example.com
+```
+
+Use on server:
+- Cert: `/etc/letsencrypt/live/mqtt.example.com/fullchain.pem`
+- Key: `/etc/letsencrypt/live/mqtt.example.com/privkey.pem`
+
+**Option B: Private CA (dev/internal)**  
+Generate your own CA, sign the server cert, and bundle the CA PEM.
+
+```bash
+mkdir -p certs && cd certs
+
+# 1) Create CA (one-time)
+openssl genrsa -out ca.key 4096
+openssl req -x509 -new -nodes -key ca.key -sha256 -days 3650 -out ca.pem \
+  -subj "/C=US/ST=CA/L=SF/O=Annadata/OU=MQTT/CN=Annadata-Root-CA"
+
+# 2) Create server key + CSR
+openssl genrsa -out server.key 2048
+openssl req -new -key server.key -out server.csr \
+  -subj "/C=US/ST=CA/L=SF/O=Annadata/OU=MQTT/CN=mqtt.example.com"
+
+# 3) Add SANs (edit DNS/IP)
+cat > server_ext.cnf <<EOF
+subjectAltName = DNS:mqtt.example.com,IP:YOUR.SERVER.IP
+extendedKeyUsage = serverAuth
+EOF
+
+# 4) Sign server cert
+openssl x509 -req -in server.csr -CA ca.pem -CAkey ca.key -CAcreateserial \
+  -out server.pem -days 365 -sha256 -extfile server_ext.cnf
+```
+
+Bundle the CA cert (never ship `ca.key`):
+- iOS: `ios/Sources/MqttQuicPlugin/Resources/mqttquic_ca.pem` (use `ca.pem`)
+
+## Test Harness (QUIC Smoke Test)
+
+This runs: connect → subscribe → publish → disconnect.
+
+```ts
+await MqttQuic.testHarness({
+  host: 'mqtt.example.com',
+  port: 1884,
+  clientId: 'mqttquic_test_client',
+  topic: 'test/topic',
+  payload: 'Hello QUIC!',
+  // optional CA override
+  caFile: '/path/to/ca-bundle.pem'
+});
+```
+
+## Using Pre-built Libraries
+
+If you prefer to use pre-built libraries:
+
+### OpenSSL
+
+Download from:
+- https://github.com/x2on/OpenSSL-for-iPhone
+- https://github.com/krzyzanowskim/OpenSSL
+
+### ngtcp2
+
+Currently, there are no widely available pre-built ngtcp2 libraries for iOS. You'll need to build from source.
+
+### nghttp3
+
+Currently, there are no widely available pre-built nghttp3 libraries for iOS. You'll need to build from source. Make sure you clone with submodules:
+
+```bash
+git clone --recurse-submodules https://github.com/ngtcp2/nghttp3.git
+```
+
+## Troubleshooting
+
+### CMake Not Found
+
+```bash
+# Install via Homebrew
+brew install cmake
+```
+
+### OpenSSL Build Fails
+
+- Ensure you're using OpenSSL 3.0+ (required for TLS 1.3)
+- Check that Xcode command line tools are installed: `xcode-select --install`
+- Verify SDK path: `xcrun --sdk iphoneos --show-sdk-path`
+
+### ngtcp2 Build Fails
+
+- Verify OpenSSL is built and path is correct
+- Check CMake version: `cmake --version` (must be 3.20+)
+- Ensure iOS deployment target matches (15.0+)
+
+### Link Errors
+
+- Verify all libraries are built for the same architecture
+- Check that header search paths are correct
+- Ensure OpenSSL and ngtcp2 are linked in the correct order
+
+## Next Steps
+
+After building ngtcp2:
+
+1. Update `NGTCP2Client.swift` to implement the TODO sections
+2. Replace `QuicClientStub` with `NGTCP2Client` in `MQTTClient.swift`
+3. Test connection to MQTT server over QUIC
+
+See `NGTCP2_INTEGRATION_PLAN.md` for detailed implementation guide.

package/ios/Sources/MqttQuicPlugin/Client/MQTTClient.swift

@@ -0,0 +1,343 @@
+//
+// MQTTClient.swift
+// MqttQuicPlugin
+//
+// High-level MQTT client: connect, publish, subscribe, disconnect.
+// Uses QuicClient + stream adapters + MQTT protocol.
+//
+
+import Foundation
+
+public final class MQTTClient {
+
+    public enum State {
+        case disconnected
+        case connecting
+        case connected
+        case error(String)
+    }
+    
+    public enum ProtocolVersion {
+        case v311
+        case v5
+        case auto  // Try 5.0 first, fallback to 3.1.1
+    }
+
+    private var state: State = .disconnected
+    private var protocolVersion: ProtocolVersion = .auto
+    private var activeProtocolVersion: UInt8 = 0  // 0x04 or 0x05
+    private var quicClient: QuicClientProtocol?
+    private var stream: QuicStreamProtocol?
+    private var reader: MQTTStreamReaderProtocol?
+    private var writer: MQTTStreamWriterProtocol?
+    private var messageLoopTask: Task<Void, Error>?
+    private var nextPacketId: UInt16 = 1
+    private var subscribedTopics: [String: (Data) -> Void] = [:]
+    private let lock = NSLock()
+
+    public init(protocolVersion: ProtocolVersion = .auto) {
+        self.protocolVersion = protocolVersion
+    }
+
+    public func getState() -> State {
+        lock.lock()
+        defer { lock.unlock() }
+        return state
+    }
+
+    public func connect(host: String, port: UInt16, clientId: String, username: String?, password: String?, cleanSession: Bool, keepalive: UInt16, sessionExpiryInterval: UInt32? = nil) async throws {
+        lock.lock()
+        if case .connecting = state {
+            lock.unlock()
+            throw MQTTProtocolError.insufficientData("already connecting")
+        }
+        state = .connecting
+        lock.unlock()
+
+        do {
+            // Determine protocol version
+            let useV5 = protocolVersion == .v5 || (protocolVersion == .auto)
+            
+            let quic: QuicClientProtocol
+            #if NGTCP2_ENABLED
+            quic = NGTCP2Client()
+            #else
+            // Build CONNACK stub (used when ngtcp2 is not linked)
+            let connack: Data
+            if useV5 {
+                connack = try MQTT5Protocol.buildConnackV5(reasonCode: .success, sessionPresent: false)
+            } else {
+                connack = MQTTProtocol.buildConnack(returnCode: MQTTConnAckCode.accepted.rawValue)
+            }
+            quic = QuicClientStub(initialReadData: connack)
+            #endif
+            try await quic.connect(host: host, port: port)
+            let s = try await quic.openStream()
+            let r = QUICStreamReader(stream: s)
+            let w = QUICStreamWriter(stream: s)
+
+            lock.lock()
+            quicClient = quic
+            stream = s
+            reader = r
+            writer = w
+            lock.unlock()
+
+            // Build CONNECT
+            let connectData: Data
+            if useV5 {
+                connectData = try MQTT5Protocol.buildConnectV5(
+                    clientId: clientId,
+                    username: username,
+                    password: password,
+                    keepalive: keepalive,
+                    cleanStart: cleanSession,
+                    sessionExpiryInterval: sessionExpiryInterval
+                )
+                activeProtocolVersion = MQTTProtocolLevel.v5
+            } else {
+                connectData = try MQTTProtocol.buildConnect(
+                    clientId: clientId,
+                    username: username,
+                    password: password,
+                    keepalive: keepalive,
+                    cleanSession: cleanSession
+                )
+                activeProtocolVersion = MQTTProtocolLevel.v311
+            }
+            
+            try await w.write(connectData)
+            try await w.drain()
+
+            // Read CONNACK
+            let fixed = try await r.readexactly(2)
+            let (msgType, remLen, hdrLen) = try MQTTProtocol.parseFixedHeader(Data(fixed))
+            let rest = try await r.readexactly(remLen)
+            var full = Data(fixed)
+            full.append(rest)
+            
+            if msgType != MQTTMessageType.CONNACK.rawValue {
+                lock.lock()
+                state = .error("expected CONNACK, got \(msgType)")
+                lock.unlock()
+                throw MQTTProtocolError.insufficientData("expected CONNACK")
+            }
+            
+            // Parse CONNACK based on protocol version
+            if activeProtocolVersion == MQTTProtocolLevel.v5 {
+                let (_, reasonCode, _, _) = try MQTT5Protocol.parseConnackV5(full, offset: hdrLen)
+                if reasonCode != .success {
+                    lock.lock()
+                    state = .error("CONNACK refused: \(reasonCode)")
+                    lock.unlock()
+                    throw MQTTProtocolError.insufficientData("CONNACK refused: \(reasonCode)")
+                }
+            } else {
+                let (_, returnCode) = try MQTTProtocol.parseConnack(full, offset: hdrLen)
+                if returnCode != MQTTConnAckCode.accepted.rawValue {
+                    lock.lock()
+                    state = .error("CONNACK refused: \(returnCode)")
+                    lock.unlock()
+                    throw MQTTProtocolError.insufficientData("CONNACK refused")
+                }
+            }
+
+            lock.lock()
+            state = .connected
+            lock.unlock()
+
+            startMessageLoop()
+        } catch {
+            lock.lock()
+            let w = writer
+            quicClient = nil
+            stream = nil
+            reader = nil
+            writer = nil
+            state = .error("\(error)")
+            lock.unlock()
+            try? await w?.close()
+            throw error
+        }
+    }
+
+    public func publish(topic: String, payload: Data, qos: UInt8, properties: [UInt8: Any]? = nil) async throws {
+        guard case .connected = getState() else { throw MQTTProtocolError.insufficientData("not connected") }
+        lock.lock()
+        let w = writer
+        let version = activeProtocolVersion
+        lock.unlock()
+        guard let w = w else { throw MQTTProtocolError.insufficientData("no writer") }
+
+        let pid: UInt16? = qos > 0 ? nextPacketIdUsed() : nil
+        let data: Data
+        if version == MQTTProtocolLevel.v5 {
+            data = try MQTT5Protocol.buildPublishV5(topic: topic, payload: payload, packetId: pid, qos: qos, retain: false, properties: properties)
+        } else {
+            data = try MQTTProtocol.buildPublish(topic: topic, payload: payload, packetId: pid, qos: qos, retain: false)
+        }
+        try await w.write(data)
+        try await w.drain()
+    }
+
+    public func subscribe(topic: String, qos: UInt8, subscriptionIdentifier: Int? = nil) async throws {
+        guard case .connected = getState() else { throw MQTTProtocolError.insufficientData("not connected") }
+        lock.lock()
+        let r = reader, w = writer
+        let version = activeProtocolVersion
+        lock.unlock()
+        guard let r = r, let w = w else { throw MQTTProtocolError.insufficientData("no reader/writer") }
+
+        let pid = nextPacketIdUsed()
+        let data: Data
+        if version == MQTTProtocolLevel.v5 {
+            data = try MQTT5Protocol.buildSubscribeV5(packetId: pid, topic: topic, qos: qos, subscriptionIdentifier: subscriptionIdentifier)
+        } else {
+            data = try MQTTProtocol.buildSubscribe(packetId: pid, topic: topic, qos: qos)
+        }
+        try await w.write(data)
+        try await w.drain()
+
+        let fixed = try await r.readexactly(2)
+        let (_, remLen, hdrLen) = try MQTTProtocol.parseFixedHeader(Data(fixed))
+        let rest = try await r.readexactly(remLen)
+        var full = Data(fixed)
+        full.append(rest)
+        
+        if version == MQTTProtocolLevel.v5 {
+            let (_, reasonCodes, _, _) = try MQTT5Protocol.parseSubackV5(full, offset: hdrLen)
+            if let firstRC = reasonCodes.first, firstRC != .grantedQoS0 && firstRC != .grantedQoS1 && firstRC != .grantedQoS2 {
+                throw MQTTProtocolError.insufficientData("SUBACK error \(firstRC)")
+            }
+        } else {
+            let (_, rc, _) = try MQTTProtocol.parseSuback(full, offset: hdrLen)
+            if rc > 0x02 { throw MQTTProtocolError.insufficientData("SUBACK error \(rc)") }
+        }
+    }
+
+    public func unsubscribe(topic: String) async throws {
+        guard case .connected = getState() else { throw MQTTProtocolError.insufficientData("not connected") }
+        lock.lock()
+        let r = reader, w = writer
+        let version = activeProtocolVersion
+        subscribedTopics.removeValue(forKey: topic)
+        lock.unlock()
+        guard let r = r, let w = w else { throw MQTTProtocolError.insufficientData("no reader/writer") }
+
+        let pid = nextPacketIdUsed()
+        let data: Data
+        if version == MQTTProtocolLevel.v5 {
+            data = try MQTT5Protocol.buildUnsubscribeV5(packetId: pid, topics: [topic])
+        } else {
+            data = try MQTTProtocol.buildUnsubscribe(packetId: pid, topics: [topic])
+        }
+        try await w.write(data)
+        try await w.drain()
+
+        let fixed = try await r.readexactly(2)
+        let (_, remLen, _) = try MQTTProtocol.parseFixedHeader(Data(fixed))
+        _ = try await r.readexactly(remLen)
+    }
+
+    public func disconnect() async throws {
+        let task = messageLoopTask
+        messageLoopTask = nil
+        task?.cancel()
+        _ = try? await task?.value
+
+        lock.lock()
+        let w = writer
+        let version = activeProtocolVersion
+        quicClient = nil
+        stream = nil
+        reader = nil
+        writer = nil
+        state = .disconnected
+        activeProtocolVersion = 0
+        lock.unlock()
+
+        if let w = w {
+            let data: Data
+            if version == MQTTProtocolLevel.v5 {
+                data = try MQTT5Protocol.buildDisconnectV5(reasonCode: .normalDisconnectionDisc)
+            } else {
+                data = MQTTProtocol.buildDisconnect()
+            }
+            try? await w.write(data)
+            try? await w.drain()
+            try? await w.close()
+        }
+    }
+
+    public func onMessage(_ topic: String, _ callback: @escaping (Data) -> Void) {
+        lock.lock()
+        subscribedTopics[topic] = callback
+        lock.unlock()
+    }
+
+    private func nextPacketIdUsed() -> UInt16 {
+        lock.lock()
+        defer { lock.unlock() }
+        let pid = nextPacketId
+        nextPacketId = nextPacketId &+ 1
+        if nextPacketId == 0 { nextPacketId = 1 }
+        return pid
+    }
+
+    private func startMessageLoop() {
+        messageLoopTask = Task { [weak self] in
+            guard let self = self else { return }
+            while !Task.isCancelled {
+                let r: MQTTStreamReaderProtocol?
+                self.lock.lock()
+                r = self.reader
+                self.lock.unlock()
+                guard let r = r else { break }
+
+                do {
+                    let fixed = try await r.readexactly(2)
+                    let (msgType, remLen, _) = try MQTTProtocol.parseFixedHeader(Data(fixed))
+                    let rest = try await r.readexactly(remLen)
+                    let type = msgType & 0xF0
+
+                    self.lock.lock()
+                    let version = self.activeProtocolVersion
+                    let w = self.writer
+                    self.lock.unlock()
+
+                    switch type {
+                    case MQTTMessageType.PINGREQ.rawValue:
+                        if let w = w {
+                            let pr = MQTTProtocol.buildPingresp()
+                            try await w.write(Data(pr))
+                            try await w.drain()
+                        }
+                    case MQTTMessageType.PUBLISH.rawValue:
+                        let qos = (msgType >> 1) & 0x03
+                        let (topic, packetId, payload, _) = try MQTTProtocol.parsePublish(Data(rest), offset: 0, qos: qos)
+
+                        self.lock.lock()
+                        let cb = self.subscribedTopics[topic]
+                        self.lock.unlock()
+                        cb?(payload)
+
+                        if qos >= 1, let pid = packetId {
+                            self.lock.lock()
+                            let wPuback = self.writer
+                            self.lock.unlock()
+                            if let wPuback = wPuback {
+                                let puback = MQTTProtocol.buildPuback(packetId: pid)
+                                try await wPuback.write(Data(puback))
+                                try await wPuback.drain()
+                            }
+                        }
+                    default:
+                        break
+                    }
+                } catch {
+                    if !Task.isCancelled { break }
+                }
+            }
+        }
+    }
+}