netkitty/dist/lib/pcap/PcapWriter.js

Network tools kit

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.PcapWriter = void 0;
const events_1 = __importDefault(require("events"));
const node_fs_1 = require("node:fs");
const PCAPGenerator_1 = require("./PCAPGenerator");
class PcapWriter extends events_1.default {
    get wroteCount() {
        return this.index;
    }
    constructor(options) {
        super();
        this.closed = false;
        this.index = 0;
        this.offset = 0;
        this.filename = options.filename;
        if (!(0, node_fs_1.existsSync)(this.filename)) {
            this.writeStream = (0, node_fs_1.createWriteStream)(this.filename, { autoClose: false, flags: 'w' });
            const header = (0, PCAPGenerator_1.GeneratePCAPHeader)();
            this.writeStream.write(header);
            this.offset += header.length;
        }
        else {
            this.writeStream = (0, node_fs_1.createWriteStream)(this.filename, { autoClose: false, flags: 'a' });
            this.offset += (0, node_fs_1.statSync)(this.filename).size;
        }
    }
    /**
     * Write packet to pcap file
     * @param packet
     * @param seconds
     * @param microseconds
     */
    write(packet, seconds, microseconds) {
        if (this.closed)
            return;
        this.index += 1;
        const startOffset = this.offset;
        const packetLength = packet.length;
        const pcapData = (0, PCAPGenerator_1.GeneratePCAPData)({
            buffer: packet,
            timestamp: Date.now(),
            microsecond: {
                seconds: seconds,
                microseconds: microseconds
            }
        });
        this.offset += pcapData.length;
        const packetOffset = this.offset - packetLength;
        const recordHeaderLength = packetOffset - startOffset;
        const wrotePacketInfo = {
            index: this.index,
            offset: startOffset,
            length: pcapData.length,
            recordHeaderOffset: startOffset,
            recordHeaderLength: recordHeaderLength,
            packetOffset: packetOffset,
            packetLength: packetLength,
            seconds: seconds,
            microseconds: microseconds,
            packet: packet.toString('base64')
        };
        this.writeStream.write(pcapData, () => this.emit('packet', wrotePacketInfo));
    }
    /**
     * Close pcap writer
     */
    async close() {
        this.closed = true;
        return new Promise((resolve, reject) => {
            this.writeStream.close(err => err ? reject(err) : resolve());
        });
    }
    on(eventName, listener) {
        super.on(eventName, listener);
        return this;
    }
    once(eventName, listener) {
        super.once(eventName, listener);
        return this;
    }
}
exports.PcapWriter = PcapWriter;