@libp2p/mdns 9.0.13 → 9.0.14-97ab31c0c

package/src/mdns.ts

@@ -0,0 +1,166 @@
+import { CustomEvent, EventEmitter } from '@libp2p/interface/events'
+import { peerDiscovery } from '@libp2p/interface/peer-discovery'
+import multicastDNS from 'multicast-dns'
+import * as query from './query.js'
+import { stringGen } from './utils.js'
+import type { ComponentLogger, Logger } from '@libp2p/interface'
+import type { PeerDiscovery, PeerDiscoveryEvents } from '@libp2p/interface/peer-discovery'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { Startable } from '@libp2p/interface/src/startable.js'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+
+export interface MulticastDNSInit {
+  broadcast?: boolean
+  interval?: number
+  serviceTag?: string
+  peerName?: string
+  port?: number
+  ip?: string
+}
+
+export interface MulticastDNSComponents {
+  addressManager: AddressManager
+  logger: ComponentLogger
+}
+
+export class MulticastDNS extends EventEmitter<PeerDiscoveryEvents> implements PeerDiscovery, Startable {
+  public mdns?: multicastDNS.MulticastDNS
+
+  private readonly log: Logger
+  private readonly broadcast: boolean
+  private readonly interval: number
+  private readonly serviceTag: string
+  private readonly peerName: string
+  private readonly port: number
+  private readonly ip: string
+  private _queryInterval: ReturnType<typeof setInterval> | null
+  private readonly components: MulticastDNSComponents
+
+  constructor (components: MulticastDNSComponents, init: MulticastDNSInit = {}) {
+    super()
+
+    this.log = components.logger.forComponent('libp2p:mdns')
+    this.broadcast = init.broadcast !== false
+    this.interval = init.interval ?? (1e3 * 10)
+    this.serviceTag = init.serviceTag ?? '_p2p._udp.local'
+    this.ip = init.ip ?? '224.0.0.251'
+    this.peerName = init.peerName ?? stringGen(63)
+    // 63 is dns label limit
+    if (this.peerName.length >= 64) {
+      throw new Error('Peer name should be less than 64 chars long')
+    }
+    this.port = init.port ?? 5353
+    this.components = components
+    this._queryInterval = null
+    this._onMdnsQuery = this._onMdnsQuery.bind(this)
+    this._onMdnsResponse = this._onMdnsResponse.bind(this)
+    this._onMdnsWarning = this._onMdnsWarning.bind(this)
+    this._onMdnsError = this._onMdnsError.bind(this)
+  }
+
+  readonly [peerDiscovery] = this
+
+  readonly [Symbol.toStringTag] = '@libp2p/mdns'
+
+  isStarted (): boolean {
+    return Boolean(this.mdns)
+  }
+
+  /**
+   * Start sending queries to the LAN.
+   *
+   * @returns {void}
+   */
+  async start (): Promise<void> {
+    if (this.mdns != null) {
+      return
+    }
+
+    this.mdns = multicastDNS({ port: this.port, ip: this.ip })
+    this.mdns.on('query', this._onMdnsQuery)
+    this.mdns.on('response', this._onMdnsResponse)
+    this.mdns.on('warning', this._onMdnsWarning)
+    this.mdns.on('error', this._onMdnsError)
+
+    this._queryInterval = query.queryLAN(this.mdns, this.serviceTag, this.interval, {
+      log: this.log
+    })
+  }
+
+  _onMdnsQuery (event: multicastDNS.QueryPacket): void {
+    if (this.mdns == null) {
+      return
+    }
+
+    this.log.trace('received incoming mDNS query')
+    query.gotQuery(
+      event,
+      this.mdns,
+      this.peerName,
+      this.components.addressManager.getAddresses(),
+      this.serviceTag,
+      this.broadcast, {
+        log: this.log
+      }
+    )
+  }
+
+  _onMdnsResponse (event: multicastDNS.ResponsePacket): void {
+    this.log.trace('received mDNS query response')
+
+    try {
+      const foundPeer = query.gotResponse(event, this.peerName, this.serviceTag, {
+        log: this.log
+      })
+
+      if (foundPeer != null) {
+        this.log('discovered peer in mDNS query response %p', foundPeer.id)
+
+        this.dispatchEvent(new CustomEvent<PeerInfo>('peer', {
+          detail: foundPeer
+        }))
+      }
+    } catch (err) {
+      this.log.error('Error processing peer response', err)
+    }
+  }
+
+  _onMdnsWarning (err: Error): void {
+    this.log.error('mdns warning', err)
+  }
+
+  _onMdnsError (err: Error): void {
+    this.log.error('mdns error', err)
+  }
+
+  /**
+   * Stop sending queries to the LAN.
+   *
+   * @returns {Promise}
+   */
+  async stop (): Promise<void> {
+    if (this.mdns == null) {
+      return
+    }
+
+    this.mdns.removeListener('query', this._onMdnsQuery)
+    this.mdns.removeListener('response', this._onMdnsResponse)
+    this.mdns.removeListener('warning', this._onMdnsWarning)
+    this.mdns.removeListener('error', this._onMdnsError)
+
+    if (this._queryInterval != null) {
+      clearInterval(this._queryInterval)
+      this._queryInterval = null
+    }
+
+    await new Promise<void>((resolve) => {
+      if (this.mdns != null) {
+        this.mdns.destroy(resolve)
+      } else {
+        resolve()
+      }
+    })
+
+    this.mdns = undefined
+  }
+}

package/src/query.ts

@@ -1,16 +1,14 @@
-import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
 import { multiaddr, type Multiaddr, protocols } from '@multiformats/multiaddr'
+import type { LoggerOptions } from '@libp2p/interface'
 import type { PeerInfo } from '@libp2p/interface/peer-info'
 import type { Answer, StringAnswer, TxtAnswer } from 'dns-packet'
 import type { MulticastDNS, QueryPacket, ResponsePacket } from 'multicast-dns'
 
-const log = logger('libp2p:mdns:query')
-
-export function queryLAN (mdns: MulticastDNS, serviceTag: string, interval: number): ReturnType<typeof setInterval> {
+export function queryLAN (mdns: MulticastDNS, serviceTag: string, interval: number, options?: LoggerOptions): ReturnType<typeof setInterval> {
   const query = (): void => {
-    log.trace('query', serviceTag)
+    options?.log.trace('query', serviceTag)
 
     mdns.query({
       questions: [{
@@ -25,7 +23,7 @@ export function queryLAN (mdns: MulticastDNS, serviceTag: string, interval: numb
   return setInterval(query, interval)
 }
 
-export function gotResponse (rsp: ResponsePacket, localPeerName: string, serviceTag: string): PeerInfo | undefined {
+export function gotResponse (rsp: ResponsePacket, localPeerName: string, serviceTag: string, options?: LoggerOptions): PeerInfo | undefined {
   if (rsp.answers == null) {
     return
   }
@@ -70,21 +68,20 @@ export function gotResponse (rsp: ResponsePacket, localPeerName: string, service
     if (peerId == null) {
       throw new Error("Multiaddr doesn't contain PeerId")
     }
-    log('peer found %p', peerId)
+    options?.log('peer found %p', peerId)
 
     return {
       id: peerIdFromString(peerId),
-      multiaddrs: multiaddrs.map(addr => addr.decapsulateCode(protocols('p2p').code)),
-      protocols: []
+      multiaddrs: multiaddrs.map(addr => addr.decapsulateCode(protocols('p2p').code))
     }
   } catch (e) {
-    log.error('failed to parse mdns response', e)
+    options?.log.error('failed to parse mdns response', e)
   }
 }
 
-export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerName: string, multiaddrs: Multiaddr[], serviceTag: string, broadcast: boolean): void {
+export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerName: string, multiaddrs: Multiaddr[], serviceTag: string, broadcast: boolean, options?: LoggerOptions): void {
   if (!broadcast) {
-    log('not responding to mDNS query as broadcast mode is false')
+    options?.log('not responding to mDNS query as broadcast mode is false')
     return
   }
 
@@ -113,13 +110,13 @@ export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerName: string
         // TXT record fields have a max data length of 255 bytes
         // see 6.1 - https://www.ietf.org/rfc/rfc6763.txt
         if (data.length > 255) {
-          log('multiaddr %a is too long to use in mDNS query response', addr)
+          options?.log('multiaddr %a is too long to use in mDNS query response', addr)
           return
         }
 
         // spec mandates multiaddr contains peer id
         if (addr.getPeerId() == null) {
-          log('multiaddr %a did not have a peer ID so cannot be used in mDNS query response', addr)
+          options?.log('multiaddr %a did not have a peer ID so cannot be used in mDNS query response', addr)
           return
         }
 
@@ -132,7 +129,7 @@ export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerName: string
         })
       })
 
-    log.trace('responding to query')
+    options?.log.trace('responding to query')
     mdns.respond(answers)
   }
 }

package/dist/typedoc-urls.json

@@ -1,8 +0,0 @@
-{
-  "MulticastDNSComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_mdns.MulticastDNSComponents.html",
-  ".:MulticastDNSComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_mdns.MulticastDNSComponents.html",
-  "MulticastDNSInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_mdns.MulticastDNSInit.html",
-  ".:MulticastDNSInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_mdns.MulticastDNSInit.html",
-  "mdns": "https://libp2p.github.io/js-libp2p/functions/_libp2p_mdns.mdns.html",
-  ".:mdns": "https://libp2p.github.io/js-libp2p/functions/_libp2p_mdns.mdns.html"
-}