GTP-U/GTPv2 Protocol Implementation

export interface GTPUHeader {
  version: number;
  protocolType: number;
  extensionHeaderFlag: boolean;
  sequenceNumberFlag: boolean;
  nPduNumberFlag: boolean;
  messageType: number;
  length: number;
  teid: number;
  sequenceNumber?: number;
  nPduNumber?: number;
  nextExtensionHeaderType?: number;
}

export function parseGTPUHeader(buffer: Buffer): GTPUHeader {
  if (buffer.length < 8) {
    throw new Error('GTP-U packet too short');
  }
  
  // Byte 0: Flags and version
  const flags = buffer.readUInt8(0);
  const version = (flags >> 5) & 0x07;
  const protocolType = (flags >> 4) & 0x01;
  const extensionHeaderFlag = Boolean((flags >> 2) & 0x01);
  const sequenceNumberFlag = Boolean((flags >> 1) & 0x01);
  const nPduNumberFlag = Boolean(flags & 0x01);
  
  // Byte 1: Message type
  const messageType = buffer.readUInt8(1);
  
  // Bytes 2-3: Length
  const length = buffer.readUInt16BE(2);
  
  // Bytes 4-7: TEID (Tunnel Endpoint Identifier)
  const teid = buffer.readUInt32BE(4);
  
  const header: GTPUHeader = {
    version,
    protocolType,
    extensionHeaderFlag,
    sequenceNumberFlag,
    nPduNumberFlag,
    messageType,
    length,
    teid
  };
  
  // Optional fields (if flags are set)
  let offset = 8;
  
  if (sequenceNumberFlag || nPduNumberFlag || extensionHeaderFlag) {
    if (buffer.length < 12) {
      throw new Error('GTP-U packet too short for optional fields');
    }
    
    if (sequenceNumberFlag) {
      header.sequenceNumber = buffer.readUInt16BE(offset);
    }
    offset += 2;
    
    if (nPduNumberFlag) {
      header.nPduNumber = buffer.readUInt8(offset);
    }
    offset += 1;
    
    if (extensionHeaderFlag) {
      header.nextExtensionHeaderType = buffer.readUInt8(offset);
    }
  }
  
  return header;
}

export function encapsulatePacket(
  payload: Buffer,
  teid: number,
  sequenceNumber?: number
): Buffer {
  const hasSequence = sequenceNumber !== undefined;
  const headerLength = hasSequence ? 12 : 8;
  
  const gtpuPacket = Buffer.alloc(headerLength + payload.length);
  
  // Byte 0: Version (1), PT (1), Flags
  let flags = 0x30; // Version 1, PT = 1
  if (hasSequence) {
    flags |= 0x02; // Set S flag
  }
  gtpuPacket.writeUInt8(flags, 0);
  
  // Byte 1: Message Type (255 = G-PDU for user data)
  gtpuPacket.writeUInt8(0xFF, 1);
  
  // Bytes 2-3: Length (payload + optional fields)
  const length = payload.length + (hasSequence ? 4 : 0);
  gtpuPacket.writeUInt16BE(length, 2);
  
  // Bytes 4-7: TEID
  gtpuPacket.writeUInt32BE(teid, 4);
  
  // Optional sequence number
  if (hasSequence) {
    gtpuPacket.writeUInt16BE(sequenceNumber!, 8);
    gtpuPacket.writeUInt8(0, 10); // N-PDU Number (not used)
    gtpuPacket.writeUInt8(0, 11); // Next Extension Header Type (none)
  }
  
  // Copy payload
  payload.copy(gtpuPacket, headerLength);
  
  return gtpuPacket;
}