@seriousme/opifex 1.11.3 → 2.0.3

package/server/handlers/handlePublish.ts

@@ -1,7 +1,72 @@
-import { SysPrefix } from "../context.ts";
-import { PacketType } from "../deps.ts";
+import { SessionState, SysPrefix } from "../context.ts";
+import {
+  invalidmaxTopicLevels,
+  invalidTopic,
+  logger,
+  PacketType,
+  ReasonCode,
+} from "../deps.ts";
 import type { Context } from "../context.ts";
-import type { PublishPacket, Topic } from "../deps.ts";
+import type {
+  ExtPublishPacket,
+  PacketId,
+  PublishPacket,
+  QoS,
+  Topic,
+  TReasonCode,
+} from "../deps.ts";
+
+const reasonsToDisconnect: TReasonCode[] = [
+  ReasonCode.topicAliasInvalid,
+];
+
+async function handlePublishError(
+  ctx: Context,
+  id: PacketId | undefined,
+  qos: QoS,
+  reasonCode: TReasonCode,
+  reasonString: string,
+) {
+  // in v4 we can only close the connection
+  if (ctx.protocolLevel === 4) {
+    // in V4 we can only close the connection
+    await ctx.close(false);
+    return;
+  }
+  // in v5 we can message the client
+  //
+
+  if (reasonsToDisconnect.includes(reasonCode)) {
+    await ctx.send({
+      type: PacketType.disconnect,
+      protocolLevel: ctx.protocolLevel,
+      reasonCode,
+      properties: {
+        reasonString,
+      },
+    });
+    await ctx.close(false);
+    return;
+  }
+
+  if (qos === 0) {
+    // no message for QoS 0
+    return;
+  }
+  // QoS 1 and 2 get a nice message
+
+  const pType = qos === 1 ? PacketType.puback : PacketType.pubrec;
+  await ctx.send({
+    type: pType,
+    protocolLevel: ctx.protocolLevel,
+    id,
+    reasonCode,
+    properties: {
+      reasonString,
+    },
+  });
+  return;
+}
 
 /**
  * Checks if a client is authorized to publish to a given topic
@@ -9,20 +74,85 @@ import type { PublishPacket, Topic } from "../deps.ts";
  * @param topic - The topic to check authorization for
  * @returns boolean indicating if client is authorized to publish
  */
-function authorizedToPublish(ctx: Context, topic: Topic) {
-  if (topic.startsWith(SysPrefix)) {
+async function authorizedToPublish(ctx: Context, topic: Topic) {
+  if (topic.startsWith(SysPrefix) && !ctx.isBroker) {
+    return false;
+  }
+  if (ctx.state === SessionState.authenticating) {
     return false;
   }
   if (ctx.handlers.isAuthorizedToPublish) {
-    return ctx.handlers.isAuthorizedToPublish(ctx, topic);
+    try {
+      return await ctx.handlers.isAuthorizedToPublish(ctx, topic);
+    } catch (err) {
+      let message = "unknown error";
+      if (err instanceof Error) {
+        message = err.message;
+      }
+      logger.error("isAuthorizedToPublish failed with error", message);
+      return false;
+    }
   }
   return true;
 }
 
+/**
+ * Validates incoming PUBLISH packet rules prior to processing.
+ * Returns an error object if invalid, or null if valid.
+ */
+function validatePublishPacket(
+  ctx: Context,
+  packet: PublishPacket,
+): { reasonCode: TReasonCode; message: string } | null {
+  const cfg = ctx.config.context;
+  const isProtocolV5 = packet.protocolLevel === 5;
+  const hasTopicAlias = isProtocolV5 &&
+    packet.properties?.topicAlias !== undefined;
+
+  if (!cfg.retainAvailable && packet.retain) {
+    return {
+      reasonCode: ReasonCode.unspecifiedError,
+      message: "Server does not support retain",
+    };
+  }
+
+  const isInvalidTopic = (packet.topic.length === 0 && !hasTopicAlias) ||
+    invalidTopic(packet.topic) ||
+    invalidmaxTopicLevels(packet.topic, cfg.maxTopicLevels);
+
+  if (isInvalidTopic) {
+    return {
+      reasonCode: ReasonCode.topicNameInvalid,
+      message: "Invalid topic name",
+    };
+  }
+
+  if (hasTopicAlias) {
+    const topicAlias = packet.properties?.topicAlias;
+    const aliasedTopic = ctx.incomingTopicAliases.get(topicAlias!);
+    if (
+      (topicAlias === 0 || topicAlias! > cfg.topicAliasMaximum) ||
+      (packet.topic === "" && aliasedTopic === undefined)
+    ) {
+      return {
+        reasonCode: ReasonCode.topicAliasInvalid,
+        message: "Invalid topic alias",
+      };
+    }
+    if (packet.topic !== "") {
+      ctx.incomingTopicAliases.set(topicAlias!, packet.topic);
+    } else {
+      packet.topic = aliasedTopic!;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Handles MQTT PUBLISH packets
  * @param ctx - The connection context
- * @param packet - The PUBLISH packet to process
+ * @param extPacket - The PUBLISH packet to process
  * @returns Promise that resolves when packet is processed
  * @throws Error if packet processing fails
  */
@@ -30,30 +160,58 @@ export async function handlePublish(
   ctx: Context,
   packet: PublishPacket,
 ): Promise<void> {
-  if (!authorizedToPublish(ctx, packet.topic)) {
+  const extPacket = packet as ExtPublishPacket;
+  const qos = extPacket.qos || 0;
+  const id = extPacket.id;
+
+  const validationError = validatePublishPacket(ctx, extPacket);
+  if (validationError) {
+    return await handlePublishError(
+      ctx,
+      id,
+      qos,
+      validationError.reasonCode,
+      validationError.message,
+    );
+  }
+
+  if (!await authorizedToPublish(ctx, extPacket.topic)) {
+    await handlePublishError(
+      ctx,
+      id,
+      qos,
+      ReasonCode.notAuthorized,
+      `Client not authorized to publish to ${extPacket.topic}`,
+    );
     return;
   }
 
-  const qos = packet.qos || 0;
+  if (
+    (extPacket.protocolLevel === 5) &&
+    extPacket.properties?.messageExpiryInterval
+  ) {
+    extPacket.expiresAtMs = Date.now() +
+      extPacket.properties.messageExpiryInterval * 1000;
+  }
   if (qos === 0) {
-    ctx.persistence.publish(packet.topic, packet);
+    await ctx.publish(extPacket);
     return;
   }
 
-  if (packet.id !== undefined) {
-    // qos 1
-    if (qos === 1) {
-      const id = packet.id; // retain the id
-      ctx.persistence.publish(packet.topic, packet);
-      await ctx.send({
-        type: PacketType.puback,
-        protocolLevel: ctx.protocolLevel,
-        id,
-      });
-      return;
-    }
+  // qos 1
+  if (qos === 1) {
+    // publish the packet
+    await ctx.publish(extPacket);
+    // send the pubAck
+    await ctx.send({
+      type: PacketType.puback,
+      protocolLevel: ctx.protocolLevel,
+      id: id!,
+    });
+    return;
+  }
 
-    /*
+  /*
 In the QoS 2 delivery protocol, the Receiver
 
 - MUST respond with a PUBREC containing the Packet Identifier from the incoming PUBLISH Packet,
@@ -66,16 +224,12 @@ messages to be delivered to any onward recipients in this case.
 Identifier as being a new publication.
 [MQTT-4.3.3-2].
     */
-    if (ctx.store) {
-      if (!ctx.store.pendingIncoming.has(packet.id)) {
-        ctx.persistence.publish(packet.topic, packet);
-        ctx.store.pendingIncoming.add(packet.id);
-      }
-      await ctx.send({
-        type: PacketType.pubrec,
-        protocolLevel: ctx.protocolLevel,
-        id: packet.id,
-      });
-    }
-  }
+
+  // we take responsibility for the packet
+  await ctx.persistence.addPendingIncomingPacket(ctx.clientId!, extPacket);
+  await ctx.send({
+    type: PacketType.pubrec,
+    protocolLevel: ctx.protocolLevel,
+    id: id!,
+  });
 }

package/server/handlers/handlePubrec.test.ts

@@ -0,0 +1,28 @@
+import { test } from "node:test";
+import type { AnyPacket } from "../deps.ts";
+import { MQTTLevel, PacketType } from "../deps.ts";
+import {
+  connect,
+  disconnect,
+  ping,
+  startMockServer,
+} from "../../dev_utils/mod.ts";
+
+test("PUBREC for unknown packet ID is handled gracefully", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Send PUBREC for non-existent packet ID (no pending outgoing QoS 2 message)
+  const pubrecPacket: AnyPacket = {
+    type: PacketType.pubrec,
+    protocolLevel: MQTTLevel.v4,
+    id: 9999,
+  };
+  mqttConn.send(pubrecPacket);
+
+  // Verify server is still responsive (didn't respond with PUBREL for unknown ID)
+  await ping(mqttConn);
+
+  await disconnect(mqttConn);
+});

package/server/handlers/handlePubrec.ts

@@ -18,9 +18,8 @@ export async function handlePubrec(
   packet: PubrecPacket,
 ): Promise<void> {
   const id = packet.id;
-  if (ctx.store?.pendingOutgoing.has(id)) {
-    ctx.store.pendingOutgoing.delete(id);
-    ctx.store.pendingAckOutgoing.add(id);
+  if (await ctx.processAck(id)) {
+    await ctx.persistence.addPendingAck(ctx.clientId!, id);
     await ctx.send({
       type: PacketType.pubrel,
       protocolLevel: ctx.protocolLevel,

package/server/handlers/handlePubrel.test.ts

@@ -0,0 +1,74 @@
+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, disconnect, startMockServer } from "../../dev_utils/mod.ts";
+
+const txtEncoder = new TextEncoder();
+
+test("PUBREL returns PUBCOMP", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // First send a QoS 2 PUBLISH to set up pending incoming
+  const publishPacket: AnyPacket = {
+    type: PacketType.publish,
+    protocolLevel: MQTTLevel.v4,
+    topic: "test/topic",
+    payload: txtEncoder.encode("qos2"),
+    qos: 2,
+    retain: false,
+    dup: false,
+    id: 1,
+  };
+  mqttConn.send(publishPacket);
+
+  // Should receive PUBREC
+  const { value: pubrec } = await mqttConn.next();
+  assert.deepStrictEqual(pubrec.type, PacketType.pubrec);
+
+  // Now send PUBREL
+  const pubrelPacket: AnyPacket = {
+    type: PacketType.pubrel,
+    protocolLevel: MQTTLevel.v4,
+    id: 1,
+  };
+  mqttConn.send(pubrelPacket);
+
+  // Should receive PUBCOMP
+  const { value: pubcomp } = await mqttConn.next();
+  assert.deepStrictEqual(pubcomp.type, PacketType.pubcomp, "Expected PUBCOMP");
+  if (pubcomp.type === PacketType.pubcomp) {
+    assert.deepStrictEqual(pubcomp.id, 1, "PUBCOMP ID should match PUBREL ID");
+  }
+
+  await disconnect(mqttConn);
+});
+
+test("PUBREL always returns PUBCOMP even without prior PUBREC", async () => {
+  const { mqttConn } = startMockServer();
+
+  await connect(mqttConn);
+
+  // Send PUBREL without prior QoS 2 PUBLISH
+  const pubrelPacket: AnyPacket = {
+    type: PacketType.pubrel,
+    protocolLevel: MQTTLevel.v4,
+    id: 99,
+  };
+  mqttConn.send(pubrelPacket);
+
+  // Should still receive PUBCOMP (MQTT spec requires this)
+  const { value: pubcomp } = await mqttConn.next();
+  assert.deepStrictEqual(
+    pubcomp.type,
+    PacketType.pubcomp,
+    "PUBREL should always receive PUBCOMP response",
+  );
+  if (pubcomp.type === PacketType.pubcomp) {
+    assert.deepStrictEqual(pubcomp.id, 99);
+  }
+
+  await disconnect(mqttConn);
+});

package/server/handlers/handlePubrel.ts

@@ -19,9 +19,19 @@ export async function handlePubrel(
   packet: PubrelPacket,
 ): Promise<void> {
   const id = packet.id;
-  if (ctx.store?.pendingIncoming.has(id)) {
-    ctx.store.pendingIncoming.delete(id);
+
+  const storedPacket = await ctx.persistence.getPendingIncomingPacket(
+    ctx.clientId!,
+    id,
+  );
+
+  if (storedPacket) {
+    // packet is in store
+    // publish the packet
+    await ctx.publish(storedPacket);
+    await ctx.persistence.deletePendingIncomingPacket(ctx.clientId!, id);
   }
+
   await ctx.send({
     type: PacketType.pubcomp,
     protocolLevel: ctx.protocolLevel,