@seriousme/opifex 1.11.3 → 2.1.0

package/server/handlers/handleSubscribe.ts

@@ -1,67 +1,185 @@
+import { SessionState } from "../context.ts";
 import type { Context } from "../context.ts";
-import { PacketType } from "../deps.ts";
-import type { SubscribePacket, Subscription, Topic } from "../deps.ts";
+import {
+  hasWildcards,
+  invalidmaxTopicLevels,
+  invalidTopicFilter,
+  joinTopicFilter,
+  logger,
+  PacketType,
+  parseTopicFilter,
+  ReasonCode,
+} from "../deps.ts";
+import type {
+  ClientSubscription,
+  ShareName,
+  SubscribePacket,
+  Topic,
+} from "../deps.ts";
 
+// V4 Subscription Failure
+const V4SubscriptionFailure = 0x80;
 /**
- * @constant {number} SubscriptionFailure
- * @description Code indicating a failed subscription attempt
+ * Checks if a client is authorized to subscribe to a topic.
  */
-const SubscriptionFailure = 0x80;
+async function authorizedToSubscribe(
+  ctx: Context,
+  topicFilter: Topic,
+  shareName: ShareName,
+): Promise<boolean> {
+  if (ctx.state === SessionState.authenticating) {
+    return false;
+  }
+  try {
+    if (ctx.handlers.isAuthorizedToSubscribe) {
+      return await ctx.handlers.isAuthorizedToSubscribe(
+        ctx,
+        topicFilter,
+        shareName,
+      );
+    }
+  } catch (err) {
+    let message = "unknown error";
+    if (err instanceof Error) {
+      message = err.message;
+    }
+    logger.error("isAuthorizedToSubscribe failed with error", message);
+    return false;
+  }
+  return true;
+}
 
 /**
- * Checks if a client is authorized to subscribe to a topic
- * @param  ctx - The connection context
- * @param  topicFilter - The topic filter to check authorization for
- * @returns True if authorized, false otherwise
+ * Validates a single subscription topic filter against server configuration.
+ * Returns an error ReasonCode if invalid, or null if valid.
  */
-function authorizedToSubscribe(ctx: Context, topicFilter: Topic) {
-  if (ctx.handlers.isAuthorizedToSubscribe) {
-    return ctx.handlers.isAuthorizedToSubscribe(ctx, topicFilter);
+function validateSubscription(
+  isProtocolV5: boolean,
+  sub: ClientSubscription,
+  cfg: Context["config"]["context"],
+): ReasonCode | null {
+  if (
+    cfg.wildcardSubscriptionAvailable === false && hasWildcards(sub.topicFilter)
+  ) {
+    return ReasonCode.wildcardSubscriptionsNotSupported;
   }
-  return true;
+
+  if (sub.shareName !== "") {
+    if (cfg.sharedSubscriptionAvailable === false || !isProtocolV5) {
+      return ReasonCode.sharedSubscriptionsNotSupported;
+    }
+    // noLocal is not allowed on shared subscriptions
+    if (sub.noLocal) {
+      return ReasonCode.topicFilterInvalid;
+    }
+  }
+
+  if (
+    sub.topicFilter.length === 0 ||
+    invalidTopicFilter(sub.topicFilter) ||
+    invalidmaxTopicLevels(sub.topicFilter, cfg.maxTopicLevels)
+  ) {
+    return ReasonCode.topicFilterInvalid;
+  }
+
+  return null;
 }
 
 /**
- * @function handleSubscribe
- * @description Processes an MQTT SUBSCRIBE packet
- * @param {Context} ctx - The connection context
- * @param {SubscribePacket} packet - The SUBSCRIBE packet received from the client
- * @returns {Promise<void>}
- * @throws {Error} If subscription processing fails
+ * Processes an MQTT SUBSCRIBE packet.
  * @remarks The order of return codes in the SUBACK Packet MUST match the order of Topic Filters in the SUBSCRIBE Packet [MQTT-3.9.3-1]
  */
 export async function handleSubscribe(
   ctx: Context,
   packet: SubscribePacket,
 ): Promise<void> {
-  /*
-   * The order of return codes in the SUBACK Packet MUST match the order of
-   * Topic Filters in the SUBSCRIBE Packet [MQTT-3.9.3-1].
-   */
-  const validSubscriptions: Subscription[] = [];
-  const returnCodes = packet.subscriptions.map((sub) => {
-    if (ctx.store) {
-      if (!authorizedToSubscribe(ctx, sub.topicFilter)) {
-        return SubscriptionFailure;
+  const cfg = ctx.config.context;
+  const isProtocolV5 = packet.protocolLevel === 5;
+
+  const subscriptionIdentifier = isProtocolV5
+    ? packet.properties?.subscriptionIdentifier
+    : undefined;
+
+  // Pre-fetch existing subscriptions to evaluate Retain Handling logic (retainHandling === 1)
+  const existingTopicFilters = new Set();
+  for await (const sub of ctx.persistence.listSubscriptions(ctx.clientId!)) {
+    existingTopicFilters.add(joinTopicFilter(sub.topicFilter, sub.shareName));
+  }
+
+  const retainedSubscriptions: ClientSubscription[] = [];
+  const results: ReasonCode[] = [];
+
+  for (const sub of packet.subscriptions) {
+    const clientSub = sub as ClientSubscription;
+    // split topicFilter into topicFilter and shareName
+    const { topicFilter, shareName } = parseTopicFilter(
+      sub.topicFilter,
+    );
+    clientSub.topicFilter = topicFilter;
+    clientSub.shareName = shareName;
+    // TopicFilter Validation
+    const validationError = validateSubscription(isProtocolV5, clientSub, cfg);
+    if (validationError !== null) {
+      if (!isProtocolV5) {
+        await ctx.close(false);
+        return;
       }
-      ctx.persistence.subscribe(ctx.store, sub.topicFilter, sub.qos);
-      validSubscriptions.push(sub);
-      return sub.qos;
+      results.push(validationError);
+      continue;
     }
-    return SubscriptionFailure;
-  });
 
+    // Authorization Check
+    if (
+      !await authorizedToSubscribe(
+        ctx,
+        clientSub.topicFilter,
+        clientSub.shareName,
+      )
+    ) {
+      results.push(
+        isProtocolV5 ? ReasonCode.notAuthorized : V4SubscriptionFailure,
+      );
+      continue;
+    }
+
+    // Register Subscription
+    const filterKey = sub.topicFilter;
+    const isNewSubscription = !existingTopicFilters.has(filterKey);
+
+    if (subscriptionIdentifier) {
+      clientSub.subscriptionIdentifier = subscriptionIdentifier;
+    }
+    await ctx.persistence.subscribe(
+      ctx.clientId!,
+      clientSub,
+    );
+
+    existingTopicFilters.add(filterKey);
+
+    // Collect Subscriptions Requiring Retained Messages
+    if (
+      clientSub.retainHandling !== 2 &&
+      (clientSub.retainHandling !== 1 || isNewSubscription)
+    ) {
+      retainedSubscriptions.push(clientSub);
+    }
+
+    // Success code (Granted QoS)
+    results.push(sub.qos as ReasonCode);
+  }
+
+  // Send SUBACK response
   await ctx.send({
     type: PacketType.suback,
     protocolLevel: ctx.protocolLevel,
     id: packet.id,
-    returnCodes: returnCodes,
+    ...(isProtocolV5
+      ? { reasonCodes: results }
+      : { returnCodes: results as number[] }),
   });
 
-  /*
-   * send any retained messages that match these subscriptions
-   */
-  if (ctx.store) {
-    ctx.persistence.handleRetained(ctx.store.clientId);
+  // Dispatch matching retained messages
+  if (retainedSubscriptions.length > 0) {
+    await ctx.persistence.handleRetained(ctx.clientId!, retainedSubscriptions);
   }
 }

package/server/handlers/handleUnsubscribe.test.ts

@@ -0,0 +1,79 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  connect,
+  connect5,
+  disconnect,
+  disconnect5,
+  startMockServer,
+  subscribe,
+  subscribe5,
+  unsubscribe,
+  unsubscribe5,
+} from "../../dev_utils/mod.ts";
+import { ReasonCode } from "../deps.ts";
+
+test("UNSUBSCRIBE returns UNSUBACK", async () => {
+  const { mqttConn } = startMockServer();
+
+  // Connect first
+  await connect(mqttConn);
+
+  // Subscribe first
+  await subscribe(mqttConn, [{ topicFilter: "test/topic", qos: 0 }]);
+
+  // Unsubscribe
+  await unsubscribe(mqttConn, ["test/topic"], { id: 2 });
+  await disconnect(mqttConn);
+});
+
+test("UNSUBSCRIBE from multiple topics returns UNSUBACK", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Subscribe to multiple topics
+  await subscribe(mqttConn, [
+    { topicFilter: "topic/one", qos: 0 },
+    { topicFilter: "topic/two", qos: 0 },
+  ]);
+
+  // Unsubscribe from both
+  await unsubscribe(mqttConn, ["topic/one", "topic/two"], { id: 3 });
+  await disconnect(mqttConn);
+});
+
+test("UNSUBSCRIBE from non-existent subscription still returns UNSUBACK", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Unsubscribe without subscribing first,should still get a SUBACK
+  await unsubscribe(mqttConn, ["nonexistent/topic"], { id: 3 });
+  await disconnect(mqttConn);
+});
+
+test("V5 UNSUBSCRIBE from multiple subscriptions gives correct reasonCodes", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect5(mqttConn);
+  // Subscribe to multiple topics
+  await subscribe5(mqttConn, [
+    { topicFilter: "topic/one", qos: 0 },
+    { topicFilter: "topic/two", qos: 0 },
+  ]);
+
+  const unsuback = await unsubscribe5(mqttConn, [
+    "topic/one",
+    "topic/two",
+    "nonexistent/topic",
+  ], { id: 3 });
+  assert.equal(unsuback.protocolLevel, 5, "V5 packet");
+  assert.deepStrictEqual(unsuback.reasonCodes, [
+    ReasonCode.success,
+    ReasonCode.success,
+    ReasonCode.noSubscriptionExisted,
+  ]);
+
+  await disconnect5(mqttConn);
+});

package/server/handlers/handleUnsubscribe.ts

@@ -1,5 +1,11 @@
-import { PacketType } from "../deps.ts";
+import {
+  joinTopicFilter,
+  PacketType,
+  parseTopicFilter,
+  ReasonCode,
+} from "../deps.ts";
 import type { UnsubscribePacket } from "../deps.ts";
+import { SessionState } from "../context.ts";
 import type { Context } from "../context.ts";
 
 /**
@@ -12,14 +18,32 @@ export async function handleUnsubscribe(
   ctx: Context,
   packet: UnsubscribePacket,
 ): Promise<void> {
-  for (const topic of packet.topicFilters) {
-    if (ctx.store) {
-      ctx.persistence.unsubscribe(ctx.store, topic);
+  // this is v5 only, no unsubscriptions while reauthenticating
+  const isAuthenticating = ctx.state === SessionState.authenticating;
+
+  const subscriptions = new Set();
+  for await (const sub of ctx.persistence.listSubscriptions(ctx.clientId!)) {
+    subscriptions.add(joinTopicFilter(sub.topicFilter, sub.shareName));
+  }
+
+  const reasonCodes: ReasonCode[] = [];
+
+  for (const packetTopicFilter of packet.topicFilters) {
+    // split topicFilter into topicFilter and shareName
+    const { topicFilter, shareName } = parseTopicFilter(
+      packetTopicFilter,
+    );
+    if (subscriptions.has(packetTopicFilter) && !isAuthenticating) {
+      reasonCodes.push(ReasonCode.success);
+      await ctx.persistence.unsubscribe(ctx.clientId!, topicFilter, shareName);
+    } else {
+      reasonCodes.push(ReasonCode.noSubscriptionExisted);
     }
   }
   await ctx.send({
     type: PacketType.unsuback,
     id: packet.id,
     protocolLevel: ctx.protocolLevel,
+    reasonCodes,
   });
 }

package/server/handlers/keepalive.test.ts

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import type { AnyPacket } from "../deps.ts";
+import { MQTTLevel, PacketType } from "../deps.ts";
+import {
+  connect,
+  delay,
+  disconnect,
+  ping,
+  startMockServer,
+} from "../../dev_utils/mod.ts";
+
+const txtEncoder = new TextEncoder();
+
+const publishPacket: AnyPacket = {
+  type: PacketType.publish,
+  protocolLevel: MQTTLevel.v4,
+  topic: "test/topic",
+  payload: txtEncoder.encode("test payload"),
+  qos: 0,
+  retain: false,
+  dup: false,
+  id: 0,
+};
+
+test("MQTT-3.1.2.10: connection stays alive with PINGREQ", {
+  concurrency: false,
+}, async () => {
+  const { mqttConn } = startMockServer();
+  const keepAlive = 1; // 1 second -> 1500ms timeout
+
+  // Connect with keepAlive
+  await connect(mqttConn, { clientId: "keepaliveTest1", keepAlive });
+
+  // Wait for 750ms (half the timeout period)
+  await delay(750);
+
+  // Send PINGREQ to reset timer
+  await ping(mqttConn);
+
+  // Wait another 750ms (total 1500ms from start, but timer was reset at 750ms)
+  await delay(750);
+
+  // Connection should still be alive
+  assert.deepStrictEqual(
+    mqttConn.isClosed,
+    false,
+    "Connection should stay alive after PINGREQ resets timer",
+  );
+
+  // Cleanup
+  await disconnect(mqttConn);
+});
+
+test("MQTT-3.1.2.10: connection closes after 1.5x keepAlive timeout", {
+  concurrency: false,
+}, async () => {
+  const { mqttConn } = startMockServer();
+  const keepAlive = 1; // 1 second -> 1500ms timeout
+
+  // Connect with keepAlive
+  await connect(mqttConn, { clientId: "keepaliveTest2", keepAlive });
+
+  // Wait for timeout to expire (1500ms + buffer)
+  await delay(1600);
+
+  // flush state
+  await mqttConn.next();
+
+  // Connection should be closed
+  assert.deepStrictEqual(
+    mqttConn.isClosed,
+    true,
+    "Connection should close after keepAlive timeout expires",
+  );
+});
+
+test(
+  "MQTT-3.1.2.10: any packet resets keepAlive timer",
+  { concurrency: false },
+  async () => {
+    const { mqttConn } = startMockServer();
+    const keepAlive = 1; // 1 second -> 1500ms timeout
+
+    // Connect with keepAlive
+    await connect(mqttConn, { clientId: "keepaliveTest3", keepAlive });
+
+    // Wait for 750ms (half timeout)
+    await delay(750);
+
+    // Send PUBLISH packet (not PINGREQ) to reset timer
+    mqttConn.send(publishPacket);
+
+    // Wait another 750ms (total 1500ms from start, but timer was reset at 750ms)
+    await delay(750);
+
+    // Connection should still be alive
+    assert.deepStrictEqual(
+      mqttConn.isClosed,
+      false,
+      "Connection should stay alive - any packet should reset timer",
+    );
+
+    // Cleanup
+    await disconnect(mqttConn);
+  },
+);
+
+test(
+  "MQTT-3.1.2.10: keepAlive=0 disables timeout",
+  { concurrency: false },
+  async () => {
+    const { mqttConn } = startMockServer();
+    const keepAlive = 0; // 0 means no timeout
+
+    // Connect with keepAlive=0
+    await connect(mqttConn, { clientId: "keepaliveTest4", keepAlive });
+
+    // Wait longer than any reasonable timeout
+    await delay(2000);
+
+    // Connection should still be open
+    assert.deepStrictEqual(
+      mqttConn.isClosed,
+      false,
+      "Connection should remain open when keepAlive=0",
+    );
+
+    // Cleanup
+    await disconnect(mqttConn);
+  },
+);

package/server/handlers/session.persistence.test.ts

@@ -0,0 +1,194 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { PacketType } from "../deps.ts";
+import {
+  addMockClient,
+  connect,
+  disconnect,
+  startMockServer,
+  subscribe,
+} from "../../dev_utils/mod.ts";
+
+test("sessionPresent is false for new client", async () => {
+  const { mqttConn } = startMockServer();
+
+  const connack = await connect(mqttConn, {
+    clientId: "new-client",
+    clean: false,
+  });
+
+  assert.deepStrictEqual(
+    connack.sessionPresent,
+    false,
+    "Expected sessionPresent=false for new client",
+  );
+
+  await disconnect(mqttConn);
+});
+
+test("sessionPresent is true when reconnecting with same clientId and clean=false", async () => {
+  const { mqttConn: mqttConn1, mqttServer } = startMockServer();
+
+  const clientId = "persist-client";
+  // First connection
+  const connack1 = await connect(mqttConn1, {
+    clientId,
+    clean: false,
+  });
+
+  if (connack1.type === PacketType.connack) {
+    assert.deepStrictEqual(
+      connack1.sessionPresent,
+      false,
+      "Expected sessionPresent=false for first connection",
+    );
+  }
+  await disconnect(mqttConn1);
+
+  // Second connection with same clientId and clean=false
+  const mqttConn2 = addMockClient(mqttServer);
+  const connack2 = await connect(mqttConn2, {
+    clientId,
+    clean: false,
+  });
+
+  assert.deepStrictEqual(
+    connack2.sessionPresent,
+    true,
+    "Expected sessionPresent=true for reconnection with clean=false",
+  );
+  await disconnect(mqttConn2);
+});
+
+test("subscriptions persist with clean=false", async () => {
+  function subsMap(subs: { topicFilter: string; qos: number }[]) {
+    const result = new Map();
+    for (const { topicFilter, qos } of subs) {
+      result.set(topicFilter, qos);
+    }
+    return result;
+  }
+  const { mqttConn: mqttConn1, mqttServer } = startMockServer();
+  const clientId = "subscription-persist-client";
+
+  // First connection
+  await connect(mqttConn1, {
+    clientId,
+    clean: false,
+  });
+
+  await subscribe(mqttConn1, [
+    { topicFilter: "sensors/temperature", qos: 1 },
+    { topicFilter: "sensors/humidity", qos: 2 },
+  ], { id: 1 });
+  await disconnect(mqttConn1);
+
+  // Verify subscriptions are stored
+  const client1Subs = await Array.fromAsync(
+    mqttServer.persistence.listSubscriptions(clientId),
+  );
+  assert.strictEqual(
+    client1Subs.length,
+    2,
+    "Expected 2 subscriptions after first connection",
+  );
+  const client1subsMap = subsMap(client1Subs);
+  assert.strictEqual(
+    client1subsMap.get("sensors/temperature"),
+    1,
+    "Expected sensors/temperature with QoS 1",
+  );
+  assert.strictEqual(
+    client1subsMap.get("sensors/humidity"),
+    2,
+    "Expected sensors/humidity with QoS 2",
+  );
+
+  // Second connection with clean=false
+  const mqttConn2 = addMockClient(mqttServer);
+  const connack2 = await connect(mqttConn2, {
+    clientId,
+    clean: false,
+  });
+
+  if (connack2.type === PacketType.connack) {
+    assert.deepStrictEqual(
+      connack2.sessionPresent,
+      true,
+      "Expected sessionPresent=true on reconnection",
+    );
+  }
+
+  // Verify subscriptions are restored
+  const client2Subs = await Array.fromAsync(
+    mqttServer.persistence.listSubscriptions(clientId),
+  );
+  assert.strictEqual(
+    client1Subs.length,
+    2,
+    "Expected 2 subscriptions after reconnection",
+  );
+  const client2subsMap = subsMap(client2Subs);
+  assert.strictEqual(
+    client2subsMap.get("sensors/temperature"),
+    1,
+    "Expected sensors/temperature with QoS 1",
+  );
+  assert.strictEqual(
+    client2subsMap.get("sensors/humidity"),
+    2,
+    "Expected sensors/humidity with QoS 2",
+  );
+
+  await disconnect(mqttConn2);
+});
+
+test("subscriptions cleared with clean=true", async () => {
+  const { mqttConn: mqttConn1, mqttServer } = startMockServer();
+  const clientId = "clean-client";
+
+  // First connection - subscribe to topics
+  await connect(mqttConn1, {
+    clientId,
+    clean: false,
+  });
+
+  await subscribe(mqttConn1, [{ topicFilter: "device/status", qos: 0 }], {
+    id: 1,
+  });
+  await disconnect(mqttConn1);
+
+  // Verify subscriptions are stored
+  const storedSubs = await Array.fromAsync(
+    mqttServer.persistence.listSubscriptions(clientId),
+  );
+  assert.strictEqual(
+    storedSubs.length,
+    1,
+    "Expected 1 subscription after first connection",
+  );
+
+  // Second connection with clean=true
+  const mqttConn2 = addMockClient(mqttServer);
+  const connack2 = await connect(mqttConn2, {
+    clientId,
+    clean: true,
+  });
+
+  assert.deepStrictEqual(
+    connack2.sessionPresent,
+    false,
+    "Expected sessionPresent=false when clean=true",
+  );
+
+  const cleanedSubs = await Array.fromAsync(
+    mqttServer.persistence.listSubscriptions(clientId),
+  );
+  assert.strictEqual(
+    cleanedSubs.length,
+    0,
+    "Expected subscriptions to be cleared with clean=true",
+  );
+
+  await disconnect(mqttConn2);
+});