@nictool/dns-resource-record 1.1.3

package/rr/loc.js

@@ -0,0 +1,216 @@
+
+import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
+
+const REF = {  // RFC 1876
+  LATLON  : 2**31,  // LAT equator, LON prime meridian
+  ALTITUDE: 100000 * 100, // reference spheroid used by GPS, in cm
+}
+
+const CONV = {
+  sec: 1000,
+  min: 60 * 1000,
+  deg: 60 * 60 * 1000,
+}
+
+export default class LOC extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setAddress (val) {
+    if (!val) throw new Error('LOC: address is required')
+
+    /*
+    ... LOC ( d1 [m1 [s1]] {"N"|"S"} d2 [m2 [s2]]
+             {"E"|"W"} alt["m"] [siz["m"] [hp["m"]
+             [vp["m"]]]] )
+    */
+    this.parseLoc(val)
+
+    this.set('address', val)
+  }
+
+  getDescription () {
+    return 'Location'
+  }
+
+  getRdataFields (arg) {
+    return [ 'address' ]
+  }
+
+  getRFCs () {
+    return [ 1876 ]
+  }
+
+  getTypeId () {
+    return 29
+  }
+
+  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?)?'
+
+    // put them all together
+    const locRe = new RegExp(`^${dms}(N|S)\\s+${dms}(E|W)\\s+${alt}`, 'i')
+    const r = string.match(locRe)
+    if (!r) throw new Error('LOC address: invalid format, see RFC 1876')
+
+    const loc = {
+      latitude: {
+        degrees   : r[1],
+        minutes   : r[2],
+        seconds   : r[3],
+        hemisphere: r[4].toUpperCase(),
+      },
+      longitude: {
+        degrees   : r[5],
+        minutes   : r[6],
+        seconds   : r[7],
+        hemisphere: r[8].toUpperCase(),
+      },
+      altitude : r[9] * 100,  // m -> cm
+      size     : r[10] * 100,
+      precision: {
+        horizontal: r[11] * 100,
+        vertical  : r[12] * 100,
+      },
+    }
+
+    return loc
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // LOC via generic, :fqdn:n:rdata:ttl:timestamp:lo
+    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))),
+      precision: {
+        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,
+    }
+
+    return new LOC({
+      type     : 'LOC',
+      owner    : this.fullyQualify(fqdn),
+      address  : this.toHuman(l),
+      ttl      : parseInt(ttl, 10),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    const [ owner, ttl, c, type ] = opts.bindline.split(/\s+/)
+
+    return new LOC({
+      owner,
+      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)
+    switch (obj.hemisphere.toUpperCase()) {
+      case 'W':
+      case 'S':
+        retval = -retval
+        break
+    }
+    retval += REF.LATLON
+    return retval
+  }
+
+  arcSecToDMS (rawmsec, latlon) {
+    let msec = Math.abs(rawmsec - REF.LATLON)
+    // console.log(`rawmsec: ${rawmsec}, abs msec: ${msec}`)
+
+    const deg = Math.floor(msec / CONV.deg)
+    msec -= deg * CONV.deg
+
+    const min = Math.floor(msec / CONV.min)
+    msec -= min * CONV.min
+
+    const sec = Math.floor(msec / CONV.sec)
+    msec -= sec * CONV.sec
+
+    let hem
+    switch (latlon) {
+      case 'lat':
+        hem = rawmsec >= REF.LATLON ? 'N' : 'S'
+        break
+      case 'lon':
+        hem = rawmsec >= REF.LATLON ? 'E' : 'W'
+        break
+      default:
+        throw new Error('unknown or missing hemisphere')
+    }
+
+    return `${deg} ${min} ${sec}${msec ? '.'+msec : ''} ${hem}`
+  }
+
+  fromExponent (prec) {
+    const mantissa = ((prec >> 4) & 0x0f) % 10
+    const exponent = ((prec >> 0) & 0x0f) % 10
+    return mantissa * Math.pow(10, exponent)
+  }
+
+  toExponent (val) {
+    /*
+     RFC 1876, ... expressed as a pair of four-bit unsigned
+     integers, each ranging from zero to nine, with the most
+     significant four bits representing the base and the second
+     number representing the power of ten by which to multiply
+     the base.
+    */
+    let exponent = 0
+    while (val >= 10) {
+      val /= 10
+      ++exponent
+    }
+    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`
+    if (obj.precision.horizontal) r += ` ${obj.precision.horizontal / 100}m`
+    if (obj.precision.vertical  ) r += ` ${obj.precision.vertical / 100}m`
+    return r
+  }
+
+  /******  EXPORTERS   *******/
+
+  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(this.toExponent(loc.size))
+    rdata += TINYDNS.UInt8toOctal(this.toExponent(loc.precision.horizontal))
+    rdata += TINYDNS.UInt8toOctal(this.toExponent(loc.precision.vertical))
+    rdata += TINYDNS.UInt32toOctal(this.dmsToArcSec(loc.latitude))
+    rdata += TINYDNS.UInt32toOctal(this.dmsToArcSec(loc.longitude))
+    rdata += TINYDNS.UInt32toOctal(loc.altitude + REF.ALTITUDE)
+
+    return this.getTinydnsGeneric(rdata)
+  }
+}

package/rr/mx.js

@@ -0,0 +1,86 @@
+
+import net from 'net'
+
+import RR from '../rr.js'
+
+export default class MX extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPreference (val) {
+    if (val === undefined) val = this?.default?.preference
+    this.is16bitInt('MX', 'preference', val)
+    this.set('preference', val)
+  }
+
+  setExchange (val) {
+    if (!val) throw new Error('MX: exchange is required')
+
+    if (net.isIPv4(val) || net.isIPv6(val))
+      throw new Error(`MX: exchange must be a FQDN, ${this.citeRFC()}`)
+
+    this.isFullyQualified('MX', 'exchange', val)
+    this.isValidHostname('MX', 'exchange', val)
+
+    // RFC 4034: letters in the DNS names ... are lower cased
+    this.set('exchange', val.toLowerCase())
+  }
+
+  getDescription () {
+    return 'Mail Exchanger'
+  }
+
+  getRdataFields (arg) {
+    return [ 'preference', 'exchange' ]
+  }
+
+  getRFCs () {
+    return [ 1035, 2181, 7505 ]
+  }
+
+  getTypeId () {
+    return 15
+  }
+
+  /******  IMPORTERS   *******/
+  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(':')
+
+    return new MX({
+      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 : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  MX  preference exchange
+    const [ owner, ttl, c, type, preference, exchange ] = opts.bindline.split(/\s+/)
+
+    return new MX({
+      owner,
+      ttl       : parseInt(ttl, 10),
+      class     : c,
+      type,
+      preference: parseInt(preference),
+      exchange,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toBind (zone_opts) {
+    return `${this.getPrefix(zone_opts)}\t${this.get('preference')}\t${this.getFQDN('exchange', zone_opts)}\n`
+  }
+
+  toTinydns () {
+    return `@${this.getTinyFQDN('owner')}::${this.getTinyFQDN('exchange')}:${this.get('preference')}:${this.getTinydnsPostamble()}\n`
+  }
+}

package/rr/naptr.js

@@ -0,0 +1,146 @@
+
+import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
+
+const rdataRe = /[\r\n\t:\\/]/
+
+export default class NAPTR extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  getDescription () {
+    return 'Naming Authority Pointer'
+  }
+
+  getQuotedFields () {
+    return [ 'flags', 'service', 'regexp' ]
+  }
+
+  getRdataFields (arg) {
+    return [ 'order', 'preference', 'flags', 'service', 'regexp', 'replacement' ]
+  }
+
+  getRFCs () {
+    return [ 2915, 3403 ]
+  }
+
+  getTypeId () {
+    return 35
+  }
+
+  /****** Resource record specific setters   *******/
+  setOrder (val) {
+    this.is16bitInt('NAPTR', 'order', val)
+    this.set('order', val)
+  }
+
+  setPreference (val) {
+    this.is16bitInt('NAPTR', 'preference', val)
+    this.set('preference', val)
+  }
+
+  setFlags (val) {
+    if (![ '', 'S', 'A', 'U', 'P' ].includes(val.toUpperCase()))
+      throw new Error (`NAPTR flags are invalid, ${this.citeRFC()}`)
+
+    this.set('flags', val.toUpperCase())
+  }
+
+  setService (val) {
+    this.set('service', val)
+  }
+
+  setRegexp (val) {
+    this.set('regexp', val)
+  }
+
+  setReplacement (val) {
+    this.set('replacement', val)
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // NAPTR via generic, :fqdn:n:rdata:ttl:timestamp:lo
+    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    if (n != 35) throw new Error('NAPTR fromTinydns, invalid n')
+
+    const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+
+    const rec = {
+      type      : 'NAPTR',
+      owner     : this.fullyQualify(fqdn),
+      ttl       : parseInt(ttl, 10),
+      timestamp : ts,
+      location  : loc !== '' && loc !== '\n' ? loc : '',
+      order     : binRdata.readUInt16BE(0,2),
+      preference: binRdata.readUInt16BE(2,4),
+    }
+
+    let idx = 4
+    const flagsLength = binRdata.readUInt8(idx); idx++
+    rec.flags         = binRdata.slice(idx, flagsLength).toString()
+    idx += flagsLength
+
+    const serviceLen  = binRdata.readUInt8(idx); idx++
+    rec.service       = binRdata.slice(idx, idx+serviceLen).toString()
+    idx += serviceLen
+
+    const regexpLen   = binRdata.readUInt8(idx); idx++
+    rec.regexp        = binRdata.slice(idx, idx+regexpLen).toString()
+    idx += regexpLen
+
+    const replaceLen  = binRdata.readUInt8(idx); idx++
+    rec.replacement   = binRdata.slice(idx, idx+replaceLen).toString()
+
+    return new NAPTR(rec)
+  }
+
+  fromBind (opts) {
+    const str = opts.bindline
+    // test.example.com  3600  IN  NAPTR order, preference, "flags", "service", "regexp", replacement
+    const [ owner, ttl, c, type, order, preference ] = str.split(/\s+/)
+    const [ flags, service, regexp ] = str.match(/(?:").*?(?:"\s)/g)
+    const replacement = str.trim().split(/\s+/).pop()
+
+    const bits = {
+      owner      : owner,
+      ttl        : parseInt(ttl, 10),
+      class      : c,
+      type       : type,
+      order      : parseInt(order, 10),
+      preference : parseInt(preference, 10),
+      flags      : flags.trim().replace(/^['"]|['"]$/g, ''),
+      service    : service.trim().replace(/^['"]|['"]$/g, ''),
+      regexp     : regexp.trim().replace(/^['"]|['"]/g, ''),
+      replacement: replacement,
+    }
+    return new NAPTR(bits)
+  }
+
+  /******  EXPORTERS   *******/
+  toTinydns () {
+
+    let rdata =
+      TINYDNS.UInt16toOctal(this.get('order')) +
+      TINYDNS.UInt16toOctal(this.get('preference')) +
+
+      TINYDNS.UInt8toOctal(this.get('flags').length) +
+      this.get('flags') +
+
+      TINYDNS.UInt8toOctal(this.get('service').length) +
+      TINYDNS.escapeOctal(rdataRe, this.get('service')) +
+
+      TINYDNS.UInt8toOctal(this.get('regexp').length) +
+      TINYDNS.escapeOctal(rdataRe, this.get('regexp'))
+
+    const replacement = this.get('replacement')
+    if (replacement !== '') {
+      rdata += TINYDNS.UInt8toOctal(replacement.length)
+      rdata += TINYDNS.escapeOctal(rdataRe, replacement)
+    }
+    rdata += '\\000'
+
+    return this.getTinydnsGeneric(rdata)
+  }
+}

package/rr/ns.js

@@ -0,0 +1,74 @@
+
+import RR from '../rr.js'
+
+export default class NS extends RR {
+  constructor (opts) {
+    super(opts)
+    if (opts === null) return
+  }
+
+  /****** Resource record specific setters   *******/
+  setDname (val) {
+    if (!val) throw new Error(`NS: dname is required, ${this.citeRFC()}`)
+
+    this.isFullyQualified('NS', 'dname', val)
+    this.isValidHostname('NS', 'dname', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('dname', val.toLowerCase())
+  }
+
+  getDescription () {
+    return 'Name Server'
+  }
+
+  getRdataFields (arg) {
+    return [ 'dname' ]
+  }
+
+  getRFCs () {
+    return [ 1035 ]
+  }
+
+  getTypeId () {
+    return 2
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // &fqdn:ip:x:ttl:timestamp:lo
+    // eslint-disable-next-line no-unused-vars
+    const [ fqdn, ip, dname, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+
+    return new NS({
+      type     : 'NS',
+      owner    : this.fullyQualify(fqdn),
+      dname    : this.fullyQualify(/\./.test(dname) ? dname : `${dname}.ns.${fqdn}`),
+      ttl      : parseInt(ttl, 10),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  NS dname
+    const [ owner, ttl, c, type, dname ] = opts.bindline.split(/\s+/)
+
+    return new NS({
+      owner,
+      ttl  : parseInt(ttl, 10),
+      class: c,
+      type : type,
+      dname: dname,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toBind (zone_opts) {
+    return `${this.getPrefix(zone_opts)}\t${this.getFQDN('dname', zone_opts)}\n`
+  }
+
+  toTinydns () {
+    return `&${this.getTinyFQDN('owner')}::${this.getTinyFQDN('dname')}:${this.getTinydnsPostamble()}\n`
+  }
+}

package/rr/nsec.js

@@ -0,0 +1,61 @@
+
+import RR from '../rr.js'
+
+export default class NSEC extends RR {
+  constructor (opts) {
+    super(opts)
+    if (opts === null) return
+  }
+
+  /****** Resource record specific setters   *******/
+  setNextDomain (val) {
+    if (!val) throw new Error(`NSEC: 'next domain' is required:, ${this.citeRFC()}`)
+
+    this.isFullyQualified('NSEC', 'next domain', val)
+    this.isValidHostname('NSEC', 'next domain', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('next domain', val.toLowerCase())
+  }
+
+  setTypeBitMaps (val) {
+    if (!val) throw new Error(`NSEC: 'type bit maps' is required, ${this.citeRFC()}`)
+
+    this.set('type bit maps', val)
+  }
+
+  getDescription () {
+    return 'Next Secure'
+  }
+
+  getRdataFields (arg) {
+    return [ 'next domain', 'type bit maps' ]
+  }
+
+  getRFCs () {
+    return [ 4034 ]
+  }
+
+  getTypeId () {
+    return 47
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  NSEC NextDomain TypeBitMaps
+    const [ owner, ttl, c, type, next ] = opts.bindline.split(/\s+/)
+    return new NSEC({
+      owner,
+      ttl            : parseInt(ttl, 10),
+      class          : c,
+      type           : type,
+      'next domain'  : next,
+      'type bit maps': opts.bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}
+
+const removeParens = a => ![ '(',')' ].includes(a)

package/rr/nsec3.js

@@ -0,0 +1,99 @@
+
+import RR from '../rr.js'
+
+export default class NSEC3 extends RR {
+  constructor (opts) {
+    super(opts)
+    if (opts === null) return
+  }
+
+  /****** Resource record specific setters   *******/
+  setHashAlgoritm (val) {
+    // Hash Algorithm is a single octet.
+    // The Hash Algorithm field is represented as an unsigned decimal integer.
+    if (!val) throw new Error(`NSEC3: 'hash algorithm' is required, ${this.citeRFC()}`)
+
+    this.is8bitInt('NSEC3', 'hash algorithm', val)
+
+    this.set('hash algorithm', val)
+  }
+
+  setFlags (val) {
+    // The Flags field is represented as an unsigned decimal integer.
+    if (!val) throw new Error(`NSEC3: 'flags' is required, ${this.citeRFC()}`)
+
+    this.is8bitInt('NSEC3', 'flags', val)
+
+    this.set('flags', val)
+  }
+
+  setIterations (val) {
+    // The Iterations field is represented as an unsigned decimal integer. 0-65535
+    if (!val) throw new Error(`NSEC3: 'iterations' is required, ${this.citeRFC()}`)
+
+    this.is16bitInt('NSEC3', 'flags', val)
+
+    this.set('iterations', val)
+  }
+
+  setSalt (val) {
+    // The Salt field is represented as a sequence of case-insensitive
+    // hexadecimal digits.  Whitespace is not allowed within the
+    // sequence.  The Salt field is represented as "-" (without the
+    // quotes) when the Salt Length field has a value of 0
+    this.set('salt', val)
+  }
+
+  setNextHashedOwnerName (val) {
+    // The Next Hashed Owner Name field is represented as an unpadded
+    // sequence of case-insensitive base32 digits, without whitespace
+    if (!val) throw new Error(`NSEC3: 'next hashed owner name' is required, ${this.citeRFC()}`)
+
+    this.set('next hashed owner name', val)
+  }
+
+  setTypeBitMaps (val) {
+    // The Type Bit Maps field is represented as a sequence of RR type mnemonics.
+    if (!val) throw new Error(`NSEC3: 'type bit maps' is required, ${this.citeRFC()}`)
+
+    this.set('type bit maps', val)
+  }
+
+  getDescription () {
+    return 'Next Secure'
+  }
+
+  getRdataFields (arg) {
+    return [ 'hash algorithm', 'flags', 'iterations', 'salt', 'next hashed owner name', 'type bit maps' ]
+  }
+
+  getRFCs () {
+    return [ 5155, 9077 ]
+  }
+
+  getTypeId () {
+    return 50
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind (str) {
+    // test.example.com  3600  IN  NSEC3
+    const [ owner, ttl, c, type ] = str.split(/\s+/)
+    return new NSEC3({
+      owner,
+      ttl                     : parseInt(ttl, 10),
+      class                   : c,
+      type                    : type,
+      'hash algorithm'        : '',
+      'flags'                 : '',
+      'iterations'            : '',
+      'salt'                  : '',
+      'next hashed owner name': '',
+      'type bit maps'         : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+}