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