2 This file is part of systemd.
4 Copyright 2013 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
26 #include <sys/ioctl.h>
27 #include <sys/resource.h>
28 #include <sys/socket.h>
31 #include "sd-bus-protocol.h"
33 #include "sd-daemon.h"
37 #include "alloc-util.h"
38 #include "bus-internal.h"
39 #include "bus-label.h"
40 #include "bus-message.h"
47 #include "parse-util.h"
48 #include "proc-cmdline.h"
49 #include "rlimit-util.h"
50 #include "stdio-util.h"
52 #include "user-util.h"
54 static int name_owner_change_callback(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
55 sd_event
*e
= userdata
;
60 sd_bus_close(sd_bus_message_get_bus(m
));
66 int bus_async_unregister_and_exit(sd_event
*e
, sd_bus
*bus
, const char *name
) {
67 _cleanup_free_
char *match
= NULL
;
75 /* We unregister the name here and then wait for the
76 * NameOwnerChanged signal for this event to arrive before we
77 * quit. We do this in order to make sure that any queued
78 * requests are still processed before we really exit. */
80 r
= sd_bus_get_unique_name(bus
, &unique
);
85 "sender='org.freedesktop.DBus',"
87 "interface='org.freedesktop.DBus',"
88 "member='NameOwnerChanged',"
89 "path='/org/freedesktop/DBus',"
92 "arg2=''", name
, unique
);
96 r
= sd_bus_add_match(bus
, NULL
, match
, name_owner_change_callback
, e
);
100 r
= sd_bus_release_name(bus
, name
);
107 int bus_event_loop_with_idle(
112 check_idle_t check_idle
,
114 bool exiting
= false;
124 r
= sd_event_get_state(e
);
127 if (r
== SD_EVENT_FINISHED
)
131 idle
= check_idle(userdata
);
135 r
= sd_event_run(e
, exiting
|| !idle
? (uint64_t) -1 : timeout
);
139 if (r
== 0 && !exiting
&& idle
) {
141 r
= sd_bus_try_close(bus
);
145 /* Fallback for dbus1 connections: we
146 * unregister the name and wait for the
147 * response to come through for it */
148 if (r
== -EOPNOTSUPP
) {
150 /* Inform the service manager that we
151 * are going down, so that it will
152 * queue all further start requests,
153 * instead of assuming we are already
155 sd_notify(false, "STOPPING=1");
157 r
= bus_async_unregister_and_exit(e
, bus
, name
);
173 r
= sd_event_get_exit_code(e
, &code
);
180 int bus_name_has_owner(sd_bus
*c
, const char *name
, sd_bus_error
*error
) {
181 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*rep
= NULL
;
182 int r
, has_owner
= 0;
187 r
= sd_bus_call_method(c
,
188 "org.freedesktop.DBus",
189 "/org/freedesktop/dbus",
190 "org.freedesktop.DBus",
199 r
= sd_bus_message_read_basic(rep
, 'b', &has_owner
);
201 return sd_bus_error_set_errno(error
, r
);
206 static int check_good_user(sd_bus_message
*m
, uid_t good_user
) {
207 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
213 if (good_user
== UID_INVALID
)
216 r
= sd_bus_query_sender_creds(m
, SD_BUS_CREDS_EUID
, &creds
);
220 /* Don't trust augmented credentials for authorization */
221 assert_return((sd_bus_creds_get_augmented_mask(creds
) & SD_BUS_CREDS_EUID
) == 0, -EPERM
);
223 r
= sd_bus_creds_get_euid(creds
, &sender_uid
);
227 return sender_uid
== good_user
;
231 sd_bus_message
*call
,
234 const char **details
,
244 /* Tests non-interactively! */
246 r
= check_good_user(call
, good_user
);
250 r
= sd_bus_query_sender_privilege(call
, capability
);
257 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*request
= NULL
;
258 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
259 int authorized
= false, challenge
= false;
260 const char *sender
, **k
, **v
;
262 sender
= sd_bus_message_get_sender(call
);
266 r
= sd_bus_message_new_method_call(
269 "org.freedesktop.PolicyKit1",
270 "/org/freedesktop/PolicyKit1/Authority",
271 "org.freedesktop.PolicyKit1.Authority",
272 "CheckAuthorization");
276 r
= sd_bus_message_append(
279 "system-bus-name", 1, "name", "s", sender
,
284 r
= sd_bus_message_open_container(request
, 'a', "{ss}");
288 STRV_FOREACH_PAIR(k
, v
, details
) {
289 r
= sd_bus_message_append(request
, "{ss}", *k
, *v
);
294 r
= sd_bus_message_close_container(request
);
298 r
= sd_bus_message_append(request
, "us", 0, NULL
);
302 r
= sd_bus_call(call
->bus
, request
, 0, e
, &reply
);
304 /* Treat no PK available as access denied */
305 if (sd_bus_error_has_name(e
, SD_BUS_ERROR_SERVICE_UNKNOWN
)) {
306 sd_bus_error_free(e
);
313 r
= sd_bus_message_enter_container(reply
, 'r', "bba{ss}");
317 r
= sd_bus_message_read(reply
, "bb", &authorized
, &challenge
);
325 *_challenge
= challenge
;
336 typedef struct AsyncPolkitQuery
{
337 sd_bus_message
*request
, *reply
;
338 sd_bus_message_handler_t callback
;
344 static void async_polkit_query_free(AsyncPolkitQuery
*q
) {
349 sd_bus_slot_unref(q
->slot
);
351 if (q
->registry
&& q
->request
)
352 hashmap_remove(q
->registry
, q
->request
);
354 sd_bus_message_unref(q
->request
);
355 sd_bus_message_unref(q
->reply
);
360 static int async_polkit_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
361 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
362 AsyncPolkitQuery
*q
= userdata
;
368 q
->slot
= sd_bus_slot_unref(q
->slot
);
369 q
->reply
= sd_bus_message_ref(reply
);
371 r
= sd_bus_message_rewind(q
->request
, true);
373 r
= sd_bus_reply_method_errno(q
->request
, r
, NULL
);
377 r
= q
->callback(q
->request
, q
->userdata
, &error_buffer
);
378 r
= bus_maybe_reply_error(q
->request
, r
, &error_buffer
);
381 async_polkit_query_free(q
);
388 int bus_verify_polkit_async(
389 sd_bus_message
*call
,
392 const char **details
,
396 sd_bus_error
*error
) {
399 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*pk
= NULL
;
401 const char *sender
, **k
, **v
;
402 sd_bus_message_handler_t callback
;
412 r
= check_good_user(call
, good_user
);
417 q
= hashmap_get(*registry
, call
);
419 int authorized
, challenge
;
421 /* This is the second invocation of this function, and
422 * there's already a response from polkit, let's
426 if (sd_bus_message_is_method_error(q
->reply
, NULL
)) {
427 const sd_bus_error
*e
;
429 /* Copy error from polkit reply */
430 e
= sd_bus_message_get_error(q
->reply
);
431 sd_bus_error_copy(error
, e
);
433 /* Treat no PK available as access denied */
434 if (sd_bus_error_has_name(e
, SD_BUS_ERROR_SERVICE_UNKNOWN
))
437 return -sd_bus_error_get_errno(e
);
440 r
= sd_bus_message_enter_container(q
->reply
, 'r', "bba{ss}");
442 r
= sd_bus_message_read(q
->reply
, "bb", &authorized
, &challenge
);
451 return sd_bus_error_set(error
, SD_BUS_ERROR_INTERACTIVE_AUTHORIZATION_REQUIRED
, "Interactive authentication required.");
457 r
= sd_bus_query_sender_privilege(call
, capability
);
464 if (sd_bus_get_current_message(call
->bus
) != call
)
467 callback
= sd_bus_get_current_handler(call
->bus
);
471 userdata
= sd_bus_get_current_userdata(call
->bus
);
473 sender
= sd_bus_message_get_sender(call
);
477 c
= sd_bus_message_get_allow_interactive_authorization(call
);
483 r
= hashmap_ensure_allocated(registry
, NULL
);
487 r
= sd_bus_message_new_method_call(
490 "org.freedesktop.PolicyKit1",
491 "/org/freedesktop/PolicyKit1/Authority",
492 "org.freedesktop.PolicyKit1.Authority",
493 "CheckAuthorization");
497 r
= sd_bus_message_append(
500 "system-bus-name", 1, "name", "s", sender
,
505 r
= sd_bus_message_open_container(pk
, 'a', "{ss}");
509 STRV_FOREACH_PAIR(k
, v
, details
) {
510 r
= sd_bus_message_append(pk
, "{ss}", *k
, *v
);
515 r
= sd_bus_message_close_container(pk
);
519 r
= sd_bus_message_append(pk
, "us", !!interactive
, NULL
);
523 q
= new0(AsyncPolkitQuery
, 1);
527 q
->request
= sd_bus_message_ref(call
);
528 q
->callback
= callback
;
529 q
->userdata
= userdata
;
531 r
= hashmap_put(*registry
, call
, q
);
533 async_polkit_query_free(q
);
537 q
->registry
= *registry
;
539 r
= sd_bus_call_async(call
->bus
, &q
->slot
, pk
, async_polkit_callback
, q
, 0);
541 async_polkit_query_free(q
);
551 void bus_verify_polkit_async_registry_free(Hashmap
*registry
) {
555 while ((q
= hashmap_steal_first(registry
)))
556 async_polkit_query_free(q
);
558 hashmap_free(registry
);
562 int bus_check_peercred(sd_bus
*c
) {
569 fd
= sd_bus_get_fd(c
);
573 l
= sizeof(struct ucred
);
574 if (getsockopt(fd
, SOL_SOCKET
, SO_PEERCRED
, &ucred
, &l
) < 0)
577 if (l
!= sizeof(struct ucred
))
580 if (ucred
.uid
!= 0 && ucred
.uid
!= geteuid())
586 int bus_connect_system_systemd(sd_bus
**_bus
) {
587 _cleanup_(sd_bus_unrefp
) sd_bus
*bus
= NULL
;
593 return sd_bus_default_system(_bus
);
595 /* If we are root and kdbus is not available, then let's talk
596 * directly to the system instance, instead of going via the
599 r
= sd_bus_new(&bus
);
603 r
= sd_bus_set_address(bus
, KERNEL_SYSTEM_BUS_ADDRESS
);
607 bus
->bus_client
= true;
609 r
= sd_bus_start(bus
);
616 bus
= sd_bus_unref(bus
);
618 r
= sd_bus_new(&bus
);
622 r
= sd_bus_set_address(bus
, "unix:path=/run/systemd/private");
626 r
= sd_bus_start(bus
);
628 return sd_bus_default_system(_bus
);
630 r
= bus_check_peercred(bus
);
640 int bus_connect_user_systemd(sd_bus
**_bus
) {
641 _cleanup_(sd_bus_unrefp
) sd_bus
*bus
= NULL
;
642 _cleanup_free_
char *ee
= NULL
;
646 /* Try via kdbus first, and then directly */
650 r
= sd_bus_new(&bus
);
654 if (asprintf(&bus
->address
, KERNEL_USER_BUS_ADDRESS_FMT
, getuid()) < 0)
657 bus
->bus_client
= true;
659 r
= sd_bus_start(bus
);
666 bus
= sd_bus_unref(bus
);
668 e
= secure_getenv("XDG_RUNTIME_DIR");
670 return sd_bus_default_user(_bus
);
672 ee
= bus_address_escape(e
);
676 r
= sd_bus_new(&bus
);
680 bus
->address
= strjoin("unix:path=", ee
, "/systemd/private");
684 r
= sd_bus_start(bus
);
686 return sd_bus_default_user(_bus
);
688 r
= bus_check_peercred(bus
);
698 #define print_property(name, fmt, ...) \
701 printf(fmt "\n", __VA_ARGS__); \
703 printf("%s=" fmt "\n", name, __VA_ARGS__); \
706 int bus_print_property(const char *name
, sd_bus_message
*property
, bool value
, bool all
) {
708 const char *contents
;
714 r
= sd_bus_message_peek_type(property
, &type
, &contents
);
720 case SD_BUS_TYPE_STRING
: {
723 r
= sd_bus_message_read_basic(property
, type
, &s
);
727 if (all
|| !isempty(s
)) {
728 _cleanup_free_
char *escaped
= NULL
;
730 escaped
= xescape(s
, "\n");
734 print_property(name
, "%s", escaped
);
740 case SD_BUS_TYPE_BOOLEAN
: {
743 r
= sd_bus_message_read_basic(property
, type
, &b
);
747 print_property(name
, "%s", yes_no(b
));
752 case SD_BUS_TYPE_UINT64
: {
755 r
= sd_bus_message_read_basic(property
, type
, &u
);
759 /* Yes, heuristics! But we can change this check
760 * should it turn out to not be sufficient */
762 if (endswith(name
, "Timestamp")) {
763 char timestamp
[FORMAT_TIMESTAMP_MAX
], *t
;
765 t
= format_timestamp(timestamp
, sizeof(timestamp
), u
);
767 print_property(name
, "%s", strempty(t
));
769 } else if (strstr(name
, "USec")) {
770 char timespan
[FORMAT_TIMESPAN_MAX
];
772 print_property(name
, "%s", format_timespan(timespan
, sizeof(timespan
), u
, 0));
773 } else if (streq(name
, "RestrictNamespaces")) {
774 _cleanup_free_
char *s
= NULL
;
775 const char *result
= NULL
;
777 if ((u
& NAMESPACE_FLAGS_ALL
) == 0)
779 else if ((u
& NAMESPACE_FLAGS_ALL
) == NAMESPACE_FLAGS_ALL
)
782 r
= namespace_flag_to_string_many(u
, &s
);
789 print_property(name
, "%s", result
);
791 print_property(name
, "%"PRIu64
, u
);
796 case SD_BUS_TYPE_INT64
: {
799 r
= sd_bus_message_read_basic(property
, type
, &i
);
803 print_property(name
, "%"PRIi64
, i
);
808 case SD_BUS_TYPE_UINT32
: {
811 r
= sd_bus_message_read_basic(property
, type
, &u
);
815 if (strstr(name
, "UMask") || strstr(name
, "Mode"))
816 print_property(name
, "%04o", u
);
818 print_property(name
, "%"PRIu32
, u
);
823 case SD_BUS_TYPE_INT32
: {
826 r
= sd_bus_message_read_basic(property
, type
, &i
);
830 print_property(name
, "%"PRIi32
, i
);
834 case SD_BUS_TYPE_DOUBLE
: {
837 r
= sd_bus_message_read_basic(property
, type
, &d
);
841 print_property(name
, "%g", d
);
845 case SD_BUS_TYPE_ARRAY
:
846 if (streq(contents
, "s")) {
850 r
= sd_bus_message_enter_container(property
, SD_BUS_TYPE_ARRAY
, contents
);
854 while ((r
= sd_bus_message_read_basic(property
, SD_BUS_TYPE_STRING
, &str
)) > 0) {
855 _cleanup_free_
char *escaped
= NULL
;
860 escaped
= xescape(str
, "\n ");
864 printf("%s%s", first
? "" : " ", escaped
);
871 if (first
&& all
&& !value
)
876 r
= sd_bus_message_exit_container(property
);
882 } else if (streq(contents
, "y")) {
886 r
= sd_bus_message_read_array(property
, SD_BUS_TYPE_BYTE
, (const void**) &u
, &n
);
896 for (i
= 0; i
< n
; i
++)
897 printf("%02x", u
[i
]);
904 } else if (streq(contents
, "u")) {
908 r
= sd_bus_message_read_array(property
, SD_BUS_TYPE_UINT32
, (const void**) &u
, &n
);
918 for (i
= 0; i
< n
; i
++)
919 printf("%08x", u
[i
]);
933 int bus_print_all_properties(sd_bus
*bus
, const char *dest
, const char *path
, char **filter
, bool value
, bool all
) {
934 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
935 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
941 r
= sd_bus_call_method(bus
,
944 "org.freedesktop.DBus.Properties",
952 r
= sd_bus_message_enter_container(reply
, SD_BUS_TYPE_ARRAY
, "{sv}");
956 while ((r
= sd_bus_message_enter_container(reply
, SD_BUS_TYPE_DICT_ENTRY
, "sv")) > 0) {
958 const char *contents
;
960 r
= sd_bus_message_read_basic(reply
, SD_BUS_TYPE_STRING
, &name
);
964 if (!filter
|| strv_find(filter
, name
)) {
965 r
= sd_bus_message_peek_type(reply
, NULL
, &contents
);
969 r
= sd_bus_message_enter_container(reply
, SD_BUS_TYPE_VARIANT
, contents
);
973 r
= bus_print_property(name
, reply
, value
, all
);
978 printf("%s=[unprintable]\n", name
);
979 /* skip what we didn't read */
980 r
= sd_bus_message_skip(reply
, contents
);
985 r
= sd_bus_message_exit_container(reply
);
989 r
= sd_bus_message_skip(reply
, "v");
994 r
= sd_bus_message_exit_container(reply
);
1001 r
= sd_bus_message_exit_container(reply
);
1008 int bus_map_id128(sd_bus
*bus
, const char *member
, sd_bus_message
*m
, sd_bus_error
*error
, void *userdata
) {
1009 sd_id128_t
*p
= userdata
;
1014 r
= sd_bus_message_read_array(m
, SD_BUS_TYPE_BYTE
, &v
, &n
);
1021 memcpy((*p
).bytes
, v
, n
);
1028 static int map_basic(sd_bus
*bus
, const char *member
, sd_bus_message
*m
, sd_bus_error
*error
, void *userdata
) {
1032 r
= sd_bus_message_peek_type(m
, &type
, NULL
);
1038 case SD_BUS_TYPE_STRING
: {
1039 char **p
= userdata
;
1042 r
= sd_bus_message_read_basic(m
, type
, &s
);
1049 return free_and_strdup(p
, s
);
1052 case SD_BUS_TYPE_ARRAY
: {
1053 _cleanup_strv_free_
char **l
= NULL
;
1054 char ***p
= userdata
;
1056 r
= bus_message_read_strv_extend(m
, &l
);
1066 case SD_BUS_TYPE_BOOLEAN
: {
1070 r
= sd_bus_message_read_basic(m
, type
, &b
);
1078 case SD_BUS_TYPE_INT32
:
1079 case SD_BUS_TYPE_UINT32
: {
1080 uint32_t u
, *p
= userdata
;
1082 r
= sd_bus_message_read_basic(m
, type
, &u
);
1090 case SD_BUS_TYPE_INT64
:
1091 case SD_BUS_TYPE_UINT64
: {
1092 uint64_t t
, *p
= userdata
;
1094 r
= sd_bus_message_read_basic(m
, type
, &t
);
1102 case SD_BUS_TYPE_DOUBLE
: {
1103 double d
, *p
= userdata
;
1105 r
= sd_bus_message_read_basic(m
, type
, &d
);
1116 int bus_message_map_all_properties(
1118 const struct bus_properties_map
*map
,
1121 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1127 r
= sd_bus_message_enter_container(m
, SD_BUS_TYPE_ARRAY
, "{sv}");
1131 while ((r
= sd_bus_message_enter_container(m
, SD_BUS_TYPE_DICT_ENTRY
, "sv")) > 0) {
1132 const struct bus_properties_map
*prop
;
1134 const char *contents
;
1138 r
= sd_bus_message_read_basic(m
, SD_BUS_TYPE_STRING
, &member
);
1142 for (i
= 0, prop
= NULL
; map
[i
].member
; i
++)
1143 if (streq(map
[i
].member
, member
)) {
1149 r
= sd_bus_message_peek_type(m
, NULL
, &contents
);
1153 r
= sd_bus_message_enter_container(m
, SD_BUS_TYPE_VARIANT
, contents
);
1157 v
= (uint8_t *)userdata
+ prop
->offset
;
1159 r
= prop
->set(sd_bus_message_get_bus(m
), member
, m
, &error
, v
);
1161 r
= map_basic(sd_bus_message_get_bus(m
), member
, m
, &error
, v
);
1165 r
= sd_bus_message_exit_container(m
);
1169 r
= sd_bus_message_skip(m
, "v");
1174 r
= sd_bus_message_exit_container(m
);
1181 return sd_bus_message_exit_container(m
);
1184 int bus_message_map_properties_changed(
1186 const struct bus_properties_map
*map
,
1190 int r
, invalidated
, i
;
1195 r
= bus_message_map_all_properties(m
, map
, userdata
);
1199 r
= sd_bus_message_enter_container(m
, SD_BUS_TYPE_ARRAY
, "s");
1204 while ((r
= sd_bus_message_read_basic(m
, SD_BUS_TYPE_STRING
, &member
)) > 0)
1205 for (i
= 0; map
[i
].member
; i
++)
1206 if (streq(map
[i
].member
, member
)) {
1213 r
= sd_bus_message_exit_container(m
);
1220 int bus_map_all_properties(
1222 const char *destination
,
1224 const struct bus_properties_map
*map
,
1227 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
1228 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1232 assert(destination
);
1236 r
= sd_bus_call_method(
1240 "org.freedesktop.DBus.Properties",
1248 return bus_message_map_all_properties(m
, map
, userdata
);
1251 int bus_connect_transport(BusTransport transport
, const char *host
, bool user
, sd_bus
**ret
) {
1252 _cleanup_(sd_bus_unrefp
) sd_bus
*bus
= NULL
;
1255 assert(transport
>= 0);
1256 assert(transport
< _BUS_TRANSPORT_MAX
);
1259 assert_return((transport
== BUS_TRANSPORT_LOCAL
) == !host
, -EINVAL
);
1260 assert_return(transport
== BUS_TRANSPORT_LOCAL
|| !user
, -EOPNOTSUPP
);
1262 switch (transport
) {
1264 case BUS_TRANSPORT_LOCAL
:
1266 r
= sd_bus_default_user(&bus
);
1268 r
= sd_bus_default_system(&bus
);
1272 case BUS_TRANSPORT_REMOTE
:
1273 r
= sd_bus_open_system_remote(&bus
, host
);
1276 case BUS_TRANSPORT_MACHINE
:
1277 r
= sd_bus_open_system_machine(&bus
, host
);
1281 assert_not_reached("Hmm, unknown transport type.");
1286 r
= sd_bus_set_exit_on_disconnect(bus
, true);
1296 int bus_connect_transport_systemd(BusTransport transport
, const char *host
, bool user
, sd_bus
**bus
) {
1299 assert(transport
>= 0);
1300 assert(transport
< _BUS_TRANSPORT_MAX
);
1303 assert_return((transport
== BUS_TRANSPORT_LOCAL
) == !host
, -EINVAL
);
1304 assert_return(transport
== BUS_TRANSPORT_LOCAL
|| !user
, -EOPNOTSUPP
);
1306 switch (transport
) {
1308 case BUS_TRANSPORT_LOCAL
:
1310 r
= bus_connect_user_systemd(bus
);
1312 r
= bus_connect_system_systemd(bus
);
1316 case BUS_TRANSPORT_REMOTE
:
1317 r
= sd_bus_open_system_remote(bus
, host
);
1320 case BUS_TRANSPORT_MACHINE
:
1321 r
= sd_bus_open_system_machine(bus
, host
);
1325 assert_not_reached("Hmm, unknown transport type.");
1331 int bus_property_get_bool(
1334 const char *interface
,
1335 const char *property
,
1336 sd_bus_message
*reply
,
1338 sd_bus_error
*error
) {
1340 int b
= *(bool*) userdata
;
1342 return sd_bus_message_append_basic(reply
, 'b', &b
);
1345 int bus_property_get_id128(
1348 const char *interface
,
1349 const char *property
,
1350 sd_bus_message
*reply
,
1352 sd_bus_error
*error
) {
1354 sd_id128_t
*id
= userdata
;
1356 if (sd_id128_is_null(*id
)) /* Add an empty array if the ID is zero */
1357 return sd_bus_message_append(reply
, "ay", 0);
1359 return sd_bus_message_append_array(reply
, 'y', id
->bytes
, 16);
1362 #if __SIZEOF_SIZE_T__ != 8
1363 int bus_property_get_size(
1366 const char *interface
,
1367 const char *property
,
1368 sd_bus_message
*reply
,
1370 sd_bus_error
*error
) {
1372 uint64_t sz
= *(size_t*) userdata
;
1374 return sd_bus_message_append_basic(reply
, 't', &sz
);
1378 #if __SIZEOF_LONG__ != 8
1379 int bus_property_get_long(
1382 const char *interface
,
1383 const char *property
,
1384 sd_bus_message
*reply
,
1386 sd_bus_error
*error
) {
1388 int64_t l
= *(long*) userdata
;
1390 return sd_bus_message_append_basic(reply
, 'x', &l
);
1393 int bus_property_get_ulong(
1396 const char *interface
,
1397 const char *property
,
1398 sd_bus_message
*reply
,
1400 sd_bus_error
*error
) {
1402 uint64_t ul
= *(unsigned long*) userdata
;
1404 return sd_bus_message_append_basic(reply
, 't', &ul
);
1408 int bus_log_parse_error(int r
) {
1409 return log_error_errno(r
, "Failed to parse bus message: %m");
1412 int bus_log_create_error(int r
) {
1413 return log_error_errno(r
, "Failed to create bus message: %m");
1417 * bus_path_encode_unique() - encode unique object path
1418 * @b: bus connection or NULL
1419 * @prefix: object path prefix
1420 * @sender_id: unique-name of client, or NULL
1421 * @external_id: external ID to be chosen by client, or NULL
1422 * @ret_path: storage for encoded object path pointer
1424 * Whenever we provide a bus API that allows clients to create and manage
1425 * server-side objects, we need to provide a unique name for these objects. If
1426 * we let the server choose the name, we suffer from a race condition: If a
1427 * client creates an object asynchronously, it cannot destroy that object until
1428 * it received the method reply. It cannot know the name of the new object,
1429 * thus, it cannot destroy it. Furthermore, it enforces a round-trip.
1431 * Therefore, many APIs allow the client to choose the unique name for newly
1432 * created objects. There're two problems to solve, though:
1433 * 1) Object names are usually defined via dbus object paths, which are
1434 * usually globally namespaced. Therefore, multiple clients must be able
1435 * to choose unique object names without interference.
1436 * 2) If multiple libraries share the same bus connection, they must be
1437 * able to choose unique object names without interference.
1438 * The first problem is solved easily by prefixing a name with the
1439 * unique-bus-name of a connection. The server side must enforce this and
1440 * reject any other name. The second problem is solved by providing unique
1441 * suffixes from within sd-bus.
1443 * This helper allows clients to create unique object-paths. It uses the
1444 * template '/prefix/sender_id/external_id' and returns the new path in
1445 * @ret_path (must be freed by the caller).
1446 * If @sender_id is NULL, the unique-name of @b is used. If @external_id is
1447 * NULL, this function allocates a unique suffix via @b (by requesting a new
1448 * cookie). If both @sender_id and @external_id are given, @b can be passed as
1451 * Returns: 0 on success, negative error code on failure.
1453 int bus_path_encode_unique(sd_bus
*b
, const char *prefix
, const char *sender_id
, const char *external_id
, char **ret_path
) {
1454 _cleanup_free_
char *sender_label
= NULL
, *external_label
= NULL
;
1455 char external_buf
[DECIMAL_STR_MAX(uint64_t)], *p
;
1458 assert_return(b
|| (sender_id
&& external_id
), -EINVAL
);
1459 assert_return(object_path_is_valid(prefix
), -EINVAL
);
1460 assert_return(ret_path
, -EINVAL
);
1463 r
= sd_bus_get_unique_name(b
, &sender_id
);
1469 xsprintf(external_buf
, "%"PRIu64
, ++b
->cookie
);
1470 external_id
= external_buf
;
1473 sender_label
= bus_label_escape(sender_id
);
1477 external_label
= bus_label_escape(external_id
);
1478 if (!external_label
)
1481 p
= strjoin(prefix
, "/", sender_label
, "/", external_label
);
1490 * bus_path_decode_unique() - decode unique object path
1491 * @path: object path to decode
1492 * @prefix: object path prefix
1493 * @ret_sender: output parameter for sender-id label
1494 * @ret_external: output parameter for external-id label
1496 * This does the reverse of bus_path_encode_unique() (see its description for
1497 * details). Both trailing labels, sender-id and external-id, are unescaped and
1498 * returned in the given output parameters (the caller must free them).
1500 * Note that this function returns 0 if the path does not match the template
1501 * (see bus_path_encode_unique()), 1 if it matched.
1503 * Returns: Negative error code on failure, 0 if the given object path does not
1504 * match the template (return parameters are set to NULL), 1 if it was
1505 * parsed successfully (return parameters contain allocated labels).
1507 int bus_path_decode_unique(const char *path
, const char *prefix
, char **ret_sender
, char **ret_external
) {
1509 char *sender
, *external
;
1511 assert(object_path_is_valid(path
));
1512 assert(object_path_is_valid(prefix
));
1514 assert(ret_external
);
1516 p
= object_path_startswith(path
, prefix
);
1519 *ret_external
= NULL
;
1526 *ret_external
= NULL
;
1530 sender
= bus_label_unescape_n(p
, q
- p
);
1531 external
= bus_label_unescape(q
+ 1);
1532 if (!sender
|| !external
) {
1538 *ret_sender
= sender
;
1539 *ret_external
= external
;
1543 int bus_property_get_rlimit(
1546 const char *interface
,
1547 const char *property
,
1548 sd_bus_message
*reply
,
1550 sd_bus_error
*error
) {
1555 const char *is_soft
;
1561 is_soft
= endswith(property
, "Soft");
1562 rl
= *(struct rlimit
**) userdata
;
1564 x
= is_soft
? rl
->rlim_cur
: rl
->rlim_max
;
1566 struct rlimit buf
= {};
1570 s
= is_soft
? strndupa(property
, is_soft
- property
) : property
;
1572 z
= rlimit_from_string(strstr(s
, "Limit"));
1576 x
= is_soft
? buf
.rlim_cur
: buf
.rlim_max
;
1579 /* rlim_t might have different sizes, let's map
1580 * RLIMIT_INFINITY to (uint64_t) -1, so that it is the same on
1582 u
= x
== RLIM_INFINITY
? (uint64_t) -1 : (uint64_t) x
;
1584 return sd_bus_message_append(reply
, "t", u
);
1587 int bus_track_add_name_many(sd_bus_track
*t
, char **l
) {
1593 /* Continues adding after failure, and returns the first failure. */
1595 STRV_FOREACH(i
, l
) {
1598 k
= sd_bus_track_add_name(t
, *i
);
1599 if (k
< 0 && r
>= 0)