@nictool/dns-resource-record 1.1.6 → 1.2.0

package/rr/cert.js

@@ -1,13 +1,12 @@
-
 import RR from '../rr.js'
 
 export default class CERT extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setCertType (val) {
+  setCertType(val) {
     // The type field is the certificate type
     // the type field as an unsigned decimal integer or as a mnemonic symbol
     // this.is16bitInt('CERT', 'type', val)
@@ -15,7 +14,7 @@ export default class CERT extends RR {
     this.set('cert type', val)
   }
 
-  setKeyTag (val) {
+  setKeyTag(val) {
     // The key tag field is the 16-bit value
     // The key tag field is represented as an unsigned decimal integer.
 
@@ -24,7 +23,7 @@ export default class CERT extends RR {
     this.set('key tag', val)
   }
 
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // The algorithm field has the same meaning as the algorithm field in DNSKEY
     // The algorithm field is represented as an unsigned decimal integer
     this.is8bitInt('CERT', 'algorithm', val)
@@ -32,41 +31,44 @@ export default class CERT extends RR {
     this.set('algorithm', val)
   }
 
-  setCertificate (val) {
+  setCertificate(val) {
     // certificate/CRL portion is represented in base 64 [16] and may be
     // divided into any number of white-space-separated substrings
     this.set('certificate', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Certificate'
   }
 
-  getRdataFields () {
-    return [ 'cert type', 'key tag', 'algorithm', 'certificate' ]
+  getRdataFields() {
+    return ['cert type', 'key tag', 'algorithm', 'certificate']
   }
 
-  getRFCs () {
-    return [ 2538, 4398 ]
+  getRFCs() {
+    return [2538, 4398]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 37
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  CERT  certtype, keytag, algo, cert
-    const [ owner, ttl, c, type, certtype, keytag, algo, certificate  ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, certtype, keytag, algo, certificate] =
+      opts.bindline.split(/\s+/)
     return new CERT({
       owner,
-      ttl        : parseInt(ttl, 10),
-      class      : c,
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
-      'cert type': /^[0-9]+$/.test(certtype) ? parseInt(certtype, 10) : certtype,
-      'key tag'  : parseInt(keytag,   10),
-      algorithm  : parseInt(algo, 10),
+      'cert type': /^[0-9]+$/.test(certtype)
+        ? parseInt(certtype, 10)
+        : certtype,
+      'key tag': parseInt(keytag, 10),
+      algorithm: parseInt(algo, 10),
       certificate,
     })
   }

package/rr/cname.js

@@ -1,15 +1,14 @@
-
 import net from 'net'
 
 import RR from '../rr.js'
 
 export default class CNAME extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setCname (val) {
+  setCname(val) {
     // A <domain-name> which specifies the canonical or primary
     // name for the owner.  The owner name is an alias.
 
@@ -25,43 +24,43 @@ export default class CNAME extends RR {
     this.set('cname', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Canonical Name'
   }
 
-  getRdataFields (arg) {
-    return [ 'cname' ]
+  getRdataFields(arg) {
+    return ['cname']
   }
 
-  getRFCs () {
-    return [ 1035, 2181 ]
+  getRFCs() {
+    return [1035, 2181]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 5
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // Cfqdn:p:ttl:timestamp:lo
-    const [ fqdn, p, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [fqdn, p, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
 
     return new CNAME({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl, 10),
-      type     : 'CNAME',
-      cname    : this.fullyQualify(p),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'CNAME',
+      cname: this.fullyQualify(p),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  CNAME  ...
-    const [ owner, ttl, c, type, cname ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, cname] = opts.bindline.split(/\s+/)
     return new CNAME({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
       type,
       cname,
@@ -70,7 +69,7 @@ export default class CNAME extends RR {
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     return `C${this.getTinyFQDN('owner')}:${this.get('cname')}:${this.getTinydnsPostamble()}\n`
   }
 }

package/rr/dname.js

@@ -4,12 +4,12 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class DNAME extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setTarget (val) {
+  setTarget(val) {
     if (!val) throw new Error('DNAME: target is required')
 
     if (net.isIPv4(val) || net.isIPv6(val))
@@ -22,44 +22,44 @@ export default class DNAME extends RR {
     this.set('target', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Delegation Name'
   }
 
-  getRdataFields (arg) {
-    return [ 'target' ]
+  getRdataFields(arg) {
+    return ['target']
   }
 
-  getRFCs () {
-    return [ 2672, 6672 ]
+  getRFCs() {
+    return [2672, 6672]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 39
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // DNAME via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
     if (n != 39) throw new Error('DNAME fromTinydns, invalid n')
 
     return new DNAME({
-      type     : 'DNAME',
-      owner    : this.fullyQualify(fqdn),
-      target   : (TINYDNS.unpackDomainName(rdata))[0],
-      ttl      : parseInt(ttl, 10),
+      type: 'DNAME',
+      owner: this.fullyQualify(fqdn),
+      target: TINYDNS.unpackDomainName(rdata)[0],
+      ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  DNAME  ...
-    const [ owner, ttl, c, type, target ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, target] = opts.bindline.split(/\s+/)
     return new DNAME({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
       type,
       target,
@@ -67,7 +67,7 @@ export default class DNAME extends RR {
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
+  toTinydns() {
     const rdata = TINYDNS.packDomainName(this.get('target'))
     return this.getTinydnsGeneric(rdata)
   }

package/rr/dnskey.js

@@ -1,117 +1,124 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class DNSKEY extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setFlags (val) {
+  setFlags(val) {
     // a 2 octet Flags Field
     this.is16bitInt('DNSKEY', 'flags', val)
 
     // the possible values are: 0, 256, and 257; RFC 4034
-    if (![ 0, 256, 257 ].includes(val)) throw new Error(`DNSKEY: flags invalid, ${this.citeRFC()}`)
+    if (![0, 256, 257].includes(val))
+      throw new Error(`DNSKEY: flags invalid, ${this.citeRFC()}`)
 
     this.set('flags', val)
   }
 
-  setProtocol (val) {
+  setProtocol(val) {
     // 1 octet
     this.is8bitInt('DNSKEY', 'protocol', val)
 
     // The Protocol Field MUST be represented as an unsigned decimal integer with a value of 3.
-    if (![ 3 ].includes(val)) throw new Error(`DNSKEY: protocol invalid, ${this.citeRFC()}`)
+    if (![3].includes(val))
+      throw new Error(`DNSKEY: protocol invalid, ${this.citeRFC()}`)
 
     this.set('protocol', val)
   }
 
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // 1 octet
     this.is8bitInt('DNSKEY', 'algorithm', val)
 
     // https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml
     // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
-    if (![ ...Array(16).keys(),253,254 ].includes(val))
-      console.error(`DNSKEY: algorithm (${val}) not recognized, ${this.citeRFC()}`)
+    if (![...Array(16).keys(), 253, 254].includes(val))
+      console.error(
+        `DNSKEY: algorithm (${val}) not recognized, ${this.citeRFC()}`,
+      )
 
     this.set('algorithm', val)
   }
 
-  setPublickey (val) {
-    if (!val) throw new Error(`DNSKEY: publickey is required, ${this.citeRFC()}`)
+  setPublickey(val) {
+    if (!val)
+      throw new Error(`DNSKEY: publickey is required, ${this.citeRFC()}`)
 
     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 [ 4034, 6014, 8624 ]
+  getRFCs() {
+    return [4034, 6014, 8624]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 48
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  DNSKEY Flags Protocol Algorithm PublicKey
-    const match = opts.bindline.match(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+\s*(.*?)\s*$/)
+    const match = opts.bindline.match(
+      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+\s*(.*?)\s*$/,
+    )
     if (!match) throw new Error(`unable to parse DNSKEY: ${opts.bindline}`)
-    const [ owner, ttl, c, type, flags, protocol, algorithm, publickey ] = match.slice(1)
+    const [owner, ttl, c, type, flags, protocol, algorithm, publickey] =
+      match.slice(1)
 
     return new DNSKEY({
       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: publickey,
     })
   }
 
-  fromTinydns (opts) {
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
     if (n != 48) throw new Error('DNSKEY fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
 
     return new DNSKEY({
-      owner      : this.fullyQualify(fqdn),
-      ttl        : parseInt(ttl, 10),
-      type       : 'DNSKEY',
-      flags      : bytes.readUInt16BE(0),
-      protocol   : bytes.readUInt8(2),
-      'algorithm': bytes.readUInt8(3),
-      'publickey': bytes.slice(4).toString(),
-      timestamp  : ts,
-      location   : loc !== '' && loc !== '\n' ? loc : '',
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'DNSKEY',
+      flags: bytes.readUInt16BE(0),
+      protocol: bytes.readUInt8(2),
+      algorithm: bytes.readUInt8(3),
+      publickey: bytes.slice(4).toString(),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
 
     return this.getTinydnsGeneric(
       TINYDNS.UInt16toOctal(this.get('flags')) +
-      TINYDNS.UInt8toOctal(this.get('protocol')) +
-      TINYDNS.UInt8toOctal(this.get('algorithm')) +
-      TINYDNS.escapeOctal(dataRe, this.get('publickey'))
+        TINYDNS.UInt8toOctal(this.get('protocol')) +
+        TINYDNS.UInt8toOctal(this.get('algorithm')) +
+        TINYDNS.escapeOctal(dataRe, this.get('publickey')),
     )
   }
 }

package/rr/ds.js

@@ -1,104 +1,106 @@
-
 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.length > 2)
+      throw new Error(`DS: key tag is too long, ${this.citeRFC()}`)
 
     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))
+    if (![1, 2, 3, 4, 5, 253, 254].includes(val))
       throw new Error(`DS: algorithm invalid, ${this.citeRFC()}`)
 
     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))
+      throw new Error(`DS: digest type invalid, ${this.citeRFC()}`)
 
     this.set('digest type', val)
   }
 
-  setDigest (val) {
+  setDigest(val) {
     if (!val) throw new Error(`DS: digest is required, ${this.citeRFC()}`)
 
     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(':')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
     if (n != 43) throw new Error('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) {
+  setCpu(val) {
     if (val.length > 255) throw new Error('HINFO cpu cannot exceed 255 chars')
     this.set('cpu', val.replace(/^["']|["']$/g, ''))
   }
 
-  setOs (val) {
+  setOs(val) {
     if (val.length > 255) throw new Error('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)
+    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 [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(''),
     )
   }
 }