Debian Codegraph @

src/network/networkd-link-bus.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <net/if.h>
4
5 #include "sd-bus.h"
6 #include "sd-dhcp-server.h"
7
8 #include "alloc-util.h"
9 #include "bus-common-errors.h"
10 #include "bus-get-properties.h"
11 #include "bus-message-util.h"
12 #include "bus-object.h"
13 #include "bus-polkit.h"
14 #include "dns-domain.h"
15 #include "networkd-dhcp4.h"
16 #include "networkd-json.h"
17 #include "networkd-link.h"
18 #include "networkd-link-bus.h"
19 #include "networkd-manager.h"
20 #include "networkd-speed-meter.h"
21 #include "networkd-state-file.h"
22 #include "ordered-set.h"
23 #include "parse-util.h"
24 #include "resolve-util.h"
25 #include "set.h"
26 #include "socket-netlink.h"
27 #include "string-util.h"
28 #include "strv.h"
29
30 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_operational_state, link_operstate, LinkOperationalState);
31 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_carrier_state, link_carrier_state, LinkCarrierState);
32 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_address_state, link_address_state, LinkAddressState);
33 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_online_state, link_online_state, LinkOnlineState);
34 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_administrative_state, link_state, LinkState);
35
36 static int property_get_bit_rates(
37 sd_bus *bus,
38 const char *path,
39 const char *interface,
40 const char *property,
41 sd_bus_message *reply,
42 void *userdata,
43 sd_bus_error *error) {
44
45 Link *link = ASSERT_PTR(userdata);
46 uint64_t tx, rx;
47
48 assert(bus);
49 assert(reply);
50
51 link_get_bit_rates(link, &tx, &rx);
52
53 return sd_bus_message_append(reply, "(tt)", tx, rx);
54 }
55
56 static int verify_managed_link(Link *l, sd_bus_error *error) {
57 assert(l);
58
59 if (l->flags & IFF_LOOPBACK)
60 return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is loopback device.", l->ifname);
61
62 return 0;
63 }
64
65 int bus_link_method_set_ntp_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
66 _cleanup_strv_free_ char **ntp = NULL;
67 Link *l = ASSERT_PTR(userdata);
68 int r;
69
70 assert(message);
71
72 r = verify_managed_link(l, error);
73 if (r < 0)
74 return r;
75
76 r = sd_bus_message_read_strv(message, &ntp);
77 if (r < 0)
78 return r;
79
80 STRV_FOREACH(i, ntp) {
81 r = dns_name_is_valid_or_address(*i);
82 if (r < 0)
83 return r;
84 if (r == 0)
85 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid NTP server: %s", *i);
86 }
87
88 r = bus_verify_polkit_async(
89 message,
90 "org.freedesktop.network1.set-ntp-servers",
91 (const char**) STRV_MAKE("interface", l->ifname),
92 &l->manager->polkit_registry,
93 error);
94 if (r < 0)
95 return r;
96 if (r == 0)
97 return 1; /* Polkit will call us back */
98
99 strv_free_and_replace(l->ntp, ntp);
100
101 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
102 if (r < 0)
103 return r;
104
105 return sd_bus_reply_method_return(message, NULL);
106 }
107
108 static int bus_link_method_set_dns_servers_internal(sd_bus_message *message, void *userdata, sd_bus_error *error, bool extended) {
109 struct in_addr_full **dns;
110 Link *l = ASSERT_PTR(userdata);
111 size_t n;
112 int r;
113
114 assert(message);
115
116 r = verify_managed_link(l, error);
117 if (r < 0)
118 return r;
119
120 r = bus_message_read_dns_servers(message, error, extended, &dns, &n);
121 if (r < 0)
122 return r;
123
124 r = bus_verify_polkit_async(
125 message,
126 "org.freedesktop.network1.set-dns-servers",
127 (const char**) STRV_MAKE("interface", l->ifname),
128 &l->manager->polkit_registry,
129 error);
130 if (r < 0)
131 goto finalize;
132 if (r == 0) {
133 r = 1; /* Polkit will call us back */
134 goto finalize;
135 }
136
137 if (l->n_dns != UINT_MAX)
138 for (unsigned i = 0; i < l->n_dns; i++)
139 in_addr_full_free(l->dns[i]);
140
141 free_and_replace(l->dns, dns);
142 l->n_dns = n;
143
144 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
145 if (r < 0)
146 return r;
147
148 return sd_bus_reply_method_return(message, NULL);
149
150 finalize:
151 for (size_t i = 0; i < n; i++)
152 in_addr_full_free(dns[i]);
153 free(dns);
154
155 return r;
156 }
157
158 int bus_link_method_set_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
159 return bus_link_method_set_dns_servers_internal(message, userdata, error, false);
160 }
161
162 int bus_link_method_set_dns_servers_ex(sd_bus_message *message, void *userdata, sd_bus_error *error) {
163 return bus_link_method_set_dns_servers_internal(message, userdata, error, true);
164 }
165
166 int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
167 _cleanup_ordered_set_free_ OrderedSet *search_domains = NULL, *route_domains = NULL;
168 Link *l = ASSERT_PTR(userdata);
169 int r;
170
171 assert(message);
172
173 r = verify_managed_link(l, error);
174 if (r < 0)
175 return r;
176
177 r = sd_bus_message_enter_container(message, 'a', "(sb)");
178 if (r < 0)
179 return r;
180
181 /* The method accepts an empty strv, to override the domains set in .network.
182 * Hence, we need to explicitly allocate empty sets here. */
183 search_domains = ordered_set_new(&dns_name_hash_ops_free);
184 if (!search_domains)
185 return -ENOMEM;
186
187 route_domains = ordered_set_new(&dns_name_hash_ops_free);
188 if (!route_domains)
189 return -ENOMEM;
190
191 for (;;) {
192 _cleanup_free_ char *str = NULL;
193 const char *name;
194 int route_only;
195
196 r = sd_bus_message_read(message, "(sb)", &name, &route_only);
197 if (r < 0)
198 return r;
199 if (r == 0)
200 break;
201
202 r = dns_name_is_valid(name);
203 if (r < 0)
204 return r;
205 if (r == 0)
206 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
207 if (!route_only && dns_name_is_root(name))
208 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Root domain is not suitable as search domain");
209
210 r = dns_name_normalize(name, 0, &str);
211 if (r < 0)
212 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
213
214 r = ordered_set_consume(route_only ? route_domains : search_domains, TAKE_PTR(str));
215 if (r == -EEXIST)
216 continue;
217 if (r < 0)
218 return r;
219 }
220
221 r = sd_bus_message_exit_container(message);
222 if (r < 0)
223 return r;
224
225 r = bus_verify_polkit_async(
226 message,
227 "org.freedesktop.network1.set-domains",
228 (const char**) STRV_MAKE("interface", l->ifname),
229 &l->manager->polkit_registry,
230 error);
231 if (r < 0)
232 return r;
233 if (r == 0)
234 return 1; /* Polkit will call us back */
235
236 ordered_set_free(l->search_domains);
237 ordered_set_free(l->route_domains);
238 l->search_domains = TAKE_PTR(search_domains);
239 l->route_domains = TAKE_PTR(route_domains);
240
241 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
242 if (r < 0)
243 return r;
244
245 return sd_bus_reply_method_return(message, NULL);
246 }
247
248 int bus_link_method_set_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
249 Link *l = ASSERT_PTR(userdata);
250 int r, b;
251
252 assert(message);
253
254 r = verify_managed_link(l, error);
255 if (r < 0)
256 return r;
257
258 r = sd_bus_message_read(message, "b", &b);
259 if (r < 0)
260 return r;
261
262 r = bus_verify_polkit_async(
263 message,
264 "org.freedesktop.network1.set-default-route",
265 (const char**) STRV_MAKE("interface", l->ifname),
266 &l->manager->polkit_registry,
267 error);
268 if (r < 0)
269 return r;
270 if (r == 0)
271 return 1; /* Polkit will call us back */
272
273 if (l->dns_default_route != b) {
274 l->dns_default_route = b;
275
276 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
277 if (r < 0)
278 return r;
279 }
280
281 return sd_bus_reply_method_return(message, NULL);
282 }
283
284 int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
285 Link *l = ASSERT_PTR(userdata);
286 ResolveSupport mode;
287 const char *llmnr;
288 int r;
289
290 assert(message);
291
292 r = verify_managed_link(l, error);
293 if (r < 0)
294 return r;
295
296 r = sd_bus_message_read(message, "s", &llmnr);
297 if (r < 0)
298 return r;
299
300 if (isempty(llmnr))
301 mode = RESOLVE_SUPPORT_YES;
302 else {
303 mode = resolve_support_from_string(llmnr);
304 if (mode < 0)
305 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid LLMNR setting: %s", llmnr);
306 }
307
308 r = bus_verify_polkit_async(
309 message,
310 "org.freedesktop.network1.set-llmnr",
311 (const char**) STRV_MAKE("interface", l->ifname),
312 &l->manager->polkit_registry,
313 error);
314 if (r < 0)
315 return r;
316 if (r == 0)
317 return 1; /* Polkit will call us back */
318
319 if (l->llmnr != mode) {
320 l->llmnr = mode;
321
322 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
323 if (r < 0)
324 return r;
325 }
326
327 return sd_bus_reply_method_return(message, NULL);
328 }
329
330 int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
331 Link *l = ASSERT_PTR(userdata);
332 ResolveSupport mode;
333 const char *mdns;
334 int r;
335
336 assert(message);
337
338 r = verify_managed_link(l, error);
339 if (r < 0)
340 return r;
341
342 r = sd_bus_message_read(message, "s", &mdns);
343 if (r < 0)
344 return r;
345
346 if (isempty(mdns))
347 mode = RESOLVE_SUPPORT_NO;
348 else {
349 mode = resolve_support_from_string(mdns);
350 if (mode < 0)
351 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid MulticastDNS setting: %s", mdns);
352 }
353
354 r = bus_verify_polkit_async(
355 message,
356 "org.freedesktop.network1.set-mdns",
357 (const char**) STRV_MAKE("interface", l->ifname),
358 &l->manager->polkit_registry,
359 error);
360 if (r < 0)
361 return r;
362 if (r == 0)
363 return 1; /* Polkit will call us back */
364
365 if (l->mdns != mode) {
366 l->mdns = mode;
367
368 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
369 if (r < 0)
370 return r;
371 }
372
373 return sd_bus_reply_method_return(message, NULL);
374 }
375
376 int bus_link_method_set_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
377 Link *l = ASSERT_PTR(userdata);
378 const char *dns_over_tls;
379 DnsOverTlsMode mode;
380 int r;
381
382 assert(message);
383
384 r = verify_managed_link(l, error);
385 if (r < 0)
386 return r;
387
388 r = sd_bus_message_read(message, "s", &dns_over_tls);
389 if (r < 0)
390 return r;
391
392 if (isempty(dns_over_tls))
393 mode = _DNS_OVER_TLS_MODE_INVALID;
394 else {
395 mode = dns_over_tls_mode_from_string(dns_over_tls);
396 if (mode < 0)
397 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSOverTLS setting: %s", dns_over_tls);
398 }
399
400 r = bus_verify_polkit_async(
401 message,
402 "org.freedesktop.network1.set-dns-over-tls",
403 (const char**) STRV_MAKE("interface", l->ifname),
404 &l->manager->polkit_registry,
405 error);
406 if (r < 0)
407 return r;
408 if (r == 0)
409 return 1; /* Polkit will call us back */
410
411 if (l->dns_over_tls_mode != mode) {
412 l->dns_over_tls_mode = mode;
413
414 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
415 if (r < 0)
416 return r;
417 }
418
419 return sd_bus_reply_method_return(message, NULL);
420 }
421
422 int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
423 Link *l = ASSERT_PTR(userdata);
424 const char *dnssec;
425 DnssecMode mode;
426 int r;
427
428 assert(message);
429
430 r = verify_managed_link(l, error);
431 if (r < 0)
432 return r;
433
434 r = sd_bus_message_read(message, "s", &dnssec);
435 if (r < 0)
436 return r;
437
438 if (isempty(dnssec))
439 mode = _DNSSEC_MODE_INVALID;
440 else {
441 mode = dnssec_mode_from_string(dnssec);
442 if (mode < 0)
443 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
444 }
445
446 r = bus_verify_polkit_async(
447 message,
448 "org.freedesktop.network1.set-dnssec",
449 (const char**) STRV_MAKE("interface", l->ifname),
450 &l->manager->polkit_registry,
451 error);
452 if (r < 0)
453 return r;
454 if (r == 0)
455 return 1; /* Polkit will call us back */
456
457 if (l->dnssec_mode != mode) {
458 l->dnssec_mode = mode;
459
460 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
461 if (r < 0)
462 return r;
463 }
464
465 return sd_bus_reply_method_return(message, NULL);
466 }
467
468 int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
469 _cleanup_set_free_ Set *ns = NULL;
470 _cleanup_strv_free_ char **ntas = NULL;
471 Link *l = ASSERT_PTR(userdata);
472 int r;
473
474 assert(message);
475
476 r = verify_managed_link(l, error);
477 if (r < 0)
478 return r;
479
480 r = sd_bus_message_read_strv(message, &ntas);
481 if (r < 0)
482 return r;
483
484 STRV_FOREACH(i, ntas) {
485 r = dns_name_is_valid(*i);
486 if (r < 0)
487 return r;
488 if (r == 0)
489 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid negative trust anchor domain: %s", *i);
490 }
491
492 /* The method accepts an empty strv, to override the negative trust anchors set in .network.
493 * Hence, we need to explicitly allocate an empty set here. */
494 ns = set_new(&dns_name_hash_ops_free);
495 if (!ns)
496 return -ENOMEM;
497
498 STRV_FOREACH(i, ntas) {
499 r = set_put_strdup_full(&ns, &dns_name_hash_ops_free, *i);
500 if (r < 0)
501 return r;
502 }
503
504 r = bus_verify_polkit_async(
505 message,
506 "org.freedesktop.network1.set-dnssec-negative-trust-anchors",
507 (const char**) STRV_MAKE("interface", l->ifname),
508 &l->manager->polkit_registry,
509 error);
510 if (r < 0)
511 return r;
512 if (r == 0)
513 return 1; /* Polkit will call us back */
514
515 set_free_and_replace(l->dnssec_negative_trust_anchors, ns);
516
517 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
518 if (r < 0)
519 return r;
520
521 return sd_bus_reply_method_return(message, NULL);
522 }
523
524 int bus_link_method_revert_ntp(sd_bus_message *message, void *userdata, sd_bus_error *error) {
525 Link *l = ASSERT_PTR(userdata);
526 int r;
527
528 assert(message);
529
530 r = verify_managed_link(l, error);
531 if (r < 0)
532 return r;
533
534 r = bus_verify_polkit_async(
535 message,
536 "org.freedesktop.network1.revert-ntp",
537 (const char**) STRV_MAKE("interface", l->ifname),
538 &l->manager->polkit_registry, error);
539 if (r < 0)
540 return r;
541 if (r == 0)
542 return 1; /* Polkit will call us back */
543
544 link_ntp_settings_clear(l);
545
546 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
547 if (r < 0)
548 return r;
549
550 return sd_bus_reply_method_return(message, NULL);
551 }
552
553 int bus_link_method_revert_dns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
554 Link *l = ASSERT_PTR(userdata);
555 int r;
556
557 assert(message);
558
559 r = verify_managed_link(l, error);
560 if (r < 0)
561 return r;
562
563 r = bus_verify_polkit_async(
564 message,
565 "org.freedesktop.network1.revert-dns",
566 (const char**) STRV_MAKE("interface", l->ifname),
567 &l->manager->polkit_registry,
568 error);
569 if (r < 0)
570 return r;
571 if (r == 0)
572 return 1; /* Polkit will call us back */
573
574 link_dns_settings_clear(l);
575
576 r = link_save_and_clean_full(l, /* also_save_manager= */ true);
577 if (r < 0)
578 return r;
579
580 return sd_bus_reply_method_return(message, NULL);
581 }
582
583 int bus_link_method_force_renew(sd_bus_message *message, void *userdata, sd_bus_error *error) {
584 Link *l = ASSERT_PTR(userdata);
585 int r;
586
587 if (!l->network)
588 return sd_bus_error_setf(error, BUS_ERROR_UNMANAGED_INTERFACE,
589 "Interface %s is not managed by systemd-networkd",
590 l->ifname);
591
592 r = bus_verify_polkit_async(
593 message,
594 "org.freedesktop.network1.forcerenew",
595 (const char**) STRV_MAKE("interface", l->ifname),
596 &l->manager->polkit_registry,
597 error);
598 if (r < 0)
599 return r;
600 if (r == 0)
601 return 1; /* Polkit will call us back */
602
603 if (sd_dhcp_server_is_running(l->dhcp_server)) {
604 r = sd_dhcp_server_forcerenew(l->dhcp_server);
605 if (r < 0)
606 return r;
607 }
608
609 return sd_bus_reply_method_return(message, NULL);
610 }
611
612 int bus_link_method_renew(sd_bus_message *message, void *userdata, sd_bus_error *error) {
613 Link *l = ASSERT_PTR(userdata);
614 int r;
615
616 if (!l->network)
617 return sd_bus_error_setf(error, BUS_ERROR_UNMANAGED_INTERFACE,
618 "Interface %s is not managed by systemd-networkd",
619 l->ifname);
620
621 r = bus_verify_polkit_async(
622 message,
623 "org.freedesktop.network1.renew",
624 (const char**) STRV_MAKE("interface", l->ifname),
625 &l->manager->polkit_registry,
626 error);
627 if (r < 0)
628 return r;
629 if (r == 0)
630 return 1; /* Polkit will call us back */
631
632 r = dhcp4_renew(l);
633 if (r < 0)
634 return r;
635
636 return sd_bus_reply_method_return(message, NULL);
637 }
638
639 int bus_link_method_reconfigure(sd_bus_message *message, void *userdata, sd_bus_error *error) {
640 Link *l = ASSERT_PTR(userdata);
641 int r;
642
643 assert(message);
644
645 r = bus_verify_polkit_async(
646 message,
647 "org.freedesktop.network1.reconfigure",
648 (const char**) STRV_MAKE("interface", l->ifname),
649 &l->manager->polkit_registry,
650 error);
651 if (r < 0)
652 return r;
653 if (r == 0)
654 return 1; /* Polkit will call us back */
655
656 r = link_reconfigure_full(l, LINK_RECONFIGURE_UNCONDITIONALLY | LINK_RECONFIGURE_CLEANLY, message, /* varlink= */ NULL, /* counter= */ NULL);
657 if (r != 0)
658 return r; /* Will reply later when r > 0. */
659
660 return sd_bus_reply_method_return(message, NULL);
661 }
662
663 int bus_link_method_describe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
664 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
665 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
666 _cleanup_free_ char *text = NULL;
667 Link *link = ASSERT_PTR(userdata);
668 int r;
669
670 assert(message);
671
672 r = link_build_json(link, &v);
673 if (r < 0)
674 return log_link_error_errno(link, r, "Failed to build JSON data: %m");
675
676 r = sd_json_variant_format(v, 0, &text);
677 if (r < 0)
678 return log_link_error_errno(link, r, "Failed to format JSON data: %m");
679
680 r = sd_bus_message_new_method_return(message, &reply);
681 if (r < 0)
682 return r;
683
684 r = sd_bus_message_append(reply, "s", text);
685 if (r < 0)
686 return r;
687
688 return sd_bus_message_send(reply);
689 }
690
691 static const sd_bus_vtable link_vtable[] = {
692 SD_BUS_VTABLE_START(0),
693
694 SD_BUS_PROPERTY("OperationalState", "s", property_get_operational_state, offsetof(Link, operstate), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
695 SD_BUS_PROPERTY("CarrierState", "s", property_get_carrier_state, offsetof(Link, carrier_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
696 SD_BUS_PROPERTY("AddressState", "s", property_get_address_state, offsetof(Link, address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
697 SD_BUS_PROPERTY("IPv4AddressState", "s", property_get_address_state, offsetof(Link, ipv4_address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
698 SD_BUS_PROPERTY("IPv6AddressState", "s", property_get_address_state, offsetof(Link, ipv6_address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
699 SD_BUS_PROPERTY("OnlineState", "s", property_get_online_state, offsetof(Link, online_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
700 SD_BUS_PROPERTY("AdministrativeState", "s", property_get_administrative_state, offsetof(Link, state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
701 SD_BUS_PROPERTY("BitRates", "(tt)", property_get_bit_rates, 0, 0),
702
703 SD_BUS_METHOD_WITH_ARGS("SetNTP",
704 SD_BUS_ARGS("as", servers),
705 SD_BUS_NO_RESULT,
706 bus_link_method_set_ntp_servers,
707 SD_BUS_VTABLE_UNPRIVILEGED),
708 SD_BUS_METHOD_WITH_ARGS("SetDNS",
709 SD_BUS_ARGS("a(iay)", addresses),
710 SD_BUS_NO_RESULT,
711 bus_link_method_set_dns_servers,
712 SD_BUS_VTABLE_UNPRIVILEGED),
713 SD_BUS_METHOD_WITH_ARGS("SetDNSEx",
714 SD_BUS_ARGS("a(iayqs)", addresses),
715 SD_BUS_NO_RESULT,
716 bus_link_method_set_dns_servers_ex,
717 SD_BUS_VTABLE_UNPRIVILEGED),
718 SD_BUS_METHOD_WITH_ARGS("SetDomains",
719 SD_BUS_ARGS("a(sb)", domains),
720 SD_BUS_NO_RESULT,
721 bus_link_method_set_domains,
722 SD_BUS_VTABLE_UNPRIVILEGED),
723 SD_BUS_METHOD_WITH_ARGS("SetDefaultRoute",
724 SD_BUS_ARGS("b", enable),
725 SD_BUS_NO_RESULT,
726 bus_link_method_set_default_route,
727 SD_BUS_VTABLE_UNPRIVILEGED),
728 SD_BUS_METHOD_WITH_ARGS("SetLLMNR",
729 SD_BUS_ARGS("s", mode),
730 SD_BUS_NO_RESULT,
731 bus_link_method_set_llmnr,
732 SD_BUS_VTABLE_UNPRIVILEGED),
733 SD_BUS_METHOD_WITH_ARGS("SetMulticastDNS",
734 SD_BUS_ARGS("s", mode),
735 SD_BUS_NO_RESULT,
736 bus_link_method_set_mdns,
737 SD_BUS_VTABLE_UNPRIVILEGED),
738 SD_BUS_METHOD_WITH_ARGS("SetDNSOverTLS",
739 SD_BUS_ARGS("s", mode),
740 SD_BUS_NO_RESULT,
741 bus_link_method_set_dns_over_tls,
742 SD_BUS_VTABLE_UNPRIVILEGED),
743 SD_BUS_METHOD_WITH_ARGS("SetDNSSEC",
744 SD_BUS_ARGS("s", mode),
745 SD_BUS_NO_RESULT,
746 bus_link_method_set_dnssec,
747 SD_BUS_VTABLE_UNPRIVILEGED),
748 SD_BUS_METHOD_WITH_ARGS("SetDNSSECNegativeTrustAnchors",
749 SD_BUS_ARGS("as", names),
750 SD_BUS_NO_RESULT,
751 bus_link_method_set_dnssec_negative_trust_anchors,
752 SD_BUS_VTABLE_UNPRIVILEGED),
753 SD_BUS_METHOD_WITH_ARGS("RevertNTP",
754 SD_BUS_NO_ARGS,
755 SD_BUS_NO_RESULT,
756 bus_link_method_revert_ntp,
757 SD_BUS_VTABLE_UNPRIVILEGED),
758 SD_BUS_METHOD_WITH_ARGS("RevertDNS",
759 SD_BUS_NO_ARGS,
760 SD_BUS_NO_RESULT,
761 bus_link_method_revert_dns,
762 SD_BUS_VTABLE_UNPRIVILEGED),
763 SD_BUS_METHOD_WITH_ARGS("Renew",
764 SD_BUS_NO_ARGS,
765 SD_BUS_NO_RESULT,
766 bus_link_method_renew,
767 SD_BUS_VTABLE_UNPRIVILEGED),
768 SD_BUS_METHOD_WITH_ARGS("ForceRenew",
769 SD_BUS_NO_ARGS,
770 SD_BUS_NO_RESULT,
771 bus_link_method_force_renew,
772 SD_BUS_VTABLE_UNPRIVILEGED),
773 SD_BUS_METHOD_WITH_ARGS("Reconfigure",
774 SD_BUS_NO_ARGS,
775 SD_BUS_NO_RESULT,
776 bus_link_method_reconfigure,
777 SD_BUS_VTABLE_UNPRIVILEGED),
778 SD_BUS_METHOD_WITH_ARGS("Describe",
779 SD_BUS_NO_ARGS,
780 SD_BUS_RESULT("s", json),
781 bus_link_method_describe,
782 SD_BUS_VTABLE_UNPRIVILEGED),
783
784 SD_BUS_VTABLE_END
785 };
786
787 char* link_bus_path(Link *link) {
788 _cleanup_free_ char *ifindex = NULL;
789 char *p;
790 int r;
791
792 assert(link);
793 assert(link->ifindex > 0);
794
795 if (asprintf(&ifindex, "%d", link->ifindex) < 0)
796 return NULL;
797
798 r = sd_bus_path_encode("/org/freedesktop/network1/link", ifindex, &p);
799 if (r < 0)
800 return NULL;
801
802 return p;
803 }
804
805 int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
806 _cleanup_strv_free_ char **l = NULL;
807 Manager *m = ASSERT_PTR(userdata);
808 unsigned c = 0;
809 Link *link;
810
811 assert(bus);
812 assert(path);
813 assert(nodes);
814
815 l = new0(char*, hashmap_size(m->links_by_index) + 1);
816 if (!l)
817 return -ENOMEM;
818
819 HASHMAP_FOREACH(link, m->links_by_index) {
820 char *p;
821
822 p = link_bus_path(link);
823 if (!p)
824 return -ENOMEM;
825
826 l[c++] = p;
827 }
828
829 l[c] = NULL;
830 *nodes = TAKE_PTR(l);
831
832 return 1;
833 }
834
835 int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
836 _cleanup_free_ char *identifier = NULL;
837 Manager *m = ASSERT_PTR(userdata);
838 Link *link;
839 int ifindex, r;
840
841 assert(bus);
842 assert(path);
843 assert(interface);
844 assert(found);
845
846 r = sd_bus_path_decode(path, "/org/freedesktop/network1/link", &identifier);
847 if (r <= 0)
848 return 0;
849
850 ifindex = parse_ifindex(identifier);
851 if (ifindex < 0)
852 return 0;
853
854 r = link_get_by_index(m, ifindex, &link);
855 if (r < 0)
856 return 0;
857
858 if (streq(interface, "org.freedesktop.network1.DHCPServer") && !link->dhcp_server)
859 return 0;
860
861 if (streq(interface, "org.freedesktop.network1.DHCPv4Client") && !link->dhcp_client)
862 return 0;
863
864 if (streq(interface, "org.freedesktop.network1.DHCPv6Client") && !link->dhcp6_client)
865 return 0;
866
867 *found = link;
868
869 return 1;
870 }
871
872 int link_send_changed_strv(Link *link, char **properties) {
873 _cleanup_free_ char *p = NULL;
874
875 assert(link);
876 assert(link->manager);
877 assert(properties);
878
879 if (sd_bus_is_ready(link->manager->bus) <= 0)
880 return 0;
881
882 p = link_bus_path(link);
883 if (!p)
884 return -ENOMEM;
885
886 return sd_bus_emit_properties_changed_strv(
887 link->manager->bus,
888 p,
889 "org.freedesktop.network1.Link",
890 properties);
891 }
892
893 const BusObjectImplementation link_object = {
894 "/org/freedesktop/network1/link",
895 "org.freedesktop.network1.Link",
896 .fallback_vtables = BUS_FALLBACK_VTABLES({link_vtable, link_object_find}),
897 .node_enumerator = link_node_enumerator,
898 };