343 lines
11 KiB
TypeScript
343 lines
11 KiB
TypeScript
import { Readable } from 'stream';
|
|
import { IFrame, IAddress } from './frame.types';
|
|
import { Address } from './address';
|
|
import { encodeHDLC } from './hdlc';
|
|
|
|
|
|
/**
|
|
* Represents an AX.25 frame with source/destination addresses, control field, and information field.
|
|
*
|
|
* This class serves as a base for specific frame types (InformationFrame, SupervisoryFrame, UnnumberedFrame)
|
|
* and provides common functionality such as parsing from raw bytes and encoding to AX.25 format.
|
|
*/
|
|
export class Frame implements IFrame {
|
|
destination: IAddress;
|
|
source: IAddress;
|
|
repeaters: IAddress[];
|
|
repeatedIndex: number | null;
|
|
control: number;
|
|
pid?: number;
|
|
info: Uint8Array;
|
|
raw?: Uint8Array;
|
|
|
|
constructor(src: Address | string = '', dst: Address | string = '', control = 0, info?: Uint8Array) {
|
|
this.source = typeof src === 'string' ? Address.fromString(src) : src;
|
|
this.destination = typeof dst === 'string' ? Address.fromString(dst) : dst;
|
|
this.repeaters = [];
|
|
this.repeatedIndex = null;
|
|
this.control = control;
|
|
this.info = info ?? new Uint8Array(0);
|
|
}
|
|
|
|
toString() {
|
|
// Format similar to common packet-radio programs
|
|
const src = this.source.toString();
|
|
const dst = this.destination.toString();
|
|
let ctl = '';
|
|
if (this instanceof UnnumberedFrame) {
|
|
ctl = `${this.uType}${this.pf ? '^' : '-'}`;
|
|
} else if (this instanceof SupervisoryFrame) {
|
|
ctl = `${this.sType}${this.nr}${this.pf ? 'v' : '-'}`;
|
|
} else if (this instanceof InformationFrame) {
|
|
ctl = `${this.ns}${this.nr}${this.pf ? '^' : '-'}`;
|
|
} else {
|
|
ctl = `CTL${this.control.toString(16)}`;
|
|
}
|
|
|
|
// Repeater path formatting
|
|
let viaStr = '';
|
|
if (this.repeaters && this.repeaters.length > 0) {
|
|
const path = this.repeaters.map((repeater, i) => {
|
|
let s = repeater.toString();
|
|
if (this.repeatedIndex === i) s += '*';
|
|
return s;
|
|
}).join(',');
|
|
viaStr = ` via ${path}`;
|
|
}
|
|
|
|
const pidStr = typeof this.pid === 'number' ? ` pid ${this.pid.toString(16).toUpperCase().padStart(2, '0')}` : '';
|
|
const lenStr = ` len=${this.info?.length ?? 0}`;
|
|
|
|
// If info looks like printable ASCII, append it after a colon
|
|
let infoText = '';
|
|
if (this.info && this.info.length > 0) {
|
|
const printable = Array.from(this.info).every(b => (b >= 0x20 && b <= 0x7e) || b === 0x09 || b === 0x0a || b === 0x0d);
|
|
if (printable) {
|
|
try {
|
|
infoText = `: ${new TextDecoder().decode(this.info)}`;
|
|
} catch {
|
|
infoText = '';
|
|
}
|
|
}
|
|
}
|
|
|
|
return `fm ${src} to ${dst}${viaStr} ctl ${ctl}${pidStr}${lenStr}${infoText}`;
|
|
}
|
|
|
|
/**
|
|
* Parses a given AX.25 frame payload and returns the corresponding Frame instance.
|
|
*
|
|
* This function processes the AX.25 protocol frame structure, extracting address fields,
|
|
* control field, and information field as appropriate. It supports parsing of I-frames,
|
|
* S-frames, and U-frames, returning the correct subclass of `Frame` for each.
|
|
*
|
|
* @param payload - The raw AX.25 frame as a Uint8Array.
|
|
* @returns {Frame} An instance of `InformationFrame`, `SupervisoryFrame`, or `UnnumberedFrame`
|
|
* depending on the type of AX.25 frame parsed.
|
|
* @throws {Error} If the payload is malformed, missing required fields, or does not conform to AX.25.
|
|
*/
|
|
static fromBytes(payload: Uint8Array): Frame {
|
|
// Skip leading null bytes (common in some KISS/TNC output)
|
|
let offset = 0;
|
|
while (offset < payload.length && payload[offset] === 0x00) {
|
|
offset++;
|
|
}
|
|
|
|
// Parse AX.25 addresses (each 7 bytes) until last address (bit 0 of SSID byte === 1)
|
|
const addrs: Address[] = [];
|
|
const repeaterFlags: boolean[] = [];
|
|
while (offset + 7 <= payload.length) {
|
|
const field = payload.slice(offset, offset + 7);
|
|
const addr = Address.fromBytes(field);
|
|
const isLast = addr.getExtension();
|
|
const hasRepeated = addr.getCH();
|
|
addrs.push(addr);
|
|
repeaterFlags.push(hasRepeated);
|
|
offset += 7;
|
|
if (isLast) break;
|
|
}
|
|
|
|
// Need at least destination and source addresses
|
|
if (addrs.length < 2) throw new Error('AX.25: not enough address fields');
|
|
|
|
// next byte: control
|
|
if (offset >= payload.length) throw new Error('AX.25: missing control byte');
|
|
const control = payload[offset];
|
|
offset += 1;
|
|
|
|
// Addresses as Address objects
|
|
const dst: Address = addrs[0];
|
|
const src: Address = addrs[1];
|
|
const repeaters: Address[] = addrs.length > 2 ? addrs.slice(2) : [];
|
|
const repeatedIndex = repeaterFlags.length > 2 ? repeaterFlags.slice(2).lastIndexOf(true) : -1;
|
|
|
|
// Decode control field (only 1-byte control supported here)
|
|
// I-frame: bit0 == 0
|
|
if ((control & 0x01) === 0) {
|
|
const ns = (control >> 1) & 0x07;
|
|
const pf = (control >> 4) & 0x01;
|
|
const nr = (control >> 5) & 0x07;
|
|
const info = payload.slice(offset);
|
|
const f = new InformationFrame(src, dst, control, info, ns, nr, pf);
|
|
f.repeaters = repeaters;
|
|
f.repeatedIndex = repeatedIndex >= 0 ? repeatedIndex : null;
|
|
f.raw = payload;
|
|
return f;
|
|
}
|
|
|
|
// S-frame: bits 0-1 == 01
|
|
if ((control & 0x03) === 0x01) {
|
|
const sCode = (control >> 2) & 0x03;
|
|
const pf = (control >> 4) & 0x01;
|
|
const nr = (control >> 5) & 0x07;
|
|
let sType: 'RR' | 'RNR' | 'REJ' | 'SREJ' = 'RR';
|
|
switch (sCode) {
|
|
case 0:
|
|
sType = 'RR';
|
|
break;
|
|
case 1:
|
|
sType = 'RNR';
|
|
break;
|
|
case 2:
|
|
sType = 'REJ';
|
|
break;
|
|
case 3:
|
|
sType = 'SREJ';
|
|
break;
|
|
}
|
|
const f = new SupervisoryFrame(src, dst, control, sType, nr, pf);
|
|
f.repeaters = repeaters;
|
|
f.repeatedIndex = repeatedIndex >= 0 ? repeatedIndex : null;
|
|
f.raw = payload;
|
|
return f;
|
|
}
|
|
|
|
// U-frame: bits 0-1 == 11
|
|
{
|
|
const pf = (control >> 4) & 0x01;
|
|
// common U-frame types (not exhaustive)
|
|
let uType = `U(${control.toString(16)})`;
|
|
switch (control) {
|
|
case 0x03:
|
|
uType = 'UI';
|
|
break;
|
|
case 0x2f:
|
|
uType = 'SABM';
|
|
break;
|
|
case 0x63:
|
|
uType = 'UA';
|
|
break;
|
|
case 0x43:
|
|
uType = 'DISC';
|
|
break;
|
|
case 0x0f:
|
|
uType = 'SNRM';
|
|
break;
|
|
}
|
|
let uPid: number | undefined;
|
|
let info: Uint8Array = new Uint8Array(0);
|
|
if (uType === 'UI') {
|
|
if (offset < payload.length) {
|
|
uPid = payload[offset];
|
|
offset += 1;
|
|
info = payload.slice(offset);
|
|
}
|
|
}
|
|
const f = new UnnumberedFrame(src, dst, control, uType, pf, info);
|
|
f.repeaters = repeaters;
|
|
f.repeatedIndex = repeatedIndex >= 0 ? repeatedIndex : null;
|
|
f.pid = uPid;
|
|
f.raw = payload;
|
|
return f;
|
|
}
|
|
}
|
|
}
|
|
|
|
export class InformationFrame extends Frame {
|
|
ns: number;
|
|
nr: number;
|
|
pf: number;
|
|
|
|
constructor(src: Address, dst: Address, control: number, info: Uint8Array, ns: number, nr: number, pf: number) {
|
|
super(src, dst, control, info);
|
|
this.ns = ns;
|
|
this.nr = nr;
|
|
this.pf = pf;
|
|
}
|
|
}
|
|
|
|
export class SupervisoryFrame extends Frame {
|
|
sType: 'RR' | 'RNR' | 'REJ' | 'SREJ';
|
|
nr: number;
|
|
pf: number;
|
|
|
|
constructor(src: Address, dst: Address, control: number, sType: 'RR' | 'RNR' | 'REJ' | 'SREJ', nr: number, pf: number) {
|
|
super(src, dst, control, new Uint8Array(0));
|
|
this.sType = sType;
|
|
this.nr = nr;
|
|
this.pf = pf;
|
|
}
|
|
}
|
|
|
|
export class UnnumberedFrame extends Frame {
|
|
uType: string;
|
|
pf: number;
|
|
|
|
constructor(src: Address, dst: Address, control: number, uType: string, pf: number, info?: Uint8Array) {
|
|
super(src, dst, control, info);
|
|
this.uType = uType;
|
|
this.pf = pf;
|
|
}
|
|
}
|
|
|
|
export const buildIControl: (ns: number, nr: number, pf?: number) => number = (ns, nr, pf = 0) => {
|
|
// bit0 = 0 for I-frames; ns in bits 1-3, pf in bit4, nr in bits 5-7
|
|
return ((ns & 0x07) << 1) | ((pf & 0x01) << 4) | ((nr & 0x07) << 5);
|
|
};
|
|
|
|
|
|
export const buildSControl: (sType: 'RR' | 'RNR' | 'REJ' | 'SREJ', nr: number, pf?: number) => number = (sType, nr, pf = 0) => {
|
|
const sCode = sType === 'RR' ? 0 : sType === 'RNR' ? 1 : sType === 'REJ' ? 2 : 3;
|
|
// bits 0-1 = 01
|
|
return 0x01 | (sCode << 2) | ((pf & 0x01) << 4) | ((nr & 0x07) << 5);
|
|
};
|
|
|
|
export const buildUControl: (uType: string, pf?: number) => number = (uType, pf = 0) => {
|
|
// common mappings
|
|
switch (uType) {
|
|
case 'UI':
|
|
return 0x03 | ((pf & 0x01) << 4);
|
|
case 'SABM':
|
|
return 0x2f | ((pf & 0x01) << 4);
|
|
case 'UA':
|
|
return 0x63 | ((pf & 0x01) << 4);
|
|
case 'DISC':
|
|
return 0x43 | ((pf & 0x01) << 4);
|
|
default:
|
|
return 0x03 | ((pf & 0x01) << 4);
|
|
}
|
|
};
|
|
|
|
// Extended control builders (2-byte) - minimal support for encoding larger NS/NR
|
|
export const buildIControlExtended: (ns: number, nr: number, pf?: number) => Uint8Array = (ns, nr, pf = 0) => {
|
|
const b1 = ((ns & 0x7f) << 1) | ((pf & 0x01) << 4);
|
|
const b2 = ((nr & 0x7f) << 1);
|
|
return Uint8Array.from([b1 & 0xff, b2 & 0xff]);
|
|
};
|
|
|
|
export const buildSControlExtended: (sType: 'RR' | 'RNR' | 'REJ' | 'SREJ', nr: number, pf?: number) => Uint8Array = (sType, nr, pf = 0) => {
|
|
const sCode = sType === 'RR' ? 0 : sType === 'RNR' ? 1 : sType === 'REJ' ? 2 : 3;
|
|
const b1 = 0x01 | (sCode << 2) | ((pf & 0x01) << 4);
|
|
const b2 = ((nr & 0x7f) << 1);
|
|
return Uint8Array.from([b1 & 0xff, b2 & 0xff]);
|
|
};
|
|
|
|
export const encodeFrame: (frame: Frame) => Uint8Array = (frame) => {
|
|
const parts: number[] = [];
|
|
// addresses: destination then source; mark source as last
|
|
parts.push(...(frame.destination as IAddress).toBytes(false));
|
|
parts.push(...(frame.source as IAddress).toBytes(true));
|
|
// control
|
|
parts.push(frame.control & 0xff);
|
|
|
|
if (frame instanceof UnnumberedFrame) {
|
|
if (frame.uType === 'UI') {
|
|
parts.push(frame.pid ?? 0xf0);
|
|
parts.push(...(frame.info ?? new Uint8Array(0)));
|
|
}
|
|
// other U-frames have no pid/info in AX.25 common usage
|
|
} else if (frame instanceof InformationFrame) {
|
|
parts.push(...(frame.info ?? new Uint8Array(0)));
|
|
} else if (frame instanceof SupervisoryFrame) {
|
|
// S-frames typically carry no PID/info
|
|
}
|
|
|
|
return Uint8Array.from(parts);
|
|
};
|
|
|
|
export const toHDLC: (frame: Frame) => Uint8Array = (frame) => {
|
|
const ax25 = encodeFrame(frame);
|
|
return encodeHDLC(ax25, { includeFcs: true });
|
|
};
|
|
|
|
export const toWire: (frame: Frame) => Buffer = (frame) => {
|
|
const h = toHDLC(frame);
|
|
return Buffer.from(h.buffer, h.byteOffset, h.byteLength);
|
|
};
|
|
|
|
export const toWireStream: (frame: Frame) => Readable = (frame) => {
|
|
const buf = toWire(frame);
|
|
const r = new Readable();
|
|
r.push(buf);
|
|
r.push(null);
|
|
return r;
|
|
};
|
|
|
|
const addrsRaw: (payload: Uint8Array, offset: number) => Uint8Array = (payload, offset) => payload.slice(offset, offset + 7);
|
|
|
|
export const encodeAX25: (dst: Address | string, src: Address | string, info: Uint8Array, options?: { ui?: boolean }) => Uint8Array = (dst, src, info, options) => {
|
|
// dst and src should be like 'CALL-SSID' or 'CALL'
|
|
const dstAddr = typeof dst === 'string' ? Address.fromString(dst) : dst;
|
|
const srcAddr = typeof src === 'string' ? Address.fromString(src) : src;
|
|
const parts: number[] = [];
|
|
const dfield = dstAddr.toBytes(false);
|
|
const sfield = srcAddr.toBytes(true); // mark source as last address
|
|
parts.push(...dfield, ...sfield);
|
|
// control
|
|
parts.push(options?.ui ? 0x03 : 0x03);
|
|
// PID - use 0xf0 (no layer 3) as default for UI-frames
|
|
parts.push(0xf0);
|
|
parts.push(...info);
|
|
return Uint8Array.from(parts);
|
|
}
|