@seriousme/opifex 1.9.4 → 1.11.0

package/mqttPacket/suback.test.ts

@@ -1,16 +1,30 @@
-import { PacketType } from "./PacketType.ts";
 import assert from "node:assert/strict";
 import { test } from "node:test";
+import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
+import type { CodecOpts } from "./mod.ts";
 
-import { decode, encode } from "./mod.ts";
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
 
-test("encode Suback", () => {
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("encode/decode Suback v4", () => {
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: MQTTLevel.v4,
+    id: 1,
+    returnCodes: [0, 1],
+  };
+  const encoded = encode(packet, codecOptsV4);
   assert.deepStrictEqual(
-    encode({
-      type: PacketType.suback,
-      id: 1,
-      returnCodes: [0, 1],
-    }),
+    encoded,
     Uint8Array.from([
       // fixedHeader
       0x90, // packetType + flags
@@ -23,27 +37,57 @@ test("encode Suback", () => {
       1,
     ]),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
-test("decode Suback", () => {
-  assert.deepStrictEqual(
-    decode(
-      Uint8Array.from([
-        // fixedHeader
-        0x90, // packetType + flags
-        4, // remainingLength
-        // variableHeader
-        0, // id MSB
-        1, // id LSB
-        // payload
-        0,
-        1,
-      ]),
-    ),
-    {
-      type: PacketType.suback,
-      id: 1,
-      returnCodes: [0, 1],
+test("encode/decode Suback v5", () => {
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: MQTTLevel.v5,
+    id: 1,
+    reasonCodes: [ReasonCode.grantedQos0, ReasonCode.grantedQos1],
+    properties: {
+      reasonString: "reason",
+      userProperty: [["test", "test"]],
     },
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+      144, // packetType + flags
+      27, // remaining length
+      0, // id MSB
+      1, // id LSB
+      22, // propertysize
+      31, // reason string
+      0, // string length MSB
+      6, // string length LSB
+      114, // r
+      101, // e
+      97, // a
+      115, // s
+      111, // o
+      110, // n
+      38, // user property
+      0, // string length MSB
+      4, // string length LSB
+      116, // t
+      101, // e
+      115, // s
+      116, // t
+      0, // string length MSB
+      4, // string length LSB
+      116, // t
+      101, // e
+      115, // s
+      116, // t
+      0, // return code
+      1, // return code
+    ]),
   );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, packet);
 });

package/mqttPacket/suback.ts

@@ -1,48 +1,100 @@
-import type { PacketId, ReturnCodes, TPacketType } from "./types.ts";
+import type {
+  CodecOpts,
+  PacketId,
+  ProtocolLevelNoV5,
+  ReturnCodes,
+  TPacketType,
+  TReasonCode,
+} from "./types.ts";
+import type { SubackProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { Encoder } from "./encoder.ts";
-import { Decoder } from "./decoder.ts";
+import { Decoder, DecoderError } from "./decoder.ts";
+const validReturnCodes = [0x00, 0x01, 0x02, 0x80];
 
-/**
- * SubackPacket is sent by the server to the client to confirm receipt and
- * processing of a SubscribePacket.
- */
-export type SubackPacket = {
+export type SubackPacketV4 = {
   type: TPacketType;
+  protocolLevel: ProtocolLevelNoV5;
   id: PacketId;
   returnCodes: ReturnCodes;
 };
 
+export type SubackPacketV5 = {
+  type: TPacketType;
+  protocolLevel: 5;
+  id: PacketId;
+  properties: SubackProperties;
+  reasonCodes: Array<TReasonCode>;
+};
+
+/**
+ * SubackPacket is sent by the server to the client to confirm receipt and
+ * processing of a SubscribePacket.
+ */
+export type SubackPacket = SubackPacketV4 | SubackPacketV5;
+
 export const suback: {
-  encode(packet: SubackPacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array): SubackPacket;
+  encode(packet: SubackPacket, _codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): SubackPacket;
 } = {
-  encode(packet: SubackPacket): { flags: number; bytes: number[] } {
+  encode(packet: SubackPacket, codecOpts: CodecOpts): Uint8Array {
     const flags = 0;
-    const encoder = new Encoder();
+    const encoder = new Encoder(packet.type);
     encoder.setInt16(packet.id);
-    encoder.setRemainder(packet.returnCodes);
-
-    return {
-      flags,
-      bytes: encoder.done(),
-    };
+    if (packet.protocolLevel !== 5) {
+      for (const code of packet.returnCodes) {
+        if (!validReturnCodes.includes(code)) {
+          throw new Error("Invalid return code");
+        }
+      }
+      encoder.setRemainder(packet.returnCodes);
+      return encoder.done(flags);
+    }
+    encoder.setProperties(
+      packet.properties || {},
+      packet.type,
+      codecOpts.maxOutgoingPacketSize,
+    );
+    for (const code of packet.reasonCodes) {
+      encoder.setReasonCode(code);
+    }
+    return encoder.done(flags);
   },
 
-  decode(buffer: Uint8Array): SubackPacket {
-    const decoder = new Decoder(buffer);
-    const id = decoder.getInt16();
-    const payload = decoder.getRemainder();
-    const returnCodes = [];
+  decode(
+    buffer: Uint8Array,
+    _flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): SubackPacket {
+    const packet = {} as SubackPacket;
+    const decoder = new Decoder(packetType, buffer);
+    packet.type = PacketType.suback;
+    packet.id = decoder.getInt16();
+    packet.protocolLevel = codecOpts.protocolLevel;
 
-    for (const code of payload) {
-      returnCodes.push(code);
+    if (packet.protocolLevel !== 5) {
+      const payload = decoder.getRemainder();
+      packet.returnCodes = [];
+      for (const code of payload) {
+        if (!validReturnCodes.includes(code)) {
+          throw new DecoderError("Invalid return code");
+        }
+        packet.returnCodes.push(code);
+      }
+      return packet;
     }
-
-    return {
-      type: PacketType.suback,
-      id,
-      returnCodes,
-    };
+    packet.properties = decoder.getProperties(PacketType.suback);
+    packet.reasonCodes = [];
+    while (!decoder.atEnd()) {
+      const code = decoder.getReasonCode();
+      packet.reasonCodes.push(code);
+    }
+    return packet;
   },
 };

package/mqttPacket/subscribe.test.ts

@@ -2,18 +2,34 @@ import { PacketType } from "./PacketType.ts";
 import assert from "node:assert/strict";
 import { test } from "node:test";
 
-import { decode, encode } from "./mod.ts";
+import { decode, encode, MQTTLevel, RetainHandling } from "./mod.ts";
+import type { CodecOpts } from "./mod.ts";
 
-test("encode Subscribe", () => {
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("encode/decode Subscribe v4", () => {
+  const packet = {
+    type: PacketType.subscribe,
+    protocolLevel: MQTTLevel.v4,
+    id: 1,
+    subscriptions: [
+      { topicFilter: "a/b", qos: 0 },
+      { topicFilter: "c/d", qos: 1 },
+    ],
+  };
+  const encoded = encode(packet, codecOptsV4);
   assert.deepStrictEqual(
-    encode({
-      type: PacketType.subscribe,
-      id: 1,
-      subscriptions: [
-        { topicFilter: "a/b", qos: 0 },
-        { topicFilter: "c/d", qos: 1 },
-      ],
-    }),
+    encoded,
     Uint8Array.from([
       // fixedHeader
       0x82, // packetType + flags
@@ -36,45 +52,75 @@ test("encode Subscribe", () => {
       1, // qos
     ]),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
-test("decode Subscribe", () => {
-  assert.deepStrictEqual(
-    decode(
-      Uint8Array.from([
-        // fixedHeader
-        0x82, // packetType + flags
-        14, // remainingLength
-        // variableHeader
-        0, // id MSB
-        1, // id LSB
-        // payload
-        0, // topic filter length MSB
-        3, // topic filter length LSB
-        97, // 'a'
-        47, // '/'
-        98, // 'b'
-        0, // qos
-        0, // topic filter length MSB
-        3, // topic filter length LSB
-        99, // 'c'
-        47, // '/'
-        100, // 'd'
-        1, // qos
-      ]),
-    ),
-    {
-      type: PacketType.subscribe,
-      id: 1,
-      subscriptions: [
-        { topicFilter: "a/b", qos: 0 },
-        { topicFilter: "c/d", qos: 1 },
-      ],
+test("encode/decode Subscribe v5", () => {
+  const packet = {
+    type: PacketType.subscribe,
+    protocolLevel: MQTTLevel.v5,
+    id: 1,
+    subscriptions: [
+      { topicFilter: "a/b", qos: 0 },
+      {
+        topicFilter: "c/d",
+        qos: 2,
+        noLocal: true,
+        retainAsPublished: true,
+        retainHandling: RetainHandling.noRetain,
+      },
+    ],
+    properties: {
+      subscriptionIdentifier: 123,
     },
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+      0x82, // packetType + flags
+      17, // remainingLength
+      // variableHeader
+      0, // id MSB
+      1, // id LSB
+      2, // propertyLength
+      11, // subscription identifier
+      123, // 123
+      // payload
+      0, // topic filter length MSB
+      3, // topic filter length LSB
+      97, // 'a'
+      47, // '/'
+      98, // 'b'
+      0, // options
+      0, // topic filter length MSB
+      3, // topic filter length LSB
+      99, // 'c'
+      47, // '/'
+      100, // 'd'
+      46, // options 0b101110
+    ]),
   );
+  const decoded = decode(encoded, codecOptsV5);
+  // add the defaults for comparison
+  const packetWithDefaults = {
+    ...packet,
+    subscriptions: [
+      {
+        ...packet.subscriptions[0],
+        noLocal: false,
+        retainAsPublished: false,
+        retainHandling: RetainHandling.sendRetained,
+      },
+      { ...packet.subscriptions[1] },
+    ],
+  };
+  assert.deepStrictEqual(decoded, packetWithDefaults);
 });
 
-test("decode Subscribe missing bit 1 flag", () => {
+test("decode Subscribe v4 missing bit 1 flag", () => {
   assert.throws(
     () =>
       decode(
@@ -99,6 +145,7 @@ test("decode Subscribe missing bit 1 flag", () => {
           100, // 'd'
           1, // qos
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid header",
@@ -129,6 +176,7 @@ test("decode Subscribe packet too short", () => {
           47, // '/'
           1, // qos
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid qos",
@@ -154,6 +202,7 @@ test("decode Subscribe packet too short", () => {
           3, // topic filter length LSB
           99, // 'c'
         ]),
+        codecOptsV4,
       ),
     Error,
     "too short",
@@ -169,6 +218,7 @@ test("decode Subscribe packet too short", () => {
           0, // id MSB
           1, // id LSB
         ]),
+        codecOptsV4,
       ),
     Error,
     "too short",
@@ -199,6 +249,7 @@ test("decode Subscribe packet invalid packet id with QoS > 0", () => {
           47, // '/'
           1, // qos
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid packet identifier",
@@ -226,8 +277,46 @@ test("decode Subscribe packet invalid packet id with QoS > 0", () => {
           47, // '/'
           2, // qos
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid packet identifier",
   );
 });
+
+test("decode Subscribe v5 with invalid subscription options", () => {
+  for (
+    const item of [
+      [0b10000000, /Invalid subscription options/], // bit 7 must be 0
+      [0b1000000, /Invalid subscription options/], // bit 6 must be 0
+      [0b110000, /Invalid retain handling/], // retain handling can't be 3
+      [0b100011, /Invalid qos/], // qos can't be 3
+    ]
+  ) {
+    const [options, err] = item as [number, RegExp];
+    assert.throws(
+      () =>
+        decode(
+          Uint8Array.from([
+            // fixedHeader
+            0x82, // packetType + flags
+            9, // remainingLength
+            // variableHeader
+            0, // id MSB
+            1, // id LSB
+            0, // propertyLength
+            // payload
+            0, // topic filter length MSB
+            3, // topic filter length LSB
+            97, // 'a'
+            47, // '/'
+            98, // 'b'
+            options, // options
+          ]),
+          codecOptsV5,
+        ),
+      err,
+      "Invalid subscription options",
+    );
+  }
+});

package/mqttPacket/subscribe.ts

@@ -1,78 +1,181 @@
-import type { PacketId, QoS, TopicFilter, TPacketType } from "./types.ts";
+import type {
+  CodecOpts,
+  PacketId,
+  ProtocolLevelNoV5,
+  QoS,
+  TopicFilter,
+  TPacketType,
+  TRetainHandling,
+} from "./types.ts";
+import type { SubscribeProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { BitMask } from "./BitMask.ts";
 import { Encoder } from "./encoder.ts";
 import { booleanFlag, Decoder, DecoderError } from "./decoder.ts";
 
-/**
- * SubscribePacket is sent from client to server to subscribe to topics
- */
-export type SubscribePacket = {
+export type SubscribePacketV4 = {
   type: TPacketType;
+  protocolLevel: ProtocolLevelNoV5;
   id: PacketId;
-  subscriptions: Subscription[];
+  subscriptions: Array<SubscriptionV4>;
+};
+
+export type SubscribePacketV5 = {
+  type: TPacketType;
+  protocolLevel: 5;
+  id: PacketId;
+  properties?: SubscribeProperties;
+  subscriptions: Array<SubscriptionV5>;
 };
 
+/**
+ * SubscribePacket is sent from client to server to subscribe to topics
+ */
+export type SubscribePacket = SubscribePacketV4 | SubscribePacketV5;
 /**
  * The topic to subscribe to and the associated QoS
  */
-export type Subscription = {
+export type SubscriptionV4 = {
   topicFilter: TopicFilter;
   qos: QoS;
 };
 
+export type SubscriptionV5 = {
+  topicFilter: TopicFilter;
+  qos: QoS;
+  noLocal?: boolean;
+  retainAsPublished?: boolean;
+  retainHandling?: TRetainHandling;
+};
+
+export type Subscription = SubscriptionV4 | SubscriptionV5;
+
 export const subscribe: {
-  encode(packet: SubscribePacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array, flags: number): SubscribePacket;
+  encode(packet: SubscribePacket, codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): SubscribePacket;
 } = {
-  encode(packet: SubscribePacket): { flags: number; bytes: number[] } {
+  encode(packet: SubscribePacket, codecOpts: CodecOpts): Uint8Array {
     // Bits 3,2,1 and 0 of the fixed header of the SUBSCRIBE Control Packet are reserved and
     // MUST be set to 0,0,1 and 0 respectively. The Server MUST treat any other value as
     // malformed and close the Network Connection [MQTT-3.8.1-1].
     const flags = 0b0010;
 
-    const encoder = new Encoder();
+    const encoder = new Encoder(packet.type);
     encoder.setInt16(packet.id);
+    if (packet.protocolLevel === 5) {
+      encoder.setProperties(
+        packet.properties || {},
+        packet.type,
+        codecOpts.maxOutgoingPacketSize,
+      );
+    }
     for (const sub of packet.subscriptions) {
-      encoder.setTopic(sub.topicFilter);
-      encoder.setByte(sub.qos);
+      encoder.setTopicFilter(sub.topicFilter);
+      if (packet.protocolLevel === 5) {
+        const {
+          qos,
+          noLocal = false,
+          retainAsPublished = false,
+          retainHandling = 0,
+        } = sub as SubscriptionV5;
+        const option = (qos & 1 ? BitMask.bit0 : 0) +
+          (qos & 2 ? BitMask.bit1 : 0) +
+          (noLocal ? BitMask.bit2 : 0) +
+          (retainAsPublished ? BitMask.bit3 : 0) +
+          ((retainHandling as number) & 1 ? BitMask.bit4 : 0) +
+          ((retainHandling as number) & 2 ? BitMask.bit5 : 0);
+        encoder.setByte(option);
+      } else {
+        encoder.setByte(sub.qos);
+      }
     }
-    return { flags, bytes: encoder.done() };
+    return encoder.done(flags);
   },
 
-  decode(buffer: Uint8Array, flags: number): SubscribePacket {
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): SubscribePacket {
     // Bits 3,2,1 and 0 of the fixed header of the SUBSCRIBE Control Packet are reserved and
     // MUST be set to 0,0,1 and 0 respectively. The Server MUST treat any other value as
     // malformed and close the Network Connection [MQTT-3.8.1-1].
-    if (!booleanFlag(flags, BitMask.bit1)) {
+    if (flags !== 0b0010) {
       throw new DecoderError("Invalid header");
     }
-
-    const decoder = new Decoder(buffer);
+    const decoder = new Decoder(packetType, buffer);
     const id = decoder.getInt16();
+    let properties = {};
+    if (codecOpts.protocolLevel === 5) {
+      properties = decoder.getProperties(PacketType.subscribe);
+    }
 
     const subscriptions: Subscription[] = [];
-    // The payload of a SUBSCRIBE packet MUST contain at least one Topic Filter / QoS pair.
+    // The payload of a SUBSCRIBE packet MUST contain at least one Topic Filter / Option pair.
     // A SUBSCRIBE packet with no payload is a protocol violation [MQTT-3.8.3-3].
     do {
       const topicFilter = decoder.getTopicFilter();
-      const qos = decoder.getByte();
+      const option = decoder.getByte();
+      const qos = option & 0b11;
       if (qos !== 0 && qos !== 1 && qos !== 2) {
         throw new DecoderError("Invalid qos");
       }
       if (qos > 0 && id === 0) {
         throw new DecoderError("Invalid packet identifier");
       }
-      subscriptions.push({
-        topicFilter: topicFilter,
-        qos,
-      });
+      if (codecOpts.protocolLevel !== 5) {
+        if (option !== qos) {
+          throw new DecoderError("Invalid qos");
+        }
+        subscriptions.push({
+          topicFilter: topicFilter,
+          qos,
+        } as SubscriptionV4);
+      } else {
+        // Bits 6 and 7 of the Subscription Options byte are reserved for future use.
+        // The Server MUST treat a SUBSCRIBE packet as malformed if any of
+        // Reserved bits in the Payload are non-zero [MQTT-3.8.3-5].
+        if (option > 0b111111) {
+          throw new DecoderError("Invalid subscription options");
+        }
+        const noLocal = booleanFlag(option, BitMask.bit2);
+        const retainAsPublished = booleanFlag(option, BitMask.bit3);
+        const retainHandling = (option & 0b110000) >> 4;
+        if (
+          retainHandling !== 0 && retainHandling !== 1 && retainHandling !== 2
+        ) {
+          throw new DecoderError("Invalid retain handling");
+        }
+        subscriptions.push({
+          topicFilter: topicFilter,
+          qos,
+          noLocal,
+          retainAsPublished,
+          retainHandling,
+        } as SubscriptionV5);
+      }
     } while (!decoder.atEnd());
     decoder.done();
+    if (codecOpts.protocolLevel !== 5) {
+      return {
+        type: PacketType.subscribe,
+        protocolLevel: codecOpts.protocolLevel,
+        id,
+        subscriptions: subscriptions as Array<SubscriptionV4>,
+      };
+    }
     return {
       type: PacketType.subscribe,
+      protocolLevel: 5,
       id,
-      subscriptions,
+      properties,
+      subscriptions: subscriptions as Array<SubscriptionV5>,
     };
   },
 };