@nictool/dns-resource-record 1.1.7 → 1.2.1

package/rr/ds.js

@@ -1,104 +1,104 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class DS extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setKeyTag (val) {
+  setKeyTag(val) {
     // a 2 octet Key Tag field...in network byte order
-    if (!val) throw new Error(`DS: key tag is required`)
-    if (val.length > 2) throw new Error(`DS: key tag is too long, ${this.citeRFC()}`)
+    if (!val) this.throwHelp(`DS: key tag is required`)
+    if (val.length > 2) this.throwHelp(`DS: key tag is too long`)
 
     this.set('key tag', val)
   }
 
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
-    if (![ 1,2,3,4,5,253,254 ].includes(val))
-      throw new Error(`DS: algorithm invalid, ${this.citeRFC()}`)
+    if (![1, 2, 3, 4, 5, 253, 254].includes(val))
+      this.throwHelp(`DS: algorithm invalid`)
 
     this.set('algorithm', val)
   }
 
-  setDigestType (val) {
-    if (![ 1,2 ].includes(val)) throw new Error(`DS: digest type invalid, ${this.citeRFC()}`)
+  setDigestType(val) {
+    if (![1, 2].includes(val)) this.throwHelp(`DS: digest type invalid`)
 
     this.set('digest type', val)
   }
 
-  setDigest (val) {
-    if (!val) throw new Error(`DS: digest is required, ${this.citeRFC()}`)
+  setDigest(val) {
+    if (!val) this.throwHelp(`DS: digest is required`)
 
     this.set('digest', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Delegation Signer'
   }
 
-  getRdataFields (arg) {
-    return [ 'key tag', 'algorithm', 'digest type', 'digest' ]
+  getRdataFields(arg) {
+    return ['key tag', 'algorithm', 'digest type', 'digest']
   }
 
-  getRFCs () {
-    return [ 4034, 4509 ]
+  getRFCs() {
+    return [4034, 4509]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 43
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  DS Key Tag Algorithm, Digest Type, Digest
-    const [ owner, ttl, c, type, keytag, algorithm, digesttype ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, keytag, algorithm, digesttype] =
+      opts.bindline.split(/\s+/)
     return new DS({
       owner,
-      ttl          : parseInt(ttl, 10),
-      class        : c,
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
-      'key tag'    : parseInt(keytag,     10),
-      algorithm    : parseInt(algorithm,  10),
+      'key tag': parseInt(keytag, 10),
+      algorithm: parseInt(algorithm, 10),
       'digest type': parseInt(digesttype, 10),
-      digest       : opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+      digest: opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
     })
   }
 
-  fromTinydns (opts) {
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    if (n != 43) throw new Error('DS fromTinydns, invalid n')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 43) this.throwHelp('DS fromTinydns, invalid n')
 
     const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
 
     return new DS({
-      owner        : this.fullyQualify(fqdn),
-      ttl          : parseInt(ttl, 10),
-      type         : 'DS',
-      'key tag'    : binRdata.readUInt16BE(0),
-      algorithm    : binRdata.readUInt8(2),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'DS',
+      'key tag': binRdata.readUInt16BE(0),
+      algorithm: binRdata.readUInt8(2),
       'digest type': binRdata.readUInt8(3),
-      digest       : binRdata.slice(4).toString(),
-      timestamp    : ts,
-      location     : loc !== '' && loc !== '\n' ? loc : '',
+      digest: binRdata.slice(4).toString(),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     const rdataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
 
     return this.getTinydnsGeneric(
       TINYDNS.UInt16toOctal(this.get('key tag')) +
-      TINYDNS.UInt8toOctal(this.get('algorithm')) +
-      TINYDNS.UInt8toOctal(this.get('digest type')) +
-      TINYDNS.escapeOctal(rdataRe, this.get('digest'))
+        TINYDNS.UInt8toOctal(this.get('algorithm')) +
+        TINYDNS.UInt8toOctal(this.get('digest type')) +
+        TINYDNS.escapeOctal(rdataRe, this.get('digest')),
     )
   }
 }

package/rr/hinfo.js

@@ -1,54 +1,55 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class HINFO extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setCpu (val) {
-    if (val.length > 255) throw new Error('HINFO cpu cannot exceed 255 chars')
+  setCpu(val) {
+    if (val.length > 255) this.throwHelp('HINFO cpu cannot exceed 255 chars')
     this.set('cpu', val.replace(/^["']|["']$/g, ''))
   }
 
-  setOs (val) {
-    if (val.length > 255) throw new Error('HINFO os cannot exceed 255 chars')
+  setOs(val) {
+    if (val.length > 255) this.throwHelp('HINFO os cannot exceed 255 chars')
     this.set('os', val.replace(/^["']|["']$/g, ''))
   }
 
-  getDescription () {
+  getDescription() {
     return 'Host Info'
   }
 
-  getRdataFields (arg) {
-    return [ 'cpu', 'os' ]
+  getRdataFields(arg) {
+    return ['cpu', 'os']
   }
 
-  getRFCs () {
-    return [ 1034, 1035, 8482 ]
+  getRFCs() {
+    return [1034, 1035, 8482]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 13
   }
 
-  getQuotedFields () {
-    return [ 'cpu', 'os' ]
+  getQuotedFields() {
+    return ['cpu', 'os']
   }
 
   /******  IMPORTERS   *******/
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  HINFO   DEC-2060 TOPS20
-    const match = opts.bindline.match(/([^\s]+)\s+([0-9]+)\s+(IN)\s+(HINFO)\s+("[^"]+"|[^\s]+)\s+("[^"]+"|[^\s]+)/i)
-    if (!match) throw new Error(`unable to parse HINFO: ${opts.bindline}`)
-    const [ owner, ttl, c, type, cpu, os ] = match.slice(1)
+    const match = opts.bindline.match(
+      /([^\s]+)\s+([0-9]+)\s+(IN)\s+(HINFO)\s+("[^"]+"|[^\s]+)\s+("[^"]+"|[^\s]+)/i,
+    )
+    if (!match) this.throwHelp(`unable to parse HINFO: ${opts.bindline}`)
+    const [owner, ttl, c, type, cpu, os] = match.slice(1)
 
     return new HINFO({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
       type,
       cpu,
@@ -56,29 +57,29 @@ export default class HINFO extends RR {
     })
   }
 
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // HINFO via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [ fqdn, , rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    const [ cpu, os ] = [ ...TINYDNS.unpackString(rdata) ]
+    const [fqdn, , rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [cpu, os] = [...TINYDNS.unpackString(rdata)]
 
     return new this.constructor({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl, 10),
-      type     : 'HINFO',
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'HINFO',
       cpu,
       os,
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
+  toTinydns() {
     return this.getTinydnsGeneric(
       [
         TINYDNS.packString(this.get('cpu')),
         TINYDNS.packString(this.get('os')),
-      ].join('')
+      ].join(''),
     )
   }
 }

package/rr/https.js

@@ -0,0 +1,62 @@
+import RR from '../rr.js'
+
+export default class HTTPS extends RR {
+  constructor(opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPriority(val) {
+    this.is16bitInt('HTTPS', 'priority', val)
+
+    this.set('priority', val)
+  }
+
+  setTargetName(val) {
+    // this.isFullyQualified('HTTPS', 'target name', val)
+    // this.isValidHostname('HTTPS', 'target name', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('target name', val.toLowerCase())
+  }
+
+  setParams(val) {
+    // if (!val) this.throwHelp(`HTTPS: params is required`)
+
+    this.set('params', val)
+  }
+
+  getDescription() {
+    return 'HTTP Semantics'
+  }
+
+  getRdataFields(arg) {
+    return ['priority', 'target name', 'params']
+  }
+
+  getRFCs() {
+    return [9460]
+  }
+
+  getTypeId() {
+    return 65
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind(opts) {
+    // test.example.com  3600  IN  HTTPS Priority TargetName Params
+    const [owner, ttl, c, type, pri, fqdn] = opts.bindline.split(/\s+/)
+    return new HTTPS({
+      owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type,
+      priority: parseInt(pri, 10),
+      'target name': fqdn,
+      params: opts.bindline.split(/\s+/).slice(6).join(' ').trim(),
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}

package/rr/ipseckey.js

@@ -1,135 +1,154 @@
-
-import net from 'net'
+import net from 'node:net'
 
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class IPSECKEY extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setPrecedence (val) {
+  setPrecedence(val) {
     // an 8-bit precedence for this record.
     this.is8bitInt('IPSECKEY', 'precedence', val)
 
     this.set('precedence', val)
   }
 
-  setGatewayType (val) {
+  setGatewayType(val) {
     // 0 (none), 1 (4-byte IPv4), 2 (16-byte IPv6), 3 (wire encoded domain name)
-    if (![ 0,1,2,3 ].includes(val))
-      throw new Error(`IPSECKEY: Gateway Type is invalid, ${this.citeRFC()}`)
+    if (![0, 1, 2, 3].includes(val))
+      this.throwHelp(`IPSECKEY: Gateway Type is invalid`)
 
     this.set('gateway type', val)
   }
 
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // unsigned int, 1 octet, values: 1=DSA, 2=RSA
-    if (![ 1,2 ].includes(val))
-      throw new Error(`IPSECKEY: Algorithm invalid, ${this.citeRFC()}`)
+    if (![1, 2].includes(val)) this.throwHelp(`IPSECKEY: Algorithm invalid`)
 
     this.set('algorithm', val)
   }
 
-  setGateway (val) {
-    const gwErr = new Error(`IPSECKEY: gateway invalid (${val}), ${this.citeRFC()}`)
+  setGateway(val) {
+    const gwErr = new Error(`IPSECKEY: gateway invalid (${val})`)
     switch (this.get('gateway type')) {
-      case 0: if (val !== '.') throw gwErr; break
-      case 1: if (!net.isIPv4(val)) throw gwErr; break
-      case 2: if (!net.isIPv6(val)) throw gwErr; break
+      case 0:
+        if (val !== '.') throw gwErr
+        break
+      case 1:
+        if (!net.isIPv4(val)) throw gwErr
+        break
+      case 2:
+        if (!net.isIPv6(val)) throw gwErr
+        break
     }
 
     this.set('gateway', val)
   }
 
-  setPublickey (val) {
-    // if (val) throw new Error(`IPSECKEY: publickey is optional, ${this.citeRFC()}`)
+  setPublickey(val) {
+    // if (val) this.throwHelp(`IPSECKEY: publickey is optional`)
 
     this.set('publickey', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'IPsec Keying'
   }
 
-  getRdataFields (arg) {
-    return [ 'precedence', 'gateway type', 'algorithm', 'gateway', 'publickey' ]
+  getRdataFields(arg) {
+    return ['precedence', 'gateway type', 'algorithm', 'gateway', 'publickey']
   }
 
-  getRFCs () {
-    return [ 4025 ]
+  getRFCs() {
+    return [4025]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 45
   }
 
+  getCanonical() {
+    return {
+      owner: '38.2.0.192.in-addr.arpa.',
+      ttl: 7200,
+      class: 'IN',
+      type: 'IPSECKEY',
+      precedence: 10,
+      'gateway type': 1,
+      algorithm: 2,
+      gateway: '192.0.2.38',
+      publickey: 'AQNRU3mG7TVTO2BkR47usntb102uFJtugbo6BSGvgqt4AQ==',
+    }
+  }
+
   /******  IMPORTERS   *******/
-  fromBind (opts) {
+  fromBind(opts) {
     // FQDN TTL CLASS IPSECKEY Precedence GatewayType Algorithm Gateway PublicKey
-    const [ owner, ttl, c, type, prec, gwt, algo, gateway, publickey ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, prec, gwt, algo, gateway, publickey] =
+      opts.bindline.split(/\s+/)
     return new IPSECKEY({
       owner,
-      ttl           : parseInt(ttl, 10),
-      class         : c,
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
-      precedence    : parseInt(prec, 10),
-      'gateway type': parseInt(gwt,  10),
-      algorithm     : parseInt(algo, 10),
+      precedence: parseInt(prec, 10),
+      'gateway type': parseInt(gwt, 10),
+      algorithm: parseInt(algo, 10),
       gateway,
       publickey,
     })
   }
 
-  fromTinydns (opts) {
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    if (n != 45) throw new Error('IPSECKEY fromTinydns, invalid n')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 45) this.throwHelp('IPSECKEY fromTinydns, invalid n')
 
     const precedence = TINYDNS.octalToUInt8(rdata.substring(0, 4))
-    const gwType     = TINYDNS.octalToUInt8(rdata.substring(4, 8))
-    const algorithm  = TINYDNS.octalToUInt8(rdata.substring(8, 12))
+    const gwType = TINYDNS.octalToUInt8(rdata.substring(4, 8))
+    const algorithm = TINYDNS.octalToUInt8(rdata.substring(8, 12))
 
     let len, gateway, octalKey
 
     switch (gwType) {
-      case 0:     // no gateway
-        gateway  = rdata.substring(12, 13) // should always be: '.'
+      case 0: // no gateway
+        gateway = rdata.substring(12, 13) // should always be: '.'
         octalKey = rdata.substring(13)
         break
-      case 1:     // 4-byte IPv4 address
-        gateway  = TINYDNS.octalToIPv4(rdata.substring(12, 28))
+      case 1: // 4-byte IPv4 address
+        gateway = TINYDNS.octalToIPv4(rdata.substring(12, 28))
         octalKey = rdata.substring(28)
         break
-      case 2:     // 16-byte IPv6
-        gateway  = TINYDNS.octalToHex(rdata.substring(12, 76))
+      case 2: // 16-byte IPv6
+        gateway = TINYDNS.octalToHex(rdata.substring(12, 76))
         octalKey = rdata.substring(76)
         break
-      case 3:     // wire encoded domain name
-        [ gateway, len ] = TINYDNS.unpackDomainName(rdata.substring(12))
+      case 3: // wire encoded domain name
+        ;[gateway, len] = TINYDNS.unpackDomainName(rdata.substring(12))
         octalKey = rdata.substring(12 + len)
         break
     }
 
     return new IPSECKEY({
-      owner         : this.fullyQualify(fqdn),
-      ttl           : parseInt(ttl, 10),
-      type          : 'IPSECKEY',
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'IPSECKEY',
       precedence,
       'gateway type': gwType,
       algorithm,
       gateway,
-      publickey     : TINYDNS.octalToBase64(octalKey),
-      timestamp     : ts,
-      location      : loc !== '' && loc !== '\n' ? loc : '',
+      publickey: TINYDNS.octalToBase64(octalKey),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     const rdataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
 
     let rdata = ''

package/rr/key.js

@@ -1,70 +1,70 @@
-
 import RR from '../rr.js'
 
 export default class KEY extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setFlags (val) {
+  setFlags(val) {
     // a 2 octet Flags Field
     this.is16bitInt('KEY', 'flags', val)
 
     this.set('flags', val)
   }
 
-  setProtocol (val) {
+  setProtocol(val) {
     // 1 octet
     this.is8bitInt('KEY', 'protocol', val)
 
     this.set('protocol', val)
   }
 
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // 1 octet
     // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
-    if (![ 1,2,3,4,5,253,254 ].includes(val))
-      throw new Error(`KEY: algorithm invalid, ${this.citeRFC()}`)
+    if (![1, 2, 3, 4, 5, 253, 254].includes(val))
+      this.throwHelp(`KEY: algorithm invalid`)
 
     this.set('algorithm', val)
   }
 
-  setPublickey (val) {
-    if (!val) throw new Error(`KEY: publickey is required, ${this.citeRFC()}`)
+  setPublickey(val) {
+    if (!val) this.throwHelp(`KEY: publickey is required`)
 
     this.set('publickey', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'DNS Public Key'
   }
 
-  getRdataFields (arg) {
-    return [ 'flags', 'protocol', 'algorithm', 'publickey' ]
+  getRdataFields(arg) {
+    return ['flags', 'protocol', 'algorithm', 'publickey']
   }
 
-  getRFCs () {
-    return [ 2535, 3445 ]
+  getRFCs() {
+    return [2535, 3445]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 25
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  KEY Flags Protocol Algorithm PublicKey
-    const [ owner, ttl, c, type, flags, protocol, algorithm ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, flags, protocol, algorithm] =
+      opts.bindline.split(/\s+/)
     return new KEY({
       owner,
-      ttl      : parseInt(ttl, 10),
-      class    : c,
-      type     : type,
-      flags    : parseInt(flags,     10),
-      protocol : parseInt(protocol, 10),
-      algorithm: parseInt(algorithm,  10),
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      flags: parseInt(flags, 10),
+      protocol: parseInt(protocol, 10),
+      algorithm: parseInt(algorithm, 10),
       publickey: opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
     })
   }