3358831774

Build Type

github

Committed by GitHub

Commit Message

Merge 51d4aa14a into 5fef5173e

Pull Request Pull Request #965: Add systemd-resolved mDNS advertiser support

Run Details

1354 of 3561 branches covered (38.02%)

Branch coverage included in aggregate %.

16 of 76 new or added lines in 2 files covered. (21.05%)

1 existing line in 1 file now uncovered.

5812 of 10223 relevant lines covered (56.85%)

106.01 hits per line

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

44.13

/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, { 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();
    }
  }

}

function 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
function dbusInvoke( bus: MessageBus, destination: string, path: string, dbusInterface: string, member: string, others?: any): Promise<any> {
  return new Promise((resolve, reject) => {
    const command = { destination, path, interface: dbusInterface, member, ...(others || {}) };

    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    bus.invoke(command, (err: any, result: any) => {
      if (err) {
        reject(new Error(`dbusInvoke error: ${JSON.stringify(err)}`));
      } else {
        resolve(result);
      }
    });

  });
}

/**
 * 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.
 */
export class AvahiAdvertiser extends EventEmitter implements Advertiser {
  private readonly accessoryInfo: AccessoryInfo;
  private readonly setupHash: string;

  private port?: number;

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

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

    this.bus = dbus.systemBus();

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

  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!`);

    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");
  }

  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;
    }

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

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

    try {
      try {
        await 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();
    }
  }

  // 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 dbusInvoke(
      bus,
      "org.freedesktop.Avahi",
      path,
      `org.freedesktop.Avahi.${dbusInterface}`,
      member,
      others,
    );
  }
}

type ResolvedServiceTxt = Array<Array<string | Buffer>>;

/**
 * Advertiser based on the systemd-resolved D-Bus library.
 * For docs on the interface, see: https://www.freedesktop.org/software/systemd/man/org.freedesktop.resolve1.html
 */
export class ResolvedAdvertiser extends EventEmitter implements Advertiser {
  private readonly accessoryInfo: AccessoryInfo;
  private readonly setupHash: string;

  private port?: number;

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

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

    this.bus = dbus.systemBus();

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

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

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

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

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

    this.path = await ResolvedAdvertiser.resolvedInvoke(this.bus, "RegisterService", {
      body: [
        this.accessoryInfo.displayName, // name
        this.accessoryInfo.displayName, // name_template
        "_hap._tcp", // type
        this.port, // service_port
        0, // service_priority
        0, // service_weight
        [this.createTxt()], // txt_datas
      ],
      signature: "sssqqqaa{say}",
    });
  }

  public async updateAdvertisement(silent?: boolean): Promise<void> {
    if (!this.bus) {
      throw new Error("Tried to update systemd-resolved advertisement on a destroyed advertiser!");
    }

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

    // Currently, systemd-resolved has no way to update an existing record.
    await this.stopAdvertising();
    await this.startAdvertising();
  }

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

    if (this.path) {
      try {
        await ResolvedAdvertiser.resolvedInvoke(this.bus, "UnregisterService", {
          body: [this.path],
          signature: "o",
        });
      } catch (error) {
        // Typically, this fails if e.g. systemd-resolved service was stopped in the meantime.
        debug("Destroying systemd-resolved advertisement failed: " + error);
      }
      this.path = undefined;
    }
  }

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

    await this.stopAdvertising();

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

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

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

      try {
        // Ensure that systemd-resolved is accessible.
        await this.resolvedInvoke(bus, "ResolveHostname", {
          body: [0, "127.0.0.1", 0, 0],
          signature: "isit",
        });
        debug("Detected systemd-resolved over DBus interface running version.");
      } catch (error) {
        debug("systemd-resolved/DBus classified unavailable due to missing systemd-resolved interface!");
        return false;
      }

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

  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  private static resolvedInvoke(bus: MessageBus, member: string, others?: any): Promise<any> {
    return dbusInvoke(
      bus,
      "org.freedesktop.resolve1",
      "/org/freedesktop/resolve1",
      "org.freedesktop.resolve1.Manager",
      member,
      others,
    );
  }
}

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, { 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	function messageBusConnectionResult(bus: MessageBus): Promise<void> {
NEW 268	return new Promise((resolve, reject) => {	×
NEW 269	const errorHandler = (error: Error) => {	×
270	// eslint-disable-next-line @typescript-eslint/no-use-before-define
NEW 271	bus.connection.removeListener("connect", connectHandler);	×
NEW 272	reject(error);	×
273	};
NEW 274	const connectHandler = () => {	×
NEW 275	bus.connection.removeListener("error", errorHandler);	×
NEW 276	resolve();	×
277	};
278
NEW 279	bus.connection.once("connect", connectHandler);	×
NEW 280	bus.connection.once("error", errorHandler);	×
281	});
282	}
283
284
285	// eslint-disable-next-line @typescript-eslint/no-explicit-any
286	function dbusInvoke( bus: MessageBus, destination: string, path: string, dbusInterface: string, member: string, others?: any): Promise<any> {
NEW 287	return new Promise((resolve, reject) => {	×
NEW 288	const command = { destination, path, interface: dbusInterface, member, ...(others \|\| {}) };	×
289
290	// eslint-disable-next-line @typescript-eslint/no-explicit-any
NEW 291	bus.invoke(command, (err: any, result: any) => {	×
NEW 292	if (err) {	×
NEW 293	reject(new Error(`dbusInvoke error: ${JSON.stringify(err)}`));	×
294	} else {
NEW 295	resolve(result);	×
296	}
297	});
298
299	});
300	}
301
302	/**
303	* Advertiser based on the Avahi D-Bus library.
304	* For (very crappy) docs on the interface, see the XML files at: https://github.com/lathiat/avahi/tree/master/avahi-daemon.
305	*/
306	export class AvahiAdvertiser extends EventEmitter implements Advertiser {	15✔
307	private readonly accessoryInfo: AccessoryInfo;
308	private readonly setupHash: string;
309
310	private port?: number;
311
312	private bus?: MessageBus;
313	private path?: string;
314
315	constructor(accessoryInfo: AccessoryInfo) {
316	super();	×
317	this.accessoryInfo = accessoryInfo;	×
318	this.setupHash = CiaoAdvertiser.computeSetupHash(accessoryInfo);	×
319
320	this.bus = dbus.systemBus();	×
321
322	debug(`Preparing Advertiser for '${this.accessoryInfo.displayName}' using Avahi backend!`);	×
323	}
324
325	private createTxt(): Array<Buffer> {	15✔
326	return Object	×
327	.entries(CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash))
328	.map((el: Array<string>) => Buffer.from(el[0] + "=" + el[1]));	×
329	}
330
331	public initPort(port: number): void {	15✔
332	this.port = port;	×
333	}
334
335	public async startAdvertising(): Promise<void> {	15✔
336	if (this.port == null) {	×
337	throw new Error("Tried starting Avahi advertisement without initializing port!");	×
338	}
339	if (!this.bus) {	×
340	throw new Error("Tried to start Avahi advertisement on a destroyed advertiser!");	×
341	}
342
343	debug(`Starting to advertise '${this.accessoryInfo.displayName}' using Avahi backend!`);	×
344
345	this.path = await AvahiAdvertiser.avahiInvoke(this.bus, "/", "Server", "EntryGroupNew") as string;	×
346	await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "AddService", {	×
347	body: [
348	-1, // interface
349	-1, // protocol
350	0, // flags
351	this.accessoryInfo.displayName, // name
352	"_hap._tcp", // type
353	"", // domain
354	"", // host
355	this.port, // port
356	this.createTxt(), // txt
357	],
358	signature: "iiussssqaay",
359	});
360	await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "Commit");	×
361	}
362
363	public async updateAdvertisement(silent?: boolean): Promise<void> {	15✔
364	if (!this.bus) {	×
365	throw new Error("Tried to update Avahi advertisement on a destroyed advertiser!");	×
366	}
367	if (!this.path) {	×
368	debug("Tried to update advertisement without a valid `path`!");	×
369	return;	×
370	}
371
372	debug("Updating txt record (txt: %o, silent: %d)", CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash), silent);	×
373
374	try {
375	await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "UpdateServiceTxt", {	×
376	body: [-1, -1, 0, this.accessoryInfo.displayName, "_hap._tcp", "", this.createTxt()],
377	signature: "iiusssaay",
378	});
379	} catch (error) {
380	console.error("Failed to update avahi advertisement: " + error);	×
381	}
382	}
383
384	public async destroy(): Promise<void> {	15✔
385	if (!this.bus) {	×
386	throw new Error("Tried to destroy Avahi advertisement on a destroyed advertiser!");	×
387	}
388
389	if (this.path) {	×
390	try {
391	await AvahiAdvertiser.avahiInvoke(this.bus, this.path, "EntryGroup", "Free");	×
392	} catch (error) {
393	// Typically, this fails if e.g. avahi service was stopped in the meantime.
394	debug("Destroying Avahi advertisement failed: " + error);	×
395	}
396	this.path = undefined;	×
397	}
398
399	this.bus.connection.stream.destroy();	×
400	this.bus = undefined;	×
401	}
402
403	public static async isAvailable(): Promise<boolean> {	15✔
404	const bus = dbus.systemBus();	×
405
406	try {
407	try {
NEW 408	await messageBusConnectionResult(bus);	×
409	} catch (error) {
410	debug("Avahi/DBus classified unavailable due to missing dbus interface!");	×
411	return false;	×
412	}
413
414	try {
415	const version = await this.avahiInvoke(bus, "/", "Server", "GetVersionString");	×
416	debug("Detected Avahi over DBus interface running version '%s'.", version);	×
417	} catch (error) {
418	debug("Avahi/DBus classified unavailable due to missing avahi interface!");	×
419	return false;	×
420	}
421
422	return true;	×
423	} finally {
424	bus.connection.stream.destroy();	×
425	}
426	}
427
428	// eslint-disable-next-line @typescript-eslint/no-explicit-any
429	private static avahiInvoke(bus: MessageBus, path: string, dbusInterface: string, member: string, others?: any): Promise<any> {	15✔
NEW 430	return dbusInvoke(	×
431	bus,
432	"org.freedesktop.Avahi",
433	path,
434	`org.freedesktop.Avahi.${dbusInterface}`,
435	member,
436	others,
437	);
438	}
439	}	15✔
440
441	type ResolvedServiceTxt = Array<Array<string \| Buffer>>;
442
443	/**
444	* Advertiser based on the systemd-resolved D-Bus library.
445	* For docs on the interface, see: https://www.freedesktop.org/software/systemd/man/org.freedesktop.resolve1.html
446	*/
447	export class ResolvedAdvertiser extends EventEmitter implements Advertiser {	15✔
448	private readonly accessoryInfo: AccessoryInfo;
449	private readonly setupHash: string;
450
451	private port?: number;
452
453	private bus?: MessageBus;
454	private path?: string;
455
456	constructor(accessoryInfo: AccessoryInfo) {
NEW 457	super();	×
NEW 458	this.accessoryInfo = accessoryInfo;	×
NEW 459	this.setupHash = CiaoAdvertiser.computeSetupHash(accessoryInfo);	×
460
NEW 461	this.bus = dbus.systemBus();	×
462
NEW 463	debug(`Preparing Advertiser for '${this.accessoryInfo.displayName}' using systemd-resolved backend!`);	×
464	}
465
466	private createTxt(): ResolvedServiceTxt {	15✔
NEW 467	return Object	×
468	.entries(CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash))
NEW 469	.map((el: Array<string>) => [el[0].toString(), Buffer.from(el[1].toString())]);	×
470	}
471
472	public initPort(port: number): void {	15✔
NEW 473	this.port = port;	×
474	}
475
476	public async startAdvertising(): Promise<void> {	15✔
NEW 477	if (this.port == null) {	×
NEW 478	throw new Error("Tried starting systemd-resolved advertisement without initializing port!");	×
479	}
NEW 480	if (!this.bus) {	×
NEW 481	throw new Error("Tried to start systemd-resolved advertisement on a destroyed advertiser!");	×
482	}
483
NEW 484	debug(`Starting to advertise '${this.accessoryInfo.displayName}' using systemd-resolved backend!`);	×
485
NEW 486	this.path = await ResolvedAdvertiser.resolvedInvoke(this.bus, "RegisterService", {	×
487	body: [
488	this.accessoryInfo.displayName, // name
489	this.accessoryInfo.displayName, // name_template
490	"_hap._tcp", // type
491	this.port, // service_port
492	0, // service_priority
493	0, // service_weight
494	[this.createTxt()], // txt_datas
495	],
496	signature: "sssqqqaa{say}",
497	});
498	}
499
500	public async updateAdvertisement(silent?: boolean): Promise<void> {	15✔
NEW 501	if (!this.bus) {	×
NEW 502	throw new Error("Tried to update systemd-resolved advertisement on a destroyed advertiser!");	×
503	}
504
NEW 505	debug("Updating txt record (txt: %o, silent: %d)", CiaoAdvertiser.createTxt(this.accessoryInfo, this.setupHash), silent);	×
506
507	// Currently, systemd-resolved has no way to update an existing record.
NEW 508	await this.stopAdvertising();	×
NEW 509	await this.startAdvertising();	×
510	}
511
512	private async stopAdvertising(): Promise<void> {	15✔
NEW 513	if (!this.bus) {	×
NEW 514	throw new Error("Tried to destroy systemd-resolved advertisement on a destroyed advertiser!");	×
515	}
516
NEW 517	if (this.path) {	×
518	try {
NEW 519	await ResolvedAdvertiser.resolvedInvoke(this.bus, "UnregisterService", {	×
520	body: [this.path],
521	signature: "o",
522	});
523	} catch (error) {
524	// Typically, this fails if e.g. systemd-resolved service was stopped in the meantime.
NEW 525	debug("Destroying systemd-resolved advertisement failed: " + error);	×
526	}
NEW 527	this.path = undefined;	×
528	}
529	}
530
531	public async destroy(): Promise<void> {	15✔
NEW 532	if (!this.bus) {	×
NEW 533	throw new Error("Tried to destroy systemd-resolved advertisement on a destroyed advertiser!");	×
534	}
535
NEW 536	await this.stopAdvertising();	×
537
NEW 538	this.bus.connection.stream.destroy();	×
NEW 539	this.bus = undefined;	×
540	}
541
542	public static async isAvailable(): Promise<boolean> {	15✔
NEW 543	const bus = dbus.systemBus();	×
544
545	try {
546	try {
NEW 547	await messageBusConnectionResult(bus);	×
548	} catch (error) {
NEW 549	debug("systemd-resolved/DBus classified unavailable due to missing dbus interface!");	×
NEW 550	return false;	×
551	}
552
553	try {
554	// Ensure that systemd-resolved is accessible.
NEW 555	await this.resolvedInvoke(bus, "ResolveHostname", {	×
556	body: [0, "127.0.0.1", 0, 0],
557	signature: "isit",
558	});
NEW 559	debug("Detected systemd-resolved over DBus interface running version.");	×
560	} catch (error) {
NEW 561	debug("systemd-resolved/DBus classified unavailable due to missing systemd-resolved interface!");	×
NEW 562	return false;	×
563	}
564
NEW 565	return true;	×
566	} finally {
NEW 567	bus.connection.stream.destroy();	×
568	}
569	}
570
571	// eslint-disable-next-line @typescript-eslint/no-explicit-any
572	private static resolvedInvoke(bus: MessageBus, member: string, others?: any): Promise<any> {	15✔
NEW 573	return dbusInvoke(	×
574	bus,
575	"org.freedesktop.resolve1",
576	"/org/freedesktop/resolve1",
577	"org.freedesktop.resolve1.Manager",
578	member,
579	others,
580	);
581	}
582	}	15✔

homebridge / HAP-NodeJS / 3358831774

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