163789673

Build Type

push

github

Committed by Supereg

Commit Message

Implement proper rate limiting for probing

Run Details

327 of 1126 branches covered (29.04%)

Branch coverage included in aggregate %.

0 of 15 new or added lines in 1 file covered. (0.0%)

4 existing lines in 1 file now uncovered.

1032 of 2442 relevant lines covered (42.26%)

29.69 hits per line

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

0.0

/src/responder/Prober.ts

import assert from "assert";
import createDebug from "debug";
import { CiaoService, ServiceState } from "../CiaoService";
import { DNSPacket, QType } from "../coder/DNSPacket";
import { Question } from "../coder/Question";
import { ResourceRecord } from "../coder/ResourceRecord";
import { MDNSServer } from "../MDNSServer";
import dnsEqual from "../util/dns-equal";
import * as tiebreaking from "../util/tiebreaking";
import { rrComparator, TiebreakingResult } from "../util/tiebreaking";
import Timeout = NodeJS.Timeout;

const PROBE_INTERVAL = 250; // 250ms as defined in RFC 6762 8.1.
const LIMITED_PROBE_INTERVAL = 1000;
const debug = createDebug("ciao:Prober");

/**
 * This class is used to execute the probing process for a given service as defined
 * in RFC 6762 8.1.
 * This ensure that the we advertise the service under a unique name.
 * It also provides a conflict resolution algorithm if multiple clients probing
 * for the same name are detected.
 */
export class Prober {

  public static readonly CANCEL_REASON = "cancelled";

  private readonly server: MDNSServer;
  private readonly service: CiaoService;

  private records: ResourceRecord[] = [];

  private timer?: Timeout;
  private currentInterval: number = PROBE_INTERVAL;
  private promiseResolve?: (value?: void | PromiseLike<void>) => void;
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  private promiseReject?: (reason?: any) => void;

  private serviceEncounteredNameChange = false;
  private sentFirstProbeQuery = false; // we MUST ignore responses received BEFORE the first probe is sent
  private sentQueriesForCurrentTry = 0;
  private sentQueries = 0;

  constructor(server: MDNSServer, service: CiaoService) {
    assert(server, "server must be defined");
    assert(service, "service must be defined");
    this.server = server;
    this.service = service;
  }

  public getService(): CiaoService {
    return this.service;
  }

  /**
   * This method is called to start the actual probing process.
   * Once the service is considered unique on the network and can be announced the promise returns.
   * While probing multiple name changes can happen
   *
   * @returns a promise which returns when the service is considered unique on the network
   */
  public probe(): Promise<void> {
    /*
     * Probing is basically the following process: We send three "probe" queries to check
     * if the desired service name is already on the network.
     * The request are sent with a delay of 250ms between them and the first
     * request starting with a random delay.
     * If we don't receive any response to our requests we consider the probing to be successful
     * and continue with announcing our service.
     */

    debug("Starting to probe for '%s'...", this.service.getFQDN());

    return new Promise((resolve, reject) => {
      this.promiseResolve = resolve;
      this.promiseReject = reject;

      this.timer = setTimeout(this.sendProbeRequest.bind(this), Math.random() * PROBE_INTERVAL);
      this.timer.unref();
    });
  }

  public cancel(): void {
    this.clear();

    this.promiseReject!(Prober.CANCEL_REASON);
  }

  private clear(): void {
    if (this.timer) {
      clearTimeout(this.timer);
      this.timer = undefined;
    }

    // reset all values to default (so the Prober can be reused if it wasn't successful)
    this.sentFirstProbeQuery = false;
    this.sentQueriesForCurrentTry = 0;
  }

  /**
   * End the current ongoing probing requests. If
   * @param success
   */
  private endProbing(success: boolean): void {
    // reset all values to default (so the Prober can be reused if it wasn't successful)
    this.clear();

    if (success) {
      debug("Probing for '%s' finished successfully", this.service.getFQDN());
      this.promiseResolve!();

      if (this.serviceEncounteredNameChange) {
        this.service.informAboutNameUpdates();
      }
    }
  }

  private sendProbeRequest(): void {
    if (this.sentQueriesForCurrentTry === 0) { // this is the first query sent, init some stuff
      // RFC 6762 8.2. When a host is probing for a group of related records with the same
      //    name (e.g., the SRV and TXT record describing a DNS-SD service), only
      //    a single question need be placed in the Question Section, since query
      //    type "ANY" (255) is used, which will elicit answers for all records
      //    with that name.  However, for tiebreaking to work correctly in all
      //    cases, the Authority Section must contain *all* the records and
      //    proposed rdata being probed for uniqueness.

      // it states *all* records, though we include ALL A/AAAA records as well, even
      // though it may not be relevant data if the probe query is published on different interfaces.
      // Having the same "format" probed on all interfaces, the simultaneous probe tiebreaking
      // algorithm can work correctly. Otherwise we would conflict with ourselfs in a situation were
      // a device is connected to the same network via WiFi and Ethernet.
      this.records = [
        this.service.srvRecord(), this.service.txtRecord(),
        this.service.ptrRecord(), ...this.service.subtypePtrRecords(),
        ...this.service.allAddressRecords(), //...this.service.allReverseAddressMappings(),
      ].sort(rrComparator); // we sort them for the tiebreaking algorithm
      this.records.forEach(record => record.flushFlag = false);
    }

    if (this.sentQueriesForCurrentTry >= 3) {
      // we sent three requests and it seems like we weren't canceled, so we have a success right here
      this.endProbing(true);
      return;
    }

    if (this.sentQueries >= 15) {
      this.currentInterval = LIMITED_PROBE_INTERVAL;
    }

    debug("Sending prober query number %d for '%s'...", this.sentQueriesForCurrentTry + 1, this.service.getFQDN());

    assert(this.records.length > 0, "Tried sending probing request for zero record length!");

    this.server.sendQueryBroadcast({
      questions: [
        // probes SHOULD be send with unicast response flag as of the RFC
        // MDNServer might overwrite the QU flag to false, as we can't use unicast if there is another responder on the machine
        new Question(this.service.getFQDN(), QType.ANY, true),
        new Question(this.service.getHostname(), QType.ANY, true),
      ],
      authorities: this.records, // include records we want to announce in authorities to support Simultaneous Probe Tiebreaking (RFC 6762 8.2.)
    }, error => {
      if (error) {
        debug("Failed to send probe query for '%s'. Encountered error: " + error.stack, this.service.getFQDN());
        this.endProbing(false);
        this.promiseReject!(error);
        return;
      }

      if (this.service.serviceState !== ServiceState.PROBING) {
        debug("Service '%s' is no longer in probing state. Stopping.", this.service.getFQDN());
        return;
      }

      this.sentFirstProbeQuery = true;
      this.sentQueriesForCurrentTry++;
      this.sentQueries++;

      this.timer = setTimeout(this.sendProbeRequest.bind(this), this.currentInterval);
      this.timer.unref();
    });
  }

  handleResponse(packet: DNSPacket): void {
    if (!this.sentFirstProbeQuery) {
      return;
    }

    let containsAnswer = false;
    // search answers and additionals for answers to our probe queries
    packet.answers.forEach(record => {
      if (dnsEqual(record.name, this.service.getFQDN()) || dnsEqual(record.name, this.service.getHostname())) {
        containsAnswer = true;
      }
    });
    packet.additionals.forEach(record => {
      if (dnsEqual(record.name, this.service.getFQDN()) || dnsEqual(record.name, this.service.getHostname())) {
        containsAnswer = true;
      }
    });

    if (containsAnswer) { // abort and cancel probes
      debug("Probing for '%s' failed. Doing a name change", this.service.getFQDN());

      this.endProbing(false); // reset the prober
      this.service.serviceState = ServiceState.UNANNOUNCED;
      this.service.incrementName();
      this.service.serviceState = ServiceState.PROBING;

      this.serviceEncounteredNameChange = true;

      this.endProbing(false); // cancel the current probing

      this.timer = setTimeout(this.sendProbeRequest.bind(this), 1000);
      this.timer.unref();
    }
  }

  handleQuery(packet: DNSPacket): void {
    if (!this.sentFirstProbeQuery) { // ignore queries if we are not sending
      return;
    }

    // if we are currently probing and receiving a query which is also a probing query
    // which matches the desired name we run the tiebreaking algorithm to decide on the winner
    let needsTiebreaking = false;
    packet.questions.forEach(question => {
      if (dnsEqual(question.name, this.service.getFQDN()) || dnsEqual(question.name, this.service.getHostname())) {
        needsTiebreaking = true;
      }
    });


    if (needsTiebreaking) {
      this.doTiebreaking(packet);
    }
  }

  private doTiebreaking(packet: DNSPacket): void {
    if (!this.sentFirstProbeQuery) { // ignore queries if we are not sending
      return;
    }

    // first of all check if the contents of authorities answers our query
    let conflict = packet.authorities.length === 0;
    packet.authorities.forEach(record => {
      if (dnsEqual(record.name, this.service.getFQDN()) || dnsEqual(record.name, this.service.getHostname())) {
        conflict = true;
      }
    });
    if (!conflict) {
      return;
    }
    // now run the actual tiebreaking algorithm to decide the winner

    // tiebreaking is actually run pretty often, as we always receive our own packets

    // first of all build our own records
    const answers = this.records; // already sorted
    const opponent = packet.authorities.sort(tiebreaking.rrComparator);

    const result = tiebreaking.runTiebreaking(answers, opponent);

    if (result === TiebreakingResult.HOST) {
      debug("'%s' won the tiebreak. We gonna ignore the other probing request!", this.service.getFQDN());
    } else if (result === TiebreakingResult.OPPONENT) {
      debug("'%s' lost the tiebreak. We are waiting a second and try to probe again...", this.service.getFQDN());

      this.endProbing(false); // cancel the current probing

      // wait 1 second and probe again (this is to guard against stale probe packets)
      // If it wasn't a stale probe packet, the other host will correctly respond to our probe queries by then
      this.timer = setTimeout(this.sendProbeRequest.bind(this), 1000);
      this.timer.unref();
    } else {
      //debug("Tiebreaking for '%s' detected exact same records on the network. There is actually no conflict!", this.service.getFQDN());
    }
  }

}

1	import assert from "assert";	×
2	import createDebug from "debug";	×
3	import { CiaoService, ServiceState } from "../CiaoService";
4	import { DNSPacket, QType } from "../coder/DNSPacket";
5	import { Question } from "../coder/Question";	×
6	import { ResourceRecord } from "../coder/ResourceRecord";
7	import { MDNSServer } from "../MDNSServer";
8	import dnsEqual from "../util/dns-equal";	×
9	import * as tiebreaking from "../util/tiebreaking";	×
10	import { rrComparator, TiebreakingResult } from "../util/tiebreaking";	×
11	import Timeout = NodeJS.Timeout;
12
13	const PROBE_INTERVAL = 250; // 250ms as defined in RFC 6762 8.1.	×
NEW 14	const LIMITED_PROBE_INTERVAL = 1000;	×
UNCOV 15	const debug = createDebug("ciao:Prober");	×
16
17	/**
18	* This class is used to execute the probing process for a given service as defined
19	* in RFC 6762 8.1.
20	* This ensure that the we advertise the service under a unique name.
21	* It also provides a conflict resolution algorithm if multiple clients probing
22	* for the same name are detected.
23	*/
24	export class Prober {	×
25
26	public static readonly CANCEL_REASON = "cancelled";	×
27
28	private readonly server: MDNSServer;
29	private readonly service: CiaoService;
30
31	private records: ResourceRecord[] = [];	×
32
33	private timer?: Timeout;
NEW 34	private currentInterval: number = PROBE_INTERVAL;	×
35	private promiseResolve?: (value?: void \| PromiseLike<void>) => void;
36	// eslint-disable-next-line @typescript-eslint/no-explicit-any
37	private promiseReject?: (reason?: any) => void;
38
NEW 39	private serviceEncounteredNameChange = false;	×
40	private sentFirstProbeQuery = false; // we MUST ignore responses received BEFORE the first probe is sent	×
NEW 41	private sentQueriesForCurrentTry = 0;	×
UNCOV 42	private sentQueries = 0;	×
43
44	constructor(server: MDNSServer, service: CiaoService) {
45	assert(server, "server must be defined");	×
46	assert(service, "service must be defined");	×
47	this.server = server;	×
48	this.service = service;	×
49	}
50
51	public getService(): CiaoService {
52	return this.service;	×
53	}
54
55	/**
56	* This method is called to start the actual probing process.
57	* Once the service is considered unique on the network and can be announced the promise returns.
58	* While probing multiple name changes can happen
59	*
60	* @returns a promise which returns when the service is considered unique on the network
61	*/
62	public probe(): Promise<void> {
63	/*
64	* Probing is basically the following process: We send three "probe" queries to check
65	* if the desired service name is already on the network.
66	* The request are sent with a delay of 250ms between them and the first
67	* request starting with a random delay.
68	* If we don't receive any response to our requests we consider the probing to be successful
69	* and continue with announcing our service.
70	*/
71
72	debug("Starting to probe for '%s'...", this.service.getFQDN());	×
73
74	return new Promise((resolve, reject) => {	×
UNCOV 75	this.promiseResolve = resolve;	×
76	this.promiseReject = reject;	×
77
78	this.timer = setTimeout(this.sendProbeRequest.bind(this), Math.random() * PROBE_INTERVAL);	×
79	this.timer.unref();	×
80	});
81	}
82
83	public cancel(): void {
84	this.clear();	×
85
86	this.promiseReject!(Prober.CANCEL_REASON);	×
87	}
88
89	private clear(): void {
90	if (this.timer) {	×
91	clearTimeout(this.timer);	×
92	this.timer = undefined;	×
93	}
94
95	// reset all values to default (so the Prober can be reused if it wasn't successful)
96	this.sentFirstProbeQuery = false;	×
NEW 97	this.sentQueriesForCurrentTry = 0;	×
98	}
99
100	/**
101	* End the current ongoing probing requests. If
102	* @param success
103	*/
104	private endProbing(success: boolean): void {
105	// reset all values to default (so the Prober can be reused if it wasn't successful)
106	this.clear();	×
107
108	if (success) {	×
109	debug("Probing for '%s' finished successfully", this.service.getFQDN());	×
110	this.promiseResolve!();	×
111
112	if (this.serviceEncounteredNameChange) {	×
113	this.service.informAboutNameUpdates();	×
114	}
115	}
116	}
117
118	private sendProbeRequest(): void {
NEW 119	if (this.sentQueriesForCurrentTry === 0) { // this is the first query sent, init some stuff	×
120	// RFC 6762 8.2. When a host is probing for a group of related records with the same
121	// name (e.g., the SRV and TXT record describing a DNS-SD service), only
122	// a single question need be placed in the Question Section, since query
123	// type "ANY" (255) is used, which will elicit answers for all records
124	// with that name. However, for tiebreaking to work correctly in all
125	// cases, the Authority Section must contain all the records and
126	// proposed rdata being probed for uniqueness.
127
128	// it states all records, though we include ALL A/AAAA records as well, even
129	// though it may not be relevant data if the probe query is published on different interfaces.
130	// Having the same "format" probed on all interfaces, the simultaneous probe tiebreaking
131	// algorithm can work correctly. Otherwise we would conflict with ourselfs in a situation were
132	// a device is connected to the same network via WiFi and Ethernet.
133	this.records = [	×
134	this.service.srvRecord(), this.service.txtRecord(),
135	this.service.ptrRecord(), ...this.service.subtypePtrRecords(),
136	...this.service.allAddressRecords(), //...this.service.allReverseAddressMappings(),
137	].sort(rrComparator); // we sort them for the tiebreaking algorithm
138	this.records.forEach(record => record.flushFlag = false);	×
139	}
140
NEW 141	if (this.sentQueriesForCurrentTry >= 3) {	×
142	// we sent three requests and it seems like we weren't canceled, so we have a success right here
143	this.endProbing(true);	×
144	return;	×
145	}
146
NEW 147	if (this.sentQueries >= 15) {	×
NEW 148	this.currentInterval = LIMITED_PROBE_INTERVAL;	×
149	}
150
NEW 151	debug("Sending prober query number %d for '%s'...", this.sentQueriesForCurrentTry + 1, this.service.getFQDN());	×
152
153	assert(this.records.length > 0, "Tried sending probing request for zero record length!");	×
154
155	this.server.sendQueryBroadcast({	×
156	questions: [
157	// probes SHOULD be send with unicast response flag as of the RFC
158	// MDNServer might overwrite the QU flag to false, as we can't use unicast if there is another responder on the machine
159	new Question(this.service.getFQDN(), QType.ANY, true),
160	new Question(this.service.getHostname(), QType.ANY, true),
161	],
162	authorities: this.records, // include records we want to announce in authorities to support Simultaneous Probe Tiebreaking (RFC 6762 8.2.)
163	}, error => {
164	if (error) {	×
165	debug("Failed to send probe query for '%s'. Encountered error: " + error.stack, this.service.getFQDN());	×
166	this.endProbing(false);	×
167	this.promiseReject!(error);	×
168	return;	×
169	}
170
171	if (this.service.serviceState !== ServiceState.PROBING) {	×
172	debug("Service '%s' is no longer in probing state. Stopping.", this.service.getFQDN());	×
173	return;	×
174	}
175
176	this.sentFirstProbeQuery = true;	×
NEW 177	this.sentQueriesForCurrentTry++;	×
UNCOV 178	this.sentQueries++;	×
179
NEW 180	this.timer = setTimeout(this.sendProbeRequest.bind(this), this.currentInterval);	×
181	this.timer.unref();	×
182	});
183	}
184
185	handleResponse(packet: DNSPacket): void {
186	if (!this.sentFirstProbeQuery) {	×
187	return;	×
188	}
189
190	let containsAnswer = false;	×
191	// search answers and additionals for answers to our probe queries
192	packet.answers.forEach(record => {	×
193	if (dnsEqual(record.name, this.service.getFQDN()) \|\| dnsEqual(record.name, this.service.getHostname())) {	×
194	containsAnswer = true;	×
195	}
196	});
197	packet.additionals.forEach(record => {	×
198	if (dnsEqual(record.name, this.service.getFQDN()) \|\| dnsEqual(record.name, this.service.getHostname())) {	×
199	containsAnswer = true;	×
200	}
201	});
202
203	if (containsAnswer) { // abort and cancel probes	×
204	debug("Probing for '%s' failed. Doing a name change", this.service.getFQDN());	×
205
206	this.endProbing(false); // reset the prober	×
207	this.service.serviceState = ServiceState.UNANNOUNCED;	×
208	this.service.incrementName();	×
209	this.service.serviceState = ServiceState.PROBING;	×
210
211	this.serviceEncounteredNameChange = true;	×
212
NEW 213	this.endProbing(false); // cancel the current probing	×
214
NEW 215	this.timer = setTimeout(this.sendProbeRequest.bind(this), 1000);	×
NEW 216	this.timer.unref();	×
217	}
218	}
219
220	handleQuery(packet: DNSPacket): void {
221	if (!this.sentFirstProbeQuery) { // ignore queries if we are not sending	×
222	return;	×
223	}
224
225	// if we are currently probing and receiving a query which is also a probing query
226	// which matches the desired name we run the tiebreaking algorithm to decide on the winner
227	let needsTiebreaking = false;	×
228	packet.questions.forEach(question => {	×
229	if (dnsEqual(question.name, this.service.getFQDN()) \|\| dnsEqual(question.name, this.service.getHostname())) {	×
230	needsTiebreaking = true;	×
231	}
232	});
233
234
235	if (needsTiebreaking) {	×
236	this.doTiebreaking(packet);	×
237	}
238	}
239
240	private doTiebreaking(packet: DNSPacket): void {
241	if (!this.sentFirstProbeQuery) { // ignore queries if we are not sending	×
242	return;	×
243	}
244
245	// first of all check if the contents of authorities answers our query
246	let conflict = packet.authorities.length === 0;	×
247	packet.authorities.forEach(record => {	×
248	if (dnsEqual(record.name, this.service.getFQDN()) \|\| dnsEqual(record.name, this.service.getHostname())) {	×
249	conflict = true;	×
250	}
251	});
252	if (!conflict) {	×
253	return;	×
254	}
255	// now run the actual tiebreaking algorithm to decide the winner
256
257	// tiebreaking is actually run pretty often, as we always receive our own packets
258
259	// first of all build our own records
260	const answers = this.records; // already sorted	×
261	const opponent = packet.authorities.sort(tiebreaking.rrComparator);	×
262
263	const result = tiebreaking.runTiebreaking(answers, opponent);	×
264
265	if (result === TiebreakingResult.HOST) {	×
266	debug("'%s' won the tiebreak. We gonna ignore the other probing request!", this.service.getFQDN());	×
267	} else if (result === TiebreakingResult.OPPONENT) {	×
268	debug("'%s' lost the tiebreak. We are waiting a second and try to probe again...", this.service.getFQDN());	×
269
270	this.endProbing(false); // cancel the current probing	×
271
272	// wait 1 second and probe again (this is to guard against stale probe packets)
273	// If it wasn't a stale probe packet, the other host will correctly respond to our probe queries by then
274	this.timer = setTimeout(this.sendProbeRequest.bind(this), 1000);	×
275	this.timer.unref();	×
276	} else {
277	//debug("Tiebreaking for '%s' detected exact same records on the network. There is actually no conflict!", this.service.getFQDN());
278	}
279	}
280
281	}

homebridge / ciao / 163789673

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