@seriousme/opifex 1.1.0

package/mqttPacket/PacketType.ts

@@ -0,0 +1,21 @@
+export const PacketType = {
+  reserved: 0,
+  connect: 1,
+  connack: 2,
+  publish: 3,
+  puback: 4,
+  pubrec: 5,
+  pubrel: 6,
+  pubcomp: 7,
+  subscribe: 8,
+  suback: 9,
+  unsubscribe: 10,
+  unsuback: 11,
+  pingreq: 12,
+  pingres: 13,
+  disconnect: 14,
+} as const;
+
+export const PacketNameByType = Object.fromEntries(
+  Object.entries(PacketType).map(([k, v]) => [v, k]),
+);

package/mqttPacket/connack.test.ts

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { decode, encode } from "./mod.ts";
+import { PacketType } from "./PacketType.ts";
+
+test("encode Connack packet", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.connack,
+      sessionPresent: false,
+      returnCode: 0,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0x20, // packetType + flags
+      2, // remainingLength
+      // variableHeader
+      0, // connack flags
+      0, // return code
+    ]),
+  );
+});
+
+test("decode Connack packet", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0x20, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        0, // connack flags
+        0, // return code
+      ]),
+    ),
+    {
+      type: PacketType.connack,
+      sessionPresent: false,
+      returnCode: 0,
+    },
+  );
+});
+
+test("encode Connack with session present", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.connack,
+      sessionPresent: true,
+      returnCode: 0,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0x20, // packetType + flags
+      2, // remainingLength
+      // variableHeader
+      1, // connack flags (sessionPresent)
+      0, // return code
+    ]),
+  );
+});
+
+test("decode Connack with session present", () => {
+  assert
+    .deepStrictEqual(
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x20, // packetType + flags
+          2, // remainingLength
+          // variableHeader
+          1, // connack flags (sessionPresent)
+          0, // return code
+        ]),
+      ),
+      {
+        type: PacketType.connack,
+        sessionPresent: true,
+        returnCode: 0,
+      },
+    );
+});
+
+test("decode Connack with non-zero returnCode", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0x20, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        0, // connack flags
+        4, // return code (bad username or password)
+      ]),
+    ),
+    {
+      type: PacketType.connack,
+      sessionPresent: false,
+      returnCode: 4,
+    },
+  );
+});
+
+test("decode Connack with invalid returnCode", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x20, // packetType + flags
+          2, // remainingLength
+          // variableHeader
+          0, // connack flags
+          64, // return code (reserved)
+        ]),
+      ),
+    Error,
+    "Invalid return code",
+  );
+});
+
+test("decode short Connack packets", () => {
+  assert.throws(
+    () => decode(Uint8Array.from([0x20])),
+    Error,
+    "decoding failed",
+  );
+  assert.throws(() => decode(Uint8Array.from([0x20, 2])), Error, "too short");
+  assert.throws(() => decode(Uint8Array.from([0x20, 2, 0])), Error, "too long");
+});

package/mqttPacket/connack.ts

@@ -0,0 +1,37 @@
+import type { TAuthenticationResult, TPacketType } from "./types.ts";
+import { PacketType } from "./PacketType.ts";
+import { BitMask } from "./BitMask.ts";
+import { booleanFlag, Decoder, DecoderError } from "./decoder.ts";
+import { AuthenticationResultByNumber } from "./AuthenticationResult.ts";
+
+export type ConnackPacket = {
+  type: TPacketType;
+  sessionPresent: boolean;
+  returnCode: TAuthenticationResult;
+};
+
+export default {
+  encode(packet: ConnackPacket): { flags: number; bytes: number[] } {
+    const flags = 0;
+    return {
+      flags,
+      bytes: [packet.sessionPresent ? 1 : 0, packet.returnCode || 0],
+    };
+  },
+
+  decode(buffer: Uint8Array, _flags: number): ConnackPacket | undefined {
+    const decoder = new Decoder(buffer);
+
+    const sessionPresent = booleanFlag(decoder.getByte(), BitMask.bit0);
+    const returnCode = decoder.getByte() as TAuthenticationResult;
+    decoder.done();
+    if (!AuthenticationResultByNumber[returnCode]) {
+      throw new DecoderError("Invalid return code");
+    }
+    return {
+      type: PacketType.connack,
+      sessionPresent,
+      returnCode,
+    };
+  },
+};

package/mqttPacket/connect.test.ts

@@ -0,0 +1,297 @@
+import { PacketType } from "./PacketType.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { type ConnectPacket, decode, encode } from "./mod.ts";
+
+test("encode Connect with ClientId", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.connect,
+      clientId: "id",
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      16, // packetType + flags
+      14, // remainingLength
+      // variableHeader
+      0, // protocolNameLength MSB
+      4, // protocolNameLength LSB
+      77, // 'M'
+      81, // 'Q'
+      84, // 'T'
+      84, // 'T'
+      4, // protocolLevel
+      2, // connectFlags (cleanSession)
+      0, // keepAlive MSB
+      0, // keepAlive LSB
+      // payload
+      // clientId
+      0, // length MSB
+      2, // length LSB
+      105, // 'i'
+      100, // 'd'
+    ]),
+  );
+});
+
+test("encode Connect with Clean false", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.connect,
+      clientId: "id",
+      clean: false,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      16, // packetType + flags
+      14, // remainingLength
+      // variableHeader
+      0, // protocolNameLength MSB
+      4, // protocolNameLength LSB
+      77, // 'M'
+      81, // 'Q'
+      84, // 'T'
+      84, // 'T'
+      4, // protocolLevel
+      0, // connectFlags
+      0, // keepAlive MSB
+      0, // keepAlive LSB
+      // payload
+      // clientId
+      0, // length MSB
+      2, // length LSB
+      105, // 'i'
+      100, // 'd'
+    ]),
+  );
+});
+
+test("encode Connect with KeepAlive", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.connect,
+      clientId: "id",
+      keepAlive: 300,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      16, // packetType + flags
+      14, // remainingLength
+      // variableHeader
+      0, // protocolNameLength MSB
+      4, // protocolNameLength LSB
+      77, // 'M'
+      81, // 'Q'
+      84, // 'T'
+      84, // 'T'
+      4, // protocolLevel
+      2, // connectFlags (cleanSession)
+      1, // keepAlive MSB
+      44, // keepAlive LSB
+      // payload
+      // clientId
+      0, // length MSB
+      2, // length LSB
+      105, // 'i'
+      100, // 'd'
+    ]),
+  );
+});
+
+const encodedConnect = [
+  // fixedHeader
+  16, // packetType + flags
+  26, // remainingLength
+  // variableHeader
+  0, // protocolNameLength MSB
+  4, // protocolNameLength LSB
+  77, // 'M'
+  81, // 'Q'
+  84, // 'T'
+  84, // 'T'
+  4, // protocolLevel
+  194, // connectFlags (usernameFlag, passwordFlag, cleanSession)
+  0, // keepAlive MSB
+  0, // keepAlive LSB
+  // payload
+  // clientId
+  0, // length MSB
+  2, // length LSB
+  105, // 'i'
+  100, // 'd'
+  // username
+  0, // length MSB
+  4, // length LSB
+  117, // 'u'
+  115, // 's'
+  101, // 'e'
+  114, // 'r'
+  // password
+  0, // length MSB
+  4, // length LSB
+  112, // 'p'
+  97, // 'a'
+  115, // 's'
+  115, // 's'
+];
+
+const decodedConnect: ConnectPacket = {
+  type: PacketType.connect,
+  clientId: "id",
+  protocolName: "MQTT",
+  protocolLevel: 4,
+  username: "user",
+  password: Uint8Array.from([
+    112, // 'p'
+    97, // 'a'
+    115, // 's'
+    115, // 's'
+  ]),
+  will: undefined,
+  clean: true,
+  keepAlive: 0,
+};
+
+test("encode Connect with username and password", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.connect,
+      clientId: "id",
+      username: "user",
+      password: Uint8Array.from([
+        112, // 'p'
+        97, // 'a'
+        115, // 's'
+        115, // 's'
+      ]),
+    }),
+    Uint8Array.from(encodedConnect),
+  );
+});
+
+test("decode Connect with username and password", () => {
+  assert.deepStrictEqual(
+    decode(Uint8Array.from(encodedConnect)),
+    decodedConnect,
+  );
+});
+
+const decodedConnectWithWill = Object.assign({}, decodedConnect);
+decodedConnectWithWill.will = {
+  topic: "mywill",
+  payload: Uint8Array.from([
+    77, // 'M'
+    81, // 'Q'
+    84, // 'T'
+    84, // 'T'
+  ]),
+  retain: false,
+  qos: 1,
+};
+
+const encodedConnectWithWill = [
+  // fixedHeader
+  16, // packetType + flags
+  40, // remainingLength
+  // variableHeader
+  0, // protocolNameLength MSB
+  4, // protocolNameLength LSB
+  77, // 'M'
+  81, // 'Q'
+  84, // 'T'
+  84, // 'T'
+  4, // protocolLevel
+  206, // connectFlags (usernameFlag, passwordFlag, cleanSession, hasWill, willretain, willQos)
+  0, // keepAlive MSB
+  0, // keepAlive LSB
+  // payload
+  // clientId
+  0, // length MSB
+  2, // length LSB
+  105, // 'i'
+  100, // 'd'
+  // will topic
+  0, // length MSB
+  6, // length LSB
+  109, // 'm'
+  121, // 'y'
+  119, // 'w'
+  105, // 'i'
+  108, // 'l'
+  108, // 'l'
+  // will payload (raw bytes)
+  0, // length MSB
+  4, // length LSB
+  77, // 'M'
+  81, // 'Q'
+  84, // 'T'
+  84, // 'T'
+  // username
+  0, // length MSB
+  4, // length LSB
+  117, // 'u'
+  115, // 's'
+  101, // 'e'
+  114, // 'r'
+  // password
+  0, // length MSB
+  4, // length LSB
+  112, // 'p'
+  97, // 'a'
+  115, // 's'
+  115, // 's'
+];
+
+test("encode Connect with username and password and will", () => {
+  assert.deepStrictEqual(
+    encode(decodedConnectWithWill),
+    Uint8Array.from(encodedConnectWithWill),
+  );
+});
+
+test("decode invalid Connect", () => {
+  const longConnect = [...encodedConnect, 0];
+  longConnect[1]++;
+  const reservedBitConnect = [...encodedConnect];
+  reservedBitConnect[9] += 1; // set bit 0 of flags
+  const invalidWillQosConnect = [...encodedConnectWithWill];
+  invalidWillQosConnect[9] += 16; // set bit 4 of flags
+
+  assert.throws(
+    () => decode(Uint8Array.from([...longConnect])),
+    Error,
+    "too long",
+  );
+
+  assert.throws(
+    () => decode(Uint8Array.from(reservedBitConnect)),
+    Error,
+    "Invalid reserved bit",
+  );
+
+  assert.throws(
+    () => decode(Uint8Array.from(invalidWillQosConnect)),
+    Error,
+    "Invalid will qos",
+  );
+
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          16, // packetType + flags + reserved bit set to 1
+          26, // remainingLength
+          // variableHeader
+          0, // protocolNameLength MSB
+          4, // protocolNameLength LSB
+          77, // 'M'
+          81, // 'Q'
+          84, // 'T'
+        ]),
+      ),
+    Error,
+    "too short",
+  );
+});

package/mqttPacket/connect.ts

@@ -0,0 +1,159 @@
+import type { ClientId, Payload, QoS, Topic, TPacketType } from "./types.ts";
+import { PacketType } from "./PacketType.ts";
+import { BitMask } from "./BitMask.ts";
+import { Encoder } from "./encoder.ts";
+import {
+  booleanFlag,
+  Decoder,
+  DecoderError,
+  hasEmptyFlags,
+} from "./decoder.ts";
+
+export type ConnectPacket = {
+  type: TPacketType;
+  protocolName?: string;
+  protocolLevel?: number;
+  clientId?: ClientId;
+  username?: string;
+  password?: Uint8Array;
+  will?: {
+    topic: Topic;
+    payload: Payload;
+    retain?: boolean;
+    qos?: QoS;
+  };
+  clean?: boolean;
+  keepAlive?: number;
+};
+
+function invalidProtocolName(version: number, name: string): boolean {
+  if (version === 4 && name !== "MQTT") {
+    return true;
+  }
+  return false;
+}
+
+export default {
+  encode(packet: ConnectPacket) {
+    const flags = 0;
+
+    const protocolLevel = 4;
+    const protocolName = protocolLevel === 4 ? "MQTT" : "MQIsdp";
+    const clientId = packet.clientId || "";
+    const usernameFlag = !!packet.username;
+    const passwordFlag = !!packet.password;
+    const willRetain = !!packet.will?.retain;
+    const willQoS = packet.will?.qos || 0;
+    const willFlag = !!packet.will;
+    const cleanSession = packet.clean !== false;
+    const connectFlags = (usernameFlag ? BitMask.bit7 : 0) +
+      (passwordFlag ? BitMask.bit6 : 0) +
+      (willRetain ? BitMask.bit5 : 0) +
+      (willQoS & 2 ? BitMask.bit4 : 0) +
+      (willQoS & 1 ? BitMask.bit3 : 0) +
+      (willFlag ? BitMask.bit2 : 0) +
+      (cleanSession ? BitMask.bit1 : 0);
+    const keepAlive = packet.keepAlive || 0;
+
+    const encoder = new Encoder();
+    encoder
+      .setUtf8String(protocolName)
+      .setByte(protocolLevel)
+      .setByte(connectFlags)
+      .setInt16(keepAlive)
+      .setUtf8String(clientId);
+
+    if (packet.will) {
+      encoder.setTopic(packet.will.topic).setByteArray(packet.will.payload);
+    }
+
+    if (packet.username) {
+      encoder.setUtf8String(packet.username);
+    }
+
+    if (packet.password) {
+      encoder.setByteArray(packet.password);
+    }
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array, flags: number): ConnectPacket {
+    const decoder = new Decoder(buffer);
+    const protocolName = decoder.getUtf8String();
+    const protocolLevel = decoder.getByte();
+    if (invalidProtocolName(protocolLevel, protocolName)) {
+      throw new DecoderError("Invalid protocol name");
+    }
+
+    const connectFlags = decoder.getByte();
+
+    const usernameFlag = booleanFlag(connectFlags, BitMask.bit7);
+    const passwordFlag = booleanFlag(connectFlags, BitMask.bit6);
+    const willRetain = booleanFlag(connectFlags, BitMask.bit5);
+    const willQoS = (connectFlags & (BitMask.bit4 + BitMask.bit3)) >> 3;
+    const willFlag = booleanFlag(connectFlags, BitMask.bit2);
+    const cleanSession = booleanFlag(connectFlags, BitMask.bit1);
+    const reservedBit = booleanFlag(connectFlags, BitMask.bit0);
+
+    hasEmptyFlags(flags);
+    // The Server MUST validate that the reserved flag in the CONNECT Control Packet
+    // is set to zero and disconnect the Client if it is not zero [MQTT-3.1.2-3].
+    if (reservedBit) {
+      throw new DecoderError("Invalid reserved bit");
+    }
+
+    if (willQoS !== 0 && willQoS !== 1 && willQoS !== 2) {
+      throw new DecoderError("Invalid will qos");
+    }
+
+    const keepAlive = decoder.getInt16();
+    const clientId = decoder.getUtf8String();
+
+    let willTopic;
+    let willPayload;
+    if (willFlag) {
+      willTopic = decoder.getTopic();
+      willPayload = decoder.getByteArray();
+    }
+
+    let username;
+    let password;
+    if (usernameFlag) {
+      username = decoder.getUtf8String();
+    }
+
+    if (passwordFlag) {
+      password = decoder.getByteArray();
+    }
+
+    decoder.done();
+    if (!willFlag && (willQoS !== 0 || willRetain === true)) {
+      throw new DecoderError(
+        "Will QoS must be 0 and Will retain to false when Will flag is false",
+      );
+    }
+
+    if (clientId.length === 0 && cleanSession === false) {
+      throw new DecoderError("Clean session must be true if clientID is empty");
+    }
+
+    return {
+      type: PacketType.connect,
+      protocolName: protocolName,
+      protocolLevel,
+      clientId: clientId,
+      username: username ? username : undefined,
+      password: password ? password : undefined,
+      will: willFlag
+        ? {
+          topic: willTopic || "",
+          payload: willPayload || Uint8Array.from([0]),
+          retain: willRetain,
+          qos: willQoS,
+        }
+        : undefined,
+      clean: cleanSession,
+      keepAlive,
+    };
+  },
+};