import { canonicalIp, isUnspecifiedIp } from "./traffic-flow-ip.js" export interface ParsedFlow { src: string dst: string proto: number srcPort: number dstPort: number bytes: number packets: number inIface: string outIface: string nextHop: string flowStartMs: number flowEndMs: number natSrc: string natDst: string natSrcPort: number natDstPort: number } export type ParsedFlowInput = Partial & Pick export function emptyParsedFlow(): ParsedFlow { return { src: "", dst: "", proto: 0, srcPort: 0, dstPort: 0, bytes: 0, packets: 0, inIface: "", outIface: "", nextHop: "", flowStartMs: 0, flowEndMs: 0, natSrc: "", natDst: "", natSrcPort: 0, natDstPort: 0, } } export function normalizeParsedFlow(flow: ParsedFlowInput): ParsedFlow { return { ...emptyParsedFlow(), ...flow, src: canonicalIp(flow.src) || flow.src || "", dst: canonicalIp(flow.dst) || flow.dst || "", nextHop: canonicalIp(flow.nextHop ?? ""), flowStartMs: flow.flowStartMs ?? 0, flowEndMs: flow.flowEndMs ?? 0, natSrc: canonicalIp(flow.natSrc ?? ""), natDst: canonicalIp(flow.natDst ?? ""), natSrcPort: flow.natSrcPort ?? 0, natDstPort: flow.natDstPort ?? 0, inIface: flow.inIface ?? "", outIface: flow.outIface ?? "", srcPort: flow.srcPort ?? 0, dstPort: flow.dstPort ?? 0, packets: flow.packets ?? 0, } } interface FieldSpec { type: number length: number } /** Trusted local receiver context, never read from the exported packet. * collectorSocketId identifies a receiver socket incarnation. A wildcard-bound * socket does not establish the packet's precise local destination IP. */ export interface FlowDatagramTransport { sourcePort: number; collectorSocketId: string } function templateScope(version: number, domain: number, transport?: FlowDatagramTransport): string { if (transport === undefined) return JSON.stringify([version, domain, "unknown-transport"]) if (!transport || !Number.isInteger(transport.sourcePort) || transport.sourcePort < 1 || transport.sourcePort > 65535 || typeof transport.collectorSocketId !== "string" || transport.collectorSocketId.length < 1 || transport.collectorSocketId.length > 128 || !/^[A-Za-z0-9_-]+$/.test(transport.collectorSocketId)) throw new Error("Invalid flow datagram transport context") return JSON.stringify([version, domain, "udp-socket", transport.sourcePort, transport.collectorSocketId]) } function scopedTemplateId(scope: string, id: number): string { return JSON.stringify([scope, id]) } interface Template { fields: FieldSpec[] refreshedAtMs: number v9Clock?: V9Clock v9ValidFrom?: V9Clock v9Conflicted?: true ipfixExportTime?: number ipfixValidFrom?: number ipfixConflicted?: true ipfixScope?: string ipfixResetMessage?: object } type V9Clock = { exportedAt: number; uptime: number; sequence: number } type IpfixClock = { exportTime: number; sequence: number } type IpfixScopeState = { clock?: IpfixClock; resetAt?: number } // RFC 3954 uses uint32 milliseconds for uptime and whole seconds for export time. function differentV9Boot(first: V9Clock, second: V9Clock): boolean { const elapsedExportMs = (second.exportedAt - first.exportedAt) * 1000 // Signed modular distance handles wrap and reordered datagrams. return Math.abs((second.uptime - first.uptime - elapsedExportMs) | 0) > 2000 } function compareV9Clock(first: V9Clock, second: V9Clock): number { return first.exportedAt - second.exportedAt || ((first.uptime - second.uptime) | 0) || ((first.sequence - second.sequence) | 0) } // RouterOS refreshes reuse IDs; its configurable record fields number in tens. // These generous retention budgets bound objects, not an asserted V8 byte size. export const FLOW_TEMPLATE_LIMITS = Object.freeze({ exporters: 256, perExporterTemplates: 256, templates: 4096, perTemplateFields: 256, perExporterFields: 8192, fields: 65536 }) // RFC7011 8.4: UDP lifetime is deployment-specific; use three times the // 30-minute refresh interval in the MikroTik MUM configuration example. // Longer exporter refresh intervals require an explicit collector override. // This is not active-flow-timeout, and data traffic never refreshes a template. export const FLOW_TEMPLATE_LIFETIME_MS = Number(process.env.FLOW_TEMPLATE_LIFETIME_MS ?? 90 * 60 * 1000) if (!Number.isSafeInteger(FLOW_TEMPLATE_LIFETIME_MS) || FLOW_TEMPLATE_LIFETIME_MS <= 0) { throw new Error("FLOW_TEMPLATE_LIFETIME_MS must be a positive safe integer in milliseconds") } const MAX_TEMPLATE_EXPORTERS = FLOW_TEMPLATE_LIMITS.exporters const templatesByExporter = new Map>() // Each scope exists only while its exporter retains at least one template. const ipfixScopes = new WeakMap, Map>() const fieldsByExporter = new Map() let templateCount = 0, fieldCount = 0, refusedTemplates = 0 export class FlowTemplateRefused extends Error { readonly code = "FLOW_TEMPLATE_REFUSED" constructor(readonly reason: "fields" | "exporter-templates" | "templates" | "exporter-fields" | "total-fields" | "truncated" | "missing-template") { super("NetFlow/IPFIX template refused: " + reason) } } function refuseTemplate(reason: FlowTemplateRefused["reason"]): never { refusedTemplates++; throw new FlowTemplateRefused(reason) } function forgetExporter(exporter: string): void { const previous = templatesByExporter.get(exporter) if (!previous) return templateCount -= previous.size; fieldCount -= fieldsByExporter.get(exporter) ?? 0 fieldsByExporter.delete(exporter); templatesByExporter.delete(exporter) } /** Lazy expiry uses local monotonic time, never exporter timestamps. Retention * remains bounded by existing caps; no sweeper timer, pending data or tombstones. * Empty exporter maps remain in the existing bounded LRU until normal eviction. */ function expireTemplate(exporter: string, map: Map, id: string, now: number): void { const retained = map.get(id) if (!retained || now - retained.refreshedAtMs < FLOW_TEMPLATE_LIFETIME_MS) return map.delete(id); templateCount--; fieldCount -= retained.fields.length const scope = retained.ipfixScope if (scope !== undefined && ![...map.values()].some(template => template.ipfixScope === scope)) { ipfixScopes.get(map)?.delete(scope) } fieldsByExporter.set(exporter, (fieldsByExporter.get(exporter) ?? 0) - retained.fields.length) } function dataTemplate(exporter: string, id: string, clock?: V9Clock, ipfixExportTime?: number, resetMessage?: object): Template { const map = templatesByExporter.get(exporter) if (map) expireTemplate(exporter, map, id, performance.now()) const retained = map?.get(id) // The existing ingress catches FlowTemplateRefused, exposes an error and // refuses publication. An undecodable datagram is not an observed zero. if (!retained || retained.v9Conflicted || clock && retained.v9Clock && differentV9Boot(retained.v9Clock, clock)) refuseTemplate("missing-template") if (clock && retained.v9ValidFrom && compareV9Clock(clock, retained.v9ValidFrom) < 0) refuseTemplate("missing-template") if (ipfixExportTime !== undefined && retained.ipfixValidFrom !== undefined && ipfixExportTime < retained.ipfixValidFrom) refuseTemplate("missing-template") const resetAt = retained.ipfixScope === undefined ? undefined : ipfixScopes.get(map!)?.get(retained.ipfixScope)?.resetAt if (retained.ipfixConflicted) refuseTemplate("missing-template") if (resetAt !== undefined) { const fresh = retained.ipfixExportTime! > resetAt || retained.ipfixExportTime === resetAt && retained.ipfixResetMessage !== undefined const inResetMessage = resetMessage !== undefined && retained.ipfixResetMessage === resetMessage if (!fresh || ipfixExportTime! <= resetAt && !inResetMessage) refuseTemplate("missing-template") } return retained } function templatesForExporter(exporter: string): Map { const existing = templatesByExporter.get(exporter) if (existing) { templatesByExporter.delete(exporter) templatesByExporter.set(exporter, existing) return existing } const created = new Map() templatesByExporter.set(exporter, created) fieldsByExporter.set(exporter, 0) while (templatesByExporter.size > MAX_TEMPLATE_EXPORTERS) { const oldest = templatesByExporter.keys().next().value if (oldest == null || oldest === exporter) break forgetExporter(oldest) } return created } /** Check retention budgets after bounded field staging and body validation. * The per-template count is checked before staging. A rejected replacement leaves * the complete old template and all accounting intact. No await splits commit. */ function admitTemplate(exporter: string, map: Map, id: string, count: number): void { if (count > FLOW_TEMPLATE_LIMITS.perTemplateFields) refuseTemplate("fields") const now = performance.now() for (const retainedId of map.keys()) expireTemplate(exporter, map, retainedId, now) const previous = map.get(id), added = previous ? 0 : 1, delta = count - (previous?.fields.length ?? 0) // Preview eviction without changing any retained state until validation succeeds. const victim = !templatesByExporter.has(exporter) && templatesByExporter.size >= MAX_TEMPLATE_EXPORTERS ? templatesByExporter.keys().next().value : undefined const releasedTemplates = victim === undefined ? 0 : templatesByExporter.get(victim)?.size ?? 0 const releasedFields = victim === undefined ? 0 : fieldsByExporter.get(victim) ?? 0 if (map.size + added > FLOW_TEMPLATE_LIMITS.perExporterTemplates) refuseTemplate("exporter-templates") if (templateCount - releasedTemplates + added > FLOW_TEMPLATE_LIMITS.templates) refuseTemplate("templates") if ((fieldsByExporter.get(exporter) ?? 0) + delta > FLOW_TEMPLATE_LIMITS.perExporterFields) refuseTemplate("exporter-fields") if (fieldCount - releasedFields + delta > FLOW_TEMPLATE_LIMITS.fields) refuseTemplate("total-fields") } function storeTemplate(exporter: string, map: Map, id: string, fields: FieldSpec[], v9Clock?: V9Clock, ipfix?: { scope: string; exportTime: number; resetMessage?: object }): void { const previous = map.get(id), delta = fields.length - (previous?.fields.length ?? 0) const ipfixExportTime = ipfix?.exportTime const resetAt = ipfix && ipfixScopes.get(map)?.get(ipfix.scope)?.resetAt if (v9Clock && previous?.v9Clock && previous.v9Clock.exportedAt > v9Clock.exportedAt) return if (ipfixExportTime !== undefined && previous?.ipfixExportTime !== undefined && previous.ipfixExportTime > ipfixExportTime) return if (ipfixExportTime !== undefined && resetAt !== undefined && ipfixExportTime <= resetAt && !ipfix?.resetMessage) return const sameLayout = previous && delta === 0 && fields.every((field, index) => field.type === previous.fields[index].type && field.length === previous.fields[index].length) if (v9Clock && previous?.v9Clock?.exportedAt === v9Clock.exportedAt) { if (previous.v9Conflicted || previous.fields.length > 0 && fields.length > 0 && differentV9Boot(previous.v9Clock, v9Clock)) { previous.v9Conflicted = true return } if (compareV9Clock(v9Clock, previous.v9Clock) < 0) return } // Export Time has one-second resolution. Conflicting definitions within // that second cannot be ordered using the message timestamp. if (previous && ipfixExportTime !== undefined && previous.ipfixExportTime === ipfixExportTime && (!sameLayout || previous.ipfixConflicted)) { previous.ipfixConflicted = true return } if (!previous) templateCount++ fieldCount += delta; fieldsByExporter.set(exporter, (fieldsByExporter.get(exporter) ?? 0) + delta) if (ipfix) { let scopes = ipfixScopes.get(map) if (!scopes) ipfixScopes.set(map, scopes = new Map()) if (!scopes.has(ipfix.scope)) scopes.set(ipfix.scope, {}) } // A refresh of the same layout must not move the first compatible packet. const v9ValidFrom = v9Clock && previous?.v9Clock ? sameLayout && !previous.v9Conflicted && !differentV9Boot(previous.v9Clock, v9Clock) ? previous.v9ValidFrom : v9Clock : undefined map.set(id, { fields, refreshedAtMs: performance.now(), v9Clock, v9ValidFrom, ipfixExportTime, ipfixScope: ipfix?.scope, ipfixResetMessage: ipfix?.resetMessage, ipfixValidFrom: sameLayout && !previous.ipfixConflicted && (resetAt === undefined || previous.ipfixExportTime! > resetAt) ? previous.ipfixValidFrom : ipfixExportTime }) } function templateFields(buf: Buffer, offset: number, end: number, count: number, enterprise: boolean) { const fields: FieldSpec[] = [] for (let index = 0; index < count; index++) { if (offset + 4 > end) refuseTemplate("truncated") const type = buf.readUInt16BE(offset), length = buf.readUInt16BE(offset + 2) offset += 4 if (enterprise && type & 0x8000) { if (offset + 4 > end) refuseTemplate("truncated") offset += 4 } fields.push({ type: enterprise ? type & 0x7fff : type, length }) } return { fields, next: offset } } function ipv4(buf: Buffer, offset: number): string { return `${buf[offset]}.${buf[offset + 1]}.${buf[offset + 2]}.${buf[offset + 3]}` } function usableIpfixIp(ip: string): boolean { const t = String(ip ?? "").trim() if (!t) return false return !isUnspecifiedIp(t) } function ipv6(buf: Buffer, offset: number): string { const parts: string[] = [] for (let i = 0; i < 8; i++) parts.push(buf.readUInt16BE(offset + i * 2).toString(16)) return parts.join(":") } const VAR_LEN = 0xffff function consumeField( buf: Buffer, off: number, length: number, limit: number, ): { data: Buffer; next: number } | null { if (length === VAR_LEN) { if (off >= limit) return null const first = buf[off]! if (first < 255) { const end = off + 1 + first if (end > limit) return null return { data: buf.subarray(off + 1, end), next: end } } if (off + 3 > limit) return null const len = buf.readUInt16BE(off + 1) const end = off + 3 + len if (end > limit) return null return { data: buf.subarray(off + 3, end), next: end } } const end = off + length if (end > limit) return null return { data: buf.subarray(off, end), next: end } } function fixedRecordSize(fields: FieldSpec[]): number | null { let n = 0 for (const f of fields) { if (f.length === VAR_LEN) return null n += f.length } return n } function readUint(buf: Buffer, offset: number, length: number): number { if (length === 1) return buf.readUInt8(offset) if (length === 2) return buf.readUInt16BE(offset) if (length === 4) return buf.readUInt32BE(offset) if (length === 8) { const big = buf.readBigUInt64BE(offset) const n = Number(big) return Number.isFinite(n) ? n : 0 } let v = 0 for (let i = 0; i < length; i++) v = (v << 8) + buf[offset + i] return v >>> 0 } function parseNetflowV5(buf: Buffer): ParsedFlow[] { if (buf.length < 24) return [] const count = buf.readUInt16BE(2) const out: ParsedFlow[] = [] let off = 24 for (let i = 0; i < count && off + 48 <= buf.length; i++) { out.push(normalizeParsedFlow({ src: ipv4(buf, off), dst: ipv4(buf, off + 4), packets: buf.readUInt32BE(off + 16), bytes: buf.readUInt32BE(off + 20), srcPort: buf.readUInt16BE(off + 32), dstPort: buf.readUInt16BE(off + 34), proto: buf.readUInt8(off + 38), inIface: String(buf.readUInt16BE(off + 12)), outIface: String(buf.readUInt16BE(off + 14)), })) off += 48 } return out } function parseIpfixTemplates(exporter: string, buf: Buffer, setStart: number, setEnd: number, setId: number, scope: string, exportTime: number, resetMessage?: object) { let off = setStart + 4 let map: Map | undefined while (off + 4 <= setEnd) { const templateId = buf.readUInt16BE(off) const fieldCount = buf.readUInt16BE(off + 2) off += 4 // This collector is UDP-only: RFC7011 section8.4 requires ignoring // withdrawals, including the four-byte Options withdrawal record. if (fieldCount === 0) continue if (fieldCount > FLOW_TEMPLATE_LIMITS.perTemplateFields) refuseTemplate("fields") if (setId === 3) { // options template: skip scope count if (off + 2 > setEnd) refuseTemplate("truncated") off += 2 } const parsed = templateFields(buf, off, setEnd, fieldCount, true) off = parsed.next if (templateId >= 256) { admitTemplate(exporter, map ?? templatesByExporter.get(exporter) ?? new Map(), scopedTemplateId(scope, templateId), fieldCount) map ??= templatesForExporter(exporter) storeTemplate(exporter, map, scopedTemplateId(scope, templateId), parsed.fields, undefined, { scope, exportTime, resetMessage }) } } } function recordFromFields( fields: FieldSpec[], buf: Buffer, offset: number, limit: number, ): { flow: ParsedFlow; next: number } | null { let off = offset let src = "" let dst = "" let proto = 0 let srcPort = 0 let dstPort = 0 let bytes = 0 let packets = 0 let inIface = "" let outIface = "" let ifaceName = "" let nextHop = "" let flowStartMs = 0 let flowEndMs = 0 let natSrc = "" let natDst = "" let natSrcPort = 0 let natDstPort = 0 for (const f of fields) { const field = consumeField(buf, off, f.length, limit) if (!field) return null const { data } = field switch (f.type) { case 8: if (data.length === 4) { const value = ipv4(data, 0) if (usableIpfixIp(value) || !usableIpfixIp(src)) src = value } break case 12: if (data.length === 4) { const value = ipv4(data, 0) if (usableIpfixIp(value) || !usableIpfixIp(dst)) dst = value } break case 27: if (data.length === 16 && !usableIpfixIp(src)) src = ipv6(data, 0) break case 28: if (data.length === 16 && !usableIpfixIp(dst)) dst = ipv6(data, 0) break case 15: if (data.length === 4 && !nextHop) nextHop = ipv4(data, 0) break case 18: if (data.length === 4 && !nextHop) nextHop = ipv4(data, 0) break case 62: if (data.length === 16 && !nextHop) nextHop = ipv6(data, 0) break case 225: if (data.length === 4) { const value = ipv4(data, 0) if (usableIpfixIp(value) || !usableIpfixIp(natSrc)) natSrc = value } break case 226: if (data.length === 4) { const value = ipv4(data, 0) if (usableIpfixIp(value) || !usableIpfixIp(natDst)) natDst = value } break case 281: if (data.length === 16 && !usableIpfixIp(natSrc)) { const value = ipv6(data, 0) if (usableIpfixIp(value)) natSrc = value } break case 282: if (data.length === 16 && !usableIpfixIp(natDst)) { const value = ipv6(data, 0) if (usableIpfixIp(value)) natDst = value } break case 227: natSrcPort = readUint(data, 0, data.length) break case 228: natDstPort = readUint(data, 0, data.length) break case 4: proto = readUint(data, 0, data.length) break case 7: srcPort = readUint(data, 0, data.length) break case 11: dstPort = readUint(data, 0, data.length) break case 1: bytes = readUint(data, 0, data.length) break case 2: packets = readUint(data, 0, data.length) break case 85: if (!bytes) bytes = readUint(data, 0, data.length) break case 86: if (!packets) packets = readUint(data, 0, data.length) break case 10: inIface = String(readUint(data, 0, data.length)) break case 14: outIface = String(readUint(data, 0, data.length)) break case 21: if (!flowEndMs) flowEndMs = readUint(data, 0, data.length) break case 22: if (!flowStartMs) flowStartMs = readUint(data, 0, data.length) break case 150: if (!flowStartMs) flowStartMs = readUint(data, 0, data.length) * 1000 break case 151: if (!flowEndMs) flowEndMs = readUint(data, 0, data.length) * 1000 break case 152: flowStartMs = readUint(data, 0, data.length) break case 153: flowEndMs = readUint(data, 0, data.length) break case 82: ifaceName = data.toString("utf8").replace(/\0/g, "").trim() break default: break } off = field.next } if (ifaceName && !inIface) inIface = ifaceName if (natSrc && !usableIpfixIp(src) && usableIpfixIp(natSrc)) src = natSrc if (natDst && !usableIpfixIp(dst) && usableIpfixIp(natDst)) dst = natDst return { flow: normalizeParsedFlow({ src, dst, proto, srcPort, dstPort, bytes, packets, inIface, outIface, nextHop, flowStartMs, flowEndMs, natSrc, natDst, natSrcPort, natDstPort, }), next: off, } } function parseDataRecords( tpl: Template, buf: Buffer, recOff: number, setEnd: number, out: ParsedFlow[], ) { const size = fixedRecordSize(tpl.fields) while (recOff + 1 < setEnd) { if (size != null && recOff + size > setEnd) break const parsed = recordFromFields(tpl.fields, buf, recOff, setEnd) if (!parsed) break if (parsed.flow.src || parsed.flow.dst) out.push(parsed.flow) if (parsed.next <= recOff) break recOff = parsed.next } } function parseIpfix(buf: Buffer, exporter: string, scope: string): ParsedFlow[] { if (buf.length < 16) return [] const total = buf.readUInt16BE(2) const exportTime = buf.readUInt32BE(4) const sequence = buf.readUInt32BE(8) const map = templatesByExporter.get(exporter) const state = map && ipfixScopes.get(map)?.get(scope) const previous = state?.clock const delta = previous ? (sequence - previous.sequence) >>> 0 : 0 const regressed = state && previous && exportTime > previous.exportTime && delta > 0x80000000 const end = Math.min(buf.length, total) let resetMessage: object | undefined if (regressed) { for (let start = 16; start + 4 <= end;) { const length = buf.readUInt16BE(start + 2) if (length < 4 || start + length > end) break if (buf.readUInt16BE(start) >= 256) { resetMessage = {} break } start += length } } if (regressed && resetMessage) { state.resetAt = exportTime state.clock = undefined } let off = 16 const out: ParsedFlow[] = [] let hasData = false while (off + 4 <= end) { const setId = buf.readUInt16BE(off) const setLen = buf.readUInt16BE(off + 2) if (setLen < 4 || off + setLen > end) break const setEnd = off + setLen if (setId === 2 || setId === 3) { parseIpfixTemplates(exporter, buf, off, setEnd, setId, scope, exportTime, resetMessage) } else if (setId >= 256) { const tpl = dataTemplate(exporter, scopedTemplateId(scope, setId), undefined, exportTime, resetMessage) parseDataRecords(tpl, buf, off + 4, setEnd, out) hasData = true } off = setEnd } const currentMap = templatesByExporter.get(exporter) const current = currentMap && ipfixScopes.get(currentMap)?.get(scope) if (hasData && current && (!current.clock || exportTime >= current.clock.exportTime && ((sequence - current.clock.sequence) >>> 0) < 0x80000000)) { current.clock = { exportTime, sequence } } return out } function parseNetflowV9(buf: Buffer, exporter: string, scope: string): ParsedFlow[] { if (buf.length < 20) return [] const count = buf.readUInt16BE(2) const clock = { exportedAt: buf.readUInt32BE(8), uptime: buf.readUInt32BE(4), sequence: buf.readUInt32BE(12) } let off = 20 const out: ParsedFlow[] = [] let map = templatesByExporter.get(exporter) if (map) templatesForExporter(exporter) for (let s = 0; s < count && off + 4 <= buf.length; s++) { const setId = buf.readUInt16BE(off) const setLen = buf.readUInt16BE(off + 2) if (setLen < 4 || off + setLen > buf.length) break const setEnd = off + setLen if (setId === 0) { let tOff = off + 4 while (tOff + 4 <= setEnd) { const templateId = buf.readUInt16BE(tOff) const fieldCount = buf.readUInt16BE(tOff + 2) tOff += 4 // Preserve v9's existing zero-field replacement semantics. RFC7011's // UDP withdrawal-ignore rule applies to IPFIX, not the v9 format. if (fieldCount === 0) { if (templateId >= 256) { admitTemplate(exporter, map ?? new Map(), scopedTemplateId(scope, templateId), 0) map ??= templatesForExporter(exporter); storeTemplate(exporter, map, scopedTemplateId(scope, templateId), [], clock) } continue } if (fieldCount > FLOW_TEMPLATE_LIMITS.perTemplateFields) refuseTemplate("fields") const parsed = templateFields(buf, tOff, setEnd, fieldCount, false) tOff = parsed.next if (templateId >= 256) { admitTemplate(exporter, map ?? new Map(), scopedTemplateId(scope, templateId), fieldCount) map ??= templatesForExporter(exporter); storeTemplate(exporter, map, scopedTemplateId(scope, templateId), parsed.fields, clock) } } if (map) templatesForExporter(exporter) } else if (setId >= 256) { const tpl = dataTemplate(exporter, scopedTemplateId(scope, setId), clock) parseDataRecords(tpl, buf, off + 4, setEnd, out) } off = setEnd } return out } export function parseFlowPacket(buf: Buffer, exporterIp: string, transport?: FlowDatagramTransport): ParsedFlow[] { if (buf.length < 2) return [] const version = buf.readUInt16BE(0) if (version === 5) return parseNetflowV5(buf) // Validate receiver context before ANY template access/LRU touch. if (version === 9 && buf.length >= 20) return parseNetflowV9(buf, exporterIp, templateScope(version, buf.readUInt32BE(16), transport)) if (version === 10 && buf.length >= 16) return parseIpfix(buf, exporterIp, templateScope(version, buf.readUInt32BE(12), transport)) return [] } export function protoName(proto: number): string { switch (proto) { case 1: return "ICMP" case 6: return "TCP" case 17: return "UDP" case 47: return "GRE" case 50: return "ESP" case 58: return "ICMPv6" case 89: return "OSPF" default: return String(proto) } } /** One collector socket per isolate. Call only after invalidating its predecessor's * callbacks; parsed flow rows and owned SQL batches do not retain templates. */ export function clearFlowTemplateCache(): void { templatesByExporter.clear() fieldsByExporter.clear(); templateCount = 0; fieldCount = 0 } export function resetFlowTemplatesForTests(): void { clearFlowTemplateCache(); refusedTemplates = 0 } export function templateCacheUsageForTests(exporter?: string) { return { exporters: templatesByExporter.size, templates: templateCount, fields: fieldCount, refusedTemplates, exporterTemplates: exporter === undefined ? null : templatesByExporter.get(exporter)?.size ?? 0, exporterFields: exporter === undefined ? null : fieldsByExporter.get(exporter) ?? 0 } } export function templateExporterCountForTests(): number { return templatesByExporter.size }