node-rtc-connection 1.0.18 → 2.0.4

package/src/sctp/chunks.ts

@@ -0,0 +1,350 @@
+/**
+ * @file chunks.ts
+ * @description SCTP common header and chunk encode/parse (RFC 4960 + RFC 8260
+ * for I-DATA is NOT used; classic DATA only). Scoped to the WebRTC profile.
+ * @module sctp/chunks
+ */
+
+'use strict';
+
+export const CHUNK_TYPE = Object.freeze({
+  DATA: 0,
+  INIT: 1,
+  INIT_ACK: 2,
+  SACK: 3,
+  HEARTBEAT: 4,
+  HEARTBEAT_ACK: 5,
+  ABORT: 6,
+  SHUTDOWN: 7,
+  SHUTDOWN_ACK: 8,
+  ERROR: 9,
+  COOKIE_ECHO: 10,
+  COOKIE_ACK: 11,
+  SHUTDOWN_COMPLETE: 14,
+  FORWARD_TSN: 192, // 0xC0
+});
+
+export const PARAM_TYPE = Object.freeze({
+  HEARTBEAT_INFO: 1,
+  STATE_COOKIE: 7,
+  UNRECOGNIZED_PARAM: 8,
+  COOKIE_PRESERVATIVE: 9,
+  SUPPORTED_ADDR_TYPES: 11,
+  // RFC 8260 / RFC 3758
+  FORWARD_TSN_SUPPORTED: 49152, // 0xC000
+  SUPPORTED_EXTENSIONS: 32776, // 0x8008
+});
+
+// Payload Protocol Identifiers used by WebRTC data channels (RFC 8831).
+export const PPID = Object.freeze({
+  DCEP: 50,
+  STRING: 51,
+  BINARY: 53,
+  STRING_EMPTY: 56,
+  BINARY_EMPTY: 57,
+  STRING_PARTIAL: 54, // deprecated
+  BINARY_PARTIAL: 52, // deprecated
+});
+
+export interface CommonHeader {
+  srcPort: number;
+  dstPort: number;
+  verificationTag: number;
+  checksum: number;
+}
+
+export interface ParsedChunk {
+  type: number;
+  flags: number;
+  length: number;
+  body: Buffer;
+}
+
+export interface ParsedParam {
+  type: number;
+  length: number;
+  value: Buffer;
+}
+
+export interface InitBodyParams {
+  initiateTag: number;
+  a_rwnd: number;
+  outStreams: number;
+  inStreams: number;
+  initialTSN: number;
+}
+
+export interface ParsedInitBody {
+  initiateTag: number;
+  a_rwnd: number;
+  outStreams: number;
+  inStreams: number;
+  initialTSN: number;
+  params: ParsedParam[];
+}
+
+export interface DataBodyParams {
+  tsn: number;
+  streamId: number;
+  streamSeq: number;
+  ppid: number;
+  userData: Buffer;
+  unordered?: boolean;
+  beginning?: boolean;
+  ending?: boolean;
+}
+
+export interface EncodedDataBody {
+  flags: number;
+  body: Buffer;
+}
+
+export interface ParsedDataBody {
+  unordered: boolean;
+  beginning: boolean;
+  ending: boolean;
+  tsn: number;
+  streamId: number;
+  streamSeq: number;
+  ppid: number;
+  userData: Buffer;
+}
+
+export interface SackBodyParams {
+  cumulativeTSNAck: number;
+  a_rwnd: number;
+  gapBlocks?: Array<[number, number]>;
+  dupTSNs?: number[];
+}
+
+export interface ParsedSackBody {
+  cumulativeTSNAck: number;
+  a_rwnd: number;
+  gapBlocks: Array<[number, number]>;
+  dupTSNs: number[];
+}
+
+/** Round a length up to the next 4-byte boundary. */
+export function pad4(n: number): number {
+  return (n + 3) & ~3;
+}
+
+/**
+ * Encode the 12-byte SCTP common header (checksum left as 0; filled by crc32c).
+ * @param {number} srcPort
+ * @param {number} dstPort
+ * @param {number} verificationTag
+ * @returns {Buffer}
+ */
+export function encodeCommonHeader(srcPort: number, dstPort: number, verificationTag: number): Buffer {
+  const h = Buffer.alloc(12);
+  h.writeUInt16BE(srcPort, 0);
+  h.writeUInt16BE(dstPort, 2);
+  h.writeUInt32BE(verificationTag >>> 0, 4);
+  h.writeUInt32BE(0, 8); // checksum placeholder
+  return h;
+}
+
+/**
+ * Parse the common header.
+ * @param {Buffer} packet
+ * @returns {{srcPort:number,dstPort:number,verificationTag:number,checksum:number}}
+ */
+export function parseCommonHeader(packet: Buffer): CommonHeader {
+  return {
+    srcPort: packet.readUInt16BE(0),
+    dstPort: packet.readUInt16BE(2),
+    verificationTag: packet.readUInt32BE(4),
+    checksum: packet.readUInt32LE(8),
+  };
+}
+
+/**
+ * Wrap a chunk body with the 4-byte chunk header, padded to 4 bytes.
+ * @param {number} type
+ * @param {number} flags
+ * @param {Buffer} body
+ * @returns {Buffer}
+ */
+export function encodeChunk(type: number, flags: number, body: Buffer): Buffer {
+  const len = 4 + body.length;
+  const out = Buffer.alloc(pad4(len));
+  out.writeUInt8(type, 0);
+  out.writeUInt8(flags, 1);
+  out.writeUInt16BE(len, 2); // length excludes padding
+  body.copy(out, 4);
+  return out;
+}
+
+/**
+ * Parse all chunks out of an SCTP packet (after the 12-byte common header).
+ * @param {Buffer} packet
+ * @returns {Array<{type:number,flags:number,length:number,body:Buffer}>}
+ */
+export function parseChunks(packet: Buffer): ParsedChunk[] {
+  const chunks: ParsedChunk[] = [];
+  let off = 12;
+  while (off + 4 <= packet.length) {
+    const type = packet.readUInt8(off);
+    const flags = packet.readUInt8(off + 1);
+    const length = packet.readUInt16BE(off + 2);
+    if (length < 4 || off + length > packet.length) break;
+    const body = packet.slice(off + 4, off + length);
+    chunks.push({ type, flags, length, body });
+    off += pad4(length);
+  }
+  return chunks;
+}
+
+/**
+ * Encode a TLV parameter, padded to 4 bytes.
+ * @param {number} type
+ * @param {Buffer} value
+ * @returns {Buffer}
+ */
+export function encodeParam(type: number, value: Buffer): Buffer {
+  const len = 4 + value.length;
+  const out = Buffer.alloc(pad4(len));
+  out.writeUInt16BE(type, 0);
+  out.writeUInt16BE(len, 2);
+  value.copy(out, 4);
+  return out;
+}
+
+/**
+ * Parse TLV parameters from a buffer.
+ * @param {Buffer} buf
+ * @returns {Array<{type:number,length:number,value:Buffer}>}
+ */
+export function parseParams(buf: Buffer): ParsedParam[] {
+  const params: ParsedParam[] = [];
+  let off = 0;
+  while (off + 4 <= buf.length) {
+    const type = buf.readUInt16BE(off);
+    const length = buf.readUInt16BE(off + 2);
+    if (length < 4 || off + length > buf.length) break;
+    params.push({ type, length, value: buf.slice(off + 4, off + length) });
+    off += pad4(length);
+  }
+  return params;
+}
+
+/**
+ * Build an INIT or INIT_ACK fixed body (without parameters).
+ * @param {Object} p
+ * @param {number} p.initiateTag
+ * @param {number} p.a_rwnd - advertised receiver window
+ * @param {number} p.outStreams
+ * @param {number} p.inStreams
+ * @param {number} p.initialTSN
+ * @returns {Buffer}
+ */
+export function encodeInitBody({ initiateTag, a_rwnd, outStreams, inStreams, initialTSN }: InitBodyParams): Buffer {
+  const b = Buffer.alloc(16);
+  b.writeUInt32BE(initiateTag >>> 0, 0);
+  b.writeUInt32BE(a_rwnd >>> 0, 4);
+  b.writeUInt16BE(outStreams, 8);
+  b.writeUInt16BE(inStreams, 10);
+  b.writeUInt32BE(initialTSN >>> 0, 12);
+  return b;
+}
+
+/**
+ * Parse an INIT/INIT_ACK body.
+ * @param {Buffer} body
+ * @returns {{initiateTag:number,a_rwnd:number,outStreams:number,inStreams:number,initialTSN:number,params:Array}}
+ */
+export function parseInitBody(body: Buffer): ParsedInitBody {
+  return {
+    initiateTag: body.readUInt32BE(0),
+    a_rwnd: body.readUInt32BE(4),
+    outStreams: body.readUInt16BE(8),
+    inStreams: body.readUInt16BE(10),
+    initialTSN: body.readUInt32BE(12),
+    params: parseParams(body.slice(16)),
+  };
+}
+
+/**
+ * Encode a DATA chunk body (RFC 4960 §3.3.1).
+ * @param {Object} p
+ * @param {number} p.tsn
+ * @param {number} p.streamId
+ * @param {number} p.streamSeq
+ * @param {number} p.ppid
+ * @param {Buffer} p.userData
+ * @returns {{flags:number, body:Buffer}}
+ */
+export function encodeDataBody({ tsn, streamId, streamSeq, ppid, userData, unordered = false, beginning = true, ending = true }: DataBodyParams): EncodedDataBody {
+  const head = Buffer.alloc(12);
+  head.writeUInt32BE(tsn >>> 0, 0);
+  head.writeUInt16BE(streamId, 4);
+  head.writeUInt16BE(streamSeq, 6);
+  head.writeUInt32BE(ppid >>> 0, 8);
+  let flags = 0;
+  if (ending) flags |= 0x01; // E
+  if (beginning) flags |= 0x02; // B
+  if (unordered) flags |= 0x04; // U
+  return { flags, body: Buffer.concat([head, userData]) };
+}
+
+/**
+ * Parse a DATA chunk body.
+ * @param {number} flags
+ * @param {Buffer} body
+ */
+export function parseDataBody(flags: number, body: Buffer): ParsedDataBody {
+  return {
+    unordered: !!(flags & 0x04),
+    beginning: !!(flags & 0x02),
+    ending: !!(flags & 0x01),
+    tsn: body.readUInt32BE(0),
+    streamId: body.readUInt16BE(4),
+    streamSeq: body.readUInt16BE(6),
+    ppid: body.readUInt32BE(8),
+    userData: body.slice(12),
+  };
+}
+
+/**
+ * Encode a SACK chunk body (cumulative ack only, no gap/dup for simplicity but
+ * gap blocks supported via params).
+ * @param {Object} p
+ * @param {number} p.cumulativeTSNAck
+ * @param {number} p.a_rwnd
+ * @param {Array<[number,number]>} [p.gapBlocks] - [start,end] offsets from cumAck+1
+ * @param {Array<number>} [p.dupTSNs]
+ * @returns {Buffer}
+ */
+export function encodeSackBody({ cumulativeTSNAck, a_rwnd, gapBlocks = [], dupTSNs = [] }: SackBodyParams): Buffer {
+  const b = Buffer.alloc(12 + gapBlocks.length * 4 + dupTSNs.length * 4);
+  b.writeUInt32BE(cumulativeTSNAck >>> 0, 0);
+  b.writeUInt32BE(a_rwnd >>> 0, 4);
+  b.writeUInt16BE(gapBlocks.length, 8);
+  b.writeUInt16BE(dupTSNs.length, 10);
+  let o = 12;
+  for (const [start, end] of gapBlocks) {
+    b.writeUInt16BE(start, o); b.writeUInt16BE(end, o + 2); o += 4;
+  }
+  for (const d of dupTSNs) { b.writeUInt32BE(d >>> 0, o); o += 4; }
+  return b;
+}
+
+/**
+ * Parse a SACK chunk body.
+ */
+export function parseSackBody(body: Buffer): ParsedSackBody {
+  const cumulativeTSNAck = body.readUInt32BE(0);
+  const a_rwnd = body.readUInt32BE(4);
+  const numGap = body.readUInt16BE(8);
+  const numDup = body.readUInt16BE(10);
+  const gapBlocks: Array<[number, number]> = [];
+  let o = 12;
+  for (let i = 0; i < numGap; i++) {
+    gapBlocks.push([body.readUInt16BE(o), body.readUInt16BE(o + 2)]);
+    o += 4;
+  }
+  const dupTSNs: number[] = [];
+  for (let i = 0; i < numDup; i++) { dupTSNs.push(body.readUInt32BE(o)); o += 4; }
+  return { cumulativeTSNAck, a_rwnd, gapBlocks, dupTSNs };
+}

package/src/sctp/crc32c.ts

@@ -0,0 +1,57 @@
+/**
+ * @file crc32c.ts
+ * @description CRC-32C (Castagnoli) checksum for SCTP packets (RFC 4960 App. B,
+ * polynomial 0x1EDC6F41), reflected input/output, used with the SCTP-specific
+ * byte ordering described in RFC 4960 §6.8 / RFC 3309.
+ * @module sctp/crc32c
+ */
+
+// Precomputed reflected table for polynomial 0x1EDC6F41 (reflected 0x82F63B78).
+const TABLE: Uint32Array = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0x82f63b78 ^ (c >>> 1) : c >>> 1;
+    }
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+
+/**
+ * Compute the raw reflected CRC-32C over a buffer.
+ * @returns unsigned 32-bit
+ */
+export function crc32c(buf: Buffer): number {
+  let crc = 0xffffffff;
+  for (let i = 0; i < buf.length; i++) {
+    crc = TABLE[(crc ^ buf[i]!) & 0xff]! ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+/**
+ * Insert the SCTP checksum into a packet. The checksum field (bytes 8..11 of
+ * the common header) is zeroed, the CRC computed over the whole packet, then
+ * written back in little-endian byte order (RFC 4960 §6.8, RFC 3309).
+ * @param packet - full SCTP packet (header + chunks)
+ * @returns the same packet, checksum filled in
+ */
+export function applyChecksum(packet: Buffer): Buffer {
+  packet.writeUInt32LE(0, 8);
+  const crc = crc32c(packet);
+  packet.writeUInt32LE(crc, 8);
+  return packet;
+}
+
+/**
+ * Validate the checksum of a received SCTP packet.
+ */
+export function verifyChecksum(packet: Buffer): boolean {
+  const original = packet.readUInt32LE(8);
+  packet.writeUInt32LE(0, 8);
+  const crc = crc32c(packet);
+  packet.writeUInt32LE(original, 8); // restore
+  return crc === original;
+}

package/src/sctp/datachannel-manager.ts

@@ -0,0 +1,187 @@
+/**
+ * @file datachannel-manager.ts
+ * @description Bridges SCTP streams + DCEP to RTCDataChannel instances.
+ * @module sctp/datachannel-manager
+ *
+ * Responsibilities:
+ *  - Allocate SCTP stream IDs per RFC 8832 §6: the DTLS client (a=setup:active)
+ *    uses even stream IDs, the DTLS server uses odd.
+ *  - Send DATA_CHANNEL_OPEN and await DATA_CHANNEL_ACK; respond to inbound OPEN.
+ *  - Map outgoing string/binary sends to the correct PPID, and incoming PPIDs
+ *    back to string/binary, including the EMPTY variants for zero-length data.
+ */
+
+'use strict';
+
+import { EventEmitter } from 'events';
+import * as dcep from './dcep';
+import { PPID } from './chunks';
+import type { SctpAssociation, SctpMessage } from './association';
+import { RTCDataChannel, RTCDataChannelEvents } from '../datachannel/RTCDataChannel';
+
+/** Subset of RTCDataChannelInit used when opening/accepting channels. */
+interface ChannelInit {
+  ordered?: boolean;
+  maxRetransmits?: number | null;
+  maxPacketLifeTime?: number | null;
+  protocol?: string;
+}
+
+/** A locally tracked channel and whether its DCEP open has been acked. */
+interface ChannelEntry {
+  channel: RTCDataChannel;
+  acked: boolean;
+}
+
+/** Information surfaced on the 'open-request' event for an inbound channel. */
+export interface OpenRequestInfo {
+  streamId: number;
+  label: string;
+  protocol: string;
+  ordered: boolean;
+  channelType: number;
+  reliabilityParameter: number;
+}
+
+class DataChannelManager extends EventEmitter {
+  #sctp: SctpAssociation;
+  #channels: Map<number, ChannelEntry>; // streamId -> { channel, acked }
+  #nextStreamId: number;
+
+  /**
+   * @param {import('./association').SctpAssociation} association
+   * @param {boolean} isDtlsClient - true if we are the DTLS client (even IDs)
+   */
+  constructor(association: SctpAssociation, isDtlsClient: boolean) {
+    super();
+    this.#sctp = association;
+    this.#channels = new Map(); // streamId -> { channel, acked }
+    this.#nextStreamId = isDtlsClient ? 0 : 1;
+
+    this.#sctp.on('message', (m: SctpMessage) => this.#onSctpMessage(m));
+  }
+
+  /**
+   * Open a channel initiated locally.
+   * @param {import('../datachannel/RTCDataChannel').RTCDataChannel} channel
+   * @param {Object} init - { ordered, maxRetransmits, maxPacketLifeTime, protocol }
+   */
+  openChannel(channel: RTCDataChannel, init: ChannelInit = {}): void {
+    let streamId = channel.id;
+    if (streamId === null || streamId === undefined) {
+      streamId = this.#allocateStreamId();
+      channel.emit(RTCDataChannelEvents.SET_ID, streamId);
+    }
+    this.#channels.set(streamId, { channel, acked: false });
+    this.#attachSender(channel, streamId, init);
+
+    if (!channel.negotiated) {
+      const open = dcep.encodeOpen({
+        channelType: this.#channelType(init),
+        priority: 0,
+        reliabilityParameter: this.#reliabilityParam(init),
+        label: channel.label,
+        protocol: init.protocol || channel.protocol || '',
+      });
+      this.#sctp.sendData(streamId, PPID.DCEP, open);
+      // Negotiated=false channels open after receiving DATA_CHANNEL_ACK.
+    } else {
+      // Pre-negotiated: considered open immediately.
+      (this.#channels.get(streamId) as ChannelEntry).acked = true;
+      channel.emit(RTCDataChannelEvents.OPEN);
+    }
+  }
+
+  #allocateStreamId(): number {
+    let id = this.#nextStreamId;
+    while (this.#channels.has(id)) id += 2;
+    this.#nextStreamId = id + 2;
+    return id;
+  }
+
+  #channelType(init: ChannelInit): number {
+    const unordered = init.ordered === false;
+    if (init.maxRetransmits != null) {
+      return unordered
+        ? dcep.CHANNEL_TYPE.PARTIAL_RELIABLE_REXMIT_UNORDERED
+        : dcep.CHANNEL_TYPE.PARTIAL_RELIABLE_REXMIT;
+    }
+    if (init.maxPacketLifeTime != null) {
+      return unordered
+        ? dcep.CHANNEL_TYPE.PARTIAL_RELIABLE_TIMED_UNORDERED
+        : dcep.CHANNEL_TYPE.PARTIAL_RELIABLE_TIMED;
+    }
+    return unordered ? dcep.CHANNEL_TYPE.RELIABLE_UNORDERED : dcep.CHANNEL_TYPE.RELIABLE;
+  }
+
+  #reliabilityParam(init: ChannelInit): number {
+    if (init.maxRetransmits != null) return init.maxRetransmits >>> 0;
+    if (init.maxPacketLifeTime != null) return init.maxPacketLifeTime >>> 0;
+    return 0;
+  }
+
+  /** Wire the channel's outbound SEND events -> SCTP DATA with the right PPID. */
+  #attachSender(channel: RTCDataChannel, streamId: number, init: ChannelInit): void {
+    const unordered = init.ordered === false;
+    channel.on(RTCDataChannelEvents.SEND, (data: Buffer, isBinary: boolean) => {
+      let ppid: number;
+      if (isBinary) {
+        ppid = data.length === 0 ? PPID.BINARY_EMPTY : PPID.BINARY;
+      } else {
+        ppid = data.length === 0 ? PPID.STRING_EMPTY : PPID.STRING;
+      }
+      // EMPTY PPIDs still need one byte on the wire (RFC 8831 §6.6).
+      const payload = data.length === 0 ? Buffer.from([0]) : data;
+      this.#sctp.sendData(streamId, ppid, payload, { unordered });
+    });
+  }
+
+  #onSctpMessage(m: SctpMessage): void {
+    if (m.ppid === PPID.DCEP) {
+      this.#onDcep(m);
+      return;
+    }
+    const entry = this.#channels.get(m.streamId);
+    if (!entry) return; // data for unknown channel
+    const isBinary = m.ppid === PPID.BINARY || m.ppid === PPID.BINARY_EMPTY || m.ppid === PPID.BINARY_PARTIAL;
+    const isEmpty = m.ppid === PPID.STRING_EMPTY || m.ppid === PPID.BINARY_EMPTY;
+    const data = isEmpty ? Buffer.alloc(0) : m.data;
+    entry.channel.emit(RTCDataChannelEvents.RECEIVE, data, isBinary);
+  }
+
+  #onDcep(m: SctpMessage): void {
+    const type = dcep.messageType(m.data);
+    if (type === dcep.MESSAGE_TYPE.DATA_CHANNEL_OPEN) {
+      const open = dcep.decodeOpen(m.data);
+      // Acknowledge and surface a new inbound channel.
+      this.#sctp.sendData(m.streamId, PPID.DCEP, dcep.encodeAck());
+      this.emit('open-request', {
+        streamId: m.streamId,
+        label: open.label,
+        protocol: open.protocol,
+        ordered: !open.unordered,
+        channelType: open.channelType,
+        reliabilityParameter: open.reliabilityParameter,
+      });
+    } else if (type === dcep.MESSAGE_TYPE.DATA_CHANNEL_ACK) {
+      const entry = this.#channels.get(m.streamId);
+      if (entry && !entry.acked) {
+        entry.acked = true;
+        entry.channel.emit(RTCDataChannelEvents.OPEN);
+      }
+    }
+  }
+
+  /**
+   * Register an inbound channel (created in response to 'open-request') and
+   * attach its sender.
+   */
+  acceptChannel(channel: RTCDataChannel, info: OpenRequestInfo): void {
+    channel.emit(RTCDataChannelEvents.SET_ID, info.streamId);
+    this.#channels.set(info.streamId, { channel, acked: true });
+    this.#attachSender(channel, info.streamId, { ordered: info.ordered });
+    channel.emit(RTCDataChannelEvents.OPEN);
+  }
+}
+
+export { DataChannelManager };

package/src/sctp/dcep.ts

@@ -0,0 +1,94 @@
+/**
+ * @file dcep.ts
+ * @description Data Channel Establishment Protocol (RFC 8832) message codec.
+ * @module sctp/dcep
+ *
+ * DCEP runs on PPID 50 and negotiates a data channel on an SCTP stream:
+ *   DATA_CHANNEL_OPEN (0x03)  -> DATA_CHANNEL_ACK (0x02)
+ */
+
+'use strict';
+
+export const MESSAGE_TYPE = Object.freeze({
+  DATA_CHANNEL_ACK: 0x02,
+  DATA_CHANNEL_OPEN: 0x03,
+});
+
+// Channel types (reliability/ordering), RFC 8832 §5.1.
+export const CHANNEL_TYPE = Object.freeze({
+  RELIABLE: 0x00,
+  RELIABLE_UNORDERED: 0x80,
+  PARTIAL_RELIABLE_REXMIT: 0x01,
+  PARTIAL_RELIABLE_REXMIT_UNORDERED: 0x81,
+  PARTIAL_RELIABLE_TIMED: 0x02,
+  PARTIAL_RELIABLE_TIMED_UNORDERED: 0x82,
+});
+
+export interface OpenParams {
+  channelType: number;
+  priority?: number;
+  reliabilityParameter?: number;
+  label?: string;
+  protocol?: string;
+}
+
+export interface DecodedOpen {
+  channelType: number;
+  priority: number;
+  reliabilityParameter: number;
+  label: string;
+  protocol: string;
+  unordered: boolean;
+}
+
+/**
+ * Encode a DATA_CHANNEL_OPEN message.
+ * @param {Object} p
+ * @param {number} p.channelType
+ * @param {number} p.priority
+ * @param {number} p.reliabilityParameter
+ * @param {string} p.label
+ * @param {string} p.protocol
+ * @returns {Buffer}
+ */
+export function encodeOpen({ channelType, priority = 0, reliabilityParameter = 0, label = '', protocol = '' }: OpenParams): Buffer {
+  const labelBuf = Buffer.from(label, 'utf8');
+  const protoBuf = Buffer.from(protocol, 'utf8');
+  const buf = Buffer.alloc(12 + labelBuf.length + protoBuf.length);
+  buf.writeUInt8(MESSAGE_TYPE.DATA_CHANNEL_OPEN, 0);
+  buf.writeUInt8(channelType, 1);
+  buf.writeUInt16BE(priority, 2);
+  buf.writeUInt32BE(reliabilityParameter >>> 0, 4);
+  buf.writeUInt16BE(labelBuf.length, 8);
+  buf.writeUInt16BE(protoBuf.length, 10);
+  labelBuf.copy(buf, 12);
+  protoBuf.copy(buf, 12 + labelBuf.length);
+  return buf;
+}
+
+/**
+ * Decode a DATA_CHANNEL_OPEN message.
+ * @param {Buffer} buf
+ * @returns {Object}
+ */
+export function decodeOpen(buf: Buffer): DecodedOpen {
+  const channelType = buf.readUInt8(1);
+  const priority = buf.readUInt16BE(2);
+  const reliabilityParameter = buf.readUInt32BE(4);
+  const labelLen = buf.readUInt16BE(8);
+  const protoLen = buf.readUInt16BE(10);
+  const label = buf.slice(12, 12 + labelLen).toString('utf8');
+  const protocol = buf.slice(12 + labelLen, 12 + labelLen + protoLen).toString('utf8');
+  const unordered = (channelType & 0x80) !== 0;
+  return { channelType, priority, reliabilityParameter, label, protocol, unordered };
+}
+
+/** Encode a DATA_CHANNEL_ACK message. */
+export function encodeAck(): Buffer {
+  return Buffer.from([MESSAGE_TYPE.DATA_CHANNEL_ACK]);
+}
+
+/** Return the message type of a DCEP buffer. */
+export function messageType(buf: Buffer): number {
+  return buf.length > 0 ? buf.readUInt8(0) : -1;
+}