node-ikev2 0.1.3 → 0.2.1

package/lib/src/configuration-attribute.js

@@ -0,0 +1,851 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ *
+ * See: https://datatracker.ietf.org/doc/html/rfc7296#section-3.15.1
+ *
+ *    Attribute Type           Value  Multi-Valued  Length
+ *    ------------------------------------------------------------
+ *    INTERNAL_IP4_ADDRESS     1      YES*          0 or 4 octets
+ *    INTERNAL_IP4_NETMASK     2      NO            0 or 4 octets
+ *    INTERNAL_IP4_DNS         3      YES           0 or 4 octets
+ *    INTERNAL_IP4_NBNS        4      YES           0 or 4 octets
+ *    INTERNAL_IP4_DHCP        6      YES           0 or 4 octets
+ *    APPLICATION_VERSION      7      NO            0 or more
+ *    INTERNAL_IP6_ADDRESS     8      YES*          0 or 17 octets
+ *    INTERNAL_IP6_DNS         10     YES           0 or 16 octets
+ *    INTERNAL_IP6_DHCP        12     YES           0 or 16 octets
+ *    INTERNAL_IP4_SUBNET      13     YES           0 or 8 octets
+ *    SUPPORTED_ATTRIBUTES     14     NO            Multiple of 2
+ *    INTERNAL_IP6_SUBNET      15     YES           17 octets
+ *
+ * See: https://www.iana.org/assignments/ikev2-parameters/ikev2-parameters.xhtml#ikev2-parameters-20
+ *
+ * Value 	Attribute Type 	Multi-Valued 	Length 	Reference
+ * 0	Reserved			[RFC7296]
+ * 1	INTERNAL_IP4_ADDRESS	YES*	0 or 4 octets	[RFC7296]
+ * 2	INTERNAL_IP4_NETMASK	NO	0 or 4 octets	[RFC7296]
+ * 3	INTERNAL_IP4_DNS	YES	0 or 4 octets	[RFC7296]
+ * 4	INTERNAL_IP4_NBNS	YES	0 or 4 octets	[RFC7296]
+ * 5	Reserved			[RFC7296]
+ * 6	INTERNAL_IP4_DHCP	YES	0 or 4 octets	[RFC7296]
+ * 7	APPLICATION_VERSION	NO	0 or more	[RFC7296]
+ * 8	INTERNAL_IP6_ADDRESS	YES*	0 or 17 octets	[RFC7296]
+ * 9	Reserved			[RFC7296]
+ * 10	INTERNAL_IP6_DNS	YES	0 or 16 octets	[RFC7296]
+ * 11	Reserved			[RFC7296]
+ * 12	INTERNAL_IP6_DHCP	YES	0 or 16 octets	[RFC7296]
+ * 13	INTERNAL_IP4_SUBNET	YES	0 or 8 octets	[RFC7296]
+ * 14	SUPPORTED_ATTRIBUTES	NO	Multiple of 2	[RFC7296]
+ * 15	INTERNAL_IP6_SUBNET	YES	17 octets	[RFC7296]
+ * 16	MIP6_HOME_PREFIX	YES	0 or 21 octets	[RFC5026]
+ * 17	INTERNAL_IP6_LINK	NO	8 or more	[RFC5739]
+ * 18	INTERNAL_IP6_PREFIX	YES	17 octets	[RFC5739]
+ * 19	HOME_AGENT_ADDRESS	NO	16 or 20	[http://www.3gpp.org/ftp/Specs/html-info/24302.htm][John_Meredith]
+ * 20	P_CSCF_IP4_ADDRESS	YES	0 or 4 octets	[RFC7651]
+ * 21	P_CSCF_IP6_ADDRESS	YES	0 or 16 octets	[RFC7651]
+ * 22	FTT_KAT	NO	2 octets	[TS 24.302 12.6.0]
+ * 23	EXTERNAL_SOURCE_IP4_NAT_INFO	NO	0 or 6	[TS 29.139][Kimmo_Kymalainen]
+ * 24	TIMEOUT_PERIOD_FOR_LIVENESS_CHECK	NO	0 or 4 octets	[TS 24.302 13.4.0][Frederic_Firmin]
+ * 25	INTERNAL_DNS_DOMAIN	YES	0 or more	[RFC8598]
+ * 26	INTERNAL_DNSSEC_TA	YES	0 or more	[RFC8598]
+ * 27	ENCDNS_IP4	YES	0 or more	[RFC9464]
+ * 28	ENCDNS_IP6	YES	0 or more	[RFC9464]
+ * 29	ENCDNS_DIGEST_INFO	YES	0 or more	[RFC9464]
+ * 30-16383	Unassigned
+ * 16384-32767	Reserved for Private Use			[RFC7296]
+ */
+var configurationAttributeType;
+(function (configurationAttributeType) {
+    // Reserved 0
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP4_ADDRESS"] = 1] = "INTERNAL_IP4_ADDRESS";
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP4_NETMASK"] = 2] = "INTERNAL_IP4_NETMASK";
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP4_DNS"] = 3] = "INTERNAL_IP4_DNS";
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP4_NBNS"] = 4] = "INTERNAL_IP4_NBNS";
+    // Reserved 5
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP4_DHCP"] = 6] = "INTERNAL_IP4_DHCP";
+    configurationAttributeType[configurationAttributeType["APPLICATION_VERSION"] = 7] = "APPLICATION_VERSION";
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP6_ADDRESS"] = 8] = "INTERNAL_IP6_ADDRESS";
+    // Reserved 9
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP6_DNS"] = 10] = "INTERNAL_IP6_DNS";
+    // Reserved 11
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP6_DHCP"] = 12] = "INTERNAL_IP6_DHCP";
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP4_SUBNET"] = 13] = "INTERNAL_IP4_SUBNET";
+    configurationAttributeType[configurationAttributeType["SUPPORTED_ATTRIBUTES"] = 14] = "SUPPORTED_ATTRIBUTES";
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP6_SUBNET"] = 15] = "INTERNAL_IP6_SUBNET";
+    configurationAttributeType[configurationAttributeType["MIP6_HOME_PREFIX"] = 16] = "MIP6_HOME_PREFIX";
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP6_LINK"] = 17] = "INTERNAL_IP6_LINK";
+    configurationAttributeType[configurationAttributeType["INTERNAL_IP6_PREFIX"] = 18] = "INTERNAL_IP6_PREFIX";
+    configurationAttributeType[configurationAttributeType["HOME_AGENT_ADDRESS"] = 19] = "HOME_AGENT_ADDRESS";
+    configurationAttributeType[configurationAttributeType["P_CSCF_IP4_ADDRESS"] = 20] = "P_CSCF_IP4_ADDRESS";
+    configurationAttributeType[configurationAttributeType["P_CSCF_IP6_ADDRESS"] = 21] = "P_CSCF_IP6_ADDRESS";
+    configurationAttributeType[configurationAttributeType["FTT_KAT"] = 22] = "FTT_KAT";
+    configurationAttributeType[configurationAttributeType["EXTERNAL_SOURCE_IP4_NAT_INFO"] = 23] = "EXTERNAL_SOURCE_IP4_NAT_INFO";
+    configurationAttributeType[configurationAttributeType["TIMEOUT_PERIOD_FOR_LIVENESS_CHECK"] = 24] = "TIMEOUT_PERIOD_FOR_LIVENESS_CHECK";
+    configurationAttributeType[configurationAttributeType["INTERNAL_DNS_DOMAIN"] = 25] = "INTERNAL_DNS_DOMAIN";
+    configurationAttributeType[configurationAttributeType["INTERNAL_DNSSEC_TA"] = 26] = "INTERNAL_DNSSEC_TA";
+    configurationAttributeType[configurationAttributeType["ENCDNS_IP4"] = 27] = "ENCDNS_IP4";
+    configurationAttributeType[configurationAttributeType["ENCDNS_IP6"] = 28] = "ENCDNS_IP6";
+    configurationAttributeType[configurationAttributeType["ENCDNS_DIGEST_INFO"] = 29] = "ENCDNS_DIGEST_INFO";
+    // 30-16383 Unassigned
+    // 16384-32767 Reserved for Private Use
+})(configurationAttributeType || (exports.configurationAttributeType = configurationAttributeType = {}));
+/**
+ * Configuration Attributes
+ *
+ *    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
+ *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *   |R|         Attribute Type      |            Length             |
+ *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *   |                                                               |
+ *   ~                             Value                             ~
+ *   |                                                               |
+ *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ *                 Figure 23: Configuration Attribute Format
+ *
+ * See: https://datatracker.ietf.org/doc/html/rfc7296#section-3.15.1
+ *
+ * As used in the PayloadCP
+ *
+ */
+class ConfigurationAttribute {
+    constructor(type, 
+    // public length: number,
+    value) {
+        this.type = type;
+        this.value = value;
+        if (type < 0 || type > 0x7fff) {
+            throw new Error("Invalid attribute type");
+        }
+    }
+    /**
+     * Parses a ConfigurationAttribute from a Buffer
+     * @param {Buffer} buffer
+     * @static
+     * @public
+     * @returns {ConfigurationAttribute}
+     */
+    static parse(buffer) {
+        if (!Buffer.isBuffer(buffer)) {
+            throw new Error("Input must be a Buffer");
+        }
+        if (buffer.length < 4) {
+            throw new Error("Buffer too short for attribute header (minimum 4 bytes)");
+        }
+        const attributeType = buffer.readUInt16BE(0) & 0x7fff;
+        const length = buffer.readUInt16BE(2);
+        if (buffer.length < 4 + length) {
+            throw new Error(`Buffer too short for TLV attribute value. Expected ${4 + length} bytes, got ${buffer.length}`);
+        }
+        const value = buffer.subarray(4, 4 + length);
+        return new ConfigurationAttribute(attributeType, value);
+    }
+    /**
+     * Serializes a Configuration Attribute from a JSON object
+     * @param {any} json
+     * @static
+     * @public
+     * @returns {Buffer}
+     */
+    static serializeJSON(json) {
+        const attributeType = json.attributeType;
+        const value = json.value;
+        const configurationAttribute = new ConfigurationAttribute(attributeType, value);
+        return configurationAttribute.serialize();
+    }
+    /**
+     * Serializes a Configuration Attribute to a Buffer
+     * @public
+     * @returns {Buffer}
+     */
+    serialize() {
+        const buffer = Buffer.alloc(4 + this.value.length);
+        buffer.writeUInt16BE(this.type, 0);
+        buffer.writeUInt16BE(this.value.length, 2);
+        this.value.copy(buffer, 4);
+        return buffer;
+    }
+    /**
+     * Parses Configuration Attributes from a Buffer
+     * @param {Buffer} buffer
+     * @static
+     * @public
+     * @returns {ConfigurationAttribute[]}
+     */
+    static parseConfigurationAttributes(buffer) {
+        const attributes = [];
+        let offset = 0;
+        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);
+            const attribute = ConfigurationAttribute.parse(attributeBuffer);
+            attributes.push(attribute);
+            offset += 4 + attributeLength;
+        }
+        return attributes;
+    }
+    /**
+     * Converts Configuration Attribute to JSON
+     * @public
+     * @returns {Record<string, any>} JSON object
+     */
+    toJSON() {
+        return {
+            attributeType: this.type,
+            value: this.value.toString("hex"),
+        };
+    }
+    /**
+     * Returns a string representation of the configuration attribute
+     * @public
+     * @returns {string}
+     */
+    toString() {
+        const prettyJson = this.toJSON();
+        prettyJson.configurationAttributeType = `${configurationAttributeType[prettyJson.attributeType]} (${prettyJson.attributeType})`;
+        prettyJson.value = this.value.toString("hex");
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.ConfigurationAttribute = ConfigurationAttribute;
+class INTERNAL_IP4_ADDRESS extends ConfigurationAttribute {
+    constructor(address) {
+        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 !== 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 = (0, ip_address_1.parseIPv4AddressString)(json.address);
+        return new INTERNAL_IP4_ADDRESS(address).serialize();
+    }
+    toJSON() {
+        return {
+            address: (0, ip_address_1.formatIPv4AddressBuffer)(this.address),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP4_ADDRESS = INTERNAL_IP4_ADDRESS;
+class INTERNAL_IP4_NETMASK extends ConfigurationAttribute {
+    constructor(netmask) {
+        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 !== 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 = (0, ip_address_1.parseIPv4AddressString)(json.netmask);
+        return new INTERNAL_IP4_NETMASK(netmask).serialize();
+    }
+    toJSON() {
+        return {
+            netmask: (0, ip_address_1.formatIPv4AddressBuffer)(this.netmask),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP4_NETMASK = INTERNAL_IP4_NETMASK;
+class INTERNAL_IP4_DNS extends ConfigurationAttribute {
+    constructor(dns) {
+        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 !== 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 = (0, ip_address_1.parseIPv4AddressString)(json.dns);
+        return new INTERNAL_IP4_DNS(dns).serialize();
+    }
+    toJSON() {
+        return {
+            dns: (0, ip_address_1.formatIPv4AddressBuffer)(this.dns),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP4_DNS = INTERNAL_IP4_DNS;
+class INTERNAL_IP4_NBNS extends ConfigurationAttribute {
+    constructor(nbns) {
+        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 !== 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 = (0, ip_address_1.parseIPv4AddressString)(json.nbns);
+        return new INTERNAL_IP4_NBNS(nbns).serialize();
+    }
+    toJSON() {
+        return {
+            nbns: (0, ip_address_1.formatIPv4AddressBuffer)(this.nbns),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP4_NBNS = INTERNAL_IP4_NBNS;
+class INTERNAL_IP4_DHCP extends ConfigurationAttribute {
+    constructor(dhcp) {
+        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 !== 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 = (0, ip_address_1.parseIPv4AddressString)(json.dhcp);
+        return new INTERNAL_IP4_DHCP(dhcp).serialize();
+    }
+    toJSON() {
+        return {
+            dhcp: (0, ip_address_1.formatIPv4AddressBuffer)(this.dhcp),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP4_DHCP = INTERNAL_IP4_DHCP;
+class APPLICATION_VERSION extends ConfigurationAttribute {
+    constructor(versionString) {
+        super(configurationAttributeType.APPLICATION_VERSION, Buffer.from(versionString));
+        this.versionString = versionString;
+    }
+    static parse(buffer) {
+        return new APPLICATION_VERSION(buffer.toString("utf8"));
+    }
+    static serializeJSON(json) {
+        const versionString = json.versionString;
+        const applicationVersion = new APPLICATION_VERSION(versionString);
+        return applicationVersion.serialize();
+    }
+    toJSON() {
+        return {
+            versionString: this.versionString,
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.APPLICATION_VERSION = APPLICATION_VERSION;
+class INTERNAL_IP6_ADDRESS extends ConfigurationAttribute {
+    constructor(address, prefixLength) {
+        if (address.length !== 16 && address.length !== 0) {
+            throw new Error("Invalid value 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);
+        }
+        super(configurationAttributeType.INTERNAL_IP6_ADDRESS, value);
+        this.address = address;
+        this.prefixLength = prefixLength;
+    }
+    static parse(buffer) {
+        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 = (0, ip_address_1.parseIPv6AddressString)(json.address);
+        const prefixLength = json.prefixLength;
+        return new INTERNAL_IP6_ADDRESS(address, prefixLength).serialize();
+    }
+    toJSON() {
+        return {
+            address: (0, ip_address_1.formatIPv6AddressBuffer)(this.address),
+            prefixLength: this.prefixLength,
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP6_ADDRESS = INTERNAL_IP6_ADDRESS;
+class INTERNAL_IP6_DNS extends ConfigurationAttribute {
+    constructor(dns) {
+        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 && 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 = (0, ip_address_1.parseIPv6AddressString)(json.dns);
+        return new INTERNAL_IP6_DNS(dns).serialize();
+    }
+    toJSON() {
+        return {
+            dns: (0, ip_address_1.formatIPv6AddressBuffer)(this.dns),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP6_DNS = INTERNAL_IP6_DNS;
+class INTERNAL_IP6_DHCP extends ConfigurationAttribute {
+    constructor(dhcp) {
+        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 && 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 = (0, ip_address_1.parseIPv6AddressString)(json.dhcp);
+        return new INTERNAL_IP6_DHCP(dhcp).serialize();
+    }
+    toJSON() {
+        return {
+            dhcp: (0, ip_address_1.formatIPv6AddressBuffer)(this.dhcp),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP6_DHCP = INTERNAL_IP6_DHCP;
+class INTERNAL_IP4_SUBNET extends ConfigurationAttribute {
+    constructor(address, netmask) {
+        if (!((address.length == 4 && netmask.length == 4) ||
+            (address.length == 0 && netmask.length == 0))) {
+            throw new Error("Invalid value length for INTERNAL_IP4_SUBNET");
+        }
+        let value = Buffer.alloc(address.length + netmask.length);
+        address.copy(value, 0);
+        netmask.copy(value, address.length);
+        super(configurationAttributeType.INTERNAL_IP4_SUBNET, value);
+        this.address = address;
+        this.netmask = netmask;
+    }
+    static parse(buffer) {
+        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 = (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: (0, ip_address_1.formatIPv4AddressBuffer)(this.address),
+            netmask: (0, ip_address_1.formatIPv4AddressBuffer)(this.netmask),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP4_SUBNET = INTERNAL_IP4_SUBNET;
+class SUPPORTED_ATTRIBUTES extends ConfigurationAttribute {
+    constructor(values) {
+        let value = Buffer.alloc(values.length * 2);
+        values.forEach((cfgAttrType, index) => {
+            value.writeUInt16BE(cfgAttrType, index * 2);
+        });
+        super(configurationAttributeType.SUPPORTED_ATTRIBUTES, value);
+        this.values = values;
+    }
+    static parse(buffer) {
+        if (buffer.length % 2 !== 0) {
+            throw new Error("Invalid value length for SUPPORTED_ATTRIBUTES");
+        }
+        const values = [];
+        for (let i = 0; i < buffer.length; i += 2) {
+            values.push(buffer.readUInt16BE(i));
+        }
+        return new SUPPORTED_ATTRIBUTES(values);
+    }
+    static serializeJSON(json) {
+        return new SUPPORTED_ATTRIBUTES(json.values).serialize();
+    }
+    toJSON() {
+        return {
+            values: this.values,
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.SUPPORTED_ATTRIBUTES = SUPPORTED_ATTRIBUTES;
+class INTERNAL_IP6_SUBNET extends ConfigurationAttribute {
+    constructor(address, prefixLength) {
+        if (address.length !== 16 && address.length !== 0) {
+            throw new Error("Invalid value 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);
+        }
+        super(configurationAttributeType.INTERNAL_IP6_SUBNET, value);
+        this.address = address;
+        this.prefixLength = prefixLength;
+    }
+    static parse(buffer) {
+        if (buffer.length !== 17) {
+            throw new Error("Invalid value length for INTERNAL_IP6_SUBNET");
+        }
+        return new INTERNAL_IP6_SUBNET(buffer.subarray(0, 16), buffer.readUInt8(16));
+    }
+    static serializeJSON(json) {
+        const address = (0, ip_address_1.parseIPv6AddressString)(json.address);
+        const prefixLength = json.prefixLength;
+        return new INTERNAL_IP6_SUBNET(address, prefixLength).serialize();
+    }
+    toJSON() {
+        return {
+            address: (0, ip_address_1.formatIPv6AddressBuffer)(this.address),
+            prefixLength: this.prefixLength,
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.INTERNAL_IP6_SUBNET = INTERNAL_IP6_SUBNET;
+class P_CSCF_IP4_ADDRESS extends ConfigurationAttribute {
+    constructor(address) {
+        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 && 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 = (0, ip_address_1.parseIPv4AddressString)(json.address);
+        return new P_CSCF_IP4_ADDRESS(address).serialize();
+    }
+    toJSON() {
+        return {
+            address: (0, ip_address_1.formatIPv4AddressBuffer)(this.address),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.P_CSCF_IP4_ADDRESS = P_CSCF_IP4_ADDRESS;
+class P_CSCF_IP6_ADDRESS extends ConfigurationAttribute {
+    constructor(address) {
+        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 && 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 = (0, ip_address_1.parseIPv6AddressString)(json.address);
+        return new P_CSCF_IP6_ADDRESS(address).serialize();
+    }
+    toJSON() {
+        return {
+            address: (0, ip_address_1.formatIPv6AddressBuffer)(this.address),
+        };
+    }
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.P_CSCF_IP6_ADDRESS = P_CSCF_IP6_ADDRESS;
+class CPAttributes {
+    constructor() {
+        this.INTERNAL_IP4_ADDRESS = [];
+        this.INTERNAL_IP4_NETMASK = undefined;
+        this.INTERNAL_IP4_DNS = [];
+        this.INTERNAL_IP4_NBNS = [];
+        this.INTERNAL_IP4_DHCP = [];
+        this.APPLICATION_VERSION = undefined;
+        this.INTERNAL_IP6_ADDRESS = [];
+        this.INTERNAL_IP6_DNS = [];
+        this.INTERNAL_IP6_DHCP = [];
+        this.INTERNAL_IP4_SUBNET = [];
+        this.SUPPORTED_ATTRIBUTES = undefined;
+        this.INTERNAL_IP6_SUBNET = [];
+        this.P_CSCF_IP4_ADDRESS = [];
+        this.P_CSCF_IP6_ADDRESS = [];
+        this.OtherAttributes = [];
+    }
+    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:
+                    cpAttributes.INTERNAL_IP4_ADDRESS.push(INTERNAL_IP4_ADDRESS.parse(attribute.value));
+                    break;
+                case configurationAttributeType.INTERNAL_IP4_NETMASK:
+                    cpAttributes.INTERNAL_IP4_NETMASK = INTERNAL_IP4_NETMASK.parse(attribute.value);
+                    break;
+                case configurationAttributeType.INTERNAL_IP4_DNS:
+                    cpAttributes.INTERNAL_IP4_DNS.push(INTERNAL_IP4_DNS.parse(attribute.value));
+                    break;
+                case configurationAttributeType.INTERNAL_IP4_NBNS:
+                    cpAttributes.INTERNAL_IP4_NBNS.push(INTERNAL_IP4_NBNS.parse(attribute.value));
+                    break;
+                case configurationAttributeType.INTERNAL_IP4_DHCP:
+                    cpAttributes.INTERNAL_IP4_DHCP.push(INTERNAL_IP4_DHCP.parse(attribute.value));
+                    break;
+                case configurationAttributeType.APPLICATION_VERSION:
+                    cpAttributes.APPLICATION_VERSION = APPLICATION_VERSION.parse(attribute.value);
+                    break;
+                case configurationAttributeType.INTERNAL_IP6_ADDRESS:
+                    cpAttributes.INTERNAL_IP6_ADDRESS.push(INTERNAL_IP6_ADDRESS.parse(attribute.value));
+                    break;
+                case configurationAttributeType.INTERNAL_IP6_DNS:
+                    cpAttributes.INTERNAL_IP6_DNS.push(INTERNAL_IP6_DNS.parse(attribute.value));
+                    break;
+                case configurationAttributeType.INTERNAL_IP6_DHCP:
+                    cpAttributes.INTERNAL_IP6_DHCP.push(INTERNAL_IP6_DHCP.parse(attribute.value));
+                    break;
+                case configurationAttributeType.INTERNAL_IP4_SUBNET:
+                    cpAttributes.INTERNAL_IP4_SUBNET.push(INTERNAL_IP4_SUBNET.parse(attribute.value));
+                    break;
+                case configurationAttributeType.SUPPORTED_ATTRIBUTES:
+                    cpAttributes.SUPPORTED_ATTRIBUTES = SUPPORTED_ATTRIBUTES.parse(attribute.value);
+                    break;
+                case configurationAttributeType.INTERNAL_IP6_SUBNET:
+                    cpAttributes.INTERNAL_IP6_SUBNET.push(INTERNAL_IP6_SUBNET.parse(attribute.value));
+                    break;
+                case configurationAttributeType.P_CSCF_IP4_ADDRESS:
+                    cpAttributes.P_CSCF_IP4_ADDRESS.push(P_CSCF_IP4_ADDRESS.parse(attribute.value));
+                    break;
+                case configurationAttributeType.P_CSCF_IP6_ADDRESS:
+                    cpAttributes.P_CSCF_IP6_ADDRESS.push(P_CSCF_IP6_ADDRESS.parse(attribute.value));
+                    break;
+                default:
+                    cpAttributes.OtherAttributes.push(attribute);
+                    break;
+            }
+        }
+        return cpAttributes;
+    }
+    /**
+     * Serializes the configuration attributes to a buffer
+     * @public
+     * @returns {Buffer}
+     */
+    serialize() {
+        let buffer = Buffer.alloc(0);
+        for (let attribute of this.INTERNAL_IP4_ADDRESS) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        if (this.INTERNAL_IP4_NETMASK) {
+            buffer = Buffer.concat([buffer, this.INTERNAL_IP4_NETMASK.serialize()]);
+        }
+        for (let attribute of this.INTERNAL_IP4_DNS) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        for (let attribute of this.INTERNAL_IP4_NBNS) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        for (let attribute of this.INTERNAL_IP4_DHCP) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        if (this.APPLICATION_VERSION) {
+            buffer = Buffer.concat([buffer, this.APPLICATION_VERSION.serialize()]);
+        }
+        for (let attribute of this.INTERNAL_IP6_ADDRESS) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        for (let attribute of this.INTERNAL_IP6_DNS) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        for (let attribute of this.INTERNAL_IP6_DHCP) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        for (let attribute of this.INTERNAL_IP4_SUBNET) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        if (this.SUPPORTED_ATTRIBUTES) {
+            buffer = Buffer.concat([buffer, this.SUPPORTED_ATTRIBUTES.serialize()]);
+        }
+        for (let attribute of this.INTERNAL_IP6_SUBNET) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        for (let attribute of this.P_CSCF_IP4_ADDRESS) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        for (let attribute of this.P_CSCF_IP6_ADDRESS) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        for (let attribute of this.OtherAttributes) {
+            buffer = Buffer.concat([buffer, attribute.serialize()]);
+        }
+        return buffer;
+    }
+    /**
+     * Converts Configuration Attribute to JSON
+     * @public
+     * @returns {Record<string, any>}
+     */
+    toJSON() {
+        return {
+            INTERNAL_IP4_ADDRESS: this.INTERNAL_IP4_ADDRESS,
+            INTERNAL_IP4_NETMASK: this.INTERNAL_IP4_NETMASK,
+            INTERNAL_IP4_DNS: this.INTERNAL_IP4_DNS,
+            INTERNAL_IP4_NBNS: this.INTERNAL_IP4_NBNS,
+            INTERNAL_IP4_DHCP: this.INTERNAL_IP4_DHCP,
+            APPLICATION_VERSION: this.APPLICATION_VERSION,
+            INTERNAL_IP6_ADDRESS: this.INTERNAL_IP6_ADDRESS,
+            INTERNAL_IP6_DNS: this.INTERNAL_IP6_DNS,
+            INTERNAL_IP6_DHCP: this.INTERNAL_IP6_DHCP,
+            INTERNAL_IP4_SUBNET: this.INTERNAL_IP4_SUBNET,
+            SUPPORTED_ATTRIBUTES: this.SUPPORTED_ATTRIBUTES,
+            INTERNAL_IP6_SUBNET: this.INTERNAL_IP6_SUBNET,
+            P_CSCF_IP4_ADDRESS: this.P_CSCF_IP4_ADDRESS,
+            P_CSCF_IP6_ADDRESS: this.P_CSCF_IP6_ADDRESS,
+            OtherAttributes: this.OtherAttributes,
+        };
+    }
+    /**
+     * Returns a string representation of the configuration attributes
+     * @public
+     * @returns {string}
+     */
+    toString() {
+        const prettyJson = this.toJSON();
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.CPAttributes = CPAttributes;