node-rtc-connection 2.0.4 → 2.0.6

package/src/sctp/chunks.ts

@@ -1,350 +0,0 @@
-/**
- * @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

@@ -1,57 +0,0 @@
-/**
- * @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

@@ -1,187 +0,0 @@
-/**
- * @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

@@ -1,94 +0,0 @@
-/**
- * @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;
-}