node-ikev2 0.1.4 → 0.2.1

package/lib/src/configuration-attribute.d.ts

@@ -263,7 +263,7 @@ export declare class P_CSCF_IP6_ADDRESS extends ConfigurationAttribute {
     toJSON(): Record<string, any>;
     toString(): string;
 }
-export declare class CP_Attributes {
+export declare class CPAttributes {
     INTERNAL_IP4_ADDRESS: INTERNAL_IP4_ADDRESS[];
     INTERNAL_IP4_NETMASK: INTERNAL_IP4_NETMASK | undefined;
     INTERNAL_IP4_DNS: INTERNAL_IP4_DNS[];
@@ -280,7 +280,7 @@ export declare class CP_Attributes {
     P_CSCF_IP6_ADDRESS: P_CSCF_IP6_ADDRESS[];
     OtherAttributes: ConfigurationAttribute[];
     constructor();
-    parse(buffer: Buffer): void;
+    static parse(buffer: Buffer): CPAttributes;
     /**
      * Serializes the configuration attributes to a buffer
      * @public
@@ -300,7 +300,3 @@ export declare class CP_Attributes {
      */
     toString(): string;
 }
-export declare function parseIPv4AddressString(addressString: string): Buffer;
-export declare function formatIPv4AddressBuffer(buffer: Buffer): string;
-export declare function parseIPv6AddressString(addressString: string): Buffer;
-export declare function formatIPv6AddressBuffer(addressBuffer: Buffer): string;

package/lib/src/configuration-attribute.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CP_Attributes = exports.P_CSCF_IP6_ADDRESS = exports.P_CSCF_IP4_ADDRESS = exports.INTERNAL_IP6_SUBNET = exports.SUPPORTED_ATTRIBUTES = exports.INTERNAL_IP4_SUBNET = exports.INTERNAL_IP6_DHCP = exports.INTERNAL_IP6_DNS = exports.INTERNAL_IP6_ADDRESS = exports.APPLICATION_VERSION = exports.INTERNAL_IP4_DHCP = exports.INTERNAL_IP4_NBNS = exports.INTERNAL_IP4_DNS = exports.INTERNAL_IP4_NETMASK = exports.INTERNAL_IP4_ADDRESS = exports.ConfigurationAttribute = exports.configurationAttributeType = void 0;
-exports.parseIPv4AddressString = parseIPv4AddressString;
-exports.formatIPv4AddressBuffer = formatIPv4AddressBuffer;
-exports.parseIPv6AddressString = parseIPv6AddressString;
-exports.formatIPv6AddressBuffer = formatIPv6AddressBuffer;
+exports.CPAttributes = exports.P_CSCF_IP6_ADDRESS = exports.P_CSCF_IP4_ADDRESS = exports.INTERNAL_IP6_SUBNET = exports.SUPPORTED_ATTRIBUTES = exports.INTERNAL_IP4_SUBNET = exports.INTERNAL_IP6_DHCP = exports.INTERNAL_IP6_DNS = exports.INTERNAL_IP6_ADDRESS = exports.APPLICATION_VERSION = exports.INTERNAL_IP4_DHCP = exports.INTERNAL_IP4_NBNS = exports.INTERNAL_IP4_DNS = exports.INTERNAL_IP4_NETMASK = exports.INTERNAL_IP4_ADDRESS = exports.ConfigurationAttribute = exports.configurationAttributeType = void 0;
+const ip_address_1 = require("./ip-address");
 /**
  * Configuration Attribute Types
  *
@@ -182,7 +179,7 @@ class ConfigurationAttribute {
     static parseConfigurationAttributes(buffer) {
         const attributes = [];
         let offset = 0;
-        while (offset < buffer.length) {
+        while (offset + 4 <= buffer.length) {
             // const attributeType = buffer.readUInt16BE(offset) & 0x7fff;
             const attributeLength = buffer.readUInt16BE(offset + 2);
             const attributeBuffer = buffer.subarray(offset, offset + 4 + attributeLength);
@@ -218,25 +215,28 @@ class ConfigurationAttribute {
 exports.ConfigurationAttribute = ConfigurationAttribute;
 class INTERNAL_IP4_ADDRESS extends ConfigurationAttribute {
     constructor(address) {
-        if (address.length !== 4) {
+        if (address.length !== 0 && address.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_ADDRESS");
         }
         super(configurationAttributeType.INTERNAL_IP4_ADDRESS, address);
         this.address = address;
     }
     static parse(buffer) {
-        if (buffer.length !== 4) {
+        if (buffer.length !== 0 && buffer.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_ADDRESS");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP4_ADDRESS(Buffer.alloc(0));
+        }
         return new INTERNAL_IP4_ADDRESS(buffer.subarray(0, 4));
     }
     static serializeJSON(json) {
-        const address = parseIPv4AddressString(json.address);
+        const address = (0, ip_address_1.parseIPv4AddressString)(json.address);
         return new INTERNAL_IP4_ADDRESS(address).serialize();
     }
     toJSON() {
         return {
-            address: formatIPv4AddressBuffer(this.address),
+            address: (0, ip_address_1.formatIPv4AddressBuffer)(this.address),
         };
     }
     toString() {
@@ -247,25 +247,28 @@ class INTERNAL_IP4_ADDRESS extends ConfigurationAttribute {
 exports.INTERNAL_IP4_ADDRESS = INTERNAL_IP4_ADDRESS;
 class INTERNAL_IP4_NETMASK extends ConfigurationAttribute {
     constructor(netmask) {
-        if (netmask.length !== 4) {
+        if (netmask.length !== 0 && netmask.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_NETMASK");
         }
         super(configurationAttributeType.INTERNAL_IP4_NETMASK, netmask);
         this.netmask = netmask;
     }
     static parse(buffer) {
-        if (buffer.length !== 4) {
+        if (buffer.length !== 0 && buffer.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_NETMASK");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP4_NETMASK(Buffer.alloc(0));
+        }
         return new INTERNAL_IP4_NETMASK(buffer.subarray(0, 4));
     }
     static serializeJSON(json) {
-        const netmask = parseIPv4AddressString(json.netmask);
+        const netmask = (0, ip_address_1.parseIPv4AddressString)(json.netmask);
         return new INTERNAL_IP4_NETMASK(netmask).serialize();
     }
     toJSON() {
         return {
-            netmask: formatIPv4AddressBuffer(this.netmask),
+            netmask: (0, ip_address_1.formatIPv4AddressBuffer)(this.netmask),
         };
     }
     toString() {
@@ -276,25 +279,28 @@ class INTERNAL_IP4_NETMASK extends ConfigurationAttribute {
 exports.INTERNAL_IP4_NETMASK = INTERNAL_IP4_NETMASK;
 class INTERNAL_IP4_DNS extends ConfigurationAttribute {
     constructor(dns) {
-        if (dns.length !== 4) {
+        if (dns.length !== 0 && dns.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_DNS");
         }
         super(configurationAttributeType.INTERNAL_IP4_DNS, dns);
         this.dns = dns;
     }
     static parse(buffer) {
-        if (buffer.length !== 4) {
+        if (buffer.length !== 0 && buffer.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_DNS");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP4_DNS(Buffer.alloc(0));
+        }
         return new INTERNAL_IP4_DNS(buffer.subarray(0, 4));
     }
     static serializeJSON(json) {
-        const dns = parseIPv4AddressString(json.dns);
+        const dns = (0, ip_address_1.parseIPv4AddressString)(json.dns);
         return new INTERNAL_IP4_DNS(dns).serialize();
     }
     toJSON() {
         return {
-            dns: formatIPv4AddressBuffer(this.dns),
+            dns: (0, ip_address_1.formatIPv4AddressBuffer)(this.dns),
         };
     }
     toString() {
@@ -305,25 +311,28 @@ class INTERNAL_IP4_DNS extends ConfigurationAttribute {
 exports.INTERNAL_IP4_DNS = INTERNAL_IP4_DNS;
 class INTERNAL_IP4_NBNS extends ConfigurationAttribute {
     constructor(nbns) {
-        if (nbns.length !== 4) {
+        if (nbns.length !== 0 && nbns.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_NBNS");
         }
         super(configurationAttributeType.INTERNAL_IP4_NBNS, nbns);
         this.nbns = nbns;
     }
     static parse(buffer) {
-        if (buffer.length !== 4) {
+        if (buffer.length !== 0 && buffer.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_NBNS");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP4_NBNS(Buffer.alloc(0));
+        }
         return new INTERNAL_IP4_NBNS(buffer.subarray(0, 4));
     }
     static serializeJSON(json) {
-        const nbns = parseIPv4AddressString(json.nbns);
+        const nbns = (0, ip_address_1.parseIPv4AddressString)(json.nbns);
         return new INTERNAL_IP4_NBNS(nbns).serialize();
     }
     toJSON() {
         return {
-            nbns: formatIPv4AddressBuffer(this.nbns),
+            nbns: (0, ip_address_1.formatIPv4AddressBuffer)(this.nbns),
         };
     }
     toString() {
@@ -334,25 +343,28 @@ class INTERNAL_IP4_NBNS extends ConfigurationAttribute {
 exports.INTERNAL_IP4_NBNS = INTERNAL_IP4_NBNS;
 class INTERNAL_IP4_DHCP extends ConfigurationAttribute {
     constructor(dhcp) {
-        if (dhcp.length !== 4) {
+        if (dhcp.length !== 0 && dhcp.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_DHCP");
         }
         super(configurationAttributeType.INTERNAL_IP4_DHCP, dhcp);
         this.dhcp = dhcp;
     }
     static parse(buffer) {
-        if (buffer.length !== 4) {
+        if (buffer.length !== 0 && buffer.length !== 4) {
             throw new Error("Invalid value length for INTERNAL_IP4_DHCP");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP4_DHCP(Buffer.alloc(0));
+        }
         return new INTERNAL_IP4_DHCP(buffer.subarray(0, 4));
     }
     static serializeJSON(json) {
-        const dhcp = parseIPv4AddressString(json.dhcp);
+        const dhcp = (0, ip_address_1.parseIPv4AddressString)(json.dhcp);
         return new INTERNAL_IP4_DHCP(dhcp).serialize();
     }
     toJSON() {
         return {
-            dhcp: formatIPv4AddressBuffer(this.dhcp),
+            dhcp: (0, ip_address_1.formatIPv4AddressBuffer)(this.dhcp),
         };
     }
     toString() {
@@ -387,33 +399,42 @@ class APPLICATION_VERSION extends ConfigurationAttribute {
 exports.APPLICATION_VERSION = APPLICATION_VERSION;
 class INTERNAL_IP6_ADDRESS extends ConfigurationAttribute {
     constructor(address, prefixLength) {
-        if (address.length !== 16) {
+        if (address.length !== 16 && address.length !== 0) {
             throw new Error("Invalid value length for INTERNAL_IP6_ADDRESS");
         }
-        if (prefixLength < 0 || prefixLength > 128) {
-            throw new Error("Invalid prefix length for INTERNAL_IP6_ADDRESS");
+        var value;
+        if (address.length === 0) {
+            value = address;
+        }
+        else {
+            if (prefixLength < 0 || prefixLength > 128) {
+                throw new Error("Invalid prefix length for INTERNAL_IP6_ADDRESS");
+            }
+            value = Buffer.alloc(17);
+            address.copy(value, 0);
+            value.writeUInt8(prefixLength, 16);
         }
-        let value = Buffer.alloc(17);
-        address.copy(value, 0);
-        value.writeUInt8(prefixLength, 16);
         super(configurationAttributeType.INTERNAL_IP6_ADDRESS, value);
         this.address = address;
         this.prefixLength = prefixLength;
     }
     static parse(buffer) {
-        if (buffer.length !== 17) {
+        if (buffer.length !== 17 && buffer.length !== 0) {
             throw new Error("Invalid value length for INTERNAL_IP6_ADDRESS");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP6_ADDRESS(Buffer.alloc(0), 0);
+        }
         return new INTERNAL_IP6_ADDRESS(buffer.subarray(0, 16), buffer.readUInt8(16));
     }
     static serializeJSON(json) {
-        const address = parseIPv6AddressString(json.address);
+        const address = (0, ip_address_1.parseIPv6AddressString)(json.address);
         const prefixLength = json.prefixLength;
         return new INTERNAL_IP6_ADDRESS(address, prefixLength).serialize();
     }
     toJSON() {
         return {
-            address: formatIPv6AddressBuffer(this.address),
+            address: (0, ip_address_1.formatIPv6AddressBuffer)(this.address),
             prefixLength: this.prefixLength,
         };
     }
@@ -425,25 +446,28 @@ class INTERNAL_IP6_ADDRESS extends ConfigurationAttribute {
 exports.INTERNAL_IP6_ADDRESS = INTERNAL_IP6_ADDRESS;
 class INTERNAL_IP6_DNS extends ConfigurationAttribute {
     constructor(dns) {
-        if (dns.length !== 16) {
+        if (dns.length !== 16 && dns.length !== 0) {
             throw new Error("Invalid value length for INTERNAL_IP6_DNS");
         }
         super(configurationAttributeType.INTERNAL_IP6_DNS, dns);
         this.dns = dns;
     }
     static parse(buffer) {
-        if (buffer.length !== 16) {
+        if (buffer.length !== 16 && buffer.length !== 0) {
             throw new Error("Invalid value length for INTERNAL_IP6_DNS");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP6_DNS(Buffer.alloc(0));
+        }
         return new INTERNAL_IP6_DNS(buffer.subarray(0, 16));
     }
     static serializeJSON(json) {
-        const dns = parseIPv6AddressString(json.dns);
+        const dns = (0, ip_address_1.parseIPv6AddressString)(json.dns);
         return new INTERNAL_IP6_DNS(dns).serialize();
     }
     toJSON() {
         return {
-            dns: formatIPv6AddressBuffer(this.dns),
+            dns: (0, ip_address_1.formatIPv6AddressBuffer)(this.dns),
         };
     }
     toString() {
@@ -454,25 +478,28 @@ class INTERNAL_IP6_DNS extends ConfigurationAttribute {
 exports.INTERNAL_IP6_DNS = INTERNAL_IP6_DNS;
 class INTERNAL_IP6_DHCP extends ConfigurationAttribute {
     constructor(dhcp) {
-        if (dhcp.length !== 16) {
+        if (dhcp.length !== 16 && dhcp.length !== 0) {
             throw new Error("Invalid value length for INTERNAL_IP6_DHCP");
         }
         super(configurationAttributeType.INTERNAL_IP6_DHCP, dhcp);
         this.dhcp = dhcp;
     }
     static parse(buffer) {
-        if (buffer.length !== 16) {
+        if (buffer.length !== 16 && buffer.length !== 0) {
             throw new Error("Invalid value length for INTERNAL_IP6_DHCP");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP6_DHCP(Buffer.alloc(0));
+        }
         return new INTERNAL_IP6_DHCP(buffer.subarray(0, 16));
     }
     static serializeJSON(json) {
-        const dhcp = parseIPv6AddressString(json.dhcp);
+        const dhcp = (0, ip_address_1.parseIPv6AddressString)(json.dhcp);
         return new INTERNAL_IP6_DHCP(dhcp).serialize();
     }
     toJSON() {
         return {
-            dhcp: formatIPv6AddressBuffer(this.dhcp),
+            dhcp: (0, ip_address_1.formatIPv6AddressBuffer)(this.dhcp),
         };
     }
     toString() {
@@ -483,34 +510,35 @@ class INTERNAL_IP6_DHCP extends ConfigurationAttribute {
 exports.INTERNAL_IP6_DHCP = INTERNAL_IP6_DHCP;
 class INTERNAL_IP4_SUBNET extends ConfigurationAttribute {
     constructor(address, netmask) {
-        if (address.length !== 4) {
+        if (!((address.length == 4 && netmask.length == 4) ||
+            (address.length == 0 && netmask.length == 0))) {
             throw new Error("Invalid value length for INTERNAL_IP4_SUBNET");
         }
-        if (netmask.length !== 4) {
-            throw new Error("Invalid value length for INTERNAL_IP4_SUBNET");
-        }
-        let value = Buffer.alloc(8);
+        let value = Buffer.alloc(address.length + netmask.length);
         address.copy(value, 0);
-        netmask.copy(value, 4);
+        netmask.copy(value, address.length);
         super(configurationAttributeType.INTERNAL_IP4_SUBNET, value);
         this.address = address;
         this.netmask = netmask;
     }
     static parse(buffer) {
-        if (buffer.length !== 8) {
+        if (buffer.length !== 8 && buffer.length != 0) {
             throw new Error("Invalid value length for INTERNAL_IP4_SUBNET");
         }
+        if (buffer.length === 0) {
+            return new INTERNAL_IP4_SUBNET(Buffer.alloc(0), Buffer.alloc(0));
+        }
         return new INTERNAL_IP4_SUBNET(buffer.subarray(0, 4), buffer.subarray(4, 8));
     }
     static serializeJSON(json) {
-        const address = parseIPv4AddressString(json.address);
-        const netmask = parseIPv4AddressString(json.netmask);
+        const address = (0, ip_address_1.parseIPv4AddressString)(json.address);
+        const netmask = (0, ip_address_1.parseIPv4AddressString)(json.netmask);
         return new INTERNAL_IP4_SUBNET(address, netmask).serialize();
     }
     toJSON() {
         return {
-            address: formatIPv4AddressBuffer(this.address),
-            netmask: formatIPv4AddressBuffer(this.netmask),
+            address: (0, ip_address_1.formatIPv4AddressBuffer)(this.address),
+            netmask: (0, ip_address_1.formatIPv4AddressBuffer)(this.netmask),
         };
     }
     toString() {
@@ -554,15 +582,21 @@ class SUPPORTED_ATTRIBUTES extends ConfigurationAttribute {
 exports.SUPPORTED_ATTRIBUTES = SUPPORTED_ATTRIBUTES;
 class INTERNAL_IP6_SUBNET extends ConfigurationAttribute {
     constructor(address, prefixLength) {
-        if (address.length !== 16) {
+        if (address.length !== 16 && address.length !== 0) {
             throw new Error("Invalid value length for INTERNAL_IP6_SUBNET");
         }
-        if (prefixLength < 0 || prefixLength > 128) {
-            throw new Error("Invalid prefix length for INTERNAL_IP6_SUBNET");
+        var value;
+        if (address.length === 0) {
+            value = address;
+        }
+        else {
+            if (prefixLength < 0 || prefixLength > 128) {
+                throw new Error("Invalid prefix length for INTERNAL_IP6_SUBNET");
+            }
+            value = Buffer.alloc(17);
+            address.copy(value, 0);
+            value.writeUInt8(prefixLength, 16);
         }
-        let value = Buffer.alloc(17);
-        address.copy(value, 0);
-        value.writeUInt8(prefixLength, 16);
         super(configurationAttributeType.INTERNAL_IP6_SUBNET, value);
         this.address = address;
         this.prefixLength = prefixLength;
@@ -574,13 +608,13 @@ class INTERNAL_IP6_SUBNET extends ConfigurationAttribute {
         return new INTERNAL_IP6_SUBNET(buffer.subarray(0, 16), buffer.readUInt8(16));
     }
     static serializeJSON(json) {
-        const address = parseIPv6AddressString(json.address);
+        const address = (0, ip_address_1.parseIPv6AddressString)(json.address);
         const prefixLength = json.prefixLength;
         return new INTERNAL_IP6_SUBNET(address, prefixLength).serialize();
     }
     toJSON() {
         return {
-            address: formatIPv6AddressBuffer(this.address),
+            address: (0, ip_address_1.formatIPv6AddressBuffer)(this.address),
             prefixLength: this.prefixLength,
         };
     }
@@ -592,25 +626,28 @@ class INTERNAL_IP6_SUBNET extends ConfigurationAttribute {
 exports.INTERNAL_IP6_SUBNET = INTERNAL_IP6_SUBNET;
 class P_CSCF_IP4_ADDRESS extends ConfigurationAttribute {
     constructor(address) {
-        if (address.length !== 4) {
+        if (address.length !== 4 && address.length !== 0) {
             throw new Error("Invalid value length for P_CSCF_IP4_ADDRESS");
         }
         super(configurationAttributeType.P_CSCF_IP4_ADDRESS, address);
         this.address = address;
     }
     static parse(buffer) {
-        if (buffer.length !== 4) {
+        if (buffer.length !== 4 && buffer.length !== 0) {
             throw new Error("Invalid value length for P_CSCF_IP4_ADDRESS");
         }
+        if (buffer.length === 0) {
+            return new P_CSCF_IP4_ADDRESS(Buffer.alloc(0));
+        }
         return new P_CSCF_IP4_ADDRESS(buffer.subarray(0, 4));
     }
     static serializeJSON(json) {
-        const address = parseIPv4AddressString(json.address);
+        const address = (0, ip_address_1.parseIPv4AddressString)(json.address);
         return new P_CSCF_IP4_ADDRESS(address).serialize();
     }
     toJSON() {
         return {
-            address: formatIPv4AddressBuffer(this.address),
+            address: (0, ip_address_1.formatIPv4AddressBuffer)(this.address),
         };
     }
     toString() {
@@ -621,25 +658,28 @@ class P_CSCF_IP4_ADDRESS extends ConfigurationAttribute {
 exports.P_CSCF_IP4_ADDRESS = P_CSCF_IP4_ADDRESS;
 class P_CSCF_IP6_ADDRESS extends ConfigurationAttribute {
     constructor(address) {
-        if (address.length !== 16) {
+        if (address.length !== 16 && address.length !== 0) {
             throw new Error("Invalid value length for P_CSCF_IP6_ADDRESS");
         }
         super(configurationAttributeType.P_CSCF_IP6_ADDRESS, address);
         this.address = address;
     }
     static parse(buffer) {
-        if (buffer.length !== 16) {
+        if (buffer.length !== 16 && buffer.length !== 0) {
             throw new Error("Invalid value length for P_CSCF_IP6_ADDRESS");
         }
+        if (buffer.length === 0) {
+            return new P_CSCF_IP6_ADDRESS(Buffer.alloc(0));
+        }
         return new P_CSCF_IP6_ADDRESS(buffer.subarray(0, 16));
     }
     static serializeJSON(json) {
-        const address = parseIPv6AddressString(json.address);
+        const address = (0, ip_address_1.parseIPv6AddressString)(json.address);
         return new P_CSCF_IP6_ADDRESS(address).serialize();
     }
     toJSON() {
         return {
-            address: formatIPv6AddressBuffer(this.address),
+            address: (0, ip_address_1.formatIPv6AddressBuffer)(this.address),
         };
     }
     toString() {
@@ -648,7 +688,7 @@ class P_CSCF_IP6_ADDRESS extends ConfigurationAttribute {
     }
 }
 exports.P_CSCF_IP6_ADDRESS = P_CSCF_IP6_ADDRESS;
-class CP_Attributes {
+class CPAttributes {
     constructor() {
         this.INTERNAL_IP4_ADDRESS = [];
         this.INTERNAL_IP4_NETMASK = undefined;
@@ -666,57 +706,59 @@ class CP_Attributes {
         this.P_CSCF_IP6_ADDRESS = [];
         this.OtherAttributes = [];
     }
-    parse(buffer) {
+    static parse(buffer) {
+        const cpAttributes = new CPAttributes();
         let attributes = ConfigurationAttribute.parseConfigurationAttributes(buffer);
         for (let attribute of attributes) {
             switch (attribute.type) {
                 case configurationAttributeType.INTERNAL_IP4_ADDRESS:
-                    this.INTERNAL_IP4_ADDRESS.push(INTERNAL_IP4_ADDRESS.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP4_ADDRESS.push(INTERNAL_IP4_ADDRESS.parse(attribute.value));
                     break;
                 case configurationAttributeType.INTERNAL_IP4_NETMASK:
-                    this.INTERNAL_IP4_NETMASK = INTERNAL_IP4_NETMASK.parse(attribute.value);
+                    cpAttributes.INTERNAL_IP4_NETMASK = INTERNAL_IP4_NETMASK.parse(attribute.value);
                     break;
                 case configurationAttributeType.INTERNAL_IP4_DNS:
-                    this.INTERNAL_IP4_DNS.push(INTERNAL_IP4_DNS.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP4_DNS.push(INTERNAL_IP4_DNS.parse(attribute.value));
                     break;
                 case configurationAttributeType.INTERNAL_IP4_NBNS:
-                    this.INTERNAL_IP4_NBNS.push(INTERNAL_IP4_NBNS.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP4_NBNS.push(INTERNAL_IP4_NBNS.parse(attribute.value));
                     break;
                 case configurationAttributeType.INTERNAL_IP4_DHCP:
-                    this.INTERNAL_IP4_DHCP.push(INTERNAL_IP4_DHCP.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP4_DHCP.push(INTERNAL_IP4_DHCP.parse(attribute.value));
                     break;
                 case configurationAttributeType.APPLICATION_VERSION:
-                    this.APPLICATION_VERSION = APPLICATION_VERSION.parse(attribute.value);
+                    cpAttributes.APPLICATION_VERSION = APPLICATION_VERSION.parse(attribute.value);
                     break;
                 case configurationAttributeType.INTERNAL_IP6_ADDRESS:
-                    this.INTERNAL_IP6_ADDRESS.push(INTERNAL_IP6_ADDRESS.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP6_ADDRESS.push(INTERNAL_IP6_ADDRESS.parse(attribute.value));
                     break;
                 case configurationAttributeType.INTERNAL_IP6_DNS:
-                    this.INTERNAL_IP6_DNS.push(INTERNAL_IP6_DNS.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP6_DNS.push(INTERNAL_IP6_DNS.parse(attribute.value));
                     break;
                 case configurationAttributeType.INTERNAL_IP6_DHCP:
-                    this.INTERNAL_IP6_DHCP.push(INTERNAL_IP6_DHCP.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP6_DHCP.push(INTERNAL_IP6_DHCP.parse(attribute.value));
                     break;
                 case configurationAttributeType.INTERNAL_IP4_SUBNET:
-                    this.INTERNAL_IP4_SUBNET.push(INTERNAL_IP4_SUBNET.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP4_SUBNET.push(INTERNAL_IP4_SUBNET.parse(attribute.value));
                     break;
                 case configurationAttributeType.SUPPORTED_ATTRIBUTES:
-                    this.SUPPORTED_ATTRIBUTES = SUPPORTED_ATTRIBUTES.parse(attribute.value);
+                    cpAttributes.SUPPORTED_ATTRIBUTES = SUPPORTED_ATTRIBUTES.parse(attribute.value);
                     break;
                 case configurationAttributeType.INTERNAL_IP6_SUBNET:
-                    this.INTERNAL_IP6_SUBNET.push(INTERNAL_IP6_SUBNET.parse(attribute.value));
+                    cpAttributes.INTERNAL_IP6_SUBNET.push(INTERNAL_IP6_SUBNET.parse(attribute.value));
                     break;
                 case configurationAttributeType.P_CSCF_IP4_ADDRESS:
-                    this.P_CSCF_IP4_ADDRESS.push(P_CSCF_IP4_ADDRESS.parse(attribute.value));
+                    cpAttributes.P_CSCF_IP4_ADDRESS.push(P_CSCF_IP4_ADDRESS.parse(attribute.value));
                     break;
                 case configurationAttributeType.P_CSCF_IP6_ADDRESS:
-                    this.P_CSCF_IP6_ADDRESS.push(P_CSCF_IP6_ADDRESS.parse(attribute.value));
+                    cpAttributes.P_CSCF_IP6_ADDRESS.push(P_CSCF_IP6_ADDRESS.parse(attribute.value));
                     break;
                 default:
-                    this.OtherAttributes.push(attribute);
+                    cpAttributes.OtherAttributes.push(attribute);
                     break;
             }
         }
+        return cpAttributes;
     }
     /**
      * Serializes the configuration attributes to a buffer
@@ -806,119 +848,4 @@ class CP_Attributes {
         return JSON.stringify(prettyJson, null, 2);
     }
 }
-exports.CP_Attributes = CP_Attributes;
-function parseIPv4AddressString(addressString) {
-    const buffer = Buffer.alloc(4);
-    const stringParts = addressString.split('.');
-    const parts = stringParts.map(p => {
-        if (!/^\d+$/.test(p)) {
-            throw new Error(`Invalid IPv4 address: part "${p}" contains non-digit characters.`);
-        }
-        const parsed = parseInt(p, 10);
-        if (parsed < 0 || parsed > 255) {
-            throw new Error(`Invalid IPv4 address: part "${p}" is not a valid octet.`);
-        }
-        return parsed;
-    });
-    if (parts.length !== 4) {
-        throw new Error("Invalid IPv4 address");
-    }
-    buffer.writeUInt8(parts[0], 0);
-    buffer.writeUInt8(parts[1], 1);
-    buffer.writeUInt8(parts[2], 2);
-    buffer.writeUInt8(parts[3], 3);
-    return buffer;
-}
-function formatIPv4AddressBuffer(buffer) {
-    if (buffer.length !== 4) {
-        throw new Error("Invalid IPv4 address");
-    }
-    const parts = [
-        buffer.readUInt8(0),
-        buffer.readUInt8(1),
-        buffer.readUInt8(2),
-        buffer.readUInt8(3),
-    ];
-    return parts.join('.');
-}
-function parseIPv6AddressString(addressString) {
-    const buffer = Buffer.alloc(16);
-    let parts;
-    let zeroFillCount = 0;
-    let currentBufferIndex = 0;
-    if (addressString.includes('::')) {
-        const partsSplitted = addressString.split('::');
-        if (partsSplitted.length > 2) {
-            throw new Error("Invalid IPv6 address: multiple '::' sequences.");
-        }
-        const [beforeDoubleColon, afterDoubleColon] = partsSplitted;
-        const beforeParts = beforeDoubleColon.split(':').filter(p => p !== '');
-        const afterParts = afterDoubleColon.split(':').filter(p => p !== '');
-        // Calculate how many zero groups are needed for '::'
-        zeroFillCount = 8 - (beforeParts.length + afterParts.length);
-        if (zeroFillCount < 0) {
-            throw new Error("Invalid IPv6 address: too many parts for '::' expansion.");
-        }
-        parts = [...beforeParts];
-        for (let i = 0; i < zeroFillCount; i++) {
-            parts.push('0'); // Represent the zero groups
-        }
-        parts.push(...afterParts);
-    }
-    else {
-        parts = addressString.split(':');
-    }
-    if (parts.length !== 8) {
-        throw new Error(`Invalid IPv6 address: expected 8 parts, got ${parts.length}.`);
-    }
-    for (let i = 0; i < 8; i++) {
-        const part = parts[i];
-        if (part.length > 4) {
-            throw new Error(`Invalid IPv6 address part length: ${part}`);
-        }
-        const value = parseInt(part, 16);
-        if (isNaN(value) || value < 0 || value > 0xFFFF) {
-            throw new Error(`Invalid IPv6 address part: ${part}`);
-        }
-        buffer.writeUInt16BE(value, currentBufferIndex);
-        currentBufferIndex += 2;
-    }
-    return buffer;
-}
-function formatIPv6AddressBuffer(addressBuffer) {
-    if (addressBuffer.length !== 16) {
-        throw new Error("Invalid buffer length for IPv6 address; expected 16 bytes.");
-    }
-    const parts = Array.from({ length: 8 }, (_, i) => addressBuffer.readUInt16BE(i * 2).toString(16).replace(/^0+/, '') || '0');
-    let maxZeroLength = 0;
-    let maxZeroIndex = -1;
-    let currentZeroLength = 0;
-    let currentZeroIndex = -1;
-    for (let i = 0; i < parts.length; i++) {
-        if (parts[i] === '0') {
-            if (currentZeroLength === 0) {
-                currentZeroIndex = i;
-            }
-            currentZeroLength++;
-        }
-        else {
-            if (currentZeroLength > maxZeroLength) {
-                maxZeroLength = currentZeroLength;
-                maxZeroIndex = currentZeroIndex;
-            }
-            currentZeroLength = 0;
-        }
-    }
-    if (currentZeroLength > maxZeroLength) {
-        maxZeroLength = currentZeroLength;
-        maxZeroIndex = currentZeroIndex;
-    }
-    if (maxZeroLength > 1) {
-        const before = parts.slice(0, maxZeroIndex).join(':');
-        const after = parts.slice(maxZeroIndex + maxZeroLength).join(':');
-        return `${before}::${after}`;
-    }
-    else {
-        return parts.join(':');
-    }
-}
+exports.CPAttributes = CPAttributes;

package/lib/src/index.d.ts

@@ -5,5 +5,7 @@ export * from "./proposal";
 export * from "./selector";
 export * from "./transform";
 export * from "./message";
+export * from "./configuration-attribute";
+export * from "./ip-address";
 import * as ikev2 from "./message";
 export { ikev2 };

package/lib/src/index.js

@@ -44,5 +44,7 @@ __exportStar(require("./proposal"), exports);
 __exportStar(require("./selector"), exports);
 __exportStar(require("./transform"), exports);
 __exportStar(require("./message"), exports);
+__exportStar(require("./configuration-attribute"), exports);
+__exportStar(require("./ip-address"), exports);
 const ikev2 = __importStar(require("./message"));
 exports.ikev2 = ikev2;

package/lib/src/ip-address.d.ts

@@ -0,0 +1,6 @@
+export declare function parseIPv4AddressString(addressString: string): Buffer;
+export declare function formatIPv4AddressBuffer(buffer: Buffer): string;
+export declare function parseIPv6AddressString(addressString: string): Buffer;
+export declare function formatIPv6AddressBuffer(addressBuffer: Buffer): string;
+export declare function parseIPAddressString(addressString: string): Buffer;
+export declare function formatIPAddressBuffer(addressBuffer: Buffer): string;

package/lib/src/ip-address.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIPv4AddressString = parseIPv4AddressString;
+exports.formatIPv4AddressBuffer = formatIPv4AddressBuffer;
+exports.parseIPv6AddressString = parseIPv6AddressString;
+exports.formatIPv6AddressBuffer = formatIPv6AddressBuffer;
+exports.parseIPAddressString = parseIPAddressString;
+exports.formatIPAddressBuffer = formatIPAddressBuffer;
+function parseIPv4AddressString(addressString) {
+    if (addressString.length === 0) {
+        throw new Error(`Invalid IPv4 address ${addressString}`);
+    }
+    const buffer = Buffer.alloc(4);
+    const stringParts = addressString.split(".");
+    const parts = stringParts.map((p) => {
+        if (!/^\d+$/.test(p)) {
+            throw new Error(`Invalid IPv4 address ${addressString}: part "${p}" contains non-digit characters.`);
+        }
+        const parsed = parseInt(p, 10);
+        if (parsed < 0 || parsed > 255) {
+            throw new Error(`Invalid IPv4 address ${addressString}: part "${p}" is not a valid octet.`);
+        }
+        return parsed;
+    });
+    if (parts.length !== 4) {
+        throw new Error(`Invalid IPv4 address ${addressString}`);
+    }
+    buffer.writeUInt8(parts[0], 0);
+    buffer.writeUInt8(parts[1], 1);
+    buffer.writeUInt8(parts[2], 2);
+    buffer.writeUInt8(parts[3], 3);
+    return buffer;
+}
+function formatIPv4AddressBuffer(buffer) {
+    if (buffer.length === 0) {
+        throw new Error(`Invalid IPv4 address ${buffer}`);
+    }
+    if (buffer.length !== 4) {
+        throw new Error(`Invalid IPv4 address ${buffer}`);
+    }
+    const parts = [
+        buffer.readUInt8(0),
+        buffer.readUInt8(1),
+        buffer.readUInt8(2),
+        buffer.readUInt8(3),
+    ];
+    return parts.join(".");
+}
+function parseIPv6AddressString(addressString) {
+    if (addressString.length === 0) {
+        return Buffer.alloc(0);
+    }
+    const buffer = Buffer.alloc(16);
+    let parts;
+    let zeroFillCount = 0;
+    let currentBufferIndex = 0;
+    if (addressString.includes("::")) {
+        const partsSplitted = addressString.split("::");
+        if (partsSplitted.length > 2) {
+            throw new Error(`Invalid IPv6 address ${addressString}: multiple '::' sequences.`);
+        }
+        const [beforeDoubleColon, afterDoubleColon] = partsSplitted;
+        const beforeParts = beforeDoubleColon.split(":").filter((p) => p !== "");
+        const afterParts = afterDoubleColon.split(":").filter((p) => p !== "");
+        // Calculate how many zero groups are needed for '::'
+        zeroFillCount = 8 - (beforeParts.length + afterParts.length);
+        if (zeroFillCount < 0) {
+            throw new Error(`Invalid IPv6 address ${addressString}: too many parts for '::' expansion.`);
+        }
+        parts = [...beforeParts];
+        for (let i = 0; i < zeroFillCount; i++) {
+            parts.push("0"); // Represent the zero groups
+        }
+        parts.push(...afterParts);
+    }
+    else {
+        parts = addressString.split(":");
+    }
+    if (parts.length !== 8) {
+        throw new Error(`Invalid IPv6 address ${addressString}: expected 8 parts, got ${parts.length}.`);
+    }
+    for (let i = 0; i < 8; i++) {
+        const part = parts[i];
+        if (part.length > 4) {
+            throw new Error(`Invalid IPv6 address ${addressString}: part length: ${part}`);
+        }
+        const value = parseInt(part, 16);
+        if (isNaN(value) || value < 0 || value > 0xffff) {
+            throw new Error(`Invalid IPv6 address ${addressString}: part: ${part}`);
+        }
+        buffer.writeUInt16BE(value, currentBufferIndex);
+        currentBufferIndex += 2;
+    }
+    return buffer;
+}
+function formatIPv6AddressBuffer(addressBuffer) {
+    if (addressBuffer.length === 0) {
+        return "";
+    }
+    if (addressBuffer.length !== 16) {
+        throw new Error(`Invalid buffer length for IPv6 address ${addressBuffer}: expected 16 bytes.`);
+    }
+    const parts = Array.from({ length: 8 }, (_, i) => addressBuffer
+        .readUInt16BE(i * 2)
+        .toString(16)
+        .replace(/^0+/, "") || "0");
+    let maxZeroLength = 0;
+    let maxZeroIndex = -1;
+    let currentZeroLength = 0;
+    let currentZeroIndex = -1;
+    for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === "0") {
+            if (currentZeroLength === 0) {
+                currentZeroIndex = i;
+            }
+            currentZeroLength++;
+        }
+        else {
+            if (currentZeroLength > maxZeroLength) {
+                maxZeroLength = currentZeroLength;
+                maxZeroIndex = currentZeroIndex;
+            }
+            currentZeroLength = 0;
+        }
+    }
+    if (currentZeroLength > maxZeroLength) {
+        maxZeroLength = currentZeroLength;
+        maxZeroIndex = currentZeroIndex;
+    }
+    if (maxZeroLength > 1) {
+        const before = parts.slice(0, maxZeroIndex).join(":");
+        const after = parts.slice(maxZeroIndex + maxZeroLength).join(":");
+        return `${before}::${after}`;
+    }
+    else {
+        return parts.join(":");
+    }
+}
+function parseIPAddressString(addressString) {
+    if (addressString.length === 0) {
+        return Buffer.alloc(0);
+    }
+    if (addressString.includes(":")) {
+        return parseIPv6AddressString(addressString);
+    }
+    return parseIPv4AddressString(addressString);
+}
+function formatIPAddressBuffer(addressBuffer) {
+    if (addressBuffer.length === 0) {
+        return "";
+    }
+    if (addressBuffer.length === 4) {
+        return formatIPv4AddressBuffer(addressBuffer);
+    }
+    if (addressBuffer.length === 16) {
+        return formatIPv6AddressBuffer(addressBuffer);
+    }
+    throw new Error(`Invalid buffer length for IP address ${addressBuffer}: expected 4 or 16 bytes.`);
+}

package/lib/src/payload.d.ts

@@ -732,11 +732,11 @@ export declare class PayloadVENDOR extends Payload {
  */
 export declare class PayloadTS extends Payload {
     nextPayload: payloadType;
-    numTs: number;
+    tsType: payloadType;
     tsList: TrafficSelector[];
     critical: boolean;
     length: number;
-    constructor(nextPayload: payloadType, numTs: number, tsList: TrafficSelector[], critical?: boolean, length?: number);
+    constructor(nextPayload: payloadType, tsType: payloadType, tsList: TrafficSelector[], critical?: boolean, length?: number);
     /**
      * Parses a Traffic Selector Payload from a buffer
      * @param buffer
@@ -779,11 +779,10 @@ export declare class PayloadTS extends Payload {
  */
 export declare class PayloadTSi extends PayloadTS {
     nextPayload: payloadType;
-    numTs: number;
     tsList: TrafficSelector[];
     critical: boolean;
     length: number;
-    constructor(nextPayload: payloadType, numTs: number, tsList: TrafficSelector[], critical?: boolean, length?: number);
+    constructor(nextPayload: payloadType, tsList: TrafficSelector[], critical?: boolean, length?: number);
 }
 /**
  * IKEv2 Traffic Selector - Responder Payload
@@ -792,11 +791,10 @@ export declare class PayloadTSi extends PayloadTS {
  */
 export declare class PayloadTSr extends PayloadTS {
     nextPayload: payloadType;
-    numTs: number;
     tsList: TrafficSelector[];
     critical: boolean;
     length: number;
-    constructor(nextPayload: payloadType, numTs: number, tsList: TrafficSelector[], critical?: boolean, length?: number);
+    constructor(nextPayload: payloadType, tsList: TrafficSelector[], critical?: boolean, length?: number);
 }
 /**
  * IKEv2 Encrypted and Authenticated Payload

package/lib/src/payload.js

@@ -1347,10 +1347,10 @@ exports.PayloadVENDOR = PayloadVENDOR;
  * @extends Payload
  */
 class PayloadTS extends Payload {
-    constructor(nextPayload, numTs, tsList, critical = false, length = 0) {
-        super(payloadType.NONE, nextPayload, critical, length > 0 ? length : 5 + tsList.reduce((acc, ts) => acc + ts.length, 0));
+    constructor(nextPayload, tsType, tsList, critical = false, length = 0) {
+        super(tsType, nextPayload, critical, length > 0 ? length : 0);
         this.nextPayload = nextPayload;
-        this.numTs = numTs;
+        this.tsType = tsType;
         this.tsList = tsList;
         this.critical = critical;
         this.length = length;
@@ -1372,7 +1372,7 @@ class PayloadTS extends Payload {
             tsList.push(ts);
             offset += ts.length;
         }
-        return new PayloadTS(genericPayload.nextPayload, numTs, tsList, genericPayload.critical, genericPayload.length);
+        return new PayloadTS(genericPayload.nextPayload, genericPayload.type, tsList, genericPayload.critical, genericPayload.length);
     }
     /**
      * Serializes a JSON representation of the TS payload to a buffer
@@ -1383,6 +1383,7 @@ class PayloadTS extends Payload {
      */
     static serializeJSON(json) {
         var _a;
+        // const type = json.type; // TODO include the type in the JSON, as it is discriminating
         const buffer = Buffer.alloc(json.length);
         const genericPayload = Payload.serializeJSON(json);
         genericPayload.copy(buffer);
@@ -1404,13 +1405,16 @@ class PayloadTS extends Payload {
      */
     serialize() {
         // Encode deep first to calculate length
+        if (this.tsList.length > 255) {
+            throw new Error(`Too many traffic selectors ${this.tsList.length}`);
+        }
         const tsListBuffer = this.tsList.map((ts) => ts.serialize());
         const tsBuffer = Buffer.concat(tsListBuffer);
         // Fix the length
-        this.length = 5 + tsBuffer.length;
+        this.length = 8 + tsBuffer.length;
         const buffer = Buffer.alloc(this.length);
         super.serialize().copy(buffer);
-        buffer.writeUInt8(this.numTs, 4);
+        buffer.writeUInt8(this.tsList.length, 4);
         // No need to blank 3 reserved bytes, Buffer.alloc does that
         tsBuffer.copy(buffer, 8);
         return buffer;
@@ -1422,7 +1426,6 @@ class PayloadTS extends Payload {
      */
     toJSON() {
         const json = super.genToJSON();
-        json.numTs = this.numTs;
         json.tsList = this.tsList.map((ts) => ts.toJSON());
         return json;
     }
@@ -1433,7 +1436,7 @@ class PayloadTS extends Payload {
      */
     toString() {
         const genericString = super.genToString();
-        return `${genericString}\nnumTs: ${this.numTs}\ntsList: ${this.tsList.map((ts) => ts.toString()).join(", ")}`;
+        return `${genericString}\ntsList: ${this.tsList.map((ts) => ts.toString()).join(", ")}`;
     }
 }
 exports.PayloadTS = PayloadTS;
@@ -1443,10 +1446,9 @@ exports.PayloadTS = PayloadTS;
  * @extends Payload
  */
 class PayloadTSi extends PayloadTS {
-    constructor(nextPayload, numTs, tsList, critical = false, length = 0) {
-        super(nextPayload, numTs, tsList, critical, length > 0 ? length : 5 + tsList.reduce((acc, ts) => acc + ts.length, 0));
+    constructor(nextPayload, tsList, critical = false, length = 0) {
+        super(nextPayload, payloadType.TSi, tsList, critical, length > 0 ? length : 0);
         this.nextPayload = nextPayload;
-        this.numTs = numTs;
         this.tsList = tsList;
         this.critical = critical;
         this.length = length;
@@ -1460,10 +1462,9 @@ exports.PayloadTSi = PayloadTSi;
  * @extends Payload
  */
 class PayloadTSr extends PayloadTS {
-    constructor(nextPayload, numTs, tsList, critical = false, length = 0) {
-        super(nextPayload, numTs, tsList, critical, length > 0 ? length : 5 + tsList.reduce((acc, ts) => acc + ts.length, 0));
+    constructor(nextPayload, tsList, critical = false, length = 0) {
+        super(nextPayload, payloadType.TSr, tsList, critical, length > 0 ? length : 0);
         this.nextPayload = nextPayload;
-        this.numTs = numTs;
         this.tsList = tsList;
         this.critical = critical;
         this.length = length;
@@ -1684,7 +1685,7 @@ class PayloadCP extends Payload {
     static parse(buffer) {
         const genericPayload = Payload.parse(buffer);
         const cfgType = buffer.readUInt8(4);
-        const cfgData = buffer.subarray(5, genericPayload.length);
+        const cfgData = buffer.subarray(8, genericPayload.length);
         return new PayloadCP(genericPayload.nextPayload, cfgType, cfgData, genericPayload.critical, genericPayload.length);
     }
     /**
@@ -1699,10 +1700,7 @@ class PayloadCP extends Payload {
         const genericPayload = Payload.serializeJSON(json);
         genericPayload.copy(buffer);
         buffer.writeUInt8(json.cfgType, 4);
-        // Write 3-byte reserved field as zeros in big-endian order
-        buffer.writeUInt8(0, 5);
-        buffer.writeUInt8(0, 6);
-        buffer.writeUInt8(0, 7);
+        // 3-bytes reserved field as zeros in big-endian order
         Buffer.from(json.cfgData, "hex").copy(buffer, 8);
         return buffer;
     }

package/lib/src/selector.d.ts

@@ -37,12 +37,12 @@ export declare enum TrafficSelectorType {
 export declare class TrafficSelector {
     type: number;
     protocolId: number;
-    length: number;
     startPort: number;
     endPort: number;
     startAddress: Buffer;
     endAddress: Buffer;
-    constructor(type: number, protocolId: number, length: number, startPort: number, endPort: number, startAddress: Buffer, endAddress: Buffer);
+    length: number;
+    constructor(type: number, protocolId: number, startPort: number, endPort: number, startAddress: Buffer, endAddress: Buffer, length?: number);
     /**
      * Parses a Traffic Selector from a buffer
      * @param buffer The buffer to parse from.

package/lib/src/selector.js

@@ -1,4 +1,7 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrafficSelector = exports.TrafficSelectorType = void 0;
+const ip_address_1 = require("./ip-address");
 /**
  * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -17,8 +20,6 @@
 
                         Traffic Selector
 */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrafficSelector = exports.TrafficSelectorType = void 0;
 /**
  * Traffic Selector Type
  */
@@ -39,14 +40,14 @@ var TrafficSelectorType;
  * @property {Buffer} endAddress - 4 bytes
  */
 class TrafficSelector {
-    constructor(type, protocolId, length, startPort, endPort, startAddress, endAddress) {
+    constructor(type, protocolId, startPort, endPort, startAddress, endAddress, length = 0) {
         this.type = type;
         this.protocolId = protocolId;
-        this.length = length;
         this.startPort = startPort;
         this.endPort = endPort;
         this.startAddress = startAddress;
         this.endAddress = endAddress;
+        this.length = length;
     }
     /**
      * Parses a Traffic Selector from a buffer
@@ -58,16 +59,42 @@ class TrafficSelector {
     static parse(buffer) {
         try {
             const type = buffer.readUInt8(0);
+            var expectedLength;
+            switch (type) {
+                case TrafficSelectorType.TS_IPV4_ADDR_RANGE:
+                    expectedLength = 16;
+                    break;
+                case TrafficSelectorType.TS_IPV6_ADDR_RANGE:
+                    expectedLength = 40;
+                    break;
+                default:
+                    throw new Error("Invalid traffic selector type");
+            }
             const protocolId = buffer.readUInt8(1);
             const length = buffer.readUInt16BE(2);
+            if (length !== expectedLength) {
+                throw new Error("Invalid traffic selector length");
+            }
             const startPort = buffer.readUInt16BE(4);
             const endPort = buffer.readUInt16BE(6);
-            const startAddress = buffer.subarray(8, 12);
-            const endAddress = buffer.subarray(12, 16);
-            return new TrafficSelector(type, protocolId, length, startPort, endPort, startAddress, endAddress);
+            var startAddress;
+            var endAddress;
+            switch (type) {
+                case TrafficSelectorType.TS_IPV4_ADDR_RANGE:
+                    startAddress = buffer.subarray(8, 12);
+                    endAddress = buffer.subarray(12, 16);
+                    break;
+                case TrafficSelectorType.TS_IPV6_ADDR_RANGE:
+                    startAddress = buffer.subarray(8, 24);
+                    endAddress = buffer.subarray(24, 40);
+                    break;
+                default:
+                    throw new Error("Invalid traffic selector type");
+            }
+            return new TrafficSelector(type, protocolId, startPort, endPort, startAddress, endAddress, length);
         }
         catch (error) {
-            throw new Error("Failed to parse traffic selector");
+            throw new Error("Failed to parse traffic selector: " + error);
         }
     }
     /**
@@ -78,14 +105,29 @@ class TrafficSelector {
      * @returns {Buffer}
      */
     static serializeJSON(json) {
-        const buffer = Buffer.alloc(16);
+        var length;
+        var ipLength;
+        const startAddress = (0, ip_address_1.parseIPAddressString)(json.startAddress);
+        const endAddress = (0, ip_address_1.parseIPAddressString)(json.endAddress);
+        if (startAddress.length === 4 && endAddress.length === 4) {
+            length = 16;
+            ipLength = 4;
+        }
+        else if (startAddress.length === 16 && endAddress.length === 16) {
+            length = 40;
+            ipLength = 16;
+        }
+        else {
+            throw new Error("Invalid traffic selector length");
+        }
+        const buffer = Buffer.alloc(length);
         buffer.writeUInt8(json.type, 0);
         buffer.writeUInt8(json.protocolId, 1);
-        buffer.writeUInt16BE(json.length, 2);
+        buffer.writeUInt16BE(length, 2);
         buffer.writeUInt16BE(json.startPort, 4);
         buffer.writeUInt16BE(json.endPort, 6);
-        Buffer.from(json.startAddress, "hex").copy(buffer, 8);
-        Buffer.from(json.endAddress, "hex").copy(buffer, 12);
+        startAddress.copy(buffer, 8);
+        endAddress.copy(buffer, 8 + ipLength);
         return buffer;
     }
     /**
@@ -94,14 +136,33 @@ class TrafficSelector {
      * @returns {Buffer}
      */
     serialize() {
-        const buffer = Buffer.alloc(16);
+        var ipLength;
+        switch (this.type) {
+            case TrafficSelectorType.TS_IPV4_ADDR_RANGE:
+                if (this.startAddress.length != 4 || this.endAddress.length != 4) {
+                    throw new Error("Invalid traffic selector length");
+                }
+                this.length = 16;
+                ipLength = 4;
+                break;
+            case TrafficSelectorType.TS_IPV6_ADDR_RANGE:
+                if (this.startAddress.length != 16 || this.endAddress.length != 16) {
+                    throw new Error("Invalid traffic selector length");
+                }
+                this.length = 40;
+                ipLength = 16;
+                break;
+            default:
+                throw new Error("Invalid traffic selector type");
+        }
+        const buffer = Buffer.alloc(this.length);
         buffer.writeUInt8(this.type, 0);
         buffer.writeUInt8(this.protocolId, 1);
         buffer.writeUInt16BE(this.length, 2);
         buffer.writeUInt16BE(this.startPort, 4);
         buffer.writeUInt16BE(this.endPort, 6);
         this.startAddress.copy(buffer, 8);
-        this.endAddress.copy(buffer, 12);
+        this.endAddress.copy(buffer, 8 + ipLength);
         return buffer;
     }
     /**
@@ -113,11 +174,10 @@ class TrafficSelector {
         return {
             type: this.type,
             protocolId: this.protocolId,
-            length: this.length,
             startPort: this.startPort,
             endPort: this.endPort,
-            startAddress: this.startAddress.toString("hex"),
-            endAddress: this.endAddress.toString("hex"),
+            startAddress: (0, ip_address_1.formatIPAddressBuffer)(this.startAddress),
+            endAddress: (0, ip_address_1.formatIPAddressBuffer)(this.endAddress),
         };
     }
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-ikev2",
   "title": "Node-IKEV2",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "IKEv2 parser and serializer for Node.js",
   "main": "./lib/src/index.js",
   "types": "./lib/src/index.d.ts",