@seriousme/opifex 1.9.4 → 1.10.1

package/mqttPacket/connect.ts

@@ -1,7 +1,18 @@
-import type { ClientId, Payload, QoS, Topic, TPacketType } from "./types.ts";
+import type {
+  ClientId,
+  CodecOpts,
+  Payload,
+  ProtocolLevel,
+  ProtocolLevelNoV5,
+  QoS,
+  Topic,
+  TPacketType,
+} from "./types.ts";
+import type { ConnectProperties, WillProperties } from "./Properties.ts";
+import { PropertySetType } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { BitMask } from "./BitMask.ts";
-import { Encoder } from "./encoder.ts";
+import { Encoder, EncoderError } from "./encoder.ts";
 import {
   booleanFlag,
   Decoder,
@@ -12,10 +23,10 @@ import {
 /**
  * ConnectPacket is sent from the client to the server to initiate a connection.
  */
-export type ConnectPacket = {
+export type ConnectPacketV4 = {
   type: TPacketType;
   protocolName?: string;
-  protocolLevel?: number;
+  protocolLevel: ProtocolLevelNoV5;
   clientId?: ClientId;
   username?: string;
   password?: Uint8Array;
@@ -27,31 +38,85 @@ export type ConnectPacket = {
   };
   clean?: boolean;
   keepAlive?: number;
+  bridgeMode?: boolean;
 };
 
+export type ConnectPacketV5 = {
+  type: TPacketType;
+  protocolName?: string;
+  protocolLevel: 5;
+  clientId?: ClientId;
+  username?: string;
+  password?: Uint8Array;
+  will?: {
+    topic: Topic;
+    payload: Payload;
+    retain?: boolean;
+    qos?: QoS;
+    properties?: WillProperties;
+  };
+  clean?: boolean;
+  keepAlive?: number;
+  bridgeMode?: boolean;
+  properties?: ConnectProperties;
+};
+
+export type ConnectPacket = ConnectPacketV4 | ConnectPacketV5;
+
 function invalidProtocolName(version: number, name: string): boolean {
-  if (version === 4 && name !== "MQTT") {
-    return true;
+  if (version === 3 && name === "MQIsdp") {
+    return false;
   }
-  return false;
+  if (version === 4 && name === "MQTT") {
+    return false;
+  }
+  if (version === 5 && name == "MQTT") {
+    return false;
+  }
+  return true;
 }
 
 export const connect: {
-  encode(packet: ConnectPacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array, flags: number): ConnectPacket;
+  encode(packet: ConnectPacket, _codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): ConnectPacket;
 } = {
-  encode(packet: ConnectPacket): { flags: number; bytes: number[] } {
+  encode(packet: ConnectPacket, codecOpts: CodecOpts): Uint8Array {
     const flags = 0;
 
-    const protocolLevel = 4;
-    const protocolName = protocolLevel === 4 ? "MQTT" : "MQIsdp";
+    if (typeof packet.protocolLevel !== "number") {
+      throw new EncoderError("Protocol level must be a number");
+    }
+    const protocolLevel = packet.protocolLevel || 4;
+    if (protocolLevel < 3 || protocolLevel > 5) {
+      throw new EncoderError("Unsupported protocol level");
+    }
+    const protocolName = protocolLevel > 3 ? "MQTT" : "MQIsdp";
     const clientId = packet.clientId || "";
-    const usernameFlag = !!packet.username;
-    const passwordFlag = !!packet.password;
+    const usernameFlag = packet.username !== undefined;
+    if (protocolLevel === 3 && clientId === "") {
+      throw new EncoderError("Client id required for protocol level 3");
+    }
+    const passwordFlag = usernameFlag && packet.password !== undefined;
     const willRetain = !!packet.will?.retain;
     const willQoS = packet.will?.qos || 0;
-    const willFlag = !!packet.will;
+    const willFlag = packet.will !== undefined;
+    if (willFlag) {
+      if (packet.will?.topic === undefined) {
+        throw new EncoderError("Will topic must be defined");
+      }
+      if (packet.will?.payload === undefined) {
+        throw new EncoderError("Will payload must be defined");
+      }
+    }
     const cleanSession = packet.clean !== false;
+    if (!cleanSession && (clientId === "")) {
+      throw new EncoderError("Client id required for clean session");
+    }
     const connectFlags = (usernameFlag ? BitMask.bit7 : 0) +
       (passwordFlag ? BitMask.bit6 : 0) +
       (willRetain ? BitMask.bit5 : 0) +
@@ -60,35 +125,64 @@ export const connect: {
       (willFlag ? BitMask.bit2 : 0) +
       (cleanSession ? BitMask.bit1 : 0);
     const keepAlive = packet.keepAlive || 0;
+    const bridgeMode = !!packet.bridgeMode;
+    const rawProtocolLevel = bridgeMode ? protocolLevel + 128 : protocolLevel;
 
-    const encoder = new Encoder();
+    const encoder = new Encoder(packet.type);
     encoder
       .setUtf8String(protocolName)
-      .setByte(protocolLevel)
+      .setByte(rawProtocolLevel)
       .setByte(connectFlags)
-      .setInt16(keepAlive)
-      .setUtf8String(clientId);
+      .setInt16(keepAlive);
+    if (packet.protocolLevel === 5) {
+      encoder.setProperties(
+        packet.properties || {},
+        PropertySetType.connect,
+        codecOpts.maxOutgoingPacketSize,
+      );
+    }
+    encoder.setUtf8String(clientId);
 
-    if (packet.will) {
+    if (
+      packet.will !== undefined && packet.will.topic !== undefined &&
+      packet.will.payload !== undefined
+    ) {
+      if (packet.protocolLevel === 5) {
+        encoder.setProperties(
+          packet.will?.properties || {},
+          PropertySetType.will,
+          codecOpts.maxOutgoingPacketSize,
+        );
+      }
       encoder.setTopic(packet.will.topic).setByteArray(packet.will.payload);
     }
 
-    if (packet.username) {
+    if (packet.username !== undefined) {
       encoder.setUtf8String(packet.username);
     }
 
-    if (packet.password) {
+    if (passwordFlag && packet.password !== undefined) {
       encoder.setByteArray(packet.password);
     }
-    return { flags, bytes: encoder.done() };
+    return encoder.done(flags);
   },
 
-  decode(buffer: Uint8Array, flags: number): ConnectPacket {
-    const decoder = new Decoder(buffer);
-    const protocolName = decoder.getUtf8String();
-    const protocolLevel = decoder.getByte();
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    _codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): ConnectPacket {
+    const decoder = new Decoder(packetType, buffer);
+    const protocolName = decoder.getUTF8String();
+    const rawProtocolLevel = decoder.getByte();
+    const bridgeMode = rawProtocolLevel > 128;
+    const protocolLevel = bridgeMode
+      ? rawProtocolLevel - 128
+      : rawProtocolLevel;
+
     if (invalidProtocolName(protocolLevel, protocolName)) {
-      throw new DecoderError("Invalid protocol name");
+      throw new DecoderError("Invalid protocol name or level");
     }
 
     const connectFlags = decoder.getByte();
@@ -112,12 +206,24 @@ export const connect: {
       throw new DecoderError("Invalid will qos");
     }
 
-    const keepAlive = decoder.getInt16();
-    const clientId = decoder.getUtf8String();
+    if (!usernameFlag && passwordFlag) {
+      throw new DecoderError("Password without username");
+    }
 
+    const keepAlive = decoder.getInt16();
+    const isV5 = protocolLevel === 5;
+    let properties;
+    if (isV5) {
+      properties = decoder.getProperties(PropertySetType.connect);
+    }
+    const clientId = decoder.getUTF8String();
+    let willProperties;
     let willTopic;
     let willPayload;
     if (willFlag) {
+      if (isV5) {
+        willProperties = decoder.getProperties(PropertySetType.will);
+      }
       willTopic = decoder.getTopic();
       willPayload = decoder.getByteArray();
     }
@@ -125,7 +231,7 @@ export const connect: {
     let username;
     let password;
     if (usernameFlag) {
-      username = decoder.getUtf8String();
+      username = decoder.getUTF8String();
     }
 
     if (passwordFlag) {
@@ -143,13 +249,40 @@ export const connect: {
       throw new DecoderError("Clean session must be true if clientID is empty");
     }
 
-    return {
+    let bridgeModeProp = {};
+    if (bridgeMode) {
+      bridgeModeProp = { bridgeMode };
+    }
+    const commonProps = {
       type: PacketType.connect,
       protocolName: protocolName,
-      protocolLevel,
       clientId: clientId,
-      username: username ? username : undefined,
+      username,
       password: password ? password : undefined,
+      clean: cleanSession,
+      keepAlive,
+      ...bridgeModeProp,
+    };
+
+    if (isV5) {
+      return {
+        ...commonProps,
+        protocolLevel: 5,
+        will: willFlag
+          ? {
+            topic: willTopic || "",
+            payload: willPayload || Uint8Array.from([0]),
+            retain: willRetain,
+            qos: willQoS,
+            properties: willProperties,
+          }
+          : undefined,
+        properties,
+      };
+    }
+    return {
+      ...commonProps,
+      protocolLevel: protocolLevel as ProtocolLevel,
       will: willFlag
         ? {
           topic: willTopic || "",
@@ -158,8 +291,6 @@ export const connect: {
           qos: willQoS,
         }
         : undefined,
-      clean: cleanSession,
-      keepAlive,
     };
   },
 };

package/mqttPacket/decoder.test.ts

@@ -4,10 +4,11 @@ import { test } from "node:test";
 import { Decoder } from "./decoder.ts";
 
 const utf8encoder = new TextEncoder();
+const packetType = 0;
 
 test("decode byte", () => {
   const byte = 127;
-  const decoder = new Decoder(Uint8Array.from([byte]));
+  const decoder = new Decoder(packetType, Uint8Array.from([byte]));
   assert.deepStrictEqual(decoder.getByte(), byte);
   assert.deepStrictEqual(decoder.done(), true);
 });
@@ -16,7 +17,7 @@ test("decode Int16", () => {
   const value = 0xf0f2;
   const msb = 0xf0;
   const lsb = 0xf2;
-  const decoder = new Decoder(Uint8Array.from([msb, lsb]));
+  const decoder = new Decoder(packetType, Uint8Array.from([msb, lsb]));
   assert.deepStrictEqual(decoder.getInt16(), value);
   assert.deepStrictEqual(decoder.done(), true);
 });
@@ -25,7 +26,7 @@ test("decode Int16 with remainder", () => {
   const value = 0xf0f2;
   const msb = 0xf0;
   const lsb = 0xf2;
-  const decoder = new Decoder(Uint8Array.from([msb, lsb, 0xff]));
+  const decoder = new Decoder(packetType, Uint8Array.from([msb, lsb, 0xff]));
   assert.deepStrictEqual(decoder.getInt16(), value, "value is correct");
   assert.deepStrictEqual(decoder.atEnd(), false);
 });
@@ -35,6 +36,7 @@ test("decode byte array", () => {
   byteArray.fill(127);
   const len = byteArray.length;
   const decoder = new Decoder(
+    packetType,
     Uint8Array.from([len >> 8, len & 0xff, ...byteArray]),
   );
   assert.deepStrictEqual(decoder.getByteArray(), Uint8Array.from(byteArray));
@@ -44,7 +46,7 @@ test("decode byte array", () => {
 test("decode byte array as remainder", () => {
   const str = "hello world";
   const byteArray = utf8encoder.encode(str);
-  const decoder = new Decoder(byteArray);
+  const decoder = new Decoder(packetType, byteArray);
   assert.deepStrictEqual(decoder.getRemainder(), byteArray);
   assert.deepStrictEqual(decoder.done(), true);
 });
@@ -54,8 +56,11 @@ test("decode byte array as empty remainder", () => {
   const emptyArray = Uint8Array.from([]);
   const byteArray = utf8encoder.encode(str);
   const len = byteArray.length;
-  const decoder = new Decoder(Uint8Array.from([0x00, len, ...byteArray]));
-  assert.deepStrictEqual(decoder.getUtf8String(), str);
+  const decoder = new Decoder(
+    packetType,
+    Uint8Array.from([0x00, len, ...byteArray]),
+  );
+  assert.deepStrictEqual(decoder.getUTF8String(), str);
   assert.deepStrictEqual(decoder.getRemainder(), emptyArray);
   assert.deepStrictEqual(decoder.done(), true);
 });
@@ -64,8 +69,11 @@ test("decode string", () => {
   const str = "hello world";
   const byteArray = utf8encoder.encode(str);
   const len = byteArray.length;
-  const decoder = new Decoder(Uint8Array.from([0x00, len, ...byteArray]));
-  assert.deepStrictEqual(decoder.getUtf8String(), str);
+  const decoder = new Decoder(
+    packetType,
+    Uint8Array.from([0x00, len, ...byteArray]),
+  );
+  assert.deepStrictEqual(decoder.getUTF8String(), str);
   assert.deepStrictEqual(decoder.done(), true);
 });
 
@@ -73,13 +81,16 @@ test("decode topic", () => {
   const str = "hello world";
   const byteArray = utf8encoder.encode(str);
   const len = byteArray.length;
-  const decoder = new Decoder(Uint8Array.from([0x00, len, ...byteArray]));
+  const decoder = new Decoder(
+    packetType,
+    Uint8Array.from([0x00, len, ...byteArray]),
+  );
   assert.deepStrictEqual(decoder.getTopic(), str);
   assert.deepStrictEqual(decoder.done(), true);
 });
 
 test("Topic too short", () => {
-  const decoder = new Decoder(Uint8Array.from([0x00, 0]));
+  const decoder = new Decoder(packetType, Uint8Array.from([0x00, 0]));
   assert.throws(
     () => decoder.getTopic(),
     Error,
@@ -88,7 +99,7 @@ test("Topic too short", () => {
 });
 
 test("Invalid topic", () => {
-  const decoder = new Decoder(Uint8Array.from([0x00, 0x01, 0x00]));
+  const decoder = new Decoder(packetType, Uint8Array.from([0x00, 0x01, 0x00]));
   assert.throws(
     () => decoder.getTopic(),
     Error,
@@ -97,7 +108,7 @@ test("Invalid topic", () => {
 });
 
 test("Invalid topicFilter", () => {
-  const decoder = new Decoder(Uint8Array.from([0x00, 0x01, 0x00]));
+  const decoder = new Decoder(packetType, Uint8Array.from([0x00, 0x01, 0x00]));
   assert.throws(
     () => decoder.getTopic(),
     Error,
@@ -109,15 +120,21 @@ test("Buffer too short", () => {
   const str = "hello world";
   const byteArray = utf8encoder.encode(str);
   const len = byteArray.length;
-  const decoder = new Decoder(Uint8Array.from([0x00, len + 1, ...byteArray]));
-  assert.throws(() => decoder.getUtf8String(), Error, "too short");
+  const decoder = new Decoder(
+    packetType,
+    Uint8Array.from([0x00, len + 1, ...byteArray]),
+  );
+  assert.throws(() => decoder.getUTF8String(), Error, "too short");
 });
 
 test("Buffer too long", () => {
   const str = "hello world";
   const byteArray = utf8encoder.encode(str);
   const len = byteArray.length;
-  const decoder = new Decoder(Uint8Array.from([0x00, len, ...byteArray, 0]));
-  assert.deepStrictEqual(decoder.getUtf8String(), str);
+  const decoder = new Decoder(
+    packetType,
+    Uint8Array.from([0x00, len, ...byteArray, 0]),
+  );
+  assert.deepStrictEqual(decoder.getUTF8String(), str);
   assert.throws(() => decoder.done(), Error, "too long");
 });

package/mqttPacket/decoder.ts

@@ -1,7 +1,32 @@
-import type { TBitMask, Topic, TopicFilter } from "./types.ts";
+import type {
+  TBitMask,
+  Topic,
+  TopicFilter,
+  TPacketType,
+  TReasonCode,
+  UTF8StringPair,
+} from "./types.ts";
 import { invalidTopic, invalidTopicFilter } from "./validators.ts";
+import { isValidReasonCode } from "./ReasonCode.ts";
+import type {
+  Mqttv5PropertyTypesNoUser,
+  PropsByPacketSetType,
+  SubscriptionIdentifiersType,
+  UserPropertyType,
+  ValidPropertyNumber,
+} from "./Properties.ts";
+import {
+  propertyByNumber,
+  PropertyByPropertySetType,
+  propertyKind,
+  propertyToId,
+  propertyToKind,
+} from "./Properties.ts";
 
 const utf8Decoder = new TextDecoder("utf-8");
+const userPropID = propertyToId.userProperty;
+const subIdentID = propertyToId.subscriptionIdentifier;
+const subIdentsID = propertyToId.subscriptionIdentifiers;
 /**
  * Checks if a specific bit flag is set in a byte using a bitmask
  * @param byte - The byte to check
@@ -48,6 +73,7 @@ export class DecoderError extends Error {
  * Decoder class for parsing MQTT packets
  */
 export class Decoder {
+  private packetType: TPacketType;
   private buf: Uint8Array;
   private pos: number;
   private len: number;
@@ -57,7 +83,8 @@ export class Decoder {
    * @param buf - The buffer to decode
    * @param pos - Starting position in the buffer (default: 0)
    */
-  constructor(buf: Uint8Array, pos: number = 0) {
+  constructor(packetType: TPacketType, buf: Uint8Array, pos: number = 0) {
+    this.packetType = packetType;
     this.buf = buf;
     this.pos = pos;
     this.len = buf.length;
@@ -93,6 +120,37 @@ export class Decoder {
     return (msb << 8) | lsb;
   }
 
+  /**
+   * Gets a 4 byte integer from the buffer (for v5)
+   * @returns The 32 bit integer value
+   */
+  getInt32(): number {
+    const msb = this.getInt16();
+    const lsb = this.getInt16();
+    return (msb << 16) | lsb;
+  }
+
+  /**
+   * Gets a variable byte integer from the buffer (for v5)
+   * its like the length decoder in length.ts but this one works directly on the buffer
+   * @returns The decoded variable byte integer
+   * @throws {DecoderError} If malformed variable byte integer
+   */
+  getVariableByteInteger(): number {
+    let num = 0;
+    let multiplier = 1;
+    let byte;
+    do {
+      byte = this.getByte();
+      num += (byte & 127) * multiplier;
+      if (multiplier > 128 * 128 * 128) {
+        throw new DecoderError("Malformed Variable Byte Integer");
+      }
+      multiplier *= 128;
+    } while ((byte & 128) !== 0);
+    return num;
+  }
+
   /**
    * Gets a byte array from the buffer
    * @returns A subarray of the buffer
@@ -110,18 +168,28 @@ export class Decoder {
    * Gets a UTF-8 string from the buffer
    * @returns The decoded UTF-8 string
    */
-  getUtf8String(): string {
+  getUTF8String(): string {
     const str = utf8Decoder.decode(this.getByteArray());
     return str;
   }
 
+  /**
+   * Gets a UTF-8 string pair from the buffer (for v5)
+   * @returns The decoded UTF-8 pair as [name,value]
+   */
+  getUTF8StringPair(): UTF8StringPair {
+    const name = utf8Decoder.decode(this.getByteArray());
+    const value = utf8Decoder.decode(this.getByteArray());
+    return [name, value];
+  }
+
   /**
    * Gets a topic from the buffer
    * @returns The decoded topic
    * @throws {DecoderError} If topic is invalid
    */
   getTopic(): Topic {
-    const topic = this.getUtf8String();
+    const topic = this.getUTF8String();
     if (invalidTopic(topic)) {
       throw new DecoderError(
         "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
@@ -136,7 +204,7 @@ export class Decoder {
    * @throws {DecoderError} If topic filter is invalid
    */
   getTopicFilter(): TopicFilter {
-    const topicFilter = this.getUtf8String();
+    const topicFilter = this.getUTF8String();
     if (invalidTopicFilter(topicFilter)) {
       throw new DecoderError(
         "Topicfilter must contain valid UTF-8 and contain more than 1 byte and valid wildcards",
@@ -156,6 +224,106 @@ export class Decoder {
     return this.buf.subarray(start, end);
   }
 
+  /**
+   * Gets a single property
+   * @param id
+   * @returns
+   */
+  private getProperty(
+    id: ValidPropertyNumber,
+  ): Mqttv5PropertyTypesNoUser {
+    switch (propertyToKind[id]) {
+      case propertyKind.boolean:
+        return !!this.getByte();
+      case propertyKind.byte:
+        return this.getByte();
+      case propertyKind.int16:
+        return this.getInt16();
+      case propertyKind.int32:
+        return this.getInt32();
+      case propertyKind.varInt:
+        return this.getVariableByteInteger();
+      case propertyKind.byteArray:
+        return this.getByteArray();
+      case propertyKind.utf8string:
+        return this.getUTF8String();
+    }
+    // deno-coverage-ignore
+    throw new DecoderError("Invalid property kind");
+  }
+
+  /**
+   * Gets all properties from the buffer
+   * and validates if they are allowed for this type of packet
+   * @param propertySetType
+   * @returns
+   * @throws {DecoderError} If properties are invalid
+   */
+  getProperties<T extends keyof PropsByPacketSetType>(
+    propertySetType: T,
+  ): PropsByPacketSetType[T] {
+    const allowedProps: readonly number[] =
+      PropertyByPropertySetType[propertySetType];
+    const properties = {} as PropsByPacketSetType[T];
+    const propLength = this.getVariableByteInteger();
+    const endPos = this.pos + propLength;
+    const userProps: UserPropertyType = [];
+    const subIdents: SubscriptionIdentifiersType = [];
+
+    while (this.pos < endPos) {
+      const id = this.getVariableByteInteger() as ValidPropertyNumber;
+      const label = propertyByNumber[id];
+      if (
+        id === subIdentID && allowedProps.includes(subIdentsID)
+      ) {
+        subIdents.push(this.getVariableByteInteger());
+        continue;
+      }
+      if (!allowedProps.includes(id)) {
+        throw new DecoderError(
+          `Property type ${label ? label : id} not allowed at byte ${this.pos}`,
+        );
+      }
+      if (id === userPropID) {
+        const stringPair = this.getUTF8StringPair();
+        userProps.push(stringPair);
+        continue;
+      }
+
+      const value = this.getProperty(id);
+
+      // deno-lint-ignore no-explicit-any
+      if ((properties as any)[label] !== undefined) {
+        throw new DecoderError(`Property ${label} only allowed once`);
+      } else {
+        // deno-lint-ignore no-explicit-any
+        (properties as any)[label] = value;
+      }
+    }
+    if (userProps.length > 0) {
+      // deno-lint-ignore no-explicit-any
+      (properties as any).userProperty = userProps;
+    }
+    if (subIdents.length > 0) {
+      // deno-lint-ignore no-explicit-any
+      (properties as any).subscriptionIdentifiers = subIdents;
+    }
+    return properties;
+  }
+
+  /**
+   * Gets a reason code from the buffer
+   * @returns The decoded reason code
+   * @throws {DecoderError} If reason code is invalid
+   */
+  getReasonCode(): TReasonCode {
+    const reasonCode = this.getByte();
+    if (!isValidReasonCode(this.packetType, reasonCode)) {
+      throw new DecoderError("Invalid reason code");
+    }
+    return reasonCode as TReasonCode;
+  }
+
   /**
    * Checks if decoder has reached the end of the buffer
    * @returns True if at end, false otherwise