Debian Codegraph @

src/resolve/resolved-dns-browse-services.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "af-list.h"
4 #include "alloc-util.h"
5 #include "dns-domain.h"
6 #include "dns-question.h"
7 #include "dns-rr.h"
8 #include "event-util.h"
9 #include "log.h"
10 #include "random-util.h"
11 #include "resolved-dns-browse-services.h"
12 #include "resolved-dns-cache.h"
13 #include "resolved-dns-query.h"
14 #include "resolved-dns-scope.h"
15 #include "resolved-manager.h"
16 #include "string-table.h"
17 #include "string-util.h"
18
19 typedef enum BrowseServiceUpdateEvent {
20 BROWSE_SERVICE_UPDATE_ADDED,
21 BROWSE_SERVICE_UPDATE_REMOVED,
22 _BROWSE_SERVICE_UPDATE_MAX,
23 _BROWSE_SERVICE_UPDATE_INVALID = -EINVAL,
24 } BrowseServiceUpdateEvent;
25
26 static const char * const browse_service_update_event_table[_BROWSE_SERVICE_UPDATE_MAX] = {
27 [BROWSE_SERVICE_UPDATE_ADDED] = "added",
28 [BROWSE_SERVICE_UPDATE_REMOVED] = "removed",
29 };
30
31 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(browse_service_update_event, BrowseServiceUpdateEvent);
32
33 /* RFC6762 5.2
34 * The intervals between successive queries MUST increase by at least a
35 * factor of two. When the interval between queries reaches or exceeds
36 * 60 minutes, perform subsequent queries at a steady-state rate of one
37 * query per hour. */
38 static usec_t mdns_calculate_next_query_delay(usec_t current_delay) {
39 assert(current_delay <= 60 * 60 * USEC_PER_SEC);
40
41 if (current_delay == 0)
42 return USEC_PER_SEC;
43
44 return current_delay < 60 * 60 / 2 * USEC_PER_SEC ? current_delay * 2 : 60 * 60 * USEC_PER_SEC;
45 }
46
47 /* RFC 6762 section 5.2
48 * The querier should plan to issue a query at 80% of
49 * the record lifetime, and then if no answer is received, at 85%, 90%, and 95%. */
50 static inline int DNS_RECORD_TTL_STATE_TO_PERCENT(DnsRecordTTLState ttl_state) {
51 static const int ttl_percent_table[_DNS_RECORD_TTL_STATE_MAX] = {
52 [DNS_RECORD_TTL_STATE_80_PERCENT] = 80,
53 [DNS_RECORD_TTL_STATE_85_PERCENT] = 85,
54 [DNS_RECORD_TTL_STATE_90_PERCENT] = 90,
55 [DNS_RECORD_TTL_STATE_95_PERCENT] = 95,
56 [DNS_RECORD_TTL_STATE_100_PERCENT] = 100,
57 };
58 if (ttl_state < 0 || ttl_state >= _DNS_RECORD_TTL_STATE_MAX)
59 return -EINVAL;
60 return ttl_percent_table[ttl_state];
61 }
62
63 static usec_t mdns_maintenance_next_time(usec_t until, uint32_t ttl, DnsRecordTTLState ttl_state) {
64 assert(ttl_state >= DNS_RECORD_TTL_STATE_80_PERCENT);
65 assert(ttl_state < _DNS_RECORD_TTL_STATE_MAX);
66
67 int percent = DNS_RECORD_TTL_STATE_TO_PERCENT(ttl_state);
68 assert(percent > 0);
69 assert(percent <= 100);
70
71 return usec_sub_unsigned(until, (100 - percent) * ttl * USEC_PER_SEC / 100);
72 }
73
74 /* RFC 6762 section 5.2
75 * A random variation of 2% of the record TTL should
76 * be added to maintenance queries. */
77 static usec_t mdns_maintenance_jitter(uint32_t ttl) {
78 return random_u64_range(2 * ttl * USEC_PER_SEC / 100);
79 }
80
81 static void mdns_maintenance_query_complete(DnsQuery *q) {
82 _cleanup_(dns_service_browser_unrefp) DnsServiceBrowser *sb = NULL;
83 _cleanup_(dns_query_freep) DnsQuery *query = q;
84 DnssdDiscoveredService *service = NULL;
85 int r;
86
87 assert(query);
88 assert(query->manager);
89
90 if (query->state != DNS_TRANSACTION_SUCCESS)
91 return;
92
93 service = dnssd_discovered_service_ref(query->dnsservice_request);
94 if (!service)
95 return;
96
97 sb = dns_service_browser_ref(service->service_browser);
98 if (!sb)
99 return;
100
101 r = mdns_browser_revisit_cache(sb, query->answer_family);
102 if (r < 0)
103 return (void) log_error_errno(r, "Failed to revisit cache for family %s: %m", af_to_name(query->answer_family));
104 }
105
106 static int mdns_maintenance_query(sd_event_source *s, uint64_t usec, void *userdata) {
107 DnssdDiscoveredService *service = ASSERT_PTR(userdata);
108 _cleanup_(dns_query_freep) DnsQuery *q = NULL;
109 int r;
110
111 /* Check if the TTL state has reached the maximum value, then revisit
112 * cache */
113 if (service->rr_ttl_state++ == DNS_RECORD_TTL_STATE_100_PERCENT)
114 return mdns_browser_revisit_cache(service->service_browser, service->family);
115
116 /* Create a new DNS query */
117 r = dns_query_new(
118 service->service_browser->manager,
119 &q,
120 service->service_browser->question_utf8,
121 service->service_browser->question_idna,
122 /* question_bypass= */ NULL,
123 service->service_browser->ifindex,
124 service->service_browser->flags);
125 if (r < 0)
126 return log_error_errno(r, "Failed to create mDNS query for maintenance: %m");
127
128 q->complete = mdns_maintenance_query_complete;
129 q->varlink_request = sd_varlink_ref(service->service_browser->link);
130 q->dnsservice_request = dnssd_discovered_service_ref(service);
131
132 /* Schedule the next maintenance query based on the TTL */
133 usec_t next_time = mdns_maintenance_next_time(service->until, service->rr->ttl, service->rr_ttl_state);
134
135 r = event_reset_time(
136 service->service_browser->manager->event,
137 &service->schedule_event,
138 CLOCK_BOOTTIME,
139 next_time,
140 /* accuracy= */ 0,
141 mdns_maintenance_query,
142 service,
143 /* priority= */ 0,
144 "mdns-next-query-schedule",
145 /* force_reset= */ true);
146 if (r < 0)
147 return log_error_errno(r, "Failed to schedule next mDNS maintenance query: %m");
148
149 /* Perform the query */
150 r = dns_query_go(q);
151 if (r < 0)
152 return log_error_errno(r, "Failed to send mDNS maintenance query: %m");
153
154 TAKE_PTR(q);
155 return 0;
156 }
157
158 int dns_add_new_service(DnsServiceBrowser *sb, DnsResourceRecord *rr, int owner_family, int ifindex, usec_t until) {
159 _cleanup_(dnssd_discovered_service_unrefp) DnssdDiscoveredService *s = NULL;
160 int r;
161
162 assert(sb);
163 assert(rr);
164
165 s = new(DnssdDiscoveredService, 1);
166 if (!s)
167 return log_oom();
168
169 usec_t usec = now(CLOCK_BOOTTIME);
170
171 *s = (DnssdDiscoveredService) {
172 .n_ref = 1,
173 .service_browser = sb,
174 .rr = dns_resource_record_copy(rr),
175 .family = owner_family,
176 .ifindex = ifindex,
177 .until = until,
178 .query = NULL,
179 .rr_ttl_state = DNS_RECORD_TTL_STATE_80_PERCENT,
180 };
181
182 LIST_PREPEND(dns_services, sb->dns_services, s);
183
184 /* Schedule the first cache maintenance query at 80% of the record's
185 * TTL. Subsequent queries issued at 5% increments until 100% of the
186 * TTL. RFC 6762 section 5.2. If service is being added after 80% of the
187 * TTL has already elapsed, schedule the next query at the next 5%
188 * increment. */
189 usec_t next_time = 0;
190 while (s->rr_ttl_state >= DNS_RECORD_TTL_STATE_80_PERCENT &&
191 s->rr_ttl_state < _DNS_RECORD_TTL_STATE_MAX) {
192 next_time = mdns_maintenance_next_time(s->until, s->rr->ttl, s->rr_ttl_state);
193 if (next_time >= usec)
194 break;
195
196 s->rr_ttl_state++;
197 }
198
199 if (next_time < usec) {
200 /* If next_time is still in the past, the service is being added
201 * after it has already expired. Just schedule a 100%
202 * maintenance query. */
203 next_time = usec_add(usec, USEC_PER_SEC);
204 s->rr_ttl_state = DNS_RECORD_TTL_STATE_100_PERCENT;
205 }
206
207 usec_t jitter = mdns_maintenance_jitter(rr->ttl);
208
209 r = sd_event_add_time(
210 sb->manager->event,
211 &s->schedule_event,
212 CLOCK_BOOTTIME,
213 usec_add(next_time, jitter),
214 /* accuracy= */ 0,
215 mdns_maintenance_query,
216 s);
217 if (r < 0)
218 return log_error_errno(
219 r,
220 "Failed to schedule mDNS maintenance query for DNS service: %m");
221
222 TAKE_PTR(s);
223 return 0;
224 }
225
226 void dns_remove_service(DnsServiceBrowser *sb, DnssdDiscoveredService *service) {
227 assert(sb);
228 assert(service);
229
230 LIST_REMOVE(dns_services, sb->dns_services, service);
231 dnssd_discovered_service_unref(service);
232 }
233
234 DnssdDiscoveredService *dns_service_free(DnssdDiscoveredService *service) {
235 if (!service)
236 return NULL;
237
238 service->schedule_event = sd_event_source_disable_unref(service->schedule_event);
239
240 if (service->query && DNS_TRANSACTION_IS_LIVE(service->query->state))
241 dns_query_complete(service->query, DNS_TRANSACTION_ABORTED);
242
243 service->rr = dns_resource_record_unref(service->rr);
244
245 return mfree(service);
246 }
247
248 DEFINE_TRIVIAL_REF_UNREF_FUNC(DnssdDiscoveredService, dnssd_discovered_service, dns_service_free);
249
250 int mdns_service_update(DnssdDiscoveredService *service, DnsResourceRecord *rr, usec_t t, usec_t until) {
251 assert(service);
252 assert(rr);
253
254 service->until = until;
255 service->rr->ttl = rr->ttl;
256
257 /* Update the 80% TTL maintenance event based on new record received
258 * from the network. RFC 6762 section 5.2 */
259 if (service->schedule_event) {
260 usec_t next_time = mdns_maintenance_next_time(
261 service->until, service->rr->ttl, DNS_RECORD_TTL_STATE_80_PERCENT);
262 usec_t jitter = mdns_maintenance_jitter(service->rr->ttl);
263
264 return sd_event_source_set_time(service->schedule_event, usec_add(next_time, jitter));
265 }
266
267 return 0;
268 }
269
270 bool dns_service_match_and_update(DnssdDiscoveredService *services, DnsResourceRecord *rr, int owner_family, usec_t until) {
271 usec_t t = now(CLOCK_BOOTTIME);
272
273 /* Check if a discovered service matching the given resource record and owner family exists in the list.
274 * If found, update the service's expiration time if the new 'until' is later, unless the TTL is <= 1 (goodbye packet).
275 * Return true if a matching service is found, false otherwise. */
276
277 LIST_FOREACH(dns_services, service, services)
278 if (dns_resource_record_equal(service->rr, rr) > 0 && service->family == owner_family) {
279 if (rr->ttl <= 1)
280 return true;
281
282 if (service->until < until)
283 mdns_service_update(service, rr, t, until);
284
285 return true;
286 }
287
288 return false;
289 }
290
291 void dns_browse_services_purge(Manager *m, int family) {
292 int r = 0;
293
294 /* Called after caches are flushed.
295 * Clear local service records and notify varlink client. */
296 if (!m)
297 return;
298
299 DnsServiceBrowser *sb;
300 HASHMAP_FOREACH(sb, m->dns_service_browsers) {
301 r = sd_event_source_set_enabled(sb->schedule_event, SD_EVENT_OFF);
302 if (r < 0)
303 log_error_errno(r, "Failed to disable event source for service browser, ignoring: %m");
304
305 if (IN_SET(family, AF_INET, AF_UNSPEC)) {
306 r = mdns_browser_revisit_cache(sb, AF_INET);
307 if (r < 0)
308 log_error_errno(r, "Failed to revisit cache for IPv4, ignoring: %m");
309 }
310
311 if (IN_SET(family, AF_INET6, AF_UNSPEC)) {
312 r = mdns_browser_revisit_cache(sb, AF_INET6);
313 if (r < 0)
314 log_error_errno(r, "Failed to revisit cache for IPv6, ignoring: %m");
315 }
316 }
317 }
318
319 int mdns_manage_services_answer(DnsServiceBrowser *sb, DnsAnswer *answer, int owner_family) {
320 DnsAnswerItem *item;
321 _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
322 int r;
323
324 assert(sb);
325
326 /* Check for new service added */
327 DNS_ANSWER_FOREACH_ITEM(item, answer) {
328 _cleanup_free_ char *name = NULL, *type = NULL, *domain = NULL;
329 _cleanup_(sd_json_variant_unrefp) sd_json_variant *entry = NULL;
330 int ifindex;
331
332 if (dns_service_match_and_update(sb->dns_services, item->rr, owner_family, item->until))
333 continue;
334
335 r = dns_service_split(item->rr->ptr.name, &name, &type, &domain);
336 if (r < 0) {
337 log_error_errno(r, "Failed to split DNS service name: %m");
338 goto finish;
339 }
340
341 if (!name) {
342 type = mfree(type);
343 domain = mfree(domain);
344 r = dns_service_split(dns_resource_key_name(item->rr->key), &name, &type, &domain);
345 if (r < 0) {
346 log_error_errno(r, "Failed to split DNS service name (fallback): %m");
347 goto finish;
348 }
349 }
350
351 if (!type)
352 continue;
353
354 /* Prefer the per-item ifindex, fall back to the service browser's ifindex */
355 ifindex = item->ifindex > 0 ? item->ifindex : sb->ifindex;
356
357 r = dns_add_new_service(sb, item->rr, owner_family, ifindex, item->until);
358 if (r < 0) {
359 log_error_errno(r, "Failed to add new DNS service: %m");
360 goto finish;
361 }
362
363 log_debug("Add into the list %s, %s, %s, %s, %d",
364 strna(name),
365 strna(type),
366 strna(domain),
367 strna(af_to_ipv4_ipv6(owner_family)),
368 ifindex);
369
370 r = sd_json_buildo(
371 &entry,
372 SD_JSON_BUILD_PAIR_STRING(
373 "updateFlag",
374 browse_service_update_event_to_string(
375 BROWSE_SERVICE_UPDATE_ADDED)),
376 SD_JSON_BUILD_PAIR_INTEGER("family", owner_family),
377 SD_JSON_BUILD_PAIR_CONDITION(
378 !isempty(name), "name", SD_JSON_BUILD_STRING(name)),
379 SD_JSON_BUILD_PAIR_CONDITION(
380 !isempty(type), "type", SD_JSON_BUILD_STRING(type)),
381 SD_JSON_BUILD_PAIR_CONDITION(
382 !isempty(domain), "domain", SD_JSON_BUILD_STRING(domain)),
383 SD_JSON_BUILD_PAIR_INTEGER("ifindex", ifindex));
384 if (r < 0) {
385 log_error_errno(r, "Failed to build JSON for new service: %m");
386 goto finish;
387 }
388
389 r = sd_json_variant_append_array(&array, entry);
390 if (r < 0) {
391 log_error_errno(r, "Failed to append JSON entry to array: %m");
392 goto finish;
393 }
394 }
395
396 /* Check for services removed */
397 LIST_FOREACH(dns_services, service, sb->dns_services) {
398 _cleanup_free_ char *name = NULL, *type = NULL, *domain = NULL;
399 _cleanup_(sd_json_variant_unrefp) sd_json_variant *entry = NULL;
400 int ifindex;
401
402 if (service->family != owner_family)
403 continue;
404
405 if (dns_answer_contains(answer, service->rr))
406 continue;
407
408 r = dns_service_split(service->rr->ptr.name, &name, &type, &domain);
409 if (r < 0) {
410 log_error_errno(r, "Failed to split DNS service name from list: %m");
411 goto finish;
412 }
413
414 if (!name) {
415 type = mfree(type);
416 domain = mfree(domain);
417 r = dns_service_split(dns_resource_key_name(service->rr->key), &name, &type, &domain);
418 if (r < 0) {
419 log_error_errno(r,
420 "Failed to split DNS service name (fallback) from list: %m");
421 goto finish;
422 }
423 }
424
425 /* Capture ifindex before removing the service */
426 ifindex = service->ifindex;
427
428 dns_remove_service(sb, service);
429
430 log_debug("Remove from the list %s, %s, %s, %s, %d",
431 strna(name),
432 strna(type),
433 strna(domain),
434 strna(af_to_ipv4_ipv6(owner_family)),
435 ifindex);
436
437 r = sd_json_buildo(
438 &entry,
439 SD_JSON_BUILD_PAIR_STRING(
440 "updateFlag",
441 browse_service_update_event_to_string(
442 BROWSE_SERVICE_UPDATE_REMOVED)),
443 SD_JSON_BUILD_PAIR_INTEGER("family", owner_family),
444 SD_JSON_BUILD_PAIR_STRING("name", strempty(name)),
445 SD_JSON_BUILD_PAIR_STRING("type", strempty(type)),
446 SD_JSON_BUILD_PAIR_STRING("domain", strempty(domain)),
447 SD_JSON_BUILD_PAIR_INTEGER("ifindex", ifindex));
448 if (r < 0) {
449 log_error_errno(r, "Failed to build JSON for removed service: %m");
450 goto finish;
451 }
452
453 r = sd_json_variant_append_array(&array, entry);
454 if (r < 0) {
455 log_error_errno(r, "Failed to append JSON entry to array: %m");
456 goto finish;
457 }
458 }
459
460 if (!sd_json_variant_is_blank_array(array)) {
461 _cleanup_(sd_json_variant_unrefp) sd_json_variant *vm = NULL;
462
463 r = sd_json_buildo(&vm, SD_JSON_BUILD_PAIR_VARIANT("browserServiceData", array));
464 if (r < 0) {
465 log_error_errno(r,
466 "Failed to build JSON object for browser service data: %m");
467 goto finish;
468 }
469
470 r = sd_varlink_notify(sb->link, vm);
471 if (r < 0) {
472 log_error_errno(r, "Failed to notify via varlink: %m");
473 goto finish;
474 }
475 }
476
477 return 0;
478
479 finish:
480 return sd_varlink_error_errno(sb->link, r);
481 }
482
483 int mdns_browser_revisit_cache(DnsServiceBrowser *sb, int owner_family) {
484 _cleanup_(dns_answer_unrefp) DnsAnswer *lookup_ret_answer = NULL;
485 int r;
486
487 assert(sb);
488 assert(sb->manager);
489
490 /* ifindex=0 means "all interfaces" */
491 if (sb->ifindex == 0) {
492 LIST_FOREACH(scopes, scope, sb->manager->dns_scopes) {
493 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
494
495 if (scope->protocol != DNS_PROTOCOL_MDNS)
496 continue;
497
498 if (scope->family != owner_family)
499 continue;
500
501 dns_cache_prune(&scope->cache);
502
503 r = dns_cache_lookup(
504 &scope->cache,
505 sb->key,
506 sb->flags,
507 /* ret_rcode= */ NULL,
508 &answer,
509 /* ret_full_packet= */ NULL,
510 /* ret_query_flags= */ NULL,
511 /* ret_dnssec_result= */ NULL);
512 if (r < 0)
513 return log_error_errno(r, "Failed to look up DNS cache for service browser key on scope %s: %m",
514 dns_scope_ifname(scope) ?: "global");
515
516 r = mdns_manage_services_answer(sb, answer, owner_family);
517 if (r < 0)
518 return log_error_errno(r, "Failed to manage mDNS services after cache lookup on scope %s: %m",
519 dns_scope_ifname(scope) ?: "global");
520 }
521 return 0;
522 }
523
524 /* Single scope for specifically requested interface */
525 DnsScope *scope = manager_find_scope_from_protocol(sb->manager, sb->ifindex, DNS_PROTOCOL_MDNS, owner_family);
526 if (!scope)
527 return 0;
528
529 dns_cache_prune(&scope->cache);
530
531 r = dns_cache_lookup(
532 &scope->cache,
533 sb->key,
534 sb->flags,
535 /* ret_rcode= */ NULL,
536 &lookup_ret_answer,
537 /* ret_full_packet= */ NULL,
538 /* ret_query_flags= */ NULL,
539 /* ret_dnssec_result= */ NULL);
540 if (r < 0)
541 return log_error_errno(r, "Failed to look up DNS cache for service browser key: %m");
542
543 r = mdns_manage_services_answer(sb, lookup_ret_answer, owner_family);
544 if (r < 0)
545 return log_error_errno(r, "Failed to manage mDNS services after cache lookup: %m");
546
547 return 0;
548 }
549
550 int mdns_notify_browsers_goodbye(DnsScope *scope) {
551 DnsServiceBrowser *sb;
552 int r;
553
554 if (!scope)
555 return 0;
556
557 HASHMAP_FOREACH(sb, scope->manager->dns_service_browsers) {
558 r = mdns_browser_revisit_cache(sb, scope->family);
559 if (r < 0)
560 return log_error_errno(
561 r,
562 "Failed to revisit cache for service browser with family %d: %m",
563 scope->family);
564 }
565
566 return 0;
567 }
568
569 int mdns_notify_browsers_unsolicited_updates(Manager *m, DnsAnswer *answer, int owner_family) {
570 DnsServiceBrowser *sb;
571 int r;
572
573 assert(m);
574
575 if (!answer)
576 return 0;
577
578 HASHMAP_FOREACH(sb, m->dns_service_browsers) {
579
580 r = dns_answer_match_key(answer, sb->key, NULL);
581 if (r < 0)
582 return log_error_errno(
583 r,
584 "Failed to match answer key with service browser's key: %m");
585 if (r == 0)
586 continue;
587
588 r = mdns_browser_revisit_cache(sb, owner_family);
589 if (r < 0)
590 return log_error_errno(r, "Failed to revisit cache for service browser: %m");
591 }
592
593 return 0;
594 }
595
596 static void mdns_browse_service_query_complete(DnsQuery *q) {
597 _cleanup_(dns_service_browser_unrefp) DnsServiceBrowser *sb = NULL;
598 _cleanup_(dns_query_freep) DnsQuery *query = q;
599 int r;
600
601 assert(query);
602 assert(query->manager);
603
604 if (query->state != DNS_TRANSACTION_SUCCESS)
605 return;
606
607 sb = dns_service_browser_ref(query->service_browser_request);
608 if (!sb)
609 return;
610
611 r = mdns_browser_revisit_cache(sb, query->answer_family);
612 if (r < 0)
613 return (void) log_error_errno(r, "Failed to revisit cache for service browser: %m");
614
615 /* When the query is answered from cache, we only get answers for one
616 * answer_family i.e. either ipv4 or ipv6. We need to perform another
617 * cache lookup for the other answer_family */
618 if (query->answer_query_flags == SD_RESOLVED_FROM_CACHE) {
619 r = mdns_browser_revisit_cache(sb, query->answer_family == AF_INET ? AF_INET6 : AF_INET);
620 if (r < 0)
621 return (void) log_error_errno(r, "Failed to revisit cache for service browser: %m");
622 }
623 }
624
625 static int mdns_next_query_schedule(sd_event_source *s, uint64_t usec, void *userdata) {
626 _cleanup_(dns_service_browser_unrefp) DnsServiceBrowser *sb = NULL;
627 _cleanup_(dns_query_freep) DnsQuery *q = NULL;
628 int r;
629
630 assert(userdata);
631 assert_se(sb = dns_service_browser_ref(userdata));
632
633 /* Enable the answer from the cache for the very first query */
634 if (sb->delay == 0)
635 SET_FLAG(sb->flags, SD_RESOLVED_NO_CACHE, false);
636
637 /* Set the flag indicating that the query is continuous.
638 * RFC 6762 Section 5.2 outlines timing requirements for continuous queries.
639 */
640 sb->flags |= SD_RESOLVED_QUERY_CONTINUOUS;
641
642 r = dns_query_new(sb->manager, &q, sb->question_utf8, sb->question_idna, NULL, sb->ifindex, sb->flags);
643 if (r < 0)
644 return log_error_errno(r, "Failed to create new DNS query: %m");
645
646 q->complete = mdns_browse_service_query_complete;
647 q->service_browser_request = dns_service_browser_ref(sb);
648 q->varlink_request = sd_varlink_ref(sb->link);
649 sd_varlink_set_userdata(sb->link, q);
650
651 r = dns_query_go(q);
652 if (r < 0)
653 return log_error_errno(r, "Failed to send DNS query: %m");
654
655 /* Calculate the next query delay */
656 sb->delay = mdns_calculate_next_query_delay(sb->delay);
657
658 SET_FLAG(sb->flags, SD_RESOLVED_NO_CACHE, true);
659
660 r = event_reset_time_relative(
661 sb->manager->event,
662 &sb->schedule_event,
663 CLOCK_BOOTTIME,
664 sb->delay,
665 /* accuracy= */ 0,
666 mdns_next_query_schedule,
667 sb,
668 /* priority= */ 0,
669 "mdns-next-query-schedule",
670 /* force_reset= */ true);
671 if (r < 0)
672 return log_error_errno(r, "Failed to reset event time for next query schedule: %m");
673
674 TAKE_PTR(q);
675
676 return 0;
677 }
678
679 void dns_browse_services_restart(Manager *m) {
680 int r;
681
682 if (!(m && m->dns_service_browsers))
683 return;
684
685 DnsServiceBrowser *sb;
686
687 HASHMAP_FOREACH(sb, m->dns_service_browsers) {
688 sb->delay = 0;
689
690 r = event_reset_time_relative(
691 sb->manager->event,
692 &sb->schedule_event,
693 CLOCK_BOOTTIME,
694 (sb->delay * USEC_PER_SEC),
695 /* accuracy= */ 0,
696 mdns_next_query_schedule,
697 sb,
698 /* priority= */ 0,
699 "mdns-next-query-schedule",
700 /* force_reset= */ true);
701
702 if (r < 0)
703 log_error_errno(r,
704 "Failed to reset mDNS service subscriber event for service browser: %m");
705 }
706 }
707
708 int dns_subscribe_browse_service(
709 Manager *m, sd_varlink *link, const char *domain, const char *type, int ifindex, uint64_t flags) {
710
711 _cleanup_(dns_service_browser_unrefp) DnsServiceBrowser *sb = NULL;
712 _cleanup_(dns_question_unrefp) DnsQuestion *question_idna = NULL, *question_utf8 = NULL;
713 int r;
714
715 assert(m);
716 assert(link);
717
718 if (ifindex < 0)
719 return sd_varlink_error_invalid_parameter_name(link, "ifindex");
720
721 if (ifindex == 0)
722 log_debug("BrowseServices: browsing all mDNS interfaces");
723
724 if (isempty(type))
725 type = NULL;
726 else if (!dnssd_srv_type_is_valid(type))
727 return sd_varlink_error_invalid_parameter_name(link, "type");
728
729 if (isempty(domain))
730 domain = "local";
731 else {
732 r = dns_name_is_valid(domain);
733 if (r < 0)
734 return r;
735 if (r == 0)
736 return sd_varlink_error_invalid_parameter_name(link, "domain");
737 }
738
739 r = dns_question_new_service_pointer(
740 &question_utf8, type, domain, /* convert_idna= */ false);
741 if (r < 0)
742 return log_error_errno(r, "Failed to create DNS question for UTF8 version: %m");
743
744 r = dns_question_new_service_pointer(
745 &question_idna, type, domain, /* convert_idna= */ true);
746 if (r < 0)
747 return log_error_errno(r, "Failed to create DNS question for IDNA version: %m");
748
749 sb = new(DnsServiceBrowser, 1);
750 if (!sb)
751 return log_oom();
752
753 *sb = (DnsServiceBrowser) {
754 .n_ref = 1,
755 .manager = m,
756 .link = sd_varlink_ref(link),
757 .question_utf8 = dns_question_ref(question_utf8),
758 .question_idna = dns_question_ref(question_idna),
759 .key = dns_question_first_key(question_utf8),
760 .ifindex = ifindex,
761 .flags = flags,
762 .delay = 0,
763 };
764
765 /* Only mDNS continuous querying is currently supported. See RFC 6762 */
766 if (!FLAGS_SET(flags, SD_RESOLVED_MDNS))
767 return -EINVAL;
768
769 r = sd_event_add_time_relative(
770 m->event,
771 &sb->schedule_event,
772 CLOCK_BOOTTIME,
773 sb->delay,
774 /* accuracy= */ 0,
775 mdns_next_query_schedule,
776 sb);
777 if (r < 0)
778 return r;
779
780 r = hashmap_ensure_put(&m->dns_service_browsers, NULL, link, sb);
781 if (r < 0)
782 return log_error_errno(r, "Failed to add service browser to the hashmap: %m");
783
784 TAKE_PTR(sb);
785
786 return 0;
787 }
788
789 DnsServiceBrowser *dns_service_browser_free(DnsServiceBrowser *sb) {
790 DnsQuery *q;
791
792 if (!sb)
793 return NULL;
794
795 while (sb->dns_services)
796 dns_remove_service(sb, sb->dns_services);
797
798 sb->schedule_event = sd_event_source_disable_unref(sb->schedule_event);
799
800 q = sd_varlink_get_userdata(sb->link);
801 if (q && DNS_TRANSACTION_IS_LIVE(q->state))
802 dns_query_complete(q, DNS_TRANSACTION_ABORTED);
803
804 sb->question_idna = dns_question_unref(sb->question_idna);
805 sb->question_utf8 = dns_question_unref(sb->question_utf8);
806
807 sb->link = sd_varlink_unref(sb->link);
808
809 return mfree(sb);
810 }
811
812 DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsServiceBrowser, dns_service_browser, dns_service_browser_free);