@libp2p/mdns 0.18.0 → 1.0.2

package/src/compat/utils.ts

@@ -0,0 +1,81 @@
+import type { PeerData } from '@libp2p/interfaces/peer-data'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { logger } from '@libp2p/logger'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { Multiaddr } from '@multiformats/multiaddr'
+import type { Answer } from 'dns-packet'
+import { SERVICE_TAG_LOCAL } from './constants.js'
+
+const log = logger('libp2p:mdns:compat:utils')
+
+export function findPeerDataInAnswers (answers: Answer[], ourPeerId: PeerId): PeerData | undefined {
+  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.trace('got response', SERVICE_TAG_LOCAL)
+
+  const txtRecord = answers.find(a => a.type === 'TXT')
+  if (txtRecord == null || txtRecord.type !== 'TXT') {
+    log('missing TXT record in response')
+    return
+  }
+
+  let peerIdStr: string
+  try {
+    peerIdStr = txtRecord.data[0].toString()
+  } catch (err) {
+    log('failed to extract peer ID from TXT record data', txtRecord, err)
+    return
+  }
+
+  let peerId: PeerId
+  try {
+    peerId = peerIdFromString(peerIdStr)
+  } catch (err) {
+    log('failed to create peer ID from TXT record data', peerIdStr, err)
+    return
+  }
+
+  if (ourPeerId.equals(peerId)) {
+    log('ignoring reply to myself')
+    return
+  }
+
+  const multiaddrs: Multiaddr[] = []
+  const hosts: { A: Record<string, string>, AAAA: Record<string, string> } = {
+    A: {},
+    AAAA: {}
+  }
+
+  answers.forEach(answer => {
+    if (answer.type === 'A') {
+      hosts.A[answer.name] = answer.data
+    }
+
+    if (answer.type === 'AAAA') {
+      hosts.AAAA[answer.name] = answer.data
+    }
+  })
+
+  answers.forEach(answer => {
+    if (answer.type === 'SRV') {
+      if (hosts.A[answer.data.target] != null) {
+        multiaddrs.push(new Multiaddr(`/ip4/${hosts.A[answer.data.target]}/tcp/${answer.data.port}/p2p/${peerId.toString()}`))
+      } else if (hosts.AAAA[answer.data.target] != null) {
+        multiaddrs.push(new Multiaddr(`/ip6/${hosts.AAAA[answer.data.target]}/tcp/${answer.data.port}/p2p/${peerId.toString()}`))
+      } else {
+        multiaddrs.push(new Multiaddr(`/dnsaddr/${answer.data.target}/tcp/${answer.data.port}/p2p/${peerId.toString()}`))
+      }
+    }
+  })
+
+  return {
+    id: peerId,
+    multiaddrs,
+    protocols: []
+  }
+}

package/src/index.ts

@@ -1,30 +1,25 @@
 import multicastDNS from 'multicast-dns'
-import { EventEmitter } from 'events'
-import debug from 'debug'
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces'
+import { logger } from '@libp2p/logger'
 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 { PeerDiscovery, PeerDiscoveryEvents } from '@libp2p/interfaces/peer-discovery'
 import type { PeerData } from '@libp2p/interfaces/peer-data'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
-const log = Object.assign(debug('libp2p:mdns'), {
-  error: debug('libp2p:mdns:error')
-})
+const log = logger('libp2p:mdns')
 
 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 {
+export class MulticastDNS extends EventEmitter<PeerDiscoveryEvents> implements PeerDiscovery, Initializable {
   static tag = 'mdns'
 
   public mdns?: multicastDNS.MulticastDNS
@@ -33,24 +28,17 @@ export class MulticastDNS extends EventEmitter implements PeerDiscovery {
   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 _queryInterval: ReturnType<typeof setInterval> | null
   private readonly _goMdns?: GoMulticastDNS
+  private components: Components = new Components()
 
-  constructor (options: MulticastDNSOptions) {
+  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)
@@ -58,15 +46,19 @@ export class MulticastDNS extends EventEmitter implements PeerDiscovery {
 
     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)
+      this._goMdns.addEventListener('peer', this._onPeer)
     }
   }
 
+  init (components: Components): void {
+    this.components = components
+
+    this._goMdns?.init(components)
+  }
+
   isStarted () {
     return Boolean(this.mdns)
   }
@@ -97,23 +89,36 @@ export class MulticastDNS extends EventEmitter implements PeerDiscovery {
       return
     }
 
-    query.gotQuery(event, this.mdns, this.peerId, this.peerMultiaddrs, this.serviceTag, this.broadcast)
+    log.trace('received incoming mDNS query')
+    query.gotQuery(event, this.mdns, this.components.getPeerId(), this.components.getAddressManager().getAddresses(), this.serviceTag, this.broadcast)
   }
 
   _onMdnsResponse (event: multicastDNS.ResponsePacket) {
+    log.trace('received mDNS query response')
+
     try {
-      const foundPeer = query.gotResponse(event, this.peerId, this.serviceTag)
+      const foundPeer = query.gotResponse(event, this.components.getPeerId(), this.serviceTag)
 
       if (foundPeer != null) {
-        this.emit('peer', foundPeer)
+        log('discovered peer in mDNS qeury response %p', foundPeer.id)
+
+        this.dispatchEvent(new CustomEvent<PeerData>('peer', {
+          detail: foundPeer
+        }))
       }
     } catch (err) {
-      log('Error processing peer response', err)
+      log.error('Error processing peer response', err)
     }
   }
 
-  _onPeer (peerData: PeerData) {
-    (this.mdns != null) && this.emit('peer', peerData)
+  _onPeer (evt: CustomEvent<PeerData>) {
+    if (this.mdns == null) {
+      return
+    }
+
+    this.dispatchEvent(new CustomEvent<PeerData>('peer', {
+      detail: evt.detail
+    }))
   }
 
   /**
@@ -128,7 +133,7 @@ export class MulticastDNS extends EventEmitter implements PeerDiscovery {
 
     this.mdns.removeListener('query', this._onMdnsQuery)
     this.mdns.removeListener('response', this._onMdnsResponse)
-    this._goMdns?.removeListener('peer', this._onPeer)
+    this._goMdns?.removeEventListener('peer', this._onPeer)
 
     if (this._queryInterval != null) {
       clearInterval(this._queryInterval)

package/src/query.ts

@@ -1,19 +1,18 @@
 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 { logger } from '@libp2p/logger'
+import { Multiaddr, MultiaddrObject, protocols } from '@multiformats/multiaddr'
+import { peerIdFromString } from '@libp2p/peer-id'
+import type { PeerId } from '@libp2p/interfaces/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')
-})
+const log = logger('libp2p:mdns:query')
 
 export function queryLAN (mdns: MulticastDNS, serviceTag: string, interval: number) {
   const query = () => {
     log('query', serviceTag)
+
     mdns.query({
       questions: [{
         name: serviceTag,
@@ -83,14 +82,16 @@ export function gotResponse (rsp: ResponsePacket, localPeerId: PeerId, serviceTa
     }
   })
 
-  if (localPeerId.toString(base58btc) === b58Id) {
+  if (localPeerId.toString() === b58Id) {
     return // replied to myself, ignore
   }
 
-  log('peer found -', b58Id)
+  const id = peerIdFromString(b58Id)
+
+  log('peer found %p', id)
 
   return {
-    id: PeerId.fromString(b58Id),
+    id,
     multiaddrs,
     protocols: []
   }
@@ -98,11 +99,12 @@ export function gotResponse (rsp: ResponsePacket, localPeerId: PeerId, serviceTa
 
 export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerId: PeerId, multiaddrs: Multiaddr[], serviceTag: string, broadcast: boolean) {
   if (!broadcast) {
+    log('not responding to mDNS query as broadcast mode is false')
     return
   }
 
   const addresses: MultiaddrObject[] = multiaddrs.reduce<MultiaddrObject[]>((acc, addr) => {
-    if (addr.isThinWaistAddress()) {
+    if (addr.decapsulateCode(protocols('p2p').code).isThinWaistAddress()) {
       acc.push(addr.toOptions())
     }
     return acc
@@ -110,6 +112,7 @@ export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerId: PeerId,
 
   // Only announce TCP for now
   if (addresses.length === 0) {
+    log('no thin waist addresses present, cannot respond to query')
     return
   }
 
@@ -121,14 +124,14 @@ export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerId: PeerId,
       type: 'PTR',
       class: 'IN',
       ttl: 120,
-      data: peerId.toString(base58btc) + '.' + serviceTag
+      data: peerId.toString() + '.' + serviceTag
     })
 
     // Only announce TCP multiaddrs for now
     const port = addresses[0].port
 
     answers.push({
-      name: peerId.toString(base58btc) + '.' + serviceTag,
+      name: peerId.toString() + '.' + serviceTag,
       type: 'SRV',
       class: 'IN',
       ttl: 120,
@@ -141,11 +144,11 @@ export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerId: PeerId,
     })
 
     answers.push({
-      name: peerId.toString(base58btc) + '.' + serviceTag,
+      name: peerId.toString() + '.' + serviceTag,
       type: 'TXT',
       class: 'IN',
       ttl: 120,
-      data: peerId.toString(base58btc)
+      data: peerId.toString()
     })
 
     addresses.forEach((addr) => {