@nictool/dns-resource-record 1.6.0 → 1.7.0

package/rr/TEMPLATE.js

@@ -0,0 +1,124 @@
+import RR from '../rr.js'
+
+/**
+ * DNS Resource Record Template
+ *
+ * Use this as a starting point for creating a new Resource Record (RR) class.
+ * Replace 'TEMPLATE' with the actual record type (e.g., 'MX', 'SRV').
+ *
+ * ## Mandates
+ * - Every new RR MUST extend the `RR` class.
+ * - 100% test coverage is required for all new PRs.
+ * - Follow established patterns for naming and implementation.
+ * - **Registration**: You MUST update `index.js` to import and export the new class and add it to the `classes` array.
+ * - **Tests**: You MUST create a corresponding test file in `test/rr/<type>.js` (mirroring an existing test file like `test/rr/a.js`).
+ *
+ * ## `rdataFields` and Avoiding Boilerplate
+ * The `rdataFields` static property defines the fields in the RDATA section.
+ * It is an array where each element can be:
+ *   - A string: The field name.
+ *   - An array: `[fieldName, type]`
+ *
+ * Supported types for `setTypedValue`:
+ *   - `u8`, `u16`, `u32`: Unsigned integers of 8, 16, or 32 bits.
+ *   - `fqdn`: A fully qualified domain name.
+ *   - `qstr`: Quoted string field (BIND quoting behavior).
+ *   - `charstr`: DNS length-prefixed character-string (max 255 bytes).
+ *   - `qcharstr`: Quoted DNS length-prefixed character-string.
+ *   - `charstrs`: Concatenated DNS character-strings.
+ *   - `svcparams`: SVCB/HTTPS params string.
+ *   - `base64`: Base64 encoded data.
+ *   - `hex`: Hexadecimal encoded data.
+ *   - `str`: A simple string.
+ *   - `ipv4`: An IPv4 address.
+ *   - `ipv6`: An IPv6 address.
+ *
+ * If you provide a type in `rdataFields`, the base `RR` class automatically
+ * handles validation and setting of that field. You only need to implement
+ * a custom `set<FieldName>` method if you need more complex validation
+ * logic than what the default types provide.
+ */
+
+export default class TEMPLATE extends RR {
+  // The DNS record type name (e.g., 'A', 'MX', 'TXT')
+  static typeName = 'TEMPLATE'
+  static typeId = 0
+  static RFCs = []
+  static tags = []
+
+  // The character used in tinydns format (optional)
+  static tinydnsType = 'T'
+
+  // Define the RDATA fields.
+  // Using types here avoids the need for manual setters in many cases.
+  static rdataFields = [
+    ['field1', 'u16'],
+    ['field2', 'fqdn'],
+  ]
+
+  constructor(opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+
+  /*
+  // Example of a custom setter. Only implement if default validation
+  // from `rdataFields` is insufficient.
+  setField1(val) {
+    if (val === undefined) val = this?.default?.field1
+    if (val === undefined) this.throwHelp('TEMPLATE: field1 is required')
+    this.is16bitInt('TEMPLATE', 'field1', val)
+    this.set('field1', parseInt(val, 10))
+  }
+  */
+
+  /****** Metadata (Required) *******/
+
+  getDescription() {
+    return 'Short description of the TEMPLATE record'
+  }
+
+  getCanonical() {
+    // Returns a sample object representing a valid record.
+    // This is used for documentation and testing.
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'TEMPLATE',
+      field1: 10,
+      field2: 'target.example.com.',
+    }
+  }
+
+  /******  IMPORTERS / EXPORTERS (Recommended) *******/
+
+  /*
+  // Optional: Override if generic implementation in RR.js is insufficient
+  fromTinydns({ tinyline }) {
+     // Implementation...
+  }
+  */
+
+  /*
+  // Optional: Override if generic implementation in RR.js is insufficient
+  toTinydns() {
+    // Implementation...
+  }
+  */
+
+  getWireRdata() {
+    // MUST be implemented for binary/wire format support.
+    // Returns a Uint8Array.
+    // Example:
+    /*
+    const domain = this.wirePackDomain(this.get('field2'))
+    const result = new Uint8Array(2 + domain.length)
+    new DataView(result.buffer).setUint16(0, this.get('field1'))
+    result.set(domain, 2)
+    return result
+    */
+    throw new Error('getWireRdata not implemented')
+  }
+}

package/rr/a.js

@@ -1,6 +1,13 @@
 import RR from '../rr.js'
 
 export default class A extends RR {
+  static typeName = 'A'
+  static typeId = 1
+  static RFCs = [1035]
+  static tinydnsType = '+'
+  static rdataFields = [['address', 'ipv4']]
+  static tags = ['common']
+
   constructor(opts) {
     super(opts)
   }
@@ -16,22 +23,6 @@ export default class A extends RR {
     return 'Address'
   }
 
-  getTags() {
-    return ['common']
-  }
-
-  getRdataFields(arg) {
-    return ['address']
-  }
-
-  getRFCs() {
-    return [1035]
-  }
-
-  getTypeId() {
-    return 1
-  }
-
   getCanonical() {
     return {
       owner: 'host.example.com.',
@@ -42,39 +33,8 @@ export default class A extends RR {
     }
   }
 
-  /******  IMPORTERS   *******/
-  fromTinydns({ tinyline }) {
-    // +fqdn:ip:ttl:timestamp:lo
-    const [owner, ip, ttl, ts, loc] = tinyline.slice(1).split(':')
-
-    return new A({
-      owner: this.fullyQualify(owner),
-      type: 'A',
-      address: ip,
-      ttl: parseInt(ttl, 10),
-      timestamp: ts,
-      location: loc?.trim() ?? '',
-    })
-  }
-
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  A  192.0.2.127
-    const [owner, ttl, c, type, address] = bindline.split(/\s+/)
-    return new A({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: c,
-      type,
-      address,
-    })
-  }
-
   /******  EXPORTERS   *******/
   getWireRdata() {
-    return Buffer.from(this.get('address').split('.').map(Number))
-  }
-
-  toTinydns() {
-    return `+${this.getTinyFQDN('owner')}:${this.get('address')}:${this.getTinydnsPostamble()}\n`
+    return new Uint8Array(this.get('address').split('.').map(Number))
   }
 }

package/rr/aaaa.js

@@ -2,6 +2,12 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class AAAA extends RR {
+  static typeName = 'AAAA'
+  static typeId = 28
+  static RFCs = [3596, 5952]
+  static rdataFields = [['address', 'ipv6']]
+  static tags = ['common']
+
   constructor(opts) {
     super(opts)
   }
@@ -11,33 +17,17 @@ export default class AAAA extends RR {
     if (!val) this.throwHelp('AAAA: address is required')
     if (!this.isIPv6(val)) this.throwHelp(`AAAA: address must be IPv6 (${val})`)
 
-    this.set('address', this.expand(val.toLowerCase())) // lower case: RFC 5952
+    this.set('address', this.expandIPv6(val.toLowerCase())) // lower case: RFC 5952
   }
 
   getCompressed(val) {
-    return this.compress(val ?? this.get('address'))
+    return this.compressIPv6(val ?? this.get('address'))
   }
 
   getDescription() {
     return 'Address IPv6'
   }
 
-  getTags() {
-    return ['common']
-  }
-
-  getRdataFields(arg) {
-    return ['address']
-  }
-
-  getRFCs() {
-    return [3596, 5952]
-  }
-
-  getTypeId() {
-    return 28
-  }
-
   getCanonical() {
     return {
       owner: 'host.example.com.',
@@ -81,69 +71,12 @@ export default class AAAA extends RR {
     })
   }
 
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  AAAA  ...
-    const [owner, ttl, c, type, ip] = bindline.split(/\s+/)
-    return new AAAA({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: c,
-      type,
-      address: this.expand(ip),
-    })
-  }
-
-  compress(val) {
-    /*
-     * RFC 5952
-     * 4.1. Leading zeros MUST be suppressed...A single 16-bit 0000 field MUST be represented as 0.
-     * 4.2.1 The use of the symbol "::" MUST be used to its maximum capability.
-     * 4.2.2 The symbol "::" MUST NOT be used to shorten just one 16-bit 0 field.
-     * 4.2.3 When choosing placement of a "::", the longest run...MUST be shortened
-     * 4.3 The characters a-f in an IPv6 address MUST be represented in lowercase.
-     */
-    let r = val
-      .replace(/0000/g, '0') // 4.1 0000 -> 0
-      .replace(/:0+([1-9a-fA-F])/g, ':$1') // 4.1 remove leading zeros
-
-    const mostConsecutiveZeros = [
-      new RegExp(/0?(?::0){6,}:0?/),
-      new RegExp(/0?(?::0){5,}:0?/),
-      new RegExp(/0?(?::0){4,}:0?/),
-      new RegExp(/0?(?::0){3,}:0?/),
-      new RegExp(/0?(?::0){2,}:0?/),
-    ]
-
-    for (const re of mostConsecutiveZeros) {
-      if (re.test(r)) {
-        r = r.replace(re, '::') // 4.2
-        break
-      }
-    }
-
-    return r.toLowerCase() // 4.3
-  }
-
-  expand(val, delimiter) {
-    if (delimiter === undefined) delimiter = ':'
-
-    const colons = val.match(/:/g)
-    if (colons?.length < 7) {
-      // console.log(`AAAA: restoring compressed colons`)
-      val = val.replace(/::/, ':'.repeat(9 - colons.length))
-    }
-
-    // restore compressed leading zeros
-    return val
-      .split(':')
-      .map((s) => s.padStart(4, 0))
-      .join(delimiter)
-      .toLowerCase()
-  }
-
   /******  EXPORTERS   *******/
   getWireRdata() {
-    return Buffer.from(this.expand(this.get('address'), ''), 'hex')
+    const hex = this.expandIPv6(this.get('address'), '')
+    const arr = new Uint8Array(hex.length / 2)
+    for (let i = 0; i < arr.length; i++) arr[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16)
+    return arr
   }
 
   toBind(zone_opts) {
@@ -152,7 +85,7 @@ export default class AAAA extends RR {
 
   toTinydns() {
     // from AAAA notation (8 groups of 4 hex digits) to 16 escaped octals
-    const rdata = TINYDNS.packHex(this.expand(this.get('address'), ''))
+    const rdata = TINYDNS.packHex(this.expandIPv6(this.get('address'), ''))
     return this.getTinydnsGeneric(rdata)
   }
 }

package/rr/apl.js

@@ -3,6 +3,11 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class APL extends RR {
+  static typeName = 'APL'
+  static typeId = 42
+  static RFCs = [3123]
+  static rdataFields = ['apl rdata']
+
   constructor(opts) {
     super(opts)
   }
@@ -10,8 +15,6 @@ export default class APL extends RR {
   /****** Resource record specific setters   *******/
   setAplRdata(val) {
     if (!val) this.throwHelp('APL: apl rdata is required')
-    // apl rdata is a list of address prefix list items, e.g.:
-    // 1:192.0.2.0/24 !1:192.0.2.64/28 2:2001:db8::/32
     this.set('apl rdata', val)
   }
 
@@ -19,25 +22,13 @@ export default class APL extends RR {
     return 'Address Prefix List'
   }
 
-  getRdataFields(arg) {
-    return ['apl rdata']
-  }
-
-  getRFCs() {
-    return [3123]
-  }
-
-  getTypeId() {
-    return 42
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
       ttl: 3600,
       class: 'IN',
       type: 'APL',
-      'apl rdata': '1:192.0.2.0/24 !1:192.0.2.64/28 2:2001:db8::/32',
+      'apl rdata': '1:192.0.2.1/24 !1:192.0.2.64/28 2:2001:db8::1/128',
     }
   }
 
@@ -47,32 +38,33 @@ export default class APL extends RR {
     const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 42) this.throwHelp('APL fromTinydns, invalid n')
 
-    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const bytes = Uint8Array.from(TINYDNS.octalToChar(rdata), (c) => c.charCodeAt(0))
     const items = []
     let pos = 0
 
     while (pos < bytes.length) {
-      const afi = bytes.readUInt16BE(pos)
+      const afi = (bytes[pos] << 8) | bytes[pos + 1]
       pos += 2
-      const prefix = bytes.readUInt8(pos)
+      const prefix = bytes[pos]
       pos++
-      const adfLenByte = bytes.readUInt8(pos)
+      const adfLenByte = bytes[pos]
       pos++
       const neg = (adfLenByte & 0x80) !== 0
       const addrLen = adfLenByte & 0x7f
-      const addrBytes = bytes.slice(pos, pos + addrLen)
+      const addrBytes = bytes.subarray(pos, pos + addrLen)
       pos += addrLen
 
       let addr
       if (afi === 1) {
-        const padded = Buffer.alloc(4)
-        addrBytes.copy(padded)
+        const padded = new Uint8Array(4)
+        padded.set(addrBytes)
         addr = [...padded].join('.')
       } else {
-        const padded = Buffer.alloc(16)
-        addrBytes.copy(padded)
+        const padded = new Uint8Array(16)
+        padded.set(addrBytes)
+        const paddedDv = new DataView(padded.buffer)
         const groups = []
-        for (let i = 0; i < 16; i += 2) groups.push(padded.readUInt16BE(i).toString(16).padStart(4, '0'))
+        for (let i = 0; i < 16; i += 2) groups.push(paddedDv.getUint16(i).toString(16).padStart(4, '0'))
         addr = this.compressIPv6(groups.join(':'))
       }
 
@@ -102,6 +94,43 @@ export default class APL extends RR {
     })
   }
 
+  fromWire({ owner, cls, ttl, rdata }) {
+    const items = []
+    let pos = 0
+    while (pos < rdata.length) {
+      const afi = (rdata[pos] << 8) | rdata[pos + 1]
+      pos += 2
+      const prefix = rdata[pos++]
+      const adfLenByte = rdata[pos++]
+      const neg = (adfLenByte & 0x80) !== 0
+      const addrLen = adfLenByte & 0x7f
+      const addrBytes = rdata.subarray(pos, pos + addrLen)
+      pos += addrLen
+
+      let addr
+      if (afi === 1) {
+        const padded = new Uint8Array(4)
+        padded.set(addrBytes)
+        addr = [...padded].join('.')
+      } else {
+        const padded = new Uint8Array(16)
+        padded.set(addrBytes)
+        const dv = new DataView(padded.buffer)
+        const groups = []
+        for (let i = 0; i < 16; i += 2) groups.push(dv.getUint16(i).toString(16).padStart(4, '0'))
+        addr = this.compressIPv6(groups.join(':'))
+      }
+      items.push(`${neg ? '!' : ''}${afi}:${addr}/${prefix}`)
+    }
+    return new APL({
+      owner,
+      ttl,
+      class: cls,
+      type: 'APL',
+      'apl rdata': items.join(' '),
+    })
+  }
+
   /******  EXPORTERS   *******/
   toTinydns() {
     return this.getTinydnsGeneric(
@@ -119,7 +148,7 @@ export default class APL extends RR {
 
           let addrBytes
           if (afi === 1) {
-            addrBytes = Buffer.from(addr.split('.').map((n) => parseInt(n, 10)))
+            addrBytes = new Uint8Array(addr.split('.').map((n) => parseInt(n, 10)))
           } else {
             const dblIdx = addr.indexOf('::')
             let groups
@@ -136,7 +165,10 @@ export default class APL extends RR {
             } else {
               groups = addr.split(':')
             }
-            addrBytes = Buffer.from(groups.map((g) => g.padStart(4, '0')).join(''), 'hex')
+            const hexStr = groups.map((g) => g.padStart(4, '0')).join('')
+            addrBytes = Uint8Array.from({ length: hexStr.length / 2 }, (_, i) =>
+              parseInt(hexStr.slice(i * 2, i * 2 + 2), 16),
+            )
           }
 
           let len = addrBytes.length
@@ -152,4 +184,68 @@ export default class APL extends RR {
         .join(''),
     )
   }
+
+  getWireRdata() {
+    const items = this.get('apl rdata').split(/\s+/)
+    const rdata = []
+
+    for (const item of items) {
+      const neg = item.startsWith('!')
+      const bare = neg ? item.slice(1) : item
+      const colonIdx = bare.indexOf(':')
+      const afi = parseInt(bare.slice(0, colonIdx), 10)
+      const rest = bare.slice(colonIdx + 1)
+      const slashIdx = rest.lastIndexOf('/')
+      const addr = rest.slice(0, slashIdx)
+      const prefix = parseInt(rest.slice(slashIdx + 1), 10)
+
+      let addrBytes
+      if (afi === 1) {
+        addrBytes = new Uint8Array(addr.split('.').map((n) => parseInt(n, 10)))
+      } else {
+        const dblIdx = addr.indexOf('::')
+        let groups
+        if (dblIdx !== -1) {
+          const left = addr
+            .slice(0, dblIdx)
+            .split(':')
+            .filter((s) => s !== '')
+          const right = addr
+            .slice(dblIdx + 2)
+            .split(':')
+            .filter((s) => s !== '')
+          groups = [...left, ...Array(8 - left.length - right.length).fill('0000'), ...right]
+        } else {
+          groups = addr.split(':')
+        }
+        const hexStr = groups.map((g) => g.padStart(4, '0')).join('')
+        addrBytes = Uint8Array.from({ length: hexStr.length / 2 }, (_, i) =>
+          parseInt(hexStr.slice(i * 2, i * 2 + 2), 16),
+        )
+      }
+
+      let len = addrBytes.length
+      while (len > 0 && addrBytes[len - 1] === 0) len--
+      const afdPart = addrBytes.slice(0, len)
+
+      const itemBytes = new Uint8Array(4 + afdPart.length)
+      const dv = new DataView(itemBytes.buffer, itemBytes.byteOffset)
+      dv.setUint16(0, afi)
+      itemBytes[2] = prefix
+      itemBytes[3] = (neg ? 0x80 : 0) | afdPart.length
+      itemBytes.set(afdPart, 4)
+
+      rdata.push(itemBytes)
+    }
+
+    const totalLen = rdata.reduce((sum, r) => sum + r.length, 0)
+    const bytes = new Uint8Array(totalLen)
+    let pos = 0
+    for (const r of rdata) {
+      bytes.set(r, pos)
+      pos += r.length
+    }
+
+    return bytes
+  }
 }

package/rr/caa.js

@@ -2,6 +2,16 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class CAA extends RR {
+  static typeName = 'CAA'
+  static typeId = 257
+  static RFCs = [6844, 8659, 9619]
+  static rdataFields = [
+    ['flags', 'u8'],
+    ['tag', 'charstr'],
+    ['value', 'qstr'],
+  ]
+  static tags = ['security']
+
   constructor(opts) {
     super(opts)
   }
@@ -62,26 +72,6 @@ export default class CAA extends RR {
     return 'Certification Authority Authorization'
   }
 
-  getTags() {
-    return ['security']
-  }
-
-  getQuotedFields() {
-    return ['value']
-  }
-
-  getRdataFields(arg) {
-    return ['flags', 'tag', 'value']
-  }
-
-  getRFCs() {
-    return [6844, 8659]
-  }
-
-  getTypeId() {
-    return 257
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
@@ -97,8 +87,8 @@ export default class CAA extends RR {
   /******  IMPORTERS   *******/
   fromTinydns({ tinyline }) {
     // CAA via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
-    if (n != 257) this.throwHelp('CAA fromTinydns, invalid n')
+    const { owner, typeId, rdata, ttl, timestamp, location } = this.parseTinydnsLine(tinyline)
+    if (typeId != this.getTypeId()) this.throwHelp('CAA fromTinydns, invalid typeId')
 
     const flags = TINYDNS.octalToUInt8(rdata.slice(0, 4))
     const taglen = TINYDNS.octalToUInt8(rdata.slice(4, 8))
@@ -108,49 +98,36 @@ export default class CAA extends RR {
     const fingerprint = unescaped.slice(taglen)
 
     return new CAA({
-      owner: this.fullyQualify(fqdn),
-      ttl: parseInt(ttl, 10),
+      owner,
+      ttl,
       type: 'CAA',
       flags,
       tag,
       value: fingerprint,
-      timestamp: ts,
-      location: loc?.trim() ?? '',
+      timestamp,
+      location,
     })
   }
 
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  CAA flags, tags, value
-    const regex =
-      /^(?<owner>\S+)\s+(?<ttl>\d{1,10})\s+(?<class>IN)\s+(?<type>CAA)\s+(?<flags>\d+)\s+(?<tag>\w+)\s+(?:"(?<quotedValue>[^"]+)"|(?<unquotedValue>\S+))$/i
-
-    const match = bindline.trim().match(regex)
-
-    if (!match) {
-      this.throwHelp(`unable to parse CAA: ${bindline}`)
-    }
-
-    const { owner, ttl, class: c, type, flags, tag, quotedValue, unquotedValue } = match.groups
+  /******  EXPORTERS   *******/
 
-    return new CAA({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: c,
-      type,
-      flags: parseInt(flags, 10),
-      tag,
-      value: quotedValue ?? unquotedValue,
-    })
+  getWireRdata() {
+    const tag = new TextEncoder().encode(this.get('tag'))
+    const value = new TextEncoder().encode(this.get('value'))
+    const result = new Uint8Array(2 + tag.length + value.length)
+    result[0] = this.get('flags')
+    result[1] = tag.length
+    result.set(tag, 2)
+    result.set(value, 2 + tag.length)
+    return result
   }
 
-  /******  EXPORTERS   *******/
-
   toTinydns() {
     return this.getTinydnsGeneric(
       TINYDNS.UInt8toOctal(this.get('flags')) +
         TINYDNS.UInt8toOctal(this.get('tag').length) +
         TINYDNS.escapeOctal(/[\r\n\t:\\/]/, this.get('tag')) +
-        TINYDNS.escapeOctal(/[\r\n\t:\\/]/, this.getQuoted('value')),
+        TINYDNS.escapeOctal(/[\r\n\t:\\/]/, this.get('value')),
     )
   }
 }