@nictool/dns-resource-record 1.1.7 → 1.2.1

package/rr/txt.js

@@ -1,62 +1,60 @@
-
 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(':')
-    if (n != 16) throw new Error('TXT fromTinydns, invalid n')
+    let [fqdn, n, rdata, ttl, ts, loc] = str.substring(1).split(':')
+    if (n != 16) this.throwHelp('TXT fromTinydns, invalid n')
 
     rdata = TINYDNS.octalToChar(rdata)
     let s = ''
@@ -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*$/)
-    if (!match) throw new Error(`unable to parse TXT: ${opts.bindline}`)
-    const [ owner, ttl, c, type, rdata ] = match.slice(1)
+    const match = opts.bindline.split(
+      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+?\s*(.*?)\s*$/,
+    )
+    if (!match) this.throwHelp(`unable to parse TXT: ${opts.bindline}`)
+    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) {
-    if (!val) throw new Error(`URI: target is required, ${this.citeRFC()}`)
+  setTarget(val) {
+    if (!val) this.throwHelp(`URI: target is required`)
 
     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(':')
-    if (n != 256) throw new Error('URI fromTinydns, invalid n')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 256) this.throwHelp('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,45 @@
+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   *******/
+}