]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/bus-control.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bus: sync with kdbus.git
[thirdparty/systemd.git] / src / libsystemd / sd-bus / bus-control.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2013 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #ifdef HAVE_VALGRIND_MEMCHECK_H
23 #include <valgrind/memcheck.h>
24 #endif
25
26 #include <stddef.h>
27 #include <errno.h>
28
29 #include "strv.h"
30 #include "sd-bus.h"
31 #include "bus-internal.h"
32 #include "bus-message.h"
33 #include "bus-control.h"
34 #include "bus-bloom.h"
35 #include "bus-util.h"
36 #include "cgroup-util.h"
37
38 _public_ int sd_bus_get_unique_name(sd_bus *bus, const char **unique) {
39 int r;
40
41 assert_return(bus, -EINVAL);
42 assert_return(unique, -EINVAL);
43 assert_return(!bus_pid_changed(bus), -ECHILD);
44
45 r = bus_ensure_running(bus);
46 if (r < 0)
47 return r;
48
49 *unique = bus->unique_name;
50 return 0;
51 }
52
53 static int bus_request_name_kernel(sd_bus *bus, const char *name, uint64_t flags) {
54 struct kdbus_cmd_name *n;
55 size_t size, l;
56 int r;
57
58 assert(bus);
59 assert(name);
60
61 l = strlen(name) + 1;
62 size = offsetof(struct kdbus_cmd_name, items) + KDBUS_ITEM_SIZE(l);
63 n = alloca0_align(size, 8);
64 n->size = size;
65 n->flags = request_name_flags_to_kdbus(flags);
66
67 n->items[0].size = KDBUS_ITEM_HEADER_SIZE + l;
68 n->items[0].type = KDBUS_ITEM_NAME;
69 memcpy(n->items[0].str, name, l);
70
71 #ifdef HAVE_VALGRIND_MEMCHECK_H
72 VALGRIND_MAKE_MEM_DEFINED(n, n->size);
73 #endif
74
75 r = ioctl(bus->input_fd, KDBUS_CMD_NAME_ACQUIRE, n);
76 if (r < 0)
77 return -errno;
78
79 if (n->flags & KDBUS_NAME_IN_QUEUE)
80 return 0;
81
82 return 1;
83 }
84
85 static int bus_request_name_dbus1(sd_bus *bus, const char *name, uint64_t flags) {
86 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
87 uint32_t ret, param = 0;
88 int r;
89
90 assert(bus);
91 assert(name);
92
93 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
94 param |= BUS_NAME_ALLOW_REPLACEMENT;
95 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
96 param |= BUS_NAME_REPLACE_EXISTING;
97 if (!(flags & SD_BUS_NAME_QUEUE))
98 param |= BUS_NAME_DO_NOT_QUEUE;
99
100 r = sd_bus_call_method(
101 bus,
102 "org.freedesktop.DBus",
103 "/org/freedesktop/DBus",
104 "org.freedesktop.DBus",
105 "RequestName",
106 NULL,
107 &reply,
108 "su",
109 name,
110 param);
111 if (r < 0)
112 return r;
113
114 r = sd_bus_message_read(reply, "u", &ret);
115 if (r < 0)
116 return r;
117
118 if (ret == BUS_NAME_ALREADY_OWNER)
119 return -EALREADY;
120 else if (ret == BUS_NAME_EXISTS)
121 return -EEXIST;
122 else if (ret == BUS_NAME_IN_QUEUE)
123 return 0;
124 else if (ret == BUS_NAME_PRIMARY_OWNER)
125 return 1;
126
127 return -EIO;
128 }
129
130 _public_ int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) {
131 assert_return(bus, -EINVAL);
132 assert_return(name, -EINVAL);
133 assert_return(bus->bus_client, -EINVAL);
134 assert_return(!bus_pid_changed(bus), -ECHILD);
135 assert_return(!(flags & ~(SD_BUS_NAME_ALLOW_REPLACEMENT|SD_BUS_NAME_REPLACE_EXISTING|SD_BUS_NAME_QUEUE)), -EINVAL);
136 assert_return(service_name_is_valid(name), -EINVAL);
137 assert_return(name[0] != ':', -EINVAL);
138
139 if (!BUS_IS_OPEN(bus->state))
140 return -ENOTCONN;
141
142 if (bus->is_kernel)
143 return bus_request_name_kernel(bus, name, flags);
144 else
145 return bus_request_name_dbus1(bus, name, flags);
146 }
147
148 static int bus_release_name_kernel(sd_bus *bus, const char *name) {
149 struct kdbus_cmd_name *n;
150 size_t size, l;
151 int r;
152
153 assert(bus);
154 assert(name);
155
156 l = strlen(name) + 1;
157 size = offsetof(struct kdbus_cmd_name, items) + KDBUS_ITEM_SIZE(l);
158 n = alloca0_align(size, 8);
159 n->size = size;
160
161 n->items[0].size = KDBUS_ITEM_HEADER_SIZE + l;
162 n->items[0].type = KDBUS_ITEM_NAME;
163 memcpy(n->items[0].str, name, l);
164
165 #ifdef HAVE_VALGRIND_MEMCHECK_H
166 VALGRIND_MAKE_MEM_DEFINED(n, n->size);
167 #endif
168 r = ioctl(bus->input_fd, KDBUS_CMD_NAME_RELEASE, n);
169 if (r < 0)
170 return -errno;
171
172 return 0;
173 }
174
175 static int bus_release_name_dbus1(sd_bus *bus, const char *name) {
176 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
177 uint32_t ret;
178 int r;
179
180 assert(bus);
181 assert(name);
182
183 r = sd_bus_call_method(
184 bus,
185 "org.freedesktop.DBus",
186 "/org/freedesktop/DBus",
187 "org.freedesktop.DBus",
188 "ReleaseName",
189 NULL,
190 &reply,
191 "s",
192 name);
193 if (r < 0)
194 return r;
195
196 r = sd_bus_message_read(reply, "u", &ret);
197 if (r < 0)
198 return r;
199 if (ret == BUS_NAME_NON_EXISTENT)
200 return -ESRCH;
201 if (ret == BUS_NAME_NOT_OWNER)
202 return -EADDRINUSE;
203 if (ret == BUS_NAME_RELEASED)
204 return 0;
205
206 return -EINVAL;
207 }
208
209 _public_ int sd_bus_release_name(sd_bus *bus, const char *name) {
210 assert_return(bus, -EINVAL);
211 assert_return(name, -EINVAL);
212 assert_return(bus->bus_client, -EINVAL);
213 assert_return(!bus_pid_changed(bus), -ECHILD);
214 assert_return(service_name_is_valid(name), -EINVAL);
215 assert_return(name[0] != ':', -EINVAL);
216
217 if (!BUS_IS_OPEN(bus->state))
218 return -ENOTCONN;
219
220 if (bus->is_kernel)
221 return bus_release_name_kernel(bus, name);
222 else
223 return bus_release_name_dbus1(bus, name);
224 }
225
226 static int kernel_get_list(sd_bus *bus, uint64_t flags, char ***x) {
227 struct kdbus_cmd_name_list cmd = {};
228 struct kdbus_name_list *name_list;
229 struct kdbus_name_info *name;
230 uint64_t previous_id = 0;
231 int r;
232
233 /* Caller will free half-constructed list on failure... */
234
235 cmd.size = sizeof(cmd);
236 cmd.flags = flags;
237
238 r = ioctl(bus->input_fd, KDBUS_CMD_NAME_LIST, &cmd);
239 if (r < 0)
240 return -errno;
241
242 name_list = (struct kdbus_name_list *) ((uint8_t *) bus->kdbus_buffer + cmd.offset);
243
244 KDBUS_ITEM_FOREACH(name, name_list, names) {
245
246 struct kdbus_item *item;
247 const char *entry_name = NULL;
248
249 if ((flags & KDBUS_NAME_LIST_UNIQUE) && name->owner_id != previous_id) {
250 char *n;
251
252 if (asprintf(&n, ":1.%llu", (unsigned long long) name->owner_id) < 0) {
253 r = -ENOMEM;
254 goto fail;
255 }
256
257 r = strv_consume(x, n);
258 if (r < 0)
259 goto fail;
260
261 previous_id = name->owner_id;
262 }
263
264 KDBUS_ITEM_FOREACH(item, name, items)
265 if (item->type == KDBUS_ITEM_OWNED_NAME)
266 entry_name = item->name.name;
267
268 if (entry_name && service_name_is_valid(entry_name)) {
269 r = strv_extend(x, entry_name);
270 if (r < 0) {
271 r = -ENOMEM;
272 goto fail;
273 }
274 }
275 }
276
277 r = 0;
278
279 fail:
280 bus_kernel_cmd_free(bus, cmd.offset);
281 return r;
282 }
283
284 static int bus_list_names_kernel(sd_bus *bus, char ***acquired, char ***activatable) {
285 _cleanup_strv_free_ char **x = NULL, **y = NULL;
286 int r;
287
288 if (acquired) {
289 r = kernel_get_list(bus, KDBUS_NAME_LIST_UNIQUE | KDBUS_NAME_LIST_NAMES, &x);
290 if (r < 0)
291 return r;
292 }
293
294 if (activatable) {
295 r = kernel_get_list(bus, KDBUS_NAME_LIST_ACTIVATORS, &y);
296 if (r < 0)
297 return r;
298
299 *activatable = y;
300 y = NULL;
301 }
302
303 if (acquired) {
304 *acquired = x;
305 x = NULL;
306 }
307
308 return 0;
309 }
310
311 static int bus_list_names_dbus1(sd_bus *bus, char ***acquired, char ***activatable) {
312 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
313 _cleanup_strv_free_ char **x = NULL, **y = NULL;
314 int r;
315
316 if (acquired) {
317 r = sd_bus_call_method(
318 bus,
319 "org.freedesktop.DBus",
320 "/org/freedesktop/DBus",
321 "org.freedesktop.DBus",
322 "ListNames",
323 NULL,
324 &reply,
325 NULL);
326 if (r < 0)
327 return r;
328
329 r = sd_bus_message_read_strv(reply, &x);
330 if (r < 0)
331 return r;
332
333 reply = sd_bus_message_unref(reply);
334 }
335
336 if (activatable) {
337 r = sd_bus_call_method(
338 bus,
339 "org.freedesktop.DBus",
340 "/org/freedesktop/DBus",
341 "org.freedesktop.DBus",
342 "ListActivatableNames",
343 NULL,
344 &reply,
345 NULL);
346 if (r < 0)
347 return r;
348
349 r = sd_bus_message_read_strv(reply, &y);
350 if (r < 0)
351 return r;
352
353 *activatable = y;
354 y = NULL;
355 }
356
357 if (acquired) {
358 *acquired = x;
359 x = NULL;
360 }
361
362 return 0;
363 }
364
365 _public_ int sd_bus_list_names(sd_bus *bus, char ***acquired, char ***activatable) {
366 assert_return(bus, -EINVAL);
367 assert_return(acquired || activatable, -EINVAL);
368 assert_return(!bus_pid_changed(bus), -ECHILD);
369
370 if (!BUS_IS_OPEN(bus->state))
371 return -ENOTCONN;
372
373 if (bus->is_kernel)
374 return bus_list_names_kernel(bus, acquired, activatable);
375 else
376 return bus_list_names_dbus1(bus, acquired, activatable);
377 }
378
379 static int bus_populate_creds_from_items(
380 sd_bus *bus,
381 struct kdbus_info *info,
382 uint64_t mask,
383 sd_bus_creds *c) {
384
385 struct kdbus_item *item;
386 uint64_t m;
387 int r;
388
389 assert(bus);
390 assert(info);
391 assert(c);
392
393 KDBUS_ITEM_FOREACH(item, info, items) {
394
395 switch (item->type) {
396
397 case KDBUS_ITEM_PIDS:
398
399 if (mask & SD_BUS_CREDS_PID && item->pids.pid > 0) {
400 c->pid = (pid_t) item->pids.pid;
401 c->mask |= SD_BUS_CREDS_PID;
402 }
403
404 if (mask & SD_BUS_CREDS_TID && item->pids.tid > 0) {
405 c->tid = (pid_t) item->pids.tid;
406 c->mask |= SD_BUS_CREDS_TID;
407 }
408
409 break;
410
411 case KDBUS_ITEM_CREDS:
412
413 if (mask & SD_BUS_CREDS_UID && (uid_t) item->creds.uid != UID_INVALID) {
414 c->uid = (uid_t) item->creds.uid;
415 c->mask |= SD_BUS_CREDS_UID;
416 }
417
418 if (mask & SD_BUS_CREDS_EUID && (uid_t) item->creds.euid != UID_INVALID) {
419 c->euid = (uid_t) item->creds.euid;
420 c->mask |= SD_BUS_CREDS_EUID;
421 }
422
423 if (mask & SD_BUS_CREDS_SUID && (uid_t) item->creds.suid != UID_INVALID) {
424 c->suid = (uid_t) item->creds.suid;
425 c->mask |= SD_BUS_CREDS_SUID;
426 }
427
428 if (mask & SD_BUS_CREDS_FSUID && (uid_t) item->creds.fsuid != UID_INVALID) {
429 c->fsuid = (uid_t) item->creds.fsuid;
430 c->mask |= SD_BUS_CREDS_FSUID;
431 }
432
433 if (mask & SD_BUS_CREDS_GID && (gid_t) item->creds.gid != GID_INVALID) {
434 c->gid = (gid_t) item->creds.gid;
435 c->mask |= SD_BUS_CREDS_GID;
436 }
437
438 if (mask & SD_BUS_CREDS_EGID && (gid_t) item->creds.egid != GID_INVALID) {
439 c->egid = (gid_t) item->creds.egid;
440 c->mask |= SD_BUS_CREDS_EGID;
441 }
442
443 if (mask & SD_BUS_CREDS_SGID && (gid_t) item->creds.sgid != GID_INVALID) {
444 c->sgid = (gid_t) item->creds.sgid;
445 c->mask |= SD_BUS_CREDS_SGID;
446 }
447
448 if (mask & SD_BUS_CREDS_FSGID && (gid_t) item->creds.fsgid != GID_INVALID) {
449 c->fsgid = (gid_t) item->creds.fsgid;
450 c->mask |= SD_BUS_CREDS_FSGID;
451 }
452
453 break;
454
455 case KDBUS_ITEM_PID_COMM:
456 if (mask & SD_BUS_CREDS_COMM) {
457 r = free_and_strdup(&c->comm, item->str);
458 if (r < 0)
459 return r;
460
461 c->mask |= SD_BUS_CREDS_COMM;
462 }
463 break;
464
465 case KDBUS_ITEM_TID_COMM:
466 if (mask & SD_BUS_CREDS_TID_COMM) {
467 r = free_and_strdup(&c->tid_comm, item->str);
468 if (r < 0)
469 return r;
470
471 c->mask |= SD_BUS_CREDS_TID_COMM;
472 }
473 break;
474
475 case KDBUS_ITEM_EXE:
476 if (mask & SD_BUS_CREDS_EXE) {
477 r = free_and_strdup(&c->exe, item->str);
478 if (r < 0)
479 return r;
480
481 c->mask |= SD_BUS_CREDS_EXE;
482 }
483 break;
484
485 case KDBUS_ITEM_CMDLINE:
486 if (mask & SD_BUS_CREDS_CMDLINE) {
487 c->cmdline_size = item->size - offsetof(struct kdbus_item, data);
488 c->cmdline = memdup(item->data, c->cmdline_size);
489 if (!c->cmdline)
490 return -ENOMEM;
491
492 c->mask |= SD_BUS_CREDS_CMDLINE;
493 }
494 break;
495
496 case KDBUS_ITEM_CGROUP:
497 m = (SD_BUS_CREDS_CGROUP | SD_BUS_CREDS_UNIT |
498 SD_BUS_CREDS_USER_UNIT | SD_BUS_CREDS_SLICE |
499 SD_BUS_CREDS_SESSION | SD_BUS_CREDS_OWNER_UID) & mask;
500
501 if (m) {
502 r = free_and_strdup(&c->cgroup, item->str);
503 if (r < 0)
504 return r;
505
506 r = bus_get_root_path(bus);
507 if (r < 0)
508 return r;
509
510 r = free_and_strdup(&c->cgroup_root, bus->cgroup_root);
511 if (r < 0)
512 return r;
513
514 c->mask |= m;
515 }
516 break;
517
518 case KDBUS_ITEM_CAPS:
519 m = (SD_BUS_CREDS_EFFECTIVE_CAPS | SD_BUS_CREDS_PERMITTED_CAPS |
520 SD_BUS_CREDS_INHERITABLE_CAPS | SD_BUS_CREDS_BOUNDING_CAPS) & mask;
521
522 if (m) {
523 c->capability_size = item->size - offsetof(struct kdbus_item, caps.caps);
524 c->capability = memdup(item->caps.caps, c->capability_size);
525 if (!c->capability)
526 return -ENOMEM;
527
528 c->mask |= m;
529 }
530 break;
531
532 case KDBUS_ITEM_SECLABEL:
533 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT) {
534 r = free_and_strdup(&c->label, item->str);
535 if (r < 0)
536 return r;
537
538 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
539 }
540 break;
541
542 case KDBUS_ITEM_AUDIT:
543 if (mask & SD_BUS_CREDS_AUDIT_SESSION_ID && (uint32_t) item->audit.sessionid != (uint32_t) -1) {
544 c->audit_session_id = (uint32_t) item->audit.sessionid;
545 c->mask |= SD_BUS_CREDS_AUDIT_SESSION_ID;
546 }
547
548 if (mask & SD_BUS_CREDS_AUDIT_LOGIN_UID && (uid_t) item->audit.loginuid != UID_INVALID) {
549 c->audit_login_uid = (uid_t) item->audit.loginuid;
550 c->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
551 }
552 break;
553
554 case KDBUS_ITEM_OWNED_NAME:
555 if ((mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) && service_name_is_valid(item->name.name)) {
556 r = strv_extend(&c->well_known_names, item->name.name);
557 if (r < 0)
558 return r;
559
560 c->mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
561 }
562 break;
563
564 case KDBUS_ITEM_CONN_DESCRIPTION:
565 if (mask & SD_BUS_CREDS_DESCRIPTION) {
566 r = free_and_strdup(&c->description, item->str);
567 if (r < 0)
568 return r;
569
570 c->mask |= SD_BUS_CREDS_DESCRIPTION;
571 }
572 break;
573
574 case KDBUS_ITEM_AUXGROUPS:
575 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
576 size_t n;
577 uid_t *g;
578
579 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
580
581 n = (item->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
582 g = newdup(gid_t, item->data32, n);
583 if (!g)
584 return -ENOMEM;
585
586 free(c->supplementary_gids);
587 c->supplementary_gids = g;
588 c->n_supplementary_gids = n;
589
590 c->mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
591 }
592 break;
593 }
594 }
595
596 return 0;
597 }
598
599 int bus_get_name_creds_kdbus(
600 sd_bus *bus,
601 const char *name,
602 uint64_t mask,
603 bool allow_activator,
604 sd_bus_creds **creds) {
605
606 _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
607 struct kdbus_cmd_info *cmd;
608 struct kdbus_info *conn_info;
609 size_t size, l;
610 uint64_t id;
611 int r;
612
613 r = bus_kernel_parse_unique_name(name, &id);
614 if (r < 0)
615 return r;
616 if (r > 0) {
617 size = offsetof(struct kdbus_cmd_info, items);
618 cmd = alloca0_align(size, 8);
619 cmd->id = id;
620 } else {
621 l = strlen(name) + 1;
622 size = offsetof(struct kdbus_cmd_info, items) + KDBUS_ITEM_SIZE(l);
623 cmd = alloca0_align(size, 8);
624 cmd->items[0].size = KDBUS_ITEM_HEADER_SIZE + l;
625 cmd->items[0].type = KDBUS_ITEM_NAME;
626 memcpy(cmd->items[0].str, name, l);
627 }
628
629 cmd->size = size;
630 cmd->flags = attach_flags_to_kdbus(mask);
631
632 /* If augmentation is on, and the bus doesn't didn't allow us
633 * to get the bits we want, then ask for the PID/TID so that we
634 * can read the rest from /proc. */
635 if ((mask & SD_BUS_CREDS_AUGMENT) &&
636 (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
637 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID|
638 SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM|SD_BUS_CREDS_EXE|SD_BUS_CREDS_CMDLINE|
639 SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID|
640 SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS|
641 SD_BUS_CREDS_SELINUX_CONTEXT|
642 SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID)))
643 cmd->flags |= KDBUS_ATTACH_PIDS;
644
645 r = ioctl(bus->input_fd, KDBUS_CMD_CONN_INFO, cmd);
646 if (r < 0)
647 return -errno;
648
649 conn_info = (struct kdbus_info *) ((uint8_t *) bus->kdbus_buffer + cmd->offset);
650
651 /* Non-activated names are considered not available */
652 if (!allow_activator && (conn_info->flags & KDBUS_HELLO_ACTIVATOR)) {
653 if (name[0] == ':')
654 r = -ENXIO;
655 else
656 r = -ESRCH;
657 goto fail;
658 }
659
660 c = bus_creds_new();
661 if (!c) {
662 r = -ENOMEM;
663 goto fail;
664 }
665
666 if (mask & SD_BUS_CREDS_UNIQUE_NAME) {
667 if (asprintf(&c->unique_name, ":1.%llu", (unsigned long long) conn_info->id) < 0) {
668 r = -ENOMEM;
669 goto fail;
670 }
671
672 c->mask |= SD_BUS_CREDS_UNIQUE_NAME;
673 }
674
675 /* If KDBUS_ITEM_OWNED_NAME is requested then we'll get 0 of
676 them in case the service has no names. This does not mean
677 however that the list of owned names could not be
678 acquired. Hence, let's explicitly clarify that the data is
679 complete. */
680 c->mask |= mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
681
682 r = bus_populate_creds_from_items(bus, conn_info, mask, c);
683 if (r < 0)
684 goto fail;
685
686 r = bus_creds_add_more(c, mask, 0, 0);
687 if (r < 0)
688 goto fail;
689
690 if (creds) {
691 *creds = c;
692 c = NULL;
693 }
694
695 r = 0;
696
697 fail:
698 bus_kernel_cmd_free(bus, cmd->offset);
699 return r;
700 }
701
702 static int bus_get_name_creds_dbus1(
703 sd_bus *bus,
704 const char *name,
705 uint64_t mask,
706 sd_bus_creds **creds) {
707
708 _cleanup_bus_message_unref_ sd_bus_message *reply_unique = NULL, *reply = NULL;
709 _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
710 const char *unique = NULL;
711 pid_t pid = 0;
712 int r;
713
714 /* Only query the owner if the caller wants to know it or if
715 * the caller just wants to check whether a name exists */
716 if ((mask & SD_BUS_CREDS_UNIQUE_NAME) || mask == 0) {
717 r = sd_bus_call_method(
718 bus,
719 "org.freedesktop.DBus",
720 "/org/freedesktop/DBus",
721 "org.freedesktop.DBus",
722 "GetNameOwner",
723 NULL,
724 &reply_unique,
725 "s",
726 name);
727 if (r < 0)
728 return r;
729
730 r = sd_bus_message_read(reply_unique, "s", &unique);
731 if (r < 0)
732 return r;
733 }
734
735 if (mask != 0) {
736 c = bus_creds_new();
737 if (!c)
738 return -ENOMEM;
739
740 if ((mask & SD_BUS_CREDS_UNIQUE_NAME) && unique) {
741 c->unique_name = strdup(unique);
742 if (!c->unique_name)
743 return -ENOMEM;
744
745 c->mask |= SD_BUS_CREDS_UNIQUE_NAME;
746 }
747
748 if ((mask & SD_BUS_CREDS_PID) ||
749 ((mask & SD_BUS_CREDS_AUGMENT) &&
750 (mask & (SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
751 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID|
752 SD_BUS_CREDS_COMM|SD_BUS_CREDS_EXE|SD_BUS_CREDS_CMDLINE|
753 SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID|
754 SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS|
755 SD_BUS_CREDS_SELINUX_CONTEXT|
756 SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID)))) {
757
758 uint32_t u;
759
760 r = sd_bus_call_method(
761 bus,
762 "org.freedesktop.DBus",
763 "/org/freedesktop/DBus",
764 "org.freedesktop.DBus",
765 "GetConnectionUnixProcessID",
766 NULL,
767 &reply,
768 "s",
769 unique ? unique : name);
770 if (r < 0)
771 return r;
772
773 r = sd_bus_message_read(reply, "u", &u);
774 if (r < 0)
775 return r;
776
777 pid = u;
778 if (mask & SD_BUS_CREDS_PID) {
779 c->pid = u;
780 c->mask |= SD_BUS_CREDS_PID;
781 }
782
783 reply = sd_bus_message_unref(reply);
784 }
785
786 if (mask & SD_BUS_CREDS_UID) {
787 uint32_t u;
788
789 r = sd_bus_call_method(
790 bus,
791 "org.freedesktop.DBus",
792 "/org/freedesktop/DBus",
793 "org.freedesktop.DBus",
794 "GetConnectionUnixUser",
795 NULL,
796 &reply,
797 "s",
798 unique ? unique : name);
799 if (r < 0)
800 return r;
801
802 r = sd_bus_message_read(reply, "u", &u);
803 if (r < 0)
804 return r;
805
806 c->uid = u;
807 c->mask |= SD_BUS_CREDS_UID;
808
809 reply = sd_bus_message_unref(reply);
810 }
811
812 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT) {
813 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
814 const void *p = NULL;
815 size_t sz = 0;
816
817 r = sd_bus_call_method(
818 bus,
819 "org.freedesktop.DBus",
820 "/org/freedesktop/DBus",
821 "org.freedesktop.DBus",
822 "GetConnectionSELinuxSecurityContext",
823 &error,
824 &reply,
825 "s",
826 unique ? unique : name);
827 if (r < 0) {
828 if (!sd_bus_error_has_name(&error, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown"))
829 return r;
830 } else {
831 r = sd_bus_message_read_array(reply, 'y', &p, &sz);
832 if (r < 0)
833 return r;
834
835 c->label = strndup(p, sz);
836 if (!c->label)
837 return -ENOMEM;
838
839 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
840 }
841 }
842
843 r = bus_creds_add_more(c, mask, pid, 0);
844 if (r < 0)
845 return r;
846 }
847
848 if (creds) {
849 *creds = c;
850 c = NULL;
851 }
852
853 return 0;
854 }
855
856 _public_ int sd_bus_get_name_creds(
857 sd_bus *bus,
858 const char *name,
859 uint64_t mask,
860 sd_bus_creds **creds) {
861
862 assert_return(bus, -EINVAL);
863 assert_return(name, -EINVAL);
864 assert_return((mask & ~SD_BUS_CREDS_AUGMENT) <= _SD_BUS_CREDS_ALL, -ENOTSUP);
865 assert_return(mask == 0 || creds, -EINVAL);
866 assert_return(!bus_pid_changed(bus), -ECHILD);
867 assert_return(service_name_is_valid(name), -EINVAL);
868 assert_return(bus->bus_client, -ENODATA);
869
870 if (!BUS_IS_OPEN(bus->state))
871 return -ENOTCONN;
872
873 if (bus->is_kernel)
874 return bus_get_name_creds_kdbus(bus, name, mask, false, creds);
875 else
876 return bus_get_name_creds_dbus1(bus, name, mask, creds);
877 }
878
879 static int bus_get_owner_creds_kdbus(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
880 _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
881 struct kdbus_cmd_info cmd = {
882 .size = sizeof(struct kdbus_cmd_info)
883 };
884 struct kdbus_info *creator_info;
885 pid_t pid = 0;
886 int r;
887
888 c = bus_creds_new();
889 if (!c)
890 return -ENOMEM;
891
892 cmd.flags = attach_flags_to_kdbus(mask);
893
894 /* If augmentation is on, and the bus doesn't didn't allow us
895 * to get the bits we want, then ask for the PID/TID so that we
896 * can read the rest from /proc. */
897 if ((mask & SD_BUS_CREDS_AUGMENT) &&
898 (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
899 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID|
900 SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM|SD_BUS_CREDS_EXE|SD_BUS_CREDS_CMDLINE|
901 SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID|
902 SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS|
903 SD_BUS_CREDS_SELINUX_CONTEXT|
904 SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID)))
905 cmd.flags |= KDBUS_ATTACH_PIDS;
906
907 r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
908 if (r < 0)
909 return -errno;
910
911 creator_info = (struct kdbus_info *) ((uint8_t *) bus->kdbus_buffer + cmd.offset);
912
913 r = bus_populate_creds_from_items(bus, creator_info, mask, c);
914 bus_kernel_cmd_free(bus, cmd.offset);
915 if (r < 0)
916 return r;
917
918 r = bus_creds_add_more(c, mask, pid, 0);
919 if (r < 0)
920 return r;
921
922 *ret = c;
923 c = NULL;
924 return 0;
925 }
926
927 static int bus_get_owner_creds_dbus1(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
928 _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
929 pid_t pid = 0;
930 int r;
931
932 if (!bus->ucred_valid && !isempty(bus->label))
933 return -ENODATA;
934
935 c = bus_creds_new();
936 if (!c)
937 return -ENOMEM;
938
939 if (bus->ucred_valid) {
940 if (bus->ucred.pid > 0) {
941 pid = c->pid = bus->ucred.pid;
942 c->mask |= SD_BUS_CREDS_PID & mask;
943 }
944
945 if (bus->ucred.uid != UID_INVALID) {
946 c->uid = bus->ucred.uid;
947 c->mask |= SD_BUS_CREDS_UID & mask;
948 }
949
950 if (bus->ucred.gid != GID_INVALID) {
951 c->gid = bus->ucred.gid;
952 c->mask |= SD_BUS_CREDS_GID & mask;
953 }
954 }
955
956 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
957 c->label = strdup(bus->label);
958 if (!c->label)
959 return -ENOMEM;
960
961 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
962 }
963
964 r = bus_creds_add_more(c, mask, pid, 0);
965 if (r < 0)
966 return r;
967
968 *ret = c;
969 c = NULL;
970 return 0;
971 }
972
973 _public_ int sd_bus_get_owner_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
974 assert_return(bus, -EINVAL);
975 assert_return((mask & ~SD_BUS_CREDS_AUGMENT) <= _SD_BUS_CREDS_ALL, -ENOTSUP);
976 assert_return(ret, -EINVAL);
977 assert_return(!bus_pid_changed(bus), -ECHILD);
978
979 if (!BUS_IS_OPEN(bus->state))
980 return -ENOTCONN;
981
982 if (bus->is_kernel)
983 return bus_get_owner_creds_kdbus(bus, mask, ret);
984 else
985 return bus_get_owner_creds_dbus1(bus, mask, ret);
986 }
987
988 static int add_name_change_match(sd_bus *bus,
989 uint64_t cookie,
990 const char *name,
991 const char *old_owner,
992 const char *new_owner) {
993
994 uint64_t name_id = KDBUS_MATCH_ID_ANY, old_owner_id = 0, new_owner_id = 0;
995 int is_name_id = -1, r;
996 struct kdbus_item *item;
997
998 assert(bus);
999
1000 /* If we encounter a match that could match against
1001 * NameOwnerChanged messages, then we need to create
1002 * KDBUS_ITEM_NAME_{ADD,REMOVE,CHANGE} and
1003 * KDBUS_ITEM_ID_{ADD,REMOVE} matches for it, possibly
1004 * multiple if the match is underspecified.
1005 *
1006 * The NameOwnerChanged signals take three parameters with
1007 * unique or well-known names, but only some forms actually
1008 * exist:
1009 *
1010 * WELLKNOWN, "", UNIQUE → KDBUS_ITEM_NAME_ADD
1011 * WELLKNOWN, UNIQUE, "" → KDBUS_ITEM_NAME_REMOVE
1012 * WELLKNOWN, UNIQUE, UNIQUE → KDBUS_ITEM_NAME_CHANGE
1013 * UNIQUE, "", UNIQUE → KDBUS_ITEM_ID_ADD
1014 * UNIQUE, UNIQUE, "" → KDBUS_ITEM_ID_REMOVE
1015 *
1016 * For the latter two the two unique names must be identical.
1017 *
1018 * */
1019
1020 if (name) {
1021 is_name_id = bus_kernel_parse_unique_name(name, &name_id);
1022 if (is_name_id < 0)
1023 return 0;
1024 }
1025
1026 if (!isempty(old_owner)) {
1027 r = bus_kernel_parse_unique_name(old_owner, &old_owner_id);
1028 if (r < 0)
1029 return 0;
1030 if (r == 0)
1031 return 0;
1032 if (is_name_id > 0 && old_owner_id != name_id)
1033 return 0;
1034 } else
1035 old_owner_id = KDBUS_MATCH_ID_ANY;
1036
1037 if (!isempty(new_owner)) {
1038 r = bus_kernel_parse_unique_name(new_owner, &new_owner_id);
1039 if (r < 0)
1040 return r;
1041 if (r == 0)
1042 return 0;
1043 if (is_name_id > 0 && new_owner_id != name_id)
1044 return 0;
1045 } else
1046 new_owner_id = KDBUS_MATCH_ID_ANY;
1047
1048 if (is_name_id <= 0) {
1049 struct kdbus_cmd_match *m;
1050 size_t sz, l;
1051
1052 /* If the name argument is missing or is a well-known
1053 * name, then add KDBUS_ITEM_NAME_{ADD,REMOVE,CHANGE}
1054 * matches for it */
1055
1056 l = name ? strlen(name) + 1 : 0;
1057
1058 sz = ALIGN8(offsetof(struct kdbus_cmd_match, items) +
1059 offsetof(struct kdbus_item, name_change) +
1060 offsetof(struct kdbus_notify_name_change, name) +
1061 l);
1062
1063 m = alloca0_align(sz, 8);
1064 m->size = sz;
1065 m->cookie = cookie;
1066
1067 item = m->items;
1068 item->size =
1069 offsetof(struct kdbus_item, name_change) +
1070 offsetof(struct kdbus_notify_name_change, name) +
1071 l;
1072
1073 item->name_change.old_id.id = old_owner_id;
1074 item->name_change.new_id.id = new_owner_id;
1075
1076 if (name)
1077 memcpy(item->name_change.name, name, l);
1078
1079 /* If the old name is unset or empty, then
1080 * this can match against added names */
1081 if (!old_owner || old_owner[0] == 0) {
1082 item->type = KDBUS_ITEM_NAME_ADD;
1083
1084 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
1085 if (r < 0)
1086 return -errno;
1087 }
1088
1089 /* If the new name is unset or empty, then
1090 * this can match against removed names */
1091 if (!new_owner || new_owner[0] == 0) {
1092 item->type = KDBUS_ITEM_NAME_REMOVE;
1093
1094 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
1095 if (r < 0)
1096 return -errno;
1097 }
1098
1099 /* The CHANGE match we need in either case, because
1100 * what is reported as a name change by the kernel
1101 * might just be an owner change between starter and
1102 * normal clients. For userspace such a change should
1103 * be considered a removal/addition, hence let's
1104 * subscribe to this unconditionally. */
1105 item->type = KDBUS_ITEM_NAME_CHANGE;
1106 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
1107 if (r < 0)
1108 return -errno;
1109 }
1110
1111 if (is_name_id != 0) {
1112 struct kdbus_cmd_match *m;
1113 uint64_t sz;
1114
1115 /* If the name argument is missing or is a unique
1116 * name, then add KDBUS_ITEM_ID_{ADD,REMOVE} matches
1117 * for it */
1118
1119 sz = ALIGN8(offsetof(struct kdbus_cmd_match, items) +
1120 offsetof(struct kdbus_item, id_change) +
1121 sizeof(struct kdbus_notify_id_change));
1122
1123 m = alloca0_align(sz, 8);
1124 m->size = sz;
1125 m->cookie = cookie;
1126
1127 item = m->items;
1128 item->size =
1129 offsetof(struct kdbus_item, id_change) +
1130 sizeof(struct kdbus_notify_id_change);
1131 item->id_change.id = name_id;
1132
1133 /* If the old name is unset or empty, then this can
1134 * match against added ids */
1135 if (!old_owner || old_owner[0] == 0) {
1136 item->type = KDBUS_ITEM_ID_ADD;
1137
1138 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
1139 if (r < 0)
1140 return -errno;
1141 }
1142
1143 /* If thew new name is unset or empty, then this can
1144 * match against removed ids */
1145 if (!new_owner || new_owner[0] == 0) {
1146 item->type = KDBUS_ITEM_ID_REMOVE;
1147
1148 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
1149 if (r < 0)
1150 return -errno;
1151 }
1152 }
1153
1154 return 0;
1155 }
1156
1157 int bus_add_match_internal_kernel(
1158 sd_bus *bus,
1159 struct bus_match_component *components,
1160 unsigned n_components,
1161 uint64_t cookie) {
1162
1163 struct kdbus_cmd_match *m;
1164 struct kdbus_item *item;
1165 uint64_t *bloom;
1166 size_t sz;
1167 const char *sender = NULL;
1168 size_t sender_length = 0;
1169 uint64_t src_id = KDBUS_MATCH_ID_ANY;
1170 bool using_bloom = false;
1171 unsigned i;
1172 bool matches_name_change = true;
1173 const char *name_change_arg[3] = {};
1174 int r;
1175
1176 assert(bus);
1177
1178 /* Monitor streams don't support matches, make this a NOP */
1179 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1180 return 0;
1181
1182 bloom = alloca0(bus->bloom_size);
1183
1184 sz = ALIGN8(offsetof(struct kdbus_cmd_match, items));
1185
1186 for (i = 0; i < n_components; i++) {
1187 struct bus_match_component *c = &components[i];
1188
1189 switch (c->type) {
1190
1191 case BUS_MATCH_SENDER:
1192 if (!streq(c->value_str, "org.freedesktop.DBus"))
1193 matches_name_change = false;
1194
1195 r = bus_kernel_parse_unique_name(c->value_str, &src_id);
1196 if (r < 0)
1197 return r;
1198 else if (r > 0)
1199 sz += ALIGN8(offsetof(struct kdbus_item, id) + sizeof(uint64_t));
1200 else {
1201 sender = c->value_str;
1202 sender_length = strlen(sender);
1203 sz += ALIGN8(offsetof(struct kdbus_item, str) + sender_length + 1);
1204 }
1205
1206 break;
1207
1208 case BUS_MATCH_MESSAGE_TYPE:
1209 if (c->value_u8 != SD_BUS_MESSAGE_SIGNAL)
1210 matches_name_change = false;
1211
1212 bloom_add_pair(bloom, bus->bloom_size, bus->bloom_n_hash, "message-type", bus_message_type_to_string(c->value_u8));
1213 using_bloom = true;
1214 break;
1215
1216 case BUS_MATCH_INTERFACE:
1217 if (!streq(c->value_str, "org.freedesktop.DBus"))
1218 matches_name_change = false;
1219
1220 bloom_add_pair(bloom, bus->bloom_size, bus->bloom_n_hash, "interface", c->value_str);
1221 using_bloom = true;
1222 break;
1223
1224 case BUS_MATCH_MEMBER:
1225 if (!streq(c->value_str, "NameOwnerChanged"))
1226 matches_name_change = false;
1227
1228 bloom_add_pair(bloom, bus->bloom_size, bus->bloom_n_hash, "member", c->value_str);
1229 using_bloom = true;
1230 break;
1231
1232 case BUS_MATCH_PATH:
1233 if (!streq(c->value_str, "/org/freedesktop/DBus"))
1234 matches_name_change = false;
1235
1236 bloom_add_pair(bloom, bus->bloom_size, bus->bloom_n_hash, "path", c->value_str);
1237 using_bloom = true;
1238 break;
1239
1240 case BUS_MATCH_PATH_NAMESPACE:
1241 if (!streq(c->value_str, "/")) {
1242 bloom_add_pair(bloom, bus->bloom_size, bus->bloom_n_hash, "path-slash-prefix", c->value_str);
1243 using_bloom = true;
1244 }
1245 break;
1246
1247 case BUS_MATCH_ARG...BUS_MATCH_ARG_LAST: {
1248 char buf[sizeof("arg")-1 + 2 + 1];
1249
1250 if (c->type - BUS_MATCH_ARG < 3)
1251 name_change_arg[c->type - BUS_MATCH_ARG] = c->value_str;
1252
1253 snprintf(buf, sizeof(buf), "arg%u", c->type - BUS_MATCH_ARG);
1254 bloom_add_pair(bloom, bus->bloom_size, bus->bloom_n_hash, buf, c->value_str);
1255 using_bloom = true;
1256 break;
1257 }
1258
1259 case BUS_MATCH_ARG_PATH...BUS_MATCH_ARG_PATH_LAST: {
1260 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
1261
1262 snprintf(buf, sizeof(buf), "arg%u-slash-prefix", c->type - BUS_MATCH_ARG_PATH);
1263 bloom_add_pair(bloom, bus->bloom_size, bus->bloom_n_hash, buf, c->value_str);
1264 using_bloom = true;
1265 break;
1266 }
1267
1268 case BUS_MATCH_ARG_NAMESPACE...BUS_MATCH_ARG_NAMESPACE_LAST: {
1269 char buf[sizeof("arg")-1 + 2 + sizeof("-dot-prefix")];
1270
1271 snprintf(buf, sizeof(buf), "arg%u-dot-prefix", c->type - BUS_MATCH_ARG_NAMESPACE);
1272 bloom_add_pair(bloom, bus->bloom_size, bus->bloom_n_hash, buf, c->value_str);
1273 using_bloom = true;
1274 break;
1275 }
1276
1277 case BUS_MATCH_DESTINATION:
1278 /* The bloom filter does not include
1279 the destination, since it is only
1280 available for broadcast messages
1281 which do not carry a destination
1282 since they are undirected. */
1283 break;
1284
1285 case BUS_MATCH_ROOT:
1286 case BUS_MATCH_VALUE:
1287 case BUS_MATCH_LEAF:
1288 case _BUS_MATCH_NODE_TYPE_MAX:
1289 case _BUS_MATCH_NODE_TYPE_INVALID:
1290 assert_not_reached("Invalid match type?");
1291 }
1292 }
1293
1294 if (using_bloom)
1295 sz += ALIGN8(offsetof(struct kdbus_item, data64) + bus->bloom_size);
1296
1297 m = alloca0_align(sz, 8);
1298 m->size = sz;
1299 m->cookie = cookie;
1300
1301 item = m->items;
1302
1303 if (src_id != KDBUS_MATCH_ID_ANY) {
1304 item->size = offsetof(struct kdbus_item, id) + sizeof(uint64_t);
1305 item->type = KDBUS_ITEM_ID;
1306 item->id = src_id;
1307 item = KDBUS_ITEM_NEXT(item);
1308 }
1309
1310 if (using_bloom) {
1311 item->size = offsetof(struct kdbus_item, data64) + bus->bloom_size;
1312 item->type = KDBUS_ITEM_BLOOM_MASK;
1313 memcpy(item->data64, bloom, bus->bloom_size);
1314 item = KDBUS_ITEM_NEXT(item);
1315 }
1316
1317 if (sender) {
1318 item->size = offsetof(struct kdbus_item, str) + sender_length + 1;
1319 item->type = KDBUS_ITEM_NAME;
1320 memcpy(item->str, sender, sender_length + 1);
1321 }
1322
1323 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
1324 if (r < 0)
1325 return -errno;
1326
1327 if (matches_name_change) {
1328
1329 /* If this match could theoretically match
1330 * NameOwnerChanged messages, we need to
1331 * install a second non-bloom filter explitly
1332 * for it */
1333
1334 r = add_name_change_match(bus, cookie, name_change_arg[0], name_change_arg[1], name_change_arg[2]);
1335 if (r < 0)
1336 return r;
1337 }
1338
1339 return 0;
1340 }
1341
1342 #define internal_match(bus, m) \
1343 ((bus)->hello_flags & KDBUS_HELLO_MONITOR \
1344 ? (isempty(m) ? "eavesdrop='true'" : strappenda((m), ",eavesdrop='true'")) \
1345 : (m))
1346
1347 static int bus_add_match_internal_dbus1(
1348 sd_bus *bus,
1349 const char *match) {
1350
1351 const char *e;
1352
1353 assert(bus);
1354 assert(match);
1355
1356 e = internal_match(bus, match);
1357
1358 return sd_bus_call_method(
1359 bus,
1360 "org.freedesktop.DBus",
1361 "/org/freedesktop/DBus",
1362 "org.freedesktop.DBus",
1363 "AddMatch",
1364 NULL,
1365 NULL,
1366 "s",
1367 e);
1368 }
1369
1370 int bus_add_match_internal(
1371 sd_bus *bus,
1372 const char *match,
1373 struct bus_match_component *components,
1374 unsigned n_components,
1375 uint64_t cookie) {
1376
1377 assert(bus);
1378
1379 if (bus->is_kernel)
1380 return bus_add_match_internal_kernel(bus, components, n_components, cookie);
1381 else
1382 return bus_add_match_internal_dbus1(bus, match);
1383 }
1384
1385 int bus_remove_match_internal_kernel(
1386 sd_bus *bus,
1387 uint64_t cookie) {
1388
1389 struct kdbus_cmd_match m;
1390 int r;
1391
1392 assert(bus);
1393
1394 /* Monitor streams don't support matches, make this a NOP */
1395 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1396 return 0;
1397
1398 zero(m);
1399 m.size = offsetof(struct kdbus_cmd_match, items);
1400 m.cookie = cookie;
1401
1402 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_REMOVE, &m);
1403 if (r < 0)
1404 return -errno;
1405
1406 return 0;
1407 }
1408
1409 static int bus_remove_match_internal_dbus1(
1410 sd_bus *bus,
1411 const char *match) {
1412
1413 const char *e;
1414
1415 assert(bus);
1416 assert(match);
1417
1418 e = internal_match(bus, match);
1419
1420 return sd_bus_call_method(
1421 bus,
1422 "org.freedesktop.DBus",
1423 "/org/freedesktop/DBus",
1424 "org.freedesktop.DBus",
1425 "RemoveMatch",
1426 NULL,
1427 NULL,
1428 "s",
1429 e);
1430 }
1431
1432 int bus_remove_match_internal(
1433 sd_bus *bus,
1434 const char *match,
1435 uint64_t cookie) {
1436
1437 assert(bus);
1438
1439 if (bus->is_kernel)
1440 return bus_remove_match_internal_kernel(bus, cookie);
1441 else
1442 return bus_remove_match_internal_dbus1(bus, match);
1443 }
1444
1445 _public_ int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_t *machine) {
1446 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL, *m = NULL;
1447 const char *mid;
1448 int r;
1449
1450 assert_return(bus, -EINVAL);
1451 assert_return(name, -EINVAL);
1452 assert_return(machine, -EINVAL);
1453 assert_return(!bus_pid_changed(bus), -ECHILD);
1454 assert_return(service_name_is_valid(name), -EINVAL);
1455
1456 if (!BUS_IS_OPEN(bus->state))
1457 return -ENOTCONN;
1458
1459 if (streq_ptr(name, bus->unique_name))
1460 return sd_id128_get_machine(machine);
1461
1462 r = sd_bus_message_new_method_call(
1463 bus,
1464 &m,
1465 name,
1466 "/",
1467 "org.freedesktop.DBus.Peer",
1468 "GetMachineId");
1469 if (r < 0)
1470 return r;
1471
1472 r = sd_bus_message_set_auto_start(m, false);
1473 if (r < 0)
1474 return r;
1475
1476 r = sd_bus_call(bus, m, 0, NULL, &reply);
1477 if (r < 0)
1478 return r;
1479
1480 r = sd_bus_message_read(reply, "s", &mid);
1481 if (r < 0)
1482 return r;
1483
1484 return sd_id128_from_string(mid, machine);
1485 }
Unnamed repository; edit this file 'description' to name the repository.