@libp2p/mdns 0.18.0

package/src/compat/querier.ts

@@ -0,0 +1,209 @@
+import { EventEmitter } from 'events'
+import MDNS from 'multicast-dns'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { PeerId } from '@libp2p/peer-id'
+import debug from 'debug'
+import { SERVICE_TAG_LOCAL, MULTICAST_IP, MULTICAST_PORT } from './constants.js'
+import { base58btc } from 'multiformats/bases/base58'
+import type { PeerDiscovery } from '@libp2p/interfaces/peer-discovery'
+import type { ResponsePacket } from 'multicast-dns'
+import type { RemoteInfo } from 'dgram'
+
+const log = Object.assign(debug('libp2p:mdns:compat:querier'), {
+  error: debug('libp2p:mdns:compat:querier:error')
+})
+
+export interface QuerierOptions {
+  peerId: PeerId
+  queryInterval?: number
+  queryPeriod?: number
+}
+
+export interface Handle {
+  stop: () => Promise<void>
+}
+
+export class Querier extends EventEmitter implements PeerDiscovery {
+  private readonly _peerIdStr: string
+  private readonly _options: Required<QuerierOptions>
+  private _handle?: Handle
+
+  constructor (options: QuerierOptions) {
+    super()
+
+    const { peerId, queryInterval, queryPeriod } = options
+
+    if (peerId == null) {
+      throw new Error('missing peerId parameter')
+    }
+
+    this._peerIdStr = peerId.toString(base58btc)
+    this._options = {
+      peerId,
+
+      // Re-query in leu of network change detection (every 60s by default)
+      queryInterval: queryInterval ?? 60000,
+      // Time for which the MDNS server will stay alive waiting for responses
+      // Must be less than options.queryInterval!
+      queryPeriod: Math.min(
+        queryInterval ?? 60000,
+        queryPeriod ?? 5000
+      )
+    }
+    this._onResponse = this._onResponse.bind(this)
+  }
+
+  isStarted () {
+    return Boolean(this._handle)
+  }
+
+  start () {
+    this._handle = periodically(() => {
+      // Create a querier that queries multicast but gets responses unicast
+      const mdns = MDNS({ multicast: false, interface: '0.0.0.0', port: 0 })
+
+      mdns.on('response', this._onResponse)
+
+      // @ts-expect-error @types/multicast-dns are wrong
+      mdns.query({
+        id: nextId(), // id > 0 for unicast response
+        questions: [{
+          name: SERVICE_TAG_LOCAL,
+          type: 'PTR',
+          class: 'IN'
+        }]
+      }, null, {
+        address: MULTICAST_IP,
+        port: MULTICAST_PORT
+      })
+
+      return {
+        stop: async () => {
+          mdns.removeListener('response', this._onResponse)
+          return await new Promise(resolve => mdns.destroy(resolve))
+        }
+      }
+    }, {
+      period: this._options.queryPeriod,
+      interval: this._options.queryInterval
+    })
+  }
+
+  _onResponse (event: ResponsePacket, info: RemoteInfo) {
+    const answers = event.answers ?? []
+    const ptrRecord = answers.find(a => a.type === 'PTR' && a.name === SERVICE_TAG_LOCAL)
+
+    // Only deal with responses for our service tag
+    if (ptrRecord == null) return
+
+    log('got response', event, info)
+
+    const txtRecord = answers.find(a => a.type === 'TXT')
+    if (txtRecord == null || txtRecord.type !== 'TXT') {
+      return log('missing TXT record in response')
+    }
+
+    let peerIdStr
+    try {
+      peerIdStr = txtRecord.data[0].toString()
+    } catch (err) {
+      return log('failed to extract peer ID from TXT record data', txtRecord, err)
+    }
+
+    if (this._peerIdStr === peerIdStr) {
+      return log('ignoring reply to myself')
+    }
+
+    let peerId
+    try {
+      peerId = PeerId.fromString(peerIdStr)
+    } catch (err) {
+      return log('failed to create peer ID from TXT record data', peerIdStr, err)
+    }
+
+    const srvRecord = answers.find(a => a.type === 'SRV')
+    if (srvRecord == null || srvRecord.type !== 'SRV') {
+      return log('missing SRV record in response')
+    }
+
+    log('peer found', peerIdStr)
+
+    const { port } = srvRecord.data ?? {}
+    const protos = { A: 'ip4', AAAA: 'ip6' }
+
+    const multiaddrs = answers
+      .filter(a => ['A', 'AAAA'].includes(a.type))
+      .reduce<Multiaddr[]>((addrs, a) => {
+      if (a.type !== 'A' && a.type !== 'AAAA') {
+        return addrs
+      }
+
+      const maStr = `/${protos[a.type]}/${a.data}/tcp/${port}`
+      try {
+        addrs.push(new Multiaddr(maStr))
+        log(maStr)
+      } catch (err) {
+        log(`failed to create multiaddr from ${a.type} record data`, maStr, port, err)
+      }
+      return addrs
+    }, [])
+
+    this.emit('peer', {
+      id: peerId,
+      multiaddrs
+    })
+  }
+
+  async stop () {
+    if (this._handle != null) {
+      await this._handle.stop()
+    }
+  }
+}
+
+/**
+ * Run `fn` for a certain period of time, and then wait for an interval before
+ * running it again. `fn` must return an object with a stop function, which is
+ * called when the period expires.
+ */
+function periodically (fn: () => Handle, options: { period: number, interval: number }) {
+  let handle: Handle | null
+  let timeoutId: NodeJS.Timer
+  let stopped = false
+
+  const reRun = () => {
+    handle = fn()
+    timeoutId = setTimeout(() => {
+      if (handle != null) {
+        handle.stop().catch(log)
+      }
+
+      if (!stopped) {
+        timeoutId = setTimeout(reRun, options.interval)
+      }
+
+      handle = null
+    }, options.period)
+  }
+
+  reRun()
+
+  return {
+    async stop () {
+      stopped = true
+      clearTimeout(timeoutId)
+      if (handle != null) {
+        await handle.stop()
+      }
+    }
+  }
+}
+
+const nextId = (() => {
+  let id = 0
+  return () => {
+    id++
+    if (id === Number.MAX_SAFE_INTEGER) id = 1
+    return id
+  }
+})()

package/src/compat/responder.ts

@@ -0,0 +1,127 @@
+import OS from 'os'
+import MDNS, { QueryPacket } from 'multicast-dns'
+import debug from 'debug'
+import { SERVICE_TAG_LOCAL } from './constants.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Multiaddr, MultiaddrObject } from '@multiformats/multiaddr'
+import { base58btc } from 'multiformats/bases/base58'
+import type { RemoteInfo } from 'dgram'
+import type { Answer } from 'dns-packet'
+
+const log = Object.assign(debug('libp2p:mdns:compat:responder'), {
+  error: debug('libp2p:mdns:compat:responder:error')
+})
+
+export interface ResponderOptions {
+  peerId: PeerId
+  multiaddrs: Multiaddr[]
+}
+
+export class Responder {
+  private readonly _peerIdStr: string
+  private readonly _multiaddrs: Multiaddr[]
+  private _mdns?: MDNS.MulticastDNS
+
+  constructor (options: ResponderOptions) {
+    const { peerId, multiaddrs } = options
+
+    if (peerId == null) {
+      throw new Error('missing peerId parameter')
+    }
+
+    this._peerIdStr = peerId.toString(base58btc)
+    this._multiaddrs = multiaddrs
+    this._onQuery = this._onQuery.bind(this)
+  }
+
+  start () {
+    this._mdns = MDNS()
+    this._mdns.on('query', this._onQuery)
+  }
+
+  _onQuery (event: QueryPacket, info: RemoteInfo) {
+    const addresses = this._multiaddrs.reduce<MultiaddrObject[]>((acc, addr) => {
+      if (addr.isThinWaistAddress()) {
+        acc.push(addr.toOptions())
+      }
+      return acc
+    }, [])
+
+    // Only announce TCP for now
+    if (addresses.length === 0) {
+      return
+    }
+
+    const questions = event.questions ?? []
+
+    // Only respond to queries for our service tag
+    if (!questions.some(q => q.name === SERVICE_TAG_LOCAL)) return
+
+    log('got query', event, info)
+
+    const answers: Answer[] = []
+    const peerServiceTagLocal = `${this._peerIdStr}.${SERVICE_TAG_LOCAL}`
+
+    answers.push({
+      name: SERVICE_TAG_LOCAL,
+      type: 'PTR',
+      class: 'IN',
+      ttl: 120,
+      data: peerServiceTagLocal
+    })
+
+    // Only announce TCP multiaddrs for now
+    const port = addresses[0].port
+
+    answers.push({
+      name: peerServiceTagLocal,
+      type: 'SRV',
+      class: 'IN',
+      ttl: 120,
+      data: {
+        priority: 10,
+        weight: 1,
+        port,
+        target: OS.hostname()
+      }
+    })
+
+    answers.push({
+      name: peerServiceTagLocal,
+      type: 'TXT',
+      class: 'IN',
+      ttl: 120,
+      data: [Buffer.from(this._peerIdStr)]
+    })
+
+    addresses.forEach((ma) => {
+      if ([4, 6].includes(ma.family)) {
+        answers.push({
+          name: OS.hostname(),
+          type: ma.family === 4 ? 'A' : 'AAAA',
+          class: 'IN',
+          ttl: 120,
+          data: ma.host
+        })
+      }
+    })
+
+    if (this._mdns != null) {
+      log('responding to query', answers)
+      this._mdns.respond(answers, info)
+    }
+  }
+
+  stop () {
+    if (this._mdns != null) {
+      this._mdns.removeListener('query', this._onQuery)
+      return new Promise<void>(resolve => {
+        if (this._mdns != null) {
+          this._mdns.destroy(resolve)
+        } else {
+          resolve()
+        }
+      })
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,191 @@
+import multicastDNS from 'multicast-dns'
+import { EventEmitter } from 'events'
+import debug from 'debug'
+import * as query from './query.js'
+import { GoMulticastDNS } from './compat/index.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type PeerDiscovery from '@libp2p/interfaces/peer-discovery'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { PeerData } from '@libp2p/interfaces/peer-data'
+
+const log = Object.assign(debug('libp2p:mdns'), {
+  error: debug('libp2p:mdns:error')
+})
+
+export interface MulticastDNSOptions {
+  peerId: PeerId
+  broadcast?: boolean
+  interval?: number
+  serviceTag?: string
+  port?: number
+  multiaddrs?: Multiaddr[]
+  compat?: boolean
+  compatQueryPeriod?: number
+  compatQueryInterval?: number
+}
+
+export class MulticastDNS extends EventEmitter implements PeerDiscovery {
+  static tag = 'mdns'
+
+  public mdns?: multicastDNS.MulticastDNS
+
+  private readonly broadcast: boolean
+  private readonly interval: number
+  private readonly serviceTag: string
+  private readonly port: number
+  private readonly peerId: PeerId
+  private readonly peerMultiaddrs: Multiaddr[] // TODO: update this when multiaddrs change?
+  private _queryInterval: NodeJS.Timer | null
+  private readonly _goMdns?: GoMulticastDNS
+
+  constructor (options: MulticastDNSOptions) {
+    super()
+
+    if (options.peerId == null) {
+      throw new Error('needs own PeerId to work')
+    }
+
+    this.broadcast = options.broadcast !== false
+    this.interval = options.interval ?? (1e3 * 10)
+    this.serviceTag = options.serviceTag ?? 'ipfs.local'
+    this.port = options.port ?? 5353
+    this.peerId = options.peerId
+    this.peerMultiaddrs = options.multiaddrs ?? []
+    this._queryInterval = null
+    this._onPeer = this._onPeer.bind(this)
+    this._onMdnsQuery = this._onMdnsQuery.bind(this)
+    this._onMdnsResponse = this._onMdnsResponse.bind(this)
+
+    if (options.compat !== false) {
+      this._goMdns = new GoMulticastDNS({
+        multiaddrs: this.peerMultiaddrs,
+        peerId: options.peerId,
+        queryPeriod: options.compatQueryPeriod,
+        queryInterval: options.compatQueryInterval
+      })
+      this._goMdns.on('peer', this._onPeer)
+    }
+  }
+
+  isStarted () {
+    return Boolean(this.mdns)
+  }
+
+  /**
+   * Start sending queries to the LAN.
+   *
+   * @returns {void}
+   */
+  async start () {
+    if (this.mdns != null) {
+      return
+    }
+
+    this.mdns = multicastDNS({ port: this.port })
+    this.mdns.on('query', this._onMdnsQuery)
+    this.mdns.on('response', this._onMdnsResponse)
+
+    this._queryInterval = query.queryLAN(this.mdns, this.serviceTag, this.interval)
+
+    if (this._goMdns != null) {
+      await this._goMdns.start()
+    }
+  }
+
+  _onMdnsQuery (event: multicastDNS.QueryPacket) {
+    if (this.mdns == null) {
+      return
+    }
+
+    query.gotQuery(event, this.mdns, this.peerId, this.peerMultiaddrs, this.serviceTag, this.broadcast)
+  }
+
+  _onMdnsResponse (event: multicastDNS.ResponsePacket) {
+    try {
+      const foundPeer = query.gotResponse(event, this.peerId, this.serviceTag)
+
+      if (foundPeer != null) {
+        this.emit('peer', foundPeer)
+      }
+    } catch (err) {
+      log('Error processing peer response', err)
+    }
+  }
+
+  _onPeer (peerData: PeerData) {
+    (this.mdns != null) && this.emit('peer', peerData)
+  }
+
+  /**
+   * Stop sending queries to the LAN.
+   *
+   * @returns {Promise}
+   */
+  async stop () {
+    if (this.mdns == null) {
+      return
+    }
+
+    this.mdns.removeListener('query', this._onMdnsQuery)
+    this.mdns.removeListener('response', this._onMdnsResponse)
+    this._goMdns?.removeListener('peer', this._onPeer)
+
+    if (this._queryInterval != null) {
+      clearInterval(this._queryInterval)
+      this._queryInterval = null
+    }
+
+    await Promise.all([
+      this._goMdns?.stop(),
+      new Promise<void>((resolve) => {
+        if (this.mdns != null) {
+          this.mdns.destroy(resolve)
+        } else {
+          resolve()
+        }
+      })
+    ])
+
+    this.mdns = undefined
+  }
+}
+
+/* for reference
+
+   [ { name: 'discovery.ipfs.io.local',
+       type: 'PTR',
+       class: 1,
+       ttl: 120,
+       data: 'QmbBHw1Xx9pUpAbrVZUKTPL5Rsph5Q9GQhRvcWVBPFgGtC.discovery.ipfs.io.local' },
+
+     { name: 'QmbBHw1Xx9pUpAbrVZUKTPL5Rsph5Q9GQhRvcWVBPFgGtC.discovery.ipfs.io.local',
+       type: 'SRV',
+       class: 1,
+       ttl: 120,
+       data: { priority: 10, weight: 1, port: 4001, target: 'lorien.local' } },
+
+     { name: 'lorien.local',
+       type: 'A',
+       class: 1,
+       ttl: 120,
+       data: '127.0.0.1' },
+
+     { name: 'lorien.local',
+       type: 'A',
+       class: 1,
+       ttl: 120,
+       data: '127.94.0.1' },
+
+     { name: 'lorien.local',
+       type: 'A',
+       class: 1,
+       ttl: 120,
+       data: '172.16.38.224' },
+
+     { name: 'QmbBHw1Xx9pUpAbrVZUKTPL5Rsph5Q9GQhRvcWVBPFgGtC.discovery.ipfs.io.local',
+       type: 'TXT',
+       class: 1,
+       ttl: 120,
+       data: 'QmbBHw1Xx9pUpAbrVZUKTPL5Rsph5Q9GQhRvcWVBPFgGtC' } ],
+
+*/

package/src/query.ts

@@ -0,0 +1,166 @@
+import os from 'os'
+import debug from 'debug'
+import { Multiaddr, MultiaddrObject } from '@multiformats/multiaddr'
+import { base58btc } from 'multiformats/bases/base58'
+import { PeerId } from '@libp2p/peer-id'
+import type { PeerData } from '@libp2p/interfaces/peer-data'
+import type { MulticastDNS, ResponsePacket, QueryPacket } from 'multicast-dns'
+import type { SrvAnswer, StringAnswer, TxtAnswer, Answer } from 'dns-packet'
+
+const log = Object.assign(debug('libp2p:mdns'), {
+  error: debug('libp2p:mdns:error')
+})
+
+export function queryLAN (mdns: MulticastDNS, serviceTag: string, interval: number) {
+  const query = () => {
+    log('query', serviceTag)
+    mdns.query({
+      questions: [{
+        name: serviceTag,
+        type: 'PTR'
+      }]
+    })
+  }
+
+  // Immediately start a query, then do it every interval.
+  query()
+  return setInterval(query, interval)
+}
+
+interface Answers {
+  ptr?: StringAnswer
+  srv?: SrvAnswer
+  txt?: TxtAnswer
+  a: StringAnswer[]
+  aaaa: StringAnswer[]
+}
+
+export function gotResponse (rsp: ResponsePacket, localPeerId: PeerId, serviceTag: string): PeerData | undefined {
+  if (rsp.answers == null) {
+    return
+  }
+
+  const answers: Answers = {
+    a: [],
+    aaaa: []
+  }
+
+  rsp.answers.forEach((answer) => {
+    switch (answer.type) {
+      case 'PTR': answers.ptr = answer; break
+      case 'SRV': answers.srv = answer; break
+      case 'TXT': answers.txt = answer; break
+      case 'A': answers.a.push(answer); break
+      case 'AAAA': answers.aaaa.push(answer); break
+      default: break
+    }
+  })
+
+  if (answers.ptr == null ||
+      answers.ptr.name !== serviceTag ||
+      answers.txt == null ||
+      answers.srv == null) {
+    return
+  }
+
+  const b58Id = answers.txt.data[0].toString()
+  const port = answers.srv.data.port
+  const multiaddrs: Multiaddr[] = []
+
+  answers.a.forEach((a) => {
+    const ma = new Multiaddr(`/ip4/${a.data}/tcp/${port}`)
+
+    if (!multiaddrs.some((m) => m.equals(ma))) {
+      multiaddrs.push(ma)
+    }
+  })
+
+  answers.aaaa.forEach((a) => {
+    const ma = new Multiaddr(`/ip6/${a.data}/tcp/${port}`)
+
+    if (!multiaddrs.some((m) => m.equals(ma))) {
+      multiaddrs.push(ma)
+    }
+  })
+
+  if (localPeerId.toString(base58btc) === b58Id) {
+    return // replied to myself, ignore
+  }
+
+  log('peer found -', b58Id)
+
+  return {
+    id: PeerId.fromString(b58Id),
+    multiaddrs,
+    protocols: []
+  }
+}
+
+export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerId: PeerId, multiaddrs: Multiaddr[], serviceTag: string, broadcast: boolean) {
+  if (!broadcast) {
+    return
+  }
+
+  const addresses: MultiaddrObject[] = multiaddrs.reduce<MultiaddrObject[]>((acc, addr) => {
+    if (addr.isThinWaistAddress()) {
+      acc.push(addr.toOptions())
+    }
+    return acc
+  }, [])
+
+  // Only announce TCP for now
+  if (addresses.length === 0) {
+    return
+  }
+
+  if (qry.questions[0] != null && qry.questions[0].name === serviceTag) {
+    const answers: Answer[] = []
+
+    answers.push({
+      name: serviceTag,
+      type: 'PTR',
+      class: 'IN',
+      ttl: 120,
+      data: peerId.toString(base58btc) + '.' + serviceTag
+    })
+
+    // Only announce TCP multiaddrs for now
+    const port = addresses[0].port
+
+    answers.push({
+      name: peerId.toString(base58btc) + '.' + serviceTag,
+      type: 'SRV',
+      class: 'IN',
+      ttl: 120,
+      data: {
+        priority: 10,
+        weight: 1,
+        port: port,
+        target: os.hostname()
+      }
+    })
+
+    answers.push({
+      name: peerId.toString(base58btc) + '.' + serviceTag,
+      type: 'TXT',
+      class: 'IN',
+      ttl: 120,
+      data: peerId.toString(base58btc)
+    })
+
+    addresses.forEach((addr) => {
+      if ([4, 6].includes(addr.family)) {
+        answers.push({
+          name: os.hostname(),
+          type: addr.family === 4 ? 'A' : 'AAAA',
+          class: 'IN',
+          ttl: 120,
+          data: addr.host
+        })
+      }
+    })
+
+    log('responding to query')
+    mdns.respond(answers)
+  }
+}