163594882

Build Type

push

github

Committed by Supereg

Commit Message

Checking packet is coming from the same subnet

Run Details

327 of 1088 branches covered (30.06%)

Branch coverage included in aggregate %.

1 of 10 new or added lines in 2 files covered. (10.0%)

4 existing lines in 2 files now uncovered.

1032 of 2386 relevant lines covered (43.25%)

30.39 hits per line

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

6.39

/src/MDNSServer.ts

import assert from "assert";
import createDebug from "debug";
import dgram, { Socket } from "dgram";
import { AddressInfo } from "net";
import {
  DNSPacket,
  DNSProbeQueryDefinition,
  DNSQueryDefinition,
  DNSResponseDefinition,
  OpCode,
  PacketType,
  RCode,
} from "./coder/DNSPacket";
import { InterfaceName, IPFamily, NetworkManager, NetworkManagerEvent, NetworkUpdate } from "./NetworkManager";
import { getNetAddress } from "./util/domain-formatter";

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

export interface EndpointInfo {
  address: string;
  port: number;
  interface: string;
}

export type SendCallback = (error?: Error | null) => void;

/**
 * Defines the options passed to the underlying mdns server.
 */
export interface MDNSServerOptions {
  /**
   * If specified, the mdns server will only listen on the specified interfaces (allowlist).
   * It can be supplied as a string (representing a single interface) or as an array of strings
   * to define multiple interfaces.
   * The interface can be defined by specifying the interface name (like 'en0') or
   * by specifying an ip address.
   */
  interface?: string | string[];
}

export interface PacketHandler {

  handleQuery(packet: DNSPacket, rinfo: EndpointInfo): void;

  handleResponse(packet: DNSPacket, rinfo: EndpointInfo): void;

}

interface SocketError {
  name: string;
  error: Error;
}

/**
 * This class can be used to create a mdns server to send and receive mdns packets on the local network.
 *
 * Currently only udp4 sockets will be advertised.
 */
export class MDNSServer {

  public static readonly MTU = process.env.CIAO_MTU? parseInt(process.env.CIAO_MTU): 1500;
  public static readonly DEFAULT_IP4_HEADER = 20;
  public static readonly DEFAULT_IP6_HEADER = 40;
  public static readonly UDP_HEADER = 8;

  public static readonly MDNS_PORT = 5353;
  public static readonly MDNS_TTL = 255;
  public static readonly MULTICAST_IPV4 = "224.0.0.251";
  public static readonly MULTICAST_IPV6 = "FF02::FB";

  private readonly handler: PacketHandler;
  private readonly networkManager: NetworkManager;

  private readonly sockets: Map<InterfaceName, Socket> = new Map();

  // RFC 6762 15.1. If we are not the first responder bound to 5353 we can't receive unicast responses
  // thus the QU flag must not be used in queries. Responders are only affected when sending probe queries.
  // Probe queries should be sent with QU set, though can't be sent with QU when we can't receive unicast responses.
  private suppressUnicastResponseFlag = false;

  private bound = false;
  private closed = false;

  constructor(handler: PacketHandler, options?: MDNSServerOptions) {
    assert(handler, "handler cannot be undefined");
    this.handler = handler;

    this.networkManager = new NetworkManager({
      interface: options && options.interface,
      excludeIpv6Only: true,
    });
    this.networkManager.on(NetworkManagerEvent.NETWORK_UPDATE, this.handleUpdatedNetworkInterfaces.bind(this));

    this.networkManager.waitForInit().then(() => {
      for (const name of this.networkManager.getInterfaceMap().keys()) {
        const multicast = this.createDgramSocket(name, true);

        this.sockets.set(name, multicast);
      }
    });
  }

  public getNetworkManager(): NetworkManager {
    return this.networkManager;
  }

  public getInterfaceNames(): IterableIterator<InterfaceName> {
    return this.networkManager.getInterfaceMap().keys();
  }

  public getNetworkCount(): number {
    return this.sockets.size;
  }

  public async bind(): Promise<void> {
    if (this.closed) {
      throw new Error("Cannot rebind closed server!");
    }

    // RFC 6762 15.1. suggest that we probe if we are not the only socket.
    // though as ciao will probably always be installed besides an existing mdns responder, we just assume that without probing
    // As it only affects probe queries, impact isn't that big.
    this.suppressUnicastResponseFlag = true;

    await this.networkManager.waitForInit();
    const promises: Promise<void>[] = [];
    for (const [name, socket] of this.sockets) {
      promises.push(this.bindSocket(socket, name, IPFamily.IPv4));
    }

    return Promise.all(promises).then(() => {
      this.bound = true;
      // map void[] to void
    });
  }

  public shutdown(): void {
    this.networkManager.shutdown();

    for (const socket of this.sockets.values()) {
      socket.close();
    }

    this.bound = false;
    this.closed = true;

    this.sockets.clear();
  }

  public sendQueryBroadcast(query: DNSQueryDefinition | DNSProbeQueryDefinition, callback?: SendCallback): void {
    const packets = DNSPacket.createDNSQueryPackets(query, MDNSServer.MTU, IPFamily.IPv4);
    if (packets.length > 1) {
      debug("Query broadcast is split into %d packets!", packets.length);
    }

    const promises: Promise<void>[] = [];
    for (const packet of packets) {
      promises.push(this.sendOnAllNetworks(packet));
    }

    Promise.all(promises).then(() => {
      if (callback) {
        callback();
      }
    }, (error: SocketError) => {
      callback? callback(error.error): MDNSServer.handleSocketError(error.name, error.error);
    });
  }

  public sendResponseBroadcast(response: DNSResponseDefinition, callback?: SendCallback): void {
    const packets = DNSPacket.createDNSResponsePackets(response, MDNSServer.MTU, IPFamily.IPv4);
    if (packets.length > 1) {
      debug("Response broadcast is split into %d packets!", packets.length);
    }

    const promises: Promise<void>[] = [];
    for (const packet of packets) {
      promises.push(this.sendOnAllNetworks(packet));
    }

    Promise.all(promises).then(() => {
      if (callback) {
        callback();
      }
    }, (error: SocketError) => {
      callback? callback(error.error): MDNSServer.handleSocketError(error.name, error.error);
    });
  }

  public sendResponse(response: DNSResponseDefinition, endpoint: EndpointInfo, callback?: SendCallback): void;
  public sendResponse(response: DNSResponseDefinition, interfaceName: InterfaceName, callback?: SendCallback): void;
  public sendResponse(response: DNSResponseDefinition, endpointOrInterface: EndpointInfo | InterfaceName, callback?: SendCallback): void {
    const packets = DNSPacket.createDNSResponsePackets(response, MDNSServer.MTU, IPFamily.IPv4);
    if (packets.length > 1) {
      debug("Response is split into %d packets!", packets.length);
    }

    const promises: Promise<void>[] = [];
    for (const packet of packets) {
      promises.push(this.send(packet, endpointOrInterface));
    }

    Promise.all(promises).then(() => {
      if (callback) {
        callback();
      }
    }, (error: SocketError) => {
      callback? callback(error.error): MDNSServer.handleSocketError(error.name, error.error);
    });
  }

  private sendOnAllNetworks(packet: DNSPacket): Promise<void> {
    this.checkUnicastResponseFlag(packet);

    const message = packet.encode();
    this.assertBeforeSend(message, IPFamily.IPv4);

    const promises: Promise<void>[] = [];
    for (const [name, socket] of this.sockets) {
      const promise = new Promise<void>((resolve, reject) => {
        socket.send(message, MDNSServer.MDNS_PORT, MDNSServer.MULTICAST_IPV4, error => {
          if (error) {
            const socketError: SocketError = { name: name, error: error };
            reject(socketError);
          } else {
            resolve();
          }
        });
      });
      promises.push(promise);
    }

    return Promise.all(promises).then(() => {
      // map void[] to void
    });
  }

  private send(packet: DNSPacket, endpointOrInterface: EndpointInfo | InterfaceName): Promise<void> {
    this.checkUnicastResponseFlag(packet);

    const message = packet.encode();
    this.assertBeforeSend(message, IPFamily.IPv4);

    let address: string;
    let port: number;
    let name: string;

    if (typeof endpointOrInterface === "string") { // its a network interface name
      address = MDNSServer.MULTICAST_IPV4;
      port = MDNSServer.MDNS_PORT;
      name = endpointOrInterface;
    } else {
      address = endpointOrInterface.address;
      port = endpointOrInterface.port;
      name = endpointOrInterface.interface;
    }

    const socket = this.sockets.get(name);
    assert(socket, `Could not find socket for given network interface '${name}'`);

    return new Promise<void>((resolve, reject) => {
      socket!.send(message, port, address, error => {
        if (error) {
          const socketError: SocketError = { name: name, error: error };
          reject(socketError);
        } else {
          resolve();
        }
      });
    });
  }

  private checkUnicastResponseFlag(packet: DNSPacket): void {
    if (this.suppressUnicastResponseFlag && packet.type === PacketType.QUERY) {
      packet.questions.forEach(record => record.unicastResponseFlag = false);
    }
  }

  private assertBeforeSend(message: Buffer, family: IPFamily): void {
    assert(this.bound, "Cannot send packets before server is not bound!");
    assert(!this.closed, "Cannot send packets on a closed mdns server!");

    const ipHeaderSize = family === IPFamily.IPv4? MDNSServer.DEFAULT_IP4_HEADER: MDNSServer.DEFAULT_IP6_HEADER;

    // RFC 6762 17.
    assert(ipHeaderSize + MDNSServer.UDP_HEADER + message.length <= 9000,
      "DNS cannot exceed the size of 9000 bytes even with IP Fragmentation!");
  }

  private createDgramSocket(name: InterfaceName, reuseAddr = false, type: "udp4" | "udp6" = "udp4"): Socket {
    const socket = dgram.createSocket({
      type: type,
      reuseAddr: reuseAddr,
    });

    socket.on("message", this.handleMessage.bind(this, name));
    socket.on("error", MDNSServer.handleSocketError.bind(this, name));

    return socket;
  }

  private bindSocket(socket: Socket, name: InterfaceName, family: IPFamily): Promise<void> {
    const networkInterface = this.networkManager.getInterface(name);
    assert(networkInterface, `Could not find network interface '${name}' in network manager which socket is going to be bind to!`);

    return new Promise((resolve, reject) => {
      const errorHandler = (error: Error | number): void => reject(error);
      socket.once("error", errorHandler);

      socket.bind(MDNSServer.MDNS_PORT, () => {
        socket.removeListener("error", errorHandler);

        const multicastAddress = family === IPFamily.IPv4? MDNSServer.MULTICAST_IPV4: MDNSServer.MULTICAST_IPV6;
        const interfaceAddress = family === IPFamily.IPv4? networkInterface!.ipv4: networkInterface!.ipv6;
        assert(interfaceAddress, "Interface address cannot be undefined!");

        socket.addMembership(multicastAddress, interfaceAddress!);

        socket.setMulticastInterface(interfaceAddress!);

        socket.setMulticastTTL(MDNSServer.MDNS_TTL); // outgoing multicast datagrams
        socket.setTTL(MDNSServer.MDNS_TTL); // outgoing unicast datagrams

        socket.setMulticastLoopback(true);

        resolve();
      });
    });
  }

  private handleMessage(name: InterfaceName, buffer: Buffer, rinfo: AddressInfo): void {
    if (!this.bound) {
      return;
    }

    const networkInterface = this.networkManager.getInterface(name);
    if (!networkInterface) {
      debug("Received packet on non existing network interface: %s!", name);
      return;
    }
    const ip4Netaddress = getNetAddress(rinfo.address, networkInterface.ip4Netmask!);
    if (ip4Netaddress !== networkInterface.ipv4Netaddress) {
      debug("Dropping packet on %s coming from %s as subnet doesn't match!", name, rinfo.address);
      return;
    }

    let packet: DNSPacket;
    try {
      // TODO parse packet on the fly, a lot of RESPONSE packets will never be used
      packet = DNSPacket.decode(buffer);
    } catch (error) {
      debug("Received malformed packet from %s: %s", JSON.stringify(rinfo), error.message);
      debug(error.stack); // might be a bit spammy, but not having the error cause when it's maybe needed is not better
      return;
    }

    if (packet.opcode !== OpCode.QUERY) {
      // RFC 6762 18.3 we MUST ignore messages with opcodes other than zero (QUERY)
      return;
    }

    if (packet.rcode !== RCode.NoError) {
      // RFC 6762 18.3 we MUST ignore messages with response code other than zero (NoError)
      return;
    }

    const endpoint: EndpointInfo = {
      address: rinfo.address,
      port: rinfo.port,
      interface: name,
    };

    if (packet.type === PacketType.QUERY) {
      this.handler.handleQuery(packet, endpoint);
    } else if (packet.type === PacketType.RESPONSE) {
      if (rinfo.port !== MDNSServer.MDNS_PORT) {
        // RFC 6762 6.  Multicast DNS implementations MUST silently ignore any Multicast DNS responses
        //    they receive where the source UDP port is not 5353.
        return;
      }

      this.handler.handleResponse(packet, endpoint);
    }
  }

  private static handleSocketError(name: InterfaceName, error: Error): void {
    console.warn(`Encountered MDNS socket error on socket '${name}' : ${error.message}`);
    console.warn(error.stack);
  }

  private handleUpdatedNetworkInterfaces(networkUpdate: NetworkUpdate): void {
    if (networkUpdate.removed) {
      for (const networkInterface of networkUpdate.removed) {
        const socket = this.sockets.get(networkInterface.name);
        this.sockets.delete(networkInterface.name);

        if (socket) {
          socket.close();
        }
      }
    }

    if (networkUpdate.changes) {
      for (const change of networkUpdate.changes) {
        const socket = this.sockets.get(change.name);
        assert(socket, "Couldn't find socket for network change!");

        if (!change.outdatedIpv4 && change.updatedIpv4) {
          // this does currently not happen, as we exclude ipv6 only interfaces
          // thus such a change would be happening through the ADDED array
          assert.fail("Reached illegal state! IPv4 address changed from undefined to defined!");
        } else if (change.outdatedIpv4 && !change.updatedIpv4) {
          // this does currently not happen, as we exclude ipv6 only interfaces
          // thus such a change would be happening through the REMOVED array
          assert.fail("Reached illegal state! IPV4 address change from defined to undefined!");
        } else if (change.outdatedIpv4 && change.updatedIpv4) {
          try {
            socket!.dropMembership(MDNSServer.MULTICAST_IPV4, change.outdatedIpv4);
          } catch (error) {
            debug("Thrown expected error when dropping outdated address membership: " + error.message);
          }
          try {
            socket!.addMembership(MDNSServer.MULTICAST_IPV4, change.updatedIpv4);
          } catch (error) {
            debug("Thrown expected error when adding new address membership: " + error.message);
          }

          socket!.setMulticastInterface(change.updatedIpv4);
        }
      }
    }

    if (networkUpdate.added) {
      for (const networkInterface of networkUpdate.added) {
        const socket = this.createDgramSocket(networkInterface.name, true);
        this.bindSocket(socket, networkInterface.name, IPFamily.IPv4).then(() => {
          this.sockets.set(networkInterface.name, socket);
        });
      }
    }
  }

}

1	import assert from "assert";	9✔
2	import createDebug from "debug";	9✔
3	import dgram, { Socket } from "dgram";	9✔
4	import { AddressInfo } from "net";
5	import {	9✔
6	DNSPacket,
7	DNSProbeQueryDefinition,
8	DNSQueryDefinition,
9	DNSResponseDefinition,
10	OpCode,
11	PacketType,
12	RCode,
13	} from "./coder/DNSPacket";
14	import { InterfaceName, IPFamily, NetworkManager, NetworkManagerEvent, NetworkUpdate } from "./NetworkManager";	9✔
15	import { getNetAddress } from "./util/domain-formatter";	9✔
16
17	const debug = createDebug("ciao:MDNSServer");	9✔
18
19	export interface EndpointInfo {
20	address: string;
21	port: number;
22	interface: string;
23	}
24
25	export type SendCallback = (error?: Error \| null) => void;
26
27	/**
28	* Defines the options passed to the underlying mdns server.
29	*/
30	export interface MDNSServerOptions {
31	/**
32	* If specified, the mdns server will only listen on the specified interfaces (allowlist).
33	* It can be supplied as a string (representing a single interface) or as an array of strings
34	* to define multiple interfaces.
35	* The interface can be defined by specifying the interface name (like 'en0') or
36	* by specifying an ip address.
37	*/
38	interface?: string \| string[];
39	}
40
41	export interface PacketHandler {
42
43	handleQuery(packet: DNSPacket, rinfo: EndpointInfo): void;
44
45	handleResponse(packet: DNSPacket, rinfo: EndpointInfo): void;
46
47	}
48
49	interface SocketError {
50	name: string;
51	error: Error;
52	}
53
54	/**
55	* This class can be used to create a mdns server to send and receive mdns packets on the local network.
56	*
57	* Currently only udp4 sockets will be advertised.
58	*/
59	export class MDNSServer {	9✔
60
61	public static readonly MTU = process.env.CIAO_MTU? parseInt(process.env.CIAO_MTU): 1500;	9!
62	public static readonly DEFAULT_IP4_HEADER = 20;	9✔
63	public static readonly DEFAULT_IP6_HEADER = 40;	9✔
64	public static readonly UDP_HEADER = 8;	9✔
65
66	public static readonly MDNS_PORT = 5353;	9✔
67	public static readonly MDNS_TTL = 255;	9✔
68	public static readonly MULTICAST_IPV4 = "224.0.0.251";	9✔
69	public static readonly MULTICAST_IPV6 = "FF02::FB";	9✔
70
71	private readonly handler: PacketHandler;
72	private readonly networkManager: NetworkManager;
73
74	private readonly sockets: Map<InterfaceName, Socket> = new Map();	×
75
76	// RFC 6762 15.1. If we are not the first responder bound to 5353 we can't receive unicast responses
77	// thus the QU flag must not be used in queries. Responders are only affected when sending probe queries.
78	// Probe queries should be sent with QU set, though can't be sent with QU when we can't receive unicast responses.
79	private suppressUnicastResponseFlag = false;	×
80
81	private bound = false;	×
82	private closed = false;	×
83
84	constructor(handler: PacketHandler, options?: MDNSServerOptions) {
85	assert(handler, "handler cannot be undefined");	×
86	this.handler = handler;	×
87
88	this.networkManager = new NetworkManager({	×
89	interface: options && options.interface,	×
90	excludeIpv6Only: true,
91	});
92	this.networkManager.on(NetworkManagerEvent.NETWORK_UPDATE, this.handleUpdatedNetworkInterfaces.bind(this));	×
93
94	this.networkManager.waitForInit().then(() => {	×
95	for (const name of this.networkManager.getInterfaceMap().keys()) {	×
96	const multicast = this.createDgramSocket(name, true);	×
97
98	this.sockets.set(name, multicast);	×
99	}
100	});
101	}
102
103	public getNetworkManager(): NetworkManager {
104	return this.networkManager;	×
105	}
106
107	public getInterfaceNames(): IterableIterator<InterfaceName> {
108	return this.networkManager.getInterfaceMap().keys();	×
109	}
110
111	public getNetworkCount(): number {
112	return this.sockets.size;	×
113	}
114
115	public async bind(): Promise<void> {
116	if (this.closed) {	×
117	throw new Error("Cannot rebind closed server!");	×
118	}
119
120	// RFC 6762 15.1. suggest that we probe if we are not the only socket.
121	// though as ciao will probably always be installed besides an existing mdns responder, we just assume that without probing
122	// As it only affects probe queries, impact isn't that big.
123	this.suppressUnicastResponseFlag = true;	×
124
125	await this.networkManager.waitForInit();	×
126	const promises: Promise<void>[] = [];	×
127	for (const [name, socket] of this.sockets) {	×
128	promises.push(this.bindSocket(socket, name, IPFamily.IPv4));	×
129	}
130
131	return Promise.all(promises).then(() => {	×
132	this.bound = true;	×
133	// map void[] to void
134	});
135	}
136
137	public shutdown(): void {
138	this.networkManager.shutdown();	×
139
140	for (const socket of this.sockets.values()) {	×
141	socket.close();	×
142	}
143
144	this.bound = false;	×
145	this.closed = true;	×
146
147	this.sockets.clear();	×
148	}
149
150	public sendQueryBroadcast(query: DNSQueryDefinition \| DNSProbeQueryDefinition, callback?: SendCallback): void {
151	const packets = DNSPacket.createDNSQueryPackets(query, MDNSServer.MTU, IPFamily.IPv4);	×
152	if (packets.length > 1) {	×
153	debug("Query broadcast is split into %d packets!", packets.length);	×
154	}
155
156	const promises: Promise<void>[] = [];	×
157	for (const packet of packets) {	×
158	promises.push(this.sendOnAllNetworks(packet));	×
159	}
160
161	Promise.all(promises).then(() => {	×
162	if (callback) {	×
163	callback();	×
164	}
165	}, (error: SocketError) => {
166	callback? callback(error.error): MDNSServer.handleSocketError(error.name, error.error);	×
167	});
168	}
169
170	public sendResponseBroadcast(response: DNSResponseDefinition, callback?: SendCallback): void {
171	const packets = DNSPacket.createDNSResponsePackets(response, MDNSServer.MTU, IPFamily.IPv4);	×
172	if (packets.length > 1) {	×
173	debug("Response broadcast is split into %d packets!", packets.length);	×
174	}
175
176	const promises: Promise<void>[] = [];	×
177	for (const packet of packets) {	×
178	promises.push(this.sendOnAllNetworks(packet));	×
179	}
180
181	Promise.all(promises).then(() => {	×
182	if (callback) {	×
183	callback();	×
184	}
185	}, (error: SocketError) => {
186	callback? callback(error.error): MDNSServer.handleSocketError(error.name, error.error);	×
187	});
188	}
189
190	public sendResponse(response: DNSResponseDefinition, endpoint: EndpointInfo, callback?: SendCallback): void;
191	public sendResponse(response: DNSResponseDefinition, interfaceName: InterfaceName, callback?: SendCallback): void;
192	public sendResponse(response: DNSResponseDefinition, endpointOrInterface: EndpointInfo \| InterfaceName, callback?: SendCallback): void {
193	const packets = DNSPacket.createDNSResponsePackets(response, MDNSServer.MTU, IPFamily.IPv4);	×
194	if (packets.length > 1) {	×
195	debug("Response is split into %d packets!", packets.length);	×
196	}
197
198	const promises: Promise<void>[] = [];	×
199	for (const packet of packets) {	×
200	promises.push(this.send(packet, endpointOrInterface));	×
201	}
202
203	Promise.all(promises).then(() => {	×
204	if (callback) {	×
205	callback();	×
206	}
207	}, (error: SocketError) => {
208	callback? callback(error.error): MDNSServer.handleSocketError(error.name, error.error);	×
209	});
210	}
211
212	private sendOnAllNetworks(packet: DNSPacket): Promise<void> {
213	this.checkUnicastResponseFlag(packet);	×
214
215	const message = packet.encode();	×
216	this.assertBeforeSend(message, IPFamily.IPv4);	×
217
218	const promises: Promise<void>[] = [];	×
219	for (const [name, socket] of this.sockets) {	×
220	const promise = new Promise<void>((resolve, reject) => {	×
221	socket.send(message, MDNSServer.MDNS_PORT, MDNSServer.MULTICAST_IPV4, error => {	×
222	if (error) {	×
223	const socketError: SocketError = { name: name, error: error };	×
224	reject(socketError);	×
225	} else {
226	resolve();	×
227	}
228	});
229	});
230	promises.push(promise);	×
231	}
232
233	return Promise.all(promises).then(() => {	×
234	// map void[] to void
235	});
236	}
237
238	private send(packet: DNSPacket, endpointOrInterface: EndpointInfo \| InterfaceName): Promise<void> {
239	this.checkUnicastResponseFlag(packet);	×
240
241	const message = packet.encode();	×
242	this.assertBeforeSend(message, IPFamily.IPv4);	×
243
244	let address: string;
245	let port: number;
246	let name: string;
247
248	if (typeof endpointOrInterface === "string") { // its a network interface name	×
249	address = MDNSServer.MULTICAST_IPV4;	×
250	port = MDNSServer.MDNS_PORT;	×
251	name = endpointOrInterface;	×
252	} else {
253	address = endpointOrInterface.address;	×
254	port = endpointOrInterface.port;	×
255	name = endpointOrInterface.interface;	×
256	}
257
258	const socket = this.sockets.get(name);	×
259	assert(socket, `Could not find socket for given network interface '${name}'`);	×
260
261	return new Promise<void>((resolve, reject) => {	×
262	socket!.send(message, port, address, error => {	×
263	if (error) {	×
264	const socketError: SocketError = { name: name, error: error };	×
265	reject(socketError);	×
266	} else {
267	resolve();	×
268	}
269	});
270	});
271	}
272
273	private checkUnicastResponseFlag(packet: DNSPacket): void {
274	if (this.suppressUnicastResponseFlag && packet.type === PacketType.QUERY) {	×
275	packet.questions.forEach(record => record.unicastResponseFlag = false);	×
276	}
277	}
278
279	private assertBeforeSend(message: Buffer, family: IPFamily): void {
280	assert(this.bound, "Cannot send packets before server is not bound!");	×
281	assert(!this.closed, "Cannot send packets on a closed mdns server!");	×
282
283	const ipHeaderSize = family === IPFamily.IPv4? MDNSServer.DEFAULT_IP4_HEADER: MDNSServer.DEFAULT_IP6_HEADER;	×
284
285	// RFC 6762 17.
286	assert(ipHeaderSize + MDNSServer.UDP_HEADER + message.length <= 9000,	×
287	"DNS cannot exceed the size of 9000 bytes even with IP Fragmentation!");
288	}
289
290	private createDgramSocket(name: InterfaceName, reuseAddr = false, type: "udp4" \| "udp6" = "udp4"): Socket {	×
291	const socket = dgram.createSocket({	×
292	type: type,
293	reuseAddr: reuseAddr,
294	});
295
296	socket.on("message", this.handleMessage.bind(this, name));	×
297	socket.on("error", MDNSServer.handleSocketError.bind(this, name));	×
298
299	return socket;	×
300	}
301
302	private bindSocket(socket: Socket, name: InterfaceName, family: IPFamily): Promise<void> {
303	const networkInterface = this.networkManager.getInterface(name);	×
304	assert(networkInterface, `Could not find network interface '${name}' in network manager which socket is going to be bind to!`);	×
305
306	return new Promise((resolve, reject) => {	×
307	const errorHandler = (error: Error \| number): void => reject(error);	×
308	socket.once("error", errorHandler);	×
309
310	socket.bind(MDNSServer.MDNS_PORT, () => {	×
311	socket.removeListener("error", errorHandler);	×
312
313	const multicastAddress = family === IPFamily.IPv4? MDNSServer.MULTICAST_IPV4: MDNSServer.MULTICAST_IPV6;	×
314	const interfaceAddress = family === IPFamily.IPv4? networkInterface!.ipv4: networkInterface!.ipv6;	×
315	assert(interfaceAddress, "Interface address cannot be undefined!");	×
316
317	socket.addMembership(multicastAddress, interfaceAddress!);	×
318
319	socket.setMulticastInterface(interfaceAddress!);	×
320
321	socket.setMulticastTTL(MDNSServer.MDNS_TTL); // outgoing multicast datagrams	×
322	socket.setTTL(MDNSServer.MDNS_TTL); // outgoing unicast datagrams	×
323
324	socket.setMulticastLoopback(true);	×
325
326	resolve();	×
327	});
328	});
329	}
330
331	private handleMessage(name: InterfaceName, buffer: Buffer, rinfo: AddressInfo): void {
332	if (!this.bound) {	×
333	return;	×
334	}
335
NEW 336	const networkInterface = this.networkManager.getInterface(name);	×
NEW 337	if (!networkInterface) {	×
NEW 338	debug("Received packet on non existing network interface: %s!", name);	×
NEW 339	return;	×
340	}
NEW 341	const ip4Netaddress = getNetAddress(rinfo.address, networkInterface.ip4Netmask!);	×
NEW 342	if (ip4Netaddress !== networkInterface.ipv4Netaddress) {	×
NEW 343	debug("Dropping packet on %s coming from %s as subnet doesn't match!", name, rinfo.address);	×
NEW 344	return;	×
345	}
346
347	let packet: DNSPacket;
348	try {	×
349	// TODO parse packet on the fly, a lot of RESPONSE packets will never be used
UNCOV 350	packet = DNSPacket.decode(buffer);	×
351	} catch (error) {
352	debug("Received malformed packet from %s: %s", JSON.stringify(rinfo), error.message);	×
353	debug(error.stack); // might be a bit spammy, but not having the error cause when it's maybe needed is not better	×
354	return;	×
355	}
356
357	if (packet.opcode !== OpCode.QUERY) {	×
358	// RFC 6762 18.3 we MUST ignore messages with opcodes other than zero (QUERY)
359	return;	×
360	}
361
362	if (packet.rcode !== RCode.NoError) {	×
363	// RFC 6762 18.3 we MUST ignore messages with response code other than zero (NoError)
364	return;	×
365	}
366
367	const endpoint: EndpointInfo = {	×
368	address: rinfo.address,
369	port: rinfo.port,
370	interface: name,
371	};
372
UNCOV 373	if (packet.type === PacketType.QUERY) {	×
UNCOV 374	this.handler.handleQuery(packet, endpoint);	×
375	} else if (packet.type === PacketType.RESPONSE) {	×
376	if (rinfo.port !== MDNSServer.MDNS_PORT) {	×
377	// RFC 6762 6. Multicast DNS implementations MUST silently ignore any Multicast DNS responses
378	// they receive where the source UDP port is not 5353.
379	return;	×
380	}
381
382	this.handler.handleResponse(packet, endpoint);	×
383	}
384	}
385
386	private static handleSocketError(name: InterfaceName, error: Error): void {
387	console.warn(`Encountered MDNS socket error on socket '${name}' : ${error.message}`);	×
388	console.warn(error.stack);	×
389	}
390
391	private handleUpdatedNetworkInterfaces(networkUpdate: NetworkUpdate): void {
392	if (networkUpdate.removed) {	×
393	for (const networkInterface of networkUpdate.removed) {	×
394	const socket = this.sockets.get(networkInterface.name);	×
395	this.sockets.delete(networkInterface.name);	×
396
397	if (socket) {	×
398	socket.close();	×
399	}
400	}
401	}
402
403	if (networkUpdate.changes) {	×
404	for (const change of networkUpdate.changes) {	×
405	const socket = this.sockets.get(change.name);	×
406	assert(socket, "Couldn't find socket for network change!");	×
407
408	if (!change.outdatedIpv4 && change.updatedIpv4) {	×
409	// this does currently not happen, as we exclude ipv6 only interfaces
410	// thus such a change would be happening through the ADDED array
411	assert.fail("Reached illegal state! IPv4 address changed from undefined to defined!");	×
412	} else if (change.outdatedIpv4 && !change.updatedIpv4) {	×
413	// this does currently not happen, as we exclude ipv6 only interfaces
414	// thus such a change would be happening through the REMOVED array
415	assert.fail("Reached illegal state! IPV4 address change from defined to undefined!");	×
416	} else if (change.outdatedIpv4 && change.updatedIpv4) {	×
417	try {	×
418	socket!.dropMembership(MDNSServer.MULTICAST_IPV4, change.outdatedIpv4);	×
419	} catch (error) {
420	debug("Thrown expected error when dropping outdated address membership: " + error.message);	×
421	}
422	try {	×
423	socket!.addMembership(MDNSServer.MULTICAST_IPV4, change.updatedIpv4);	×
424	} catch (error) {
425	debug("Thrown expected error when adding new address membership: " + error.message);	×
426	}
427
428	socket!.setMulticastInterface(change.updatedIpv4);	×
429	}
430	}
431	}
432
433	if (networkUpdate.added) {	×
434	for (const networkInterface of networkUpdate.added) {	×
435	const socket = this.createDgramSocket(networkInterface.name, true);	×
436	this.bindSocket(socket, networkInterface.name, IPFamily.IPv4).then(() => {	×
437	this.sockets.set(networkInterface.name, socket);	×
438	});
439	}
440	}
441	}
442
443	}

homebridge / ciao / 163594882

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