@nictool/dns-resource-record 1.1.7 → 1.2.0

package/rr/ipseckey.js

@@ -1,4 +1,3 @@
-
 import net from 'net'
 
 import RR from '../rr.js'
@@ -6,130 +5,139 @@ 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))
+    if (![0, 1, 2, 3].includes(val))
       throw new Error(`IPSECKEY: Gateway Type is invalid, ${this.citeRFC()}`)
 
     this.set('gateway type', val)
   }
 
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // unsigned int, 1 octet, values: 1=DSA, 2=RSA
-    if (![ 1,2 ].includes(val))
+    if (![1, 2].includes(val))
       throw new Error(`IPSECKEY: Algorithm invalid, ${this.citeRFC()}`)
 
     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}), ${this.citeRFC()}`,
+    )
     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) {
+  setPublickey(val) {
     // if (val) throw new Error(`IPSECKEY: publickey is optional, ${this.citeRFC()}`)
 
     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
   }
 
   /******  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(':')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
     if (n != 45) throw new Error('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))
+    if (![1, 2, 3, 4, 5, 253, 254].includes(val))
       throw new Error(`KEY: algorithm invalid, ${this.citeRFC()}`)
 
     this.set('algorithm', val)
   }
 
-  setPublickey (val) {
+  setPublickey(val) {
     if (!val) throw new Error(`KEY: 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 [ 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(),
     })
   }

package/rr/loc.js

@@ -1,9 +1,9 @@
-
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
-const REF = {  // RFC 1876
-  LATLON  : 2**31,  // LAT equator, LON prime meridian
+const REF = {
+  // RFC 1876
+  LATLON: 2 ** 31, // LAT equator, LON prime meridian
   ALTITUDE: 100000 * 100, // reference spheroid used by GPS, in cm
 }
 
@@ -14,12 +14,12 @@ const CONV = {
 }
 
 export default class LOC extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setAddress (val) {
+  setAddress(val) {
     if (!val) throw new Error('LOC: address is required')
 
     /*
@@ -32,29 +32,29 @@ export default class LOC extends RR {
     this.set('address', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Location'
   }
 
-  getRdataFields (arg) {
-    return [ 'address' ]
+  getRdataFields(arg) {
+    return ['address']
   }
 
-  getRFCs () {
-    return [ 1876 ]
+  getRFCs() {
+    return [1876]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 29
   }
 
-  parseLoc (string) {
-
+  parseLoc(string) {
     // d1 [m1 [s1]]
     const dms = '(\\d+)\\s+(?:(\\d+)\\s+)?(?:([\\d.]+)\\s+)?'
 
     // alt["m"] [siz["m"] [hp["m"] [vp["m"]]]]
-    const alt = '(-?[\\d.]+)m?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?'
+    const alt =
+      '(-?[\\d.]+)m?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?'
 
     // put them all together
     const locRe = new RegExp(`^${dms}(N|S)\\s+${dms}(E|W)\\s+${alt}`, 'i')
@@ -63,22 +63,22 @@ export default class LOC extends RR {
 
     const loc = {
       latitude: {
-        degrees   : r[1],
-        minutes   : r[2],
-        seconds   : r[3],
+        degrees: r[1],
+        minutes: r[2],
+        seconds: r[3],
         hemisphere: r[4].toUpperCase(),
       },
       longitude: {
-        degrees   : r[5],
-        minutes   : r[6],
-        seconds   : r[7],
+        degrees: r[5],
+        minutes: r[6],
+        seconds: r[7],
         hemisphere: r[8].toUpperCase(),
       },
-      altitude : r[9] * 100,  // m -> cm
-      size     : r[10] * 100,
+      altitude: r[9] * 100, // m -> cm
+      size: r[10] * 100,
       precision: {
         horizontal: r[11] * 100,
-        vertical  : r[12] * 100,
+        vertical: r[12] * 100,
       },
     }
 
@@ -86,48 +86,61 @@ export default class LOC extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // LOC 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 != 29) throw new Error('LOC fromTinydns, invalid n')
 
     // divide by 100 is to convert cm to meters
     const l = {
-      version  : TINYDNS.octalToUInt8(rdata.substring(0, 4)),
-      size     : this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(4, 8))),
+      version: TINYDNS.octalToUInt8(rdata.substring(0, 4)),
+      size: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(4, 8))),
       precision: {
-        horizontal: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring( 8, 12))),
-        vertical  : this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(12, 16))),
+        horizontal: this.fromExponent(
+          TINYDNS.octalToUInt8(rdata.substring(8, 12)),
+        ),
+        vertical: this.fromExponent(
+          TINYDNS.octalToUInt8(rdata.substring(12, 16)),
+        ),
       },
-      latitude : this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(16, 32)), 'lat'),
-      longitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(32, 48)), 'lon'),
-      altitude : TINYDNS.octalToUInt32(rdata.substring(48, 64)) - REF.ALTITUDE,
+      latitude: this.arcSecToDMS(
+        TINYDNS.octalToUInt32(rdata.substring(16, 32)),
+        'lat',
+      ),
+      longitude: this.arcSecToDMS(
+        TINYDNS.octalToUInt32(rdata.substring(32, 48)),
+        'lon',
+      ),
+      altitude: TINYDNS.octalToUInt32(rdata.substring(48, 64)) - REF.ALTITUDE,
     }
 
     return new LOC({
-      type     : 'LOC',
-      owner    : this.fullyQualify(fqdn),
-      address  : this.toHuman(l),
-      ttl      : parseInt(ttl, 10),
+      type: 'LOC',
+      owner: this.fullyQualify(fqdn),
+      address: this.toHuman(l),
+      ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
-    const [ owner, ttl, c, type ] = opts.bindline.split(/\s+/)
+  fromBind(opts) {
+    const [owner, ttl, c, type] = opts.bindline.split(/\s+/)
 
     return new LOC({
       owner,
-      ttl    : parseInt(ttl, 10),
-      class  : c,
-      type   : type,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
       address: opts.bindline.split(/\s+/).slice(4).join(' ').trim(),
     })
   }
 
-  dmsToArcSec (obj) {
-    let retval = (obj.degrees * CONV.deg) + ((obj.minutes || 0) * CONV.min) + ((obj.seconds || 0) * CONV.sec)
+  dmsToArcSec(obj) {
+    let retval =
+      obj.degrees * CONV.deg +
+      (obj.minutes || 0) * CONV.min +
+      (obj.seconds || 0) * CONV.sec
     switch (obj.hemisphere.toUpperCase()) {
       case 'W':
       case 'S':
@@ -138,7 +151,7 @@ export default class LOC extends RR {
     return retval
   }
 
-  arcSecToDMS (rawmsec, latlon) {
+  arcSecToDMS(rawmsec, latlon) {
     let msec = Math.abs(rawmsec - REF.LATLON)
     // console.log(`rawmsec: ${rawmsec}, abs msec: ${msec}`)
 
@@ -163,16 +176,16 @@ export default class LOC extends RR {
         throw new Error('unknown or missing hemisphere')
     }
 
-    return `${deg} ${min} ${sec}${msec ? '.'+msec : ''} ${hem}`
+    return `${deg} ${min} ${sec}${msec ? '.' + msec : ''} ${hem}`
   }
 
-  fromExponent (prec) {
+  fromExponent(prec) {
     const mantissa = ((prec >> 4) & 0x0f) % 10
     const exponent = ((prec >> 0) & 0x0f) % 10
     return mantissa * Math.pow(10, exponent)
   }
 
-  toExponent (val) {
+  toExponent(val) {
     /*
      RFC 1876, ... expressed as a pair of four-bit unsigned
      integers, each ranging from zero to nine, with the most
@@ -188,22 +201,22 @@ export default class LOC extends RR {
     return (parseInt(val) << 4) | (exponent & 0x0f)
   }
 
-  toHuman (obj) {
-    let r = `${obj.latitude} ${obj.longitude} ${(obj.altitude/100)}m`
-    if (obj.size)                 r += ` ${obj.size/100}m`
+  toHuman(obj) {
+    let r = `${obj.latitude} ${obj.longitude} ${obj.altitude / 100}m`
+    if (obj.size) r += ` ${obj.size / 100}m`
     if (obj.precision.horizontal) r += ` ${obj.precision.horizontal / 100}m`
-    if (obj.precision.vertical  ) r += ` ${obj.precision.vertical / 100}m`
+    if (obj.precision.vertical) r += ` ${obj.precision.vertical / 100}m`
     return r
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     const loc = this.parseLoc(this.get('address'))
 
     // LOC format declares in meters, tinydns uses cm (hence * 100)
     let rdata = ''
-    rdata += TINYDNS.UInt8toOctal(0)  // version
+    rdata += TINYDNS.UInt8toOctal(0) // version
     rdata += TINYDNS.UInt8toOctal(this.toExponent(loc.size))
     rdata += TINYDNS.UInt8toOctal(this.toExponent(loc.precision.horizontal))
     rdata += TINYDNS.UInt8toOctal(this.toExponent(loc.precision.vertical))

package/rr/mx.js

@@ -1,21 +1,20 @@
-
 import net from 'net'
 
 import RR from '../rr.js'
 
 export default class MX extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setPreference (val) {
+  setPreference(val) {
     if (val === undefined) val = this?.default?.preference
     this.is16bitInt('MX', 'preference', val)
     this.set('preference', val)
   }
 
-  setExchange (val) {
+  setExchange(val) {
     if (!val) throw new Error('MX: exchange is required')
 
     if (net.isIPv4(val) || net.isIPv6(val))
@@ -28,47 +27,50 @@ export default class MX extends RR {
     this.set('exchange', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Mail Exchanger'
   }
 
-  getRdataFields (arg) {
-    return [ 'preference', 'exchange' ]
+  getRdataFields(arg) {
+    return ['preference', 'exchange']
   }
 
-  getRFCs () {
-    return [ 1035, 2181, 7505 ]
+  getRFCs() {
+    return [1035, 2181, 7505]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 15
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // @fqdn:ip:x:dist:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [ owner, ip, x, preference, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [owner, ip, x, preference, ttl, ts, loc] = opts.tinyline
+      .substring(1)
+      .split(':')
 
     return new MX({
-      type      : 'MX',
-      owner     : this.fullyQualify(owner),
-      exchange  : this.fullyQualify(/\./.test(x) ? x : `${x}.mx.${owner}`),
+      type: 'MX',
+      owner: this.fullyQualify(owner),
+      exchange: this.fullyQualify(/\./.test(x) ? x : `${x}.mx.${owner}`),
       preference: parseInt(preference, 10) || 0,
-      ttl       : parseInt(ttl, 10),
-      timestamp : ts,
-      location  : loc !== '' && loc !== '\n' ? loc : '',
+      ttl: parseInt(ttl, 10),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  MX  preference exchange
-    const [ owner, ttl, c, type, preference, exchange ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, preference, exchange] =
+      opts.bindline.split(/\s+/)
 
     return new MX({
       owner,
-      ttl       : parseInt(ttl, 10),
-      class     : c,
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
       preference: parseInt(preference),
       exchange,
@@ -76,11 +78,11 @@ export default class MX extends RR {
   }
 
   /******  EXPORTERS   *******/
-  toBind (zone_opts) {
+  toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t${this.get('preference')}\t${this.getFQDN('exchange', zone_opts)}\n`
   }
 
-  toTinydns () {
+  toTinydns() {
     return `@${this.getTinyFQDN('owner')}::${this.getTinyFQDN('exchange')}:${this.get('preference')}:${this.getTinydnsPostamble()}\n`
   }
 }