1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
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.
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.
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/>.
22 #ifdef HAVE_VALGRIND_MEMCHECK_H
23 #include <valgrind/memcheck.h>
32 #include "bus-internal.h"
33 #include "bus-message.h"
34 #include "bus-control.h"
35 #include "bus-bloom.h"
38 _public_ int sd_bus_get_unique_name(sd_bus *bus, const char **unique) {
41 assert_return(bus, -EINVAL);
42 assert_return(unique, -EINVAL);
43 assert_return(!bus_pid_changed(bus), -ECHILD);
45 r = bus_ensure_running(bus);
49 *unique = bus->unique_name;
53 _public_ int sd_bus_request_name(sd_bus *bus, const char *name, int flags) {
54 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
58 assert_return(bus, -EINVAL);
59 assert_return(name, -EINVAL);
60 assert_return(bus->bus_client, -EINVAL);
61 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
62 assert_return(!bus_pid_changed(bus), -ECHILD);
65 struct kdbus_cmd_name *n;
69 n = alloca0(offsetof(struct kdbus_cmd_name, name) + l + 1);
70 n->size = offsetof(struct kdbus_cmd_name, name) + l + 1;
71 kdbus_translate_request_name_flags(flags, (uint64_t *) &n->flags);
72 memcpy(n->name, name, l+1);
74 #ifdef HAVE_VALGRIND_MEMCHECK_H
75 VALGRIND_MAKE_MEM_DEFINED(n, n->size);
78 r = ioctl(bus->input_fd, KDBUS_CMD_NAME_ACQUIRE, n);
80 if (errno == -EALREADY)
81 return SD_BUS_NAME_ALREADY_OWNER;
84 return SD_BUS_NAME_EXISTS;
89 if (n->flags & KDBUS_NAME_IN_QUEUE)
90 return SD_BUS_NAME_IN_QUEUE;
92 return SD_BUS_NAME_PRIMARY_OWNER;
94 r = sd_bus_call_method(
96 "org.freedesktop.DBus",
98 "org.freedesktop.DBus",
108 r = sd_bus_message_read(reply, "u", &ret);
116 _public_ int sd_bus_release_name(sd_bus *bus, const char *name) {
117 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
121 assert_return(bus, -EINVAL);
122 assert_return(name, -EINVAL);
123 assert_return(bus->bus_client, -EINVAL);
124 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
125 assert_return(!bus_pid_changed(bus), -ECHILD);
127 if (bus->is_kernel) {
128 struct kdbus_cmd_name *n;
132 n = alloca0(offsetof(struct kdbus_cmd_name, name) + l + 1);
133 n->size = offsetof(struct kdbus_cmd_name, name) + l + 1;
134 memcpy(n->name, name, l+1);
136 #ifdef HAVE_VALGRIND_MEMCHECK_H
137 VALGRIND_MAKE_MEM_DEFINED(n, n->size);
139 r = ioctl(bus->input_fd, KDBUS_CMD_NAME_RELEASE, n);
145 r = sd_bus_call_method(
147 "org.freedesktop.DBus",
149 "org.freedesktop.DBus",
158 r = sd_bus_message_read(reply, "u", &ret);
166 _public_ int sd_bus_list_names(sd_bus *bus, char ***l) {
167 _cleanup_bus_message_unref_ sd_bus_message *reply1 = NULL, *reply2 = NULL;
171 assert_return(bus, -EINVAL);
172 assert_return(l, -EINVAL);
173 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
174 assert_return(!bus_pid_changed(bus), -ECHILD);
176 if (bus->is_kernel) {
177 _cleanup_free_ struct kdbus_cmd_name_list *cmd = NULL;
178 struct kdbus_name_list *name_list;
179 struct kdbus_cmd_name *name;
181 cmd = malloc0(sizeof(struct kdbus_cmd_name_list *));
185 cmd->flags = KDBUS_NAME_LIST_UNIQUE_NAMES;
187 r = ioctl(sd_bus_get_fd(bus), KDBUS_CMD_NAME_LIST, cmd);
191 name_list = (struct kdbus_name_list *) ((uint8_t *) bus->kdbus_buffer + cmd->offset);
193 KDBUS_PART_FOREACH(name, name_list, names) {
196 if (name->size > sizeof(*name))
199 asprintf(&n, ":1.%llu", (unsigned long long) name->id);
201 r = strv_extend(&x, n);
206 r = ioctl(sd_bus_get_fd(bus), KDBUS_CMD_FREE, &cmd->offset);
212 r = sd_bus_call_method(
214 "org.freedesktop.DBus",
216 "org.freedesktop.DBus",
224 r = sd_bus_call_method(
226 "org.freedesktop.DBus",
228 "org.freedesktop.DBus",
229 "ListActivatableNames",
236 r = bus_message_read_strv_extend(reply1, &x);
242 r = bus_message_read_strv_extend(reply2, &x);
254 static int bus_get_owner_dbus(
258 sd_bus_creds **creds) {
260 _cleanup_bus_message_unref_ sd_bus_message *reply_unique = NULL, *reply = NULL;
261 _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
262 const char *unique = NULL;
266 /* Only query the owner if the caller wants to know it or if
267 * the caller just wants to check whether a name exists */
268 if ((mask & SD_BUS_CREDS_UNIQUE_NAME) || mask == 0) {
269 r = sd_bus_call_method(
271 "org.freedesktop.DBus",
273 "org.freedesktop.DBus",
282 r = sd_bus_message_read(reply_unique, "s", &unique);
292 if ((mask & SD_BUS_CREDS_UNIQUE_NAME) && unique) {
293 c->unique_name = strdup(unique);
297 c->mask |= SD_BUS_CREDS_UNIQUE_NAME;
300 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_GID|
301 SD_BUS_CREDS_COMM|SD_BUS_CREDS_EXE|SD_BUS_CREDS_CMDLINE|
302 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|
303 SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS|
304 SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID)) {
307 r = sd_bus_call_method(
309 "org.freedesktop.DBus",
311 "org.freedesktop.DBus",
312 "GetConnectionUnixProcessID",
316 unique ? unique : name);
320 r = sd_bus_message_read(reply, "u", &u);
325 if (mask & SD_BUS_CREDS_PID) {
327 c->mask |= SD_BUS_CREDS_PID;
330 reply = sd_bus_message_unref(reply);
333 if (mask & SD_BUS_CREDS_UID) {
336 r = sd_bus_call_method(
338 "org.freedesktop.DBus",
340 "org.freedesktop.DBus",
341 "GetConnectionUnixUser",
345 unique ? unique : name);
349 r = sd_bus_message_read(reply, "u", &u);
354 c->mask |= SD_BUS_CREDS_UID;
356 reply = sd_bus_message_unref(reply);
359 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT) {
363 r = sd_bus_call_method(
365 "org.freedesktop.DBus",
367 "org.freedesktop.DBus",
368 "GetConnectionSELinuxSecurityContext",
372 unique ? unique : name);
376 r = sd_bus_message_read_array(reply, 'y', &p, &sz);
380 c->label = strndup(p, sz);
384 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
387 r = bus_creds_add_more(c, mask, pid, 0);
400 static int bus_get_owner_kdbus(
404 sd_bus_creds **creds) {
406 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
407 _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
408 struct kdbus_cmd_name_info *cmd;
409 struct kdbus_name_info *name_info;
410 struct kdbus_item *item;
415 r = bus_kernel_parse_unique_name(name, &id);
419 size = offsetof(struct kdbus_cmd_name_info, name);
423 size = offsetof(struct kdbus_cmd_name_info, name) + strlen(name) + 1;
425 strcpy(cmd->name, name);
430 r = kdbus_translate_attach_flags(mask, (uint64_t*) &cmd->attach_flags);
434 r = ioctl(bus->input_fd, KDBUS_CMD_NAME_INFO, cmd);
438 name_info = (struct kdbus_name_info *) ((uint8_t *) bus->kdbus_buffer + cmd->offset);
444 if (mask & SD_BUS_CREDS_UNIQUE_NAME) {
445 if (asprintf(&c->unique_name, ":1.%llu", (unsigned long long) name_info->id) < 0)
448 c->mask |= SD_BUS_CREDS_UNIQUE_NAME;
451 KDBUS_PART_FOREACH(item, name_info, items) {
453 switch (item->type) {
455 case KDBUS_ITEM_CREDS:
456 m = (SD_BUS_CREDS_UID | SD_BUS_CREDS_GID | SD_BUS_CREDS_PID |
457 SD_BUS_CREDS_TID | SD_BUS_CREDS_PID_STARTTIME) & mask;
460 c->uid = item->creds.uid;
461 c->pid = item->creds.pid;
462 c->gid = item->creds.gid;
463 c->tid = item->creds.tid;
464 c->pid_starttime = item->creds.starttime;
469 case KDBUS_ITEM_PID_COMM:
470 if (mask & SD_BUS_CREDS_COMM) {
471 c->comm = strdup(item->str);
477 c->mask |= SD_BUS_CREDS_COMM;
481 case KDBUS_ITEM_TID_COMM:
482 if (mask & SD_BUS_CREDS_TID_COMM) {
483 c->tid_comm = strdup(item->str);
489 c->mask |= SD_BUS_CREDS_TID_COMM;
494 if (mask & SD_BUS_CREDS_EXE) {
495 c->exe = strdup(item->str);
501 c->mask |= SD_BUS_CREDS_EXE;
505 case KDBUS_ITEM_CMDLINE:
506 if (mask & SD_BUS_CREDS_CMDLINE) {
507 c->cmdline_size = item->size - KDBUS_PART_HEADER_SIZE;
508 c->cmdline = memdup(item->data, c->cmdline_size);
514 c->mask |= SD_BUS_CREDS_CMDLINE;
518 case KDBUS_ITEM_CGROUP:
519 m = (SD_BUS_CREDS_CGROUP | SD_BUS_CREDS_UNIT |
520 SD_BUS_CREDS_USER_UNIT | SD_BUS_CREDS_SLICE |
521 SD_BUS_CREDS_SESSION | SD_BUS_CREDS_OWNER_UID) & mask;
524 c->cgroup = strdup(item->str);
534 case KDBUS_ITEM_CAPS:
535 m = (SD_BUS_CREDS_EFFECTIVE_CAPS | SD_BUS_CREDS_PERMITTED_CAPS |
536 SD_BUS_CREDS_INHERITABLE_CAPS | SD_BUS_CREDS_BOUNDING_CAPS) & mask;
539 c->capability_size = item->size - KDBUS_PART_HEADER_SIZE;
540 c->capability = memdup(item->data, c->capability_size);
541 if (!c->capability) {
550 case KDBUS_ITEM_SECLABEL:
551 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT) {
552 c->label = strdup(item->str);
558 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
562 case KDBUS_ITEM_AUDIT:
563 m = (SD_BUS_CREDS_AUDIT_SESSION_ID | SD_BUS_CREDS_AUDIT_LOGIN_UID) & mask;
566 c->audit_session_id = item->audit.sessionid;
567 c->audit_login_uid = item->audit.loginuid;
572 case KDBUS_ITEM_NAMES:
573 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
574 c->well_known_names_size = item->size - KDBUS_PART_HEADER_SIZE;
575 c->well_known_names = memdup(item->data, c->well_known_names_size);
576 if (!c->well_known_names) {
581 c->mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
595 ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd->offset);
599 _public_ int sd_bus_get_owner(
603 sd_bus_creds **creds) {
605 assert_return(bus, -EINVAL);
606 assert_return(name, -EINVAL);
607 assert_return(mask <= _SD_BUS_CREDS_MAX, -ENOTSUP);
608 assert_return(mask == 0 || creds, -EINVAL);
609 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
610 assert_return(!bus_pid_changed(bus), -ECHILD);
613 return bus_get_owner_kdbus(bus, name, mask, creds);
615 return bus_get_owner_dbus(bus, name, mask, creds);
618 static int add_name_change_match(sd_bus *bus,
621 const char *old_owner,
622 const char *new_owner) {
624 uint64_t name_id = 0, old_owner_id = 0, new_owner_id = 0;
625 int is_name_id = -1, r;
626 struct kdbus_item *item;
630 /* If we encounter a match that could match against
631 * NameOwnerChanged messages, then we need to create
632 * KDBUS_MATCH_NAME_{ADD,REMOVE,CHANGE} and
633 * KDBUS_MATCH_ID_{ADD,REMOVE} matches for it, possibly
634 * multiple if the match is underspecified.
636 * The NameOwnerChanged signals take three parameters with
637 * unique or well-known names, but only some forms actually
640 * WELLKNOWN, "", UNIQUE → KDBUS_MATCH_NAME_ADD
641 * WELLKNOWN, UNIQUE, "" → KDBUS_MATCH_NAME_REMOVE
642 * WELLKNOWN, UNIQUE, UNIQUE → KDBUS_MATCH_NAME_CHANGE
643 * UNIQUE, "", UNIQUE → KDBUS_MATCH_ID_ADD
644 * UNIQUE, UNIQUE, "" → KDBUS_MATCH_ID_REMOVE
646 * For the latter two the two unique names must be identical.
651 is_name_id = bus_kernel_parse_unique_name(name, &name_id);
657 r = bus_kernel_parse_unique_name(old_owner, &old_owner_id);
662 if (is_name_id > 0 && old_owner_id != name_id)
667 r = bus_kernel_parse_unique_name(new_owner, &new_owner_id);
672 if (is_name_id > 0 && new_owner_id != name_id)
676 if (is_name_id <= 0) {
679 /* If the name argument is missing or is a well-known
680 * name, then add KDBUS_MATCH_NAME_{ADD,REMOVE,CHANGE}
683 l = name ? strlen(name) : 0;
685 sz = ALIGN8(offsetof(struct kdbus_cmd_match, items) +
686 offsetof(struct kdbus_item, name_change) +
687 offsetof(struct kdbus_notify_name_change, name) +
693 struct kdbus_cmd_match match;
699 m.match.cookie = cookie;
700 m.match.src_id = KDBUS_SRC_ID_KERNEL;
702 item = m.match.items;
704 offsetof(struct kdbus_item, name_change) +
705 offsetof(struct kdbus_notify_name_change, name) +
708 item->name_change.old_id = old_owner_id;
709 item->name_change.new_id = new_owner_id;
712 strcpy(item->name_change.name, name);
714 /* If the old name is unset or empty, then
715 * this can match against added names */
716 if (!old_owner || old_owner[0] == 0) {
717 item->type = KDBUS_MATCH_NAME_ADD;
719 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
724 /* If the new name is unset or empty, then
725 * this can match against removed names */
726 if (!new_owner || new_owner[0] == 0) {
727 item->type = KDBUS_MATCH_NAME_REMOVE;
729 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
734 /* If the neither name is explicitly set to
735 * the empty string, then this can match
736 * agains changed names */
737 if (!(old_owner && old_owner[0] == 0) &&
738 !(new_owner && new_owner[0] == 0)) {
739 item->type = KDBUS_MATCH_NAME_CHANGE;
741 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
748 if (is_name_id != 0) {
750 ALIGN8(offsetof(struct kdbus_cmd_match, items) +
751 offsetof(struct kdbus_item, id_change) +
752 sizeof(struct kdbus_notify_id_change));
755 struct kdbus_cmd_match match;
758 /* If the name argument is missing or is a unique
759 * name, then add KDBUS_MATCH_ID_{ADD,REMOVE} matches
765 m.match.cookie = cookie;
766 m.match.src_id = KDBUS_SRC_ID_KERNEL;
768 item = m.match.items;
769 item->size = offsetof(struct kdbus_item, id_change) + sizeof(struct kdbus_notify_id_change);
770 item->id_change.id = name_id;
772 /* If the old name is unset or empty, then this can
773 * match against added ids */
774 if (!old_owner || old_owner[0] == 0) {
775 item->type = KDBUS_MATCH_ID_ADD;
777 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
782 /* If thew new name is unset or empty, then this can
783 match against removed ids */
784 if (!new_owner || new_owner[0] == 0) {
785 item->type = KDBUS_MATCH_ID_REMOVE;
787 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
796 int bus_add_match_internal(
799 struct bus_match_component *components,
800 unsigned n_components,
808 if (bus->is_kernel) {
809 struct kdbus_cmd_match *m;
810 struct kdbus_item *item;
811 uint64_t bloom[BLOOM_SIZE/8];
813 const char *sender = NULL;
814 size_t sender_length = 0;
815 uint64_t src_id = KDBUS_MATCH_SRC_ID_ANY;
816 bool using_bloom = false;
818 bool matches_name_change = true;
819 const char *name_change_arg[3] = {};
823 sz = offsetof(struct kdbus_cmd_match, items);
825 for (i = 0; i < n_components; i++) {
826 struct bus_match_component *c = &components[i];
830 case BUS_MATCH_SENDER:
831 if (!streq(c->value_str, "org.freedesktop.DBus"))
832 matches_name_change = false;
834 r = bus_kernel_parse_unique_name(c->value_str, &src_id);
839 sender = c->value_str;
840 sender_length = strlen(sender);
841 sz += ALIGN8(offsetof(struct kdbus_item, str) + sender_length + 1);
846 case BUS_MATCH_MESSAGE_TYPE:
847 if (c->value_u8 != SD_BUS_MESSAGE_SIGNAL)
848 matches_name_change = false;
850 bloom_add_pair(bloom, "message-type", bus_message_type_to_string(c->value_u8));
854 case BUS_MATCH_INTERFACE:
855 if (!streq(c->value_str, "org.freedesktop.DBus"))
856 matches_name_change = false;
858 bloom_add_pair(bloom, "interface", c->value_str);
862 case BUS_MATCH_MEMBER:
863 if (!streq(c->value_str, "NameOwnerChanged"))
864 matches_name_change = false;
866 bloom_add_pair(bloom, "member", c->value_str);
871 if (!streq(c->value_str, "/org/freedesktop/DBus"))
872 matches_name_change = false;
874 bloom_add_pair(bloom, "path", c->value_str);
878 case BUS_MATCH_PATH_NAMESPACE:
879 if (!streq(c->value_str, "/")) {
880 bloom_add_pair(bloom, "path-slash-prefix", c->value_str);
885 case BUS_MATCH_ARG...BUS_MATCH_ARG_LAST: {
886 char buf[sizeof("arg")-1 + 2 + 1];
888 if (c->type - BUS_MATCH_ARG < 3)
889 name_change_arg[c->type - BUS_MATCH_ARG] = c->value_str;
891 snprintf(buf, sizeof(buf), "arg%u", c->type - BUS_MATCH_ARG);
892 bloom_add_pair(bloom, buf, c->value_str);
897 case BUS_MATCH_ARG_PATH...BUS_MATCH_ARG_PATH_LAST: {
898 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
900 snprintf(buf, sizeof(buf), "arg%u-slash-prefix", c->type - BUS_MATCH_ARG_PATH);
901 bloom_add_pair(bloom, buf, c->value_str);
906 case BUS_MATCH_ARG_NAMESPACE...BUS_MATCH_ARG_NAMESPACE_LAST: {
907 char buf[sizeof("arg")-1 + 2 + sizeof("-dot-prefix")];
909 snprintf(buf, sizeof(buf), "arg%u-dot-prefix", c->type - BUS_MATCH_ARG_NAMESPACE);
910 bloom_add_pair(bloom, buf, c->value_str);
915 case BUS_MATCH_DESTINATION:
916 /* The bloom filter does not include
917 the destination, since it is only
918 available for broadcast messages
919 which do not carry a destination
920 since they are undirected. */
924 case BUS_MATCH_VALUE:
926 case _BUS_MATCH_NODE_TYPE_MAX:
927 case _BUS_MATCH_NODE_TYPE_INVALID:
928 assert_not_reached("Invalid match type?");
933 sz += ALIGN8(offsetof(struct kdbus_item, data64) + BLOOM_SIZE);
943 item->size = offsetof(struct kdbus_item, data64) + BLOOM_SIZE;
944 item->type = KDBUS_MATCH_BLOOM;
945 memcpy(item->data64, bloom, BLOOM_SIZE);
947 item = KDBUS_PART_NEXT(item);
951 item->size = offsetof(struct kdbus_item, str) + sender_length + 1;
952 item->type = KDBUS_MATCH_SRC_NAME;
953 memcpy(item->str, sender, sender_length + 1);
956 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
960 if (matches_name_change) {
962 /* If this match could theoretically match
963 * NameOwnerChanged messages, we need to
964 * install a second non-bloom filter explitly
967 r = add_name_change_match(bus, cookie, name_change_arg[0], name_change_arg[1], name_change_arg[2]);
974 return sd_bus_call_method(
976 "org.freedesktop.DBus",
978 "org.freedesktop.DBus",
986 int bus_remove_match_internal(
996 if (bus->is_kernel) {
997 struct kdbus_cmd_match m;
1000 m.size = offsetof(struct kdbus_cmd_match, items);
1003 r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_REMOVE, &m);
1010 return sd_bus_call_method(
1012 "org.freedesktop.DBus",
1014 "org.freedesktop.DBus",
1023 _public_ int sd_bus_get_owner_machine_id(sd_bus *bus, const char *name, sd_id128_t *machine) {
1024 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL, *m = NULL;
1028 assert_return(bus, -EINVAL);
1029 assert_return(name, -EINVAL);
1030 assert_return(machine, -EINVAL);
1031 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1032 assert_return(!bus_pid_changed(bus), -ECHILD);
1034 if (streq_ptr(name, bus->unique_name))
1035 return sd_id128_get_machine(machine);
1037 r = sd_bus_message_new_method_call(
1041 "org.freedesktop.DBus.Peer",
1042 "GetMachineId", &m);
1046 r = sd_bus_message_set_no_auto_start(m, true);
1050 r = sd_bus_call(bus, m, 0, NULL, &reply);
1054 r = sd_bus_message_read(reply, "s", &mid);
1058 return sd_id128_from_string(mid, machine);