@annadata/capacitor-mqtt-quic 0.1.7 → 0.1.9

package/android/src/main/cpp/ngtcp2_jni.cpp

@@ -24,6 +24,7 @@
 #include <algorithm>
 #include <atomic>
 #include <chrono>
+#include <cinttypes>
 #include <cstdarg>
 #include <cstdlib>
 #include <cstdio>
@@ -73,7 +74,11 @@ struct OutgoingChunk {
 class QuicClient {
  public:
   QuicClient(std::string host, uint16_t port)
-      : host_(std::move(host)),
+      : QuicClient(std::move(host), "", port) {}
+
+  QuicClient(std::string host_for_tls, std::string connect_addr, uint16_t port)
+      : host_(std::move(host_for_tls)),
+        connect_addr_(connect_addr.empty() ? host_ : std::move(connect_addr)),
         port_(port),
         fd_(-1),
         ssl_ctx_(nullptr),
@@ -181,6 +186,9 @@ class QuicClient {
       buffer[i] = state.recv_buf.front();
       state.recv_buf.pop_front();
     }
+    if (n > 0) {
+      LOGI("read_stream stream_id=%" PRId64 " returning %zu bytes", (int64_t)stream_id, n);
+    }
     return (ssize_t)n;
   }
 
@@ -188,7 +196,7 @@ class QuicClient {
     if (!conn_) {
       return 0;
     }
-    int rv = ngtcp2_conn_shutdown_stream_write(conn_, stream_id, 0);
+    int rv = ngtcp2_conn_shutdown_stream_write(conn_, 0, stream_id, 0);
     if (rv != 0) {
       setError(ngtcp2_strerror(rv));
       return -1;
@@ -223,6 +231,8 @@ class QuicClient {
     std::lock_guard<std::mutex> lock(stream_mutex_);
     StreamState &state = streams_[stream_id];
     state.recv_buf.insert(state.recv_buf.end(), data, data + datalen);
+    LOGI("recv stream data stream_id=%" PRId64 " len=%zu recv_buf_total=%zu",
+         (int64_t)stream_id, datalen, state.recv_buf.size());
     if (flags & NGTCP2_STREAM_DATA_FLAG_FIN) {
       state.fin_received = true;
     }
@@ -254,7 +264,8 @@ class QuicClient {
 
     char port_str[16];
     snprintf(port_str, sizeof(port_str), "%u", port_);
-    int rv = getaddrinfo(host_.c_str(), port_str, &hints, &res);
+    const char *resolve_host = connect_addr_.empty() ? host_.c_str() : connect_addr_.c_str();
+    int rv = getaddrinfo(resolve_host, port_str, &hints, &res);
     if (rv != 0) {
       setError(gai_strerror(rv));
       return -1;
@@ -266,12 +277,19 @@ class QuicClient {
       if (fd == -1) {
         continue;
       }
-      if (connect(fd, rp->ai_addr, rp->ai_addrlen) == 0) {
+      if (::connect(fd, rp->ai_addr, rp->ai_addrlen) == 0) {
         memcpy(&remote_addr_, rp->ai_addr, rp->ai_addrlen);
         remote_addrlen_ = (socklen_t)rp->ai_addrlen;
+        char buf[INET6_ADDRSTRLEN];
+        const void *src = (rp->ai_family == AF_INET)
+            ? (void *)&((struct sockaddr_in *)rp->ai_addr)->sin_addr
+            : (void *)&((struct sockaddr_in6 *)rp->ai_addr)->sin6_addr;
+        if (inet_ntop(rp->ai_family, src, buf, sizeof(buf))) {
+          resolved_address_ = buf;
+        }
         break;
       }
-      close(fd);
+      ::close(fd);
       fd = -1;
     }
     freeaddrinfo(res);
@@ -284,7 +302,7 @@ class QuicClient {
     if (getsockname(fd, (struct sockaddr *)&local_addr_, &local_addrlen_) !=
         0) {
       setError("getsockname failed");
-      close(fd);
+      ::close(fd);
       return -1;
     }
 
@@ -333,17 +351,21 @@ class QuicClient {
     bool ca_loaded = false;
     const char *ca_file = std::getenv("MQTT_QUIC_CA_FILE");
     const char *ca_path = std::getenv("MQTT_QUIC_CA_PATH");
-    if ((ca_file && ca_file[0] != '\0') || (ca_path && ca_path[0] != '\0')) {
-      if (wolfSSL_CTX_load_verify_locations(ssl_ctx_, ca_file, ca_path) != 1) {
+    const char *file_arg = (ca_file && ca_file[0] != '\0') ? ca_file : nullptr;
+    const char *path_arg = (ca_path && ca_path[0] != '\0') ? ca_path : nullptr;
+    if (file_arg || path_arg) {
+      if (wolfSSL_CTX_load_verify_locations(ssl_ctx_, file_arg, path_arg) == 1) {
+        ca_loaded = true;
+      } else {
         setError("Failed to load CA bundle from MQTT_QUIC_CA_FILE/CA_PATH");
         return -1;
       }
+    }
+    if (!ca_loaded && wolfSSL_CTX_set_default_verify_paths(ssl_ctx_) == 1) {
       ca_loaded = true;
     }
-    if (!ca_loaded) {
-      if (wolfSSL_CTX_set_default_verify_paths(ssl_ctx_) == 1) {
-        ca_loaded = true;
-      }
+    if (!ca_loaded && wolfSSL_CTX_load_system_CA_certs(ssl_ctx_) == 1) {
+      ca_loaded = true;
     }
     if (!ca_loaded) {
       setError("No CA bundle available for TLS verification");
@@ -647,30 +669,44 @@ class QuicClient {
   }
 
   void cleanup() {
-    if (conn_) {
-      ngtcp2_conn_del(conn_);
+    ngtcp2_conn *conn_to_del = nullptr;
+    void *ssl_to_free = nullptr;
+    void *ssl_ctx_to_free = nullptr;
+    int fd_to_close = -1;
+    int wake0 = -1, wake1 = -1;
+    {
+      std::lock_guard<std::mutex> lock(cleanup_mutex_);
+      conn_to_del = conn_;
       conn_ = nullptr;
-    }
-    if (ssl_) {
-      wolfSSL_free(ssl_);
+      ssl_to_free = ssl_;
       ssl_ = nullptr;
-    }
-    if (ssl_ctx_) {
-      wolfSSL_CTX_free(ssl_ctx_);
+      ssl_ctx_to_free = ssl_ctx_;
       ssl_ctx_ = nullptr;
-    }
-    if (fd_ != -1) {
-      close(fd_);
+      fd_to_close = fd_;
       fd_ = -1;
-    }
-    if (wakeup_fds_[0] != -1) {
-      close(wakeup_fds_[0]);
+      wake0 = wakeup_fds_[0];
+      wake1 = wakeup_fds_[1];
       wakeup_fds_[0] = -1;
-    }
-    if (wakeup_fds_[1] != -1) {
-      close(wakeup_fds_[1]);
       wakeup_fds_[1] = -1;
     }
+    if (conn_to_del) {
+      ngtcp2_conn_del(conn_to_del);
+    }
+    if (ssl_to_free) {
+      wolfSSL_free(static_cast<WOLFSSL *>(ssl_to_free));
+    }
+    if (ssl_ctx_to_free) {
+      wolfSSL_CTX_free(static_cast<WOLFSSL_CTX *>(ssl_ctx_to_free));
+    }
+    if (fd_to_close != -1) {
+      ::close(fd_to_close);
+    }
+    if (wake0 != -1) {
+      ::close(wake0);
+    }
+    if (wake1 != -1) {
+      ::close(wake1);
+    }
   }
 
   void clearError() {
@@ -740,10 +776,11 @@ class QuicClient {
     return 0;
   }
 
-  static int stream_close_cb(ngtcp2_conn *conn, int64_t stream_id,
-                             uint64_t app_error_code, void *user_data,
-                             void *stream_user_data) {
+  static int stream_close_cb(ngtcp2_conn *conn, uint32_t flags,
+                             int64_t stream_id, uint64_t app_error_code,
+                             void *user_data, void *stream_user_data) {
     (void)conn;
+    (void)flags;
     (void)app_error_code;
     (void)stream_user_data;
     auto *client = static_cast<QuicClient *>(user_data);
@@ -761,9 +798,14 @@ class QuicClient {
     return client->on_handshake_completed();
   }
 
+ public:
+  const std::string &resolved_address() const { return resolved_address_; }
+
  private:
   std::string host_;
+  std::string connect_addr_;
   uint16_t port_;
+  std::string resolved_address_;
 
   int fd_;
   struct sockaddr_storage remote_addr_;
@@ -795,6 +837,8 @@ class QuicClient {
 
   mutable std::mutex err_mutex_;
   std::string last_error_str_;
+
+  std::mutex cleanup_mutex_;
 };
 
 static std::map<jlong, std::unique_ptr<QuicClient>> connections;
@@ -822,6 +866,27 @@ Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeCreateConnection(
   return handle;
 }
 
+JNIEXPORT jlong JNICALL
+Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeCreateConnectionWithAddress(
+    JNIEnv *env, jobject thiz, jstring hostnameForTls, jstring connectAddress, jint port) {
+  const char *tls_str = env->GetStringUTFChars(hostnameForTls, nullptr);
+  const char *addr_str = env->GetStringUTFChars(connectAddress, nullptr);
+  if (!tls_str || !addr_str) {
+    if (tls_str) env->ReleaseStringUTFChars(hostnameForTls, tls_str);
+    return 0;
+  }
+  std::string host_for_tls(tls_str);
+  std::string connect_addr(addr_str);
+  env->ReleaseStringUTFChars(hostnameForTls, tls_str);
+  env->ReleaseStringUTFChars(connectAddress, addr_str);
+
+  auto client = std::make_unique<QuicClient>(host_for_tls, connect_addr, (uint16_t)port);
+  std::lock_guard<std::mutex> lock(connections_mutex);
+  jlong handle = next_handle++;
+  connections[handle] = std::move(client);
+  return handle;
+}
+
 JNIEXPORT jint JNICALL
 Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeConnect(
     JNIEnv *env, jobject thiz, jlong connHandle) {
@@ -926,4 +991,26 @@ Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeGetLastError(
   return env->NewStringUTF(it->second->last_error());
 }
 
+JNIEXPORT jstring JNICALL
+Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeGetLastResolvedAddress(
+    JNIEnv *env, jobject thiz, jlong connHandle) {
+  std::lock_guard<std::mutex> lock(connections_mutex);
+  auto it = connections.find(connHandle);
+  if (it == connections.end()) {
+    return nullptr;
+  }
+  const std::string &addr = it->second->resolved_address();
+  if (addr.empty()) {
+    return nullptr;
+  }
+  return env->NewStringUTF(addr.c_str());
+}
+
+// Debug-build alias: Kotlin/AGP can mangle the method name to include the module suffix.
+JNIEXPORT jstring JNICALL
+Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeGetLastError_00024annadata_1capacitor_1mqtt_1quic_1debug__J(
+    JNIEnv *env, jobject thiz, jlong connHandle) {
+  return Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeGetLastError(env, thiz, connHandle);
+}
+
 } // extern "C"

package/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt

@@ -13,10 +13,13 @@ import android.system.Os
 import android.util.Base64
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import java.nio.charset.StandardCharsets
 import java.io.File
 import java.io.IOException
+import java.net.InetAddress
 
 /**
  * Capacitor plugin bridge. Phase 3: connect/publish/subscribe call into MQTTClient.
@@ -27,6 +30,29 @@ class MqttQuicPlugin : Plugin() {
     private var client = MQTTClient(MQTTClient.ProtocolVersion.AUTO)
     private val scope = CoroutineScope(Dispatchers.Main)
 
+    /** Last resolved IP per host (used when DNS fails on reconnect). */
+    @Volatile
+    private var lastResolvedHost: String? = null
+    @Volatile
+    private var lastResolvedIp: String? = null
+
+    /** Resolve hostname to IP for socket connect (avoids "No address" on reconnect). Returns null if resolution fails. */
+    private fun resolveHostToIp(host: String): String? {
+        return try {
+            InetAddress.getAllByName(host).firstOrNull()?.hostAddress?.also { ip ->
+                lastResolvedHost = host
+                lastResolvedIp = ip
+            }
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    /** Use cached IP for this host if fresh resolve failed (e.g. on reconnect). */
+    private fun resolveOrCachedIp(host: String): String? {
+        return resolveHostToIp(host) ?: if (host == lastResolvedHost) lastResolvedIp else null
+    }
+
     private fun bundledCaFilePath(): String? {
         return try {
             val assetName = "mqttquic_ca.pem"
@@ -100,9 +126,38 @@ class MqttQuicPlugin : Plugin() {
                         notifyListeners("message", data)
                     }
                 }
-                client.connect(host, port, clientId, username, password, cleanSession, keepalive, sessionExpiryInterval)
-                call.resolve(JSObject().put("connected", true))
-                notifyListeners("connected", JSObject().put("connected", true))
+                // Resolve host to IP on IO so native getaddrinfo gets an IP (avoids "No address associated with hostname" on reconnect)
+                val noAddressMsg = "No address associated with hostname"
+                var lastException: Exception? = null
+                for (attempt in 1..2) {
+                    try {
+                        withContext(Dispatchers.IO) {
+                            val resolvedIp = resolveOrCachedIp(host)
+                            client.connect(host, port, clientId, username, password, cleanSession ?: true, keepalive ?: 20, sessionExpiryInterval, connectAddress = resolvedIp)
+                        }
+                        // Cache resolved IP from native so reconnect can use it when Java DNS fails
+                        client.getLastResolvedAddress()?.let { ip ->
+                            lastResolvedHost = host
+                            lastResolvedIp = ip
+                        }
+                        call.resolve(JSObject().put("connected", true))
+                        notifyListeners("connected", JSObject().put("connected", true))
+                        return@launch
+                    } catch (e: Exception) {
+                        // Cache resolved IP from native even on failure (e.g. CONNACK timeout) so reconnect can use it
+                        client.getLastResolvedAddress()?.let { ip ->
+                            lastResolvedHost = host
+                            lastResolvedIp = ip
+                        }
+                        lastException = e
+                        if (attempt == 1 && e.message?.contains(noAddressMsg, ignoreCase = true) == true) {
+                            delay(2000L)
+                            continue
+                        }
+                        break
+                    }
+                }
+                call.reject(lastException?.message ?: "Connection failed")
             } catch (e: Exception) {
                 call.reject(e.message ?: "Connection failed")
             }
@@ -199,7 +254,7 @@ class MqttQuicPlugin : Plugin() {
                 val properties = mutableMapOf<Int, Any>()
                 messageExpiryInterval?.let { properties[MQTT5PropertyType.MESSAGE_EXPIRY_INTERVAL.toInt()] = it }
                 contentType?.let { properties[MQTT5PropertyType.CONTENT_TYPE.toInt()] = it }
-                client.publish(topic, data, minOf(qos, 2), if (properties.isNotEmpty()) properties else null)
+                client.publish(topic, data, minOf(qos ?: 0, 2), if (properties.isNotEmpty()) properties else null)
                 call.resolve(JSObject().put("success", true))
             } catch (e: Exception) {
                 val msg = e.message ?: "Publish failed"
@@ -226,7 +281,7 @@ class MqttQuicPlugin : Plugin() {
 
         scope.launch {
             try {
-                client.subscribe(topic, minOf(qos, 2), subscriptionIdentifier)
+                client.subscribe(topic, minOf(qos ?: 0, 2), subscriptionIdentifier)
                 call.resolve(JSObject().put("success", true))
             } catch (e: Exception) {
                 call.reject(e.message ?: "Subscribe failed")