Class NetworkStack

src/network.js:44–888

const DHCP_OPT_END = 255;

class NetworkStack extends EventEmitter {
    constructor(options = {}) {
        super();
        this.gatewayIP = options.gatewayIP || '192.168.127.1';
        this.vmIP = options.vmIP || '192.168.127.3';
        this.gatewayMac = options.gatewayMac || Buffer.from([0x5a, 0x94, 0xef, 0xe4, 0x0c, 0xdd]);
        this.vmMac = Buffer.from([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]); // Default VM MAC
        
        this.natTable = new Map(); // key -> { state, mySeq, myAck, ... } for TCP state tracking
        
        // Network I/O via shared ring buffer for INCOMING data (main → worker)
        // No more MessagePort polling for data!
        this.ringReader = options.ringReader || null;
        
        // MessagePort still needed for OUTGOING control messages (worker → main)
        this.netPort = options.netPort || null;
        
        // QEMU Framing Buffer
        this.txBuffer = Buffer.alloc(0); // Data sending TO the VM (queued)
        this.rxBuffer = Buffer.alloc(0); // Data received FROM the VM (buffering for full frame)
        
        // TCP Flow Control: Maximum buffer before requesting pause
        // Use larger buffers to reduce pause/resume cycle frequency and improve throughput
        this.TX_BUFFER_HIGH_WATER = 256 * 1024;  // 256KB - request pause
        this.TX_BUFFER_LOW_WATER = 64 * 1024;    // 64KB - request resume
        this.txPaused = new Set(); // Set of TCP session keys that are paused
    }
    
    /**
     * Check if there's network data available in the ring buffer
     */
    hasNetworkData() {
        return this.ringReader && this.ringReader.hasNetworkData();
    }
    
    /**
     * Poll for network responses from ring buffer (synchronous, no waiting)
     * Call this during poll_oneoff to check for incoming data
     */
    pollNetResponses() {
        if (!this.ringReader) return;
        
        // Process more bytes per poll to improve throughput
        // BUT: Always process control messages (END, ERROR, etc.) to avoid deadlocks!
        const MAX_DATA_BYTES_PER_POLL = 512 * 1024; // 512KB max DATA per poll cycle
        let dataBytesThisPoll = 0;
        let hitDataLimit = false;
        let messagesRead = 0;
        
        // Read messages from ring buffer (no polling needed - direct memory access!)
        let msg;
        while ((msg = this.ringReader.readNetworkMessage())) {
            messagesRead++;
            if (msg.type === NET_MSG_UDP_RECV) {
                const parsed = this.ringReader.parseUdpRecv(msg.payload);
                this._handleUdpResponse(parsed);
            } else if (msg.type === NET_MSG_TCP_CONNECTED) {
                const key = this.ringReader.parseKey(msg.payload);