0.2.0 - Mid migration

web/node_modules/bonjour/lib/browser.js

@@ -0,0 +1,198 @@
+'use strict'
+
+var util = require('util')
+var EventEmitter = require('events').EventEmitter
+var serviceName = require('multicast-dns-service-types')
+var dnsEqual = require('dns-equal')
+var dnsTxt = require('dns-txt')
+
+var TLD = '.local'
+var WILDCARD = '_services._dns-sd._udp' + TLD
+
+module.exports = Browser
+
+util.inherits(Browser, EventEmitter)
+
+/**
+ * Start a browser
+ *
+ * The browser listens for services by querying for PTR records of a given
+ * type, protocol and domain, e.g. _http._tcp.local.
+ *
+ * If no type is given, a wild card search is performed.
+ *
+ * An internal list of online services is kept which starts out empty. When
+ * ever a new service is discovered, it's added to the list and an "up" event
+ * is emitted with that service. When it's discovered that the service is no
+ * longer available, it is removed from the list and a "down" event is emitted
+ * with that service.
+ */
+function Browser (mdns, opts, onup) {
+  if (typeof opts === 'function') return new Browser(mdns, null, opts)
+
+  EventEmitter.call(this)
+
+  this._mdns = mdns
+  this._onresponse = null
+  this._serviceMap = {}
+  this._txt = dnsTxt(opts.txt)
+
+  if (!opts || !opts.type) {
+    this._name = WILDCARD
+    this._wildcard = true
+  } else {
+    this._name = serviceName.stringify(opts.type, opts.protocol || 'tcp') + TLD
+    if (opts.name) this._name = opts.name + '.' + this._name
+    this._wildcard = false
+  }
+
+  this.services = []
+
+  if (onup) this.on('up', onup)
+
+  this.start()
+}
+
+Browser.prototype.start = function () {
+  if (this._onresponse) return
+
+  var self = this
+
+  // List of names for the browser to listen for. In a normal search this will
+  // be the primary name stored on the browser. In case of a wildcard search
+  // the names will be determined at runtime as responses come in.
+  var nameMap = {}
+  if (!this._wildcard) nameMap[this._name] = true
+
+  this._onresponse = function (packet, rinfo) {
+    if (self._wildcard) {
+      packet.answers.forEach(function (answer) {
+        if (answer.type !== 'PTR' || answer.name !== self._name || answer.name in nameMap) return
+        nameMap[answer.data] = true
+        self._mdns.query(answer.data, 'PTR')
+      })
+    }
+
+    Object.keys(nameMap).forEach(function (name) {
+      // unregister all services shutting down
+      goodbyes(name, packet).forEach(self._removeService.bind(self))
+
+      // register all new services
+      var matches = buildServicesFor(name, packet, self._txt, rinfo)
+      if (matches.length === 0) return
+
+      matches.forEach(function (service) {
+        if (self._serviceMap[service.fqdn]) return // ignore already registered services
+        self._addService(service)
+      })
+    })
+  }
+
+  this._mdns.on('response', this._onresponse)
+  this.update()
+}
+
+Browser.prototype.stop = function () {
+  if (!this._onresponse) return
+
+  this._mdns.removeListener('response', this._onresponse)
+  this._onresponse = null
+}
+
+Browser.prototype.update = function () {
+  this._mdns.query(this._name, 'PTR')
+}
+
+Browser.prototype._addService = function (service) {
+  this.services.push(service)
+  this._serviceMap[service.fqdn] = true
+  this.emit('up', service)
+}
+
+Browser.prototype._removeService = function (fqdn) {
+  var service, index
+  this.services.some(function (s, i) {
+    if (dnsEqual(s.fqdn, fqdn)) {
+      service = s
+      index = i
+      return true
+    }
+  })
+  if (!service) return
+  this.services.splice(index, 1)
+  delete this._serviceMap[fqdn]
+  this.emit('down', service)
+}
+
+// PTR records with a TTL of 0 is considered a "goodbye" announcement. I.e. a
+// DNS response broadcasted when a service shuts down in order to let the
+// network know that the service is no longer going to be available.
+//
+// For more info see:
+// https://tools.ietf.org/html/rfc6762#section-8.4
+//
+// This function returns an array of all resource records considered a goodbye
+// record
+function goodbyes (name, packet) {
+  return packet.answers.concat(packet.additionals)
+    .filter(function (rr) {
+      return rr.type === 'PTR' && rr.ttl === 0 && dnsEqual(rr.name, name)
+    })
+    .map(function (rr) {
+      return rr.data
+    })
+}
+
+function buildServicesFor (name, packet, txt, referer) {
+  var records = packet.answers.concat(packet.additionals).filter(function (rr) {
+    return rr.ttl > 0 // ignore goodbye messages
+  })
+
+  return records
+    .filter(function (rr) {
+      return rr.type === 'PTR' && dnsEqual(rr.name, name)
+    })
+    .map(function (ptr) {
+      var service = {
+        addresses: []
+      }
+
+      records
+        .filter(function (rr) {
+          return (rr.type === 'SRV' || rr.type === 'TXT') && dnsEqual(rr.name, ptr.data)
+        })
+        .forEach(function (rr) {
+          if (rr.type === 'SRV') {
+            var parts = rr.name.split('.')
+            var name = parts[0]
+            var types = serviceName.parse(parts.slice(1, -1).join('.'))
+            service.name = name
+            service.fqdn = rr.name
+            service.host = rr.data.target
+            service.referer = referer
+            service.port = rr.data.port
+            service.type = types.name
+            service.protocol = types.protocol
+            service.subtypes = types.subtypes
+          } else if (rr.type === 'TXT') {
+            service.rawTxt = rr.data
+            service.txt = txt.decode(rr.data)
+          }
+        })
+
+      if (!service.name) return
+
+      records
+        .filter(function (rr) {
+          return (rr.type === 'A' || rr.type === 'AAAA') && dnsEqual(rr.name, service.host)
+        })
+        .forEach(function (rr) {
+          service.addresses.push(rr.data)
+        })
+
+      return service
+    })
+    .filter(function (rr) {
+      return !!rr
+    })
+}

web/node_modules/bonjour/lib/mdns-server.js

@@ -0,0 +1,116 @@
+'use strict'
+
+var multicastdns = require('multicast-dns')
+var dnsEqual = require('dns-equal')
+var flatten = require('array-flatten')
+var deepEqual = require('deep-equal')
+
+module.exports = Server
+
+function Server (opts) {
+  this.mdns = multicastdns(opts)
+  this.mdns.setMaxListeners(0)
+  this.registry = {}
+  this.mdns.on('query', this._respondToQuery.bind(this))
+}
+
+Server.prototype.register = function (records) {
+  var self = this
+
+  if (Array.isArray(records)) records.forEach(register)
+  else register(records)
+
+  function register (record) {
+    var subRegistry = self.registry[record.type]
+    if (!subRegistry) subRegistry = self.registry[record.type] = []
+    else if (subRegistry.some(isDuplicateRecord(record))) return
+    subRegistry.push(record)
+  }
+}
+
+Server.prototype.unregister = function (records) {
+  var self = this
+
+  if (Array.isArray(records)) records.forEach(unregister)
+  else unregister(records)
+
+  function unregister (record) {
+    var type = record.type
+    if (!(type in self.registry)) return
+    self.registry[type] = self.registry[type].filter(function (r) {
+      return r.name !== record.name
+    })
+  }
+}
+
+Server.prototype._respondToQuery = function (query) {
+  var self = this
+  query.questions.forEach(function (question) {
+    var type = question.type
+    var name = question.name
+
+    // generate the answers section
+    var answers = type === 'ANY'
+      ? flatten.depth(Object.keys(self.registry).map(self._recordsFor.bind(self, name)), 1)
+      : self._recordsFor(name, type)
+
+    if (answers.length === 0) return
+
+    // generate the additionals section
+    var additionals = []
+    if (type !== 'ANY') {
+      answers.forEach(function (answer) {
+        if (answer.type !== 'PTR') return
+        additionals = additionals
+          .concat(self._recordsFor(answer.data, 'SRV'))
+          .concat(self._recordsFor(answer.data, 'TXT'))
+      })
+
+      // to populate the A and AAAA records, we need to get a set of unique
+      // targets from the SRV record
+      additionals
+        .filter(function (record) {
+          return record.type === 'SRV'
+        })
+        .map(function (record) {
+          return record.data.target
+        })
+        .filter(unique())
+        .forEach(function (target) {
+          additionals = additionals
+            .concat(self._recordsFor(target, 'A'))
+            .concat(self._recordsFor(target, 'AAAA'))
+        })
+    }
+
+    self.mdns.respond({ answers: answers, additionals: additionals }, function (err) {
+      if (err) throw err // TODO: Handle this (if no callback is given, the error will be ignored)
+    })
+  })
+}
+
+Server.prototype._recordsFor = function (name, type) {
+  if (!(type in this.registry)) return []
+
+  return this.registry[type].filter(function (record) {
+    var _name = ~name.indexOf('.') ? record.name : record.name.split('.')[0]
+    return dnsEqual(_name, name)
+  })
+}
+
+function isDuplicateRecord (a) {
+  return function (b) {
+    return a.type === b.type &&
+      a.name === b.name &&
+      deepEqual(a.data, b.data)
+  }
+}
+
+function unique () {
+  var set = []
+  return function (obj) {
+    if (~set.indexOf(obj)) return false
+    set.push(obj)
+    return true
+  }
+}

web/node_modules/bonjour/lib/registry.js

@@ -0,0 +1,189 @@
+'use strict'
+
+var dnsEqual = require('dns-equal')
+var flatten = require('array-flatten')
+var Service = require('./service')
+
+var REANNOUNCE_MAX_MS = 60 * 60 * 1000
+var REANNOUNCE_FACTOR = 3
+
+module.exports = Registry
+
+function Registry (server) {
+  this._server = server
+  this._services = []
+}
+
+Registry.prototype.publish = function (opts) {
+  var service = new Service(opts)
+  service.start = start.bind(service, this)
+  service.stop = stop.bind(service, this)
+  service.start({ probe: opts.probe !== false })
+  return service
+}
+
+Registry.prototype.unpublishAll = function (cb) {
+  teardown(this._server, this._services, cb)
+  this._services = []
+}
+
+Registry.prototype.destroy = function () {
+  this._services.forEach(function (service) {
+    service._destroyed = true
+  })
+}
+
+function start (registry, opts) {
+  if (this._activated) return
+  this._activated = true
+
+  registry._services.push(this)
+
+  if (opts.probe) {
+    var service = this
+    probe(registry._server.mdns, this, function (exists) {
+      if (exists) {
+        service.stop()
+        service.emit('error', new Error('Service name is already in use on the network'))
+        return
+      }
+      announce(registry._server, service)
+    })
+  } else {
+    announce(registry._server, this)
+  }
+}
+
+function stop (registry, cb) {
+  if (!this._activated) return // TODO: What about the callback?
+
+  teardown(registry._server, this, cb)
+
+  var index = registry._services.indexOf(this)
+  if (index !== -1) registry._services.splice(index, 1)
+}
+
+/**
+ * Check if a service name is already in use on the network.
+ *
+ * Used before announcing the new service.
+ *
+ * To guard against race conditions where multiple services are started
+ * simultaneously on the network, wait a random amount of time (between
+ * 0 and 250 ms) before probing.
+ *
+ * TODO: Add support for Simultaneous Probe Tiebreaking:
+ * https://tools.ietf.org/html/rfc6762#section-8.2
+ */
+function probe (mdns, service, cb) {
+  var sent = false
+  var retries = 0
+  var timer
+
+  mdns.on('response', onresponse)
+  setTimeout(send, Math.random() * 250)
+
+  function send () {
+    // abort if the service have or is being stopped in the meantime
+    if (!service._activated || service._destroyed) return
+
+    mdns.query(service.fqdn, 'ANY', function () {
+      // This function will optionally be called with an error object. We'll
+      // just silently ignore it and retry as we normally would
+      sent = true
+      timer = setTimeout(++retries < 3 ? send : done, 250)
+      timer.unref()
+    })
+  }
+
+  function onresponse (packet) {
+    // Apparently conflicting Multicast DNS responses received *before*
+    // the first probe packet is sent MUST be silently ignored (see
+    // discussion of stale probe packets in RFC 6762 Section 8.2,
+    // "Simultaneous Probe Tiebreaking" at
+    // https://tools.ietf.org/html/rfc6762#section-8.2
+    if (!sent) return
+
+    if (packet.answers.some(matchRR) || packet.additionals.some(matchRR)) done(true)
+  }
+
+  function matchRR (rr) {
+    return dnsEqual(rr.name, service.fqdn)
+  }
+
+  function done (exists) {
+    mdns.removeListener('response', onresponse)
+    clearTimeout(timer)
+    cb(!!exists)
+  }
+}
+
+/**
+ * Initial service announcement
+ *
+ * Used to announce new services when they are first registered.
+ *
+ * Broadcasts right away, then after 3 seconds, 9 seconds, 27 seconds,
+ * and so on, up to a maximum interval of one hour.
+ */
+function announce (server, service) {
+  var delay = 1000
+  var packet = service._records()
+
+  server.register(packet)
+
+  ;(function broadcast () {
+    // abort if the service have or is being stopped in the meantime
+    if (!service._activated || service._destroyed) return
+
+    server.mdns.respond(packet, function () {
+      // This function will optionally be called with an error object. We'll
+      // just silently ignore it and retry as we normally would
+      if (!service.published) {
+        service._activated = true
+        service.published = true
+        service.emit('up')
+      }
+      delay = delay * REANNOUNCE_FACTOR
+      if (delay < REANNOUNCE_MAX_MS && !service._destroyed) {
+        setTimeout(broadcast, delay).unref()
+      }
+    })
+  })()
+}
+
+/**
+ * Stop the given services
+ *
+ * Besides removing a service from the mDNS registry, a "goodbye"
+ * message is sent for each service to let the network know about the
+ * shutdown.
+ */
+function teardown (server, services, cb) {
+  if (!Array.isArray(services)) services = [services]
+
+  services = services.filter(function (service) {
+    return service._activated // ignore services not currently starting or started
+  })
+
+  var records = flatten.depth(services.map(function (service) {
+    service._activated = false
+    var records = service._records()
+    records.forEach(function (record) {
+      record.ttl = 0 // prepare goodbye message
+    })
+    return records
+  }), 1)
+
+  if (records.length === 0) return cb && cb()
+
+  server.unregister(records)
+
+  // send goodbye message
+  server.mdns.respond(records, function () {
+    services.forEach(function (service) {
+      service.published = false
+    })
+    if (cb) cb.apply(null, arguments)
+  })
+}

web/node_modules/bonjour/lib/service.js

@@ -0,0 +1,98 @@
+'use strict'
+
+var os = require('os')
+var util = require('util')
+var EventEmitter = require('events').EventEmitter
+var serviceName = require('multicast-dns-service-types')
+var txt = require('dns-txt')()
+
+var TLD = '.local'
+
+module.exports = Service
+
+util.inherits(Service, EventEmitter)
+
+function Service (opts) {
+  if (!opts.name) throw new Error('Required name not given')
+  if (!opts.type) throw new Error('Required type not given')
+  if (!opts.port) throw new Error('Required port not given')
+
+  this.name = opts.name
+  this.protocol = opts.protocol || 'tcp'
+  this.type = serviceName.stringify(opts.type, this.protocol)
+  this.host = opts.host || os.hostname()
+  this.port = opts.port
+  this.fqdn = this.name + '.' + this.type + TLD
+  this.subtypes = opts.subtypes || null
+  this.txt = opts.txt || null
+  this.published = false
+
+  this._activated = false // indicates intent - true: starting/started, false: stopping/stopped
+}
+
+Service.prototype._records = function () {
+  var records = [rr_ptr(this), rr_srv(this), rr_txt(this)]
+
+  var self = this
+  var interfaces = os.networkInterfaces()
+  Object.keys(interfaces).forEach(function (name) {
+    interfaces[name].forEach(function (addr) {
+      if (addr.internal) return
+      if (addr.family === 'IPv4') {
+        records.push(rr_a(self, addr.address))
+      } else {
+        records.push(rr_aaaa(self, addr.address))
+      }
+    })
+  })
+
+  return records
+}
+
+function rr_ptr (service) {
+  return {
+    name: service.type + TLD,
+    type: 'PTR',
+    ttl: 28800,
+    data: service.fqdn
+  }
+}
+
+function rr_srv (service) {
+  return {
+    name: service.fqdn,
+    type: 'SRV',
+    ttl: 120,
+    data: {
+      port: service.port,
+      target: service.host
+    }
+  }
+}
+
+function rr_txt (service) {
+  return {
+    name: service.fqdn,
+    type: 'TXT',
+    ttl: 4500,
+    data: txt.encode(service.txt)
+  }
+}
+
+function rr_a (service, ip) {
+  return {
+    name: service.host,
+    type: 'A',
+    ttl: 120,
+    data: ip
+  }
+}
+
+function rr_aaaa (service, ip) {
+  return {
+    name: service.host,
+    type: 'AAAA',
+    ttl: 120,
+    data: ip
+  }
+}