@omindu/yaksha 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omindu/yaksha",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Lightning-fast, lightweight VPN protocol library with advanced firewall bypass capabilities",
   "main": "src/index.js",
   "bin": {

package/src/client/index.js

@@ -251,10 +251,10 @@ class YakshaClient extends EventEmitter {
 
       const handler = (data) => {
         try {
-          const { header, payload } = this.protocol.deserialize(data);
+          const packet = this.protocol.deserialize(data);
 
-          if (header.type === Protocol.PACKET_TYPES.HANDSHAKE) {
-            const response = JSON.parse(payload.toString('utf8'));
+          if (packet.type === Protocol.PACKET_TYPES.HANDSHAKE) {
+            const response = JSON.parse(packet.payload.toString('utf8'));
             
             // Store session ID
             this.sessionId = response.sessionId;
@@ -296,15 +296,15 @@ class YakshaClient extends EventEmitter {
     this.emit('_rawData', data);
 
     try {
-      const { header, payload } = this.protocol.deserialize(data);
+      const packet = this.protocol.deserialize(data);
 
       this.stats.packetsReceived++;
       this.stats.bytesReceived += data.length;
 
       // Handle different packet types
-      switch (header.type) {
+      switch (packet.type) {
         case Protocol.PACKET_TYPES.DATA:
-          this._handleDataPacket(payload);
+          this._handleDataPacket(packet.payload);
           break;
 
         case Protocol.PACKET_TYPES.KEEPALIVE:

package/src/core/protocol.js

@@ -1,12 +1,18 @@
 'use strict';
 
 /**
- * Yaksha Protocol Handler
- * Custom protocol for packet parsing and handling
+ * Yaksha Protocol Implementation (v1.1.0 - Cross-Platform Fixed)
+ * Fixed for Linux server <-> Windows client compatibility
+ * - Explicit unsigned integer operations
+ * - Platform-independent CRC32 checksum
+ * - Robust buffer handling with proper byte ordering
  */
 
 const crypto = require('crypto');
-const { globalPool } = require('../utils/buffer-pool');
+
+// Protocol constants
+const PROTOCOL_VERSION = 0x01;
+const HEADER_SIZE = 16; // bytes
 
 // Packet types
 const PACKET_TYPES = {
@@ -17,12 +23,6 @@ const PACKET_TYPES = {
   KEEPALIVE: 0x05
 };
 
-// Protocol version
-const PROTOCOL_VERSION = 0x01;
-
-// Header size (fixed 16 bytes)
-const HEADER_SIZE = 16;
-
 class Protocol {
   constructor(options = {}) {
     this.version = PROTOCOL_VERSION;
@@ -31,56 +31,59 @@ class Protocol {
   }
 
   /**
-   * Create a packet header
-   * Header structure (16 bytes):
-   * - Version (1 byte)
-   * - Type (1 byte)
-   * - Length (2 bytes) - payload length
-   * - Session ID (4 bytes)
-   * - Sequence (4 bytes)
-   * - Checksum (4 bytes)
+   * Create protocol header with explicit byte ordering
+   * CRITICAL: Uses big-endian for all multi-byte values for cross-platform consistency
    */
-  createHeader(type, payloadLength, sessionId, sequence) {
-    const header = globalPool.acquire(HEADER_SIZE, true);
-
-    // Version
-    header.writeUInt8(this.version, 0);
-
-    // Type
-    header.writeUInt8(type, 1);
-
-    // Length (uint16, max 65535)
-    header.writeUInt16BE(payloadLength, 2);
-
-    // Session ID (uint32)
-    header.writeUInt32BE(sessionId, 4);
-
-    // Sequence (uint32)
-    header.writeUInt32BE(sequence, 8);
-
-    // Checksum placeholder (will be filled later)
-    header.writeUInt32BE(0, 12);
-
+  createHeader(type, length, sessionId, sequence) {
+    const header = Buffer.alloc(HEADER_SIZE); // Zero-filled for consistency
+    
+    // Force unsigned integers to prevent sign issues across platforms
+    const safeType = (type & 0xFF) >>> 0;
+    const safeLength = (length & 0xFFFF) >>> 0;
+    const safeSessionId = (sessionId >>> 0);
+    const safeSequence = (sequence >>> 0);
+    
+    header.writeUInt8(this.version, 0);      // Version (1 byte)
+    header.writeUInt8(safeType, 1);          // Type (1 byte)
+    header.writeUInt16BE(safeLength, 2);     // Length (2 bytes, big-endian)
+    header.writeUInt32BE(safeSessionId, 4);  // Session ID (4 bytes, big-endian)
+    header.writeUInt32BE(safeSequence, 8);   // Sequence (4 bytes, big-endian)
+    header.writeUInt32BE(0, 12);             // Checksum placeholder (4 bytes)
+    
     return header;
   }
 
   /**
-   * Calculate CRC32 checksum
+   * Calculate CRC32 checksum with explicit unsigned operations
+   * CRITICAL FIX: Ensures same result on Linux and Windows
    */
   calculateChecksum(data) {
-    // Simple CRC32 implementation
-    let crc = 0xFFFFFFFF;
+    // Ensure we're working with a Buffer
+    if (!Buffer.isBuffer(data)) {
+      data = Buffer.from(data);
+    }
+
+    let crc = 0xFFFFFFFF >>> 0; // Force unsigned
+    
     for (let i = 0; i < data.length; i++) {
-      crc ^= data[i];
+      const byte = data[i] & 0xFF; // Ensure byte is 0-255
+      crc = (crc ^ byte) >>> 0;
+      
       for (let j = 0; j < 8; j++) {
-        crc = (crc >>> 1) ^ (0xEDB88320 & -(crc & 1));
+        // Explicit unsigned right shift and bitwise operations
+        if ((crc & 1) !== 0) {
+          crc = ((crc >>> 1) ^ 0xEDB88320) >>> 0;
+        } else {
+          crc = (crc >>> 1) >>> 0;
+        }
       }
     }
-    return (crc ^ 0xFFFFFFFF) >>> 0;
+    
+    return ((crc ^ 0xFFFFFFFF) >>> 0);
   }
 
   /**
-   * Add random padding for traffic obfuscation
+   * Add random padding for obfuscation
    */
   addPadding(data, maxPaddingSize = 255) {
     if (!this.enablePadding) {
@@ -102,27 +105,48 @@ class Protocol {
    * Remove padding from data
    */
   removePadding(data, paddingSize) {
-    if (paddingSize === 0) {
+    if (paddingSize === 0 || !paddingSize) {
       return data;
     }
     return data.slice(0, -paddingSize);
   }
 
   /**
-   * Serialize packet
+   * Serialize packet (Linux/Windows compatible)
+   * CRITICAL FIX: Proper buffer construction and checksum calculation
    */
   serialize(type, payload, sessionId, sequence) {
+    // Ensure payload is a proper Buffer
+    if (!Buffer.isBuffer(payload)) {
+      if (typeof payload === 'string') {
+        payload = Buffer.from(payload, 'utf8');
+      } else {
+        payload = Buffer.from(payload);
+      }
+    }
+
     // Add padding to payload
     const { data: paddedPayload, paddingSize } = this.addPadding(payload);
 
-    // Create header
-    const header = this.createHeader(type, paddedPayload.length, sessionId, sequence);
+    // Force safe unsigned integers
+    const safeSessionId = (sessionId >>> 0);
+    const safeSequence = (sequence >>> 0);
+
+    // Create header with zero checksum
+    const header = this.createHeader(type, paddedPayload.length, safeSessionId, safeSequence);
 
-    // Combine header and payload
-    const packet = Buffer.concat([header, paddedPayload]);
+    // Create complete packet buffer (avoid Buffer.concat for consistency)
+    const totalSize = header.length + paddedPayload.length;
+    const packet = Buffer.allocUnsafe(totalSize);
+    
+    // Copy header and payload explicitly
+    header.copy(packet, 0, 0, header.length);
+    paddedPayload.copy(packet, header.length, 0, paddedPayload.length);
 
-    // Calculate and update checksum (checksum covers header + payload)
-    const checksum = this.calculateChecksum(packet);
+    // Calculate checksum over entire packet (with checksum field zeroed)
+    const checksum = this.calculateChecksum(packet) >>> 0;
+    
+    // Write checksum to header
     packet.writeUInt32BE(checksum, 12);
 
     return { packet, paddingSize };
@@ -132,20 +156,25 @@ class Protocol {
    * Parse packet header
    */
   parseHeader(buffer) {
+    if (!Buffer.isBuffer(buffer)) {
+      throw new Error('Invalid buffer: not a Buffer object');
+    }
+
     if (buffer.length < HEADER_SIZE) {
-      throw new Error('Buffer too small for header');
+      throw new Error(`Buffer too small for header: ${buffer.length} bytes (need ${HEADER_SIZE})`);
     }
 
-    const version = buffer.readUInt8(0);
-    const type = buffer.readUInt8(1);
-    const length = buffer.readUInt16BE(2);
-    const sessionId = buffer.readUInt32BE(4);
-    const sequence = buffer.readUInt32BE(8);
-    const checksum = buffer.readUInt32BE(12);
+    // Read with explicit unsigned operations
+    const version = buffer.readUInt8(0) & 0xFF;
+    const type = buffer.readUInt8(1) & 0xFF;
+    const length = buffer.readUInt16BE(2) >>> 0;
+    const sessionId = buffer.readUInt32BE(4) >>> 0;
+    const sequence = buffer.readUInt32BE(8) >>> 0;
+    const checksum = buffer.readUInt32BE(12) >>> 0;
 
     // Validate version
     if (version !== this.version) {
-      throw new Error(`Unsupported protocol version: ${version}`);
+      throw new Error(`Unsupported protocol version: ${version} (expected ${this.version})`);
     }
 
     // Validate type
@@ -155,7 +184,7 @@ class Protocol {
 
     // Validate length
     if (length > this.maxPayloadSize) {
-      throw new Error(`Payload too large: ${length}`);
+      throw new Error(`Payload too large: ${length} (max ${this.maxPayloadSize})`);
     }
 
     return {
@@ -169,99 +198,143 @@ class Protocol {
   }
 
   /**
-   * Deserialize packet
+   * Deserialize packet (Linux/Windows compatible)
+   * CRITICAL FIX: Robust validation and error reporting
    */
   deserialize(buffer, paddingSize = 0) {
-    // Parse header
-    const header = this.parseHeader(buffer);
+    if (!Buffer.isBuffer(buffer)) {
+      throw new Error('Invalid buffer: not a Buffer object');
+    }
 
-    // Check if we have complete packet
-    const expectedSize = HEADER_SIZE + header.length;
-    if (buffer.length < expectedSize) {
-      throw new Error(`Incomplete packet: expected ${expectedSize}, got ${buffer.length}`);
+    // Parse header first
+    const header = this.parseHeader(buffer);
+    
+    const totalExpectedSize = HEADER_SIZE + header.length;
+    if (buffer.length < totalExpectedSize) {
+      throw new Error(
+        `Incomplete packet: got ${buffer.length} bytes, expected ${totalExpectedSize} ` +
+        `(header=${HEADER_SIZE}, payload=${header.length})`
+      );
     }
 
-    // Verify checksum
-    const storedChecksum = header.checksum;
+    // Extract payload (create new buffer to avoid reference issues)
+    const payloadStart = HEADER_SIZE;
+    const payloadEnd = payloadStart + header.length;
+    const payload = Buffer.allocUnsafe(header.length);
+    buffer.copy(payload, 0, payloadStart, payloadEnd);
+
+    // Verify checksum - recalculate with checksum field zeroed
+    const verifyBuffer = Buffer.allocUnsafe(buffer.length);
+    buffer.copy(verifyBuffer, 0, 0, buffer.length);
+    verifyBuffer.writeUInt32BE(0, 12); // Zero out checksum field
     
-    // Create a copy of packet and zero out checksum field for verification
-    const packetCopy = Buffer.from(buffer.slice(0, expectedSize));
-    packetCopy.writeUInt32BE(0, 12);
+    const calculatedChecksum = this.calculateChecksum(verifyBuffer) >>> 0;
+    const receivedChecksum = header.checksum >>> 0;
     
-    const calculatedChecksum = this.calculateChecksum(packetCopy);
-
-    if (storedChecksum !== calculatedChecksum) {
-      throw new Error('Checksum verification failed');
+    if (receivedChecksum !== calculatedChecksum) {
+      // Detailed error for debugging cross-platform issues
+      const debugInfo = {
+        received: '0x' + receivedChecksum.toString(16).padStart(8, '0').toUpperCase(),
+        calculated: '0x' + calculatedChecksum.toString(16).padStart(8, '0').toUpperCase(),
+        packetSize: buffer.length,
+        headerSize: HEADER_SIZE,
+        payloadSize: header.length,
+        type: header.type,
+        sequence: header.sequence,
+        platform: process.platform,
+        nodeVersion: process.version
+      };
+      
+      throw new Error(
+        `Checksum verification failed!\n` +
+        `  Received:   ${debugInfo.received}\n` +
+        `  Calculated: ${debugInfo.calculated}\n` +
+        `  Packet: ${debugInfo.packetSize} bytes (header=${debugInfo.headerSize}, payload=${debugInfo.payloadSize})\n` +
+        `  Type: ${debugInfo.type}, Sequence: ${debugInfo.sequence}\n` +
+        `  Platform: ${debugInfo.platform}, Node: ${debugInfo.nodeVersion}`
+      );
     }
 
-    // Extract payload
-    let payload = buffer.slice(HEADER_SIZE, expectedSize);
-
-    // Remove padding if present
-    payload = this.removePadding(payload, paddingSize);
+    // Remove padding from payload
+    const unpaddedPayload = this.removePadding(payload, paddingSize);
 
     return {
-      header,
-      payload,
-      totalSize: expectedSize
+      type: header.type,
+      payload: unpaddedPayload,
+      sessionId: header.sessionId,
+      sequence: header.sequence,
+      checksum: header.checksum
     };
   }
 
   /**
-   * Create HANDSHAKE packet
+   * Get packet type name
    */
-  createHandshake(sessionId, sequence, data) {
-    return this.serialize(PACKET_TYPES.HANDSHAKE, data, sessionId, sequence);
+  getPacketTypeName(type) {
+    for (const [name, value] of Object.entries(PACKET_TYPES)) {
+      if (value === type) {
+        return name;
+      }
+    }
+    return `UNKNOWN(${type})`;
   }
 
   /**
-   * Create DATA packet
+   * Create handshake packet
+   * @param {number} sessionId - Session identifier
+   * @param {number} sequence - Packet sequence number
+   * @param {Buffer} payload - Handshake data (usually JSON)
+   * @returns {Object} { packet: Buffer, paddingSize: number }
    */
-  createData(sessionId, sequence, data) {
-    return this.serialize(PACKET_TYPES.DATA, data, sessionId, sequence);
+  createHandshake(sessionId, sequence, payload) {
+    return this.serialize(PACKET_TYPES.HANDSHAKE, payload, sessionId, sequence);
   }
 
   /**
-   * Create ACK packet
+   * Create data packet
+   * @param {number} sessionId - Session identifier
+   * @param {number} sequence - Packet sequence number
+   * @param {Buffer} payload - Data payload
+   * @returns {Object} { packet: Buffer, paddingSize: number }
    */
-  createAck(sessionId, sequence, ackSequence) {
-    const ackBuffer = Buffer.allocUnsafe(4);
-    ackBuffer.writeUInt32BE(ackSequence, 0);
-    return this.serialize(PACKET_TYPES.ACK, ackBuffer, sessionId, sequence);
+  createData(sessionId, sequence, payload) {
+    return this.serialize(PACKET_TYPES.DATA, payload, sessionId, sequence);
   }
 
   /**
-   * Create CLOSE packet
+   * Create ACK packet
+   * @param {number} sessionId - Session identifier
+   * @param {number} sequence - Packet sequence number
+   * @param {Buffer} payload - ACK data (optional)
+   * @returns {Object} { packet: Buffer, paddingSize: number }
    */
-  createClose(sessionId, sequence, reason = '') {
-    const reasonBuffer = Buffer.from(reason, 'utf8');
-    return this.serialize(PACKET_TYPES.CLOSE, reasonBuffer, sessionId, sequence);
+  createAck(sessionId, sequence, payload = Buffer.alloc(0)) {
+    return this.serialize(PACKET_TYPES.ACK, payload, sessionId, sequence);
   }
 
   /**
-   * Create KEEPALIVE packet
+   * Create close packet
+   * @param {number} sessionId - Session identifier
+   * @param {number} sequence - Packet sequence number
+   * @param {Buffer} payload - Close reason (optional)
+   * @returns {Object} { packet: Buffer, paddingSize: number }
    */
-  createKeepalive(sessionId, sequence) {
-    const timestamp = Buffer.allocUnsafe(8);
-    timestamp.writeBigUInt64BE(BigInt(Date.now()), 0);
-    return this.serialize(PACKET_TYPES.KEEPALIVE, timestamp, sessionId, sequence);
+  createClose(sessionId, sequence, payload = Buffer.alloc(0)) {
+    return this.serialize(PACKET_TYPES.CLOSE, payload, sessionId, sequence);
   }
 
   /**
-   * Get packet type name
+   * Create keepalive packet
+   * @param {number} sessionId - Session identifier
+   * @param {number} sequence - Packet sequence number
+   * @returns {Object} { packet: Buffer, paddingSize: number }
    */
-  getTypeName(type) {
-    const typeNames = {
-      [PACKET_TYPES.HANDSHAKE]: 'HANDSHAKE',
-      [PACKET_TYPES.DATA]: 'DATA',
-      [PACKET_TYPES.ACK]: 'ACK',
-      [PACKET_TYPES.CLOSE]: 'CLOSE',
-      [PACKET_TYPES.KEEPALIVE]: 'KEEPALIVE'
-    };
-    return typeNames[type] || 'UNKNOWN';
+  createKeepalive(sessionId, sequence) {
+    return this.serialize(PACKET_TYPES.KEEPALIVE, Buffer.alloc(0), sessionId, sequence);
   }
 }
 
+// Export
 module.exports = Protocol;
 module.exports.PACKET_TYPES = PACKET_TYPES;
 module.exports.HEADER_SIZE = HEADER_SIZE;

package/src/core/protocol.js.backup

@@ -0,0 +1,268 @@
+'use strict';
+
+/**
+ * Yaksha Protocol Handler
+ * Custom protocol for packet parsing and handling
+ */
+
+const crypto = require('crypto');
+const { globalPool } = require('../utils/buffer-pool');
+
+// Packet types
+const PACKET_TYPES = {
+  HANDSHAKE: 0x01,
+  DATA: 0x02,
+  ACK: 0x03,
+  CLOSE: 0x04,
+  KEEPALIVE: 0x05
+};
+
+// Protocol version
+const PROTOCOL_VERSION = 0x01;
+
+// Header size (fixed 16 bytes)
+const HEADER_SIZE = 16;
+
+class Protocol {
+  constructor(options = {}) {
+    this.version = PROTOCOL_VERSION;
+    this.maxPayloadSize = options.maxPayloadSize || 65535;
+    this.enablePadding = options.enablePadding !== false;
+  }
+
+  /**
+   * Create a packet header
+   * Header structure (16 bytes):
+   * - Version (1 byte)
+   * - Type (1 byte)
+   * - Length (2 bytes) - payload length
+   * - Session ID (4 bytes)
+   * - Sequence (4 bytes)
+   * - Checksum (4 bytes)
+   */
+  createHeader(type, payloadLength, sessionId, sequence) {
+    const header = globalPool.acquire(HEADER_SIZE, true);
+
+    // Version
+    header.writeUInt8(this.version, 0);
+
+    // Type
+    header.writeUInt8(type, 1);
+
+    // Length (uint16, max 65535)
+    header.writeUInt16BE(payloadLength, 2);
+
+    // Session ID (uint32)
+    header.writeUInt32BE(sessionId, 4);
+
+    // Sequence (uint32)
+    header.writeUInt32BE(sequence, 8);
+
+    // Checksum placeholder (will be filled later)
+    header.writeUInt32BE(0, 12);
+
+    return header;
+  }
+
+  /**
+   * Calculate CRC32 checksum
+   */
+  calculateChecksum(data) {
+    // Simple CRC32 implementation
+    let crc = 0xFFFFFFFF;
+    for (let i = 0; i < data.length; i++) {
+      crc ^= data[i];
+      for (let j = 0; j < 8; j++) {
+        crc = (crc >>> 1) ^ (0xEDB88320 & -(crc & 1));
+      }
+    }
+    return (crc ^ 0xFFFFFFFF) >>> 0;
+  }
+
+  /**
+   * Add random padding for traffic obfuscation
+   */
+  addPadding(data, maxPaddingSize = 255) {
+    if (!this.enablePadding) {
+      return { data, paddingSize: 0 };
+    }
+
+    const paddingSize = crypto.randomInt(0, Math.min(maxPaddingSize + 1, 256));
+    if (paddingSize === 0) {
+      return { data, paddingSize: 0 };
+    }
+
+    const padding = crypto.randomBytes(paddingSize);
+    const paddedData = Buffer.concat([data, padding]);
+
+    return { data: paddedData, paddingSize };
+  }
+
+  /**
+   * Remove padding from data
+   */
+  removePadding(data, paddingSize) {
+    if (paddingSize === 0) {
+      return data;
+    }
+    return data.slice(0, -paddingSize);
+  }
+
+  /**
+   * Serialize packet
+   */
+  serialize(type, payload, sessionId, sequence) {
+    // Add padding to payload
+    const { data: paddedPayload, paddingSize } = this.addPadding(payload);
+
+    // Create header
+    const header = this.createHeader(type, paddedPayload.length, sessionId, sequence);
+
+    // Combine header and payload
+    const packet = Buffer.concat([header, paddedPayload]);
+
+    // Calculate and update checksum (checksum covers header + payload)
+    const checksum = this.calculateChecksum(packet);
+    packet.writeUInt32BE(checksum, 12);
+
+    return { packet, paddingSize };
+  }
+
+  /**
+   * Parse packet header
+   */
+  parseHeader(buffer) {
+    if (buffer.length < HEADER_SIZE) {
+      throw new Error('Buffer too small for header');
+    }
+
+    const version = buffer.readUInt8(0);
+    const type = buffer.readUInt8(1);
+    const length = buffer.readUInt16BE(2);
+    const sessionId = buffer.readUInt32BE(4);
+    const sequence = buffer.readUInt32BE(8);
+    const checksum = buffer.readUInt32BE(12);
+
+    // Validate version
+    if (version !== this.version) {
+      throw new Error(`Unsupported protocol version: ${version}`);
+    }
+
+    // Validate type
+    if (!Object.values(PACKET_TYPES).includes(type)) {
+      throw new Error(`Invalid packet type: ${type}`);
+    }
+
+    // Validate length
+    if (length > this.maxPayloadSize) {
+      throw new Error(`Payload too large: ${length}`);
+    }
+
+    return {
+      version,
+      type,
+      length,
+      sessionId,
+      sequence,
+      checksum
+    };
+  }
+
+  /**
+   * Deserialize packet
+   */
+  deserialize(buffer, paddingSize = 0) {
+    // Parse header
+    const header = this.parseHeader(buffer);
+
+    // Check if we have complete packet
+    const expectedSize = HEADER_SIZE + header.length;
+    if (buffer.length < expectedSize) {
+      throw new Error(`Incomplete packet: expected ${expectedSize}, got ${buffer.length}`);
+    }
+
+    // Verify checksum
+    const storedChecksum = header.checksum;
+    
+    // Create a copy of packet and zero out checksum field for verification
+    const packetCopy = Buffer.from(buffer.slice(0, expectedSize));
+    packetCopy.writeUInt32BE(0, 12);
+    
+    const calculatedChecksum = this.calculateChecksum(packetCopy);
+
+    if (storedChecksum !== calculatedChecksum) {
+      throw new Error('Checksum verification failed');
+    }
+
+    // Extract payload
+    let payload = buffer.slice(HEADER_SIZE, expectedSize);
+
+    // Remove padding if present
+    payload = this.removePadding(payload, paddingSize);
+
+    return {
+      header,
+      payload,
+      totalSize: expectedSize
+    };
+  }
+
+  /**
+   * Create HANDSHAKE packet
+   */
+  createHandshake(sessionId, sequence, data) {
+    return this.serialize(PACKET_TYPES.HANDSHAKE, data, sessionId, sequence);
+  }
+
+  /**
+   * Create DATA packet
+   */
+  createData(sessionId, sequence, data) {
+    return this.serialize(PACKET_TYPES.DATA, data, sessionId, sequence);
+  }
+
+  /**
+   * Create ACK packet
+   */
+  createAck(sessionId, sequence, ackSequence) {
+    const ackBuffer = Buffer.allocUnsafe(4);
+    ackBuffer.writeUInt32BE(ackSequence, 0);
+    return this.serialize(PACKET_TYPES.ACK, ackBuffer, sessionId, sequence);
+  }
+
+  /**
+   * Create CLOSE packet
+   */
+  createClose(sessionId, sequence, reason = '') {
+    const reasonBuffer = Buffer.from(reason, 'utf8');
+    return this.serialize(PACKET_TYPES.CLOSE, reasonBuffer, sessionId, sequence);
+  }
+
+  /**
+   * Create KEEPALIVE packet
+   */
+  createKeepalive(sessionId, sequence) {
+    const timestamp = Buffer.allocUnsafe(8);
+    timestamp.writeBigUInt64BE(BigInt(Date.now()), 0);
+    return this.serialize(PACKET_TYPES.KEEPALIVE, timestamp, sessionId, sequence);
+  }
+
+  /**
+   * Get packet type name
+   */
+  getTypeName(type) {
+    const typeNames = {
+      [PACKET_TYPES.HANDSHAKE]: 'HANDSHAKE',
+      [PACKET_TYPES.DATA]: 'DATA',
+      [PACKET_TYPES.ACK]: 'ACK',
+      [PACKET_TYPES.CLOSE]: 'CLOSE',
+      [PACKET_TYPES.KEEPALIVE]: 'KEEPALIVE'
+    };
+    return typeNames[type] || 'UNKNOWN';
+  }
+}
+
+module.exports = Protocol;
+module.exports.PACKET_TYPES = PACKET_TYPES;
+module.exports.HEADER_SIZE = HEADER_SIZE;
+module.exports.PROTOCOL_VERSION = PROTOCOL_VERSION;

package/src/server/index.js

@@ -242,20 +242,20 @@ class YakshaServer extends EventEmitter {
   _handleTCPData(buffer, client) {
     try {
       // Parse packet
-      const { header, payload, totalSize } = this.protocol.deserialize(buffer);
+      const packet = this.protocol.deserialize(buffer);
 
       this.stats.packetsReceived++;
-      this.stats.bytesReceived += totalSize;
+      this.stats.bytesReceived += buffer.length;
       client.lastActivity = Date.now();
 
       // Handle different packet types
-      switch (header.type) {
+      switch (packet.type) {
         case Protocol.PACKET_TYPES.HANDSHAKE:
-          this._handleHandshake(payload, client);
+          this._handleHandshake(packet.payload, client);
           break;
 
         case Protocol.PACKET_TYPES.DATA:
-          this._handleData(payload, client);
+          this._handleData(packet.payload, client);
           break;
 
         case Protocol.PACKET_TYPES.KEEPALIVE:
@@ -292,14 +292,14 @@ class YakshaServer extends EventEmitter {
       }
 
       // Process packet
-      const { payload } = this.protocol.deserialize(data);
+      const packet = this.protocol.deserialize(data);
 
       this.stats.packetsReceived++;
       this.stats.bytesReceived += data.length;
       client.lastActivity = Date.now();
 
       // Handle data packet
-      this._handleData(payload, client, 'udp');
+      this._handleData(packet.payload, client, 'udp');
 
     } catch (error) {
       this.logger.error('Error processing UDP data:', error.message);