130250602

Build Type

push

github

Committed by Supereg

Commit Message

Reworked the NetworkManager to detect which interfaces belong to the same network

Run Details

73 of 595 branches covered (12.27%)

Branch coverage included in aggregate %.

63 of 123 new or added lines in 4 files covered. (51.22%)

6 existing lines in 1 file now uncovered.

153 of 1069 relevant lines covered (14.31%)

5.72 hits per line

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

0.0

/src/CiaoService.ts

import {
  AAAARecord,
  AnswerRecord,
  ARecord,
  PTRRecord,
  RecordBase,
  SRVRecord,
  TXTRecord,
  Type,
} from "@homebridge/dns-packet";
import assert from "assert";
import createDebug from "debug";
import { EventEmitter } from "events";
import net from "net";
import { Protocol, Responder } from "./index";
import { NetworkChange, NetworkManager, NetworkManagerEvent } from "./NetworkManager";
import * as domainFormatter from "./util/domain-formatter";
import { formatReverseAddressPTRName } from "./util/domain-formatter";

const debug = createDebug("ciao:CiaoService");

const numberedServiceNamePattern = /^(.*) \((\d+)\)$/; // matches a name lik "My Service (2)"
const numberedHostnamePattern = /^(.*)-(\d+)\((\.\w{2,})\)$/; // matches a hostname like "My-Computer-(2).local"

/**
 * This enum defines some commonly used service types.
 * This is also referred to as service name (as of RFC 6763).
 * A service name must not be longer than 15 characters (RFC 6763 7.2).
 */
export const enum ServiceType {
  // noinspection JSUnusedGlobalSymbols
  AIRDROP = "airdrop",
  AIRPLAY = "airplay",
  AIRPORT = "airport",
  COMPANION_LINK = "companion-link",
  DACP = "dacp", // digital audio control protocl (iTunes)
  HAP = "hap", // used by HomeKit accessoires
  HOMEKIT = "homekit", // used by home hubs
  HTTP = "http",
  HTTP_ALT = "http_alt", // http alternate
  IPP = "ipp", // internet printing protocol
  IPPS = "ipps", // intenert priting protocol over https
  RAOP = "raop", // remote audio output protocol
  scanner = "scanner", // bonjour scanning
  TOUCH_ABLE = "touch-able", // iPhone and iPod touch remote controllable
  DNS_SD = "dns-sd",
  PRINTER = "printer",
}

export interface ServiceOptions {
  /**
   * Instance Name of the service
   */
  name: string;
  /**
   * Type of the service
   */
  type: ServiceType | string;
  /**
   * Optional array of subtypes of the service
   */
  subtypes?: (ServiceType | string)[];
  /**
   * Port of the service
   */
  port: number;

  /**
   * The protocol the service uses. Default is TCP.
   */
  protocol?: Protocol;
  /**
   * Defines a hostname under which the service can be reached.
   * The specified hostname should not include the TLD.
   * If undefined the service name will be used as default.
   */
  hostname?: string;
  /**
   * If defined a txt record will be published with the given service.
   */
  txt?: ServiceTxt;

  /**
   * Adds ability to set custom domain. Will default to "local".
   * The domain will also be automatically appended to the hostname.
   */
  domain?: string;
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export type ServiceTxt = Record<string, any>;

export const enum ServiceState {
  UNANNOUNCED = "unannounced",
  PROBING = "probing",
  ANNOUNCED = "announced",
}

export interface ServiceRecords {
  ptr: PTRRecord; // this is the main type ptr record
  subtypePTRs?: PTRRecord[];
  metaQueryPtr: PTRRecord; // pointer for the "_services._dns-sd._udp.local" meta query
  srv: SRVRecord;
  txt: TXTRecord;
  a: Record<string, ARecord>; // indexed by interface name
  aaaa: Record<string, AAAARecord[]>; // indexed by interface name
  reverseAddressPTRs: Record<string, PTRRecord>; // indexed by address
}

export const enum ServiceEvent {
  /**
   * Event is called when the Prober identifies that the name for the service is already used
   * and thus resolve the name conflict by adjusting the name (e.g. adding '(2)' to the name).
   * This change must be persisted and thus a listener must hook up to this event
   * in order for the name to be persited.
   */
  NAME_CHANGED = "name-change",
  HOSTNAME_CHANGED = "hostname-change",
}

export const enum InternalServiceEvent {
  PUBLISH = "publish",
  UNPUBLISH = "unpublish",
  RECORD_UPDATE = "records-update",
}

export type PublishCallback = (error?: Error) => void;
export type UnpublishCallback = (error?: Error) => void;

export declare interface CiaoService {

  on(event: "name-change", listener: (name: string) => void): this;
  on(event: "hostname-change", listener: (hostname: string) => void): this;

  on(event: InternalServiceEvent.PUBLISH, listener: (callback: PublishCallback) => void): this;
  on(event: InternalServiceEvent.UNPUBLISH, listener: (callback: UnpublishCallback) => void): this;
  on(event: InternalServiceEvent.RECORD_UPDATE, listener: (records: AnswerRecord[], callback?: (error?: Error | null) => void) => void): this;

  emit(event: ServiceEvent.NAME_CHANGED, name: string): boolean;
  emit(event: ServiceEvent.HOSTNAME_CHANGED, hostname: string): boolean;

  emit(event: InternalServiceEvent.PUBLISH, callback: PublishCallback): boolean;
  emit(event: InternalServiceEvent.UNPUBLISH, callback: UnpublishCallback): boolean;
  emit(event: InternalServiceEvent.RECORD_UPDATE, records: AnswerRecord[], callback?: (error?: Error | null) => void): boolean;

}

export class CiaoService extends EventEmitter {

  private readonly networkManager: NetworkManager;

  private name: string;
  private readonly type: ServiceType | string;
  private readonly subTypes?: string[];
  private readonly protocol: Protocol;
  private readonly serviceDomain: string; // remember: can't be named "domain" => conflicts with EventEmitter

  private fqdn: string; // fully qualified domain name
  private readonly typePTR: string;
  private readonly subTypePTRs?: string[];

  private hostname: string; // formatted hostname
  readonly port: number;

  private txt?: Buffer[];

  serviceState = ServiceState.UNANNOUNCED; // this field is entirely controlled by the Responder class
  private serviceRecords: ServiceRecords;

  constructor(networkManager: NetworkManager, options: ServiceOptions) {
    super();
    assert(networkManager, "networkManager is required");
    assert(options, "parameters options is required");
    assert(options.name, "service options parameter 'name' is required");
    assert(options.type, "service options parameter 'type' is required");
    assert(options.port, "service options parameter 'port' is required");
    assert(options.type.length <= 15, "service options parameter 'type' must not be longer than 15 characters");

    this.networkManager = networkManager;
    this.networkManager.on(NetworkManagerEvent.INTERFACE_UPDATE, this.handleNetworkChange.bind(this));

    this.name = options.name;
    this.type = options.type;
    this.subTypes = options.subtypes;
    this.protocol = options.protocol || Protocol.TCP;
    this.serviceDomain = options.domain || "local";

    this.fqdn = this.formatFQDN();

    this.typePTR = domainFormatter.stringify({ // something like '_hap._tcp.local'
      type: this.type,
      protocol: this.protocol,
      domain: this.serviceDomain,
    });

    if (this.subTypes) {
      this.subTypePTRs = this.subTypes.map(subtype => domainFormatter.stringify({
        subtype: subtype,
        type: this.type,
        protocol: this.protocol,
        domain: this.serviceDomain,
      }));
    }

    this.hostname = domainFormatter.formatHostname(options.hostname || this.name, this.serviceDomain)
      .replace(/ /g, "-"); // replacing all spaces with dashes in the hostname
    this.port = options.port;

    if (options.txt) {
      this.txt = CiaoService.txtBuffersFromRecord(options.txt);
    }

    // checks if hostname or name are already numbered and adjusts the numbers if necessary
    this.incrementName(true); // must be done before the rebuildServiceRecords call

    this.serviceRecords = this.rebuildServiceRecords(); // build the initial set of records
  }

  public advertise(): Promise<void> {
    debug("[%s] Going to advertise service...", this.name);

    if (this.listeners(ServiceEvent.NAME_CHANGED)) {
      debug("[%s] WARN: No listeners found for a potential name change on the 'name-change' event!", this.name);
    }
    return new Promise((resolve, reject) => {
      this.emit(InternalServiceEvent.PUBLISH, error => error? reject(error): resolve());
    });
  }

  public end(): Promise<void> {
    debug("[%s] Service is saying goodbye", this.name);
    return new Promise((resolve, reject) => {
      this.emit(InternalServiceEvent.UNPUBLISH, error => error? reject(error): resolve());
    });
  }

  public getFQDN(): string {
    return this.fqdn;
  }

  public getTypePTR(): string {
    return this.typePTR;
  }

  public getSubtypePTRs(): string[] | undefined {
    return this.subTypePTRs;
  }

  public getHostname(): string {
    return this.hostname;
  }

  /**
   * Sets or updates the txt of the service
   * @param txt - the new txt record
   */
  public updateTxt(txt: ServiceTxt): Promise<void> {
    assert(txt, "txt cannot be undefined");

    this.txt = CiaoService.txtBuffersFromRecord(txt);
    debug("[%s] Updating txt record...", this.name);

    return new Promise((resolve, reject) => {
      if (this.serviceState === ServiceState.ANNOUNCED) {
        this.rebuildServiceRecords();
        this.emit(InternalServiceEvent.RECORD_UPDATE, [this.txtRecord()], error => error? reject(error): resolve());
      } else {
        resolve();
      }
    });
  }

  private static txtBuffersFromRecord(txt: ServiceTxt): Buffer[] {
    const result: Buffer[] = [];

    Object.entries(txt).forEach(([key, value]) => {
      const entry = key + "=" + value;
      result.push(Buffer.from(entry));
    });

    return result;
  }

  private handleNetworkChange(change: NetworkChange): void {
    if (this.serviceState !== ServiceState.ANNOUNCED) {
      return; // service records are rebuilt short before the announce step
    }

    const added = change.added?.map(iface => iface.name) || [];
    const updated = change.updated?.map(iface => iface.newInterface.name) || [];
    const removed = change.removed?.map(iface => iface.name) || [];

    debug("[%s] Encountered network change: added: '%s'; updated: '%s'; removed: '%s'", this.name, added.join(", "), updated.join(", "), removed.join(", "));

    const records: AnswerRecord[] = [];

    if (change.updated) {
      for (const interfaceChange of change.updated) {
        for (const outdated of interfaceChange.outdatedAddresses) {
          records.push({
            name: this.hostname,
            type: net.isIPv4(outdated)? Type.A: Type.AAAA,
            ttl: 0,
            data: outdated,
            flush: true,
          });
        }

        for (const updated of interfaceChange.updatedAddresses) {
          records.push({
            name: this.hostname,
            type: net.isIPv4(updated)? Type.A: Type.AAAA,
            ttl: 120,
            data: updated,
            flush: true,
          });
        }
      }
    }

    this.rebuildServiceRecords();
    // records for a removed interface are now no longer present after the call above
    // records for a new interface got now built by the call above

    if (records.length > 0) {
      this.emit(InternalServiceEvent.RECORD_UPDATE, records);
    }

    if (added.length > 0) {
      // TODO add support for this. We will need to announce the service on the newly appeared interface
      //  as a name conflict could appear there we would also do a Probing. As we probably do not want
      //  that we have different names on different interfaces we should just Probe an reannounce on ALL interfaces
      console.log("CIAO: [" + this.name + "] Detected a new network interface appearing on the machine. The service probably " +
        "needs to be announced on again on that interface. This is currently unsupported. " +
        "Please restart the program so that the new interface is properly advertised!");
    }
  }

  /**
   * This method is called by the Prober when encountering a conflict on the network.
   * It advices the service to change its name, like incrementing a number appended to the name.
   * So "My Service" will become "My Service (2)", and "My Service (2)" would become "My Service (3)"
   */
  incrementName(nameCheckOnly?: boolean): void {
    if (this.serviceState !== ServiceState.UNANNOUNCED) {
      throw new Error("Service name can only be incremented when in state UNANNOUNCED!");
    }

    const oldName = this.name;
    const oldHostname = this.hostname;

    let nameBase;
    let nameNumber;

    let hostnameBase;
    let hostnameTLD;
    let hostnameNumber;

    const nameMatcher = this.name.match(numberedServiceNamePattern);
    if (nameMatcher) { // if it matched. Extract the current nameNumber
      nameBase = nameMatcher[1];
      nameNumber = parseInt(nameMatcher[2]);

      assert(nameNumber, `Failed to extract name number from ${this.name}. Resulted in ${nameNumber}`);
    } else {
      nameBase = this.name;
      nameNumber = 1;
    }

    const hostnameMatcher = this.hostname.match(numberedHostnamePattern);
    if (hostnameMatcher) { // if it matched. Extract the current nameNumber
      hostnameBase = hostnameMatcher[1];
      hostnameTLD = hostnameMatcher[3];
      hostnameNumber = parseInt(hostnameMatcher[2]);

      assert(hostnameNumber, `Failed to extract hostname number from ${this.hostname}. Resulted in ${hostnameNumber}`);
    } else {
      const lastDot = this.hostname.lastIndexOf(".");

      hostnameBase = this.hostname.slice(0, lastDot);
      hostnameTLD = this.hostname.slice(lastDot);
      hostnameNumber = 1;
    }

    if (!nameCheckOnly) {
      // increment the numbers
      nameNumber++;
      hostnameNumber++;
    }

    const newNumber = Math.max(nameNumber, hostnameNumber);

    // reassemble the name
    this.name = newNumber === 1? nameBase: `${nameBase} (${newNumber})`;
    this.hostname = newNumber === 1? `${hostnameBase}${hostnameTLD}`: `${hostnameBase}-(${newNumber})${hostnameTLD}`;

    this.fqdn = this.formatFQDN(); // update the fqdn

    // we must inform the user that the names changed, so the new names can be persisted
    // This is done after the Probing finish, as multiple name changes could happen in one probing session
    // It is the responsibility of the Prober to call the informAboutNameUpdates function

    if (this.name !== oldName || this.hostname !== oldHostname) {
      debug("[%s] Service changed name '%s' -> '%s', '%s' -> '%s'", this.name, oldName, this.name, oldHostname, this.hostname);
    }

    if (!nameCheckOnly) {
      this.rebuildServiceRecords(); // rebuild all services
    }
  }

  informAboutNameUpdates(): void {
    // we trust the prober that this function is only called when the name was actually changed

    const nameCalled = this.emit(ServiceEvent.NAME_CHANGED, this.name);
    const hostnameCalled = this.emit(ServiceEvent.HOSTNAME_CHANGED, domainFormatter.removeTLD(this.hostname));

    // at least one event should be listened to. We can figure out the number from one or another
    if (!nameCalled && !hostnameCalled) {
      console.warn(`CIAO: [${this.name}] Service changed name but nobody was listening on the 'name-change' event!`);
    }
  }

  private formatFQDN(): string {
    if (this.serviceState !== ServiceState.UNANNOUNCED) {
      throw new Error("Name can't be changed after service was already announced!");
    }

    const fqdn = domainFormatter.stringify({
      name: this.name,
      type: this.type,
      protocol: this.protocol,
      domain: this.serviceDomain,
    });

    assert(fqdn.length <= 255, "A fully qualified domain name cannot be longer than 255 characters");
    return fqdn;
  }

  rebuildServiceRecords(): ServiceRecords {
    const aRecordMap: Record<string, ARecord> = {};
    const aaaaRecordMap: Record<string, AAAARecord[]> = {};
    const reverseAddressMap: Record<string, PTRRecord> = {};
    let subtypePTRs: PTRRecord[] | undefined = undefined;

    for (const networkInterfaces of this.networkManager.getInterfaces()) {
      if (networkInterfaces.ipv4) {
        aRecordMap[networkInterfaces.name] = {
          name: this.hostname,
          type: Type.A,
          ttl: 120,
          data: networkInterfaces.ipv4,
          flush: true,
        };
        reverseAddressMap[networkInterfaces.ipv4] = {
          name: formatReverseAddressPTRName(networkInterfaces.ipv4),
          type: Type.PTR,
          ttl: 4500, // PTR records
          data: this.hostname,
        };
      }

      if (networkInterfaces.ipv6) {
        aaaaRecordMap[networkInterfaces.name] = [{
          name: this.hostname,
          type: Type.AAAA,
          ttl: 120,
          data: networkInterfaces.ipv6,
          flush: true,
        }];
        reverseAddressMap[networkInterfaces.ipv6] = {
          name: formatReverseAddressPTRName(networkInterfaces.ipv6),
          type: Type.PTR,
          ttl: 4500, // PTR records
          data: this.hostname,
        };
      }

      if (networkInterfaces.routeAbleIpv6) {
        let records = aaaaRecordMap[networkInterfaces.name];
        if (!records) {
          aaaaRecordMap[networkInterfaces.name] = records = [];
        }

        for (const ip6 of networkInterfaces.routeAbleIpv6) {
          records.push({
            name: this.hostname,
            type: Type.AAAA,
            ttl: 120,
            data: ip6,
            flush: true,
          });
          reverseAddressMap[ip6] = {
            name: formatReverseAddressPTRName(ip6),
            type: Type.PTR,
            ttl: 4500, // PTR records
            data: this.hostname,
          };
        }
      }
    }

    if (this.subTypePTRs) {
      subtypePTRs = [];
      for (const ptr of this.subTypePTRs) {
        subtypePTRs.push({
          name: ptr,
          type: Type.PTR,
          ttl: 4500, // 75 minutes
          data: this.fqdn,
        });
      }
    }

    debug("[%s] Rebuilding service records...", this.name);

    return this.serviceRecords = {
      ptr: {
        name: this.typePTR,
        type: Type.PTR,
        ttl: 4500, // 75 minutes
        data: this.fqdn,
      },
      subtypePTRs: subtypePTRs, // possibly undefined
      metaQueryPtr: {
        name: Responder.SERVICE_TYPE_ENUMERATION_NAME,
        type: Type.PTR,
        ttl: 4500, // 75 minutes
        data: this.typePTR,
      },
      srv: {
        name: this.fqdn,
        type: Type.SRV,
        ttl: 120,
        data: {
          target: this.hostname, // TODO we could just use the local hostname, and let the service respond to queries from the original responder
          port: this.port,
        },
        flush: true,
      },
      txt: {
        name: this.fqdn,
        type: Type.TXT,
        ttl: 4500, // 75 minutes
        data: this.txt || [],
        flush: true,
      },
      a: aRecordMap,
      aaaa: aaaaRecordMap,
      reverseAddressPTRs: reverseAddressMap,
    };
  }

  ptrRecord(): PTRRecord {
    return CiaoService.copyRecord(this.serviceRecords.ptr);
  }

  subtypePtrRecords(): PTRRecord[] {
    return this.serviceRecords.subtypePTRs? CiaoService.copyRecords(this.serviceRecords.subtypePTRs): [];
  }

  metaQueryPtrRecord(): PTRRecord {
    return CiaoService.copyRecord(this.serviceRecords.metaQueryPtr);
  }

  srvRecord(): SRVRecord {
    return CiaoService.copyRecord(this.serviceRecords.srv);
  }

  txtRecord(): TXTRecord {
    return CiaoService.copyRecord(this.serviceRecords.txt);
  }

  aRecord(networkInterface: string): ARecord | undefined {
    // TODO include localhost record if the response comes from our own machine
    const record = this.serviceRecords.a[networkInterface];
    return record? CiaoService.copyRecord(record): undefined;
  }

  aaaaRecords(networkInterface: string): AAAARecord[] | undefined {
    // TODO include localhost record if the response comes from our own machine
    const records = this.serviceRecords.aaaa[networkInterface];
    return records? CiaoService.copyRecords(records): undefined;
  }

  allAddressRecords(): (ARecord | AAAARecord)[] {
    const records: (ARecord | AAAARecord)[] = [];

    records.push(...CiaoService.copyRecords(Object.values(this.serviceRecords.a)));
    Object.values(this.serviceRecords.aaaa).forEach(recordArray => {
      records.push(...CiaoService.copyRecords(recordArray));
    });

    return records;
  }

  reverseAddressMapping(address: string): PTRRecord | undefined {
    const record = this.serviceRecords.reverseAddressPTRs[address];
    return record? CiaoService.copyRecord(record): undefined;
  }

  private static copyRecord<T extends RecordBase>(record: T): T {
    // eslint-disable-next-line
    // @ts-ignore
    return {
      name: record.name,
      type: record.type,
      ttl: record.ttl,
      data: record.data,
      class: record.class,
    };
  }

  private static copyRecords<T extends RecordBase>(records: T[]): T[] {
    const result: T[] = [];
    for (const record of records) {
      result.push(CiaoService.copyRecord(record));
    }

    return result;
  }

}

1	import {
2	AAAARecord,
3	AnswerRecord,
4	ARecord,
5	PTRRecord,
6	RecordBase,
7	SRVRecord,
8	TXTRecord,
9	Type,
10	} from "@homebridge/dns-packet";
11	import assert from "assert";	×
12	import createDebug from "debug";	×
13	import { EventEmitter } from "events";	×
14	import net from "net";	×
15	import { Protocol, Responder } from "./index";	×
16	import { NetworkChange, NetworkManager, NetworkManagerEvent } from "./NetworkManager";
17	import * as domainFormatter from "./util/domain-formatter";	×
18	import { formatReverseAddressPTRName } from "./util/domain-formatter";	×
19
20	const debug = createDebug("ciao:CiaoService");	×
21
22	const numberedServiceNamePattern = /^(.*) \((\d+)\)$/; // matches a name lik "My Service (2)"	×
23	const numberedHostnamePattern = /^(.*)-(\d+)\((\.\w{2,})\)$/; // matches a hostname like "My-Computer-(2).local"	×
24
25	/**
26	* This enum defines some commonly used service types.
27	* This is also referred to as service name (as of RFC 6763).
28	* A service name must not be longer than 15 characters (RFC 6763 7.2).
29	*/
30	export const enum ServiceType {	×
31	// noinspection JSUnusedGlobalSymbols
32	AIRDROP = "airdrop",	×
33	AIRPLAY = "airplay",	×
34	AIRPORT = "airport",	×
35	COMPANION_LINK = "companion-link",	×
36	DACP = "dacp", // digital audio control protocl (iTunes)	×
37	HAP = "hap", // used by HomeKit accessoires	×
38	HOMEKIT = "homekit", // used by home hubs	×
39	HTTP = "http",	×
40	HTTP_ALT = "http_alt", // http alternate	×
41	IPP = "ipp", // internet printing protocol	×
42	IPPS = "ipps", // intenert priting protocol over https	×
43	RAOP = "raop", // remote audio output protocol	×
44	scanner = "scanner", // bonjour scanning	×
45	TOUCH_ABLE = "touch-able", // iPhone and iPod touch remote controllable	×
46	DNS_SD = "dns-sd",	×
47	PRINTER = "printer",	×
48	}
49
50	export interface ServiceOptions {
51	/**
52	* Instance Name of the service
53	*/
54	name: string;
55	/**
56	* Type of the service
57	*/
58	type: ServiceType \| string;
59	/**
60	* Optional array of subtypes of the service
61	*/
62	subtypes?: (ServiceType \| string)[];
63	/**
64	* Port of the service
65	*/
66	port: number;
67
68	/**
69	* The protocol the service uses. Default is TCP.
70	*/
71	protocol?: Protocol;
72	/**
73	* Defines a hostname under which the service can be reached.
74	* The specified hostname should not include the TLD.
75	* If undefined the service name will be used as default.
76	*/
77	hostname?: string;
78	/**
79	* If defined a txt record will be published with the given service.
80	*/
81	txt?: ServiceTxt;
82
83	/**
84	* Adds ability to set custom domain. Will default to "local".
85	* The domain will also be automatically appended to the hostname.
86	*/
87	domain?: string;
88	}
89
90	// eslint-disable-next-line @typescript-eslint/no-explicit-any
91	export type ServiceTxt = Record<string, any>;
92
93	export const enum ServiceState {	×
94	UNANNOUNCED = "unannounced",	×
95	PROBING = "probing",	×
96	ANNOUNCED = "announced",	×
97	}
98
99	export interface ServiceRecords {
100	ptr: PTRRecord; // this is the main type ptr record
101	subtypePTRs?: PTRRecord[];
102	metaQueryPtr: PTRRecord; // pointer for the "_services._dns-sd._udp.local" meta query
103	srv: SRVRecord;
104	txt: TXTRecord;
105	a: Record<string, ARecord>; // indexed by interface name
106	aaaa: Record<string, AAAARecord[]>; // indexed by interface name
107	reverseAddressPTRs: Record<string, PTRRecord>; // indexed by address
108	}
109
110	export const enum ServiceEvent {	×
111	/**
112	* Event is called when the Prober identifies that the name for the service is already used
113	* and thus resolve the name conflict by adjusting the name (e.g. adding '(2)' to the name).
114	* This change must be persisted and thus a listener must hook up to this event
115	* in order for the name to be persited.
116	*/
117	NAME_CHANGED = "name-change",	×
118	HOSTNAME_CHANGED = "hostname-change",	×
119	}
120
121	export const enum InternalServiceEvent {	×
122	PUBLISH = "publish",	×
123	UNPUBLISH = "unpublish",	×
124	RECORD_UPDATE = "records-update",	×
125	}
126
127	export type PublishCallback = (error?: Error) => void;
128	export type UnpublishCallback = (error?: Error) => void;
129
130	export declare interface CiaoService {
131
132	on(event: "name-change", listener: (name: string) => void): this;
133	on(event: "hostname-change", listener: (hostname: string) => void): this;
134
135	on(event: InternalServiceEvent.PUBLISH, listener: (callback: PublishCallback) => void): this;
136	on(event: InternalServiceEvent.UNPUBLISH, listener: (callback: UnpublishCallback) => void): this;
137	on(event: InternalServiceEvent.RECORD_UPDATE, listener: (records: AnswerRecord[], callback?: (error?: Error \| null) => void) => void): this;
138
139	emit(event: ServiceEvent.NAME_CHANGED, name: string): boolean;
140	emit(event: ServiceEvent.HOSTNAME_CHANGED, hostname: string): boolean;
141
142	emit(event: InternalServiceEvent.PUBLISH, callback: PublishCallback): boolean;
143	emit(event: InternalServiceEvent.UNPUBLISH, callback: UnpublishCallback): boolean;
144	emit(event: InternalServiceEvent.RECORD_UPDATE, records: AnswerRecord[], callback?: (error?: Error \| null) => void): boolean;
145
146	}
147
148	export class CiaoService extends EventEmitter {	×
149
150	private readonly networkManager: NetworkManager;
151
152	private name: string;
153	private readonly type: ServiceType \| string;
154	private readonly subTypes?: string[];
155	private readonly protocol: Protocol;
156	private readonly serviceDomain: string; // remember: can't be named "domain" => conflicts with EventEmitter
157
158	private fqdn: string; // fully qualified domain name
159	private readonly typePTR: string;
160	private readonly subTypePTRs?: string[];
161
162	private hostname: string; // formatted hostname
163	readonly port: number;
164
165	private txt?: Buffer[];
166
167	serviceState = ServiceState.UNANNOUNCED; // this field is entirely controlled by the Responder class	×
168	private serviceRecords: ServiceRecords;
169
170	constructor(networkManager: NetworkManager, options: ServiceOptions) {
171	super();	×
172	assert(networkManager, "networkManager is required");	×
173	assert(options, "parameters options is required");	×
174	assert(options.name, "service options parameter 'name' is required");	×
175	assert(options.type, "service options parameter 'type' is required");	×
176	assert(options.port, "service options parameter 'port' is required");	×
177	assert(options.type.length <= 15, "service options parameter 'type' must not be longer than 15 characters");	×
178
179	this.networkManager = networkManager;	×
180	this.networkManager.on(NetworkManagerEvent.INTERFACE_UPDATE, this.handleNetworkChange.bind(this));	×
181
182	this.name = options.name;	×
183	this.type = options.type;	×
184	this.subTypes = options.subtypes;	×
185	this.protocol = options.protocol \|\| Protocol.TCP;	×
186	this.serviceDomain = options.domain \|\| "local";	×
187
188	this.fqdn = this.formatFQDN();	×
189
190	this.typePTR = domainFormatter.stringify({ // something like '_hap._tcp.local'	×
191	type: this.type,
192	protocol: this.protocol,
193	domain: this.serviceDomain,
194	});
195
196	if (this.subTypes) {	×
197	this.subTypePTRs = this.subTypes.map(subtype => domainFormatter.stringify({	×
198	subtype: subtype,
199	type: this.type,
200	protocol: this.protocol,
201	domain: this.serviceDomain,
202	}));
203	}
204
205	this.hostname = domainFormatter.formatHostname(options.hostname \|\| this.name, this.serviceDomain)	×
206	.replace(/ /g, "-"); // replacing all spaces with dashes in the hostname
207	this.port = options.port;	×
208
209	if (options.txt) {	×
210	this.txt = CiaoService.txtBuffersFromRecord(options.txt);	×
211	}
212
213	// checks if hostname or name are already numbered and adjusts the numbers if necessary
214	this.incrementName(true); // must be done before the rebuildServiceRecords call	×
215
216	this.serviceRecords = this.rebuildServiceRecords(); // build the initial set of records	×
217	}
218
219	public advertise(): Promise<void> {
220	debug("[%s] Going to advertise service...", this.name);	×
221
222	if (this.listeners(ServiceEvent.NAME_CHANGED)) {	×
223	debug("[%s] WARN: No listeners found for a potential name change on the 'name-change' event!", this.name);	×
224	}
225	return new Promise((resolve, reject) => {	×
226	this.emit(InternalServiceEvent.PUBLISH, error => error? reject(error): resolve());	×
227	});
228	}
229
230	public end(): Promise<void> {
231	debug("[%s] Service is saying goodbye", this.name);	×
232	return new Promise((resolve, reject) => {	×
233	this.emit(InternalServiceEvent.UNPUBLISH, error => error? reject(error): resolve());	×
234	});
235	}
236
237	public getFQDN(): string {
238	return this.fqdn;	×
239	}
240
241	public getTypePTR(): string {
242	return this.typePTR;	×
243	}
244
245	public getSubtypePTRs(): string[] \| undefined {
246	return this.subTypePTRs;	×
247	}
248
249	public getHostname(): string {
250	return this.hostname;	×
251	}
252
253	/**
254	* Sets or updates the txt of the service
255	* @param txt - the new txt record
256	*/
257	public updateTxt(txt: ServiceTxt): Promise<void> {
258	assert(txt, "txt cannot be undefined");	×
259
260	this.txt = CiaoService.txtBuffersFromRecord(txt);	×
261	debug("[%s] Updating txt record...", this.name);	×
262
263	return new Promise((resolve, reject) => {	×
264	if (this.serviceState === ServiceState.ANNOUNCED) {	×
265	this.rebuildServiceRecords();	×
266	this.emit(InternalServiceEvent.RECORD_UPDATE, [this.txtRecord()], error => error? reject(error): resolve());	×
267	} else {
268	resolve();	×
269	}
270	});
271	}
272
273	private static txtBuffersFromRecord(txt: ServiceTxt): Buffer[] {
274	const result: Buffer[] = [];	×
275
276	Object.entries(txt).forEach(([key, value]) => {	×
277	const entry = key + "=" + value;	×
278	result.push(Buffer.from(entry));	×
279	});
280
281	return result;	×
282	}
283
284	private handleNetworkChange(change: NetworkChange): void {
285	if (this.serviceState !== ServiceState.ANNOUNCED) {	×
286	return; // service records are rebuilt short before the announce step	×
287	}
288
289	const added = change.added?.map(iface => iface.name) \|\| [];	×
290	const updated = change.updated?.map(iface => iface.newInterface.name) \|\| [];	×
291	const removed = change.removed?.map(iface => iface.name) \|\| [];	×
292
293	debug("[%s] Encountered network change: added: '%s'; updated: '%s'; removed: '%s'", this.name, added.join(", "), updated.join(", "), removed.join(", "));	×
294
295	const records: AnswerRecord[] = [];	×
296
297	if (change.updated) {	×
298	for (const interfaceChange of change.updated) {	×
299	for (const outdated of interfaceChange.outdatedAddresses) {	×
300	records.push({	×
301	name: this.hostname,
302	type: net.isIPv4(outdated)? Type.A: Type.AAAA,	×
303	ttl: 0,
304	data: outdated,
305	flush: true,
306	});
307	}
308
309	for (const updated of interfaceChange.updatedAddresses) {	×
310	records.push({	×
311	name: this.hostname,
312	type: net.isIPv4(updated)? Type.A: Type.AAAA,	×
313	ttl: 120,
314	data: updated,
315	flush: true,
316	});
317	}
318	}
319	}
320
321	this.rebuildServiceRecords();	×
322	// records for a removed interface are now no longer present after the call above
323	// records for a new interface got now built by the call above
324
325	if (records.length > 0) {	×
326	this.emit(InternalServiceEvent.RECORD_UPDATE, records);	×
327	}
328
329	if (added.length > 0) {	×
330	// TODO add support for this. We will need to announce the service on the newly appeared interface
331	// as a name conflict could appear there we would also do a Probing. As we probably do not want
332	// that we have different names on different interfaces we should just Probe an reannounce on ALL interfaces
333	console.log("CIAO: [" + this.name + "] Detected a new network interface appearing on the machine. The service probably " +	×
334	"needs to be announced on again on that interface. This is currently unsupported. " +
335	"Please restart the program so that the new interface is properly advertised!");
336	}
337	}
338
339	/**
340	* This method is called by the Prober when encountering a conflict on the network.
341	* It advices the service to change its name, like incrementing a number appended to the name.
342	* So "My Service" will become "My Service (2)", and "My Service (2)" would become "My Service (3)"
343	*/
344	incrementName(nameCheckOnly?: boolean): void {
345	if (this.serviceState !== ServiceState.UNANNOUNCED) {	×
346	throw new Error("Service name can only be incremented when in state UNANNOUNCED!");	×
347	}
348
349	const oldName = this.name;	×
350	const oldHostname = this.hostname;	×
351
352	let nameBase;
353	let nameNumber;
354
355	let hostnameBase;
356	let hostnameTLD;
357	let hostnameNumber;
358
359	const nameMatcher = this.name.match(numberedServiceNamePattern);	×
360	if (nameMatcher) { // if it matched. Extract the current nameNumber	×
361	nameBase = nameMatcher[1];	×
362	nameNumber = parseInt(nameMatcher[2]);	×
363
364	assert(nameNumber, `Failed to extract name number from ${this.name}. Resulted in ${nameNumber}`);	×
365	} else {
366	nameBase = this.name;	×
367	nameNumber = 1;	×
368	}
369
370	const hostnameMatcher = this.hostname.match(numberedHostnamePattern);	×
371	if (hostnameMatcher) { // if it matched. Extract the current nameNumber	×
372	hostnameBase = hostnameMatcher[1];	×
373	hostnameTLD = hostnameMatcher[3];	×
374	hostnameNumber = parseInt(hostnameMatcher[2]);	×
375
376	assert(hostnameNumber, `Failed to extract hostname number from ${this.hostname}. Resulted in ${hostnameNumber}`);	×
377	} else {
378	const lastDot = this.hostname.lastIndexOf(".");	×
379
380	hostnameBase = this.hostname.slice(0, lastDot);	×
381	hostnameTLD = this.hostname.slice(lastDot);	×
382	hostnameNumber = 1;	×
383	}
384
385	if (!nameCheckOnly) {	×
386	// increment the numbers
387	nameNumber++;	×
388	hostnameNumber++;	×
389	}
390
391	const newNumber = Math.max(nameNumber, hostnameNumber);	×
392
393	// reassemble the name
394	this.name = newNumber === 1? nameBase: `${nameBase} (${newNumber})`;	×
395	this.hostname = newNumber === 1? `${hostnameBase}${hostnameTLD}`: `${hostnameBase}-(${newNumber})${hostnameTLD}`;	×
396
397	this.fqdn = this.formatFQDN(); // update the fqdn	×
398
399	// we must inform the user that the names changed, so the new names can be persisted
400	// This is done after the Probing finish, as multiple name changes could happen in one probing session
401	// It is the responsibility of the Prober to call the informAboutNameUpdates function
402
403	if (this.name !== oldName \|\| this.hostname !== oldHostname) {	×
404	debug("[%s] Service changed name '%s' -> '%s', '%s' -> '%s'", this.name, oldName, this.name, oldHostname, this.hostname);	×
405	}
406
407	if (!nameCheckOnly) {	×
408	this.rebuildServiceRecords(); // rebuild all services	×
409	}
410	}
411
412	informAboutNameUpdates(): void {
413	// we trust the prober that this function is only called when the name was actually changed
414
415	const nameCalled = this.emit(ServiceEvent.NAME_CHANGED, this.name);	×
416	const hostnameCalled = this.emit(ServiceEvent.HOSTNAME_CHANGED, domainFormatter.removeTLD(this.hostname));	×
417
418	// at least one event should be listened to. We can figure out the number from one or another
419	if (!nameCalled && !hostnameCalled) {	×
420	console.warn(`CIAO: [${this.name}] Service changed name but nobody was listening on the 'name-change' event!`);	×
421	}
422	}
423
424	private formatFQDN(): string {
425	if (this.serviceState !== ServiceState.UNANNOUNCED) {	×
426	throw new Error("Name can't be changed after service was already announced!");	×
427	}
428
429	const fqdn = domainFormatter.stringify({	×
430	name: this.name,
431	type: this.type,
432	protocol: this.protocol,
433	domain: this.serviceDomain,
434	});
435
436	assert(fqdn.length <= 255, "A fully qualified domain name cannot be longer than 255 characters");	×
437	return fqdn;	×
438	}
439
440	rebuildServiceRecords(): ServiceRecords {
441	const aRecordMap: Record<string, ARecord> = {};	×
442	const aaaaRecordMap: Record<string, AAAARecord[]> = {};	×
443	const reverseAddressMap: Record<string, PTRRecord> = {};	×
444	let subtypePTRs: PTRRecord[] \| undefined = undefined;	×
445
446	for (const networkInterfaces of this.networkManager.getInterfaces()) {	×
447	if (networkInterfaces.ipv4) {	×
448	aRecordMap[networkInterfaces.name] = {	×
449	name: this.hostname,
450	type: Type.A,
451	ttl: 120,
452	data: networkInterfaces.ipv4,
453	flush: true,
454	};
455	reverseAddressMap[networkInterfaces.ipv4] = {	×
456	name: formatReverseAddressPTRName(networkInterfaces.ipv4),
457	type: Type.PTR,
458	ttl: 4500, // PTR records
459	data: this.hostname,
460	};
461	}
462
463	if (networkInterfaces.ipv6) {	×
464	aaaaRecordMap[networkInterfaces.name] = [{	×
465	name: this.hostname,
466	type: Type.AAAA,
467	ttl: 120,
468	data: networkInterfaces.ipv6,
469	flush: true,
470	}];
471	reverseAddressMap[networkInterfaces.ipv6] = {	×
472	name: formatReverseAddressPTRName(networkInterfaces.ipv6),
473	type: Type.PTR,
474	ttl: 4500, // PTR records
475	data: this.hostname,
476	};
477	}
478
479	if (networkInterfaces.routeAbleIpv6) {	×
480	let records = aaaaRecordMap[networkInterfaces.name];	×
481	if (!records) {	×
482	aaaaRecordMap[networkInterfaces.name] = records = [];	×
483	}
484
485	for (const ip6 of networkInterfaces.routeAbleIpv6) {	×
486	records.push({	×
487	name: this.hostname,
488	type: Type.AAAA,
489	ttl: 120,
490	data: ip6,
491	flush: true,
492	});
NEW 493	reverseAddressMap[ip6] = {	×
494	name: formatReverseAddressPTRName(ip6),
495	type: Type.PTR,
496	ttl: 4500, // PTR records
497	data: this.hostname,
498	};
499	}
500	}
501	}
502
503	if (this.subTypePTRs) {	×
504	subtypePTRs = [];	×
505	for (const ptr of this.subTypePTRs) {	×
506	subtypePTRs.push({	×
507	name: ptr,
508	type: Type.PTR,
509	ttl: 4500, // 75 minutes
510	data: this.fqdn,
511	});
512	}
513	}
514
515	debug("[%s] Rebuilding service records...", this.name);	×
516
517	return this.serviceRecords = {	×
518	ptr: {
519	name: this.typePTR,
520	type: Type.PTR,
521	ttl: 4500, // 75 minutes
522	data: this.fqdn,
523	},
524	subtypePTRs: subtypePTRs, // possibly undefined
525	metaQueryPtr: {
526	name: Responder.SERVICE_TYPE_ENUMERATION_NAME,
527	type: Type.PTR,
528	ttl: 4500, // 75 minutes
529	data: this.typePTR,
530	},
531	srv: {
532	name: this.fqdn,
533	type: Type.SRV,
534	ttl: 120,
535	data: {
536	target: this.hostname, // TODO we could just use the local hostname, and let the service respond to queries from the original responder
537	port: this.port,
538	},
539	flush: true,
540	},
541	txt: {
542	name: this.fqdn,
543	type: Type.TXT,
544	ttl: 4500, // 75 minutes
545	data: this.txt \|\| [],	×
546	flush: true,
547	},
548	a: aRecordMap,
549	aaaa: aaaaRecordMap,
550	reverseAddressPTRs: reverseAddressMap,
551	};
552	}
553
554	ptrRecord(): PTRRecord {
555	return CiaoService.copyRecord(this.serviceRecords.ptr);	×
556	}
557
558	subtypePtrRecords(): PTRRecord[] {
559	return this.serviceRecords.subtypePTRs? CiaoService.copyRecords(this.serviceRecords.subtypePTRs): [];	×
560	}
561
562	metaQueryPtrRecord(): PTRRecord {
563	return CiaoService.copyRecord(this.serviceRecords.metaQueryPtr);	×
564	}
565
566	srvRecord(): SRVRecord {
567	return CiaoService.copyRecord(this.serviceRecords.srv);	×
568	}
569
570	txtRecord(): TXTRecord {
571	return CiaoService.copyRecord(this.serviceRecords.txt);	×
572	}
573
574	aRecord(networkInterface: string): ARecord \| undefined {
575	// TODO include localhost record if the response comes from our own machine
576	const record = this.serviceRecords.a[networkInterface];	×
577	return record? CiaoService.copyRecord(record): undefined;	×
578	}
579
580	aaaaRecords(networkInterface: string): AAAARecord[] \| undefined {
581	// TODO include localhost record if the response comes from our own machine
582	const records = this.serviceRecords.aaaa[networkInterface];	×
583	return records? CiaoService.copyRecords(records): undefined;	×
584	}
585
586	allAddressRecords(): (ARecord \| AAAARecord)[] {
587	const records: (ARecord \| AAAARecord)[] = [];	×
588
589	records.push(...CiaoService.copyRecords(Object.values(this.serviceRecords.a)));	×
590	Object.values(this.serviceRecords.aaaa).forEach(recordArray => {	×
591	records.push(...CiaoService.copyRecords(recordArray));	×
592	});
593
594	return records;	×
595	}
596
597	reverseAddressMapping(address: string): PTRRecord \| undefined {
598	const record = this.serviceRecords.reverseAddressPTRs[address];	×
599	return record? CiaoService.copyRecord(record): undefined;	×
600	}
601
602	private static copyRecord<T extends RecordBase>(record: T): T {
603	// eslint-disable-next-line
604	// @ts-ignore
605	return {	×
606	name: record.name,
607	type: record.type,
608	ttl: record.ttl,
609	data: record.data,
610	class: record.class,
611	};
612	}
613
614	private static copyRecords<T extends RecordBase>(records: T[]): T[] {
615	const result: T[] = [];	×
616	for (const record of records) {	×
617	result.push(CiaoService.copyRecord(record));	×
618	}
619
620	return result;	×
621	}
622
623	}

homebridge / ciao / 130250602

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