@nictool/dns-resource-record 1.1.6 → 1.2.0

package/rr/tlsa.js

@@ -1,106 +1,113 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class TLSA extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setCertificateUsage (val) {
-    if (![ 0,1,2,3 ].includes(val))
+  setCertificateUsage(val) {
+    if (![0, 1, 2, 3].includes(val))
       throw new Error(`TLSA: certificate usage invalid, ${this.citeRFC()}`)
 
     this.set('certificate usage', val)
   }
 
-  setSelector (val) {
-    if (![ 0,1 ].includes(val))
+  setSelector(val) {
+    if (![0, 1].includes(val))
       throw new Error(`TLSA: selector invalid, ${this.citeRFC()}`)
 
     this.set('selector', val)
   }
 
-  setMatchingType (val) {
-    if (![ 0,1,2 ].includes(val))
+  setMatchingType(val) {
+    if (![0, 1, 2].includes(val))
       throw new Error(`TLSA: matching type, ${this.citeRFC()}`)
 
     this.set('matching type', val)
   }
 
-  setCertificateAssociationData (val) {
+  setCertificateAssociationData(val) {
     this.set('certificate association data', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'TLSA certificate association'
   }
 
-  getRdataFields (arg) {
-    return [ 'certificate usage', 'selector', 'matching type', 'certificate association data' ]
+  getRdataFields(arg) {
+    return [
+      'certificate usage',
+      'selector',
+      'matching type',
+      'certificate association data',
+    ]
   }
 
-  getRFCs () {
-    return [ 6698 ]
+  getRFCs() {
+    return [6698]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 52
   }
 
-  getQuotedFields () {
-    return [  ]
+  getQuotedFields() {
+    return []
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  TLSA, usage, selector, match, data
-    const match = opts.bindline.split(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+(.*?)\s*$/)
+    const match = opts.bindline.split(
+      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+(.*?)\s*$/,
+    )
     if (!match) throw new Error(`unable to parse TLSA: ${opts.bindline}`)
-    const [ owner, ttl, c, type, usage, selector, matchtype, cad ] = match.slice(1)
+    const [owner, ttl, c, type, usage, selector, matchtype, cad] =
+      match.slice(1)
     return new TLSA({
-      owner                         : this.fullyQualify(owner),
-      ttl                           : parseInt(ttl, 10),
-      class                         : c,
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
-      'certificate usage'           : parseInt(usage,     10),
-      selector                      : parseInt(selector,  10),
-      'matching type'               : parseInt(matchtype, 10),
+      'certificate usage': parseInt(usage, 10),
+      selector: parseInt(selector, 10),
+      'matching type': parseInt(matchtype, 10),
       'certificate association data': cad,
     })
   }
 
-  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 != 52) throw new Error('TLSA fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
 
     return new TLSA({
-      owner                         : this.fullyQualify(fqdn),
-      ttl                           : parseInt(ttl, 10),
-      type                          : 'TLSA',
-      'certificate usage'           : bytes.readUInt8(0),
-      selector                      : bytes.readUInt8(1),
-      'matching type'               : bytes.readUInt8(2),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'TLSA',
+      'certificate usage': bytes.readUInt8(0),
+      selector: bytes.readUInt8(1),
+      'matching type': bytes.readUInt8(2),
       'certificate association data': bytes.slice(3).toString(),
-      timestamp                     : ts,
-      location                      : loc !== '' && loc !== '\n' ? loc : '',
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
+  toTinydns() {
     const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
 
     return this.getTinydnsGeneric(
       TINYDNS.UInt8toOctal(this.get('certificate usage')) +
-      TINYDNS.UInt8toOctal(this.get('selector')) +
-      TINYDNS.UInt8toOctal(this.get('matching type')) +
-      TINYDNS.escapeOctal(dataRe, this.get('certificate association data'))
+        TINYDNS.UInt8toOctal(this.get('selector')) +
+        TINYDNS.UInt8toOctal(this.get('matching type')) +
+        TINYDNS.escapeOctal(dataRe, this.get('certificate association data')),
     )
   }
 }

package/rr/tsig.js

@@ -0,0 +1,48 @@
+import RR from '../rr.js'
+
+export default class TSIG extends RR {
+  constructor(opts) {
+    super(opts)
+    if (opts === null) return
+  }
+
+  /****** Resource record specific setters   *******/
+
+  getDescription() {
+    return 'Transaction Signature'
+  }
+
+  getRdataFields(arg) {
+    return ['algorithm name', 'time signed', 'fudge', 'mac', 'original id', 'error', 'other']
+  }
+
+  getRFCs() {
+    return [2845]
+  }
+
+  getTypeId() {
+    return 250
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind(opts) {
+    // test.example.com  3600  IN  TSIG SAMPLE-ALG.EXAMPLE. 853804800 300 0 0 0
+    const [owner, ttl, c, type, algorithm] = opts.bindline.split(/\s+/)
+    return new TSIG({
+      owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      'algorithm': algorithm,
+      // 'time signed': opts.bindline,
+      // fudge
+      // mac
+      // original id
+      // error
+      // other
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}

package/rr/txt.js

@@ -1,61 +1,59 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class TXT extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setData (val) {
+  setData(val) {
     this.set('data', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Text'
   }
 
-  getRdataFields (arg) {
-    return [ 'data' ]
+  getRdataFields(arg) {
+    return ['data']
   }
 
-  getRFCs () {
-    return [ 1035 ]
+  getRFCs() {
+    return [1035]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 16
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     const str = opts.tinyline
     let fqdn, rdata, s, ttl, ts, loc
     // 'fqdn:s:ttl:timestamp:lo
     if (str[0] === "'") {
-      [ fqdn, s, ttl, ts, loc ] = str.substring(1).split(':')
+      ;[fqdn, s, ttl, ts, loc] = str.substring(1).split(':')
       rdata = TINYDNS.octalToChar(s)
-    }
-    else {
-      [ fqdn, rdata, ttl, ts, loc ] = this.fromTinydnsGeneric(str)
+    } else {
+      ;[fqdn, rdata, ttl, ts, loc] = this.fromTinydnsGeneric(str)
     }
 
     return new this.constructor({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl, 10),
-      type     : 'TXT',
-      data     : rdata,
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'TXT',
+      data: rdata,
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromTinydnsGeneric (str) {
+  fromTinydnsGeneric(str) {
     // generic: :fqdn:n:rdata:ttl:timestamp:location
     // eslint-disable-next-line prefer-const
-    let [ fqdn, n, rdata, ttl, ts, loc ] = str.substring(1).split(':')
+    let [fqdn, n, rdata, ttl, ts, loc] = str.substring(1).split(':')
     if (n != 16) throw new Error('TXT fromTinydns, invalid n')
 
     rdata = TINYDNS.octalToChar(rdata)
@@ -67,35 +65,40 @@ export default class TXT extends RR {
       pos = len + pos
       len = rdata.charCodeAt(pos + 1)
     }
-    return [ fqdn, s, ttl, ts, loc ]
+    return [fqdn, s, ttl, ts, loc]
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  TXT  "..."
-    const match = opts.bindline.split(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+?\s*(.*?)\s*$/)
+    const match = opts.bindline.split(
+      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+?\s*(.*?)\s*$/,
+    )
     if (!match) throw new Error(`unable to parse TXT: ${opts.bindline}`)
-    const [ owner, ttl, c, type, rdata ] = match.slice(1)
+    const [owner, ttl, c, type, rdata] = match.slice(1)
 
     return new this.constructor({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
       type,
-      data : rdata.match(/"([^"]+?)"/g).map(s => s.replace(/^"|"$/g, '')).join(''),
+      data: rdata
+        .match(/"([^"]+?)"/g)
+        .map((s) => s.replace(/^"|"$/g, ''))
+        .join(''),
     })
   }
 
   /******  EXPORTERS   *******/
-  toBind (zone_opts) {
+  toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t"${asQuotedStrings(this.get('data'))}"\n`
   }
 
-  toMaraDNS () {
+  toMaraDNS() {
     const data = asQuotedStrings(this.get('data')).replace(/"/g, "'")
     return `${this.get('owner')}\t+${this.get('ttl')}\t${this.get('type')}\t'${data}' ~\n`
   }
 
-  toTinydns () {
+  toTinydns() {
     let data = this.get('data')
     if (Array.isArray(data)) data = data.join('')
     const rdata = TINYDNS.escapeOctal(new RegExp(/[\r\n\t:\\/]/, 'g'), data)
@@ -103,15 +106,19 @@ export default class TXT extends RR {
   }
 }
 
-function asQuotedStrings (data) {
-
+function asQuotedStrings(data) {
   // BIND croaks when any string in the TXT RR data is longer than 255
   if (Array.isArray(data)) {
     let hasTooLong = false
     for (const str of data) {
       if (str.length > 255) hasTooLong = true
     }
-    return hasTooLong ? data.join('').match(/(.{1,255})/g).join('" "') : data.join('" "')
+    return hasTooLong
+      ? data
+          .join('')
+          .match(/(.{1,255})/g)
+          .join('" "')
+      : data.join('" "')
   }
 
   if (data.length > 255) {

package/rr/uri.js

@@ -1,91 +1,91 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class URI extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setPriority (val) {
+  setPriority(val) {
     this.is16bitInt('URI', 'priority', val)
 
     this.set('priority', val)
   }
 
-  setWeight (val) {
+  setWeight(val) {
     this.is16bitInt('URI', 'weight', val)
 
     this.set('weight', val)
   }
 
-  setTarget (val) {
+  setTarget(val) {
     if (!val) throw new Error(`URI: target is required, ${this.citeRFC()}`)
 
     this.set('target', val)
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // URI 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 != 256) throw new Error('URI fromTinydns, invalid n')
 
     return new URI({
-      type     : 'URI',
-      owner    : this.fullyQualify(fqdn),
-      priority : TINYDNS.octalToUInt16(rdata.substring(0, 8)),
-      weight   : TINYDNS.octalToUInt16(rdata.substring(8, 16)),
-      target   : TINYDNS.octalToChar(rdata.substring(16)),
-      ttl      : parseInt(ttl, 10),
+      type: 'URI',
+      owner: this.fullyQualify(fqdn),
+      priority: TINYDNS.octalToUInt16(rdata.substring(0, 8)),
+      weight: TINYDNS.octalToUInt16(rdata.substring(8, 16)),
+      target: TINYDNS.octalToChar(rdata.substring(16)),
+      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  URI  priority, weight, target
-    const [ owner, ttl, c, type, priority, weight, target ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, priority, weight, target] =
+      opts.bindline.split(/\s+/)
     return new URI({
-      class   : c,
-      type    : type,
+      class: c,
+      type: type,
       owner,
       priority: parseInt(priority, 10),
-      weight  : parseInt(weight, 10),
-      target  : target.replace(/^"|"$/g, ''),
-      ttl     : parseInt(ttl, 10),
+      weight: parseInt(weight, 10),
+      target: target.replace(/^"|"$/g, ''),
+      ttl: parseInt(ttl, 10),
     })
   }
 
   /******  MISC   *******/
-  getDescription () {
+  getDescription() {
     return 'URI'
   }
 
-  getRdataFields (arg) {
-    return [ 'priority', 'weight', 'target' ]
+  getRdataFields(arg) {
+    return ['priority', 'weight', 'target']
   }
 
-  getRFCs () {
-    return [ 7553 ]
+  getRFCs() {
+    return [7553]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 256
   }
 
-  getQuotedFields () {
-    return [ 'target' ]
+  getQuotedFields() {
+    return ['target']
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
+  toTinydns() {
     const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
     let rdata = ''
 
-    for (const e of [ 'priority', 'weight' ]) {
+    for (const e of ['priority', 'weight']) {
       rdata += TINYDNS.UInt16toOctal(this.get(e))
     }
 

package/rr/wks.js

@@ -0,0 +1,44 @@
+import RR from '../rr.js'
+
+export default class WKS extends RR {
+  constructor(opts) {
+    super(opts)
+    if (opts === null) return
+  }
+
+  /****** Resource record specific setters   *******/
+
+  getDescription() {
+    return 'Well Known Service'
+  }
+
+  getRdataFields(arg) {
+    return ['bit map']
+  }
+
+  getRFCs() {
+    return [883, 1035]
+  }
+
+  getTypeId() {
+    return 11
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind(opts) {
+    // test.example.com  3600  IN  WKS 192.168.1.1 TCP 25
+    const [owner, ttl, c, type, address, protocol, bitmap] = opts.bindline.split(/\s+/)
+    return new WKS({
+      owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type,
+      address,  // 32-bit int
+      protocol, // 8-bit int, 6=TCP, 17=UDP
+      bitmap,   // var len bit map, must be multiple of 8
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}