139721029

Build Type

push

github

Committed by Supereg

Commit Message

Adding support for truncated queries

Run Details

73 of 620 branches covered (11.77%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

153 of 1165 relevant lines covered (13.13%)

5.25 hits per line

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

0.0

/src/MDNSServer.ts

import dnsPacket, {
  AnswerRecord,
  DecodedDnsPacket,
  EncodingDnsPacket,
  Opcode,
  QuestionRecord,
  RCode,
} from "@homebridge/dns-packet";
import assert from "assert";
import dgram, { Socket } from "dgram";
import { AddressInfo } from "net";
import { IPFamily } from "./index";
import { NetworkUpdate, NetworkManager, NetworkManagerEvent, NetworkId } from "./NetworkManager";
import createDebug from "debug";

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

export interface DnsResponse {
  flags?: number;
  id?: number;
  questions?: QuestionRecord[];
  answers: AnswerRecord[];
  authorities?: AnswerRecord[];
  additionals?: AnswerRecord[];
}

export interface DnsQuery {
  flags?: number;
  id?: number;
  questions: QuestionRecord[];
  answers?: AnswerRecord[];
  authorities?: AnswerRecord[];
  additionals?: AnswerRecord[];
}

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

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

// eslint-disable-next-line
export interface MDNSServerOptions {
  interface?: string | string[];
}

export interface PacketHandler {

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

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

}

/**
 * This class can be used to create a mdns server to send and receive mdns packets on the local network.
 *
 * There are some limitations, please refer to https://github.com/homebridge/ciao/wiki/Unicast-Response-Workaround.
 *
 * Currently only udp4 sockets will be advertised.
 */
export class MDNSServer {

  /*
  TODO random RFC note
  From section 6.2 of RFC 1035 <https://tools.ietf.org/html/rfc1035>:
    //    When a response is so long that truncation is required, the truncation
    //    should start at the end of the response and work forward in the
    //    datagram.  Thus if there is any data for the authority section, the
    //    answer section is guaranteed to be unique.
   */

  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 multicastSockets: Map<NetworkId, Socket> = new Map();
  private readonly unicastSockets: Map<NetworkId, Socket> = new Map();

  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.handleNetworkUpdate.bind(this));

    for (const name of this.networkManager.getNetworkMap().keys()) {
      const multicast = this.createDgramSocket(name, true);
      const unicast = this.createDgramSocket(name);

      this.multicastSockets.set(name, multicast);
      this.unicastSockets.set(name, unicast);
    }

    if (this.multicastSockets.size === 0) { // misconfigured options
      throw new Error("Did not bind any sockets!");
    }
  }

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

  public getNetworkIds(): IterableIterator<NetworkId> {
    return this.multicastSockets.keys();
  }

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

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

    const promises: Promise<void>[] = [];

    for (const [id, socket] of this.multicastSockets) {
      promises.push(this.bindMulticastSocket(socket, id, IPFamily.IPv4));
    }

    for (const [id, socket] of this.unicastSockets) {
      promises.push(this.bindUnicastSocket(socket, id));
    }

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

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

    // TODO sockets can already be closed when the interface was shut down previously :thinking:
    for (const socket of this.multicastSockets.values()) {
      socket.close();
    }

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

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

    this.multicastSockets.clear();
    this.unicastSockets.clear();
  }

  public sendQueryBroadcast(query: DnsQuery, callback?: SendCallback): void {
    const packet: EncodingDnsPacket = {
      type: "query",
      flags: query.flags || 0,
      id: query.id,
      questions: query.questions,
      answers: query.answers,
      authorities: query.authorities,
      additionals: query.additionals,
    };

    this.sendOnAllNetworks(packet, callback);
  }

  public sendResponse(response: DnsResponse, endpoint: EndpointInfo, callback?: SendCallback): void;
  public sendResponse(response: DnsResponse, networkId: NetworkId, callback?: SendCallback): void;
  public sendResponse(response: DnsResponse, endpointOrNetwork: EndpointInfo | NetworkId, callback?: SendCallback): void {
    const packet: EncodingDnsPacket = {
      type: "response",
      flags: response.flags || 0,
      id: response.id,
      questions: response.questions,
      answers: response.answers,
      authorities: response.authorities,
      additionals: response.additionals,
    };

    packet.flags! |= dnsPacket.AUTHORITATIVE_ANSWER; // RFC 6763 18.4 AA MUST be set

    this.send(packet, endpointOrNetwork, callback);
  }

  public sendResponseBroadcast(response: DnsResponse, callback?: SendCallback): void {
    const packet: EncodingDnsPacket = {
      type: "response",
      flags: response.flags || 0,
      id: response.id,
      questions: response.questions,
      answers: response.answers,
      authorities: response.authorities,
      additionals: response.additionals,
    };

    packet.flags! |= dnsPacket.AUTHORITATIVE_ANSWER; // RFC 6763 18.4 AA MUST be set

    this.sendOnAllNetworks(packet, callback);
  }

  private sendOnAllNetworks(packet: EncodingDnsPacket, callback?: SendCallback): void {
    const message = dnsPacket.encode(packet);
    this.assertBeforeSend(packet, message);

    const socketMap = packet.type === "response"? this.multicastSockets: this.unicastSockets;

    let socketCount = socketMap.size;
    const encounteredErrors: Error[] = [];

    for (const [id, socket] of socketMap) {
      socket.send(message, MDNSServer.MDNS_PORT, MDNSServer.MULTICAST_IPV4, error => {
        if (!callback) {
          if (error) {
            MDNSServer.handleSocketError(id, error);
          }
          return;
        }

        if (error) {
          encounteredErrors.push(error);
        }

        if (--socketCount <= 0) {
          if (encounteredErrors.length > 0) {
            callback(new Error("Socket errors: " + encounteredErrors.map(error => error.stack).join(";")));
          } else {
            callback();
          }
        }
      });
    }
  }

  private send(packet: EncodingDnsPacket, endpointOrNetwork: EndpointInfo | NetworkId, callback?: SendCallback): void {
    const message = dnsPacket.encode(packet);
    this.assertBeforeSend(packet, message);

    let address;
    let port;
    let network;

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

    const socketMap = packet.type === "response"? this.multicastSockets: this.unicastSockets;
    const socket = socketMap.get(network);
    assert(socket, `Could not find socket for given network '${network}'`);

    socket!.send(message, port, address, callback);
  }

  private assertBeforeSend(packet: EncodingDnsPacket, message: Buffer): void {
    assert(this.bound, "Cannot send packets before server is not bound!");
    assert(!this.closed, "Cannot send packets on a closed mdns server!");
    if (message.length > 1024) { // TODO still need to check what we need to do?
      debug("packet with exceeds the record size of 1024 with " + message.length);
    }
    //assert(message.length <= 1024, "MDNS packet size cannot be larger than 1024 bytes for " + message.length + " " + JSON.stringify(packet)); // TODO we might want to tackle this
  }

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

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

    return socket;
  }

  private bindMulticastSocket(socket: Socket, id: NetworkId, family: IPFamily): Promise<void> {
    const network = this.networkManager.getNetworkById(id);
    assert(network, "Could not find network '" + id + "' 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 addresses = family === IPFamily.IPv4? network!.getIPv4Addresses(): network!.getIPv6Addresses();

        for (const interfaceAddress of addresses) {
          socket.addMembership(multicastAddress, interfaceAddress);
        }

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

        socket.setMulticastLoopback(true);

        resolve();
      });
    });
  }

  private bindUnicastSocket(socket: Socket, id: NetworkId): Promise<void> {
    const network = this.networkManager.getNetworkById(id);
    assert(network, "Could not find network '" + id + "' 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);

      // bind on random port
      socket.bind(0, network!.getDefaultIPv4(), () => {
        socket.removeListener("error", errorHandler);

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

        resolve();
      });
    });
  }

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

    let packet: DecodedDnsPacket;
    try {
      packet = dnsPacket.decode(buffer);
    } catch (error) {
      console.warn("Received malformed packet from " + rinfo + ": " + error.message);
      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,
      network: id,
    };

    if (packet.type === "query") {
      this.handler.handleQuery(packet, endpoint);
    } else if (packet.type === "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(id: NetworkId, error: Error): void {
    console.warn("Encountered MDNS socket error on socket " + id + " : " + error.message);
    console.warn(error.stack);
  }

  private handleNetworkUpdate(update: NetworkUpdate): void {
    if (update.removed) {
      for (const network of update.removed) {
        this.removeSocket(network.getId());
      }
    }

    if (update.updated) {
      for (const change of update.updated) {
        if (!change.changedDefaultIPv4Address) {
          continue;
        }

        // the default address changed were the socket was running
        this.removeSocket(change.networkId);
        this.addAndBindSocket(change.networkId);
      }
    }

    if (update.added) {
      for (const network of update.added) {
        this.addAndBindSocket(network.getId());
      }
    }
  }

  private addAndBindSocket(id: NetworkId): void {
    const multicast = this.createDgramSocket(id, true);
    const unicast = this.createDgramSocket(id);

    const promises = [
      this.bindMulticastSocket(multicast, id, IPFamily.IPv4),
      this.bindUnicastSocket(unicast, id),
    ];

    Promise.all(promises).then(() => {
      this.multicastSockets.set(id, multicast);
      this.unicastSockets.set(id, unicast);
    });
  }

  private removeSocket(id: NetworkId): void {
    const multicastSocket = this.multicastSockets.get(id);
    this.multicastSockets.delete(id);
    const unicastSocket = this.unicastSockets.get(id);
    this.multicastSockets.delete(id);

    if (multicastSocket) {
      try {
        multicastSocket.close();
      } catch (error) {
        console.log(error.stack); // TODO remove or properly handle
      }
    }
    if (unicastSocket) {
      try {
        unicastSocket.close();
      } catch (error) {
        console.log(error.stack); // TODO remove or properly handle
      }
    }
  }

}

1	import dnsPacket, {	×
2	AnswerRecord,
3	DecodedDnsPacket,
4	EncodingDnsPacket,
5	Opcode,
6	QuestionRecord,
7	RCode,
8	} from "@homebridge/dns-packet";
9	import assert from "assert";	×
10	import dgram, { Socket } from "dgram";	×
11	import { AddressInfo } from "net";
12	import { IPFamily } from "./index";
13	import { NetworkUpdate, NetworkManager, NetworkManagerEvent, NetworkId } from "./NetworkManager";	×
NEW 14	import createDebug from "debug";	×
15
NEW 16	const debug = createDebug("ciao:MDNSServer");	×
17
18	export interface DnsResponse {
19	flags?: number;
20	id?: number;
21	questions?: QuestionRecord[];
22	answers: AnswerRecord[];
23	authorities?: AnswerRecord[];
24	additionals?: AnswerRecord[];
25	}
26
27	export interface DnsQuery {
28	flags?: number;
29	id?: number;
30	questions: QuestionRecord[];
31	answers?: AnswerRecord[];
32	authorities?: AnswerRecord[];
33	additionals?: AnswerRecord[];
34	}
35
36	export interface EndpointInfo {
37	address: string;
38	port: number;
39	network: string;
40	}
41
42	export type SendCallback = (error?: Error \| null) => void;
43
44	// eslint-disable-next-line
45	export interface MDNSServerOptions {
46	interface?: string \| string[];
47	}
48
49	export interface PacketHandler {
50
51	handleQuery(packet: DecodedDnsPacket, rinfo: EndpointInfo): void;
52
53	handleResponse(packet: DecodedDnsPacket, rinfo: EndpointInfo): void;
54
55	}
56
57	/**
58	* This class can be used to create a mdns server to send and receive mdns packets on the local network.
59	*
60	* There are some limitations, please refer to https://github.com/homebridge/ciao/wiki/Unicast-Response-Workaround.
61	*
62	* Currently only udp4 sockets will be advertised.
63	*/
64	export class MDNSServer {	×
65
66	/*
67	TODO random RFC note
68	From section 6.2 of RFC 1035 <https://tools.ietf.org/html/rfc1035>:
69	// When a response is so long that truncation is required, the truncation
70	// should start at the end of the response and work forward in the
71	// datagram. Thus if there is any data for the authority section, the
72	// answer section is guaranteed to be unique.
73	*/
74
75	public static readonly MDNS_PORT = 5353;	×
76	public static readonly MDNS_TTL = 255;	×
77	public static readonly MULTICAST_IPV4 = "224.0.0.251";	×
78	public static readonly MULTICAST_IPV6 = "FF02::FB";	×
79
80	private readonly handler: PacketHandler;
81
82	private readonly networkManager: NetworkManager;
83
84	private readonly multicastSockets: Map<NetworkId, Socket> = new Map();	×
85	private readonly unicastSockets: Map<NetworkId, Socket> = new Map();	×
86
87	private bound = false;	×
88	private closed = false;	×
89
90	constructor(handler: PacketHandler, options?: MDNSServerOptions) {
91	assert(handler, "handler cannot be undefined");	×
92	this.handler = handler;	×
93
94	this.networkManager = new NetworkManager({	×
95	interface: options && options.interface,	×
96	excludeIpv6Only: true,
97	});
98	this.networkManager.on(NetworkManagerEvent.NETWORK_UPDATE, this.handleNetworkUpdate.bind(this));	×
99
100	for (const name of this.networkManager.getNetworkMap().keys()) {	×
101	const multicast = this.createDgramSocket(name, true);	×
102	const unicast = this.createDgramSocket(name);	×
103
104	this.multicastSockets.set(name, multicast);	×
105	this.unicastSockets.set(name, unicast);	×
106	}
107
108	if (this.multicastSockets.size === 0) { // misconfigured options	×
109	throw new Error("Did not bind any sockets!");	×
110	}
111	}
112
113	public getNetworkManager(): NetworkManager {
114	return this.networkManager;	×
115	}
116
117	public getNetworkIds(): IterableIterator<NetworkId> {
118	return this.multicastSockets.keys();	×
119	}
120
121	public getNetworkCount(): number {
122	return this.multicastSockets.size;	×
123	}
124
125	public async bind(): Promise<void> {
126	if (this.closed) {	×
127	throw new Error("Cannot rebind closed server!");	×
128	}
129
130	const promises: Promise<void>[] = [];	×
131
132	for (const [id, socket] of this.multicastSockets) {	×
133	promises.push(this.bindMulticastSocket(socket, id, IPFamily.IPv4));	×
134	}
135
136	for (const [id, socket] of this.unicastSockets) {	×
137	promises.push(this.bindUnicastSocket(socket, id));	×
138	}
139
140	return Promise.all(promises).then(() => {	×
141	this.bound = true;	×
142	// map void[] to void
143	});
144	}
145
146	public shutdown(): void {
147	this.networkManager.shutdown();	×
148
149	// TODO sockets can already be closed when the interface was shut down previously :thinking:
150	for (const socket of this.multicastSockets.values()) {	×
151	socket.close();	×
152	}
153
154	for (const socket of this.unicastSockets.values()) {	×
155	socket.close();	×
156	}
157
158	this.bound = false;	×
159	this.closed = true;	×
160
161	this.multicastSockets.clear();	×
162	this.unicastSockets.clear();	×
163	}
164
165	public sendQueryBroadcast(query: DnsQuery, callback?: SendCallback): void {
166	const packet: EncodingDnsPacket = {	×
167	type: "query",
168	flags: query.flags \|\| 0,	×
169	id: query.id,
170	questions: query.questions,
171	answers: query.answers,
172	authorities: query.authorities,
173	additionals: query.additionals,
174	};
175
176	this.sendOnAllNetworks(packet, callback);	×
177	}
178
179	public sendResponse(response: DnsResponse, endpoint: EndpointInfo, callback?: SendCallback): void;
180	public sendResponse(response: DnsResponse, networkId: NetworkId, callback?: SendCallback): void;
181	public sendResponse(response: DnsResponse, endpointOrNetwork: EndpointInfo \| NetworkId, callback?: SendCallback): void {
182	const packet: EncodingDnsPacket = {	×
183	type: "response",
184	flags: response.flags \|\| 0,	×
185	id: response.id,
186	questions: response.questions,
187	answers: response.answers,
188	authorities: response.authorities,
189	additionals: response.additionals,
190	};
191
192	packet.flags! \|= dnsPacket.AUTHORITATIVE_ANSWER; // RFC 6763 18.4 AA MUST be set	×
193
194	this.send(packet, endpointOrNetwork, callback);	×
195	}
196
197	public sendResponseBroadcast(response: DnsResponse, callback?: SendCallback): void {
198	const packet: EncodingDnsPacket = {	×
199	type: "response",
200	flags: response.flags \|\| 0,	×
201	id: response.id,
202	questions: response.questions,
203	answers: response.answers,
204	authorities: response.authorities,
205	additionals: response.additionals,
206	};
207
208	packet.flags! \|= dnsPacket.AUTHORITATIVE_ANSWER; // RFC 6763 18.4 AA MUST be set	×
209
210	this.sendOnAllNetworks(packet, callback);	×
211	}
212
213	private sendOnAllNetworks(packet: EncodingDnsPacket, callback?: SendCallback): void {
214	const message = dnsPacket.encode(packet);	×
215	this.assertBeforeSend(packet, message);	×
216
217	const socketMap = packet.type === "response"? this.multicastSockets: this.unicastSockets;	×
218
219	let socketCount = socketMap.size;	×
220	const encounteredErrors: Error[] = [];	×
221
222	for (const [id, socket] of socketMap) {	×
223	socket.send(message, MDNSServer.MDNS_PORT, MDNSServer.MULTICAST_IPV4, error => {	×
224	if (!callback) {	×
225	if (error) {	×
226	MDNSServer.handleSocketError(id, error);	×
227	}
228	return;	×
229	}
230
231	if (error) {	×
232	encounteredErrors.push(error);	×
233	}
234
235	if (--socketCount <= 0) {	×
236	if (encounteredErrors.length > 0) {	×
237	callback(new Error("Socket errors: " + encounteredErrors.map(error => error.stack).join(";")));	×
238	} else {
239	callback();	×
240	}
241	}
242	});
243	}
244	}
245
246	private send(packet: EncodingDnsPacket, endpointOrNetwork: EndpointInfo \| NetworkId, callback?: SendCallback): void {
247	const message = dnsPacket.encode(packet);	×
248	this.assertBeforeSend(packet, message);	×
249
250	let address;
251	let port;
252	let network;
253
254	if (typeof endpointOrNetwork === "string") { // its a network id	×
255	address = MDNSServer.MULTICAST_IPV4;	×
256	port = MDNSServer.MDNS_PORT;	×
257	network = endpointOrNetwork;	×
258	} else {
259	address = endpointOrNetwork.address;	×
260	port = endpointOrNetwork.port;	×
261	network = endpointOrNetwork.network;	×
262	}
263
264	const socketMap = packet.type === "response"? this.multicastSockets: this.unicastSockets;	×
265	const socket = socketMap.get(network);	×
266	assert(socket, `Could not find socket for given network '${network}'`);	×
267
268	socket!.send(message, port, address, callback);	×
269	}
270
271	private assertBeforeSend(packet: EncodingDnsPacket, message: Buffer): void {
272	assert(this.bound, "Cannot send packets before server is not bound!");	×
273	assert(!this.closed, "Cannot send packets on a closed mdns server!");	×
NEW 274	if (message.length > 1024) { // TODO still need to check what we need to do?	×
NEW 275	debug("packet with exceeds the record size of 1024 with " + message.length);	×
276	}
277	//assert(message.length <= 1024, "MDNS packet size cannot be larger than 1024 bytes for " + message.length + " " + JSON.stringify(packet)); // TODO we might want to tackle this
278	}
279
280	private createDgramSocket(id: NetworkId, reuseAddr = false, type: "udp4" \| "udp6" = "udp4"): Socket {	×
281	const socket = dgram.createSocket({	×
282	type: type,
283	reuseAddr: reuseAddr,
284	});
285
286	socket.on("message", this.handleMessage.bind(this, id));	×
287	socket.on("error", MDNSServer.handleSocketError.bind(this, id));	×
288
289	return socket;	×
290	}
291
292	private bindMulticastSocket(socket: Socket, id: NetworkId, family: IPFamily): Promise<void> {
293	const network = this.networkManager.getNetworkById(id);	×
294	assert(network, "Could not find network '" + id + "' in network manager which socket is going to be bind to!");	×
295
296	return new Promise((resolve, reject) => {	×
297	const errorHandler = (error: Error \| number): void => reject(error);	×
298	socket.once("error", errorHandler);	×
299
300	socket.bind(MDNSServer.MDNS_PORT, () => {	×
301	socket.removeListener("error", errorHandler);	×
302
303	const multicastAddress = family === IPFamily.IPv4? MDNSServer.MULTICAST_IPV4: MDNSServer.MULTICAST_IPV6;	×
304	const addresses = family === IPFamily.IPv4? network!.getIPv4Addresses(): network!.getIPv6Addresses();	×
305
306	for (const interfaceAddress of addresses) {	×
307	socket.addMembership(multicastAddress, interfaceAddress);	×
308	}
309
310	socket.setMulticastTTL(MDNSServer.MDNS_TTL); // outgoing multicast datagrams	×
311	socket.setTTL(MDNSServer.MDNS_TTL); // outgoing unicast datagrams	×
312
313	socket.setMulticastLoopback(true);	×
314
315	resolve();	×
316	});
317	});
318	}
319
320	private bindUnicastSocket(socket: Socket, id: NetworkId): Promise<void> {
321	const network = this.networkManager.getNetworkById(id);	×
322	assert(network, "Could not find network '" + id + "' in network manager which socket is going to be bind to!");	×
323
324	return new Promise((resolve, reject) => {	×
325	const errorHandler = (error: Error \| number): void => reject(error);	×
326	socket.once("error", errorHandler);	×
327
328	// bind on random port
329	socket.bind(0, network!.getDefaultIPv4(), () => {	×
330	socket.removeListener("error", errorHandler);	×
331
332	socket.setMulticastTTL(255); // outgoing multicast datagrams	×
333	socket.setTTL(255); // outgoing unicast datagrams	×
334
335	resolve();	×
336	});
337	});
338	}
339
340	private handleMessage(id: NetworkId, buffer: Buffer, rinfo: AddressInfo): void {
341	if (!this.bound) {	×
342	return;	×
343	}
344
345	let packet: DecodedDnsPacket;
346	try {	×
347	packet = dnsPacket.decode(buffer);	×
348	} catch (error) {
349	console.warn("Received malformed packet from " + rinfo + ": " + error.message);	×
350	return;	×
351	}
352
353	if (packet.opcode !== Opcode.QUERY) {	×
354	// RFC 6762 18.3 we MUST ignore messages with opcodes other than zero (QUERY)
355	return;	×
356	}
357
358	if (packet.rcode !== RCode.NOERROR) {	×
359	// RFC 6762 18.3 we MUST ignore messages with response code other than zero (NOERROR)
360	return;	×
361	}
362
363	const endpoint: EndpointInfo = {	×
364	address: rinfo.address,
365	port: rinfo.port,
366	network: id,
367	};
368
369	if (packet.type === "query") {	×
370	this.handler.handleQuery(packet, endpoint);	×
371	} else if (packet.type === "response") {	×
372	if (rinfo.port !== MDNSServer.MDNS_PORT) {	×
373	// RFC 6762 6. Multicast DNS implementations MUST silently ignore any Multicast DNS responses
374	// they receive where the source UDP port is not 5353.
375	return;	×
376	}
377
378	this.handler.handleResponse(packet, endpoint);	×
379	}
380	}
381
382	private static handleSocketError(id: NetworkId, error: Error): void {
383	console.warn("Encountered MDNS socket error on socket " + id + " : " + error.message);	×
384	console.warn(error.stack);	×
385	}
386
387	private handleNetworkUpdate(update: NetworkUpdate): void {
388	if (update.removed) {	×
389	for (const network of update.removed) {	×
390	this.removeSocket(network.getId());	×
391	}
392	}
393
394	if (update.updated) {	×
395	for (const change of update.updated) {	×
396	if (!change.changedDefaultIPv4Address) {	×
397	continue;	×
398	}
399
400	// the default address changed were the socket was running
401	this.removeSocket(change.networkId);	×
402	this.addAndBindSocket(change.networkId);	×
403	}
404	}
405
406	if (update.added) {	×
407	for (const network of update.added) {	×
408	this.addAndBindSocket(network.getId());	×
409	}
410	}
411	}
412
413	private addAndBindSocket(id: NetworkId): void {
414	const multicast = this.createDgramSocket(id, true);	×
415	const unicast = this.createDgramSocket(id);	×
416
417	const promises = [	×
418	this.bindMulticastSocket(multicast, id, IPFamily.IPv4),
419	this.bindUnicastSocket(unicast, id),
420	];
421
422	Promise.all(promises).then(() => {	×
423	this.multicastSockets.set(id, multicast);	×
424	this.unicastSockets.set(id, unicast);	×
425	});
426	}
427
428	private removeSocket(id: NetworkId): void {
429	const multicastSocket = this.multicastSockets.get(id);	×
430	this.multicastSockets.delete(id);	×
431	const unicastSocket = this.unicastSockets.get(id);	×
432	this.multicastSockets.delete(id);	×
433
434	if (multicastSocket) {	×
435	try {	×
436	multicastSocket.close();	×
437	} catch (error) {
438	console.log(error.stack); // TODO remove or properly handle	×
439	}
440	}
441	if (unicastSocket) {	×
442	try {	×
443	unicastSocket.close();	×
444	} catch (error) {
445	console.log(error.stack); // TODO remove or properly handle	×
446	}
447	}
448	}
449
450	}

homebridge / ciao / 139721029

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