131531548

Build Type

push

github

Committed by Supereg

Commit Message

Reducing the amount of rebinding happening on a network change (and some typo fixes here and there)

Run Details

73 of 603 branches covered (12.11%)

Branch coverage included in aggregate %.

0 of 14 new or added lines in 2 files covered. (0.0%)

4 existing lines in 3 files now uncovered.

153 of 1108 relevant lines covered (13.81%)

5.52 hits per line

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

0.0

/src/NetworkManager.ts

import assert from "assert";
import createDebug from "debug";
import { EventEmitter } from "events";
import deepEqual from "fast-deep-equal";
import net from "net";
import os, { NetworkInterfaceInfo } from "os";
import { arrayDifference } from "./util/array-utils";
import { getNetAddress } from "./util/domain-formatter";
import Timeout = NodeJS.Timeout;

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

export type NetworkId = string; // currently we identify the network by its ipv4 net address
export type InterfaceName = string;
export type MacAddress = string;

export type IPv4Address = string;
export type IPv6Address = string;
export type IPAddress = IPv4Address | IPv6Address;

interface NetworkInterface {
  name: InterfaceName;
  mac: MacAddress;

  // one of ipv4 or ipv6 will be present, most of the time even both
  ipv4?: IPv4Address;
  ipv4NetAddress?: IPv4Address; // address identifying the address for the ipv4 net
  ipv6?: IPv6Address;
  ipv6NetAddress?: IPv6Address; // address identifying the address for the ipv6 net

  routableIpv6?: IPv6Address[];
}

export const enum NetworkManagerEvent {
  NETWORK_UPDATE = "network-update",
}

export interface NetworkUpdate {
  added?: NetworkInformation[];
  removed?: NetworkInformation[];
  updated?: NetworkChange[];
}

export interface NetworkChange {
  networkId: NetworkId;

  removedInterfaces: InterfaceName[];
  addedInterfaces: InterfaceName[];

  changedDefaultIPv4Address?: IPv4Address;

  removedAddresses: IPAddress[];
  newAddresses: IPAddress[];
}

export interface NetworkManagerOptions {
  interface?: string | string[];
  excludeIpv6Only?: boolean;
}

export declare interface NetworkManager {

  on(event: "network-update", listener: (change: NetworkUpdate) => void): this;

  emit(event: "network-update", change: NetworkUpdate): boolean;

}

export class NetworkManager extends EventEmitter {

  private static readonly POLLING_TIME = 15 * 1000; // 15 seconds

  private readonly restrictedInterfaces?: InterfaceName[];
  private readonly excludeIpv6Only: boolean;

  private readonly participatingNetworks: Map<NetworkId, NetworkInformation>;

  private currentTimer?: Timeout;

  constructor(options?: NetworkManagerOptions) {
    super();

    if (options && options.interface) {
      if (typeof options.interface === "string" && net.isIP(options.interface)) {
        const interfaceName = NetworkManager.resolveInterface(options.interface);

        if (interfaceName) {
          this.restrictedInterfaces = [interfaceName];
        } else {
          console.log("CIAO: Interface was specified as ip (%s), though couldn't find a matching interface for the given address. " +
            "Going to fallback to bind on all available interfaces.", options.interface);
        }
      } else {
        this.restrictedInterfaces = Array.isArray(options.interface)? options.interface: [options.interface];
      }
    }
    this.excludeIpv6Only = !!(options && options.excludeIpv6Only);
    assert(this.excludeIpv6Only, "NetworkManager currently does not support including ipv6 only networks");

    this.participatingNetworks = this.getCurrentNetworkInformation();

    const networks: string[] = [];
    for (const network of this.participatingNetworks.values()) {
      networks.push(`[${network.getInterfaceNames().join(", ")}]`);
    }

    if (options) {
      debug("Created NetworkManager (initial networks [%s]; options: %s)", networks.join(", "), JSON.stringify(options));
    } else {
      debug("Created NetworkManager (initial networks [%s])", networks.join(", "));
    }

    this.scheduleNextJob();
  }

  public shutdown(): void {
    if (this.currentTimer) {
      clearTimeout(this.currentTimer);
      this.currentTimer = undefined;
    }
  }

  public getNetworkMap(): Map<NetworkId, NetworkInformation> {
    return this.participatingNetworks;
  }

  public getNetworks(): IterableIterator<NetworkInformation> {
    return this.participatingNetworks.values();
  }

  public getNetworkById(id: NetworkId): NetworkInformation | undefined {
    return this.participatingNetworks.get(id);
  }

  private scheduleNextJob(): void {
    const timer = setTimeout(this.checkForNewNetworks.bind(this), NetworkManager.POLLING_TIME);
    timer.unref(); // this timer won't prevent shutdown
  }

  private checkForNewNetworks(): void {
    debug("Checking for new networks...");

    const latestNetworks = this.getCurrentNetworkInformation();

    let added: NetworkInformation[] | undefined = undefined;
    let removed: NetworkInformation[] | undefined = undefined;
    let updated: NetworkChange[] | undefined = undefined;

    for (const [name, network] of latestNetworks) {
      const currentNetwork = this.participatingNetworks.get(name);

      if (currentNetwork) { // the network could potentially have changed
        if (!currentNetwork.equals(network)) { // the network actually changed
          const change = currentNetwork.changeNetwork(network);

          (updated || (updated = [])) // get or create array
            .push(change);

          assert(currentNetwork.equals(network), "Network is still different after update!");
        }
      } else { // the network was added
        this.participatingNetworks.set(name, network);
        (added || (added = [])) // get or create array
          .push(network);
      }
    }

    // at this point we updated any existing networks and added all new networks
    // thus if the length of below is not the same, networks must have been removed completely
    // this check ensures that we do not unnecessarily loop twice through our networks
    if (this.participatingNetworks.size !== latestNetworks.size) {
      for (const [name, network] of this.participatingNetworks) {
        if (!latestNetworks.has(name)) { // network was removed
          this.participatingNetworks.delete(name);
          (removed || (removed = [])) // get or create new array
            .push(network);
        }
      }
    }

    if (added || removed || updated) { // emit an event if changes happened
      debug("Detected network changes: %d added, %d removed, %d updated",
        added?.length || 0, removed?.length || 0, updated?.length || 0);

      this.emit(NetworkManagerEvent.NETWORK_UPDATE, {
        added: added,
        removed: removed,
        updated: updated,
      });
    }

    this.scheduleNextJob();
  }

  private getCurrentNetworkInterfaces(): Map<InterfaceName, NetworkInterface> {
    const interfaces: Map<InterfaceName, NetworkInterface> = new Map();

    Object.entries(os.networkInterfaces()).forEach(([name, infoArray]) => {
      if (!NetworkManager.validNetworkInterfaceName(name)) {
        return;
      }

      if (this.restrictedInterfaces && !this.restrictedInterfaces.includes(name)) {
        return;
      }

      let ipv4Info: NetworkInterfaceInfo | undefined = undefined;
      let ipv6Info: NetworkInterfaceInfo | undefined = undefined;
      let routableIpv6Infos: IPv6Address[] | undefined = undefined;
      let internal = false;

      for (const info of infoArray) {
        if (info.internal) {
          internal = true;
          break;
        }

        if (info.family === "IPv4" && !ipv4Info) {
          ipv4Info = info;
        } else if (info.family === "IPv6" && !ipv6Info) {
          if (info.scopeid) { // we only care about non zero scope (aka link-local ipv6)
            ipv6Info = info;
          } else if (info.scopeid === 0) { // global routable ipv6
            (routableIpv6Infos || (routableIpv6Infos = []))
              .push(info.address);
          }
        }
      }

      if (internal) {
        return; // we will not explicitly add the loopback interface
      }

      assert(ipv4Info || ipv6Info, "Could not find valid addresses for interface '" + name + "'");

      if (this.excludeIpv6Only && !ipv4Info) {
        return;
      }

      const networkInterface: NetworkInterface = {
        name: name,
        mac: (ipv4Info?.mac || ipv6Info?.mac)!,

        routableIpv6: routableIpv6Infos,
      };

      if (ipv4Info) {
        networkInterface.ipv4 = ipv4Info.address;
        networkInterface.ipv4NetAddress = getNetAddress(ipv4Info.address, ipv4Info.netmask);
      }

      if (ipv6Info) {
        networkInterface.ipv6 = ipv6Info.address;
        networkInterface.ipv6NetAddress = getNetAddress(ipv6Info.address, ipv6Info.netmask);
      }

      interfaces.set(name, networkInterface);
    });

    return interfaces;
  }

  private getCurrentNetworkInformation(): Map<NetworkId, NetworkInformation> {
    const networks: Map<NetworkId, NetworkInformation> = new Map();

    const interfaces = this.getCurrentNetworkInterfaces();

    for (const networkInterface of interfaces.values()) {
      if (!networkInterface.ipv4NetAddress || !networkInterface.ipv4) { // the ipv4 check is only that Typescript also knows
        /**
         * First of all, the MDNSServer does currently only advertise on ipv4, meaning ipv6 only
         * interfaces won't ever get advertised.
         * Secondly we currently ignore the ipv6 subnet address. When adding ipv6 support to the MDNSServer
         * one might need to rework this part here.
         * If two network interfaces share the same ipv4 subnet it does not necessarily mean that they share
         * the same ipv6 subnet.
         * Though keep in mind we return all ipv6 addresses when a query arrives on the ipv4 of a network interface.
         */
        continue;
      }

      const existingNetwork = networks.get(networkInterface.ipv4NetAddress); // we currently only compare ipv4 net address

      if (existingNetwork) {
        if (!existingNetwork.hasInterface(networkInterface)) {
          existingNetwork.addInterface(networkInterface);
        }
      } else {
        const network = new NetworkInformation(networkInterface);
        networks.set(networkInterface.ipv4NetAddress, network);
      }
    }

    return networks;
  }

  private static validNetworkInterfaceName(name: InterfaceName): boolean {
    // TODO are these all the available names?
    return os.platform() === "win32" // windows has some weird interface naming, just pass everything for now
      || name.startsWith("en") || name.startsWith("eth") || name.startsWith("wlan") || name.startsWith("wl");
  }

  private static resolveInterface(address: IPAddress): InterfaceName | undefined {
    let interfaceName: InterfaceName | undefined;

    outer: for (const [name, infoArray] of Object.entries(os.networkInterfaces())) {
      for (const info of infoArray) {
        if (info.address === address) {
          interfaceName = name;
          break outer; // exit out of both loops
        }
      }
    }

    return interfaceName;
  }

}

/**
 * All NetworkInterfaces sharing the same IPv4 netAddress will be grouped into one network.
 * Most of the time, if the ipv4 netaddress match the ipv6 netaddress will also match,
 * though this is not guaranteed, tough we currently ignore that,
 * as our MDNSServer implementation does only listen on tcp4 and not tcp6.
 * Additionally when a client requests all A and AAAA records we will always return
 * the ipv6 addresses of the interface the request came on, even though we can't verify if
 * the ipv6 address may not match.
 */
export class NetworkInformation {

  private interfaces: InterfaceName[]; // most of the time this will have a length of 1

  private ipv4: IPv4Address[]; // one ipv4 for every network interface
  private readonly ipv4NetAddress: IPv4Address; // one ipv6 for every network interface
  private ipv6?: IPv6Address[];
  //ip6NetAddress?: IPv6Address; // address identifying the address for the ipv6 net
  private routableIpv6?: IPv6Address[];

  private defaultIPv4Address: IPv4Address = "";

  // TODO mapping from interface to addresses (or vice versa)?

  constructor(networkInterface: NetworkInterface) {
    assert(networkInterface.ipv4, "Can't create Network without ipv4 (currently)");
    assert(networkInterface.ipv4NetAddress, "Can't create Network without ipv4 (currently)");

    // we currently do not keep track of the mac addresses of the network interfaces, as there is no use to this

    this.interfaces = [networkInterface.name];
    this.ipv4 = [networkInterface.ipv4!];
    this.ipv4NetAddress = networkInterface.ipv4NetAddress!;

    if (networkInterface.ipv6) {
      this.ipv6 = [networkInterface.ipv6];
    }

    if (networkInterface.routableIpv6) {
      this.routableIpv6 = [];
      this.routableIpv6.push(...networkInterface.routableIpv6);
    }

    this.getDefaultIPv4(); // ensure it is set
  }

  public getId(): NetworkId {
    return this.ipv4NetAddress;
  }

  public getIPv4Addresses(): IPv4Address[] {
    return this.ipv4;
  }

  public getIPv6Addresses(): IPv6Address[] {
    return this.ipv6 || [];
  }

  public hasAddress(address: IPAddress): boolean {
    return this.ipv4.includes(address) || (!!this.ipv6 && this.ipv6.includes(address)) || (!!this.routableIpv6 && this.routableIpv6.includes(address));
  }

  // noinspection JSUnusedGlobalSymbols
  public getRoutableIPv6Addresses(): IPv6Address[] {
    return this.routableIpv6 || [];
  }

  public getAddresses(): IPAddress[] {
    const addresses = this.ipv4.concat(this.ipv6? this.ipv6: []);
    if (this.routableIpv6) {
      addresses.push(...this.routableIpv6);
    }

    return addresses;
  }

  public getDefaultIPv4(): IPv4Address {
    if (this.defaultIPv4Address) {
      return this.defaultIPv4Address;
    }
    // basically just returns the first ipv4. This is used to bind the socket on for all interfaces on the network

    this.defaultIPv4Address = this.ipv4[0];
    assert(!!this.defaultIPv4Address, "default ipv4 is undefined!");
    return this.defaultIPv4Address;
  }

  // noinspection JSUnusedGlobalSymbols
  public hasInterface(name: InterfaceName): boolean;
  public hasInterface(name: NetworkInterface): boolean;
  public hasInterface(name: InterfaceName | NetworkInterface): boolean {
    if (typeof name === "string") {
      return this.interfaces.includes(name);
    } else {
      return this.interfaces.includes(name.name);
    }
  }

  public getInterfaceNames(): InterfaceName[] {
    return this.interfaces;
  }

  public addInterface(networkInterface: NetworkInterface): void {
    assert(this.ipv4NetAddress === networkInterface.ipv4NetAddress, "Cannot add a network interface to the network with a different net address");
    this.interfaces.push(networkInterface.name);

    if (networkInterface.ipv4) {
      this.ipv4.push(networkInterface.ipv4);
    }

    if (networkInterface.ipv6) {
      if (!this.ipv6) {
        this.ipv6 = [];
      }
      this.ipv6.push(networkInterface.ipv6);
    }

    if (networkInterface.routableIpv6) {
      if (!this.routableIpv6) {
        this.routableIpv6 = [];
      }
      this.routableIpv6.push(...networkInterface.routableIpv6);
    }
  }

  public changeNetwork(updated: NetworkInformation): NetworkChange {
    const interfaceDifference = arrayDifference(this.interfaces, updated.interfaces);
    const ipv4Difference = arrayDifference(this.ipv4, updated.ipv4);
    const ipv6Difference = arrayDifference(this.ipv6, updated.ipv6);
    const routableDifference = arrayDifference(this.routableIpv6, updated.routableIpv6);

    const oldDefaultIpv4 = this.getDefaultIPv4();

    const addedAddresses = ipv4Difference.added.concat(ipv6Difference.added).concat(routableDifference.added);
    const removedAddresses = ipv4Difference.removed.concat(ipv6Difference.removed).concat(routableDifference.removed);

    // preserve a predictable order
    this.interfaces = updated.interfaces;
    this.ipv4 = updated.ipv4;
    this.ipv6 = updated.ipv6;
    this.routableIpv6 = updated.routableIpv6;

    if (!this.hasAddress(oldDefaultIpv4)) {
      this.defaultIPv4Address = ""; // reset the default ip, it disappeared
      // calling getDefaultIPv4 again (like below) will set it to a new default again
    }

    return {
      networkId: this.ipv4NetAddress,

      addedInterfaces: interfaceDifference.added,
      removedInterfaces: interfaceDifference.removed,

      changedDefaultIPv4Address: oldDefaultIpv4 !== this.getDefaultIPv4()? this.getDefaultIPv4(): undefined,

      newAddresses: addedAddresses,
      removedAddresses: removedAddresses,
    };
  }

  public equals(network: NetworkInformation): boolean {
    return this.ipv4NetAddress === network.ipv4NetAddress && deepEqual(this.interfaces, network.interfaces)
      && deepEqual(this.ipv4, network.ipv4) && deepEqual(this.ipv6, network.ipv6)
      && deepEqual(this.routableIpv6, network.routableIpv6);
  }

}

1	import assert from "assert";	×
2	import createDebug from "debug";	×
3	import { EventEmitter } from "events";	×
4	import deepEqual from "fast-deep-equal";	×
5	import net from "net";	×
6	import os, { NetworkInterfaceInfo } from "os";	×
7	import { arrayDifference } from "./util/array-utils";	×
8	import { getNetAddress } from "./util/domain-formatter";	×
9	import Timeout = NodeJS.Timeout;
10
11	const debug = createDebug("ciao:NetworkManager");	×
12
13	export type NetworkId = string; // currently we identify the network by its ipv4 net address
14	export type InterfaceName = string;
15	export type MacAddress = string;
16
17	export type IPv4Address = string;
18	export type IPv6Address = string;
19	export type IPAddress = IPv4Address \| IPv6Address;
20
21	interface NetworkInterface {
22	name: InterfaceName;
23	mac: MacAddress;
24
25	// one of ipv4 or ipv6 will be present, most of the time even both
26	ipv4?: IPv4Address;
27	ipv4NetAddress?: IPv4Address; // address identifying the address for the ipv4 net
28	ipv6?: IPv6Address;
29	ipv6NetAddress?: IPv6Address; // address identifying the address for the ipv6 net
30
31	routableIpv6?: IPv6Address[];
32	}
33
34	export const enum NetworkManagerEvent {	×
35	NETWORK_UPDATE = "network-update",	×
36	}
37
38	export interface NetworkUpdate {
39	added?: NetworkInformation[];
40	removed?: NetworkInformation[];
41	updated?: NetworkChange[];
42	}
43
44	export interface NetworkChange {
45	networkId: NetworkId;
46
47	removedInterfaces: InterfaceName[];
48	addedInterfaces: InterfaceName[];
49
50	changedDefaultIPv4Address?: IPv4Address;
51
52	removedAddresses: IPAddress[];
53	newAddresses: IPAddress[];
54	}
55
56	export interface NetworkManagerOptions {
57	interface?: string \| string[];
58	excludeIpv6Only?: boolean;
59	}
60
61	export declare interface NetworkManager {
62
63	on(event: "network-update", listener: (change: NetworkUpdate) => void): this;
64
65	emit(event: "network-update", change: NetworkUpdate): boolean;
66
67	}
68
69	export class NetworkManager extends EventEmitter {	×
70
71	private static readonly POLLING_TIME = 15 * 1000; // 15 seconds	×
72
73	private readonly restrictedInterfaces?: InterfaceName[];
74	private readonly excludeIpv6Only: boolean;
75
76	private readonly participatingNetworks: Map<NetworkId, NetworkInformation>;
77
78	private currentTimer?: Timeout;
79
80	constructor(options?: NetworkManagerOptions) {
81	super();	×
82
83	if (options && options.interface) {	×
84	if (typeof options.interface === "string" && net.isIP(options.interface)) {	×
85	const interfaceName = NetworkManager.resolveInterface(options.interface);	×
86
87	if (interfaceName) {	×
88	this.restrictedInterfaces = [interfaceName];	×
89	} else {
90	console.log("CIAO: Interface was specified as ip (%s), though couldn't find a matching interface for the given address. " +	×
91	"Going to fallback to bind on all available interfaces.", options.interface);
92	}
93	} else {
94	this.restrictedInterfaces = Array.isArray(options.interface)? options.interface: [options.interface];	×
95	}
96	}
97	this.excludeIpv6Only = !!(options && options.excludeIpv6Only);	×
98	assert(this.excludeIpv6Only, "NetworkManager currently does not support including ipv6 only networks");	×
99
100	this.participatingNetworks = this.getCurrentNetworkInformation();	×
101
102	const networks: string[] = [];	×
103	for (const network of this.participatingNetworks.values()) {	×
104	networks.push(`[${network.getInterfaceNames().join(", ")}]`);	×
105	}
106
107	if (options) {	×
108	debug("Created NetworkManager (initial networks [%s]; options: %s)", networks.join(", "), JSON.stringify(options));	×
109	} else {
110	debug("Created NetworkManager (initial networks [%s])", networks.join(", "));	×
111	}
112
113	this.scheduleNextJob();	×
114	}
115
116	public shutdown(): void {
117	if (this.currentTimer) {	×
118	clearTimeout(this.currentTimer);	×
119	this.currentTimer = undefined;	×
120	}
121	}
122
123	public getNetworkMap(): Map<NetworkId, NetworkInformation> {
124	return this.participatingNetworks;	×
125	}
126
127	public getNetworks(): IterableIterator<NetworkInformation> {
128	return this.participatingNetworks.values();	×
129	}
130
131	public getNetworkById(id: NetworkId): NetworkInformation \| undefined {
132	return this.participatingNetworks.get(id);	×
133	}
134
135	private scheduleNextJob(): void {
136	const timer = setTimeout(this.checkForNewNetworks.bind(this), NetworkManager.POLLING_TIME);	×
137	timer.unref(); // this timer won't prevent shutdown	×
138	}
139
140	private checkForNewNetworks(): void {
141	debug("Checking for new networks...");	×
142
143	const latestNetworks = this.getCurrentNetworkInformation();	×
144
145	let added: NetworkInformation[] \| undefined = undefined;	×
146	let removed: NetworkInformation[] \| undefined = undefined;	×
147	let updated: NetworkChange[] \| undefined = undefined;	×
148
149	for (const [name, network] of latestNetworks) {	×
150	const currentNetwork = this.participatingNetworks.get(name);	×
151
152	if (currentNetwork) { // the network could potentially have changed	×
153	if (!currentNetwork.equals(network)) { // the network actually changed	×
154	const change = currentNetwork.changeNetwork(network);	×
155
156	(updated \|\| (updated = [])) // get or create array	×
157	.push(change);
158
NEW 159	assert(currentNetwork.equals(network), "Network is still different after update!");	×
160	}
161	} else { // the network was added
162	this.participatingNetworks.set(name, network);	×
163	(added \|\| (added = [])) // get or create array	×
164	.push(network);
165	}
166	}
167
168	// at this point we updated any existing networks and added all new networks
169	// thus if the length of below is not the same, networks must have been removed completely
170	// this check ensures that we do not unnecessarily loop twice through our networks
171	if (this.participatingNetworks.size !== latestNetworks.size) {	×
172	for (const [name, network] of this.participatingNetworks) {	×
173	if (!latestNetworks.has(name)) { // network was removed	×
174	this.participatingNetworks.delete(name);	×
175	(removed \|\| (removed = [])) // get or create new array	×
176	.push(network);
177	}
178	}
179	}
180
181	if (added \|\| removed \|\| updated) { // emit an event if changes happened	×
182	debug("Detected network changes: %d added, %d removed, %d updated",	×
183	added?.length \|\| 0, removed?.length \|\| 0, updated?.length \|\| 0);	×
184
185	this.emit(NetworkManagerEvent.NETWORK_UPDATE, {	×
186	added: added,
187	removed: removed,
188	updated: updated,
189	});
190	}
191
192	this.scheduleNextJob();	×
193	}
194
195	private getCurrentNetworkInterfaces(): Map<InterfaceName, NetworkInterface> {
196	const interfaces: Map<InterfaceName, NetworkInterface> = new Map();	×
197
198	Object.entries(os.networkInterfaces()).forEach(([name, infoArray]) => {	×
199	if (!NetworkManager.validNetworkInterfaceName(name)) {	×
200	return;	×
201	}
202
203	if (this.restrictedInterfaces && !this.restrictedInterfaces.includes(name)) {	×
204	return;	×
205	}
206
207	let ipv4Info: NetworkInterfaceInfo \| undefined = undefined;	×
208	let ipv6Info: NetworkInterfaceInfo \| undefined = undefined;	×
209	let routableIpv6Infos: IPv6Address[] \| undefined = undefined;	×
210	let internal = false;	×
211
212	for (const info of infoArray) {	×
213	if (info.internal) {	×
214	internal = true;	×
215	break;	×
216	}
217
218	if (info.family === "IPv4" && !ipv4Info) {	×
219	ipv4Info = info;	×
220	} else if (info.family === "IPv6" && !ipv6Info) {	×
221	if (info.scopeid) { // we only care about non zero scope (aka link-local ipv6)	×
222	ipv6Info = info;	×
223	} else if (info.scopeid === 0) { // global routable ipv6	×
224	(routableIpv6Infos \|\| (routableIpv6Infos = []))	×
225	.push(info.address);
226	}
227	}
228	}
229
230	if (internal) {	×
231	return; // we will not explicitly add the loopback interface	×
232	}
233
234	assert(ipv4Info \|\| ipv6Info, "Could not find valid addresses for interface '" + name + "'");	×
235
236	if (this.excludeIpv6Only && !ipv4Info) {	×
237	return;	×
238	}
239
240	const networkInterface: NetworkInterface = {	×
241	name: name,
242	mac: (ipv4Info?.mac \|\| ipv6Info?.mac)!,	×
243
244	routableIpv6: routableIpv6Infos,
245	};
246
247	if (ipv4Info) {	×
248	networkInterface.ipv4 = ipv4Info.address;	×
249	networkInterface.ipv4NetAddress = getNetAddress(ipv4Info.address, ipv4Info.netmask);	×
250	}
251
252	if (ipv6Info) {	×
253	networkInterface.ipv6 = ipv6Info.address;	×
254	networkInterface.ipv6NetAddress = getNetAddress(ipv6Info.address, ipv6Info.netmask);	×
255	}
256
257	interfaces.set(name, networkInterface);	×
258	});
259
260	return interfaces;	×
261	}
262
263	private getCurrentNetworkInformation(): Map<NetworkId, NetworkInformation> {
264	const networks: Map<NetworkId, NetworkInformation> = new Map();	×
265
266	const interfaces = this.getCurrentNetworkInterfaces();	×
267
268	for (const networkInterface of interfaces.values()) {	×
269	if (!networkInterface.ipv4NetAddress \|\| !networkInterface.ipv4) { // the ipv4 check is only that Typescript also knows	×
270	/**
271	* First of all, the MDNSServer does currently only advertise on ipv4, meaning ipv6 only
272	* interfaces won't ever get advertised.
273	* Secondly we currently ignore the ipv6 subnet address. When adding ipv6 support to the MDNSServer
274	* one might need to rework this part here.
275	* If two network interfaces share the same ipv4 subnet it does not necessarily mean that they share
276	* the same ipv6 subnet.
277	* Though keep in mind we return all ipv6 addresses when a query arrives on the ipv4 of a network interface.
278	*/
279	continue;	×
280	}
281
282	const existingNetwork = networks.get(networkInterface.ipv4NetAddress); // we currently only compare ipv4 net address	×
283
284	if (existingNetwork) {	×
285	if (!existingNetwork.hasInterface(networkInterface)) {	×
286	existingNetwork.addInterface(networkInterface);	×
287	}
288	} else {
289	const network = new NetworkInformation(networkInterface);	×
290	networks.set(networkInterface.ipv4NetAddress, network);	×
291	}
292	}
293
294	return networks;	×
295	}
296
297	private static validNetworkInterfaceName(name: InterfaceName): boolean {
298	// TODO are these all the available names?
299	return os.platform() === "win32" // windows has some weird interface naming, just pass everything for now	×
300	\|\| name.startsWith("en") \|\| name.startsWith("eth") \|\| name.startsWith("wlan") \|\| name.startsWith("wl");
301	}
302
303	private static resolveInterface(address: IPAddress): InterfaceName \| undefined {
304	let interfaceName: InterfaceName \| undefined;
305
306	outer: for (const [name, infoArray] of Object.entries(os.networkInterfaces())) {	×
307	for (const info of infoArray) {	×
308	if (info.address === address) {	×
309	interfaceName = name;	×
310	break outer; // exit out of both loops	×
311	}
312	}
313	}
314
315	return interfaceName;	×
316	}
317
318	}
319
320	/**
321	* All NetworkInterfaces sharing the same IPv4 netAddress will be grouped into one network.
322	* Most of the time, if the ipv4 netaddress match the ipv6 netaddress will also match,
323	* though this is not guaranteed, tough we currently ignore that,
324	* as our MDNSServer implementation does only listen on tcp4 and not tcp6.
325	* Additionally when a client requests all A and AAAA records we will always return
326	* the ipv6 addresses of the interface the request came on, even though we can't verify if
327	* the ipv6 address may not match.
328	*/
329	export class NetworkInformation {	×
330
331	private interfaces: InterfaceName[]; // most of the time this will have a length of 1
332
333	private ipv4: IPv4Address[]; // one ipv4 for every network interface
334	private readonly ipv4NetAddress: IPv4Address; // one ipv6 for every network interface
335	private ipv6?: IPv6Address[];
336	//ip6NetAddress?: IPv6Address; // address identifying the address for the ipv6 net
337	private routableIpv6?: IPv6Address[];
338
NEW 339	private defaultIPv4Address: IPv4Address = "";	×
340
341	// TODO mapping from interface to addresses (or vice versa)?
342
343	constructor(networkInterface: NetworkInterface) {
344	assert(networkInterface.ipv4, "Can't create Network without ipv4 (currently)");	×
345	assert(networkInterface.ipv4NetAddress, "Can't create Network without ipv4 (currently)");	×
346
347	// we currently do not keep track of the mac addresses of the network interfaces, as there is no use to this
348
349	this.interfaces = [networkInterface.name];	×
350	this.ipv4 = [networkInterface.ipv4!];	×
351	this.ipv4NetAddress = networkInterface.ipv4NetAddress!;	×
352
353	if (networkInterface.ipv6) {	×
354	this.ipv6 = [networkInterface.ipv6];	×
355	}
356
357	if (networkInterface.routableIpv6) {	×
358	this.routableIpv6 = [];	×
359	this.routableIpv6.push(...networkInterface.routableIpv6);	×
360	}
361
NEW 362	this.getDefaultIPv4(); // ensure it is set	×
363	}
364
365	public getId(): NetworkId {
366	return this.ipv4NetAddress;	×
367	}
368
369	public getIPv4Addresses(): IPv4Address[] {
370	return this.ipv4;	×
371	}
372
373	public getIPv6Addresses(): IPv6Address[] {
374	return this.ipv6 \|\| [];	×
375	}
376
377	public hasAddress(address: IPAddress): boolean {
NEW 378	return this.ipv4.includes(address) \|\| (!!this.ipv6 && this.ipv6.includes(address)) \|\| (!!this.routableIpv6 && this.routableIpv6.includes(address));	×
379	}
380
381	// noinspection JSUnusedGlobalSymbols
382	public getRoutableIPv6Addresses(): IPv6Address[] {
383	return this.routableIpv6 \|\| [];	×
384	}
385
386	public getAddresses(): IPAddress[] {
387	const addresses = this.ipv4.concat(this.ipv6? this.ipv6: []);	×
388	if (this.routableIpv6) {	×
389	addresses.push(...this.routableIpv6);	×
390	}
391
392	return addresses;	×
393	}
394
395	public getDefaultIPv4(): IPv4Address {
NEW 396	if (this.defaultIPv4Address) {	×
NEW 397	return this.defaultIPv4Address;	×
398	}
399	// basically just returns the first ipv4. This is used to bind the socket on for all interfaces on the network
400
NEW 401	this.defaultIPv4Address = this.ipv4[0];	×
NEW 402	assert(!!this.defaultIPv4Address, "default ipv4 is undefined!");	×
NEW 403	return this.defaultIPv4Address;	×
404	}
405
406	// noinspection JSUnusedGlobalSymbols
407	public hasInterface(name: InterfaceName): boolean;
408	public hasInterface(name: NetworkInterface): boolean;
409	public hasInterface(name: InterfaceName \| NetworkInterface): boolean {
410	if (typeof name === "string") {	×
411	return this.interfaces.includes(name);	×
412	} else {
413	return this.interfaces.includes(name.name);	×
414	}
415	}
416
417	public getInterfaceNames(): InterfaceName[] {
418	return this.interfaces;	×
419	}
420
421	public addInterface(networkInterface: NetworkInterface): void {
422	assert(this.ipv4NetAddress === networkInterface.ipv4NetAddress, "Cannot add a network interface to the network with a different net address");	×
423	this.interfaces.push(networkInterface.name);	×
424
425	if (networkInterface.ipv4) {	×
426	this.ipv4.push(networkInterface.ipv4);	×
427	}
428
429	if (networkInterface.ipv6) {	×
430	if (!this.ipv6) {	×
431	this.ipv6 = [];	×
432	}
433	this.ipv6.push(networkInterface.ipv6);	×
434	}
435
436	if (networkInterface.routableIpv6) {	×
437	if (!this.routableIpv6) {	×
438	this.routableIpv6 = [];	×
439	}
440	this.routableIpv6.push(...networkInterface.routableIpv6);	×
441	}
442	}
443
444	public changeNetwork(updated: NetworkInformation): NetworkChange {
445	const interfaceDifference = arrayDifference(this.interfaces, updated.interfaces);	×
446	const ipv4Difference = arrayDifference(this.ipv4, updated.ipv4);	×
447	const ipv6Difference = arrayDifference(this.ipv6, updated.ipv6);	×
448	const routableDifference = arrayDifference(this.routableIpv6, updated.routableIpv6);	×
449
450	const oldDefaultIpv4 = this.getDefaultIPv4();	×
451
452	const addedAddresses = ipv4Difference.added.concat(ipv6Difference.added).concat(routableDifference.added);	×
453	const removedAddresses = ipv4Difference.removed.concat(ipv6Difference.removed).concat(routableDifference.removed);	×
454
455	// preserve a predictable order
456	this.interfaces = updated.interfaces;	×
457	this.ipv4 = updated.ipv4;	×
458	this.ipv6 = updated.ipv6;	×
459	this.routableIpv6 = updated.routableIpv6;	×
460
NEW 461	if (!this.hasAddress(oldDefaultIpv4)) {	×
NEW 462	this.defaultIPv4Address = ""; // reset the default ip, it disappeared	×
463	// calling getDefaultIPv4 again (like below) will set it to a new default again
464	}
465
UNCOV 466	return {	×
467	networkId: this.ipv4NetAddress,
468
469	addedInterfaces: interfaceDifference.added,
470	removedInterfaces: interfaceDifference.removed,
471
472	changedDefaultIPv4Address: oldDefaultIpv4 !== this.getDefaultIPv4()? this.getDefaultIPv4(): undefined,	×
473
474	newAddresses: addedAddresses,
475	removedAddresses: removedAddresses,
476	};
477	}
478
479	public equals(network: NetworkInformation): boolean {
480	return this.ipv4NetAddress === network.ipv4NetAddress && deepEqual(this.interfaces, network.interfaces)	×
481	&& deepEqual(this.ipv4, network.ipv4) && deepEqual(this.ipv6, network.ipv6)
482	&& deepEqual(this.routableIpv6, network.routableIpv6);
483	}
484
485	}

homebridge / ciao / 131531548

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