]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/shared/bus-unit-util.c
projects / thirdparty / systemd.git / blob
? search:


8b1a353a9b3df512542191e5b7b230d51c3b8f18
[thirdparty/systemd.git] / src / shared / bus-unit-util.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "af-list.h"
4 #include "alloc-util.h"
5 #include "bus-error.h"
6 #include "bus-unit-util.h"
7 #include "bus-util.h"
8 #include "cap-list.h"
9 #include "cgroup-setup.h"
10 #include "cgroup-util.h"
11 #include "condition.h"
12 #include "coredump-util.h"
13 #include "cpu-set-util.h"
14 #include "dissect-image.h"
15 #include "escape.h"
16 #include "exec-util.h"
17 #include "exit-status.h"
18 #include "fileio.h"
19 #include "hexdecoct.h"
20 #include "hostname-util.h"
21 #include "in-addr-util.h"
22 #include "ioprio-util.h"
23 #include "ip-protocol-list.h"
24 #include "libmount-util.h"
25 #include "locale-util.h"
26 #include "log.h"
27 #include "macro.h"
28 #include "missing_fs.h"
29 #include "mountpoint-util.h"
30 #include "nsflags.h"
31 #include "numa-util.h"
32 #include "open-file.h"
33 #include "parse-helpers.h"
34 #include "parse-util.h"
35 #include "path-util.h"
36 #include "percent-util.h"
37 #include "process-util.h"
38 #include "rlimit-util.h"
39 #if HAVE_SECCOMP
40 #include "seccomp-util.h"
41 #endif
42 #include "securebits-util.h"
43 #include "signal-util.h"
44 #include "socket-util.h"
45 #include "sort-util.h"
46 #include "stdio-util.h"
47 #include "string-util.h"
48 #include "syslog-util.h"
49 #include "terminal-util.h"
50 #include "unit-def.h"
51 #include "user-util.h"
52 #include "utf8.h"
53
54 int bus_parse_unit_info(sd_bus_message *message, UnitInfo *u) {
55 assert(message);
56 assert(u);
57
58 u->machine = NULL;
59
60 return sd_bus_message_read(
61 message,
62 "(ssssssouso)",
63 &u->id,
64 &u->description,
65 &u->load_state,
66 &u->active_state,
67 &u->sub_state,
68 &u->following,
69 &u->unit_path,
70 &u->job_id,
71 &u->job_type,
72 &u->job_path);
73 }
74
75 #define DEFINE_BUS_APPEND_PARSE_PTR(bus_type, cast_type, type, parse_func) \
76 static int bus_append_##parse_func( \
77 sd_bus_message *m, \
78 const char *field, \
79 const char *eq) { \
80 type val; \
81 int r; \
82 \
83 r = parse_func(eq, &val); \
84 if (r < 0) \
85 return log_error_errno(r, "Failed to parse %s=%s: %m", field, eq); \
86 \
87 r = sd_bus_message_append(m, "(sv)", field, \
88 bus_type, (cast_type) val); \
89 if (r < 0) \
90 return bus_log_create_error(r); \
91 \
92 return 1; \
93 }
94
95 #define DEFINE_BUS_APPEND_PARSE(bus_type, parse_func) \
96 static int bus_append_##parse_func( \
97 sd_bus_message *m, \
98 const char *field, \
99 const char *eq) { \
100 int r; \
101 \
102 r = parse_func(eq); \
103 if (r < 0) \
104 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s: %s", field, eq); \
105 \
106 r = sd_bus_message_append(m, "(sv)", field, \
107 bus_type, (int32_t) r); \
108 if (r < 0) \
109 return bus_log_create_error(r); \
110 \
111 return 1; \
112 }
113
114 DEFINE_BUS_APPEND_PARSE("b", parse_boolean);
115 DEFINE_BUS_APPEND_PARSE("i", ioprio_class_from_string);
116 DEFINE_BUS_APPEND_PARSE("i", ip_tos_from_string);
117 DEFINE_BUS_APPEND_PARSE("i", log_facility_unshifted_from_string);
118 DEFINE_BUS_APPEND_PARSE("i", log_level_from_string);
119 #if !HAVE_SECCOMP
120 static inline int seccomp_parse_errno_or_action(const char *eq) { return -EINVAL; }
121 #endif
122 DEFINE_BUS_APPEND_PARSE("i", seccomp_parse_errno_or_action);
123 DEFINE_BUS_APPEND_PARSE("i", sched_policy_from_string);
124 DEFINE_BUS_APPEND_PARSE("i", secure_bits_from_string);
125 DEFINE_BUS_APPEND_PARSE("i", signal_from_string);
126 DEFINE_BUS_APPEND_PARSE("i", parse_ip_protocol);
127 DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, ioprio_parse_priority);
128 DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, parse_nice);
129 DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, safe_atoi);
130 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, nsec_t, parse_nsec);
131 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_blkio_weight_parse);
132 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_cpu_shares_parse);
133 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_weight_parse);
134 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_cpu_weight_parse);
135 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, unsigned long, mount_propagation_flag_from_string);
136 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, safe_atou64);
137 DEFINE_BUS_APPEND_PARSE_PTR("u", uint32_t, mode_t, parse_mode);
138 DEFINE_BUS_APPEND_PARSE_PTR("u", uint32_t, unsigned, safe_atou);
139 DEFINE_BUS_APPEND_PARSE_PTR("x", int64_t, int64_t, safe_atoi64);
140 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, coredump_filter_mask_from_string);
141
142 static int bus_append_string(sd_bus_message *m, const char *field, const char *eq) {
143 int r;
144
145 r = sd_bus_message_append(m, "(sv)", field, "s", eq);
146 if (r < 0)
147 return bus_log_create_error(r);
148
149 return 1;
150 }
151
152 static int bus_append_strv(sd_bus_message *m, const char *field, const char *eq, ExtractFlags flags) {
153 const char *p;
154 int r;
155
156 r = sd_bus_message_open_container(m, 'r', "sv");
157 if (r < 0)
158 return bus_log_create_error(r);
159
160 r = sd_bus_message_append_basic(m, 's', field);
161 if (r < 0)
162 return bus_log_create_error(r);
163
164 r = sd_bus_message_open_container(m, 'v', "as");
165 if (r < 0)
166 return bus_log_create_error(r);
167
168 r = sd_bus_message_open_container(m, 'a', "s");
169 if (r < 0)
170 return bus_log_create_error(r);
171
172 for (p = eq;;) {
173 _cleanup_free_ char *word = NULL;
174
175 r = extract_first_word(&p, &word, NULL, flags);
176 if (r == 0)
177 break;
178 if (r == -ENOMEM)
179 return log_oom();
180 if (r < 0)
181 return log_error_errno(r, "Invalid syntax: %s", eq);
182
183 r = sd_bus_message_append_basic(m, 's', word);
184 if (r < 0)
185 return bus_log_create_error(r);
186 }
187
188 r = sd_bus_message_close_container(m);
189 if (r < 0)
190 return bus_log_create_error(r);
191
192 r = sd_bus_message_close_container(m);
193 if (r < 0)
194 return bus_log_create_error(r);
195
196 r = sd_bus_message_close_container(m);
197 if (r < 0)
198 return bus_log_create_error(r);
199
200 return 1;
201 }
202
203 static int bus_append_byte_array(sd_bus_message *m, const char *field, const void *buf, size_t n) {
204 int r;
205
206 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
207 if (r < 0)
208 return bus_log_create_error(r);
209
210 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
211 if (r < 0)
212 return bus_log_create_error(r);
213
214 r = sd_bus_message_open_container(m, 'v', "ay");
215 if (r < 0)
216 return bus_log_create_error(r);
217
218 r = sd_bus_message_append_array(m, 'y', buf, n);
219 if (r < 0)
220 return bus_log_create_error(r);
221
222 r = sd_bus_message_close_container(m);
223 if (r < 0)
224 return bus_log_create_error(r);
225
226 r = sd_bus_message_close_container(m);
227 if (r < 0)
228 return bus_log_create_error(r);
229
230 return 1;
231 }
232
233 static int bus_append_parse_sec_rename(sd_bus_message *m, const char *field, const char *eq) {
234 char *n;
235 usec_t t;
236 size_t l;
237 int r;
238
239 r = parse_sec(eq, &t);
240 if (r < 0)
241 return log_error_errno(r, "Failed to parse %s=%s: %m", field, eq);
242
243 l = strlen(field);
244 n = newa(char, l + 2);
245 /* Change suffix Sec → USec */
246 strcpy(mempcpy(n, field, l - 3), "USec");
247
248 r = sd_bus_message_append(m, "(sv)", n, "t", t);
249 if (r < 0)
250 return bus_log_create_error(r);
251
252 return 1;
253 }
254
255 static int bus_append_parse_size(sd_bus_message *m, const char *field, const char *eq, uint64_t base) {
256 uint64_t v;
257 int r;
258
259 r = parse_size(eq, base, &v);
260 if (r < 0)
261 return log_error_errno(r, "Failed to parse %s=%s: %m", field, eq);
262
263 r = sd_bus_message_append(m, "(sv)", field, "t", v);
264 if (r < 0)
265 return bus_log_create_error(r);
266
267 return 1;
268 }
269
270 static int bus_append_exec_command(sd_bus_message *m, const char *field, const char *eq) {
271 bool explicit_path = false, done = false;
272 _cleanup_strv_free_ char **l = NULL, **ex_opts = NULL;
273 _cleanup_free_ char *path = NULL, *upgraded_name = NULL;
274 ExecCommandFlags flags = 0;
275 bool is_ex_prop = endswith(field, "Ex");
276 int r;
277
278 do {
279 switch (*eq) {
280
281 case '-':
282 if (FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE))
283 done = true;
284 else {
285 flags |= EXEC_COMMAND_IGNORE_FAILURE;
286 eq++;
287 }
288 break;
289
290 case '@':
291 if (explicit_path)
292 done = true;
293 else {
294 explicit_path = true;
295 eq++;
296 }
297 break;
298
299 case ':':
300 if (FLAGS_SET(flags, EXEC_COMMAND_NO_ENV_EXPAND))
301 done = true;
302 else {
303 flags |= EXEC_COMMAND_NO_ENV_EXPAND;
304 eq++;
305 }
306 break;
307
308 case '+':
309 if (flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_AMBIENT_MAGIC))
310 done = true;
311 else {
312 flags |= EXEC_COMMAND_FULLY_PRIVILEGED;
313 eq++;
314 }
315 break;
316
317 case '!':
318 if (flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_AMBIENT_MAGIC))
319 done = true;
320 else if (FLAGS_SET(flags, EXEC_COMMAND_NO_SETUID)) {
321 flags &= ~EXEC_COMMAND_NO_SETUID;
322 flags |= EXEC_COMMAND_AMBIENT_MAGIC;
323 eq++;
324 } else {
325 flags |= EXEC_COMMAND_NO_SETUID;
326 eq++;
327 }
328 break;
329
330 default:
331 done = true;
332 break;
333 }
334 } while (!done);
335
336 if (!is_ex_prop && (flags & (EXEC_COMMAND_NO_ENV_EXPAND|EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_AMBIENT_MAGIC))) {
337 /* Upgrade the ExecXYZ= property to ExecXYZEx= for convenience */
338 is_ex_prop = true;
339 upgraded_name = strjoin(field, "Ex");
340 if (!upgraded_name)
341 return log_oom();
342 }
343
344 if (is_ex_prop) {
345 r = exec_command_flags_to_strv(flags, &ex_opts);
346 if (r < 0)
347 return log_error_errno(r, "Failed to convert ExecCommandFlags to strv: %m");
348 }
349
350 if (explicit_path) {
351 r = extract_first_word(&eq, &path, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE);
352 if (r < 0)
353 return log_error_errno(r, "Failed to parse path: %m");
354 }
355
356 r = strv_split_full(&l, eq, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE);
357 if (r < 0)
358 return log_error_errno(r, "Failed to parse command line: %m");
359
360 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
361 if (r < 0)
362 return bus_log_create_error(r);
363
364 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, upgraded_name ?: field);
365 if (r < 0)
366 return bus_log_create_error(r);
367
368 r = sd_bus_message_open_container(m, 'v', is_ex_prop ? "a(sasas)" : "a(sasb)");
369 if (r < 0)
370 return bus_log_create_error(r);
371
372 r = sd_bus_message_open_container(m, 'a', is_ex_prop ? "(sasas)" : "(sasb)");
373 if (r < 0)
374 return bus_log_create_error(r);
375
376 if (!strv_isempty(l)) {
377
378 r = sd_bus_message_open_container(m, 'r', is_ex_prop ? "sasas" : "sasb");
379 if (r < 0)
380 return bus_log_create_error(r);
381
382 r = sd_bus_message_append(m, "s", path ?: l[0]);
383 if (r < 0)
384 return bus_log_create_error(r);
385
386 r = sd_bus_message_append_strv(m, l);
387 if (r < 0)
388 return bus_log_create_error(r);
389
390 r = is_ex_prop ? sd_bus_message_append_strv(m, ex_opts) : sd_bus_message_append(m, "b", FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE));
391 if (r < 0)
392 return bus_log_create_error(r);
393
394 r = sd_bus_message_close_container(m);
395 if (r < 0)
396 return bus_log_create_error(r);
397 }
398
399 r = sd_bus_message_close_container(m);
400 if (r < 0)
401 return bus_log_create_error(r);
402
403 r = sd_bus_message_close_container(m);
404 if (r < 0)
405 return bus_log_create_error(r);
406
407 r = sd_bus_message_close_container(m);
408 if (r < 0)
409 return bus_log_create_error(r);
410
411 return 1;
412 }
413
414 static int bus_append_open_file(sd_bus_message *m, const char *field, const char *eq) {
415 _cleanup_(open_file_freep) OpenFile *of = NULL;
416 int r;
417
418 assert(m);
419
420 r = open_file_parse(eq, &of);
421 if (r < 0)
422 return log_error_errno(r, "Failed to parse OpenFile= setting: %m");
423
424 r = sd_bus_message_append(m, "(sv)", field, "a(sst)", (size_t) 1, of->path, of->fdname, of->flags);
425 if (r < 0)
426 return bus_log_create_error(r);
427
428 return 1;
429 }
430
431 static int bus_append_ip_address_access(sd_bus_message *m, int family, const union in_addr_union *prefix, unsigned char prefixlen) {
432 int r;
433
434 assert(m);
435 assert(prefix);
436
437 r = sd_bus_message_open_container(m, 'r', "iayu");
438 if (r < 0)
439 return r;
440
441 r = sd_bus_message_append(m, "i", family);
442 if (r < 0)
443 return r;
444
445 r = sd_bus_message_append_array(m, 'y', prefix, FAMILY_ADDRESS_SIZE(family));
446 if (r < 0)
447 return r;
448
449 r = sd_bus_message_append(m, "u", prefixlen);
450 if (r < 0)
451 return r;
452
453 return sd_bus_message_close_container(m);
454 }
455
456 static int bus_append_cgroup_property(sd_bus_message *m, const char *field, const char *eq) {
457 int r;
458
459 if (STR_IN_SET(field, "DevicePolicy",
460 "Slice",
461 "ManagedOOMSwap",
462 "ManagedOOMMemoryPressure",
463 "ManagedOOMPreference",
464 "MemoryPressureWatch",
465 "DelegateSubgroup"))
466 return bus_append_string(m, field, eq);
467
468 if (STR_IN_SET(field, "ManagedOOMMemoryPressureLimit")) {
469 r = parse_permyriad(eq);
470 if (r < 0)
471 return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
472
473 /* Pass around scaled to 2^32-1 == 100% */
474 r = sd_bus_message_append(m, "(sv)", field, "u", UINT32_SCALE_FROM_PERMYRIAD(r));
475 if (r < 0)
476 return bus_log_create_error(r);
477
478 return 1;
479 }
480
481 if (STR_IN_SET(field, "CPUAccounting",
482 "MemoryAccounting",
483 "IOAccounting",
484 "BlockIOAccounting",
485 "TasksAccounting",
486 "IPAccounting"))
487 return bus_append_parse_boolean(m, field, eq);
488
489 if (STR_IN_SET(field, "CPUWeight",
490 "StartupCPUWeight"))
491 return bus_append_cg_cpu_weight_parse(m, field, eq);
492
493 if (STR_IN_SET(field, "IOWeight",
494 "StartupIOWeight"))
495 return bus_append_cg_weight_parse(m, field, eq);
496
497 if (STR_IN_SET(field, "CPUShares",
498 "StartupCPUShares"))
499 return bus_append_cg_cpu_shares_parse(m, field, eq);
500
501 if (STR_IN_SET(field, "AllowedCPUs",
502 "StartupAllowedCPUs",
503 "AllowedMemoryNodes",
504 "StartupAllowedMemoryNodes")) {
505 _cleanup_(cpu_set_reset) CPUSet cpuset = {};
506 _cleanup_free_ uint8_t *array = NULL;
507 size_t allocated;
508
509 r = parse_cpu_set(eq, &cpuset);
510 if (r < 0)
511 return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
512
513 r = cpu_set_to_dbus(&cpuset, &array, &allocated);
514 if (r < 0)
515 return log_error_errno(r, "Failed to serialize CPUSet: %m");
516
517 return bus_append_byte_array(m, field, array, allocated);
518 }
519
520 if (STR_IN_SET(field, "BlockIOWeight",
521 "StartupBlockIOWeight"))
522 return bus_append_cg_blkio_weight_parse(m, field, eq);
523
524 if (streq(field, "DisableControllers"))
525 return bus_append_strv(m, "DisableControllers", eq, EXTRACT_UNQUOTE);
526
527 if (streq(field, "Delegate")) {
528 r = parse_boolean(eq);
529 if (r < 0)
530 return bus_append_strv(m, "DelegateControllers", eq, EXTRACT_UNQUOTE);
531
532 r = sd_bus_message_append(m, "(sv)", "Delegate", "b", r);
533 if (r < 0)
534 return bus_log_create_error(r);
535
536 return 1;
537 }
538
539 if (STR_IN_SET(field, "MemoryMin",
540 "DefaultMemoryLow",
541 "DefaultMemoryMin",
542 "MemoryLow",
543 "MemoryHigh",
544 "MemoryMax",
545 "MemorySwapMax",
546 "MemoryZSwapMax",
547 "MemoryLimit",
548 "TasksMax")) {
549
550 if (streq(eq, "infinity")) {
551 r = sd_bus_message_append(m, "(sv)", field, "t", CGROUP_LIMIT_MAX);
552 if (r < 0)
553 return bus_log_create_error(r);
554 return 1;
555 } else if (isempty(eq)) {
556 uint64_t empty_value = STR_IN_SET(field,
557 "DefaultMemoryLow",
558 "DefaultMemoryMin",
559 "MemoryLow",
560 "MemoryMin") ?
561 CGROUP_LIMIT_MIN :
562 CGROUP_LIMIT_MAX;
563
564 r = sd_bus_message_append(m, "(sv)", field, "t", empty_value);
565 if (r < 0)
566 return bus_log_create_error(r);
567 return 1;
568 }
569
570 r = parse_permyriad(eq);
571 if (r >= 0) {
572 char *n;
573
574 /* When this is a percentage we'll convert this into a relative value in the range 0…UINT32_MAX
575 * and pass it in the MemoryLowScale property (and related ones). This way the physical memory
576 * size can be determined server-side. */
577
578 n = strjoina(field, "Scale");
579 r = sd_bus_message_append(m, "(sv)", n, "u", UINT32_SCALE_FROM_PERMYRIAD(r));
580 if (r < 0)
581 return bus_log_create_error(r);
582
583 return 1;
584 }
585
586 if (streq(field, "TasksMax"))
587 return bus_append_safe_atou64(m, field, eq);
588
589 return bus_append_parse_size(m, field, eq, 1024);
590 }
591
592 if (streq(field, "CPUQuota")) {
593 if (isempty(eq))
594 r = sd_bus_message_append(m, "(sv)", "CPUQuotaPerSecUSec", "t", USEC_INFINITY);
595 else {
596 r = parse_permyriad_unbounded(eq);
597 if (r == 0)
598 return log_error_errno(SYNTHETIC_ERRNO(ERANGE),
599 "CPU quota too small.");
600 if (r < 0)
601 return log_error_errno(r, "CPU quota '%s' invalid.", eq);
602
603 r = sd_bus_message_append(m, "(sv)", "CPUQuotaPerSecUSec", "t", (((uint64_t) r * USEC_PER_SEC) / 10000U));
604 }
605
606 if (r < 0)
607 return bus_log_create_error(r);
608
609 return 1;
610 }
611
612 if (streq(field, "CPUQuotaPeriodSec")) {
613 usec_t u = USEC_INFINITY;
614
615 r = parse_sec_def_infinity(eq, &u);
616 if (r < 0)
617 return log_error_errno(r, "CPU quota period '%s' invalid.", eq);
618
619 r = sd_bus_message_append(m, "(sv)", "CPUQuotaPeriodUSec", "t", u);
620 if (r < 0)
621 return bus_log_create_error(r);
622
623 return 1;
624 }
625
626 if (streq(field, "DeviceAllow")) {
627 if (isempty(eq))
628 r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 0);
629 else {
630 const char *path = eq, *rwm = NULL, *e;
631
632 e = strchr(eq, ' ');
633 if (e) {
634 path = strndupa_safe(eq, e - eq);
635 rwm = e+1;
636 }
637
638 r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 1, path, strempty(rwm));
639 }
640
641 if (r < 0)
642 return bus_log_create_error(r);
643
644 return 1;
645 }
646
647 if (cgroup_io_limit_type_from_string(field) >= 0 || STR_IN_SET(field, "BlockIOReadBandwidth", "BlockIOWriteBandwidth")) {
648 if (isempty(eq))
649 r = sd_bus_message_append(m, "(sv)", field, "a(st)", 0);
650 else {
651 const char *path, *bandwidth, *e;
652 uint64_t bytes;
653
654 e = strchr(eq, ' ');
655 if (!e)
656 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
657 "Failed to parse %s value %s.",
658 field, eq);
659
660 path = strndupa_safe(eq, e - eq);
661 bandwidth = e+1;
662
663 if (streq(bandwidth, "infinity"))
664 bytes = CGROUP_LIMIT_MAX;
665 else {
666 r = parse_size(bandwidth, 1000, &bytes);
667 if (r < 0)
668 return log_error_errno(r, "Failed to parse byte value %s: %m", bandwidth);
669 }
670
671 r = sd_bus_message_append(m, "(sv)", field, "a(st)", 1, path, bytes);
672 }
673
674 if (r < 0)
675 return bus_log_create_error(r);
676
677 return 1;
678 }
679
680 if (STR_IN_SET(field, "IODeviceWeight",
681 "BlockIODeviceWeight")) {
682 if (isempty(eq))
683 r = sd_bus_message_append(m, "(sv)", field, "a(st)", 0);
684 else {
685 const char *path, *weight, *e;
686 uint64_t u;
687
688 e = strchr(eq, ' ');
689 if (!e)
690 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
691 "Failed to parse %s value %s.",
692 field, eq);
693
694 path = strndupa_safe(eq, e - eq);
695 weight = e+1;
696
697 r = safe_atou64(weight, &u);
698 if (r < 0)
699 return log_error_errno(r, "Failed to parse %s value %s: %m", field, weight);
700
701 r = sd_bus_message_append(m, "(sv)", field, "a(st)", 1, path, u);
702 }
703
704 if (r < 0)
705 return bus_log_create_error(r);
706
707 return 1;
708 }
709
710 if (streq(field, "IODeviceLatencyTargetSec")) {
711 const char *field_usec = "IODeviceLatencyTargetUSec";
712
713 if (isempty(eq))
714 r = sd_bus_message_append(m, "(sv)", field_usec, "a(st)", USEC_INFINITY);
715 else {
716 const char *path, *target, *e;
717 usec_t usec;
718
719 e = strchr(eq, ' ');
720 if (!e)
721 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
722 "Failed to parse %s value %s.",
723 field, eq);
724
725 path = strndupa_safe(eq, e - eq);
726 target = e+1;
727
728 r = parse_sec(target, &usec);
729 if (r < 0)
730 return log_error_errno(r, "Failed to parse %s value %s: %m", field, target);
731
732 r = sd_bus_message_append(m, "(sv)", field_usec, "a(st)", 1, path, usec);
733 }
734
735 if (r < 0)
736 return bus_log_create_error(r);
737
738 return 1;
739 }
740
741 if (STR_IN_SET(field, "IPAddressAllow",
742 "IPAddressDeny")) {
743 unsigned char prefixlen;
744 union in_addr_union prefix = {};
745 int family;
746
747 if (isempty(eq)) {
748 r = sd_bus_message_append(m, "(sv)", field, "a(iayu)", 0);
749 if (r < 0)
750 return bus_log_create_error(r);
751
752 return 1;
753 }
754
755 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
756 if (r < 0)
757 return bus_log_create_error(r);
758
759 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
760 if (r < 0)
761 return bus_log_create_error(r);
762
763 r = sd_bus_message_open_container(m, 'v', "a(iayu)");
764 if (r < 0)
765 return bus_log_create_error(r);
766
767 r = sd_bus_message_open_container(m, 'a', "(iayu)");
768 if (r < 0)
769 return bus_log_create_error(r);
770
771 if (streq(eq, "any")) {
772 /* "any" is a shortcut for 0.0.0.0/0 and ::/0 */
773
774 r = bus_append_ip_address_access(m, AF_INET, &prefix, 0);
775 if (r < 0)
776 return bus_log_create_error(r);
777
778 r = bus_append_ip_address_access(m, AF_INET6, &prefix, 0);
779 if (r < 0)
780 return bus_log_create_error(r);
781
782 } else if (is_localhost(eq)) {
783 /* "localhost" is a shortcut for 127.0.0.0/8 and ::1/128 */
784
785 prefix.in.s_addr = htobe32(0x7f000000);
786 r = bus_append_ip_address_access(m, AF_INET, &prefix, 8);
787 if (r < 0)
788 return bus_log_create_error(r);
789
790 prefix.in6 = (struct in6_addr) IN6ADDR_LOOPBACK_INIT;
791 r = bus_append_ip_address_access(m, AF_INET6, &prefix, 128);
792 if (r < 0)
793 return r;
794
795 } else if (streq(eq, "link-local")) {
796 /* "link-local" is a shortcut for 169.254.0.0/16 and fe80::/64 */
797
798 prefix.in.s_addr = htobe32((UINT32_C(169) << 24 | UINT32_C(254) << 16));
799 r = bus_append_ip_address_access(m, AF_INET, &prefix, 16);
800 if (r < 0)
801 return bus_log_create_error(r);
802
803 prefix.in6 = (struct in6_addr) {
804 .s6_addr32[0] = htobe32(0xfe800000)
805 };
806 r = bus_append_ip_address_access(m, AF_INET6, &prefix, 64);
807 if (r < 0)
808 return bus_log_create_error(r);
809
810 } else if (streq(eq, "multicast")) {
811 /* "multicast" is a shortcut for 224.0.0.0/4 and ff00::/8 */
812
813 prefix.in.s_addr = htobe32((UINT32_C(224) << 24));
814 r = bus_append_ip_address_access(m, AF_INET, &prefix, 4);
815 if (r < 0)
816 return bus_log_create_error(r);
817
818 prefix.in6 = (struct in6_addr) {
819 .s6_addr32[0] = htobe32(0xff000000)
820 };
821 r = bus_append_ip_address_access(m, AF_INET6, &prefix, 8);
822 if (r < 0)
823 return bus_log_create_error(r);
824
825 } else {
826 for (;;) {
827 _cleanup_free_ char *word = NULL;
828
829 r = extract_first_word(&eq, &word, NULL, 0);
830 if (r == 0)
831 break;
832 if (r == -ENOMEM)
833 return log_oom();
834 if (r < 0)
835 return log_error_errno(r, "Failed to parse %s: %s", field, eq);
836
837 r = in_addr_prefix_from_string_auto(word, &family, &prefix, &prefixlen);
838 if (r < 0)
839 return log_error_errno(r, "Failed to parse IP address prefix: %s", word);
840
841 r = bus_append_ip_address_access(m, family, &prefix, prefixlen);
842 if (r < 0)
843 return bus_log_create_error(r);
844 }
845 }
846
847 r = sd_bus_message_close_container(m);
848 if (r < 0)
849 return bus_log_create_error(r);
850
851 r = sd_bus_message_close_container(m);
852 if (r < 0)
853 return bus_log_create_error(r);
854
855 r = sd_bus_message_close_container(m);
856 if (r < 0)
857 return bus_log_create_error(r);
858
859 return 1;
860 }
861
862 if (STR_IN_SET(field, "IPIngressFilterPath",
863 "IPEgressFilterPath")) {
864 if (isempty(eq))
865 r = sd_bus_message_append(m, "(sv)", field, "as", 0);
866 else
867 r = sd_bus_message_append(m, "(sv)", field, "as", 1, eq);
868
869 if (r < 0)
870 return bus_log_create_error(r);
871
872 return 1;
873 }
874
875 if (streq(field, "BPFProgram")) {
876 if (isempty(eq))
877 r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 0);
878 else {
879 _cleanup_free_ char *word = NULL;
880
881 r = extract_first_word(&eq, &word, ":", 0);
882 if (r == -ENOMEM)
883 return log_oom();
884 if (r < 0)
885 return log_error_errno(r, "Failed to parse %s: %m", field);
886
887 r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 1, word, eq);
888 }
889 if (r < 0)
890 return bus_log_create_error(r);
891
892 return 1;
893 }
894
895 if (STR_IN_SET(field, "SocketBindAllow",
896 "SocketBindDeny")) {
897 if (isempty(eq))
898 r = sd_bus_message_append(m, "(sv)", field, "a(iiqq)", 0);
899 else {
900 int32_t family, ip_protocol;
901 uint16_t nr_ports, port_min;
902
903 r = parse_socket_bind_item(eq, &family, &ip_protocol, &nr_ports, &port_min);
904 if (r == -ENOMEM)
905 return log_oom();
906 if (r < 0)
907 return log_error_errno(r, "Failed to parse %s", field);
908
909 r = sd_bus_message_append(
910 m, "(sv)", field, "a(iiqq)", 1, family, ip_protocol, nr_ports, port_min);
911 }
912 if (r < 0)
913 return bus_log_create_error(r);
914
915 return 1;
916 }
917
918 if (streq(field, "MemoryPressureThresholdSec"))
919 return bus_append_parse_sec_rename(m, field, eq);
920
921 return 0;
922 }
923
924 static int bus_append_automount_property(sd_bus_message *m, const char *field, const char *eq) {
925 if (STR_IN_SET(field, "Where",
926 "ExtraOptions"))
927 return bus_append_string(m, field, eq);
928
929 if (streq(field, "DirectoryMode"))
930 return bus_append_parse_mode(m, field, eq);
931
932 if (streq(field, "TimeoutIdleSec"))
933 return bus_append_parse_sec_rename(m, field, eq);
934
935 return 0;
936 }
937
938 static int bus_append_execute_property(sd_bus_message *m, const char *field, const char *eq) {
939 const char *suffix;
940 int r;
941
942 if (STR_IN_SET(field, "User",
943 "Group",
944 "UtmpIdentifier",
945 "UtmpMode",
946 "PAMName",
947 "TTYPath",
948 "WorkingDirectory",
949 "RootDirectory",
950 "SyslogIdentifier",
951 "ProtectSystem",
952 "ProtectHome",
953 "SELinuxContext",
954 "RootImage",
955 "RootVerity",
956 "RuntimeDirectoryPreserve",
957 "Personality",
958 "KeyringMode",
959 "ProtectProc",
960 "ProcSubset",
961 "NetworkNamespacePath",
962 "IPCNamespacePath",
963 "LogNamespace",
964 "RootImagePolicy",
965 "MountImagePolicy",
966 "ExtensionImagePolicy"))
967 return bus_append_string(m, field, eq);
968
969 if (STR_IN_SET(field, "IgnoreSIGPIPE",
970 "TTYVHangup",
971 "TTYReset",
972 "TTYVTDisallocate",
973 "PrivateTmp",
974 "PrivateDevices",
975 "PrivateNetwork",
976 "PrivateUsers",
977 "PrivateMounts",
978 "PrivateIPC",
979 "NoNewPrivileges",
980 "SyslogLevelPrefix",
981 "MemoryDenyWriteExecute",
982 "RestrictRealtime",
983 "DynamicUser",
984 "RemoveIPC",
985 "ProtectKernelTunables",
986 "ProtectKernelModules",
987 "ProtectKernelLogs",
988 "ProtectClock",
989 "ProtectControlGroups",
990 "MountAPIVFS",
991 "CPUSchedulingResetOnFork",
992 "LockPersonality",
993 "ProtectHostname",
994 "MemoryKSM",
995 "RestrictSUIDSGID"))
996 return bus_append_parse_boolean(m, field, eq);
997
998 if (STR_IN_SET(field, "ReadWriteDirectories",
999 "ReadOnlyDirectories",
1000 "InaccessibleDirectories",
1001 "ReadWritePaths",
1002 "ReadOnlyPaths",
1003 "InaccessiblePaths",
1004 "ExecPaths",
1005 "NoExecPaths",
1006 "ExecSearchPath",
1007 "ExtensionDirectories",
1008 "ConfigurationDirectory",
1009 "SupplementaryGroups",
1010 "SystemCallArchitectures"))
1011 return bus_append_strv(m, field, eq, EXTRACT_UNQUOTE);
1012
1013 if (STR_IN_SET(field, "SyslogLevel",
1014 "LogLevelMax"))
1015 return bus_append_log_level_from_string(m, field, eq);
1016
1017 if (streq(field, "SyslogFacility"))
1018 return bus_append_log_facility_unshifted_from_string(m, field, eq);
1019
1020 if (streq(field, "SecureBits"))
1021 return bus_append_secure_bits_from_string(m, field, eq);
1022
1023 if (streq(field, "CPUSchedulingPolicy"))
1024 return bus_append_sched_policy_from_string(m, field, eq);
1025
1026 if (STR_IN_SET(field, "CPUSchedulingPriority",
1027 "OOMScoreAdjust"))
1028 return bus_append_safe_atoi(m, field, eq);
1029
1030 if (streq(field, "CoredumpFilter"))
1031 return bus_append_coredump_filter_mask_from_string(m, field, eq);
1032
1033 if (streq(field, "Nice"))
1034 return bus_append_parse_nice(m, field, eq);
1035
1036 if (streq(field, "SystemCallErrorNumber"))
1037 return bus_append_seccomp_parse_errno_or_action(m, field, eq);
1038
1039 if (streq(field, "IOSchedulingClass"))
1040 return bus_append_ioprio_class_from_string(m, field, eq);
1041
1042 if (streq(field, "IOSchedulingPriority"))
1043 return bus_append_ioprio_parse_priority(m, field, eq);
1044
1045 if (STR_IN_SET(field, "RuntimeDirectoryMode",
1046 "StateDirectoryMode",
1047 "CacheDirectoryMode",
1048 "LogsDirectoryMode",
1049 "ConfigurationDirectoryMode",
1050 "UMask"))
1051 return bus_append_parse_mode(m, field, eq);
1052
1053 if (streq(field, "TimerSlackNSec"))
1054 return bus_append_parse_nsec(m, field, eq);
1055
1056 if (streq(field, "LogRateLimitIntervalSec"))
1057 return bus_append_parse_sec_rename(m, field, eq);
1058
1059 if (STR_IN_SET(field, "LogRateLimitBurst",
1060 "TTYRows",
1061 "TTYColumns"))
1062 return bus_append_safe_atou(m, field, eq);
1063
1064 if (streq(field, "MountFlags"))
1065 return bus_append_mount_propagation_flag_from_string(m, field, eq);
1066
1067 if (STR_IN_SET(field, "Environment",
1068 "UnsetEnvironment",
1069 "PassEnvironment"))
1070 return bus_append_strv(m, field, eq, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE);
1071
1072 if (streq(field, "EnvironmentFile")) {
1073 if (isempty(eq))
1074 r = sd_bus_message_append(m, "(sv)", "EnvironmentFiles", "a(sb)", 0);
1075 else
1076 r = sd_bus_message_append(m, "(sv)", "EnvironmentFiles", "a(sb)", 1,
1077 eq[0] == '-' ? eq + 1 : eq,
1078 eq[0] == '-');
1079 if (r < 0)
1080 return bus_log_create_error(r);
1081
1082 return 1;
1083 }
1084
1085 if (STR_IN_SET(field, "SetCredential", "SetCredentialEncrypted")) {
1086 r = sd_bus_message_open_container(m, 'r', "sv");
1087 if (r < 0)
1088 return bus_log_create_error(r);
1089
1090 r = sd_bus_message_append_basic(m, 's', field);
1091 if (r < 0)
1092 return bus_log_create_error(r);
1093
1094 r = sd_bus_message_open_container(m, 'v', "a(say)");
1095 if (r < 0)
1096 return bus_log_create_error(r);
1097
1098 if (isempty(eq))
1099 r = sd_bus_message_append(m, "a(say)", 0);
1100 else {
1101 _cleanup_free_ char *word = NULL;
1102 const char *p = eq;
1103
1104 r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1105 if (r == -ENOMEM)
1106 return log_oom();
1107 if (r < 0)
1108 return log_error_errno(r, "Failed to parse %s= parameter: %s", field, eq);
1109 if (r == 0 || !p)
1110 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Missing argument to %s=.", field);
1111
1112 r = sd_bus_message_open_container(m, 'a', "(say)");
1113 if (r < 0)
1114 return bus_log_create_error(r);
1115
1116 r = sd_bus_message_open_container(m, 'r', "say");
1117 if (r < 0)
1118 return bus_log_create_error(r);
1119
1120 r = sd_bus_message_append(m, "s", word);
1121 if (r < 0)
1122 return bus_log_create_error(r);
1123
1124 if (streq(field, "SetCredentialEncrypted")) {
1125 _cleanup_free_ void *decoded = NULL;
1126 size_t decoded_size;
1127
1128 r = unbase64mem(p, SIZE_MAX, &decoded, &decoded_size);
1129 if (r < 0)
1130 return log_error_errno(r, "Failed to base64 decode encrypted credential: %m");
1131
1132 r = sd_bus_message_append_array(m, 'y', decoded, decoded_size);
1133 } else {
1134 _cleanup_free_ char *unescaped = NULL;
1135 ssize_t l;
1136
1137 l = cunescape(p, UNESCAPE_ACCEPT_NUL, &unescaped);
1138 if (l < 0)
1139 return log_error_errno(l, "Failed to unescape %s= value: %s", field, p);
1140
1141 r = sd_bus_message_append_array(m, 'y', unescaped, l);
1142 }
1143 if (r < 0)
1144 return bus_log_create_error(r);
1145
1146 r = sd_bus_message_close_container(m);
1147 if (r < 0)
1148 return bus_log_create_error(r);
1149
1150 r = sd_bus_message_close_container(m);
1151 }
1152 if (r < 0)
1153 return bus_log_create_error(r);
1154
1155 r = sd_bus_message_close_container(m);
1156 if (r < 0)
1157 return bus_log_create_error(r);
1158
1159 r = sd_bus_message_close_container(m);
1160 if (r < 0)
1161 return bus_log_create_error(r);
1162
1163 return 1;
1164 }
1165
1166 if (STR_IN_SET(field, "LoadCredential", "LoadCredentialEncrypted")) {
1167 r = sd_bus_message_open_container(m, 'r', "sv");
1168 if (r < 0)
1169 return bus_log_create_error(r);
1170
1171 r = sd_bus_message_append_basic(m, 's', field);
1172 if (r < 0)
1173 return bus_log_create_error(r);
1174
1175 r = sd_bus_message_open_container(m, 'v', "a(ss)");
1176 if (r < 0)
1177 return bus_log_create_error(r);
1178
1179 if (isempty(eq))
1180 r = sd_bus_message_append(m, "a(ss)", 0);
1181 else {
1182 _cleanup_free_ char *word = NULL;
1183 const char *p = eq;
1184
1185 r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1186 if (r == -ENOMEM)
1187 return log_oom();
1188 if (r < 0)
1189 return log_error_errno(r, "Failed to parse %s= parameter: %s", field, eq);
1190 if (r == 0)
1191 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Missing argument to %s=.", field);
1192
1193 if (isempty(p)) /* If only one field is specified, then this means "inherit from above" */
1194 p = eq;
1195
1196 r = sd_bus_message_append(m, "a(ss)", 1, word, p);
1197 }
1198 if (r < 0)
1199 return bus_log_create_error(r);
1200
1201 r = sd_bus_message_close_container(m);
1202 if (r < 0)
1203 return bus_log_create_error(r);
1204
1205 r = sd_bus_message_close_container(m);
1206 if (r < 0)
1207 return bus_log_create_error(r);
1208
1209 return 1;
1210 }
1211
1212 if (streq(field, "LogExtraFields")) {
1213 r = sd_bus_message_open_container(m, 'r', "sv");
1214 if (r < 0)
1215 return bus_log_create_error(r);
1216
1217 r = sd_bus_message_append_basic(m, 's', "LogExtraFields");
1218 if (r < 0)
1219 return bus_log_create_error(r);
1220
1221 r = sd_bus_message_open_container(m, 'v', "aay");
1222 if (r < 0)
1223 return bus_log_create_error(r);
1224
1225 r = sd_bus_message_open_container(m, 'a', "ay");
1226 if (r < 0)
1227 return bus_log_create_error(r);
1228
1229 r = sd_bus_message_append_array(m, 'y', eq, strlen(eq));
1230 if (r < 0)
1231 return bus_log_create_error(r);
1232
1233 r = sd_bus_message_close_container(m);
1234 if (r < 0)
1235 return bus_log_create_error(r);
1236
1237 r = sd_bus_message_close_container(m);
1238 if (r < 0)
1239 return bus_log_create_error(r);
1240
1241 r = sd_bus_message_close_container(m);
1242 if (r < 0)
1243 return bus_log_create_error(r);
1244
1245 return 1;
1246 }
1247
1248 if (streq(field, "LogFilterPatterns")) {
1249 r = sd_bus_message_append(m, "(sv)", "LogFilterPatterns", "a(bs)", 1,
1250 eq[0] != '~',
1251 eq[0] != '~' ? eq : eq + 1);
1252 if (r < 0)
1253 return bus_log_create_error(r);
1254
1255 return 1;
1256 }
1257
1258 if (STR_IN_SET(field, "StandardInput",
1259 "StandardOutput",
1260 "StandardError")) {
1261 const char *n, *appended;
1262
1263 if ((n = startswith(eq, "fd:"))) {
1264 appended = strjoina(field, "FileDescriptorName");
1265 r = sd_bus_message_append(m, "(sv)", appended, "s", n);
1266 } else if ((n = startswith(eq, "file:"))) {
1267 appended = strjoina(field, "File");
1268 r = sd_bus_message_append(m, "(sv)", appended, "s", n);
1269 } else if ((n = startswith(eq, "append:"))) {
1270 appended = strjoina(field, "FileToAppend");
1271 r = sd_bus_message_append(m, "(sv)", appended, "s", n);
1272 } else if ((n = startswith(eq, "truncate:"))) {
1273 appended = strjoina(field, "FileToTruncate");
1274 r = sd_bus_message_append(m, "(sv)", appended, "s", n);
1275 } else
1276 r = sd_bus_message_append(m, "(sv)", field, "s", eq);
1277 if (r < 0)
1278 return bus_log_create_error(r);
1279
1280 return 1;
1281 }
1282
1283 if (streq(field, "StandardInputText")) {
1284 _cleanup_free_ char *unescaped = NULL;
1285 ssize_t l;
1286
1287 l = cunescape(eq, 0, &unescaped);
1288 if (l < 0)
1289 return log_error_errno(l, "Failed to unescape text '%s': %m", eq);
1290
1291 if (!strextend(&unescaped, "\n"))
1292 return log_oom();
1293
1294 /* Note that we don't expand specifiers here, but that should be OK, as this is a
1295 * programmatic interface anyway */
1296
1297 return bus_append_byte_array(m, field, unescaped, l + 1);
1298 }
1299
1300 if (streq(field, "StandardInputData")) {
1301 _cleanup_free_ void *decoded = NULL;
1302 size_t sz;
1303
1304 r = unbase64mem(eq, SIZE_MAX, &decoded, &sz);
1305 if (r < 0)
1306 return log_error_errno(r, "Failed to decode base64 data '%s': %m", eq);
1307
1308 return bus_append_byte_array(m, field, decoded, sz);
1309 }
1310
1311 if ((suffix = startswith(field, "Limit"))) {
1312 int rl;
1313
1314 rl = rlimit_from_string(suffix);
1315 if (rl >= 0) {
1316 const char *sn;
1317 struct rlimit l;
1318
1319 r = rlimit_parse(rl, eq, &l);
1320 if (r < 0)
1321 return log_error_errno(r, "Failed to parse resource limit: %s", eq);
1322
1323 r = sd_bus_message_append(m, "(sv)", field, "t", l.rlim_max);
1324 if (r < 0)
1325 return bus_log_create_error(r);
1326
1327 sn = strjoina(field, "Soft");
1328 r = sd_bus_message_append(m, "(sv)", sn, "t", l.rlim_cur);
1329 if (r < 0)
1330 return bus_log_create_error(r);
1331
1332 return 1;
1333 }
1334 }
1335
1336 if (STR_IN_SET(field, "AppArmorProfile",
1337 "SmackProcessLabel")) {
1338 int ignore = 0;
1339 const char *s = eq;
1340
1341 if (eq[0] == '-') {
1342 ignore = 1;
1343 s = eq + 1;
1344 }
1345
1346 r = sd_bus_message_append(m, "(sv)", field, "(bs)", ignore, s);
1347 if (r < 0)
1348 return bus_log_create_error(r);
1349
1350 return 1;
1351 }
1352
1353 if (STR_IN_SET(field, "CapabilityBoundingSet",
1354 "AmbientCapabilities")) {
1355 uint64_t sum = 0;
1356 bool invert = false;
1357 const char *p = eq;
1358
1359 if (*p == '~') {
1360 invert = true;
1361 p++;
1362 }
1363
1364 r = capability_set_from_string(p, &sum);
1365 if (r < 0)
1366 return log_error_errno(r, "Failed to parse %s value %s: %m", field, eq);
1367
1368 sum = invert ? ~sum : sum;
1369
1370 r = sd_bus_message_append(m, "(sv)", field, "t", sum);
1371 if (r < 0)
1372 return bus_log_create_error(r);
1373
1374 return 1;
1375 }
1376
1377 if (streq(field, "CPUAffinity")) {
1378 _cleanup_(cpu_set_reset) CPUSet cpuset = {};
1379 _cleanup_free_ uint8_t *array = NULL;
1380 size_t allocated;
1381
1382 if (eq && streq(eq, "numa")) {
1383 r = sd_bus_message_append(m, "(sv)", "CPUAffinityFromNUMA", "b", true);
1384 if (r < 0)
1385 return bus_log_create_error(r);
1386 return r;
1387 }
1388
1389 r = parse_cpu_set(eq, &cpuset);
1390 if (r < 0)
1391 return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
1392
1393 r = cpu_set_to_dbus(&cpuset, &array, &allocated);
1394 if (r < 0)
1395 return log_error_errno(r, "Failed to serialize CPUAffinity: %m");
1396
1397 return bus_append_byte_array(m, field, array, allocated);
1398 }
1399
1400 if (streq(field, "NUMAPolicy")) {
1401 r = mpol_from_string(eq);
1402 if (r < 0)
1403 return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
1404
1405 r = sd_bus_message_append(m, "(sv)", field, "i", (int32_t) r);
1406 if (r < 0)
1407 return bus_log_create_error(r);
1408
1409 return 1;
1410 }
1411
1412 if (streq(field, "NUMAMask")) {
1413 _cleanup_(cpu_set_reset) CPUSet nodes = {};
1414 _cleanup_free_ uint8_t *array = NULL;
1415 size_t allocated;
1416
1417 if (eq && streq(eq, "all")) {
1418 r = numa_mask_add_all(&nodes);
1419 if (r < 0)
1420 return log_error_errno(r, "Failed to create NUMA mask representing \"all\" NUMA nodes: %m");
1421 } else {
1422 r = parse_cpu_set(eq, &nodes);
1423 if (r < 0)
1424 return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
1425 }
1426
1427 r = cpu_set_to_dbus(&nodes, &array, &allocated);
1428 if (r < 0)
1429 return log_error_errno(r, "Failed to serialize NUMAMask: %m");
1430
1431 return bus_append_byte_array(m, field, array, allocated);
1432 }
1433
1434 if (STR_IN_SET(field, "RestrictAddressFamilies",
1435 "RestrictFileSystems",
1436 "SystemCallFilter",
1437 "SystemCallLog",
1438 "RestrictNetworkInterfaces")) {
1439 int allow_list = 1;
1440 const char *p = eq;
1441
1442 if (*p == '~') {
1443 allow_list = 0;
1444 p++;
1445 }
1446
1447 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1448 if (r < 0)
1449 return bus_log_create_error(r);
1450
1451 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1452 if (r < 0)
1453 return bus_log_create_error(r);
1454
1455 r = sd_bus_message_open_container(m, 'v', "(bas)");
1456 if (r < 0)
1457 return bus_log_create_error(r);
1458
1459 r = sd_bus_message_open_container(m, 'r', "bas");
1460 if (r < 0)
1461 return bus_log_create_error(r);
1462
1463 r = sd_bus_message_append_basic(m, 'b', &allow_list);
1464 if (r < 0)
1465 return bus_log_create_error(r);
1466
1467 r = sd_bus_message_open_container(m, 'a', "s");
1468 if (r < 0)
1469 return bus_log_create_error(r);
1470
1471 for (;;) {
1472 _cleanup_free_ char *word = NULL;
1473
1474 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
1475 if (r == 0)
1476 break;
1477 if (r == -ENOMEM)
1478 return log_oom();
1479 if (r < 0)
1480 return log_error_errno(r, "Invalid syntax: %s", eq);
1481
1482 r = sd_bus_message_append_basic(m, 's', word);
1483 if (r < 0)
1484 return bus_log_create_error(r);
1485 }
1486
1487 r = sd_bus_message_close_container(m);
1488 if (r < 0)
1489 return bus_log_create_error(r);
1490
1491 r = sd_bus_message_close_container(m);
1492 if (r < 0)
1493 return bus_log_create_error(r);
1494
1495 r = sd_bus_message_close_container(m);
1496 if (r < 0)
1497 return bus_log_create_error(r);
1498
1499 r = sd_bus_message_close_container(m);
1500 if (r < 0)
1501 return bus_log_create_error(r);
1502
1503 return 1;
1504 }
1505
1506 if (streq(field, "RestrictNamespaces")) {
1507 bool invert = false;
1508 unsigned long flags;
1509
1510 r = parse_boolean(eq);
1511 if (r > 0)
1512 flags = 0;
1513 else if (r == 0)
1514 flags = NAMESPACE_FLAGS_ALL;
1515 else {
1516 if (eq[0] == '~') {
1517 invert = true;
1518 eq++;
1519 }
1520
1521 r = namespace_flags_from_string(eq, &flags);
1522 if (r < 0)
1523 return log_error_errno(r, "Failed to parse %s value %s.", field, eq);
1524 }
1525
1526 if (invert)
1527 flags = (~flags) & NAMESPACE_FLAGS_ALL;
1528
1529 r = sd_bus_message_append(m, "(sv)", field, "t", (uint64_t) flags);
1530 if (r < 0)
1531 return bus_log_create_error(r);
1532
1533 return 1;
1534 }
1535
1536 if (STR_IN_SET(field, "BindPaths",
1537 "BindReadOnlyPaths")) {
1538 const char *p = eq;
1539
1540 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1541 if (r < 0)
1542 return bus_log_create_error(r);
1543
1544 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1545 if (r < 0)
1546 return bus_log_create_error(r);
1547
1548 r = sd_bus_message_open_container(m, 'v', "a(ssbt)");
1549 if (r < 0)
1550 return bus_log_create_error(r);
1551
1552 r = sd_bus_message_open_container(m, 'a', "(ssbt)");
1553 if (r < 0)
1554 return bus_log_create_error(r);
1555
1556 for (;;) {
1557 _cleanup_free_ char *source = NULL, *destination = NULL;
1558 char *s = NULL, *d = NULL;
1559 bool ignore_enoent = false;
1560 uint64_t flags = MS_REC;
1561
1562 r = extract_first_word(&p, &source, ":" WHITESPACE, EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS);
1563 if (r < 0)
1564 return log_error_errno(r, "Failed to parse argument: %m");
1565 if (r == 0)
1566 break;
1567
1568 s = source;
1569 if (s[0] == '-') {
1570 ignore_enoent = true;
1571 s++;
1572 }
1573
1574 if (p && p[-1] == ':') {
1575 r = extract_first_word(&p, &destination, ":" WHITESPACE, EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS);
1576 if (r < 0)
1577 return log_error_errno(r, "Failed to parse argument: %m");
1578 if (r == 0)
1579 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1580 "Missing argument after ':': %s",
1581 eq);
1582
1583 d = destination;
1584
1585 if (p && p[-1] == ':') {
1586 _cleanup_free_ char *options = NULL;
1587
1588 r = extract_first_word(&p, &options, NULL, EXTRACT_UNQUOTE);
1589 if (r < 0)
1590 return log_error_errno(r, "Failed to parse argument: %m");
1591
1592 if (isempty(options) || streq(options, "rbind"))
1593 flags = MS_REC;
1594 else if (streq(options, "norbind"))
1595 flags = 0;
1596 else
1597 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1598 "Unknown options: %s",
1599 eq);
1600 }
1601 } else
1602 d = s;
1603
1604 r = sd_bus_message_append(m, "(ssbt)", s, d, ignore_enoent, flags);
1605 if (r < 0)
1606 return bus_log_create_error(r);
1607 }
1608
1609 r = sd_bus_message_close_container(m);
1610 if (r < 0)
1611 return bus_log_create_error(r);
1612
1613 r = sd_bus_message_close_container(m);
1614 if (r < 0)
1615 return bus_log_create_error(r);
1616
1617 r = sd_bus_message_close_container(m);
1618 if (r < 0)
1619 return bus_log_create_error(r);
1620
1621 return 1;
1622 }
1623
1624 if (streq(field, "TemporaryFileSystem")) {
1625 const char *p = eq;
1626
1627 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1628 if (r < 0)
1629 return bus_log_create_error(r);
1630
1631 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1632 if (r < 0)
1633 return bus_log_create_error(r);
1634
1635 r = sd_bus_message_open_container(m, 'v', "a(ss)");
1636 if (r < 0)
1637 return bus_log_create_error(r);
1638
1639 r = sd_bus_message_open_container(m, 'a', "(ss)");
1640 if (r < 0)
1641 return bus_log_create_error(r);
1642
1643 for (;;) {
1644 _cleanup_free_ char *word = NULL, *path = NULL;
1645 const char *w;
1646
1647 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
1648 if (r < 0)
1649 return log_error_errno(r, "Failed to parse argument: %m");
1650 if (r == 0)
1651 break;
1652
1653 w = word;
1654 r = extract_first_word(&w, &path, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1655 if (r < 0)
1656 return log_error_errno(r, "Failed to parse argument: %m");
1657 if (r == 0)
1658 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1659 "Failed to parse argument: %s",
1660 p);
1661
1662 r = sd_bus_message_append(m, "(ss)", path, w);
1663 if (r < 0)
1664 return bus_log_create_error(r);
1665 }
1666
1667 r = sd_bus_message_close_container(m);
1668 if (r < 0)
1669 return bus_log_create_error(r);
1670
1671 r = sd_bus_message_close_container(m);
1672 if (r < 0)
1673 return bus_log_create_error(r);
1674
1675 r = sd_bus_message_close_container(m);
1676 if (r < 0)
1677 return bus_log_create_error(r);
1678
1679 return 1;
1680 }
1681
1682 if (streq(field, "RootHash")) {
1683 _cleanup_free_ void *roothash_decoded = NULL;
1684 size_t roothash_decoded_size = 0;
1685
1686 /* We have the path to a roothash to load and decode, eg: RootHash=/foo/bar.roothash */
1687 if (path_is_absolute(eq))
1688 return bus_append_string(m, "RootHashPath", eq);
1689
1690 /* We have a roothash to decode, eg: RootHash=012345789abcdef */
1691 r = unhexmem(eq, strlen(eq), &roothash_decoded, &roothash_decoded_size);
1692 if (r < 0)
1693 return log_error_errno(r, "Failed to decode RootHash= '%s': %m", eq);
1694 if (roothash_decoded_size < sizeof(sd_id128_t))
1695 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "RootHash= '%s' is too short: %m", eq);
1696
1697 return bus_append_byte_array(m, field, roothash_decoded, roothash_decoded_size);
1698 }
1699
1700 if (streq(field, "RootHashSignature")) {
1701 _cleanup_free_ void *roothash_sig_decoded = NULL;
1702 char *value;
1703 size_t roothash_sig_decoded_size = 0;
1704
1705 /* We have the path to a roothash signature to load and decode, eg: RootHash=/foo/bar.roothash.p7s */
1706 if (path_is_absolute(eq))
1707 return bus_append_string(m, "RootHashSignaturePath", eq);
1708
1709 if (!(value = startswith(eq, "base64:")))
1710 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to decode RootHashSignature= '%s', not a path but doesn't start with 'base64:': %m", eq);
1711
1712 /* We have a roothash signature to decode, eg: RootHashSignature=base64:012345789abcdef */
1713 r = unbase64mem(value, strlen(value), &roothash_sig_decoded, &roothash_sig_decoded_size);
1714 if (r < 0)
1715 return log_error_errno(r, "Failed to decode RootHashSignature= '%s': %m", eq);
1716
1717 return bus_append_byte_array(m, field, roothash_sig_decoded, roothash_sig_decoded_size);
1718 }
1719
1720 if (streq(field, "RootImageOptions")) {
1721 _cleanup_strv_free_ char **l = NULL;
1722 const char *p = eq;
1723
1724 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1725 if (r < 0)
1726 return bus_log_create_error(r);
1727
1728 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1729 if (r < 0)
1730 return bus_log_create_error(r);
1731
1732 r = sd_bus_message_open_container(m, 'v', "a(ss)");
1733 if (r < 0)
1734 return bus_log_create_error(r);
1735
1736 r = sd_bus_message_open_container(m, 'a', "(ss)");
1737 if (r < 0)
1738 return bus_log_create_error(r);
1739
1740 r = strv_split_colon_pairs(&l, p);
1741 if (r < 0)
1742 return log_error_errno(r, "Failed to parse argument: %m");
1743
1744 STRV_FOREACH_PAIR(first, second, l) {
1745 r = sd_bus_message_append(m, "(ss)",
1746 !isempty(*second) ? *first : "root",
1747 !isempty(*second) ? *second : *first);
1748 if (r < 0)
1749 return bus_log_create_error(r);
1750 }
1751
1752 r = sd_bus_message_close_container(m);
1753 if (r < 0)
1754 return bus_log_create_error(r);
1755
1756 r = sd_bus_message_close_container(m);
1757 if (r < 0)
1758 return bus_log_create_error(r);
1759
1760 r = sd_bus_message_close_container(m);
1761 if (r < 0)
1762 return bus_log_create_error(r);
1763
1764 return 1;
1765 }
1766
1767 if (streq(field, "MountImages")) {
1768 const char *p = eq;
1769
1770 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1771 if (r < 0)
1772 return bus_log_create_error(r);
1773
1774 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1775 if (r < 0)
1776 return bus_log_create_error(r);
1777
1778 r = sd_bus_message_open_container(m, 'v', "a(ssba(ss))");
1779 if (r < 0)
1780 return bus_log_create_error(r);
1781
1782 r = sd_bus_message_open_container(m, 'a', "(ssba(ss))");
1783 if (r < 0)
1784 return bus_log_create_error(r);
1785
1786 for (;;) {
1787 _cleanup_free_ char *first = NULL, *second = NULL, *tuple = NULL;
1788 const char *q = NULL, *source = NULL;
1789 bool permissive = false;
1790
1791 r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
1792 if (r < 0)
1793 return log_error_errno(r, "Failed to parse MountImages= property: %s", eq);
1794 if (r == 0)
1795 break;
1796
1797 q = tuple;
1798 r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &first, &second, NULL);
1799 if (r < 0)
1800 return log_error_errno(r, "Failed to parse MountImages= property: %s", eq);
1801 if (r == 0)
1802 continue;
1803
1804 source = first;
1805 if (source[0] == '-') {
1806 permissive = true;
1807 source++;
1808 }
1809
1810 if (isempty(second))
1811 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1812 "Missing argument after ':': %s",
1813 eq);
1814
1815 r = sd_bus_message_open_container(m, 'r', "ssba(ss)");
1816 if (r < 0)
1817 return bus_log_create_error(r);
1818
1819 r = sd_bus_message_append(m, "ssb", source, second, permissive);
1820 if (r < 0)
1821 return bus_log_create_error(r);
1822
1823 r = sd_bus_message_open_container(m, 'a', "(ss)");
1824 if (r < 0)
1825 return bus_log_create_error(r);
1826
1827 for (;;) {
1828 _cleanup_free_ char *partition = NULL, *mount_options = NULL;
1829
1830 r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &partition, &mount_options, NULL);
1831 if (r < 0)
1832 return log_error_errno(r, "Failed to parse MountImages= property: %s", eq);
1833 if (r == 0)
1834 break;
1835 /* Single set of options, applying to the root partition/single filesystem */
1836 if (r == 1) {
1837 r = sd_bus_message_append(m, "(ss)", "root", partition);
1838 if (r < 0)
1839 return bus_log_create_error(r);
1840
1841 break;
1842 }
1843
1844 r = sd_bus_message_append(m, "(ss)", partition, mount_options);
1845 if (r < 0)
1846 return bus_log_create_error(r);
1847 }
1848
1849 r = sd_bus_message_close_container(m);
1850 if (r < 0)
1851 return bus_log_create_error(r);
1852
1853 r = sd_bus_message_close_container(m);
1854 if (r < 0)
1855 return bus_log_create_error(r);
1856 }
1857
1858 r = sd_bus_message_close_container(m);
1859 if (r < 0)
1860 return bus_log_create_error(r);
1861
1862 r = sd_bus_message_close_container(m);
1863 if (r < 0)
1864 return bus_log_create_error(r);
1865
1866 r = sd_bus_message_close_container(m);
1867 if (r < 0)
1868 return bus_log_create_error(r);
1869
1870 return 1;
1871 }
1872
1873 if (streq(field, "ExtensionImages")) {
1874 const char *p = eq;
1875
1876 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1877 if (r < 0)
1878 return bus_log_create_error(r);
1879
1880 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1881 if (r < 0)
1882 return bus_log_create_error(r);
1883
1884 r = sd_bus_message_open_container(m, 'v', "a(sba(ss))");
1885 if (r < 0)
1886 return bus_log_create_error(r);
1887
1888 r = sd_bus_message_open_container(m, 'a', "(sba(ss))");
1889 if (r < 0)
1890 return bus_log_create_error(r);
1891
1892 for (;;) {
1893 _cleanup_free_ char *source = NULL, *tuple = NULL;
1894 const char *q = NULL, *s = NULL;
1895 bool permissive = false;
1896
1897 r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
1898 if (r < 0)
1899 return log_error_errno(r, "Failed to parse ExtensionImages= property: %s", eq);
1900 if (r == 0)
1901 break;
1902
1903 q = tuple;
1904 r = extract_first_word(&q, &source, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS);
1905 if (r < 0)
1906 return log_error_errno(r, "Failed to parse ExtensionImages= property: %s", eq);
1907 if (r == 0)
1908 continue;
1909
1910 s = source;
1911 if (s[0] == '-') {
1912 permissive = true;
1913 s++;
1914 }
1915
1916 r = sd_bus_message_open_container(m, 'r', "sba(ss)");
1917 if (r < 0)
1918 return bus_log_create_error(r);
1919
1920 r = sd_bus_message_append(m, "sb", s, permissive);
1921 if (r < 0)
1922 return bus_log_create_error(r);
1923
1924 r = sd_bus_message_open_container(m, 'a', "(ss)");
1925 if (r < 0)
1926 return bus_log_create_error(r);
1927
1928 for (;;) {
1929 _cleanup_free_ char *partition = NULL, *mount_options = NULL;
1930
1931 r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &partition, &mount_options, NULL);
1932 if (r < 0)
1933 return log_error_errno(r, "Failed to parse ExtensionImages= property: %s", eq);
1934 if (r == 0)
1935 break;
1936 /* Single set of options, applying to the root partition/single filesystem */
1937 if (r == 1) {
1938 r = sd_bus_message_append(m, "(ss)", "root", partition);
1939 if (r < 0)
1940 return bus_log_create_error(r);
1941
1942 break;
1943 }
1944
1945 r = sd_bus_message_append(m, "(ss)", partition, mount_options);
1946 if (r < 0)
1947 return bus_log_create_error(r);
1948 }
1949
1950 r = sd_bus_message_close_container(m);
1951 if (r < 0)
1952 return bus_log_create_error(r);
1953
1954 r = sd_bus_message_close_container(m);
1955 if (r < 0)
1956 return bus_log_create_error(r);
1957 }
1958
1959 r = sd_bus_message_close_container(m);
1960 if (r < 0)
1961 return bus_log_create_error(r);
1962
1963 r = sd_bus_message_close_container(m);
1964 if (r < 0)
1965 return bus_log_create_error(r);
1966
1967 r = sd_bus_message_close_container(m);
1968 if (r < 0)
1969 return bus_log_create_error(r);
1970
1971 return 1;
1972 }
1973
1974 if (STR_IN_SET(field, "StateDirectory", "RuntimeDirectory", "CacheDirectory", "LogsDirectory")) {
1975 _cleanup_strv_free_ char **symlinks = NULL, **sources = NULL;
1976 const char *p = eq;
1977
1978 /* Adding new directories is supported from both *DirectorySymlink methods and the
1979 * older ones, so first parse the input, and if we are given a new-style src:dst
1980 * tuple use the new method, else use the old one. */
1981
1982 for (;;) {
1983 _cleanup_free_ char *tuple = NULL, *source = NULL, *destination = NULL;
1984
1985 r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE);
1986 if (r < 0)
1987 return log_error_errno(r, "Failed to parse argument: %m");
1988 if (r == 0)
1989 break;
1990
1991 const char *t = tuple;
1992 r = extract_many_words(&t, ":", EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS, &source, &destination, NULL);
1993 if (r <= 0)
1994 return log_error_errno(r ?: SYNTHETIC_ERRNO(EINVAL), "Failed to parse argument: %m");
1995
1996 path_simplify(source);
1997
1998 if (isempty(destination)) {
1999 r = strv_consume(&sources, TAKE_PTR(source));
2000 if (r < 0)
2001 return bus_log_create_error(r);
2002 } else {
2003 path_simplify(destination);
2004
2005 r = strv_consume_pair(&symlinks, TAKE_PTR(source), TAKE_PTR(destination));
2006 if (r < 0)
2007 return log_oom();
2008 }
2009 }
2010
2011 if (!strv_isempty(sources)) {
2012 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
2013 if (r < 0)
2014 return bus_log_create_error(r);
2015
2016 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
2017 if (r < 0)
2018 return bus_log_create_error(r);
2019
2020 r = sd_bus_message_open_container(m, 'v', "as");
2021 if (r < 0)
2022 return bus_log_create_error(r);
2023
2024 r = sd_bus_message_append_strv(m, sources);
2025 if (r < 0)
2026 return bus_log_create_error(r);
2027
2028 r = sd_bus_message_close_container(m);
2029 if (r < 0)
2030 return bus_log_create_error(r);
2031
2032 r = sd_bus_message_close_container(m);
2033 if (r < 0)
2034 return bus_log_create_error(r);
2035 }
2036
2037 /* For State and Runtime directories we support an optional destination parameter, which
2038 * will be used to create a symlink to the source. But it is new so we cannot change the
2039 * old DBUS signatures, so append a new message type. */
2040 if (!strv_isempty(symlinks)) {
2041 const char *symlink_field;
2042
2043 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
2044 if (r < 0)
2045 return bus_log_create_error(r);
2046
2047 if (streq(field, "StateDirectory"))
2048 symlink_field = "StateDirectorySymlink";
2049 else if (streq(field, "RuntimeDirectory"))
2050 symlink_field = "RuntimeDirectorySymlink";
2051 else if (streq(field, "CacheDirectory"))
2052 symlink_field = "CacheDirectorySymlink";
2053 else if (streq(field, "LogsDirectory"))
2054 symlink_field = "LogsDirectorySymlink";
2055 else
2056 assert_not_reached();
2057
2058 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, symlink_field);
2059 if (r < 0)
2060 return bus_log_create_error(r);
2061
2062 r = sd_bus_message_open_container(m, 'v', "a(sst)");
2063 if (r < 0)
2064 return bus_log_create_error(r);
2065
2066 r = sd_bus_message_open_container(m, 'a', "(sst)");
2067 if (r < 0)
2068 return bus_log_create_error(r);
2069
2070 STRV_FOREACH_PAIR(source, destination, symlinks) {
2071 r = sd_bus_message_append(m, "(sst)", *source, *destination, 0);
2072 if (r < 0)
2073 return bus_log_create_error(r);
2074 }
2075
2076 r = sd_bus_message_close_container(m);
2077 if (r < 0)
2078 return bus_log_create_error(r);
2079
2080 r = sd_bus_message_close_container(m);
2081 if (r < 0)
2082 return bus_log_create_error(r);
2083
2084 r = sd_bus_message_close_container(m);
2085 if (r < 0)
2086 return bus_log_create_error(r);
2087 }
2088
2089 return 1;
2090 }
2091
2092 return 0;
2093 }
2094
2095 static int bus_append_kill_property(sd_bus_message *m, const char *field, const char *eq) {
2096 if (streq(field, "KillMode"))
2097 return bus_append_string(m, field, eq);
2098
2099 if (STR_IN_SET(field, "SendSIGHUP",
2100 "SendSIGKILL"))
2101 return bus_append_parse_boolean(m, field, eq);
2102
2103 if (STR_IN_SET(field, "KillSignal",
2104 "RestartKillSignal",
2105 "FinalKillSignal",
2106 "WatchdogSignal",
2107 "ReloadSignal"))
2108 return bus_append_signal_from_string(m, field, eq);
2109
2110 return 0;
2111 }
2112
2113 static int bus_append_mount_property(sd_bus_message *m, const char *field, const char *eq) {
2114
2115 if (STR_IN_SET(field, "What",
2116 "Where",
2117 "Options",
2118 "Type"))
2119 return bus_append_string(m, field, eq);
2120
2121 if (streq(field, "TimeoutSec"))
2122 return bus_append_parse_sec_rename(m, field, eq);
2123
2124 if (streq(field, "DirectoryMode"))
2125 return bus_append_parse_mode(m, field, eq);
2126
2127 if (STR_IN_SET(field, "SloppyOptions",
2128 "LazyUnmount",
2129 "ForceUnmount",
2130 "ReadwriteOnly"))
2131 return bus_append_parse_boolean(m, field, eq);
2132
2133 return 0;
2134 }
2135
2136 static int bus_append_path_property(sd_bus_message *m, const char *field, const char *eq) {
2137 int r;
2138
2139 if (streq(field, "MakeDirectory"))
2140 return bus_append_parse_boolean(m, field, eq);
2141
2142 if (streq(field, "DirectoryMode"))
2143 return bus_append_parse_mode(m, field, eq);
2144
2145 if (STR_IN_SET(field, "PathExists",
2146 "PathExistsGlob",
2147 "PathChanged",
2148 "PathModified",
2149 "DirectoryNotEmpty")) {
2150 if (isempty(eq))
2151 r = sd_bus_message_append(m, "(sv)", "Paths", "a(ss)", 0);
2152 else
2153 r = sd_bus_message_append(m, "(sv)", "Paths", "a(ss)", 1, field, eq);
2154 if (r < 0)
2155 return bus_log_create_error(r);
2156
2157 return 1;
2158 }
2159
2160 if (streq(field, "TriggerLimitBurst"))
2161 return bus_append_safe_atou(m, field, eq);
2162
2163 if (streq(field, "TriggerLimitIntervalSec"))
2164 return bus_append_parse_sec_rename(m, field, eq);
2165
2166 return 0;
2167 }
2168
2169 static int bus_append_scope_property(sd_bus_message *m, const char *field, const char *eq) {
2170 if (streq(field, "RuntimeMaxSec"))
2171 return bus_append_parse_sec_rename(m, field, eq);
2172
2173 if (streq(field, "RuntimeRandomizedExtraSec"))
2174 return bus_append_parse_sec_rename(m, field, eq);
2175
2176 if (streq(field, "TimeoutStopSec"))
2177 return bus_append_parse_sec_rename(m, field, eq);
2178
2179 /* Scope units don't have execution context but we still want to allow setting these two,
2180 * so let's handle them separately. */
2181 if (STR_IN_SET(field, "User", "Group"))
2182 return bus_append_string(m, field, eq);
2183
2184 if (streq(field, "OOMPolicy"))
2185 return bus_append_string(m, field, eq);
2186
2187 return 0;
2188 }
2189
2190 static int bus_append_service_property(sd_bus_message *m, const char *field, const char *eq) {
2191 int r;
2192
2193 if (STR_IN_SET(field, "PIDFile",
2194 "Type",
2195 "ExitType",
2196 "Restart",
2197 "BusName",
2198 "NotifyAccess",
2199 "USBFunctionDescriptors",
2200 "USBFunctionStrings",
2201 "OOMPolicy",
2202 "TimeoutStartFailureMode",
2203 "TimeoutStopFailureMode",
2204 "FileDescriptorStorePreserve"))
2205 return bus_append_string(m, field, eq);
2206
2207 if (STR_IN_SET(field, "PermissionsStartOnly",
2208 "RootDirectoryStartOnly",
2209 "RemainAfterExit",
2210 "GuessMainPID"))
2211 return bus_append_parse_boolean(m, field, eq);
2212
2213 if (STR_IN_SET(field, "RestartSec",
2214 "RestartMaxDelaySec",
2215 "TimeoutStartSec",
2216 "TimeoutStopSec",
2217 "TimeoutAbortSec",
2218 "RuntimeMaxSec",
2219 "RuntimeRandomizedExtraSec",
2220 "WatchdogSec"))
2221 return bus_append_parse_sec_rename(m, field, eq);
2222
2223 if (streq(field, "TimeoutSec")) {
2224 r = bus_append_parse_sec_rename(m, "TimeoutStartSec", eq);
2225 if (r < 0)
2226 return r;
2227
2228 return bus_append_parse_sec_rename(m, "TimeoutStopSec", eq);
2229 }
2230
2231 if (STR_IN_SET(field, "FileDescriptorStoreMax",
2232 "RestartSteps"))
2233 return bus_append_safe_atou(m, field, eq);
2234
2235 if (STR_IN_SET(field, "ExecCondition",
2236 "ExecStartPre",
2237 "ExecStart",
2238 "ExecStartPost",
2239 "ExecConditionEx",
2240 "ExecStartPreEx",
2241 "ExecStartEx",
2242 "ExecStartPostEx",
2243 "ExecReload",
2244 "ExecStop",
2245 "ExecStopPost",
2246 "ExecReloadEx",
2247 "ExecStopEx",
2248 "ExecStopPostEx"))
2249 return bus_append_exec_command(m, field, eq);
2250
2251 if (STR_IN_SET(field, "RestartPreventExitStatus",
2252 "RestartForceExitStatus",
2253 "SuccessExitStatus")) {
2254 _cleanup_free_ int *status = NULL, *signal = NULL;
2255 size_t n_status = 0, n_signal = 0;
2256 const char *p;
2257
2258 for (p = eq;;) {
2259 _cleanup_free_ char *word = NULL;
2260
2261 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
2262 if (r == 0)
2263 break;
2264 if (r == -ENOMEM)
2265 return log_oom();
2266 if (r < 0)
2267 return log_error_errno(r, "Invalid syntax in %s: %s", field, eq);
2268
2269 /* We need to call exit_status_from_string() first, because we want
2270 * to parse numbers as exit statuses, not signals. */
2271
2272 r = exit_status_from_string(word);
2273 if (r >= 0) {
2274 assert(r >= 0 && r < 256);
2275
2276 status = reallocarray(status, n_status + 1, sizeof(int));
2277 if (!status)
2278 return log_oom();
2279
2280 status[n_status++] = r;
2281
2282 } else if ((r = signal_from_string(word)) >= 0) {
2283 signal = reallocarray(signal, n_signal + 1, sizeof(int));
2284 if (!signal)
2285 return log_oom();
2286
2287 signal[n_signal++] = r;
2288
2289 } else
2290 /* original r from exit_status_to_string() */
2291 return log_error_errno(r, "Invalid status or signal %s in %s: %m",
2292 word, field);
2293 }
2294
2295 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
2296 if (r < 0)
2297 return bus_log_create_error(r);
2298
2299 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
2300 if (r < 0)
2301 return bus_log_create_error(r);
2302
2303 r = sd_bus_message_open_container(m, 'v', "(aiai)");
2304 if (r < 0)
2305 return bus_log_create_error(r);
2306
2307 r = sd_bus_message_open_container(m, 'r', "aiai");
2308 if (r < 0)
2309 return bus_log_create_error(r);
2310
2311 r = sd_bus_message_append_array(m, 'i', status, n_status * sizeof(int));
2312 if (r < 0)
2313 return bus_log_create_error(r);
2314
2315 r = sd_bus_message_append_array(m, 'i', signal, n_signal * sizeof(int));
2316 if (r < 0)
2317 return bus_log_create_error(r);
2318
2319 r = sd_bus_message_close_container(m);
2320 if (r < 0)
2321 return bus_log_create_error(r);
2322
2323 r = sd_bus_message_close_container(m);
2324 if (r < 0)
2325 return bus_log_create_error(r);
2326
2327 r = sd_bus_message_close_container(m);
2328 if (r < 0)
2329 return bus_log_create_error(r);
2330
2331 return 1;
2332 }
2333
2334 if (streq(field, "OpenFile"))
2335 return bus_append_open_file(m, field, eq);
2336
2337 return 0;
2338 }
2339
2340 static int bus_append_socket_property(sd_bus_message *m, const char *field, const char *eq) {
2341 int r;
2342
2343 if (STR_IN_SET(field, "Accept",
2344 "FlushPending",
2345 "Writable",
2346 "KeepAlive",
2347 "NoDelay",
2348 "FreeBind",
2349 "Transparent",
2350 "Broadcast",
2351 "PassCredentials",
2352 "PassSecurity",
2353 "PassPacketInfo",
2354 "ReusePort",
2355 "RemoveOnStop",
2356 "SELinuxContextFromNet"))
2357 return bus_append_parse_boolean(m, field, eq);
2358
2359 if (STR_IN_SET(field, "Priority",
2360 "IPTTL",
2361 "Mark"))
2362 return bus_append_safe_atoi(m, field, eq);
2363
2364 if (streq(field, "IPTOS"))
2365 return bus_append_ip_tos_from_string(m, field, eq);
2366
2367 if (STR_IN_SET(field, "Backlog",
2368 "MaxConnections",
2369 "MaxConnectionsPerSource",
2370 "KeepAliveProbes",
2371 "TriggerLimitBurst"))
2372 return bus_append_safe_atou(m, field, eq);
2373
2374 if (STR_IN_SET(field, "SocketMode",
2375 "DirectoryMode"))
2376 return bus_append_parse_mode(m, field, eq);
2377
2378 if (STR_IN_SET(field, "MessageQueueMaxMessages",
2379 "MessageQueueMessageSize"))
2380 return bus_append_safe_atoi64(m, field, eq);
2381
2382 if (STR_IN_SET(field, "TimeoutSec",
2383 "KeepAliveTimeSec",
2384 "KeepAliveIntervalSec",
2385 "DeferAcceptSec",
2386 "TriggerLimitIntervalSec"))
2387 return bus_append_parse_sec_rename(m, field, eq);
2388
2389 if (STR_IN_SET(field, "ReceiveBuffer",
2390 "SendBuffer",
2391 "PipeSize"))
2392 return bus_append_parse_size(m, field, eq, 1024);
2393
2394 if (STR_IN_SET(field, "ExecStartPre",
2395 "ExecStartPost",
2396 "ExecReload",
2397 "ExecStopPost"))
2398 return bus_append_exec_command(m, field, eq);
2399
2400 if (STR_IN_SET(field, "SmackLabel",
2401 "SmackLabelIPIn",
2402 "SmackLabelIPOut",
2403 "TCPCongestion",
2404 "BindToDevice",
2405 "BindIPv6Only",
2406 "FileDescriptorName",
2407 "SocketUser",
2408 "SocketGroup",
2409 "Timestamping"))
2410 return bus_append_string(m, field, eq);
2411
2412 if (streq(field, "Symlinks"))
2413 return bus_append_strv(m, field, eq, EXTRACT_UNQUOTE);
2414
2415 if (streq(field, "SocketProtocol"))
2416 return bus_append_parse_ip_protocol(m, field, eq);
2417
2418 if (STR_IN_SET(field, "ListenStream",
2419 "ListenDatagram",
2420 "ListenSequentialPacket",
2421 "ListenNetlink",
2422 "ListenSpecial",
2423 "ListenMessageQueue",
2424 "ListenFIFO",
2425 "ListenUSBFunction")) {
2426 if (isempty(eq))
2427 r = sd_bus_message_append(m, "(sv)", "Listen", "a(ss)", 0);
2428 else
2429 r = sd_bus_message_append(m, "(sv)", "Listen", "a(ss)", 1, field + STRLEN("Listen"), eq);
2430 if (r < 0)
2431 return bus_log_create_error(r);
2432
2433 return 1;
2434 }
2435
2436 return 0;
2437 }
2438 static int bus_append_timer_property(sd_bus_message *m, const char *field, const char *eq) {
2439 int r;
2440
2441 if (STR_IN_SET(field, "WakeSystem",
2442 "RemainAfterElapse",
2443 "Persistent",
2444 "OnTimezoneChange",
2445 "OnClockChange",
2446 "FixedRandomDelay"))
2447 return bus_append_parse_boolean(m, field, eq);
2448
2449 if (STR_IN_SET(field, "AccuracySec",
2450 "RandomizedDelaySec"))
2451 return bus_append_parse_sec_rename(m, field, eq);
2452
2453 if (STR_IN_SET(field, "OnActiveSec",
2454 "OnBootSec",
2455 "OnStartupSec",
2456 "OnUnitActiveSec",
2457 "OnUnitInactiveSec")) {
2458 if (isempty(eq))
2459 r = sd_bus_message_append(m, "(sv)", "TimersMonotonic", "a(st)", 0);
2460 else {
2461 usec_t t;
2462 r = parse_sec(eq, &t);
2463 if (r < 0)
2464 return log_error_errno(r, "Failed to parse %s=%s: %m", field, eq);
2465
2466 r = sd_bus_message_append(m, "(sv)", "TimersMonotonic", "a(st)", 1, field, t);
2467 }
2468 if (r < 0)
2469 return bus_log_create_error(r);
2470
2471 return 1;
2472 }
2473
2474 if (streq(field, "OnCalendar")) {
2475 if (isempty(eq))
2476 r = sd_bus_message_append(m, "(sv)", "TimersCalendar", "a(ss)", 0);
2477 else
2478 r = sd_bus_message_append(m, "(sv)", "TimersCalendar", "a(ss)", 1, field, eq);
2479 if (r < 0)
2480 return bus_log_create_error(r);
2481
2482 return 1;
2483 }
2484
2485 return 0;
2486 }
2487
2488 static int bus_append_unit_property(sd_bus_message *m, const char *field, const char *eq) {
2489 ConditionType t = _CONDITION_TYPE_INVALID;
2490 bool is_condition = false;
2491 int r;
2492
2493 if (STR_IN_SET(field, "Description",
2494 "SourcePath",
2495 "OnFailureJobMode",
2496 "JobTimeoutAction",
2497 "JobTimeoutRebootArgument",
2498 "StartLimitAction",
2499 "FailureAction",
2500 "SuccessAction",
2501 "RebootArgument",
2502 "CollectMode"))
2503 return bus_append_string(m, field, eq);
2504
2505 if (STR_IN_SET(field, "StopWhenUnneeded",
2506 "RefuseManualStart",
2507 "RefuseManualStop",
2508 "AllowIsolate",
2509 "IgnoreOnIsolate",
2510 "DefaultDependencies"))
2511 return bus_append_parse_boolean(m, field, eq);
2512
2513 if (STR_IN_SET(field, "JobTimeoutSec",
2514 "JobRunningTimeoutSec",
2515 "StartLimitIntervalSec"))
2516 return bus_append_parse_sec_rename(m, field, eq);
2517
2518 if (streq(field, "StartLimitBurst"))
2519 return bus_append_safe_atou(m, field, eq);
2520
2521 if (STR_IN_SET(field, "SuccessActionExitStatus",
2522 "FailureActionExitStatus")) {
2523 if (isempty(eq))
2524 r = sd_bus_message_append(m, "(sv)", field, "i", -1);
2525 else {
2526 uint8_t u;
2527
2528 r = safe_atou8(eq, &u);
2529 if (r < 0)
2530 return log_error_errno(r, "Failed to parse %s=%s", field, eq);
2531
2532 r = sd_bus_message_append(m, "(sv)", field, "i", (int) u);
2533 }
2534 if (r < 0)
2535 return bus_log_create_error(r);
2536
2537 return 1;
2538 }
2539
2540 if (unit_dependency_from_string(field) >= 0 ||
2541 STR_IN_SET(field, "Documentation",
2542 "RequiresMountsFor",
2543 "Markers"))
2544 return bus_append_strv(m, field, eq, EXTRACT_UNQUOTE);
2545
2546 t = condition_type_from_string(field);
2547 if (t >= 0)
2548 is_condition = true;
2549 else
2550 t = assert_type_from_string(field);
2551 if (t >= 0) {
2552 if (isempty(eq))
2553 r = sd_bus_message_append(m, "(sv)", is_condition ? "Conditions" : "Asserts", "a(sbbs)", 0);
2554 else {
2555 const char *p = eq;
2556 int trigger, negate;
2557
2558 trigger = *p == '|';
2559 if (trigger)
2560 p++;
2561
2562 negate = *p == '!';
2563 if (negate)
2564 p++;
2565
2566 r = sd_bus_message_append(m, "(sv)", is_condition ? "Conditions" : "Asserts", "a(sbbs)", 1,
2567 field, trigger, negate, p);
2568 }
2569 if (r < 0)
2570 return bus_log_create_error(r);
2571
2572 return 1;
2573 }
2574
2575 return 0;
2576 }
2577
2578 int bus_append_unit_property_assignment(sd_bus_message *m, UnitType t, const char *assignment) {
2579 const char *eq, *field;
2580 int r;
2581
2582 assert(m);
2583 assert(assignment);
2584
2585 eq = strchr(assignment, '=');
2586 if (!eq)
2587 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
2588 "Not an assignment: %s", assignment);
2589
2590 field = strndupa_safe(assignment, eq - assignment);
2591 eq++;
2592
2593 switch (t) {
2594 case UNIT_SERVICE:
2595 r = bus_append_cgroup_property(m, field, eq);
2596 if (r != 0)
2597 return r;
2598
2599 r = bus_append_execute_property(m, field, eq);
2600 if (r != 0)
2601 return r;
2602
2603 r = bus_append_kill_property(m, field, eq);
2604 if (r != 0)
2605 return r;
2606
2607 r = bus_append_service_property(m, field, eq);
2608 if (r != 0)
2609 return r;
2610 break;
2611
2612 case UNIT_SOCKET:
2613 r = bus_append_cgroup_property(m, field, eq);
2614 if (r != 0)
2615 return r;
2616
2617 r = bus_append_execute_property(m, field, eq);
2618 if (r != 0)
2619 return r;
2620
2621 r = bus_append_kill_property(m, field, eq);
2622 if (r != 0)
2623 return r;
2624
2625 r = bus_append_socket_property(m, field, eq);
2626 if (r != 0)
2627 return r;
2628 break;
2629
2630 case UNIT_TIMER:
2631 r = bus_append_timer_property(m, field, eq);
2632 if (r != 0)
2633 return r;
2634 break;
2635
2636 case UNIT_PATH:
2637 r = bus_append_path_property(m, field, eq);
2638 if (r != 0)
2639 return r;
2640 break;
2641
2642 case UNIT_SLICE:
2643 r = bus_append_cgroup_property(m, field, eq);
2644 if (r != 0)
2645 return r;
2646 break;
2647
2648 case UNIT_SCOPE:
2649 r = bus_append_cgroup_property(m, field, eq);
2650 if (r != 0)
2651 return r;
2652
2653 r = bus_append_kill_property(m, field, eq);
2654 if (r != 0)
2655 return r;
2656
2657 r = bus_append_scope_property(m, field, eq);
2658 if (r != 0)
2659 return r;
2660 break;
2661
2662 case UNIT_MOUNT:
2663 r = bus_append_cgroup_property(m, field, eq);
2664 if (r != 0)
2665 return r;
2666
2667 r = bus_append_execute_property(m, field, eq);
2668 if (r != 0)
2669 return r;
2670
2671 r = bus_append_kill_property(m, field, eq);
2672 if (r != 0)
2673 return r;
2674
2675 r = bus_append_mount_property(m, field, eq);
2676 if (r != 0)
2677 return r;
2678
2679 break;
2680
2681 case UNIT_AUTOMOUNT:
2682 r = bus_append_automount_property(m, field, eq);
2683 if (r != 0)
2684 return r;
2685
2686 break;
2687
2688 case UNIT_TARGET:
2689 case UNIT_DEVICE:
2690 case UNIT_SWAP:
2691 break;
2692
2693 default:
2694 assert_not_reached();
2695 }
2696
2697 r = bus_append_unit_property(m, field, eq);
2698 if (r != 0)
2699 return r;
2700
2701 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
2702 "Unknown assignment: %s", assignment);
2703 }
2704
2705 int bus_append_unit_property_assignment_many(sd_bus_message *m, UnitType t, char **l) {
2706 int r;
2707
2708 assert(m);
2709
2710 STRV_FOREACH(i, l) {
2711 r = bus_append_unit_property_assignment(m, t, *i);
2712 if (r < 0)
2713 return r;
2714 }
2715
2716 return 0;
2717 }
2718
2719 int bus_deserialize_and_dump_unit_file_changes(sd_bus_message *m, bool quiet) {
2720 const char *type, *path, *source;
2721 InstallChange *changes = NULL;
2722 size_t n_changes = 0;
2723 int r;
2724
2725 CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2726
2727 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sss)");
2728 if (r < 0)
2729 return bus_log_parse_error(r);
2730
2731 while ((r = sd_bus_message_read(m, "(sss)", &type, &path, &source)) > 0) {
2732 InstallChangeType t;
2733
2734 /* We expect only "success" changes to be sent over the bus. Hence, reject anything
2735 * negative. */
2736 t = install_change_type_from_string(type);
2737 if (t < 0) {
2738 log_notice_errno(t, "Manager reported unknown change type \"%s\" for path \"%s\", ignoring.",
2739 type, path);
2740 continue;
2741 }
2742
2743 r = install_changes_add(&changes, &n_changes, t, path, source);
2744 if (r < 0)
2745 return r;
2746 }
2747 if (r < 0)
2748 return bus_log_parse_error(r);
2749
2750 r = sd_bus_message_exit_container(m);
2751 if (r < 0)
2752 return bus_log_parse_error(r);
2753
2754 install_changes_dump(0, NULL, changes, n_changes, quiet);
2755
2756 return 0;
2757 }
2758
2759 int unit_load_state(sd_bus *bus, const char *name, char **load_state) {
2760 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2761 _cleanup_free_ char *path = NULL;
2762 int r;
2763
2764 path = unit_dbus_path_from_name(name);
2765 if (!path)
2766 return log_oom();
2767
2768 /* This function warns on its own, because otherwise it'd be awkward to pass
2769 * the dbus error message around. */
2770
2771 r = sd_bus_get_property_string(
2772 bus,
2773 "org.freedesktop.systemd1",
2774 path,
2775 "org.freedesktop.systemd1.Unit",
2776 "LoadState",
2777 &error,
2778 load_state);
2779 if (r < 0)
2780 return log_error_errno(r, "Failed to get load state of %s: %s", name, bus_error_message(&error, r));
2781
2782 return 0;
2783 }
2784
2785 int unit_info_compare(const UnitInfo *a, const UnitInfo *b) {
2786 int r;
2787
2788 /* First, order by machine */
2789 r = strcasecmp_ptr(a->machine, b->machine);
2790 if (r != 0)
2791 return r;
2792
2793 /* Second, order by unit type */
2794 r = strcasecmp_ptr(strrchr(a->id, '.'), strrchr(b->id, '.'));
2795 if (r != 0)
2796 return r;
2797
2798 /* Third, order by name */
2799 return strcasecmp(a->id, b->id);
2800 }
Unnamed repository; edit this file 'description' to name the repository.