@jsprismarine/raknet 0.1.0-rc.53 → 0.1.0

package/dist/Session.cjs.js

@@ -0,0 +1,386 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const protocol_ACK = require('./protocol/ACK.cjs.js');
+const BinaryStream = require('@jsprismarine/jsbinaryutils');
+const protocol_BitFlags = require('./protocol/BitFlags.cjs.js');
+const protocol_connection_ConnectedPing = require('./protocol/connection/ConnectedPing.cjs.js');
+const protocol_connection_ConnectedPong = require('./protocol/connection/ConnectedPong.cjs.js');
+const protocol_login_ConnectionRequest = require('./protocol/login/ConnectionRequest.cjs.js');
+const protocol_login_ConnectionRequestAccepted = require('./protocol/login/ConnectionRequestAccepted.cjs.js');
+const protocol_Frame = require('./protocol/Frame.cjs.js');
+const protocol_FrameReliability = require('./protocol/FrameReliability.cjs.js');
+const protocol_FrameSet = require('./protocol/FrameSet.cjs.js');
+const utils_InetAddress = require('./utils/InetAddress.cjs.js');
+const Constants = require('./Constants.cjs.js');
+const protocol_MessageIdentifiers = require('./protocol/MessageIdentifiers.cjs.js');
+const protocol_NACK = require('./protocol/NACK.cjs.js');
+const assert = require('node:assert');
+const protocol_PacketPool = require('./protocol/PacketPool.cjs.js');
+require('./protocol/AcknowledgePacket.cjs.js');
+require('./protocol/Packet.cjs.js');
+require('assert');
+
+const _interopDefault = e => e && e.__esModule ? e : { default: e };
+
+const BinaryStream__default = /*#__PURE__*/_interopDefault(BinaryStream);
+const assert__default = /*#__PURE__*/_interopDefault(assert);
+
+var RakNetPriority = /* @__PURE__ */ ((RakNetPriority2) => {
+  RakNetPriority2[RakNetPriority2["NORMAL"] = 0] = "NORMAL";
+  RakNetPriority2[RakNetPriority2["IMMEDIATE"] = 1] = "IMMEDIATE";
+  return RakNetPriority2;
+})(RakNetPriority || {});
+var SessionStatus = /* @__PURE__ */ ((SessionStatus2) => {
+  SessionStatus2[SessionStatus2["CONNECTING"] = 0] = "CONNECTING";
+  SessionStatus2[SessionStatus2["CONNECTED"] = 1] = "CONNECTED";
+  SessionStatus2[SessionStatus2["DISCONNECTING"] = 2] = "DISCONNECTING";
+  SessionStatus2[SessionStatus2["DISCONNECTED"] = 3] = "DISCONNECTED";
+  return SessionStatus2;
+})(SessionStatus || {});
+class Session {
+  constructor(listener, mtuSize, rinfo, guid) {
+    this.listener = listener;
+    this.mtuSize = mtuSize;
+    this.rinfo = rinfo;
+    this.guid = guid;
+    this.lastUpdate = Date.now();
+    this.outputOrderIndex = new Array(Constants.MAX_CHANNELS).fill(0);
+    this.outputSequenceIndex = new Array(Constants.MAX_CHANNELS).fill(0);
+    this.inputOrderIndex = new Array(Constants.MAX_CHANNELS).fill(0);
+    for (let i = 0; i < Constants.MAX_CHANNELS; i++) {
+      this.inputOrderingQueue.set(i, /* @__PURE__ */ new Map());
+    }
+    this.inputHighestSequenceIndex = new Array(Constants.MAX_CHANNELS).fill(0);
+  }
+  state = 0 /* CONNECTING */;
+  outputFrameQueue = new protocol_FrameSet.default();
+  outputSequenceNumber = 0;
+  // TODO: find a better name
+  outputReliableIndex = 0;
+  outputBackupQueue = /* @__PURE__ */ new Map();
+  outputOrderIndex;
+  outputSequenceIndex;
+  receivedFrameSequences = /* @__PURE__ */ new Set();
+  lostFrameSequences = /* @__PURE__ */ new Set();
+  // Map holding fragments of fragmented packets
+  fragmentsQueue = /* @__PURE__ */ new Map();
+  outputFragmentIndex = 0;
+  lastInputSequenceNumber = -1;
+  inputHighestSequenceIndex;
+  inputOrderIndex;
+  inputOrderingQueue = /* @__PURE__ */ new Map();
+  // Last timestamp of packet received, helpful for timeout
+  lastUpdate = Date.now();
+  active = true;
+  // Packet pool is the best option to reduce allocations
+  packetPool = new protocol_PacketPool.default();
+  // Lookup table for packet handlers, always O(1) in average and worst case
+  packetHandlers = {
+    // 0x40 | 0xc0 = MessageHeaders.ACKNOWLEDGE_PACKET
+    [protocol_MessageIdentifiers.MessageIdentifiers.ACKNOWLEDGE_PACKET]: (buffer) => {
+      const ack = this.packetPool.getAckInstance();
+      ack.buffer = buffer;
+      ack.decode();
+      this.handleACK(ack);
+    },
+    [protocol_MessageIdentifiers.MessageIdentifiers.NACKNOWLEDGE_PACKET]: (buffer) => {
+      const nack = this.packetPool.getNackInstance();
+      nack.buffer = buffer;
+      nack.decode();
+      this.handleNACK(nack);
+    },
+    [protocol_BitFlags.BitFlags.VALID]: (buffer) => {
+      const frameSet = this.packetPool.getFrameSetInstance();
+      frameSet.buffer = buffer;
+      frameSet.decode();
+      this.handleFrameSet(frameSet);
+    }
+  };
+  update(timestamp) {
+    if (!this.isActive() && !this.isDisconnected() && this.lastUpdate + 1e4 < timestamp) {
+      this.disconnect("timeout");
+      return;
+    }
+    this.active = false;
+    if (this.receivedFrameSequences.size > 0) {
+      const ack = new protocol_ACK.default();
+      ack.sequenceNumbers = Array.from(this.receivedFrameSequences).map((seq) => {
+        this.receivedFrameSequences.delete(seq);
+        return seq;
+      });
+      this.sendPacket(ack);
+    }
+    if (this.lostFrameSequences.size > 0) {
+      const pk = new protocol_NACK.default();
+      pk.sequenceNumbers = Array.from(this.lostFrameSequences).map((seq) => {
+        this.lostFrameSequences.delete(seq);
+        return seq;
+      });
+      this.sendPacket(pk);
+    }
+    this.sendFrameQueue();
+  }
+  // https://github.com/facebookarchive/RakNet/blob/1a169895a900c9fc4841c556e16514182b75faf8/Source/ReliabilityLayer.cpp#L635
+  handle(buffer) {
+    this.active = true;
+    this.lastUpdate = Date.now();
+    const handler = this.packetHandlers[buffer[0] & 240];
+    if (handler) {
+      handler(buffer);
+    } else {
+      this.listener.getLogger().debug("Received an unknown packet type=%d", buffer[0]);
+    }
+  }
+  handleFrameSet(frameSet) {
+    if (this.receivedFrameSequences.has(frameSet.sequenceNumber)) {
+      this.listener.getLogger().debug("Discarded duplicated packet from client=%o", this.getAddress());
+      return;
+    }
+    this.lostFrameSequences.delete(frameSet.sequenceNumber);
+    if (frameSet.sequenceNumber < this.lastInputSequenceNumber || frameSet.sequenceNumber === this.lastInputSequenceNumber) {
+      return;
+    }
+    this.receivedFrameSequences.add(frameSet.sequenceNumber);
+    const diff = frameSet.sequenceNumber - this.lastInputSequenceNumber;
+    if (diff !== 1) {
+      for (let i = this.lastInputSequenceNumber + 1; i < frameSet.sequenceNumber; i++) {
+        if (!this.receivedFrameSequences.has(i)) {
+          this.lostFrameSequences.add(i);
+        }
+      }
+    }
+    this.lastInputSequenceNumber = frameSet.sequenceNumber;
+    for (const frame of frameSet.frames) {
+      this.handleFrame(frame);
+    }
+  }
+  handleACK(ack) {
+    for (const seq of ack.sequenceNumbers) {
+      this.outputBackupQueue.delete(seq);
+    }
+  }
+  handleNACK(nack) {
+    for (const seq of nack.sequenceNumbers) {
+      if (this.outputBackupQueue.has(seq)) {
+        const lostFrames = this.outputBackupQueue.get(seq);
+        for (const lostFrame of lostFrames) {
+          this.sendFrame(lostFrame, 1 /* IMMEDIATE */);
+        }
+        this.outputBackupQueue.delete(seq);
+      }
+    }
+  }
+  handleFrame(frame) {
+    if (frame.isFragmented()) {
+      this.handleFragment(frame);
+      return;
+    }
+    const orderChannel = frame.orderChannel;
+    const orderIndex = frame.orderIndex;
+    const sequenceIndex = frame.sequenceIndex;
+    if (frame.isSequenced()) {
+      if (sequenceIndex < this.inputHighestSequenceIndex[orderChannel] || orderIndex < this.inputOrderIndex[orderChannel]) {
+        return;
+      }
+      this.inputHighestSequenceIndex[orderChannel] = sequenceIndex + 1;
+      this.handlePacket(frame);
+    } else if (frame.isOrdered()) {
+      if (orderIndex === this.inputOrderIndex[orderChannel]) {
+        this.inputHighestSequenceIndex[orderChannel] = 0;
+        this.inputOrderIndex[orderChannel] = orderIndex + 1;
+        this.handlePacket(frame);
+        let i = this.inputOrderIndex[orderChannel];
+        const outOfOrderQueue = this.inputOrderingQueue.get(orderChannel);
+        for (; outOfOrderQueue.has(i); i++) {
+          this.handlePacket(outOfOrderQueue.get(i));
+          outOfOrderQueue.delete(i);
+        }
+        this.inputOrderingQueue.set(orderChannel, outOfOrderQueue);
+        this.inputOrderIndex[orderChannel] = i;
+      } else if (orderIndex > this.inputOrderIndex[orderChannel]) {
+        const unordered = this.inputOrderingQueue.get(orderChannel);
+        unordered.set(orderIndex, frame);
+      }
+    } else {
+      this.handlePacket(frame);
+    }
+  }
+  sendFrame(frame, flags = 0 /* NORMAL */) {
+    assert__default.default(typeof frame.orderChannel === "number", "Frame OrderChannel cannot be null");
+    if (frame.isSequenced()) {
+      frame.orderIndex = this.outputOrderIndex[frame.orderChannel];
+      frame.sequenceIndex = this.outputSequenceIndex[frame.orderChannel]++;
+    } else if (frame.isOrderedExclusive()) {
+      frame.orderIndex = this.outputOrderIndex[frame.orderChannel]++;
+      this.outputSequenceIndex[frame.orderChannel] = 0;
+    }
+    frame.reliableIndex = this.outputReliableIndex++;
+    const maxSize = this.getMTU() - protocol_FrameSet.DATAGRAM_HEADER_BYTE_LENGTH - protocol_Frame.MAX_FRAME_BYTE_LENGTH;
+    if (frame.content.byteLength > maxSize) {
+      const buffer = Buffer.from(frame.content);
+      const fragmentId = this.outputFragmentIndex++ % 65536;
+      for (let i = 0; i < buffer.byteLength; i += maxSize) {
+        if (i !== 0) {
+          frame.reliableIndex = this.outputReliableIndex++;
+        }
+        frame.content = buffer.slice(i, i + maxSize);
+        frame.fragmentIndex = i / maxSize;
+        frame.fragmentId = fragmentId;
+        frame.fragmentSize = Math.ceil(buffer.byteLength / maxSize);
+        this.addFrameToQueue(frame, flags | 1 /* IMMEDIATE */);
+      }
+    } else {
+      this.addFrameToQueue(frame, flags);
+    }
+  }
+  addFrameToQueue(frame, priority = 0 /* NORMAL */) {
+    let length = 4;
+    for (const queuedFrame of this.outputFrameQueue.frames) {
+      length += queuedFrame.getByteLength();
+    }
+    if (length + frame.getByteLength() > this.mtuSize - 36) {
+      this.sendFrameQueue();
+    }
+    this.outputFrameQueue.frames.push(frame);
+    if (priority === 1 /* IMMEDIATE */) {
+      this.sendFrameQueue();
+    }
+  }
+  handlePacket(packet) {
+    const id = packet.content[0];
+    if (this.state === 0 /* CONNECTING */) {
+      if (id === protocol_MessageIdentifiers.MessageIdentifiers.CONNECTION_REQUEST) {
+        this.handleConnectionRequest(packet.content).then(
+          (encapsulated) => this.sendFrame(encapsulated, 1 /* IMMEDIATE */),
+          () => {
+          }
+        );
+      } else if (id === protocol_MessageIdentifiers.MessageIdentifiers.NEW_INCOMING_CONNECTION) {
+        this.state = 1 /* CONNECTED */;
+        this.listener.emit("openConnection", this);
+      }
+    } else if (id === protocol_MessageIdentifiers.MessageIdentifiers.DISCONNECTION_NOTIFICATION) {
+      this.disconnect();
+    } else if (id === protocol_MessageIdentifiers.MessageIdentifiers.CONNECTED_PING) {
+      this.handleConnectedPing(packet.content).then(
+        (encapsulated) => this.sendFrame(encapsulated),
+        () => {
+        }
+      );
+    } else if (this.state === 1 /* CONNECTED */) {
+      this.listener.emit("encapsulated", packet, this.getAddress());
+    }
+  }
+  async handleConnectionRequest(buffer) {
+    const dataPacket = new protocol_login_ConnectionRequest.default(buffer);
+    dataPacket.decode();
+    const pk = new protocol_login_ConnectionRequestAccepted.default();
+    pk.clientAddress = this.getAddress();
+    pk.requestTimestamp = dataPacket.requestTimestamp;
+    pk.acceptedTimestamp = BigInt(Date.now());
+    pk.encode();
+    const sendPacket = new protocol_Frame.default();
+    sendPacket.reliability = protocol_FrameReliability.FrameReliability.UNRELIABLE;
+    sendPacket.orderChannel = 0;
+    sendPacket.content = pk.getBuffer();
+    return sendPacket;
+  }
+  async handleConnectedPing(buffer) {
+    const dataPacket = new protocol_connection_ConnectedPing.default(buffer);
+    dataPacket.decode();
+    const pk = new protocol_connection_ConnectedPong.default();
+    pk.clientTimestamp = dataPacket.clientTimestamp;
+    pk.serverTimestamp = BigInt(Date.now());
+    pk.encode();
+    const sendPacket = new protocol_Frame.default();
+    sendPacket.reliability = protocol_FrameReliability.FrameReliability.UNRELIABLE;
+    sendPacket.orderChannel = 0;
+    sendPacket.content = pk.getBuffer();
+    return sendPacket;
+  }
+  handleFragment(frame) {
+    if (!this.fragmentsQueue.has(frame.fragmentId)) {
+      this.fragmentsQueue.set(frame.fragmentId, /* @__PURE__ */ new Map([[frame.fragmentIndex, frame]]));
+    } else {
+      const value = this.fragmentsQueue.get(frame.fragmentId);
+      value.set(frame.fragmentIndex, frame);
+      if (value.size === frame.fragmentSize) {
+        const stream = new BinaryStream__default.default();
+        for (let i = 0; i < value.size; i++) {
+          const splitPacket = value.get(i);
+          stream.write(splitPacket.content);
+        }
+        const assembledFrame = new protocol_Frame.default();
+        assembledFrame.content = stream.getBuffer();
+        assembledFrame.reliability = frame.reliability;
+        assembledFrame.reliableIndex = frame.reliableIndex;
+        assembledFrame.sequenceIndex = frame.sequenceIndex;
+        assembledFrame.orderIndex = frame.orderIndex;
+        assembledFrame.orderChannel = frame.orderChannel;
+        this.fragmentsQueue.delete(frame.fragmentId);
+        this.handleFrame(assembledFrame);
+      }
+    }
+  }
+  sendFrameQueue() {
+    if (this.outputFrameQueue.frames.length > 0) {
+      this.outputFrameQueue.sequenceNumber = this.outputSequenceNumber++;
+      this.sendFrameSet(this.outputFrameQueue);
+      this.outputFrameQueue = new protocol_FrameSet.default();
+    }
+  }
+  sendFrameSet(frameSet) {
+    this.sendPacket(frameSet);
+    this.outputBackupQueue.set(
+      frameSet.sequenceNumber,
+      frameSet.frames.filter((frame) => frame.isReliable())
+    );
+  }
+  sendPacket(packet) {
+    this.listener.sendPacket(packet, this.rinfo);
+  }
+  close() {
+    const stream = new BinaryStream__default.default(Buffer.from("\0\0\b", "binary"));
+    this.addFrameToQueue(new protocol_Frame.default().fromBinary(stream), 1 /* IMMEDIATE */);
+  }
+  /**
+   * Kick a client
+   * @param reason the reason message, optional
+   */
+  disconnect(reason = "client disconnect") {
+    this.close();
+    this.state = 3 /* DISCONNECTED */;
+    this.update(Date.now());
+    this.listener.removeSession(this, reason);
+  }
+  getState() {
+    return this.state;
+  }
+  isActive() {
+    return this.active;
+  }
+  isDisconnected() {
+    return this.state === 3 /* DISCONNECTED */;
+  }
+  getListener() {
+    return this.listener;
+  }
+  /**
+   * Returns the maxmium transfer unit
+   * for this connection.
+   * @returns {number} the UDP adjusted.
+   */
+  getMTU() {
+    return this.mtuSize - Constants.UDP_HEADER_SIZE;
+  }
+  getAddress() {
+    return new utils_InetAddress.default(this.rinfo.address, this.rinfo.port, 4);
+  }
+}
+
+exports.RakNetPriority = RakNetPriority;
+exports.SessionStatus = SessionStatus;
+exports.default = Session;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"Session.cjs.js","sources":["../src/Session.ts"],"sourcesContent":["import ACK from './protocol/ACK';\nimport BinaryStream from '@jsprismarine/jsbinaryutils';\nimport BitFlags from './protocol/BitFlags';\nimport ConnectedPing from './protocol/connection/ConnectedPing';\nimport ConnectedPong from './protocol/connection/ConnectedPong';\nimport ConnectionRequest from './protocol/login/ConnectionRequest';\nimport ConnectionRequestAccepted from './protocol/login/ConnectionRequestAccepted';\nimport Frame, { MAX_FRAME_BYTE_LENGTH } from './protocol/Frame';\nimport FrameReliability from './protocol/FrameReliability';\nimport FrameSet, { DATAGRAM_HEADER_BYTE_LENGTH } from './protocol/FrameSet';\nimport InetAddress from './utils/InetAddress';\nimport { MAX_CHANNELS, UDP_HEADER_SIZE } from './Constants';\nimport { MessageIdentifiers } from './protocol/MessageIdentifiers';\nimport NACK from './protocol/NACK';\nimport Packet from './protocol/Packet';\nimport RakNetListener from './ServerSocket';\nimport { type RemoteInfo } from 'node:dgram';\nimport assert from 'node:assert';\nimport PacketPool from './protocol/PacketPool';\n\nexport enum RakNetPriority {\n    NORMAL,\n    IMMEDIATE\n}\n\nexport enum SessionStatus {\n    CONNECTING,\n    CONNECTED,\n    DISCONNECTING,\n    DISCONNECTED\n}\n\nexport default class Session {\n    private state = SessionStatus.CONNECTING;\n\n    private outputFrameQueue = new FrameSet();\n    private outputSequenceNumber = 0; // TODO: find a better name\n    private outputReliableIndex = 0;\n    private readonly outputBackupQueue: Map<number, Frame[]> = new Map();\n\n    private readonly outputOrderIndex: number[];\n    private readonly outputSequenceIndex: number[];\n\n    private receivedFrameSequences: Set<number> = new Set();\n    private lostFrameSequences: Set<number> = new Set();\n\n    // Map holding fragments of fragmented packets\n    private readonly fragmentsQueue: Map<number, Map<number, Frame>> = new Map();\n    private outputFragmentIndex = 0;\n\n    private lastInputSequenceNumber = -1;\n    private readonly inputHighestSequenceIndex: number[];\n    private readonly inputOrderIndex: number[];\n    private inputOrderingQueue: Map<number, Map<number, Frame>> = new Map();\n\n    // Last timestamp of packet received, helpful for timeout\n    private lastUpdate: number = Date.now();\n    private active = true;\n\n    // Packet pool is the best option to reduce allocations\n    private readonly packetPool = new PacketPool();\n\n    public constructor(\n        private readonly listener: RakNetListener,\n        private readonly mtuSize: number,\n        public readonly rinfo: RemoteInfo,\n        public readonly guid: bigint\n    ) {\n        this.lastUpdate = Date.now();\n\n        this.outputOrderIndex = new Array(MAX_CHANNELS).fill(0);\n        this.outputSequenceIndex = new Array(MAX_CHANNELS).fill(0);\n\n        this.inputOrderIndex = new Array(MAX_CHANNELS).fill(0);\n        for (let i = 0; i < MAX_CHANNELS; i++) {\n            this.inputOrderingQueue.set(i, new Map());\n        }\n\n        this.inputHighestSequenceIndex = new Array(MAX_CHANNELS).fill(0);\n    }\n\n    // Lookup table for packet handlers, always O(1) in average and worst case\n    private readonly packetHandlers: Record<number, (buffer: Buffer) => void> = {\n        // 0x40 | 0xc0 = MessageHeaders.ACKNOWLEDGE_PACKET\n        [MessageIdentifiers.ACKNOWLEDGE_PACKET]: (buffer: Buffer) => {\n            const ack = this.packetPool.getAckInstance();\n            (ack as any).buffer = buffer;\n            ack.decode();\n            this.handleACK(ack);\n        },\n        [MessageIdentifiers.NACKNOWLEDGE_PACKET]: (buffer: Buffer) => {\n            const nack = this.packetPool.getNackInstance();\n            (nack as any).buffer = buffer;\n            nack.decode();\n            this.handleNACK(nack);\n        },\n        [BitFlags.VALID]: (buffer: Buffer) => {\n            const frameSet = this.packetPool.getFrameSetInstance();\n            (frameSet as any).buffer = buffer;\n            frameSet.decode();\n            this.handleFrameSet(frameSet);\n        }\n    };\n\n    public update(timestamp: number): void {\n        if (!this.isActive() && !this.isDisconnected() && this.lastUpdate + 10_000 < timestamp) {\n            this.disconnect('timeout');\n            return;\n        }\n\n        this.active = false;\n\n        // TODO: a queue just for ACKs sequences to avoid duplicateds\n        if (this.receivedFrameSequences.size > 0) {\n            const ack = new ACK();\n            ack.sequenceNumbers = Array.from(this.receivedFrameSequences).map((seq) => {\n                this.receivedFrameSequences.delete(seq);\n                return seq;\n            });\n            this.sendPacket(ack);\n        }\n\n        if (this.lostFrameSequences.size > 0) {\n            const pk = new NACK();\n            pk.sequenceNumbers = Array.from(this.lostFrameSequences).map((seq) => {\n                this.lostFrameSequences.delete(seq);\n                return seq;\n            });\n            this.sendPacket(pk);\n        }\n\n        this.sendFrameQueue();\n    }\n\n    // https://github.com/facebookarchive/RakNet/blob/1a169895a900c9fc4841c556e16514182b75faf8/Source/ReliabilityLayer.cpp#L635\n    public handle(buffer: Buffer): void {\n        this.active = true;\n        this.lastUpdate = Date.now();\n\n        // Mask the lower 4 bits of the header\n        // to get the range of header values\n        const handler = this.packetHandlers[buffer[0]! & 0xf0];\n        if (handler) {\n            handler(buffer);\n        } else {\n            this.listener.getLogger().debug('Received an unknown packet type=%d', buffer[0]);\n        }\n    }\n\n    private handleFrameSet(frameSet: FrameSet): void {\n        // TODO: additional sanity checks\n        if (this.receivedFrameSequences.has(frameSet.sequenceNumber)) {\n            this.listener.getLogger().debug('Discarded duplicated packet from client=%o', this.getAddress());\n            return;\n        }\n\n        // if it was missing, remove from the queue because we received it now\n        this.lostFrameSequences.delete(frameSet.sequenceNumber);\n\n        // For now is good like that\n        if (\n            frameSet.sequenceNumber < this.lastInputSequenceNumber ||\n            frameSet.sequenceNumber === this.lastInputSequenceNumber\n        ) {\n            return;\n        }\n\n        // Add the frame to the ACK queue\n        this.receivedFrameSequences.add(frameSet.sequenceNumber);\n\n        // Check if there are missing packets between the received packet and the last received one\n        const diff = frameSet.sequenceNumber - this.lastInputSequenceNumber;\n\n        // Check if the sequence has a hole due to a lost packet\n        if (diff !== 1) {\n            // As i said before, there we search for missing packets in the list of the recieved ones\n            for (let i = this.lastInputSequenceNumber + 1; i < frameSet.sequenceNumber; i++) {\n                // Adding the packet sequence number to the NACK queue and then sending a NACK\n                // will make the Client sending again the lost packet\n                if (!this.receivedFrameSequences.has(i)) {\n                    this.lostFrameSequences.add(i);\n                }\n            }\n        }\n\n        // If we received a lost packet we sent in NACK or a normal sequenced one\n        this.lastInputSequenceNumber = frameSet.sequenceNumber;\n\n        // Handle encapsulated\n        for (const frame of frameSet.frames) {\n            this.handleFrame(frame);\n        }\n    }\n\n    private handleACK(ack: ACK): void {\n        // TODO: ping calculation\n\n        for (const seq of ack.sequenceNumbers) {\n            this.outputBackupQueue.delete(seq);\n        }\n    }\n\n    private handleNACK(nack: NACK): void {\n        for (const seq of nack.sequenceNumbers) {\n            if (this.outputBackupQueue.has(seq)) {\n                const lostFrames = this.outputBackupQueue.get(seq)!;\n                for (const lostFrame of lostFrames) {\n                    this.sendFrame(lostFrame, RakNetPriority.IMMEDIATE);\n                }\n                this.outputBackupQueue.delete(seq);\n            }\n        }\n    }\n\n    private handleFrame(frame: Frame): void {\n        if (frame.isFragmented()) {\n            this.handleFragment(frame);\n            return;\n        }\n\n        const orderChannel = frame.orderChannel!;\n        const orderIndex = frame.orderIndex!;\n        const sequenceIndex = frame.sequenceIndex!;\n\n        if (frame.isSequenced()) {\n            if (\n                sequenceIndex < this.inputHighestSequenceIndex[orderChannel]! ||\n                orderIndex < this.inputOrderIndex[orderChannel]!\n            ) {\n                // Sequenced packet is too old, discard it\n                return;\n            }\n\n            this.inputHighestSequenceIndex[orderChannel] = sequenceIndex + 1;\n            this.handlePacket(frame);\n        } else if (frame.isOrdered()) {\n            if (orderIndex === this.inputOrderIndex[orderChannel]) {\n                this.inputHighestSequenceIndex[orderChannel] = 0;\n                this.inputOrderIndex[orderChannel] = orderIndex + 1;\n\n                this.handlePacket(frame);\n                let i = this.inputOrderIndex[orderChannel]!;\n                const outOfOrderQueue = this.inputOrderingQueue.get(orderChannel)!;\n                for (; outOfOrderQueue.has(i); i++) {\n                    this.handlePacket(outOfOrderQueue.get(i)!);\n                    outOfOrderQueue.delete(i);\n                }\n\n                // Set the updated queue\n                this.inputOrderingQueue.set(orderChannel, outOfOrderQueue);\n                this.inputOrderIndex[orderChannel] = i;\n            } else if (orderIndex > this.inputOrderIndex[orderChannel]!) {\n                const unordered = this.inputOrderingQueue.get(orderChannel)!;\n                unordered.set(orderIndex, frame);\n            }\n        } else {\n            this.handlePacket(frame);\n        }\n    }\n\n    public sendFrame(frame: Frame, flags = RakNetPriority.NORMAL): void {\n        assert(typeof frame.orderChannel === 'number', 'Frame OrderChannel cannot be null');\n        // https://github.com/facebookarchive/RakNet/blob/1a169895a900c9fc4841c556e16514182b75faf8/Source/ReliabilityLayer.cpp#L1625\n        if (frame.isSequenced()) {\n            // Sequenced packets don't increase the ordered channel index\n            frame.orderIndex = this.outputOrderIndex[frame.orderChannel]!;\n            frame.sequenceIndex = this.outputSequenceIndex[frame.orderChannel]++;\n        } else if (frame.isOrderedExclusive()) {\n            // implies sequenced, but we have to distinct them\n            frame.orderIndex = this.outputOrderIndex[frame.orderChannel]++;\n            this.outputSequenceIndex[frame.orderChannel] = 0;\n        }\n\n        frame.reliableIndex = this.outputReliableIndex++;\n\n        // Split packet if bigger than MTU size\n        const maxSize = this.getMTU() - DATAGRAM_HEADER_BYTE_LENGTH - MAX_FRAME_BYTE_LENGTH;\n        if (frame.content.byteLength > maxSize) {\n            // If we use the frame as reference, we have to copy somewhere\n            // the original buffer. Then we will point to this buffer content\n            const buffer = Buffer.from(frame.content);\n            const fragmentId = this.outputFragmentIndex++ % 65536;\n            for (let i = 0; i < buffer.byteLength; i += maxSize) {\n                // Like the original raknet, we like to use a pointer to the original\n                // frame, we don't really care about side effects in this case.\n                // RakNet will allocate the whole strcture containing splits,\n                // but i think caching just the buffer is enough.\n                // https://github.com/facebookarchive/RakNet/blob/1a169895a900c9fc4841c556e16514182b75faf8/Source/ReliabilityLayer.cpp#L2963\n\n                // Skip the first index as it's already increased by itself.\n                if (i !== 0) {\n                    frame.reliableIndex = this.outputReliableIndex++;\n                }\n\n                frame.content = buffer.slice(i, i + maxSize);\n                frame.fragmentIndex = i / maxSize;\n                frame.fragmentId = fragmentId;\n                frame.fragmentSize = Math.ceil(buffer.byteLength / maxSize);\n                this.addFrameToQueue(frame, flags | RakNetPriority.IMMEDIATE);\n            }\n        } else {\n            this.addFrameToQueue(frame, flags);\n        }\n    }\n\n    private addFrameToQueue(frame: Frame, priority = RakNetPriority.NORMAL): void {\n        let length = 4; // datagram header size\n        for (const queuedFrame of this.outputFrameQueue.frames) {\n            length += queuedFrame.getByteLength();\n        }\n\n        if (length + frame.getByteLength() > this.mtuSize - 36) {\n            this.sendFrameQueue();\n        }\n\n        this.outputFrameQueue.frames.push(frame);\n\n        if (priority === RakNetPriority.IMMEDIATE) {\n            this.sendFrameQueue();\n        }\n    }\n\n    private handlePacket(packet: Frame): void {\n        const id = packet.content[0];\n\n        if (this.state === SessionStatus.CONNECTING) {\n            if (id === MessageIdentifiers.CONNECTION_REQUEST) {\n                this.handleConnectionRequest(packet.content).then(\n                    (encapsulated) => this.sendFrame(encapsulated, RakNetPriority.IMMEDIATE),\n                    () => {}\n                );\n            } else if (id === MessageIdentifiers.NEW_INCOMING_CONNECTION) {\n                // TODO: online mode\n                this.state = SessionStatus.CONNECTED;\n                this.listener.emit('openConnection', this);\n            }\n        } else if (id === MessageIdentifiers.DISCONNECTION_NOTIFICATION) {\n            this.disconnect();\n        } else if (id === MessageIdentifiers.CONNECTED_PING) {\n            this.handleConnectedPing(packet.content).then(\n                (encapsulated) => this.sendFrame(encapsulated),\n                () => {}\n            );\n        } else if (this.state === SessionStatus.CONNECTED) {\n            this.listener.emit('encapsulated', packet, this.getAddress()); // To fit in software needs later\n        }\n    }\n\n    public async handleConnectionRequest(buffer: Buffer): Promise<Frame> {\n        const dataPacket = new ConnectionRequest(buffer);\n        dataPacket.decode();\n\n        const pk = new ConnectionRequestAccepted();\n        pk.clientAddress = this.getAddress();\n        pk.requestTimestamp = dataPacket.requestTimestamp;\n        pk.acceptedTimestamp = BigInt(Date.now());\n        pk.encode();\n\n        const sendPacket = new Frame();\n        sendPacket.reliability = FrameReliability.UNRELIABLE;\n        sendPacket.orderChannel = 0;\n        sendPacket.content = pk.getBuffer();\n\n        return sendPacket;\n    }\n\n    public async handleConnectedPing(buffer: Buffer): Promise<Frame> {\n        const dataPacket = new ConnectedPing(buffer);\n        dataPacket.decode();\n\n        const pk = new ConnectedPong();\n        pk.clientTimestamp = dataPacket.clientTimestamp;\n        pk.serverTimestamp = BigInt(Date.now());\n        pk.encode();\n\n        const sendPacket = new Frame();\n        sendPacket.reliability = FrameReliability.UNRELIABLE;\n        sendPacket.orderChannel = 0;\n        sendPacket.content = pk.getBuffer();\n\n        return sendPacket;\n    }\n\n    public handleFragment(frame: Frame): void {\n        if (!this.fragmentsQueue.has(frame.fragmentId)) {\n            this.fragmentsQueue.set(frame.fragmentId, new Map([[frame.fragmentIndex, frame]]));\n        } else {\n            const value = this.fragmentsQueue.get(frame.fragmentId)!;\n            value.set(frame.fragmentIndex, frame);\n\n            // If we have all pieces, put them together\n            if (value.size === frame.fragmentSize) {\n                const stream = new BinaryStream();\n                // Ensure the correctness of the buffer orders\n                for (let i = 0; i < value.size; i++) {\n                    const splitPacket = value.get(i)!;\n                    stream.write(splitPacket.content);\n                }\n\n                const assembledFrame = new Frame();\n                assembledFrame.content = stream.getBuffer();\n\n                assembledFrame.reliability = frame.reliability;\n                assembledFrame.reliableIndex = frame.reliableIndex;\n                assembledFrame.sequenceIndex = frame.sequenceIndex;\n                assembledFrame.orderIndex = frame.orderIndex;\n                assembledFrame.orderChannel = frame.orderChannel;\n\n                this.fragmentsQueue.delete(frame.fragmentId);\n                this.handleFrame(assembledFrame);\n            }\n        }\n    }\n\n    public sendFrameQueue(): void {\n        if (this.outputFrameQueue.frames.length > 0) {\n            this.outputFrameQueue.sequenceNumber = this.outputSequenceNumber++;\n            this.sendFrameSet(this.outputFrameQueue);\n            this.outputFrameQueue = new FrameSet();\n        }\n    }\n\n    private sendFrameSet(frameSet: FrameSet): void {\n        this.sendPacket(frameSet);\n        this.outputBackupQueue.set(\n            frameSet.sequenceNumber,\n            frameSet.frames.filter((frame) => frame.isReliable())\n        );\n    }\n\n    private sendPacket(packet: Packet): void {\n        this.listener.sendPacket(packet, this.rinfo);\n    }\n\n    public close(): void {\n        const stream = new BinaryStream(Buffer.from('\\u0000\\u0000\\u0008\\u0015', 'binary'));\n        this.addFrameToQueue(new Frame().fromBinary(stream), RakNetPriority.IMMEDIATE); // Client discconect packet 0x15\n    }\n\n    /**\n     * Kick a client\n     * @param reason the reason message, optional\n     */\n    public disconnect(reason = 'client disconnect'): void {\n        // TODO: rewrite, works but can be improved\n        this.close();\n        // Send disconnect ACK\n        this.state = SessionStatus.DISCONNECTED;\n        this.update(Date.now());\n        this.listener.removeSession(this, reason);\n    }\n\n    public getState(): number {\n        return this.state;\n    }\n\n    public isActive(): boolean {\n        return this.active;\n    }\n\n    public isDisconnected(): boolean {\n        return this.state === SessionStatus.DISCONNECTED;\n    }\n\n    public getListener(): RakNetListener {\n        return this.listener;\n    }\n\n    /**\n     * Returns the maxmium transfer unit\n     * for this connection.\n     * @returns {number} the UDP adjusted.\n     */\n    public getMTU(): number {\n        return this.mtuSize - UDP_HEADER_SIZE;\n    }\n\n    public getAddress(): InetAddress {\n        return new InetAddress(this.rinfo.address, this.rinfo.port, 4);\n    }\n}\n"],"names":["RakNetPriority","SessionStatus","MAX_CHANNELS","FrameSet","PacketPool","MessageIdentifiers","BitFlags","ACK","NACK","assert","DATAGRAM_HEADER_BYTE_LENGTH","MAX_FRAME_BYTE_LENGTH","ConnectionRequest","ConnectionRequestAccepted","Frame","FrameReliability","ConnectedPing","ConnectedPong","BinaryStream","UDP_HEADER_SIZE","InetAddress"],"mappings":"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"}

package/dist/Session.d.ts

@@ -1,8 +1,8 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import Frame from './protocol/Frame.js';
-import InetAddress from './utils/InetAddress.js';
-import RakNetListener from './ServerSocket.js';
+/// <reference types="node" />
+/// <reference types="node" />
+import Frame from './protocol/Frame';
+import InetAddress from './utils/InetAddress';
+import RakNetListener from './ServerSocket';
 import { type RemoteInfo } from 'node:dgram';
 export declare enum RakNetPriority {
     NORMAL = 0,

package/dist/Session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Session.d.ts","sourceRoot":"","sources":["../src/Session.ts"],"names":[],"mappings":";;AAOA,OAAO,KAAgC,MAAM,qBAAqB,CAAC;AAGnE,OAAO,WAAW,MAAM,wBAAwB,CAAC;AAKjD,OAAO,cAAc,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C,oBAAY,cAAc;IACtB,MAAM,IAAA;IACN,SAAS,IAAA;CACZ;AAED,oBAAY,aAAa;IACrB,UAAU,IAAA;IACV,SAAS,IAAA;IACT,aAAa,IAAA;IACb,YAAY,IAAA;CACf;AAED,MAAM,CAAC,OAAO,OAAO,OAAO;IA+BpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;aACR,KAAK,EAAE,UAAU;aACjB,IAAI,EAAE,MAAM;IAjChC,OAAO,CAAC,KAAK,CAA4B;IAEzC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmC;IAErE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAW;IAC5C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAW;IAE/C,OAAO,CAAC,sBAAsB,CAA0B;IACxD,OAAO,CAAC,kBAAkB,CAA0B;IAGpD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA8C;IAC7E,OAAO,CAAC,mBAAmB,CAAK;IAEhC,OAAO,CAAC,uBAAuB,CAAM;IACrC,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAW;IAC3C,OAAO,CAAC,kBAAkB,CAA8C;IAGxE,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,MAAM,CAAQ;IAGtB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;gBAG1B,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,MAAM,EAChB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM;IAgBhC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAoB7B;IAEK,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IA+B/B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAcnC,OAAO,CAAC,cAAc;IA6CtB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,WAAW;IA8CZ,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,iBAAwB,GAAG,IAAI;IA6CnE,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,YAAY;IA0BP,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAkBvD,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAiBzD,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IA+BlC,cAAc,IAAI,IAAI;IAQ7B,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,UAAU;IAIX,KAAK,IAAI,IAAI;IAKpB;;;OAGG;IACI,UAAU,CAAC,MAAM,SAAsB,GAAG,IAAI;IAS9C,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,OAAO;IAInB,cAAc,IAAI,OAAO;IAIzB,WAAW,IAAI,cAAc;IAIpC;;;;OAIG;IACI,MAAM,IAAI,MAAM;IAIhB,UAAU,IAAI,WAAW;CAGnC"}
+{"version":3,"file":"Session.d.ts","sourceRoot":"","sources":["../src/Session.ts"],"names":[],"mappings":";;AAOA,OAAO,KAAgC,MAAM,kBAAkB,CAAC;AAGhE,OAAO,WAAW,MAAM,qBAAqB,CAAC;AAK9C,OAAO,cAAc,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C,oBAAY,cAAc;IACtB,MAAM,IAAA;IACN,SAAS,IAAA;CACZ;AAED,oBAAY,aAAa;IACrB,UAAU,IAAA;IACV,SAAS,IAAA;IACT,aAAa,IAAA;IACb,YAAY,IAAA;CACf;AAED,MAAM,CAAC,OAAO,OAAO,OAAO;IA+BpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;aACR,KAAK,EAAE,UAAU;aACjB,IAAI,EAAE,MAAM;IAjChC,OAAO,CAAC,KAAK,CAA4B;IAEzC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmC;IAErE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAW;IAC5C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAW;IAE/C,OAAO,CAAC,sBAAsB,CAA0B;IACxD,OAAO,CAAC,kBAAkB,CAA0B;IAGpD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA8C;IAC7E,OAAO,CAAC,mBAAmB,CAAK;IAEhC,OAAO,CAAC,uBAAuB,CAAM;IACrC,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAW;IAC3C,OAAO,CAAC,kBAAkB,CAA8C;IAGxE,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,MAAM,CAAQ;IAGtB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;gBAG1B,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,MAAM,EAChB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM;IAgBhC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAoB7B;IAEK,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IA+B/B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAcnC,OAAO,CAAC,cAAc;IA6CtB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,WAAW;IA8CZ,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,iBAAwB,GAAG,IAAI;IA6CnE,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,YAAY;IA0BP,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAkBvD,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAiBzD,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IA+BlC,cAAc,IAAI,IAAI;IAQ7B,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,UAAU;IAIX,KAAK,IAAI,IAAI;IAKpB;;;OAGG;IACI,UAAU,CAAC,MAAM,SAAsB,GAAG,IAAI;IAS9C,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,OAAO;IAInB,cAAc,IAAI,OAAO;IAIzB,WAAW,IAAI,cAAc;IAIpC;;;;OAIG;IACI,MAAM,IAAI,MAAM;IAIhB,UAAU,IAAI,WAAW;CAGnC"}