3073005646

Build Type

github

Committed by GitHub

Commit Message

Merge 1cd69df8e into e0e148363

Pull Request Pull Request #970: Register listener on the listener to detect Avahi deamon restarts

Run Details

1326 of 3537 branches covered (37.49%)

Branch coverage included in aggregate %.

9 of 27 new or added lines in 1 file covered. (33.33%)

1 existing line in 1 file now uncovered.

5728 of 10122 relevant lines covered (56.59%)

65.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.67

/src/lib/Advertiser.ts

// eslint-disable-next-line @typescript-eslint/triple-slash-reference
/// <reference path="../../@types/bonjour-hap.d.ts" />
import ciao, {
  CiaoService,
  MDNSServerOptions,
  Responder,
  ServiceEvent,
  ServiceTxt,
  ServiceType,
} from "@homebridge/ciao";
import { InterfaceName, IPAddress } from "@homebridge/ciao/lib/NetworkManager";
import assert from "assert";
import bonjour, { BonjourHAP, BonjourHAPService, MulticastOptions } from "bonjour-hap";
import crypto from "crypto";
import createDebug from "debug";
import dbus, { DBusInterface, MessageBus } from "@homebridge/dbus-native";
import { EventEmitter } from "events";
import { AccessoryInfo } from "./model/AccessoryInfo";
import { PromiseTimeout } from "./util/promise-utils";

const debug = createDebug("HAP-NodeJS:Advertiser");

/**
 * This enum lists all bitmasks for all known status flags.
 * When the bit for the given bitmask is set, it represents the state described by the name.
 */
export const enum StatusFlag {
  NOT_PAIRED = 0x01,
  NOT_JOINED_WIFI = 0x02,
  PROBLEM_DETECTED = 0x04,
}

/**
 * This enum lists all bitmasks for all known pairing feature flags.
 * When the bit for the given bitmask is set, it represents the state described by the name.
 */
export const enum PairingFeatureFlag {
  SUPPORTS_HARDWARE_AUTHENTICATION = 0x01,
  SUPPORTS_SOFTWARE_AUTHENTICATION = 0x02,
}

export const enum AdvertiserEvent {
  UPDATED_NAME = "updated-name",
}

export declare interface Advertiser {
  on(event: "updated-name", listener: (name: string) => void): this;

  emit(event: "updated-name", name: string): boolean;
}

export interface ServiceNetworkOptions {
  /**
   * If defined it restricts the service to be advertised on the specified
   * ip addresses or interface names.
   *
   * If an interface name is specified, ANY address on that given interface will be advertised
   * (if an IP address of the given interface is also given in the array, it will be overridden).
   * If an IP address is specified, the service will only be advertised for the given addresses.
   *
   * Interface names and addresses can be mixed in the array.
   * If an ip address is given, the ip address must be valid at the time of service creation.
   *
   * If the service is set to advertise on a given interface, though the MDNSServer is
   * configured to ignore this interface, the service won't be advertised on the interface.
   */
  restrictedAddresses?: (InterfaceName | IPAddress)[];
  /**
   * The service won't advertise ipv6 address records.
   * This can be used to simulate binding on 0.0.0.0.
   * May be combined with {@link restrictedAddresses}.
   */
  disabledIpv6?: boolean;
}

export interface Advertiser {

  initPort(port: number): void;

  startAdvertising(): Promise<void>;

  updateAdvertisement(silent?: boolean): void;

  destroy(): void;

}

/**
 * Advertiser uses mdns to broadcast the presence of an Accessory to the local network.
 *
 * Note that as of iOS 9, an accessory can only pair with a single client. Instead of pairing your
 * accessories with multiple iOS devices in your home, Apple intends for you to use Home Sharing.
 * To support this requirement, we provide the ability to be "discoverable" or not (via a "service flag" on the
 * mdns payload).
 */
export class CiaoAdvertiser extends EventEmitter implements Advertiser {

  static protocolVersion = "1.1";
  static protocolVersionService = "1.1.0";

  private readonly accessoryInfo: AccessoryInfo;
  private readonly setupHash: string;

  private readonly responder: Responder;
  private readonly advertisedService: CiaoService;

  constructor(accessoryInfo: AccessoryInfo, responderOptions?: MDNSServerOptions, serviceOptions?: ServiceNetworkOptions) {
    super();
    this.accessoryInfo = accessoryInfo;
    this.setupHash = CiaoAdvertiser.computeSetupHash(accessoryInfo);

    this.responder = ciao.getResponder({
      ...responderOptions,
    });
    this.advertisedService = this.responder.createService({
      name: this.accessoryInfo.displayName,
      type: ServiceType.HAP,
      txt: CiaoAdvertiser.createTxt(accessoryInfo, this.setupHash),
      // host will default now to <displayName>.local, spaces replaced with dashes
      ...serviceOptions,
    });
    this.advertisedService.on(ServiceEvent.NAME_CHANGED, this.emit.bind(this, AdvertiserEvent.UPDATED_NAME));

    debug(`Preparing Advertiser for '${this.accessoryInfo.displayName}' using ciao backend!`);
  }

  public initPort(port: number): void {
    this.advertisedService.updatePort(port);
  }

  public startAdvertising(): Promise<void> {
    debug(`Starting to advertise '${this.accessoryInfo.displayName}' using ciao backend!`);
    return this.advertisedService!.advertise();
  }

  public updateAdvertisement(silent?: boolean): void {
    const txt = CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash);
    debug("Updating txt record (txt: %o, silent: %d)", txt, silent);
    this.advertisedService!.updateTxt(txt, silent);
  }

  public async destroy(): Promise<void> {
    // advertisedService.destroy(); is called implicitly via the shutdown call
    await this.responder.shutdown();
    this.removeAllListeners();
  }

  static createTxt(accessoryInfo: AccessoryInfo, setupHash: string): ServiceTxt {
    const statusFlags: StatusFlag[] = [];

    if (!accessoryInfo.paired()) {
      statusFlags.push(StatusFlag.NOT_PAIRED);
    }

    return {
      "c#": accessoryInfo.getConfigVersion(), // current configuration number
      ff: CiaoAdvertiser.ff(), // pairing feature flags
      id: accessoryInfo.username, // device id
      md: accessoryInfo.model, // model name
      pv: CiaoAdvertiser.protocolVersion, // protocol version
      "s#": 1, // current state number (must be 1)
      sf: CiaoAdvertiser.sf(...statusFlags), // status flags
      ci: accessoryInfo.category,
      sh: setupHash,
    };
  }

  static computeSetupHash(accessoryInfo: AccessoryInfo): string {
    const hash = crypto.createHash("sha512");
    hash.update(accessoryInfo.setupID + accessoryInfo.username.toUpperCase());
    return hash.digest().slice(0, 4).toString("base64");
  }

  public static ff(...flags: PairingFeatureFlag[]): number {
    let value = 0;
    flags.forEach(flag => value |= flag);
    return value;
  }

  public static sf(...flags: StatusFlag[]): number {
    let value = 0;
    flags.forEach(flag => value |= flag);
    return value;
  }

}

/**
 * Advertiser base on the legacy "bonjour-hap" library.
 */
export class BonjourHAPAdvertiser extends EventEmitter implements Advertiser {

  private readonly accessoryInfo: AccessoryInfo;
  private readonly setupHash: string;
  private readonly serviceOptions?: ServiceNetworkOptions;

  private bonjour: BonjourHAP;
  private advertisement?: BonjourHAPService;

  private port?: number;
  private destroyed = false;

  constructor(accessoryInfo: AccessoryInfo, responderOptions?: MulticastOptions, serviceOptions?: ServiceNetworkOptions) {
    super();
    this.accessoryInfo = accessoryInfo;
    this.setupHash = CiaoAdvertiser.computeSetupHash(accessoryInfo);
    this.serviceOptions = serviceOptions;

    this.bonjour = bonjour(responderOptions);
    debug(`Preparing Advertiser for '${this.accessoryInfo.displayName}' using bonjour-hap backend!`);
  }

  public initPort(port: number): void {
    this.port = port;
  }

  public startAdvertising(): Promise<void> {
    assert(!this.destroyed, "Can't advertise on a destroyed bonjour instance!");
    if (this.port == null) {
      throw new Error("Tried starting bonjour-hap advertisement without initializing port!");
    }

    debug(`Starting to advertise '${this.accessoryInfo.displayName}' using bonjour-hap backend!`);

    if (this.advertisement) {
      this.destroy();
    }

    const hostname = this.accessoryInfo.username.replace(/:/ig, "_") + ".local";

    this.advertisement = this.bonjour.publish({
      name: this.accessoryInfo.displayName,
      type: "hap",
      port: this.port,
      txt: CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash),
      host: hostname,
      addUnsafeServiceEnumerationRecord: true,
      ...this.serviceOptions,
    });

    return PromiseTimeout(1);
  }

  public updateAdvertisement(silent?: boolean): void {
    const txt = CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash);
    debug("Updating txt record (txt: %o, silent: %d)", txt, silent);

    if (this.advertisement) {
      this.advertisement.updateTxt(txt, silent);
    }
  }

  public destroy(): void {
    if (this.advertisement) {
      this.advertisement.stop(() => {
        this.advertisement!.destroy();
        this.advertisement = undefined;
        this.bonjour.destroy();
      });
    } else {
      this.bonjour.destroy();
    }
  }

}

/**
 * AvahiServerState. Refer to https://github.com/lathiat/avahi/blob/fd482a74625b8db8547b8cfca3ee3d3c6c721423/avahi-common/defs.h#L220-L227.
 */
const enum AvahiServerState {
  // noinspection JSUnusedGlobalSymbols
  INVALID = 0,
  REGISTERING,
  RUNNING,
  COLLISION,
  FAILURE
}

/**
 * Advertiser based on the Avahi D-Bus library.
 * For (very crappy) docs on the interface, see the XML files at: https://github.com/lathiat/avahi/tree/master/avahi-daemon.
 *
 * Refer to https://github.com/lathiat/avahi/blob/fd482a74625b8db8547b8cfca3ee3d3c6c721423/avahi-common/defs.h#L120-L155 for a
 * rough API usage guide of Avahi.
 */
export class AvahiAdvertiser extends EventEmitter implements Advertiser {
  private readonly accessoryInfo: AccessoryInfo;
  private readonly setupHash: string;

  private port?: number;

  private bus?: MessageBus;
  private avahiServerInterface?: DBusInterface;
  private path?: string;

  private readonly stateChangeHandler: (state: AvahiServerState) => void;

  constructor(accessoryInfo: AccessoryInfo) {
    super();
    this.accessoryInfo = accessoryInfo;
    this.setupHash = CiaoAdvertiser.computeSetupHash(accessoryInfo);

    debug(`Preparing Advertiser for '${this.accessoryInfo.displayName}' using Avahi backend!`);

    this.bus = dbus.systemBus();

    this.stateChangeHandler = this.handleStateChangedEvent.bind(this);
  }

  private createTxt(): Array<Buffer> {
    return Object
      .entries(CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash))
      .map((el: Array<string>) => Buffer.from(el[0] + "=" + el[1]));
  }

  public initPort(port: number): void {
    this.port = port;
  }

  public async startAdvertising(): Promise<void> {
    if (this.port == null) {
      throw new Error("Tried starting Avahi advertisement without initializing port!");
    }
    if (!this.bus) {
      throw new Error("Tried to start Avahi advertisement on a destroyed advertiser!");
    }

    debug(`Starting to advertise '${this.accessoryInfo.displayName}' using Avahi backend!`);

    if (!this.avahiServerInterface) {
      this.avahiServerInterface = await AvahiAdvertiser.avahiInterface(this.bus, "Server");
      this.avahiServerInterface.on("StateChanged", this.stateChangeHandler);
    }

    this.path = await AvahiAdvertiser.avahiInvoke(this.bus, "/", "Server", "EntryGroupNew") as string;
    await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "AddService", {
      body: [
        -1, // interface
        -1, // protocol
        0, // flags
        this.accessoryInfo.displayName, // name
        "_hap._tcp", // type
        "", // domain
        "", // host
        this.port, // port
        this.createTxt(), // txt
      ],
      signature: "iiussssqaay",
    });
    await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "Commit");
  }

  private handleStateChangedEvent(state: AvahiServerState): void {
    if (state === AvahiServerState.RUNNING && this.path) {
      debug("Found Avahi daemon to have restarted!");
      this.startAdvertising()
        .catch(reason => console.error("Could not (re-)create mDNS advertisement. The HAP-Server won't be discoverable: " + reason));
    }
  }

  public async updateAdvertisement(silent?: boolean): Promise<void> {
    if (!this.bus) {
      throw new Error("Tried to update Avahi advertisement on a destroyed advertiser!");
    }
    if (!this.path) {
      debug("Tried to update advertisement without a valid `path`!");
      return;
    }

    debug("Updating txt record (txt: %o, silent: %d)", CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash), silent);

    try {
      await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "UpdateServiceTxt", {
        body: [-1, -1, 0, this.accessoryInfo.displayName, "_hap._tcp", "", this.createTxt()],
        signature: "iiusssaay",
      });
    } catch (error) {
      console.error("Failed to update avahi advertisement: " + error);
    }
  }

  public async destroy(): Promise<void> {
    if (!this.bus) {
      throw new Error("Tried to destroy Avahi advertisement on a destroyed advertiser!");
    }

    if (this.path) {
      try {
        await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "Free");
      } catch (error) {
        // Typically, this fails if e.g. avahi service was stopped in the meantime.
        debug("Destroying Avahi advertisement failed: " + error);
      }
      this.path = undefined;
    }

    if (this.avahiServerInterface) {
      this.avahiServerInterface.removeListener("StateChanged", this.stateChangeHandler);
      this.avahiServerInterface = undefined;
    }

    this.bus.connection.stream.destroy();
    this.bus = undefined;
  }

  public static async isAvailable(): Promise<boolean> {
    const bus = dbus.systemBus();

    try {
      try {
        await this.messageBusConnectionResult(bus);
      } catch (error) {
        debug("Avahi/DBus classified unavailable due to missing dbus interface!");
        return false;
      }

      try {
        const version = await this.avahiInvoke(bus, "/", "Server", "GetVersionString");
        debug("Detected Avahi over DBus interface running version '%s'.", version);
      } catch (error) {
        debug("Avahi/DBus classified unavailable due to missing avahi interface!");
        return false;
      }

      return true;
    } finally {
      bus.connection.stream.destroy();
    }
  }

  private static messageBusConnectionResult(bus: MessageBus): Promise<void> {
    return new Promise((resolve, reject) => {
      const errorHandler = (error: Error) => {
        // eslint-disable-next-line @typescript-eslint/no-use-before-define
        bus.connection.removeListener("connect", connectHandler);
        reject(error);
      };
      const connectHandler = () => {
        bus.connection.removeListener("error", errorHandler);
        resolve();
      };

      bus.connection.once("connect", connectHandler);
      bus.connection.once("error", errorHandler);
    });
  }

  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  private static avahiInvoke(bus: MessageBus, path: string, dbusInterface: string, member: string, others?: any): Promise<any> {
    return new Promise((resolve, reject) => {
      const command = {
        destination: "org.freedesktop.Avahi",
        path,
        interface: "org.freedesktop.Avahi." + dbusInterface,
        member,
        ...(others || {}),
      };
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      bus.invoke(command, (err: any, result: any) => {
        if (err) {
          reject(new Error(`avahiInvoke error: ${JSON.stringify(err)}`));
        } else {
          resolve(result);
        }
      });
    });
  }

  private static avahiInterface(bus: MessageBus, dbusInterface: string): Promise<DBusInterface> {
    return new Promise((resolve, reject) => {
      bus
        .getService("org.freedesktop.Avahi")
        .getInterface("/", "org.freedesktop.Avahi." + dbusInterface, (error, iface) => {
          if (error || !iface) {
            reject(error ?? new Error("Interface not present!"));
          } else {
            resolve(iface);
          }
        });
    });
  }
}

1	// eslint-disable-next-line @typescript-eslint/triple-slash-reference
2	/// <reference path="../../@types/bonjour-hap.d.ts" />
3	import ciao, {	15✔
4	CiaoService,
5	MDNSServerOptions,
6	Responder,
7	ServiceEvent,
8	ServiceTxt,
9	ServiceType,
10	} from "@homebridge/ciao";
11	import { InterfaceName, IPAddress } from "@homebridge/ciao/lib/NetworkManager";
12	import assert from "assert";	15✔
13	import bonjour, { BonjourHAP, BonjourHAPService, MulticastOptions } from "bonjour-hap";	15✔
14	import crypto from "crypto";	15✔
15	import createDebug from "debug";	15✔
16	import dbus, { DBusInterface, MessageBus } from "@homebridge/dbus-native";	15✔
17	import { EventEmitter } from "events";	15✔
18	import { AccessoryInfo } from "./model/AccessoryInfo";
19	import { PromiseTimeout } from "./util/promise-utils";	15✔
20
21	const debug = createDebug("HAP-NodeJS:Advertiser");	15✔
22
23	/**
24	* This enum lists all bitmasks for all known status flags.
25	* When the bit for the given bitmask is set, it represents the state described by the name.
26	*/
27	export const enum StatusFlag {	15✔
28	NOT_PAIRED = 0x01,	15✔
29	NOT_JOINED_WIFI = 0x02,	15✔
30	PROBLEM_DETECTED = 0x04,	15✔
31	}
32
33	/**
34	* This enum lists all bitmasks for all known pairing feature flags.
35	* When the bit for the given bitmask is set, it represents the state described by the name.
36	*/
37	export const enum PairingFeatureFlag {	15✔
38	SUPPORTS_HARDWARE_AUTHENTICATION = 0x01,	15✔
39	SUPPORTS_SOFTWARE_AUTHENTICATION = 0x02,	15✔
40	}
41
42	export const enum AdvertiserEvent {	15✔
43	UPDATED_NAME = "updated-name",	15✔
44	}
45
46	export declare interface Advertiser {
47	on(event: "updated-name", listener: (name: string) => void): this;
48
49	emit(event: "updated-name", name: string): boolean;
50	}
51
52	export interface ServiceNetworkOptions {
53	/**
54	* If defined it restricts the service to be advertised on the specified
55	* ip addresses or interface names.
56	*
57	* If an interface name is specified, ANY address on that given interface will be advertised
58	* (if an IP address of the given interface is also given in the array, it will be overridden).
59	* If an IP address is specified, the service will only be advertised for the given addresses.
60	*
61	* Interface names and addresses can be mixed in the array.
62	* If an ip address is given, the ip address must be valid at the time of service creation.
63	*
64	* If the service is set to advertise on a given interface, though the MDNSServer is
65	* configured to ignore this interface, the service won't be advertised on the interface.
66	*/
67	restrictedAddresses?: (InterfaceName \| IPAddress)[];
68	/**
69	* The service won't advertise ipv6 address records.
70	* This can be used to simulate binding on 0.0.0.0.
71	* May be combined with {@link restrictedAddresses}.
72	*/
73	disabledIpv6?: boolean;
74	}
75
76	export interface Advertiser {
77
78	initPort(port: number): void;
79
80	startAdvertising(): Promise<void>;
81
82	updateAdvertisement(silent?: boolean): void;
83
84	destroy(): void;
85
86	}
87
88	/**
89	* Advertiser uses mdns to broadcast the presence of an Accessory to the local network.
90	*
91	* Note that as of iOS 9, an accessory can only pair with a single client. Instead of pairing your
92	* accessories with multiple iOS devices in your home, Apple intends for you to use Home Sharing.
93	* To support this requirement, we provide the ability to be "discoverable" or not (via a "service flag" on the
94	* mdns payload).
95	*/
96	export class CiaoAdvertiser extends EventEmitter implements Advertiser {	15✔
97
98	static protocolVersion = "1.1";	15✔
99	static protocolVersionService = "1.1.0";	15✔
100
101	private readonly accessoryInfo: AccessoryInfo;
102	private readonly setupHash: string;
103
104	private readonly responder: Responder;
105	private readonly advertisedService: CiaoService;
106
107	constructor(accessoryInfo: AccessoryInfo, responderOptions?: MDNSServerOptions, serviceOptions?: ServiceNetworkOptions) {
108	super();	9✔
109	this.accessoryInfo = accessoryInfo;	9✔
110	this.setupHash = CiaoAdvertiser.computeSetupHash(accessoryInfo);	9✔
111
112	this.responder = ciao.getResponder({	9✔
113	...responderOptions,
114	});
115	this.advertisedService = this.responder.createService({	9✔
116	name: this.accessoryInfo.displayName,
117	type: ServiceType.HAP,
118	txt: CiaoAdvertiser.createTxt(accessoryInfo, this.setupHash),
119	// host will default now to <displayName>.local, spaces replaced with dashes
120	...serviceOptions,
121	});
122	this.advertisedService.on(ServiceEvent.NAME_CHANGED, this.emit.bind(this, AdvertiserEvent.UPDATED_NAME));	9✔
123
124	debug(`Preparing Advertiser for '${this.accessoryInfo.displayName}' using ciao backend!`);	9✔
125	}
126
127	public initPort(port: number): void {	15✔
128	this.advertisedService.updatePort(port);	9✔
129	}
130
131	public startAdvertising(): Promise<void> {	15✔
132	debug(`Starting to advertise '${this.accessoryInfo.displayName}' using ciao backend!`);	9✔
133	return this.advertisedService!.advertise();	9✔
134	}
135
136	public updateAdvertisement(silent?: boolean): void {	15✔
137	const txt = CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash);	×
138	debug("Updating txt record (txt: %o, silent: %d)", txt, silent);	×
139	this.advertisedService!.updateTxt(txt, silent);	×
140	}
141
142	public async destroy(): Promise<void> {	15✔
143	// advertisedService.destroy(); is called implicitly via the shutdown call
144	await this.responder.shutdown();	18✔
145	this.removeAllListeners();	9✔
146	}
147
148	static createTxt(accessoryInfo: AccessoryInfo, setupHash: string): ServiceTxt {	15✔
149	const statusFlags: StatusFlag[] = [];	21✔
150
151	if (!accessoryInfo.paired()) {	21✔
152	statusFlags.push(StatusFlag.NOT_PAIRED);	21✔
153	}
154
155	return {	21✔
156	"c#": accessoryInfo.getConfigVersion(), // current configuration number
157	ff: CiaoAdvertiser.ff(), // pairing feature flags
158	id: accessoryInfo.username, // device id
159	md: accessoryInfo.model, // model name
160	pv: CiaoAdvertiser.protocolVersion, // protocol version
161	"s#": 1, // current state number (must be 1)
162	sf: CiaoAdvertiser.sf(...statusFlags), // status flags
163	ci: accessoryInfo.category,
164	sh: setupHash,
165	};
166	}
167
168	static computeSetupHash(accessoryInfo: AccessoryInfo): string {	15✔
169	const hash = crypto.createHash("sha512");	21✔
170	hash.update(accessoryInfo.setupID + accessoryInfo.username.toUpperCase());	21✔
171	return hash.digest().slice(0, 4).toString("base64");	21✔
172	}
173
174	public static ff(...flags: PairingFeatureFlag[]): number {	78✔
175	let value = 0;	33✔
176	flags.forEach(flag => value \|= flag);	33✔
177	return value;	33✔
178	}
179
180	public static sf(...flags: StatusFlag[]): number {	147✔
181	let value = 0;	45✔
182	flags.forEach(flag => value \|= flag);	57✔
183	return value;	45✔
184	}
185
186	}	15✔
187
188	/**
189	* Advertiser base on the legacy "bonjour-hap" library.
190	*/
191	export class BonjourHAPAdvertiser extends EventEmitter implements Advertiser {	15✔
192
193	private readonly accessoryInfo: AccessoryInfo;
194	private readonly setupHash: string;
195	private readonly serviceOptions?: ServiceNetworkOptions;
196
197	private bonjour: BonjourHAP;
198	private advertisement?: BonjourHAPService;
199
200	private port?: number;
201	private destroyed = false;	12✔
202
203	constructor(accessoryInfo: AccessoryInfo, responderOptions?: MulticastOptions, serviceOptions?: ServiceNetworkOptions) {
204	super();	12✔
205	this.accessoryInfo = accessoryInfo;	12✔
206	this.setupHash = CiaoAdvertiser.computeSetupHash(accessoryInfo);	12✔
207	this.serviceOptions = serviceOptions;	12✔
208
209	this.bonjour = bonjour(responderOptions);	12✔
210	debug(`Preparing Advertiser for '${this.accessoryInfo.displayName}' using bonjour-hap backend!`);	12✔
211	}
212
213	public initPort(port: number): void {	15✔
214	this.port = port;	12✔
215	}
216
217	public startAdvertising(): Promise<void> {	15✔
218	assert(!this.destroyed, "Can't advertise on a destroyed bonjour instance!");	12✔
219	if (this.port == null) {	12!
220	throw new Error("Tried starting bonjour-hap advertisement without initializing port!");	×
221	}
222
223	debug(`Starting to advertise '${this.accessoryInfo.displayName}' using bonjour-hap backend!`);	12✔
224
225	if (this.advertisement) {	12!
226	this.destroy();	×
227	}
228
229	const hostname = this.accessoryInfo.username.replace(/:/ig, "_") + ".local";	12✔
230
231	this.advertisement = this.bonjour.publish({	12✔
232	name: this.accessoryInfo.displayName,
233	type: "hap",
234	port: this.port,
235	txt: CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash),
236	host: hostname,
237	addUnsafeServiceEnumerationRecord: true,
238	...this.serviceOptions,
239	});
240
241	return PromiseTimeout(1);	12✔
242	}
243
244	public updateAdvertisement(silent?: boolean): void {	15✔
245	const txt = CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash);	×
246	debug("Updating txt record (txt: %o, silent: %d)", txt, silent);	×
247
248	if (this.advertisement) {	×
249	this.advertisement.updateTxt(txt, silent);	×
250	}
251	}
252
253	public destroy(): void {	15✔
254	if (this.advertisement) {	12!
255	this.advertisement.stop(() => {	12✔
256	this.advertisement!.destroy();	×
257	this.advertisement = undefined;	×
258	this.bonjour.destroy();	×
259	});
260	} else {
261	this.bonjour.destroy();	×
262	}
263	}
264
265	}	15✔
266
267	/**
268	* AvahiServerState. Refer to https://github.com/lathiat/avahi/blob/fd482a74625b8db8547b8cfca3ee3d3c6c721423/avahi-common/defs.h#L220-L227.
269	*/
270	const enum AvahiServerState {	15✔
271	// noinspection JSUnusedGlobalSymbols
272	INVALID = 0,	15✔
273	REGISTERING,	15✔
274	RUNNING,	15✔
275	COLLISION,	15✔
276	FAILURE	15✔
277	}
278
279	/**
280	* Advertiser based on the Avahi D-Bus library.
281	* For (very crappy) docs on the interface, see the XML files at: https://github.com/lathiat/avahi/tree/master/avahi-daemon.
282	*
283	* Refer to https://github.com/lathiat/avahi/blob/fd482a74625b8db8547b8cfca3ee3d3c6c721423/avahi-common/defs.h#L120-L155 for a
284	* rough API usage guide of Avahi.
285	*/
286	export class AvahiAdvertiser extends EventEmitter implements Advertiser {	15✔
287	private readonly accessoryInfo: AccessoryInfo;
288	private readonly setupHash: string;
289
290	private port?: number;
291
292	private bus?: MessageBus;
293	private avahiServerInterface?: DBusInterface;
294	private path?: string;
295
296	private readonly stateChangeHandler: (state: AvahiServerState) => void;
297
298	constructor(accessoryInfo: AccessoryInfo) {
299	super();	×
300	this.accessoryInfo = accessoryInfo;	×
301	this.setupHash = CiaoAdvertiser.computeSetupHash(accessoryInfo);	×
302
NEW 303	debug(`Preparing Advertiser for '${this.accessoryInfo.displayName}' using Avahi backend!`);	×
304
UNCOV 305	this.bus = dbus.systemBus();	×
306
NEW 307	this.stateChangeHandler = this.handleStateChangedEvent.bind(this);	×
308	}
309
310	private createTxt(): Array<Buffer> {	15✔
311	return Object	×
312	.entries(CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash))
313	.map((el: Array<string>) => Buffer.from(el[0] + "=" + el[1]));	×
314	}
315
316	public initPort(port: number): void {	15✔
317	this.port = port;	×
318	}
319
320	public async startAdvertising(): Promise<void> {	15✔
321	if (this.port == null) {	×
322	throw new Error("Tried starting Avahi advertisement without initializing port!");	×
323	}
324	if (!this.bus) {	×
325	throw new Error("Tried to start Avahi advertisement on a destroyed advertiser!");	×
326	}
327
328	debug(`Starting to advertise '${this.accessoryInfo.displayName}' using Avahi backend!`);	×
329
NEW 330	if (!this.avahiServerInterface) {	×
NEW 331	this.avahiServerInterface = await AvahiAdvertiser.avahiInterface(this.bus, "Server");	×
NEW 332	this.avahiServerInterface.on("StateChanged", this.stateChangeHandler);	×
333	}
334
335	this.path = await AvahiAdvertiser.avahiInvoke(this.bus, "/", "Server", "EntryGroupNew") as string;	×
336	await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "AddService", {	×
337	body: [
338	-1, // interface
339	-1, // protocol
340	0, // flags
341	this.accessoryInfo.displayName, // name
342	"_hap._tcp", // type
343	"", // domain
344	"", // host
345	this.port, // port
346	this.createTxt(), // txt
347	],
348	signature: "iiussssqaay",
349	});
350	await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "Commit");	×
351	}
352
353	private handleStateChangedEvent(state: AvahiServerState): void {	15✔
NEW 354	if (state === AvahiServerState.RUNNING && this.path) {	×
NEW 355	debug("Found Avahi daemon to have restarted!");	×
NEW 356	this.startAdvertising()	×
NEW 357	.catch(reason => console.error("Could not (re-)create mDNS advertisement. The HAP-Server won't be discoverable: " + reason));	×
358	}
359	}
360
361	public async updateAdvertisement(silent?: boolean): Promise<void> {	15✔
362	if (!this.bus) {	×
363	throw new Error("Tried to update Avahi advertisement on a destroyed advertiser!");	×
364	}
365	if (!this.path) {	×
366	debug("Tried to update advertisement without a valid `path`!");	×
367	return;	×
368	}
369
370	debug("Updating txt record (txt: %o, silent: %d)", CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash), silent);	×
371
372	try {
373	await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "UpdateServiceTxt", {	×
374	body: [-1, -1, 0, this.accessoryInfo.displayName, "_hap._tcp", "", this.createTxt()],
375	signature: "iiusssaay",
376	});
377	} catch (error) {
378	console.error("Failed to update avahi advertisement: " + error);	×
379	}
380	}
381
382	public async destroy(): Promise<void> {	15✔
383	if (!this.bus) {	×
384	throw new Error("Tried to destroy Avahi advertisement on a destroyed advertiser!");	×
385	}
386
387	if (this.path) {	×
388	try {
389	await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "Free");	×
390	} catch (error) {
391	// Typically, this fails if e.g. avahi service was stopped in the meantime.
392	debug("Destroying Avahi advertisement failed: " + error);	×
393	}
394	this.path = undefined;	×
395	}
396
NEW 397	if (this.avahiServerInterface) {	×
NEW 398	this.avahiServerInterface.removeListener("StateChanged", this.stateChangeHandler);	×
NEW 399	this.avahiServerInterface = undefined;	×
400	}
401
402	this.bus.connection.stream.destroy();	×
403	this.bus = undefined;	×
404	}
405
406	public static async isAvailable(): Promise<boolean> {	15✔
407	const bus = dbus.systemBus();	×
408
409	try {
410	try {
411	await this.messageBusConnectionResult(bus);	×
412	} catch (error) {
413	debug("Avahi/DBus classified unavailable due to missing dbus interface!");	×
414	return false;	×
415	}
416
417	try {
418	const version = await this.avahiInvoke(bus, "/", "Server", "GetVersionString");	×
419	debug("Detected Avahi over DBus interface running version '%s'.", version);	×
420	} catch (error) {
421	debug("Avahi/DBus classified unavailable due to missing avahi interface!");	×
422	return false;	×
423	}
424
425	return true;	×
426	} finally {
427	bus.connection.stream.destroy();	×
428	}
429	}
430
431	private static messageBusConnectionResult(bus: MessageBus): Promise<void> {	15✔
432	return new Promise((resolve, reject) => {	×
433	const errorHandler = (error: Error) => {	×
434	// eslint-disable-next-line @typescript-eslint/no-use-before-define
435	bus.connection.removeListener("connect", connectHandler);	×
436	reject(error);	×
437	};
438	const connectHandler = () => {	×
439	bus.connection.removeListener("error", errorHandler);	×
440	resolve();	×
441	};
442
443	bus.connection.once("connect", connectHandler);	×
444	bus.connection.once("error", errorHandler);	×
445	});
446	}
447
448	// eslint-disable-next-line @typescript-eslint/no-explicit-any
449	private static avahiInvoke(bus: MessageBus, path: string, dbusInterface: string, member: string, others?: any): Promise<any> {	15✔
450	return new Promise((resolve, reject) => {	×
NEW 451	const command = {	×
452	destination: "org.freedesktop.Avahi",
453	path,
454	interface: "org.freedesktop.Avahi." + dbusInterface,
455	member,
456	...(others \|\| {}),	×
457	};
458	// eslint-disable-next-line @typescript-eslint/no-explicit-any
459	bus.invoke(command, (err: any, result: any) => {	×
460	if (err) {	×
461	reject(new Error(`avahiInvoke error: ${JSON.stringify(err)}`));	×
462	} else {
463	resolve(result);	×
464	}
465	});
466	});
467	}
468
469	private static avahiInterface(bus: MessageBus, dbusInterface: string): Promise<DBusInterface> {	15✔
NEW 470	return new Promise((resolve, reject) => {	×
NEW 471	bus	×
472	.getService("org.freedesktop.Avahi")
473	.getInterface("/", "org.freedesktop.Avahi." + dbusInterface, (error, iface) => {
NEW 474	if (error \|\| !iface) {	×
NEW 475	reject(error ?? new Error("Interface not present!"));	×
476	} else {
NEW 477	resolve(iface);	×
478	}
479	});
480	});
481	}
482	}	15✔

homebridge / HAP-NodeJS / 3073005646

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous