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 #include <sys/socket.h>
24 #include "sd-daemon.h"
30 #include "path-util.h"
33 #include "unit-name.h"
36 #include "bus-error.h"
37 #include "bus-label.h"
38 #include "bus-message.h"
40 #include "bus-internal.h"
42 static int name_owner_change_callback(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
43 sd_event *e = userdata;
55 int bus_async_unregister_and_exit(sd_event *e, sd_bus *bus, const char *name) {
56 _cleanup_free_ char *match = NULL;
64 /* We unregister the name here and then wait for the
65 * NameOwnerChanged signal for this event to arrive before we
66 * quit. We do this in order to make sure that any queued
67 * requests are still processed before we really exit. */
69 r = sd_bus_get_unique_name(bus, &unique);
74 "sender='org.freedesktop.DBus',"
76 "interface='org.freedesktop.DBus',"
77 "member='NameOwnerChanged',"
78 "path='/org/freedesktop/DBus',"
81 "arg2=''", name, unique);
85 r = sd_bus_add_match(bus, NULL, match, name_owner_change_callback, e);
89 r = sd_bus_release_name(bus, name);
96 int bus_event_loop_with_idle(
101 check_idle_t check_idle,
103 bool exiting = false;
113 r = sd_event_get_state(e);
116 if (r == SD_EVENT_FINISHED)
120 idle = check_idle(userdata);
124 r = sd_event_run(e, exiting || !idle ? (uint64_t) -1 : timeout);
128 if (r == 0 && !exiting && idle) {
130 r = sd_bus_try_close(bus);
134 /* Fallback for dbus1 connections: we
135 * unregister the name and wait for the
136 * response to come through for it */
137 if (r == -EOPNOTSUPP) {
139 /* Inform the service manager that we
140 * are going down, so that it will
141 * queue all further start requests,
142 * instead of assuming we are already
144 sd_notify(false, "STOPPING=1");
146 r = bus_async_unregister_and_exit(e, bus, name);
162 r = sd_event_get_exit_code(e, &code);
169 int bus_name_has_owner(sd_bus *c, const char *name, sd_bus_error *error) {
170 _cleanup_bus_message_unref_ sd_bus_message *rep = NULL;
171 int r, has_owner = 0;
176 r = sd_bus_call_method(c,
177 "org.freedesktop.DBus",
178 "/org/freedesktop/dbus",
179 "org.freedesktop.DBus",
188 r = sd_bus_message_read_basic(rep, 'b', &has_owner);
190 return sd_bus_error_set_errno(error, r);
195 static int check_good_user(sd_bus_message *m, uid_t good_user) {
196 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
202 if (good_user == UID_INVALID)
205 r = sd_bus_query_sender_creds(m, SD_BUS_CREDS_EUID, &creds);
209 /* Don't trust augmented credentials for authorization */
210 assert_return((sd_bus_creds_get_augmented_mask(creds) & SD_BUS_CREDS_EUID) == 0, -EPERM);
212 r = sd_bus_creds_get_euid(creds, &sender_uid);
216 return sender_uid == good_user;
220 sd_bus_message *call,
232 /* Tests non-interactively! */
234 r = check_good_user(call, good_user);
238 r = sd_bus_query_sender_privilege(call, capability);
245 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
246 int authorized = false, challenge = false;
249 sender = sd_bus_message_get_sender(call);
253 r = sd_bus_call_method(
255 "org.freedesktop.PolicyKit1",
256 "/org/freedesktop/PolicyKit1/Authority",
257 "org.freedesktop.PolicyKit1.Authority",
258 "CheckAuthorization",
262 "system-bus-name", 1, "name", "s", sender,
269 /* Treat no PK available as access denied */
270 if (sd_bus_error_has_name(e, SD_BUS_ERROR_SERVICE_UNKNOWN)) {
271 sd_bus_error_free(e);
278 r = sd_bus_message_enter_container(reply, 'r', "bba{ss}");
282 r = sd_bus_message_read(reply, "bb", &authorized, &challenge);
290 *_challenge = challenge;
301 typedef struct AsyncPolkitQuery {
302 sd_bus_message *request, *reply;
303 sd_bus_message_handler_t callback;
309 static void async_polkit_query_free(AsyncPolkitQuery *q) {
314 sd_bus_slot_unref(q->slot);
316 if (q->registry && q->request)
317 hashmap_remove(q->registry, q->request);
319 sd_bus_message_unref(q->request);
320 sd_bus_message_unref(q->reply);
325 static int async_polkit_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
326 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
327 AsyncPolkitQuery *q = userdata;
334 q->slot = sd_bus_slot_unref(q->slot);
335 q->reply = sd_bus_message_ref(reply);
337 r = sd_bus_message_rewind(q->request, true);
339 r = sd_bus_reply_method_errno(q->request, r, NULL);
343 r = q->callback(bus, q->request, q->userdata, &error_buffer);
344 r = bus_maybe_reply_error(q->request, r, &error_buffer);
347 async_polkit_query_free(q);
354 int bus_verify_polkit_async(
355 sd_bus_message *call,
361 sd_bus_error *error) {
364 _cleanup_bus_message_unref_ sd_bus_message *pk = NULL;
367 sd_bus_message_handler_t callback;
377 r = check_good_user(call, good_user);
382 q = hashmap_get(*registry, call);
384 int authorized, challenge;
386 /* This is the second invocation of this function, and
387 * there's already a response from polkit, let's
391 if (sd_bus_message_is_method_error(q->reply, NULL)) {
392 const sd_bus_error *e;
394 /* Copy error from polkit reply */
395 e = sd_bus_message_get_error(q->reply);
396 sd_bus_error_copy(error, e);
398 /* Treat no PK available as access denied */
399 if (sd_bus_error_has_name(e, SD_BUS_ERROR_SERVICE_UNKNOWN))
402 return -sd_bus_error_get_errno(e);
405 r = sd_bus_message_enter_container(q->reply, 'r', "bba{ss}");
407 r = sd_bus_message_read(q->reply, "bb", &authorized, &challenge);
416 return sd_bus_error_set(error, SD_BUS_ERROR_INTERACTIVE_AUTHORIZATION_REQUIRED, "Interactive authentication required.");
422 r = sd_bus_query_sender_privilege(call, capability);
429 if (sd_bus_get_current_message(call->bus) != call)
432 callback = sd_bus_get_current_handler(call->bus);
436 userdata = sd_bus_get_current_userdata(call->bus);
438 sender = sd_bus_message_get_sender(call);
442 c = sd_bus_message_get_allow_interactive_authorization(call);
448 r = hashmap_ensure_allocated(registry, NULL);
452 r = sd_bus_message_new_method_call(
455 "org.freedesktop.PolicyKit1",
456 "/org/freedesktop/PolicyKit1/Authority",
457 "org.freedesktop.PolicyKit1.Authority",
458 "CheckAuthorization");
462 r = sd_bus_message_append(
465 "system-bus-name", 1, "name", "s", sender,
473 q = new0(AsyncPolkitQuery, 1);
477 q->request = sd_bus_message_ref(call);
478 q->callback = callback;
479 q->userdata = userdata;
481 r = hashmap_put(*registry, call, q);
483 async_polkit_query_free(q);
487 q->registry = *registry;
489 r = sd_bus_call_async(call->bus, &q->slot, pk, async_polkit_callback, q, 0);
491 async_polkit_query_free(q);
501 void bus_verify_polkit_async_registry_free(Hashmap *registry) {
505 while ((q = hashmap_steal_first(registry)))
506 async_polkit_query_free(q);
508 hashmap_free(registry);
512 int bus_check_peercred(sd_bus *c) {
519 fd = sd_bus_get_fd(c);
523 l = sizeof(struct ucred);
524 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
527 if (l != sizeof(struct ucred))
530 if (ucred.uid != 0 && ucred.uid != geteuid())
536 int bus_open_system_systemd(sd_bus **_bus) {
537 _cleanup_bus_unref_ sd_bus *bus = NULL;
543 return sd_bus_open_system(_bus);
545 /* If we are root and kdbus is not available, then let's talk
546 * directly to the system instance, instead of going via the
550 r = sd_bus_new(&bus);
554 r = sd_bus_set_address(bus, KERNEL_SYSTEM_BUS_ADDRESS);
558 bus->bus_client = true;
560 r = sd_bus_start(bus);
567 bus = sd_bus_unref(bus);
570 r = sd_bus_new(&bus);
574 r = sd_bus_set_address(bus, "unix:path=/run/systemd/private");
578 r = sd_bus_start(bus);
580 return sd_bus_open_system(_bus);
582 r = bus_check_peercred(bus);
592 int bus_open_user_systemd(sd_bus **_bus) {
593 _cleanup_bus_unref_ sd_bus *bus = NULL;
594 _cleanup_free_ char *ee = NULL;
598 /* Try via kdbus first, and then directly */
603 r = sd_bus_new(&bus);
607 if (asprintf(&bus->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid()) < 0)
610 bus->bus_client = true;
612 r = sd_bus_start(bus);
619 bus = sd_bus_unref(bus);
622 e = secure_getenv("XDG_RUNTIME_DIR");
624 return sd_bus_open_user(_bus);
626 ee = bus_address_escape(e);
630 r = sd_bus_new(&bus);
634 bus->address = strjoin("unix:path=", ee, "/systemd/private", NULL);
638 r = sd_bus_start(bus);
640 return sd_bus_open_user(_bus);
642 r = bus_check_peercred(bus);
652 int bus_print_property(const char *name, sd_bus_message *property, bool all) {
654 const char *contents;
660 r = sd_bus_message_peek_type(property, &type, &contents);
666 case SD_BUS_TYPE_STRING: {
669 r = sd_bus_message_read_basic(property, type, &s);
673 if (all || !isempty(s)) {
674 _cleanup_free_ char *escaped = NULL;
676 escaped = xescape(s, "\n");
680 printf("%s=%s\n", name, escaped);
686 case SD_BUS_TYPE_BOOLEAN: {
689 r = sd_bus_message_read_basic(property, type, &b);
693 printf("%s=%s\n", name, yes_no(b));
698 case SD_BUS_TYPE_UINT64: {
701 r = sd_bus_message_read_basic(property, type, &u);
705 /* Yes, heuristics! But we can change this check
706 * should it turn out to not be sufficient */
708 if (endswith(name, "Timestamp")) {
709 char timestamp[FORMAT_TIMESTAMP_MAX], *t;
711 t = format_timestamp(timestamp, sizeof(timestamp), u);
713 printf("%s=%s\n", name, strempty(t));
715 } else if (strstr(name, "USec")) {
716 char timespan[FORMAT_TIMESPAN_MAX];
718 printf("%s=%s\n", name, format_timespan(timespan, sizeof(timespan), u, 0));
720 printf("%s=%llu\n", name, (unsigned long long) u);
725 case SD_BUS_TYPE_INT64: {
728 r = sd_bus_message_read_basic(property, type, &i);
732 printf("%s=%lld\n", name, (long long) i);
737 case SD_BUS_TYPE_UINT32: {
740 r = sd_bus_message_read_basic(property, type, &u);
744 if (strstr(name, "UMask") || strstr(name, "Mode"))
745 printf("%s=%04o\n", name, u);
747 printf("%s=%u\n", name, (unsigned) u);
752 case SD_BUS_TYPE_INT32: {
755 r = sd_bus_message_read_basic(property, type, &i);
759 printf("%s=%i\n", name, (int) i);
763 case SD_BUS_TYPE_DOUBLE: {
766 r = sd_bus_message_read_basic(property, type, &d);
770 printf("%s=%g\n", name, d);
774 case SD_BUS_TYPE_ARRAY:
775 if (streq(contents, "s")) {
779 r = sd_bus_message_enter_container(property, SD_BUS_TYPE_ARRAY, contents);
783 while((r = sd_bus_message_read_basic(property, SD_BUS_TYPE_STRING, &str)) > 0) {
784 _cleanup_free_ char *escaped = NULL;
789 escaped = xescape(str, "\n ");
793 printf("%s%s", first ? "" : " ", escaped);
805 r = sd_bus_message_exit_container(property);
811 } else if (streq(contents, "y")) {
815 r = sd_bus_message_read_array(property, SD_BUS_TYPE_BYTE, (const void**) &u, &n);
824 for (i = 0; i < n; i++)
825 printf("%02x", u[i]);
832 } else if (streq(contents, "u")) {
836 r = sd_bus_message_read_array(property, SD_BUS_TYPE_UINT32, (const void**) &u, &n);
845 for (i = 0; i < n; i++)
846 printf("%08x", u[i]);
860 int bus_print_all_properties(sd_bus *bus, const char *dest, const char *path, char **filter, bool all) {
861 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
862 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
868 r = sd_bus_call_method(bus,
871 "org.freedesktop.DBus.Properties",
879 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
883 while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
885 const char *contents;
887 r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &name);
891 if (!filter || strv_find(filter, name)) {
892 r = sd_bus_message_peek_type(reply, NULL, &contents);
896 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, contents);
900 r = bus_print_property(name, reply, all);
905 printf("%s=[unprintable]\n", name);
906 /* skip what we didn't read */
907 r = sd_bus_message_skip(reply, contents);
912 r = sd_bus_message_exit_container(reply);
916 r = sd_bus_message_skip(reply, "v");
921 r = sd_bus_message_exit_container(reply);
928 r = sd_bus_message_exit_container(reply);
935 int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
936 sd_id128_t *p = userdata;
941 r = sd_bus_message_read_array(m, SD_BUS_TYPE_BYTE, &v, &n);
948 memcpy((*p).bytes, v, n);
955 static int map_basic(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
959 r = sd_bus_message_peek_type(m, &type, NULL);
964 case SD_BUS_TYPE_STRING: {
968 r = sd_bus_message_read_basic(m, type, &s);
975 r = free_and_strdup(p, s);
979 case SD_BUS_TYPE_ARRAY: {
980 _cleanup_strv_free_ char **l = NULL;
981 char ***p = userdata;
983 r = bus_message_read_strv_extend(m, &l);
994 case SD_BUS_TYPE_BOOLEAN: {
998 r = sd_bus_message_read_basic(m, type, &b);
1007 case SD_BUS_TYPE_UINT32: {
1009 uint32_t *p = userdata;
1011 r = sd_bus_message_read_basic(m, type, &u);
1020 case SD_BUS_TYPE_UINT64: {
1022 uint64_t *p = userdata;
1024 r = sd_bus_message_read_basic(m, type, &t);
1040 int bus_message_map_all_properties(
1042 const struct bus_properties_map *map,
1045 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1051 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
1055 while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
1056 const struct bus_properties_map *prop;
1058 const char *contents;
1062 r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member);
1066 for (i = 0, prop = NULL; map[i].member; i++)
1067 if (streq(map[i].member, member)) {
1073 r = sd_bus_message_peek_type(m, NULL, &contents);
1077 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
1081 v = (uint8_t *)userdata + prop->offset;
1083 r = prop->set(sd_bus_message_get_bus(m), member, m, &error, v);
1085 r = map_basic(sd_bus_message_get_bus(m), member, m, &error, v);
1089 r = sd_bus_message_exit_container(m);
1093 r = sd_bus_message_skip(m, "v");
1098 r = sd_bus_message_exit_container(m);
1105 return sd_bus_message_exit_container(m);
1108 int bus_message_map_properties_changed(
1110 const struct bus_properties_map *map,
1114 int r, invalidated, i;
1119 r = bus_message_map_all_properties(m, map, userdata);
1123 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "s");
1128 while ((r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member)) > 0)
1129 for (i = 0; map[i].member; i++)
1130 if (streq(map[i].member, member)) {
1137 r = sd_bus_message_exit_container(m);
1144 int bus_map_all_properties(
1146 const char *destination,
1148 const struct bus_properties_map *map,
1151 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1152 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1156 assert(destination);
1160 r = sd_bus_call_method(
1164 "org.freedesktop.DBus.Properties",
1172 return bus_message_map_all_properties(m, map, userdata);
1175 int bus_open_transport(BusTransport transport, const char *host, bool user, sd_bus **bus) {
1178 assert(transport >= 0);
1179 assert(transport < _BUS_TRANSPORT_MAX);
1182 assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
1183 assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
1185 switch (transport) {
1187 case BUS_TRANSPORT_LOCAL:
1189 r = sd_bus_default_user(bus);
1191 r = sd_bus_default_system(bus);
1195 case BUS_TRANSPORT_REMOTE:
1196 r = sd_bus_open_system_remote(bus, host);
1199 case BUS_TRANSPORT_MACHINE:
1200 r = sd_bus_open_system_machine(bus, host);
1204 assert_not_reached("Hmm, unknown transport type.");
1210 int bus_open_transport_systemd(BusTransport transport, const char *host, bool user, sd_bus **bus) {
1213 assert(transport >= 0);
1214 assert(transport < _BUS_TRANSPORT_MAX);
1217 assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
1218 assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
1220 switch (transport) {
1222 case BUS_TRANSPORT_LOCAL:
1224 r = bus_open_user_systemd(bus);
1226 r = bus_open_system_systemd(bus);
1230 case BUS_TRANSPORT_REMOTE:
1231 r = sd_bus_open_system_remote(bus, host);
1234 case BUS_TRANSPORT_MACHINE:
1235 r = sd_bus_open_system_machine(bus, host);
1239 assert_not_reached("Hmm, unknown transport type.");
1245 int bus_property_get_bool(
1248 const char *interface,
1249 const char *property,
1250 sd_bus_message *reply,
1252 sd_bus_error *error) {
1254 int b = *(bool*) userdata;
1256 return sd_bus_message_append_basic(reply, 'b', &b);
1259 #if __SIZEOF_SIZE_T__ != 8
1260 int bus_property_get_size(
1263 const char *interface,
1264 const char *property,
1265 sd_bus_message *reply,
1267 sd_bus_error *error) {
1269 uint64_t sz = *(size_t*) userdata;
1271 return sd_bus_message_append_basic(reply, 't', &sz);
1275 #if __SIZEOF_LONG__ != 8
1276 int bus_property_get_long(
1279 const char *interface,
1280 const char *property,
1281 sd_bus_message *reply,
1283 sd_bus_error *error) {
1285 int64_t l = *(long*) userdata;
1287 return sd_bus_message_append_basic(reply, 'x', &l);
1290 int bus_property_get_ulong(
1293 const char *interface,
1294 const char *property,
1295 sd_bus_message *reply,
1297 sd_bus_error *error) {
1299 uint64_t ul = *(unsigned long*) userdata;
1301 return sd_bus_message_append_basic(reply, 't', &ul);
1305 int bus_log_parse_error(int r) {
1306 return log_error_errno(r, "Failed to parse bus message: %m");
1309 int bus_log_create_error(int r) {
1310 return log_error_errno(r, "Failed to create bus message: %m");
1313 int bus_parse_unit_info(sd_bus_message *message, UnitInfo *u) {
1319 return sd_bus_message_read(
1334 int bus_maybe_reply_error(sd_bus_message *m, int r, sd_bus_error *error) {
1338 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1339 sd_bus_reply_method_errno(m, r, error);
1341 } else if (sd_bus_error_is_set(error)) {
1342 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1343 sd_bus_reply_method_error(m, error);
1347 log_debug("Failed to process message [type=%s sender=%s path=%s interface=%s member=%s signature=%s]: %s",
1348 bus_message_type_to_string(m->header->type),
1351 strna(m->interface),
1353 strna(m->root_container.signature),
1354 bus_error_message(error, r));
1359 int bus_append_unit_property_assignment(sd_bus_message *m, const char *assignment) {
1360 const char *eq, *field;
1366 eq = strchr(assignment, '=');
1368 log_error("Not an assignment: %s", assignment);
1372 field = strndupa(assignment, eq - assignment);
1375 if (streq(field, "CPUQuota")) {
1379 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, "CPUQuotaPerSecUSec");
1381 return bus_log_create_error(r);
1383 r = sd_bus_message_append(m, "v", "t", USEC_INFINITY);
1385 } else if (endswith(eq, "%")) {
1388 if (sscanf(eq, "%lf%%", &percent) != 1 || percent <= 0) {
1389 log_error("CPU quota '%s' invalid.", eq);
1393 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, "CPUQuotaPerSecUSec");
1395 return bus_log_create_error(r);
1397 r = sd_bus_message_append(m, "v", "t", (usec_t) percent * USEC_PER_SEC / 100);
1399 log_error("CPU quota needs to be in percent.");
1404 return bus_log_create_error(r);
1409 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1411 return bus_log_create_error(r);
1413 if (STR_IN_SET(field,
1414 "CPUAccounting", "MemoryAccounting", "BlockIOAccounting",
1415 "SendSIGHUP", "SendSIGKILL", "WakeSystem", "DefaultDependencies")) {
1417 r = parse_boolean(eq);
1419 log_error("Failed to parse boolean assignment %s.", assignment);
1423 r = sd_bus_message_append(m, "v", "b", r);
1425 } else if (streq(field, "MemoryLimit")) {
1428 r = parse_size(eq, 1024, &bytes);
1430 log_error("Failed to parse bytes specification %s", assignment);
1434 r = sd_bus_message_append(m, "v", "t", (uint64_t) bytes);
1436 } else if (STR_IN_SET(field, "CPUShares", "BlockIOWeight")) {
1439 r = safe_atou64(eq, &u);
1441 log_error("Failed to parse %s value %s.", field, eq);
1445 r = sd_bus_message_append(m, "v", "t", u);
1447 } else if (STR_IN_SET(field, "User", "Group", "DevicePolicy", "KillMode"))
1448 r = sd_bus_message_append(m, "v", "s", eq);
1450 else if (streq(field, "DeviceAllow")) {
1453 r = sd_bus_message_append(m, "v", "a(ss)", 0);
1455 const char *path, *rwm, *e;
1457 e = strchr(eq, ' ');
1459 path = strndupa(eq, e - eq);
1466 if (!path_startswith(path, "/dev")) {
1467 log_error("%s is not a device file in /dev.", path);
1471 r = sd_bus_message_append(m, "v", "a(ss)", 1, path, rwm);
1474 } else if (STR_IN_SET(field, "BlockIOReadBandwidth", "BlockIOWriteBandwidth")) {
1477 r = sd_bus_message_append(m, "v", "a(st)", 0);
1479 const char *path, *bandwidth, *e;
1482 e = strchr(eq, ' ');
1484 path = strndupa(eq, e - eq);
1487 log_error("Failed to parse %s value %s.", field, eq);
1491 if (!path_startswith(path, "/dev")) {
1492 log_error("%s is not a device file in /dev.", path);
1496 r = parse_size(bandwidth, 1000, &bytes);
1498 log_error("Failed to parse byte value %s.", bandwidth);
1502 r = sd_bus_message_append(m, "v", "a(st)", 1, path, (uint64_t) bytes);
1505 } else if (streq(field, "BlockIODeviceWeight")) {
1508 r = sd_bus_message_append(m, "v", "a(st)", 0);
1510 const char *path, *weight, *e;
1513 e = strchr(eq, ' ');
1515 path = strndupa(eq, e - eq);
1518 log_error("Failed to parse %s value %s.", field, eq);
1522 if (!path_startswith(path, "/dev")) {
1523 log_error("%s is not a device file in /dev.", path);
1527 r = safe_atou64(weight, &u);
1529 log_error("Failed to parse %s value %s.", field, weight);
1532 r = sd_bus_message_append(m, "v", "a(st)", path, u);
1535 } else if (rlimit_from_string(field) >= 0) {
1538 if (streq(eq, "infinity"))
1541 r = safe_atou64(eq, &rl);
1543 log_error("Invalid resource limit: %s", eq);
1548 r = sd_bus_message_append(m, "v", "t", rl);
1550 } else if (streq(field, "Nice")) {
1553 r = safe_atoi32(eq, &i);
1555 log_error("Failed to parse %s value %s.", field, eq);
1559 r = sd_bus_message_append(m, "v", "i", i);
1561 } else if (streq(field, "Environment")) {
1563 r = sd_bus_message_append(m, "v", "as", 1, eq);
1565 } else if (streq(field, "KillSignal")) {
1568 sig = signal_from_string_try_harder(eq);
1570 log_error("Failed to parse %s value %s.", field, eq);
1574 r = sd_bus_message_append(m, "v", "i", sig);
1576 } else if (streq(field, "AccuracySec")) {
1579 r = parse_sec(eq, &u);
1581 log_error("Failed to parse %s value %s", field, eq);
1585 r = sd_bus_message_append(m, "v", "t", u);
1588 log_error("Unknown assignment %s.", assignment);
1593 return bus_log_create_error(r);
1598 typedef struct BusWaitForJobs {
1605 sd_bus_slot *slot_job_removed;
1606 sd_bus_slot *slot_disconnected;
1609 static int match_disconnected(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
1613 log_error("Warning! D-Bus connection terminated.");
1619 static int match_job_removed(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
1620 const char *path, *unit, *result;
1621 BusWaitForJobs *d = userdata;
1630 r = sd_bus_message_read(m, "uoss", &id, &path, &unit, &result);
1632 bus_log_parse_error(r);
1636 found = set_remove(d->jobs, (char*) path);
1642 if (!isempty(result))
1643 d->result = strdup(result);
1646 d->name = strdup(unit);
1651 void bus_wait_for_jobs_free(BusWaitForJobs *d) {
1655 set_free_free(d->jobs);
1657 sd_bus_slot_unref(d->slot_disconnected);
1658 sd_bus_slot_unref(d->slot_job_removed);
1660 sd_bus_unref(d->bus);
1668 int bus_wait_for_jobs_new(sd_bus *bus, BusWaitForJobs **ret) {
1669 _cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *d = NULL;
1675 d = new0(BusWaitForJobs, 1);
1679 d->bus = sd_bus_ref(bus);
1681 /* When we are a bus client we match by sender. Direct
1682 * connections OTOH have no initialized sender field, and
1683 * hence we ignore the sender then */
1684 r = sd_bus_add_match(
1686 &d->slot_job_removed,
1689 "sender='org.freedesktop.systemd1',"
1690 "interface='org.freedesktop.systemd1.Manager',"
1691 "member='JobRemoved',"
1692 "path='/org/freedesktop/systemd1'" :
1694 "interface='org.freedesktop.systemd1.Manager',"
1695 "member='JobRemoved',"
1696 "path='/org/freedesktop/systemd1'",
1697 match_job_removed, d);
1701 r = sd_bus_add_match(
1703 &d->slot_disconnected,
1705 "sender='org.freedesktop.DBus.Local',"
1706 "interface='org.freedesktop.DBus.Local',"
1707 "member='Disconnected'",
1708 match_disconnected, d);
1718 static int bus_process_wait(sd_bus *bus) {
1722 r = sd_bus_process(bus, NULL);
1728 r = sd_bus_wait(bus, (uint64_t) -1);
1734 static int bus_job_get_service_result(BusWaitForJobs *d, char **result) {
1735 _cleanup_free_ char *dbus_path = NULL;
1741 dbus_path = unit_dbus_path_from_name(d->name);
1745 return sd_bus_get_property_string(d->bus,
1746 "org.freedesktop.systemd1",
1748 "org.freedesktop.systemd1.Service",
1754 static const struct {
1755 const char *result, *explanation;
1756 } explanations [] = {
1757 { "resources", "a configured resource limit was exceeded" },
1758 { "timeout", "a timeout was exceeded" },
1759 { "exit-code", "the control process exited with error code" },
1760 { "signal", "a fatal signal was delivered to the control process" },
1761 { "core-dump", "a fatal signal was delivered causing the control process to dump core" },
1762 { "watchdog", "the service failed to send watchdog ping" },
1763 { "start-limit", "start of the service was attempted too often" }
1766 static void log_job_error_with_service_result(const char* service, const char *result) {
1767 _cleanup_free_ char *service_shell_quoted = NULL;
1771 service_shell_quoted = shell_maybe_quote(service);
1773 if (!isempty(result)) {
1776 for (i = 0; i < ELEMENTSOF(explanations); ++i)
1777 if (streq(result, explanations[i].result))
1780 if (i < ELEMENTSOF(explanations)) {
1781 log_error("Job for %s failed because %s. See \"systemctl status %s\" and \"journalctl -xe\" for details.\n",
1783 explanations[i].explanation,
1784 strna(service_shell_quoted));
1790 log_error("Job for %s failed. See \"systemctl status %s\" and \"journalctl -xe\" for details.\n",
1792 strna(service_shell_quoted));
1795 /* For some results maybe additional explanation is required */
1796 if (streq_ptr(result, "start-limit"))
1797 log_info("To force a start use \"systemctl reset-failed %1$s\" followed by \"systemctl start %1$s\" again.",
1798 strna(service_shell_quoted));
1801 static int check_wait_response(BusWaitForJobs *d, bool quiet) {
1807 if (streq(d->result, "canceled"))
1808 log_error("Job for %s canceled.", strna(d->name));
1809 else if (streq(d->result, "timeout"))
1810 log_error("Job for %s timed out.", strna(d->name));
1811 else if (streq(d->result, "dependency"))
1812 log_error("A dependency job for %s failed. See 'journalctl -xe' for details.", strna(d->name));
1813 else if (streq(d->result, "invalid"))
1814 log_error("Job for %s invalid.", strna(d->name));
1815 else if (streq(d->result, "assert"))
1816 log_error("Assertion failed on job for %s.", strna(d->name));
1817 else if (streq(d->result, "unsupported"))
1818 log_error("Operation on or unit type of %s not supported on this system.", strna(d->name));
1819 else if (!streq(d->result, "done") && !streq(d->result, "skipped")) {
1822 _cleanup_free_ char *result = NULL;
1824 q = bus_job_get_service_result(d, &result);
1826 log_debug_errno(q, "Failed to get Result property of service %s: %m", d->name);
1828 log_job_error_with_service_result(d->name, result);
1830 log_error("Job failed. See \"journalctl -xe\" for details.");
1834 if (streq(d->result, "canceled"))
1836 else if (streq(d->result, "timeout"))
1838 else if (streq(d->result, "dependency"))
1840 else if (streq(d->result, "invalid"))
1842 else if (streq(d->result, "assert"))
1844 else if (streq(d->result, "unsupported"))
1846 else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
1852 int bus_wait_for_jobs(BusWaitForJobs *d, bool quiet) {
1857 while (!set_isempty(d->jobs)) {
1860 q = bus_process_wait(d->bus);
1862 return log_error_errno(q, "Failed to wait for response: %m");
1865 q = check_wait_response(d, quiet);
1866 /* Return the first error as it is most likely to be
1868 if (q < 0 && r == 0)
1871 log_debug_errno(q, "Got result %s/%m for job %s", strna(d->result), strna(d->name));
1884 int bus_wait_for_jobs_add(BusWaitForJobs *d, const char *path) {
1889 r = set_ensure_allocated(&d->jobs, &string_hash_ops);
1893 return set_put_strdup(d->jobs, path);
1896 int bus_deserialize_and_dump_unit_file_changes(sd_bus_message *m, bool quiet) {
1897 const char *type, *path, *source;
1900 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sss)");
1902 return bus_log_parse_error(r);
1904 while ((r = sd_bus_message_read(m, "(sss)", &type, &path, &source)) > 0) {
1906 if (streq(type, "symlink"))
1907 log_info("Created symlink from %s to %s.", path, source);
1909 log_info("Removed symlink %s.", path);
1913 return bus_log_parse_error(r);
1915 r = sd_bus_message_exit_container(m);
1917 return bus_log_parse_error(r);
1923 * bus_path_encode_unique() - encode unique object path
1924 * @b: bus connection or NULL
1925 * @prefix: object path prefix
1926 * @sender_id: unique-name of client, or NULL
1927 * @external_id: external ID to be chosen by client, or NULL
1928 * @ret_path: storage for encoded object path pointer
1930 * Whenever we provide a bus API that allows clients to create and manage
1931 * server-side objects, we need to provide a unique name for these objects. If
1932 * we let the server choose the name, we suffer from a race condition: If a
1933 * client creates an object asynchronously, it cannot destroy that object until
1934 * it received the method reply. It cannot know the name of the new object,
1935 * thus, it cannot destroy it. Furthermore, it enforces a round-trip.
1937 * Therefore, many APIs allow the client to choose the unique name for newly
1938 * created objects. There're two problems to solve, though:
1939 * 1) Object names are usually defined via dbus object paths, which are
1940 * usually globally namespaced. Therefore, multiple clients must be able
1941 * to choose unique object names without interference.
1942 * 2) If multiple libraries share the same bus connection, they must be
1943 * able to choose unique object names without interference.
1944 * The first problem is solved easily by prefixing a name with the
1945 * unique-bus-name of a connection. The server side must enforce this and
1946 * reject any other name. The second problem is solved by providing unique
1947 * suffixes from within sd-bus.
1949 * This helper allows clients to create unique object-paths. It uses the
1950 * template '/prefix/sender_id/external_id' and returns the new path in
1951 * @ret_path (must be freed by the caller).
1952 * If @sender_id is NULL, the unique-name of @b is used. If @external_id is
1953 * NULL, this function allocates a unique suffix via @b (by requesting a new
1954 * cookie). If both @sender_id and @external_id are given, @b can be passed as
1957 * Returns: 0 on success, negative error code on failure.
1959 int bus_path_encode_unique(sd_bus *b, const char *prefix, const char *sender_id, const char *external_id, char **ret_path) {
1960 _cleanup_free_ char *sender_label = NULL, *external_label = NULL;
1961 char external_buf[DECIMAL_STR_MAX(uint64_t)], *p;
1964 assert_return(b || (sender_id && external_id), -EINVAL);
1965 assert_return(object_path_is_valid(prefix), -EINVAL);
1966 assert_return(ret_path, -EINVAL);
1969 r = sd_bus_get_unique_name(b, &sender_id);
1975 xsprintf(external_buf, "%"PRIu64, ++b->cookie);
1976 external_id = external_buf;
1979 sender_label = bus_label_escape(sender_id);
1983 external_label = bus_label_escape(external_id);
1984 if (!external_label)
1987 p = strjoin(prefix, "/", sender_label, "/", external_label, NULL);
1996 * bus_path_decode_unique() - decode unique object path
1997 * @path: object path to decode
1998 * @prefix: object path prefix
1999 * @ret_sender: output parameter for sender-id label
2000 * @ret_external: output parameter for external-id label
2002 * This does the reverse of bus_path_encode_unique() (see its description for
2003 * details). Both trailing labels, sender-id and external-id, are unescaped and
2004 * returned in the given output parameters (the caller must free them).
2006 * Note that this function returns 0 if the path does not match the template
2007 * (see bus_path_encode_unique()), 1 if it matched.
2009 * Returns: Negative error code on failure, 0 if the given object path does not
2010 * match the template (return parameters are set to NULL), 1 if it was
2011 * parsed successfully (return parameters contain allocated labels).
2013 int bus_path_decode_unique(const char *path, const char *prefix, char **ret_sender, char **ret_external) {
2015 char *sender, *external;
2017 assert(object_path_is_valid(path));
2018 assert(object_path_is_valid(prefix));
2020 assert(ret_external);
2022 p = object_path_startswith(path, prefix);
2025 *ret_external = NULL;
2032 *ret_external = NULL;
2036 sender = bus_label_unescape_n(p, q - p);
2037 external = bus_label_unescape(q + 1);
2038 if (!sender || !external) {
2044 *ret_sender = sender;
2045 *ret_external = external;