feat: 🎸 add encoding to connect packet and username setting

Author: streamich

src/packet.ts

@@ -12,7 +12,10 @@ export class Packet implements PacketHeaderData {
   /** Packet first byte. */
   public b: number;
 
-  /** Variable length. */
+  /**
+   * Remaining Length - packet size less first byte and Remaining Length
+   * variable integer size.
+   */
   public l: number;
 
   constructor(b: number, l: number) {

src/packets/__tests__/connect.spec.ts

@@ -0,0 +1,42 @@
+import {PACKET_TYPE} from '../../enums';
+import {PacketConnect} from '../connect';
+
+test('can create a packet', () => {
+  const packet = PacketConnect.create(5, 0, 30, {}, 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx');
+  expect(packet.b >> 4).toBe(PACKET_TYPE.CONNECT);
+  expect(packet.id).toBe('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx');
+  expect(packet.v).toBe(5);
+  expect(packet.f).toBe(0);
+  expect(packet.k).toBe(30);
+  expect(packet.p).toEqual({});
+});
+
+test('can set username', () => {
+  const packet = PacketConnect.create(5, 0, 30, {}, 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx');
+  expect(packet.userNameFlag()).toBe(false);
+  expect(packet.usr).toBe(undefined);
+  packet.setUserName('streamich');
+  expect(packet.userNameFlag()).toBe(true);
+  expect(packet.usr).toBe('streamich');
+  packet.setUserName('lol');
+  expect(packet.userNameFlag()).toBe(true);
+  expect(packet.usr).toBe('lol');
+  packet.setUserName('');
+  expect(packet.userNameFlag()).toBe(true);
+  expect(packet.usr).toBe('');
+});
+
+test('can remove username', () => {
+  const packet = PacketConnect.create(5, 0, 30, {}, 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx');
+  expect(packet.userNameFlag()).toBe(false);
+  expect(packet.usr).toBe(undefined);
+  packet.removeUserName();
+  expect(packet.userNameFlag()).toBe(false);
+  expect(packet.usr).toBe(undefined);
+  packet.setUserName('streamich');
+  expect(packet.userNameFlag()).toBe(true);
+  expect(packet.usr).toBe('streamich');
+  packet.removeUserName();
+  expect(packet.userNameFlag()).toBe(false);
+  expect(packet.usr).toBe(undefined);
+});

src/packets/connect.ts

@@ -1,7 +1,7 @@
-import {BufferList} from '../BufferList';
+import { PACKET_TYPE } from '../enums';
 import {Packet, PacketHeaderData} from '../packet';
 import {Properties, QoS} from '../types';
-import {parseProps, parseBinary} from '../util/parse';
+import {encodeConnect} from './connect/encodeConnect';
 
 export interface PacketConnectData extends PacketHeaderData {
   /** Protocol version. */
@@ -27,6 +27,23 @@ export interface PacketConnectData extends PacketHeaderData {
 }
 
 export class PacketConnect extends Packet implements PacketConnectData {
+  /**
+   * @param v Version, i.e. 5 or 4
+   * @param f Connect flags
+   * @param k Keep-alive
+   * @param p Properties object in case of MQTT 5.0, or empty `{}` object otherwise.
+   * @param id Connection ID
+   */
+  static create(
+    v: number,
+    f: number,
+    k: number,
+    p: Properties,
+    id: string,
+  ): PacketConnect {
+    return new PacketConnect(PACKET_TYPE.CONNECT << 4, 0, v, f, k, p, id);
+  }
+
   public wp?: Properties;
   public wt?: string;
   public w?: Buffer;
@@ -49,6 +66,16 @@ export class PacketConnect extends Packet implements PacketConnectData {
     return !!(this.f & 0b10000000);
   }
 
+  public setUserName(usr: string) {
+    this.usr = usr;
+    this.f |= 0b10000000;
+  }
+
+  public removeUserName() {
+    this.usr = undefined;
+    this.f &= ~0b10000000;
+  }
+
   public passwordFlag(): boolean {
     return !!(this.f & 0b01000000);
   }
@@ -68,4 +95,8 @@ export class PacketConnect extends Packet implements PacketConnectData {
   public cleanStart(): boolean {
     return !!(this.f & 0b00000010);
   }
+
+  public toBuffer(): Buffer {
+    return encodeConnect(this);
+  }
 }

src/packets/connect/encodeConnect.ts

@@ -0,0 +1,119 @@
+import {genProps} from '../../util/genProps/v7';
+import {PacketConnect} from '../connect';
+
+// "MQTT" string with 2 byte length prefix
+const bufferMQTT = Buffer.from([0, 2, 0x4d, 0x51, 0x54, 0x54]);
+
+export const encodeConnect = (packet: PacketConnect): Buffer => {
+  const {b, f, id, v, k, p, w, wt, wp, usr, pwd} = packet;
+  const hasWill = packet.willFlag();
+  const hasUserName = packet.userNameFlag();
+  const hasPassword = packet.passwordFlag();
+
+  const isV5 = v === 5;
+  const props = isV5 ? genProps(p) : null;
+  const propsLength = props ? props.length : 0;
+  const willProps = isV5 && !!wp ? genProps(wp) : null;
+  const willPropsLength = willProps ? willProps.length : 0;
+  const willTopicLength: number = hasWill ? Buffer.byteLength(wt!) : 0;
+  const willPayloadLength: number = hasWill ? w!.length : 0;
+  const lenClientId = Buffer.byteLength(id);
+  const userNameLength = hasUserName ? Buffer.byteLength(usr!) : 0;
+  const passwordLength = hasPassword ? Buffer.byteLength(pwd!) : 0;
+
+  const remainingLength: number =
+    2 + 4 +                                     // "MQTT" string and string length prefix
+    1 +                                         // Protocol Version
+    1 +                                         // Connection flags
+    2 +                                         // Keep-alive
+    (isV5 ? propsLength : 0) +                  // Properties
+    2 + lenClientId +                           // Client ID
+    (hasWill ? (
+      willPropsLength +                         // Will props
+      2 + willTopicLength +                     // Will topic
+      2 + willPayloadLength                     // Will payload
+    ) : 0) +
+    (hasUserName ? 2 + userNameLength : 0) +   // Username
+    (hasPassword ? 2 + passwordLength : 0);    // Password
+
+  packet.l = remainingLength;
+  const remainingLengthSize = remainingLength < 128 ? 1 : remainingLength < 16_384 ? 2 : remainingLength < 2_097_152 ? 3 : 4;
+  const bufferLength = 1 + remainingLengthSize + remainingLength;
+  const buf = Buffer.allocUnsafe(bufferLength);
+
+  buf.writeUInt8(b, 0);
+
+  let offset = 1;
+
+  switch (remainingLengthSize) {
+    case 1:
+      buf.writeUInt8(remainingLength, 1);
+      offset = 2;
+      break;
+    case 2:
+      buf.writeUInt16LE(((remainingLength & 0b011111110000000) << 1) | (0b10000000 | (remainingLength & 0b01111111)), 1);
+      offset = 3;
+      break;
+    case 3:
+      buf.writeUInt16LE(((0b100000000000000 | (remainingLength & 0b011111110000000)) << 1) | (0b10000000 | (remainingLength & 0b01111111)), 1);
+      buf.writeUInt8((remainingLength >> 14) & 0b01111111, 3);
+      offset = 4;
+      break;
+    case 4:
+      buf.writeUInt32LE((((((remainingLength >> 21) & 0b01111111) << 8) | (0b10000000 | ((remainingLength >> 14) & 0b01111111))) << 16) |
+        ((0b100000000000000 | (remainingLength & 0b011111110000000)) << 1) | (0b10000000 | (remainingLength & 0b01111111)), 1);
+      offset = 5;
+      break;
+  }
+
+  bufferMQTT.copy(buf, offset);
+  offset += 6;
+
+  buf.writeUInt8(v, offset);
+  offset += 1;
+
+  buf.writeUInt8(f, offset);
+  offset += 1;
+
+  buf.writeUInt16BE(k, offset);
+  offset += 2;
+
+  if (isV5) {
+    props!.copy(buf, offset);
+    offset+= propsLength;
+  }
+
+  buf.write(id, offset);
+  offset += lenClientId;
+
+  if (hasWill) {
+    if (isV5) {
+      willProps!.copy(buf, offset);
+      offset += willPropsLength;
+    }
+    buf.writeUInt16BE(willTopicLength, offset);
+    offset += 2;
+    buf.write(wt!, offset);
+    offset += willTopicLength;
+    buf.writeUInt16BE(willPayloadLength, offset);
+    offset += 2;
+    w!.copy(buf, offset);
+    offset += willPayloadLength;
+  }
+
+  if (hasUserName) {
+    buf.writeUInt16BE(userNameLength, offset);
+    offset += 2;
+    buf.write(usr!, offset);
+    offset += userNameLength;
+  }
+
+  if (hasPassword) {
+    buf.writeUInt16BE(passwordLength, offset);
+    offset += 2;
+    pwd!.copy(buf, offset);
+    offset += passwordLength;
+  }
+
+  return buf;
+}

src/packets/publish/encodePublish/v1.ts

@@ -18,7 +18,7 @@ export const encodePublish = (packet: PacketPublish, version: number): Buffer =>
   const buf = Buffer.allocUnsafe(bufferLength);
   packet.l = remainingLength;
 
-  buf.writeUInt8(packet.b);
+  buf.writeUInt8(packet.b, 0);
 
   let offset = 1;