]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/home/homectl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #20522 from yuwata/cgroup-fix
[thirdparty/systemd.git] / src / home / homectl.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <getopt.h>
4
5 #include "sd-bus.h"
6
7 #include "ask-password-api.h"
8 #include "bus-common-errors.h"
9 #include "bus-error.h"
10 #include "bus-locator.h"
11 #include "cgroup-util.h"
12 #include "dns-domain.h"
13 #include "env-util.h"
14 #include "fd-util.h"
15 #include "fileio.h"
16 #include "format-table.h"
17 #include "fs-util.h"
18 #include "glyph-util.h"
19 #include "home-util.h"
20 #include "homectl-fido2.h"
21 #include "homectl-pkcs11.h"
22 #include "homectl-recovery-key.h"
23 #include "libfido2-util.h"
24 #include "locale-util.h"
25 #include "main-func.h"
26 #include "memory-util.h"
27 #include "pager.h"
28 #include "parse-argument.h"
29 #include "parse-util.h"
30 #include "path-util.h"
31 #include "percent-util.h"
32 #include "pkcs11-util.h"
33 #include "pretty-print.h"
34 #include "process-util.h"
35 #include "pwquality-util.h"
36 #include "rlimit-util.h"
37 #include "spawn-polkit-agent.h"
38 #include "terminal-util.h"
39 #include "uid-alloc-range.h"
40 #include "user-record-pwquality.h"
41 #include "user-record-show.h"
42 #include "user-record-util.h"
43 #include "user-record.h"
44 #include "user-util.h"
45 #include "verbs.h"
46
47 static PagerFlags arg_pager_flags = 0;
48 static bool arg_legend = true;
49 static bool arg_ask_password = true;
50 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
51 static const char *arg_host = NULL;
52 static const char *arg_identity = NULL;
53 static JsonVariant *arg_identity_extra = NULL;
54 static JsonVariant *arg_identity_extra_privileged = NULL;
55 static JsonVariant *arg_identity_extra_this_machine = NULL;
56 static JsonVariant *arg_identity_extra_rlimits = NULL;
57 static char **arg_identity_filter = NULL; /* this one is also applied to 'privileged' and 'thisMachine' subobjects */
58 static char **arg_identity_filter_rlimits = NULL;
59 static uint64_t arg_disk_size = UINT64_MAX;
60 static uint64_t arg_disk_size_relative = UINT64_MAX;
61 static char **arg_pkcs11_token_uri = NULL;
62 static char **arg_fido2_device = NULL;
63 static Fido2EnrollFlags arg_fido2_lock_with = FIDO2ENROLL_PIN | FIDO2ENROLL_UP;
64 static bool arg_recovery_key = false;
65 static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
66 static bool arg_and_resize = false;
67 static bool arg_and_change_password = false;
68 static enum {
69 EXPORT_FORMAT_FULL, /* export the full record */
70 EXPORT_FORMAT_STRIPPED, /* strip "state" + "binding", but leave signature in place */
71 EXPORT_FORMAT_MINIMAL, /* also strip signature */
72 } arg_export_format = EXPORT_FORMAT_FULL;
73
74 STATIC_DESTRUCTOR_REGISTER(arg_identity_extra, json_variant_unrefp);
75 STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_this_machine, json_variant_unrefp);
76 STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_privileged, json_variant_unrefp);
77 STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_rlimits, json_variant_unrefp);
78 STATIC_DESTRUCTOR_REGISTER(arg_identity_filter, strv_freep);
79 STATIC_DESTRUCTOR_REGISTER(arg_identity_filter_rlimits, strv_freep);
80 STATIC_DESTRUCTOR_REGISTER(arg_pkcs11_token_uri, strv_freep);
81 STATIC_DESTRUCTOR_REGISTER(arg_fido2_device, strv_freep);
82
83 static const BusLocator *bus_mgr;
84
85 static bool identity_properties_specified(void) {
86 return
87 arg_identity ||
88 !json_variant_is_blank_object(arg_identity_extra) ||
89 !json_variant_is_blank_object(arg_identity_extra_privileged) ||
90 !json_variant_is_blank_object(arg_identity_extra_this_machine) ||
91 !json_variant_is_blank_object(arg_identity_extra_rlimits) ||
92 !strv_isempty(arg_identity_filter) ||
93 !strv_isempty(arg_identity_filter_rlimits) ||
94 !strv_isempty(arg_pkcs11_token_uri) ||
95 !strv_isempty(arg_fido2_device);
96 }
97
98 static int acquire_bus(sd_bus **bus) {
99 int r;
100
101 assert(bus);
102
103 if (*bus)
104 return 0;
105
106 r = bus_connect_transport(arg_transport, arg_host, false, bus);
107 if (r < 0)
108 return bus_log_connect_error(r, arg_transport);
109
110 (void) sd_bus_set_allow_interactive_authorization(*bus, arg_ask_password);
111
112 return 0;
113 }
114
115 static int list_homes(int argc, char *argv[], void *userdata) {
116 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
117 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
118 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
119 _cleanup_(table_unrefp) Table *table = NULL;
120 int r;
121
122 r = acquire_bus(&bus);
123 if (r < 0)
124 return r;
125
126 r = bus_call_method(bus, bus_mgr, "ListHomes", &error, &reply, NULL);
127 if (r < 0)
128 return log_error_errno(r, "Failed to list homes: %s", bus_error_message(&error, r));
129
130 table = table_new("name", "uid", "gid", "state", "realname", "home", "shell");
131 if (!table)
132 return log_oom();
133
134 r = sd_bus_message_enter_container(reply, 'a', "(susussso)");
135 if (r < 0)
136 return bus_log_parse_error(r);
137
138 for (;;) {
139 const char *name, *state, *realname, *home, *shell, *color;
140 TableCell *cell;
141 uint32_t uid, gid;
142
143 r = sd_bus_message_read(reply, "(susussso)", &name, &uid, &state, &gid, &realname, &home, &shell, NULL);
144 if (r < 0)
145 return bus_log_parse_error(r);
146 if (r == 0)
147 break;
148
149 r = table_add_many(table,
150 TABLE_STRING, name,
151 TABLE_UID, uid,
152 TABLE_GID, gid);
153 if (r < 0)
154 return table_log_add_error(r);
155
156
157 r = table_add_cell(table, &cell, TABLE_STRING, state);
158 if (r < 0)
159 return table_log_add_error(r);
160
161 color = user_record_state_color(state);
162 if (color)
163 (void) table_set_color(table, cell, color);
164
165 r = table_add_many(table,
166 TABLE_STRING, strna(empty_to_null(realname)),
167 TABLE_STRING, home,
168 TABLE_STRING, strna(empty_to_null(shell)));
169 if (r < 0)
170 return table_log_add_error(r);
171 }
172
173 r = sd_bus_message_exit_container(reply);
174 if (r < 0)
175 return bus_log_parse_error(r);
176
177 if (table_get_rows(table) > 1 || !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
178 r = table_set_sort(table, (size_t) 0);
179 if (r < 0)
180 return table_log_sort_error(r);
181
182 r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, arg_legend);
183 if (r < 0)
184 return r;
185 }
186
187 if (arg_legend && (arg_json_format_flags & JSON_FORMAT_OFF)) {
188 if (table_get_rows(table) > 1)
189 printf("\n%zu home areas listed.\n", table_get_rows(table) - 1);
190 else
191 printf("No home areas.\n");
192 }
193
194 return 0;
195 }
196
197 static int acquire_existing_password(
198 const char *user_name,
199 UserRecord *hr,
200 bool emphasize_current,
201 AskPasswordFlags flags) {
202
203 _cleanup_(strv_free_erasep) char **password = NULL;
204 _cleanup_free_ char *question = NULL;
205 char *e;
206 int r;
207
208 assert(user_name);
209 assert(hr);
210
211 e = getenv("PASSWORD");
212 if (e) {
213 /* People really shouldn't use environment variables for passing passwords. We support this
214 * only for testing purposes, and do not document the behaviour, so that people won't
215 * actually use this outside of testing. */
216
217 r = user_record_set_password(hr, STRV_MAKE(e), true);
218 if (r < 0)
219 return log_error_errno(r, "Failed to store password: %m");
220
221 assert_se(unsetenv_erase("PASSWORD") >= 0);
222 return 1;
223 }
224
225 /* If this is not our own user, then don't use the password cache */
226 if (is_this_me(user_name) <= 0)
227 SET_FLAG(flags, ASK_PASSWORD_ACCEPT_CACHED|ASK_PASSWORD_PUSH_CACHE, false);
228
229 if (asprintf(&question, emphasize_current ?
230 "Please enter current password for user %s:" :
231 "Please enter password for user %s:",
232 user_name) < 0)
233 return log_oom();
234
235 r = ask_password_auto(question,
236 /* icon= */ "user-home",
237 NULL,
238 /* key_name= */ "home-password",
239 /* credential_name= */ "home.password",
240 USEC_INFINITY,
241 flags,
242 &password);
243 if (r == -EUNATCH) { /* EUNATCH is returned if no password was found and asking interactively was
244 * disabled via the flags. Not an error for us. */
245 log_debug_errno(r, "No passwords acquired.");
246 return 0;
247 }
248 if (r < 0)
249 return log_error_errno(r, "Failed to acquire password: %m");
250
251 r = user_record_set_password(hr, password, true);
252 if (r < 0)
253 return log_error_errno(r, "Failed to store password: %m");
254
255 return 1;
256 }
257
258 static int acquire_recovery_key(
259 const char *user_name,
260 UserRecord *hr,
261 AskPasswordFlags flags) {
262
263 _cleanup_(strv_free_erasep) char **recovery_key = NULL;
264 _cleanup_free_ char *question = NULL;
265 char *e;
266 int r;
267
268 assert(user_name);
269 assert(hr);
270
271 e = getenv("RECOVERY_KEY");
272 if (e) {
273 /* People really shouldn't use environment variables for passing secrets. We support this
274 * only for testing purposes, and do not document the behaviour, so that people won't
275 * actually use this outside of testing. */
276
277 r = user_record_set_password(hr, STRV_MAKE(e), true); /* recovery keys are stored in the record exactly like regular passwords! */
278 if (r < 0)
279 return log_error_errno(r, "Failed to store recovery key: %m");
280
281 assert_se(unsetenv_erase("RECOVERY_KEY") >= 0);
282 return 1;
283 }
284
285 /* If this is not our own user, then don't use the password cache */
286 if (is_this_me(user_name) <= 0)
287 SET_FLAG(flags, ASK_PASSWORD_ACCEPT_CACHED|ASK_PASSWORD_PUSH_CACHE, false);
288
289 if (asprintf(&question, "Please enter recovery key for user %s:", user_name) < 0)
290 return log_oom();
291
292 r = ask_password_auto(question,
293 /* icon= */ "user-home",
294 NULL,
295 /* key_name= */ "home-recovery-key",
296 /* credential_name= */ "home.recovery-key",
297 USEC_INFINITY,
298 flags,
299 &recovery_key);
300 if (r == -EUNATCH) { /* EUNATCH is returned if no recovery key was found and asking interactively was
301 * disabled via the flags. Not an error for us. */
302 log_debug_errno(r, "No recovery keys acquired.");
303 return 0;
304 }
305 if (r < 0)
306 return log_error_errno(r, "Failed to acquire recovery keys: %m");
307
308 r = user_record_set_password(hr, recovery_key, true);
309 if (r < 0)
310 return log_error_errno(r, "Failed to store recovery keys: %m");
311
312 return 1;
313 }
314
315 static int acquire_token_pin(
316 const char *user_name,
317 UserRecord *hr,
318 AskPasswordFlags flags) {
319
320 _cleanup_(strv_free_erasep) char **pin = NULL;
321 _cleanup_free_ char *question = NULL;
322 char *e;
323 int r;
324
325 assert(user_name);
326 assert(hr);
327
328 e = getenv("PIN");
329 if (e) {
330 r = user_record_set_token_pin(hr, STRV_MAKE(e), false);
331 if (r < 0)
332 return log_error_errno(r, "Failed to store token PIN: %m");
333
334 assert_se(unsetenv_erase("PIN") >= 0);
335 return 1;
336 }
337
338 /* If this is not our own user, then don't use the password cache */
339 if (is_this_me(user_name) <= 0)
340 SET_FLAG(flags, ASK_PASSWORD_ACCEPT_CACHED|ASK_PASSWORD_PUSH_CACHE, false);
341
342 if (asprintf(&question, "Please enter security token PIN for user %s:", user_name) < 0)
343 return log_oom();
344
345 r = ask_password_auto(
346 question,
347 /* icon= */ "user-home",
348 NULL,
349 /* key_name= */ "token-pin",
350 /* credential_name= */ "home.token-pin",
351 USEC_INFINITY,
352 flags,
353 &pin);
354 if (r == -EUNATCH) { /* EUNATCH is returned if no PIN was found and asking interactively was disabled
355 * via the flags. Not an error for us. */
356 log_debug_errno(r, "No security token PINs acquired.");
357 return 0;
358 }
359 if (r < 0)
360 return log_error_errno(r, "Failed to acquire security token PIN: %m");
361
362 r = user_record_set_token_pin(hr, pin, false);
363 if (r < 0)
364 return log_error_errno(r, "Failed to store security token PIN: %m");
365
366 return 1;
367 }
368
369 static int handle_generic_user_record_error(
370 const char *user_name,
371 UserRecord *hr,
372 const sd_bus_error *error,
373 int ret,
374 bool emphasize_current_password) {
375 int r;
376
377 assert(user_name);
378 assert(hr);
379
380 if (sd_bus_error_has_name(error, BUS_ERROR_HOME_ABSENT))
381 return log_error_errno(SYNTHETIC_ERRNO(EREMOTE),
382 "Home of user %s is currently absent, please plug in the necessary storage device or backing file system.", user_name);
383
384 else if (sd_bus_error_has_name(error, BUS_ERROR_AUTHENTICATION_LIMIT_HIT))
385 return log_error_errno(SYNTHETIC_ERRNO(ETOOMANYREFS),
386 "Too frequent unsuccessful login attempts for user %s, try again later.", user_name);
387
388 else if (sd_bus_error_has_name(error, BUS_ERROR_BAD_PASSWORD)) {
389
390 if (!strv_isempty(hr->password))
391 log_notice("Password incorrect or not sufficient, please try again.");
392
393 /* Don't consume cache entries or credentials here, we already tried that unsuccessfully. But
394 * let's push what we acquire here into the cache */
395 r = acquire_existing_password(
396 user_name,
397 hr,
398 emphasize_current_password,
399 ASK_PASSWORD_PUSH_CACHE | ASK_PASSWORD_NO_CREDENTIAL);
400 if (r < 0)
401 return r;
402
403 } else if (sd_bus_error_has_name(error, BUS_ERROR_BAD_RECOVERY_KEY)) {
404
405 if (!strv_isempty(hr->password))
406 log_notice("Recovery key incorrect or not sufficient, please try again.");
407
408 /* Don't consume cache entries or credentials here, we already tried that unsuccessfully. But
409 * let's push what we acquire here into the cache */
410 r = acquire_recovery_key(
411 user_name,
412 hr,
413 ASK_PASSWORD_PUSH_CACHE | ASK_PASSWORD_NO_CREDENTIAL);
414 if (r < 0)
415 return r;
416
417 } else if (sd_bus_error_has_name(error, BUS_ERROR_BAD_PASSWORD_AND_NO_TOKEN)) {
418
419 if (strv_isempty(hr->password))
420 log_notice("Security token not inserted, please enter password.");
421 else
422 log_notice("Password incorrect or not sufficient, and configured security token not inserted, please try again.");
423
424 r = acquire_existing_password(
425 user_name,
426 hr,
427 emphasize_current_password,
428 ASK_PASSWORD_PUSH_CACHE | ASK_PASSWORD_NO_CREDENTIAL);
429 if (r < 0)
430 return r;
431
432 } else if (sd_bus_error_has_name(error, BUS_ERROR_TOKEN_PIN_NEEDED)) {
433
434 /* First time the PIN is requested, let's accept cached data, and allow using credential store */
435 r = acquire_token_pin(
436 user_name,
437 hr,
438 ASK_PASSWORD_ACCEPT_CACHED | ASK_PASSWORD_PUSH_CACHE);
439 if (r < 0)
440 return r;
441
442 } else if (sd_bus_error_has_name(error, BUS_ERROR_TOKEN_PROTECTED_AUTHENTICATION_PATH_NEEDED)) {
443
444 log_notice("%s%sPlease authenticate physically on security token.",
445 emoji_enabled() ? special_glyph(SPECIAL_GLYPH_TOUCH) : "",
446 emoji_enabled() ? " " : "");
447
448 r = user_record_set_pkcs11_protected_authentication_path_permitted(hr, true);
449 if (r < 0)
450 return log_error_errno(r, "Failed to set PKCS#11 protected authentication path permitted flag: %m");
451
452 } else if (sd_bus_error_has_name(error, BUS_ERROR_TOKEN_USER_PRESENCE_NEEDED)) {
453
454 log_notice("%s%sPlease confirm presence on security token.",
455 emoji_enabled() ? special_glyph(SPECIAL_GLYPH_TOUCH) : "",
456 emoji_enabled() ? " " : "");
457
458 r = user_record_set_fido2_user_presence_permitted(hr, true);
459 if (r < 0)
460 return log_error_errno(r, "Failed to set FIDO2 user presence permitted flag: %m");
461
462 } else if (sd_bus_error_has_name(error, BUS_ERROR_TOKEN_USER_VERIFICATION_NEEDED)) {
463
464 log_notice("%s%sPlease verify user on security token.",
465 emoji_enabled() ? special_glyph(SPECIAL_GLYPH_TOUCH) : "",
466 emoji_enabled() ? " " : "");
467
468 r = user_record_set_fido2_user_verification_permitted(hr, true);
469 if (r < 0)
470 return log_error_errno(r, "Failed to set FIDO2 user verification permitted flag: %m");
471
472 } else if (sd_bus_error_has_name(error, BUS_ERROR_TOKEN_PIN_LOCKED))
473 return log_error_errno(SYNTHETIC_ERRNO(EPERM), "Security token PIN is locked, please unlock it first. (Hint: Removal and re-insertion might suffice.)");
474
475 else if (sd_bus_error_has_name(error, BUS_ERROR_TOKEN_BAD_PIN)) {
476
477 log_notice("Security token PIN incorrect, please try again.");
478
479 /* If the previous PIN was wrong don't accept cached info anymore, but add to cache. Also, don't use the credential data */
480 r = acquire_token_pin(
481 user_name,
482 hr,
483 ASK_PASSWORD_PUSH_CACHE | ASK_PASSWORD_NO_CREDENTIAL);
484 if (r < 0)
485 return r;
486
487 } else if (sd_bus_error_has_name(error, BUS_ERROR_TOKEN_BAD_PIN_FEW_TRIES_LEFT)) {
488
489 log_notice("Security token PIN incorrect, please try again (only a few tries left!).");
490
491 r = acquire_token_pin(
492 user_name,
493 hr,
494 ASK_PASSWORD_PUSH_CACHE | ASK_PASSWORD_NO_CREDENTIAL);
495 if (r < 0)
496 return r;
497
498 } else if (sd_bus_error_has_name(error, BUS_ERROR_TOKEN_BAD_PIN_ONE_TRY_LEFT)) {
499
500 log_notice("Security token PIN incorrect, please try again (only one try left!).");
501
502 r = acquire_token_pin(
503 user_name,
504 hr,
505 ASK_PASSWORD_PUSH_CACHE | ASK_PASSWORD_NO_CREDENTIAL);
506 if (r < 0)
507 return r;
508 } else
509 return log_error_errno(ret, "Operation on home %s failed: %s", user_name, bus_error_message(error, ret));
510
511 return 0;
512 }
513
514 static int acquire_passed_secrets(const char *user_name, UserRecord **ret) {
515 _cleanup_(user_record_unrefp) UserRecord *secret = NULL;
516 int r;
517
518 assert(ret);
519
520 /* Generates an initial secret objects that contains passwords supplied via $PASSWORD, the password
521 * cache or the credentials subsystem, but excluding any interactive stuff. If nothing is passed,
522 * returns an empty secret object. */
523
524 secret = user_record_new();
525 if (!secret)
526 return log_oom();
527
528 r = acquire_existing_password(
529 user_name,
530 secret,
531 /* emphasize_current_password = */ false,
532 ASK_PASSWORD_ACCEPT_CACHED | ASK_PASSWORD_NO_TTY | ASK_PASSWORD_NO_AGENT);
533 if (r < 0)
534 return r;
535
536 r = acquire_token_pin(
537 user_name,
538 secret,
539 ASK_PASSWORD_ACCEPT_CACHED | ASK_PASSWORD_NO_TTY | ASK_PASSWORD_NO_AGENT);
540 if (r < 0)
541 return r;
542
543 r = acquire_recovery_key(
544 user_name,
545 secret,
546 ASK_PASSWORD_ACCEPT_CACHED | ASK_PASSWORD_NO_TTY | ASK_PASSWORD_NO_AGENT);
547 if (r < 0)
548 return r;
549
550 *ret = TAKE_PTR(secret);
551 return 0;
552 }
553
554 static int activate_home(int argc, char *argv[], void *userdata) {
555 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
556 int r, ret = 0;
557 char **i;
558
559 r = acquire_bus(&bus);
560 if (r < 0)
561 return r;
562
563 STRV_FOREACH(i, strv_skip(argv, 1)) {
564 _cleanup_(user_record_unrefp) UserRecord *secret = NULL;
565
566 r = acquire_passed_secrets(*i, &secret);
567 if (r < 0)
568 return r;
569
570 for (;;) {
571 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
572 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
573
574 r = bus_message_new_method_call(bus, &m, bus_mgr, "ActivateHome");
575 if (r < 0)
576 return bus_log_create_error(r);
577
578 r = sd_bus_message_append(m, "s", *i);
579 if (r < 0)
580 return bus_log_create_error(r);
581
582 r = bus_message_append_secret(m, secret);
583 if (r < 0)
584 return bus_log_create_error(r);
585
586 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
587 if (r < 0) {
588 r = handle_generic_user_record_error(*i, secret, &error, r, /* emphasize_current_password= */ false);
589 if (r < 0) {
590 if (ret == 0)
591 ret = r;
592
593 break;
594 }
595 } else
596 break;
597 }
598 }
599
600 return ret;
601 }
602
603 static int deactivate_home(int argc, char *argv[], void *userdata) {
604 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
605 int r, ret = 0;
606 char **i;
607
608 r = acquire_bus(&bus);
609 if (r < 0)
610 return r;
611
612 STRV_FOREACH(i, strv_skip(argv, 1)) {
613 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
614 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
615
616 r = bus_message_new_method_call(bus, &m, bus_mgr, "DeactivateHome");
617 if (r < 0)
618 return bus_log_create_error(r);
619
620 r = sd_bus_message_append(m, "s", *i);
621 if (r < 0)
622 return bus_log_create_error(r);
623
624 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
625 if (r < 0) {
626 log_error_errno(r, "Failed to deactivate user home: %s", bus_error_message(&error, r));
627 if (ret == 0)
628 ret = r;
629 }
630 }
631
632 return ret;
633 }
634
635 static void dump_home_record(UserRecord *hr) {
636 int r;
637
638 assert(hr);
639
640 if (hr->incomplete) {
641 fflush(stdout);
642 log_warning("Warning: lacking rights to acquire privileged fields of user record of '%s', output incomplete.", hr->user_name);
643 }
644
645 if (arg_json_format_flags & JSON_FORMAT_OFF)
646 user_record_show(hr, true);
647 else {
648 _cleanup_(user_record_unrefp) UserRecord *stripped = NULL;
649
650 if (arg_export_format == EXPORT_FORMAT_STRIPPED)
651 r = user_record_clone(hr, USER_RECORD_EXTRACT_EMBEDDED|USER_RECORD_PERMISSIVE, &stripped);
652 else if (arg_export_format == EXPORT_FORMAT_MINIMAL)
653 r = user_record_clone(hr, USER_RECORD_EXTRACT_SIGNABLE|USER_RECORD_PERMISSIVE, &stripped);
654 else
655 r = 0;
656 if (r < 0)
657 log_warning_errno(r, "Failed to strip user record, ignoring: %m");
658 if (stripped)
659 hr = stripped;
660
661 json_variant_dump(hr->json, arg_json_format_flags, stdout, NULL);
662 }
663 }
664
665 static char **mangle_user_list(char **list, char ***ret_allocated) {
666 _cleanup_free_ char *myself = NULL;
667 char **l;
668
669 if (!strv_isempty(list)) {
670 *ret_allocated = NULL;
671 return list;
672 }
673
674 myself = getusername_malloc();
675 if (!myself)
676 return NULL;
677
678 l = new(char*, 2);
679 if (!l)
680 return NULL;
681
682 l[0] = TAKE_PTR(myself);
683 l[1] = NULL;
684
685 *ret_allocated = l;
686 return l;
687 }
688
689 static int inspect_home(int argc, char *argv[], void *userdata) {
690 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
691 _cleanup_(strv_freep) char **mangled_list = NULL;
692 int r, ret = 0;
693 char **items, **i;
694
695 pager_open(arg_pager_flags);
696
697 r = acquire_bus(&bus);
698 if (r < 0)
699 return r;
700
701 items = mangle_user_list(strv_skip(argv, 1), &mangled_list);
702 if (!items)
703 return log_oom();
704
705 STRV_FOREACH(i, items) {
706 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
707 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
708 _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
709 _cleanup_(user_record_unrefp) UserRecord *hr = NULL;
710 const char *json;
711 int incomplete;
712 uid_t uid;
713
714 r = parse_uid(*i, &uid);
715 if (r < 0) {
716 if (!valid_user_group_name(*i, 0)) {
717 log_error("Invalid user name '%s'.", *i);
718 if (ret == 0)
719 ret = -EINVAL;
720
721 continue;
722 }
723
724 r = bus_call_method(bus, bus_mgr, "GetUserRecordByName", &error, &reply, "s", *i);
725 } else
726 r = bus_call_method(bus, bus_mgr, "GetUserRecordByUID", &error, &reply, "u", (uint32_t) uid);
727
728 if (r < 0) {
729 log_error_errno(r, "Failed to inspect home: %s", bus_error_message(&error, r));
730 if (ret == 0)
731 ret = r;
732
733 continue;
734 }
735
736 r = sd_bus_message_read(reply, "sbo", &json, &incomplete, NULL);
737 if (r < 0) {
738 bus_log_parse_error(r);
739 if (ret == 0)
740 ret = r;
741
742 continue;
743 }
744
745 r = json_parse(json, JSON_PARSE_SENSITIVE, &v, NULL, NULL);
746 if (r < 0) {
747 log_error_errno(r, "Failed to parse JSON identity: %m");
748 if (ret == 0)
749 ret = r;
750
751 continue;
752 }
753
754 hr = user_record_new();
755 if (!hr)
756 return log_oom();
757
758 r = user_record_load(hr, v, USER_RECORD_LOAD_REFUSE_SECRET|USER_RECORD_LOG|USER_RECORD_PERMISSIVE);
759 if (r < 0) {
760 if (ret == 0)
761 ret = r;
762
763 continue;
764 }
765
766 hr->incomplete = incomplete;
767 dump_home_record(hr);
768 }
769
770 return ret;
771 }
772
773 static int authenticate_home(int argc, char *argv[], void *userdata) {
774 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
775 _cleanup_(strv_freep) char **mangled_list = NULL;
776 int r, ret = 0;
777 char **i, **items;
778
779 items = mangle_user_list(strv_skip(argv, 1), &mangled_list);
780 if (!items)
781 return log_oom();
782
783 r = acquire_bus(&bus);
784 if (r < 0)
785 return r;
786
787 (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
788
789 STRV_FOREACH(i, items) {
790 _cleanup_(user_record_unrefp) UserRecord *secret = NULL;
791
792 r = acquire_passed_secrets(*i, &secret);
793 if (r < 0)
794 return r;
795
796 for (;;) {
797 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
798 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
799
800 r = bus_message_new_method_call(bus, &m, bus_mgr, "AuthenticateHome");
801 if (r < 0)
802 return bus_log_create_error(r);
803
804 r = sd_bus_message_append(m, "s", *i);
805 if (r < 0)
806 return bus_log_create_error(r);
807
808 r = bus_message_append_secret(m, secret);
809 if (r < 0)
810 return bus_log_create_error(r);
811
812 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
813 if (r < 0) {
814 r = handle_generic_user_record_error(*i, secret, &error, r, false);
815 if (r < 0) {
816 if (ret == 0)
817 ret = r;
818
819 break;
820 }
821 } else
822 break;
823 }
824 }
825
826 return ret;
827 }
828
829 static int update_last_change(JsonVariant **v, bool with_password, bool override) {
830 JsonVariant *c;
831 usec_t n;
832 int r;
833
834 assert(v);
835
836 n = now(CLOCK_REALTIME);
837
838 c = json_variant_by_key(*v, "lastChangeUSec");
839 if (c) {
840 uint64_t u;
841
842 if (!override)
843 goto update_password;
844
845 if (!json_variant_is_unsigned(c))
846 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "lastChangeUSec field is not an unsigned integer, refusing.");
847
848 u = json_variant_unsigned(c);
849 if (u >= n)
850 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "lastChangeUSec is from the future, can't update.");
851 }
852
853 r = json_variant_set_field_unsigned(v, "lastChangeUSec", n);
854 if (r < 0)
855 return log_error_errno(r, "Failed to update lastChangeUSec: %m");
856
857 update_password:
858 if (!with_password)
859 return 0;
860
861 c = json_variant_by_key(*v, "lastPasswordChangeUSec");
862 if (c) {
863 uint64_t u;
864
865 if (!override)
866 return 0;
867
868 if (!json_variant_is_unsigned(c))
869 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "lastPasswordChangeUSec field is not an unsigned integer, refusing.");
870
871 u = json_variant_unsigned(c);
872 if (u >= n)
873 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "lastPasswordChangeUSec is from the future, can't update.");
874 }
875
876 r = json_variant_set_field_unsigned(v, "lastPasswordChangeUSec", n);
877 if (r < 0)
878 return log_error_errno(r, "Failed to update lastPasswordChangeUSec: %m");
879
880 return 1;
881 }
882
883 static int apply_identity_changes(JsonVariant **_v) {
884 _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
885 int r;
886
887 assert(_v);
888
889 v = json_variant_ref(*_v);
890
891 r = json_variant_filter(&v, arg_identity_filter);
892 if (r < 0)
893 return log_error_errno(r, "Failed to filter identity: %m");
894
895 r = json_variant_merge(&v, arg_identity_extra);
896 if (r < 0)
897 return log_error_errno(r, "Failed to merge identities: %m");
898
899 if (arg_identity_extra_this_machine || !strv_isempty(arg_identity_filter)) {
900 _cleanup_(json_variant_unrefp) JsonVariant *per_machine = NULL, *mmid = NULL;
901 sd_id128_t mid;
902
903 r = sd_id128_get_machine(&mid);
904 if (r < 0)
905 return log_error_errno(r, "Failed to acquire machine ID: %m");
906
907 r = json_variant_new_string(&mmid, SD_ID128_TO_STRING(mid));
908 if (r < 0)
909 return log_error_errno(r, "Failed to allocate matchMachineId object: %m");
910
911 per_machine = json_variant_ref(json_variant_by_key(v, "perMachine"));
912 if (per_machine) {
913 _cleanup_(json_variant_unrefp) JsonVariant *npm = NULL, *add = NULL;
914 _cleanup_free_ JsonVariant **array = NULL;
915 JsonVariant *z;
916 size_t i = 0;
917
918 if (!json_variant_is_array(per_machine))
919 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "perMachine field is not an array, refusing.");
920
921 array = new(JsonVariant*, json_variant_elements(per_machine) + 1);
922 if (!array)
923 return log_oom();
924
925 JSON_VARIANT_ARRAY_FOREACH(z, per_machine) {
926 JsonVariant *u;
927
928 if (!json_variant_is_object(z))
929 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "perMachine entry is not an object, refusing.");
930
931 array[i++] = z;
932
933 u = json_variant_by_key(z, "matchMachineId");
934 if (!u)
935 continue;
936
937 if (!json_variant_equal(u, mmid))
938 continue;
939
940 r = json_variant_merge(&add, z);
941 if (r < 0)
942 return log_error_errno(r, "Failed to merge perMachine entry: %m");
943
944 i--;
945 }
946
947 r = json_variant_filter(&add, arg_identity_filter);
948 if (r < 0)
949 return log_error_errno(r, "Failed to filter perMachine: %m");
950
951 r = json_variant_merge(&add, arg_identity_extra_this_machine);
952 if (r < 0)
953 return log_error_errno(r, "Failed to merge in perMachine fields: %m");
954
955 if (arg_identity_filter_rlimits || arg_identity_extra_rlimits) {
956 _cleanup_(json_variant_unrefp) JsonVariant *rlv = NULL;
957
958 rlv = json_variant_ref(json_variant_by_key(add, "resourceLimits"));
959
960 r = json_variant_filter(&rlv, arg_identity_filter_rlimits);
961 if (r < 0)
962 return log_error_errno(r, "Failed to filter resource limits: %m");
963
964 r = json_variant_merge(&rlv, arg_identity_extra_rlimits);
965 if (r < 0)
966 return log_error_errno(r, "Failed to set resource limits: %m");
967
968 if (json_variant_is_blank_object(rlv)) {
969 r = json_variant_filter(&add, STRV_MAKE("resourceLimits"));
970 if (r < 0)
971 return log_error_errno(r, "Failed to drop resource limits field from identity: %m");
972 } else {
973 r = json_variant_set_field(&add, "resourceLimits", rlv);
974 if (r < 0)
975 return log_error_errno(r, "Failed to update resource limits of identity: %m");
976 }
977 }
978
979 if (!json_variant_is_blank_object(add)) {
980 r = json_variant_set_field(&add, "matchMachineId", mmid);
981 if (r < 0)
982 return log_error_errno(r, "Failed to set matchMachineId field: %m");
983
984 array[i++] = add;
985 }
986
987 r = json_variant_new_array(&npm, array, i);
988 if (r < 0)
989 return log_error_errno(r, "Failed to allocate new perMachine array: %m");
990
991 json_variant_unref(per_machine);
992 per_machine = TAKE_PTR(npm);
993 } else {
994 _cleanup_(json_variant_unrefp) JsonVariant *item = json_variant_ref(arg_identity_extra_this_machine);
995
996 if (arg_identity_extra_rlimits) {
997 r = json_variant_set_field(&item, "resourceLimits", arg_identity_extra_rlimits);
998 if (r < 0)
999 return log_error_errno(r, "Failed to update resource limits of identity: %m");
1000 }
1001
1002 r = json_variant_set_field(&item, "matchMachineId", mmid);
1003 if (r < 0)
1004 return log_error_errno(r, "Failed to set matchMachineId field: %m");
1005
1006 r = json_variant_append_array(&per_machine, item);
1007 if (r < 0)
1008 return log_error_errno(r, "Failed to append to perMachine array: %m");
1009 }
1010
1011 r = json_variant_set_field(&v, "perMachine", per_machine);
1012 if (r < 0)
1013 return log_error_errno(r, "Failed to update per machine record: %m");
1014 }
1015
1016 if (arg_identity_extra_privileged || arg_identity_filter) {
1017 _cleanup_(json_variant_unrefp) JsonVariant *privileged = NULL;
1018
1019 privileged = json_variant_ref(json_variant_by_key(v, "privileged"));
1020
1021 r = json_variant_filter(&privileged, arg_identity_filter);
1022 if (r < 0)
1023 return log_error_errno(r, "Failed to filter identity (privileged part): %m");
1024
1025 r = json_variant_merge(&privileged, arg_identity_extra_privileged);
1026 if (r < 0)
1027 return log_error_errno(r, "Failed to merge identities (privileged part): %m");
1028
1029 if (json_variant_is_blank_object(privileged)) {
1030 r = json_variant_filter(&v, STRV_MAKE("privileged"));
1031 if (r < 0)
1032 return log_error_errno(r, "Failed to drop privileged part from identity: %m");
1033 } else {
1034 r = json_variant_set_field(&v, "privileged", privileged);
1035 if (r < 0)
1036 return log_error_errno(r, "Failed to update privileged part of identity: %m");
1037 }
1038 }
1039
1040 if (arg_identity_filter_rlimits) {
1041 _cleanup_(json_variant_unrefp) JsonVariant *rlv = NULL;
1042
1043 rlv = json_variant_ref(json_variant_by_key(v, "resourceLimits"));
1044
1045 r = json_variant_filter(&rlv, arg_identity_filter_rlimits);
1046 if (r < 0)
1047 return log_error_errno(r, "Failed to filter resource limits: %m");
1048
1049 /* Note that we only filter resource limits here, but don't apply them. We do that in the perMachine section */
1050
1051 if (json_variant_is_blank_object(rlv)) {
1052 r = json_variant_filter(&v, STRV_MAKE("resourceLimits"));
1053 if (r < 0)
1054 return log_error_errno(r, "Failed to drop resource limits field from identity: %m");
1055 } else {
1056 r = json_variant_set_field(&v, "resourceLimits", rlv);
1057 if (r < 0)
1058 return log_error_errno(r, "Failed to update resource limits of identity: %m");
1059 }
1060 }
1061
1062 json_variant_unref(*_v);
1063 *_v = TAKE_PTR(v);
1064
1065 return 0;
1066 }
1067
1068 static int add_disposition(JsonVariant **v) {
1069 int r;
1070
1071 assert(v);
1072
1073 if (json_variant_by_key(*v, "disposition"))
1074 return 0;
1075
1076 /* Set the disposition to regular, if not configured explicitly */
1077 r = json_variant_set_field_string(v, "disposition", "regular");
1078 if (r < 0)
1079 return log_error_errno(r, "Failed to set disposition field: %m");
1080
1081 return 1;
1082 }
1083
1084 static int acquire_new_home_record(UserRecord **ret) {
1085 _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
1086 _cleanup_(user_record_unrefp) UserRecord *hr = NULL;
1087 char **i;
1088 int r;
1089
1090 assert(ret);
1091
1092 if (arg_identity) {
1093 unsigned line, column;
1094
1095 r = json_parse_file(
1096 streq(arg_identity, "-") ? stdin : NULL,
1097 streq(arg_identity, "-") ? "<stdin>" : arg_identity, JSON_PARSE_SENSITIVE, &v, &line, &column);
1098 if (r < 0)
1099 return log_error_errno(r, "Failed to parse identity at %u:%u: %m", line, column);
1100 }
1101
1102 r = apply_identity_changes(&v);
1103 if (r < 0)
1104 return r;
1105
1106 r = add_disposition(&v);
1107 if (r < 0)
1108 return r;
1109
1110 STRV_FOREACH(i, arg_pkcs11_token_uri) {
1111 r = identity_add_pkcs11_key_data(&v, *i);
1112 if (r < 0)
1113 return r;
1114 }
1115
1116 STRV_FOREACH(i, arg_fido2_device) {
1117 r = identity_add_fido2_parameters(&v, *i, arg_fido2_lock_with);
1118 if (r < 0)
1119 return r;
1120 }
1121
1122 if (arg_recovery_key) {
1123 r = identity_add_recovery_key(&v);
1124 if (r < 0)
1125 return r;
1126 }
1127
1128 r = update_last_change(&v, true, false);
1129 if (r < 0)
1130 return r;
1131
1132 if (DEBUG_LOGGING)
1133 json_variant_dump(v, JSON_FORMAT_PRETTY, NULL, NULL);
1134
1135 hr = user_record_new();
1136 if (!hr)
1137 return log_oom();
1138
1139 r = user_record_load(hr, v, USER_RECORD_REQUIRE_REGULAR|USER_RECORD_ALLOW_SECRET|USER_RECORD_ALLOW_PRIVILEGED|USER_RECORD_ALLOW_PER_MACHINE|USER_RECORD_ALLOW_SIGNATURE|USER_RECORD_LOG|USER_RECORD_PERMISSIVE);
1140 if (r < 0)
1141 return r;
1142
1143 *ret = TAKE_PTR(hr);
1144 return 0;
1145 }
1146
1147 static int acquire_new_password(
1148 const char *user_name,
1149 UserRecord *hr,
1150 bool suggest,
1151 char **ret) {
1152
1153 unsigned i = 5;
1154 char *e;
1155 int r;
1156
1157 assert(user_name);
1158 assert(hr);
1159
1160 e = getenv("NEWPASSWORD");
1161 if (e) {
1162 _cleanup_(erase_and_freep) char *copy = NULL;
1163
1164 /* As above, this is not for use, just for testing */
1165
1166 if (ret) {
1167 copy = strdup(e);
1168 if (!copy)
1169 return log_oom();
1170 }
1171
1172 r = user_record_set_password(hr, STRV_MAKE(e), /* prepend = */ true);
1173 if (r < 0)
1174 return log_error_errno(r, "Failed to store password: %m");
1175
1176 assert_se(unsetenv_erase("NEWPASSWORD") >= 0);
1177
1178 if (ret)
1179 *ret = TAKE_PTR(copy);
1180
1181 return 0;
1182 }
1183
1184 if (suggest)
1185 (void) suggest_passwords();
1186
1187 for (;;) {
1188 _cleanup_(strv_free_erasep) char **first = NULL, **second = NULL;
1189 _cleanup_free_ char *question = NULL;
1190
1191 if (--i == 0)
1192 return log_error_errno(SYNTHETIC_ERRNO(ENOKEY), "Too many attempts, giving up:");
1193
1194 if (asprintf(&question, "Please enter new password for user %s:", user_name) < 0)
1195 return log_oom();
1196
1197 r = ask_password_auto(
1198 question,
1199 /* icon= */ "user-home",
1200 NULL,
1201 /* key_name= */ "home-password",
1202 /* credential_name= */ "home.new-password",
1203 USEC_INFINITY,
1204 0, /* no caching, we want to collect a new password here after all */
1205 &first);
1206 if (r < 0)
1207 return log_error_errno(r, "Failed to acquire password: %m");
1208
1209 question = mfree(question);
1210 if (asprintf(&question, "Please enter new password for user %s (repeat):", user_name) < 0)
1211 return log_oom();
1212
1213 r = ask_password_auto(
1214 question,
1215 /* icon= */ "user-home",
1216 NULL,
1217 /* key_name= */ "home-password",
1218 /* credential_name= */ "home.new-password",
1219 USEC_INFINITY,
1220 0, /* no caching */
1221 &second);
1222 if (r < 0)
1223 return log_error_errno(r, "Failed to acquire password: %m");
1224
1225 if (strv_equal(first, second)) {
1226 _cleanup_(erase_and_freep) char *copy = NULL;
1227
1228 if (ret) {
1229 copy = strdup(first[0]);
1230 if (!copy)
1231 return log_oom();
1232 }
1233
1234 r = user_record_set_password(hr, first, /* prepend = */ true);
1235 if (r < 0)
1236 return log_error_errno(r, "Failed to store password: %m");
1237
1238 if (ret)
1239 *ret = TAKE_PTR(copy);
1240
1241 return 0;
1242 }
1243
1244 log_error("Password didn't match, try again.");
1245 }
1246 }
1247
1248 static int create_home(int argc, char *argv[], void *userdata) {
1249 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1250 _cleanup_(user_record_unrefp) UserRecord *hr = NULL;
1251 int r;
1252
1253 r = acquire_bus(&bus);
1254 if (r < 0)
1255 return r;
1256
1257 (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
1258
1259 if (argc >= 2) {
1260 /* If a username was specified, use it */
1261
1262 if (valid_user_group_name(argv[1], 0))
1263 r = json_variant_set_field_string(&arg_identity_extra, "userName", argv[1]);
1264 else {
1265 _cleanup_free_ char *un = NULL, *rr = NULL;
1266
1267 /* Before we consider the user name invalid, let's check if we can split it? */
1268 r = split_user_name_realm(argv[1], &un, &rr);
1269 if (r < 0)
1270 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "User name '%s' is not valid: %m", argv[1]);
1271
1272 if (rr) {
1273 r = json_variant_set_field_string(&arg_identity_extra, "realm", rr);
1274 if (r < 0)
1275 return log_error_errno(r, "Failed to set realm field: %m");
1276 }
1277
1278 r = json_variant_set_field_string(&arg_identity_extra, "userName", un);
1279 }
1280 if (r < 0)
1281 return log_error_errno(r, "Failed to set userName field: %m");
1282 } else {
1283 /* If neither a username nor an identity have been specified we cannot operate. */
1284 if (!arg_identity)
1285 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "User name required.");
1286 }
1287
1288 r = acquire_new_home_record(&hr);
1289 if (r < 0)
1290 return r;
1291
1292 /* If the JSON record carries no plain text password (besides the recovery key), then let's query it
1293 * manually. */
1294 if (strv_length(hr->password) <= arg_recovery_key) {
1295
1296 if (strv_isempty(hr->hashed_password)) {
1297 _cleanup_(erase_and_freep) char *new_password = NULL;
1298
1299 /* No regular (i.e. non-PKCS#11) hashed passwords set in the record, let's fix that. */
1300 r = acquire_new_password(hr->user_name, hr, /* suggest = */ true, &new_password);
1301 if (r < 0)
1302 return r;
1303
1304 r = user_record_make_hashed_password(hr, STRV_MAKE(new_password), /* extend = */ false);
1305 if (r < 0)
1306 return log_error_errno(r, "Failed to hash password: %m");
1307 } else {
1308 /* There's a hash password set in the record, acquire the unhashed version of it. */
1309 r = acquire_existing_password(
1310 hr->user_name,
1311 hr,
1312 /* emphasize_current= */ false,
1313 ASK_PASSWORD_ACCEPT_CACHED | ASK_PASSWORD_PUSH_CACHE);
1314 if (r < 0)
1315 return r;
1316 }
1317 }
1318
1319 if (hr->enforce_password_policy == 0) {
1320 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1321
1322 /* If password quality enforcement is disabled, let's at least warn client side */
1323
1324 r = user_record_quality_check_password(hr, hr, &error);
1325 if (r < 0)
1326 log_warning_errno(r, "Specified password does not pass quality checks (%s), proceeding anyway.", bus_error_message(&error, r));
1327 }
1328
1329 for (;;) {
1330 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1331 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1332 _cleanup_(erase_and_freep) char *formatted = NULL;
1333
1334 r = json_variant_format(hr->json, 0, &formatted);
1335 if (r < 0)
1336 return log_error_errno(r, "Failed to format user record: %m");
1337
1338 r = bus_message_new_method_call(bus, &m, bus_mgr, "CreateHome");
1339 if (r < 0)
1340 return bus_log_create_error(r);
1341
1342 (void) sd_bus_message_sensitive(m);
1343
1344 r = sd_bus_message_append(m, "s", formatted);
1345 if (r < 0)
1346 return bus_log_create_error(r);
1347
1348 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1349 if (r < 0) {
1350 if (sd_bus_error_has_name(&error, BUS_ERROR_LOW_PASSWORD_QUALITY)) {
1351 _cleanup_(erase_and_freep) char *new_password = NULL;
1352
1353 log_error_errno(r, "%s", bus_error_message(&error, r));
1354 log_info("(Use --enforce-password-policy=no to turn off password quality checks for this account.)");
1355
1356 r = acquire_new_password(hr->user_name, hr, /* suggest = */ false, &new_password);
1357 if (r < 0)
1358 return r;
1359
1360 r = user_record_make_hashed_password(hr, STRV_MAKE(new_password), /* extend = */ false);
1361 if (r < 0)
1362 return log_error_errno(r, "Failed to hash passwords: %m");
1363 } else {
1364 r = handle_generic_user_record_error(hr->user_name, hr, &error, r, false);
1365 if (r < 0)
1366 return r;
1367 }
1368 } else
1369 break; /* done */
1370 }
1371
1372 return 0;
1373 }
1374
1375 static int remove_home(int argc, char *argv[], void *userdata) {
1376 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1377 int r, ret = 0;
1378 char **i;
1379
1380 r = acquire_bus(&bus);
1381 if (r < 0)
1382 return r;
1383
1384 (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
1385
1386 STRV_FOREACH(i, strv_skip(argv, 1)) {
1387 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1388 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1389
1390 r = bus_message_new_method_call(bus, &m, bus_mgr, "RemoveHome");
1391 if (r < 0)
1392 return bus_log_create_error(r);
1393
1394 r = sd_bus_message_append(m, "s", *i);
1395 if (r < 0)
1396 return bus_log_create_error(r);
1397
1398 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1399 if (r < 0) {
1400 log_error_errno(r, "Failed to remove home: %s", bus_error_message(&error, r));
1401 if (ret == 0)
1402 ret = r;
1403 }
1404 }
1405
1406 return ret;
1407 }
1408
1409 static int acquire_updated_home_record(
1410 sd_bus *bus,
1411 const char *username,
1412 UserRecord **ret) {
1413
1414 _cleanup_(json_variant_unrefp) JsonVariant *json = NULL;
1415 _cleanup_(user_record_unrefp) UserRecord *hr = NULL;
1416 char **i;
1417 int r;
1418
1419 assert(ret);
1420
1421 if (arg_identity) {
1422 unsigned line, column;
1423 JsonVariant *un;
1424
1425 r = json_parse_file(
1426 streq(arg_identity, "-") ? stdin : NULL,
1427 streq(arg_identity, "-") ? "<stdin>" : arg_identity, JSON_PARSE_SENSITIVE, &json, &line, &column);
1428 if (r < 0)
1429 return log_error_errno(r, "Failed to parse identity at %u:%u: %m", line, column);
1430
1431 un = json_variant_by_key(json, "userName");
1432 if (un) {
1433 if (!json_variant_is_string(un) || (username && !streq(json_variant_string(un), username)))
1434 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "User name specified on command line and in JSON record do not match.");
1435 } else {
1436 if (!username)
1437 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No username specified.");
1438
1439 r = json_variant_set_field_string(&arg_identity_extra, "userName", username);
1440 if (r < 0)
1441 return log_error_errno(r, "Failed to set userName field: %m");
1442 }
1443
1444 } else {
1445 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1446 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1447 int incomplete;
1448 const char *text;
1449
1450 if (!identity_properties_specified())
1451 return log_error_errno(SYNTHETIC_ERRNO(EALREADY), "No field to change specified.");
1452
1453 r = bus_call_method(bus, bus_mgr, "GetUserRecordByName", &error, &reply, "s", username);
1454 if (r < 0)
1455 return log_error_errno(r, "Failed to acquire user home record: %s", bus_error_message(&error, r));
1456
1457 r = sd_bus_message_read(reply, "sbo", &text, &incomplete, NULL);
1458 if (r < 0)
1459 return bus_log_parse_error(r);
1460
1461 if (incomplete)
1462 return log_error_errno(SYNTHETIC_ERRNO(EACCES), "Lacking rights to acquire user record including privileged metadata, can't update record.");
1463
1464 r = json_parse(text, JSON_PARSE_SENSITIVE, &json, NULL, NULL);
1465 if (r < 0)
1466 return log_error_errno(r, "Failed to parse JSON identity: %m");
1467
1468 reply = sd_bus_message_unref(reply);
1469
1470 r = json_variant_filter(&json, STRV_MAKE("binding", "status", "signature"));
1471 if (r < 0)
1472 return log_error_errno(r, "Failed to strip binding and status from record to update: %m");
1473 }
1474
1475 r = apply_identity_changes(&json);
1476 if (r < 0)
1477 return r;
1478
1479 STRV_FOREACH(i, arg_pkcs11_token_uri) {
1480 r = identity_add_pkcs11_key_data(&json, *i);
1481 if (r < 0)
1482 return r;
1483 }
1484
1485 STRV_FOREACH(i, arg_fido2_device) {
1486 r = identity_add_fido2_parameters(&json, *i, arg_fido2_lock_with);
1487 if (r < 0)
1488 return r;
1489 }
1490
1491 /* If the user supplied a full record, then add in lastChange, but do not override. Otherwise always
1492 * override. */
1493 r = update_last_change(&json, arg_pkcs11_token_uri || arg_fido2_device, !arg_identity);
1494 if (r < 0)
1495 return r;
1496
1497 if (DEBUG_LOGGING)
1498 json_variant_dump(json, JSON_FORMAT_PRETTY, NULL, NULL);
1499
1500 hr = user_record_new();
1501 if (!hr)
1502 return log_oom();
1503
1504 r = user_record_load(hr, json, USER_RECORD_REQUIRE_REGULAR|USER_RECORD_ALLOW_PRIVILEGED|USER_RECORD_ALLOW_PER_MACHINE|USER_RECORD_ALLOW_SECRET|USER_RECORD_ALLOW_SIGNATURE|USER_RECORD_LOG|USER_RECORD_PERMISSIVE);
1505 if (r < 0)
1506 return r;
1507
1508 *ret = TAKE_PTR(hr);
1509 return 0;
1510 }
1511
1512 static int home_record_reset_human_interaction_permission(UserRecord *hr) {
1513 int r;
1514
1515 assert(hr);
1516
1517 /* When we execute multiple operations one after the other, let's reset the permission to ask the
1518 * user each time, so that if interaction is necessary we will be told so again and thus can print a
1519 * nice message to the user, telling the user so. */
1520
1521 r = user_record_set_pkcs11_protected_authentication_path_permitted(hr, -1);
1522 if (r < 0)
1523 return log_error_errno(r, "Failed to reset PKCS#11 protected authentication path permission flag: %m");
1524
1525 r = user_record_set_fido2_user_presence_permitted(hr, -1);
1526 if (r < 0)
1527 return log_error_errno(r, "Failed to reset FIDO2 user presence permission flag: %m");
1528
1529 r = user_record_set_fido2_user_verification_permitted(hr, -1);
1530 if (r < 0)
1531 return log_error_errno(r, "Failed to reset FIDO2 user verification permission flag: %m");
1532
1533 return 0;
1534 }
1535
1536 static int update_home(int argc, char *argv[], void *userdata) {
1537 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1538 _cleanup_(user_record_unrefp) UserRecord *hr = NULL, *secret = NULL;
1539 _cleanup_free_ char *buffer = NULL;
1540 const char *username;
1541 int r;
1542
1543 if (argc >= 2)
1544 username = argv[1];
1545 else if (!arg_identity) {
1546 buffer = getusername_malloc();
1547 if (!buffer)
1548 return log_oom();
1549
1550 username = buffer;
1551 } else
1552 username = NULL;
1553
1554 r = acquire_bus(&bus);
1555 if (r < 0)
1556 return r;
1557
1558 (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
1559
1560 r = acquire_updated_home_record(bus, username, &hr);
1561 if (r < 0)
1562 return r;
1563
1564 /* Add in all secrets we can acquire cheaply */
1565 r = acquire_passed_secrets(username, &secret);
1566 if (r < 0)
1567 return r;
1568
1569 r = user_record_merge_secret(hr, secret);
1570 if (r < 0)
1571 return r;
1572
1573 /* If we do multiple operations, let's output things more verbosely, since otherwise the repeated
1574 * authentication might be confusing. */
1575
1576 if (arg_and_resize || arg_and_change_password)
1577 log_info("Updating home directory.");
1578
1579 for (;;) {
1580 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1581 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1582 _cleanup_free_ char *formatted = NULL;
1583
1584 r = bus_message_new_method_call(bus, &m, bus_mgr, "UpdateHome");
1585 if (r < 0)
1586 return bus_log_create_error(r);
1587
1588 r = json_variant_format(hr->json, 0, &formatted);
1589 if (r < 0)
1590 return log_error_errno(r, "Failed to format user record: %m");
1591
1592 (void) sd_bus_message_sensitive(m);
1593
1594 r = sd_bus_message_append(m, "s", formatted);
1595 if (r < 0)
1596 return bus_log_create_error(r);
1597
1598 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1599 if (r < 0) {
1600 if (arg_and_change_password &&
1601 sd_bus_error_has_name(&error, BUS_ERROR_BAD_PASSWORD_AND_NO_TOKEN))
1602 /* In the generic handler we'd ask for a password in this case, but when
1603 * changing passwords that's not sufficient, as we need to acquire all keys
1604 * first. */
1605 return log_error_errno(r, "Security token not inserted, refusing.");
1606
1607 r = handle_generic_user_record_error(hr->user_name, hr, &error, r, false);
1608 if (r < 0)
1609 return r;
1610 } else
1611 break;
1612 }
1613
1614 if (arg_and_resize)
1615 log_info("Resizing home.");
1616
1617 (void) home_record_reset_human_interaction_permission(hr);
1618
1619 /* Also sync down disk size to underlying LUKS/fscrypt/quota */
1620 while (arg_and_resize) {
1621 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1622 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1623
1624 r = bus_message_new_method_call(bus, &m, bus_mgr, "ResizeHome");
1625 if (r < 0)
1626 return bus_log_create_error(r);
1627
1628 /* Specify UINT64_MAX as size, in which case the underlying disk size will just be synced */
1629 r = sd_bus_message_append(m, "st", hr->user_name, UINT64_MAX);
1630 if (r < 0)
1631 return bus_log_create_error(r);
1632
1633 r = bus_message_append_secret(m, hr);
1634 if (r < 0)
1635 return bus_log_create_error(r);
1636
1637 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1638 if (r < 0) {
1639 if (arg_and_change_password &&
1640 sd_bus_error_has_name(&error, BUS_ERROR_BAD_PASSWORD_AND_NO_TOKEN))
1641 return log_error_errno(r, "Security token not inserted, refusing.");
1642
1643 r = handle_generic_user_record_error(hr->user_name, hr, &error, r, false);
1644 if (r < 0)
1645 return r;
1646 } else
1647 break;
1648 }
1649
1650 if (arg_and_change_password)
1651 log_info("Synchronizing passwords and encryption keys.");
1652
1653 (void) home_record_reset_human_interaction_permission(hr);
1654
1655 /* Also sync down passwords to underlying LUKS/fscrypt */
1656 while (arg_and_change_password) {
1657 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1658 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1659
1660 r = bus_message_new_method_call(bus, &m, bus_mgr, "ChangePasswordHome");
1661 if (r < 0)
1662 return bus_log_create_error(r);
1663
1664 /* Specify an empty new secret, in which case the underlying LUKS/fscrypt password will just be synced */
1665 r = sd_bus_message_append(m, "ss", hr->user_name, "{}");
1666 if (r < 0)
1667 return bus_log_create_error(r);
1668
1669 r = bus_message_append_secret(m, hr);
1670 if (r < 0)
1671 return bus_log_create_error(r);
1672
1673 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1674 if (r < 0) {
1675 if (sd_bus_error_has_name(&error, BUS_ERROR_BAD_PASSWORD_AND_NO_TOKEN))
1676 return log_error_errno(r, "Security token not inserted, refusing.");
1677
1678 r = handle_generic_user_record_error(hr->user_name, hr, &error, r, false);
1679 if (r < 0)
1680 return r;
1681 } else
1682 break;
1683 }
1684
1685 return 0;
1686 }
1687
1688 static int passwd_home(int argc, char *argv[], void *userdata) {
1689 _cleanup_(user_record_unrefp) UserRecord *old_secret = NULL, *new_secret = NULL;
1690 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1691 _cleanup_free_ char *buffer = NULL;
1692 const char *username;
1693 int r;
1694
1695 if (arg_pkcs11_token_uri)
1696 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "To change the PKCS#11 security token use 'homectl update --pkcs11-token-uri=…'.");
1697 if (arg_fido2_device)
1698 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "To change the FIDO2 security token use 'homectl update --fido2-device=…'.");
1699 if (identity_properties_specified())
1700 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "The 'passwd' verb does not permit changing other record properties at the same time.");
1701
1702 if (argc >= 2)
1703 username = argv[1];
1704 else {
1705 buffer = getusername_malloc();
1706 if (!buffer)
1707 return log_oom();
1708
1709 username = buffer;
1710 }
1711
1712 r = acquire_bus(&bus);
1713 if (r < 0)
1714 return r;
1715
1716 (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
1717
1718 r = acquire_passed_secrets(username, &old_secret);
1719 if (r < 0)
1720 return r;
1721
1722 new_secret = user_record_new();
1723 if (!new_secret)
1724 return log_oom();
1725
1726 r = acquire_new_password(username, new_secret, /* suggest = */ true, NULL);
1727 if (r < 0)
1728 return r;
1729
1730 for (;;) {
1731 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1732 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1733
1734 r = bus_message_new_method_call(bus, &m, bus_mgr, "ChangePasswordHome");
1735 if (r < 0)
1736 return bus_log_create_error(r);
1737
1738 r = sd_bus_message_append(m, "s", username);
1739 if (r < 0)
1740 return bus_log_create_error(r);
1741
1742 r = bus_message_append_secret(m, new_secret);
1743 if (r < 0)
1744 return bus_log_create_error(r);
1745
1746 r = bus_message_append_secret(m, old_secret);
1747 if (r < 0)
1748 return bus_log_create_error(r);
1749
1750 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1751 if (r < 0) {
1752 if (sd_bus_error_has_name(&error, BUS_ERROR_LOW_PASSWORD_QUALITY)) {
1753
1754 log_error_errno(r, "%s", bus_error_message(&error, r));
1755
1756 r = acquire_new_password(username, new_secret, /* suggest = */ false, NULL);
1757
1758 } else if (sd_bus_error_has_name(&error, BUS_ERROR_BAD_PASSWORD_AND_NO_TOKEN))
1759
1760 /* In the generic handler we'd ask for a password in this case, but when
1761 * changing passwords that's not sufficeint, as we need to acquire all keys
1762 * first. */
1763 return log_error_errno(r, "Security token not inserted, refusing.");
1764 else
1765 r = handle_generic_user_record_error(username, old_secret, &error, r, true);
1766 if (r < 0)
1767 return r;
1768 } else
1769 break;
1770 }
1771
1772 return 0;
1773 }
1774
1775 static int parse_disk_size(const char *t, uint64_t *ret) {
1776 int r;
1777
1778 assert(t);
1779 assert(ret);
1780
1781 if (streq(t, "min"))
1782 *ret = 0;
1783 else if (streq(t, "max"))
1784 *ret = UINT64_MAX-1; /* Largest size that isn't UINT64_MAX special marker */
1785 else {
1786 uint64_t ds;
1787
1788 r = parse_size(t, 1024, &ds);
1789 if (r < 0)
1790 return log_error_errno(r, "Failed to parse disk size parameter: %s", t);
1791
1792 if (ds >= UINT64_MAX) /* UINT64_MAX has special meaning for us ("dont change"), refuse */
1793 return log_error_errno(SYNTHETIC_ERRNO(ERANGE), "Disk size out of range: %s", t);
1794
1795 *ret = ds;
1796 }
1797
1798 return 0;
1799 }
1800
1801 static int resize_home(int argc, char *argv[], void *userdata) {
1802 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1803 _cleanup_(user_record_unrefp) UserRecord *secret = NULL;
1804 uint64_t ds = UINT64_MAX;
1805 int r;
1806
1807 r = acquire_bus(&bus);
1808 if (r < 0)
1809 return r;
1810
1811 (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
1812
1813 if (arg_disk_size_relative != UINT64_MAX ||
1814 (argc > 2 && parse_permyriad(argv[2]) >= 0))
1815 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
1816 "Relative disk size specification currently not supported when resizing.");
1817
1818 if (argc > 2) {
1819 r = parse_disk_size(argv[2], &ds);
1820 if (r < 0)
1821 return r;
1822 }
1823
1824 if (arg_disk_size != UINT64_MAX) {
1825 if (ds != UINT64_MAX && ds != arg_disk_size)
1826 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Disk size specified twice and doesn't match, refusing.");
1827
1828 ds = arg_disk_size;
1829 }
1830
1831 r = acquire_passed_secrets(argv[1], &secret);
1832 if (r < 0)
1833 return r;
1834
1835 for (;;) {
1836 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1837 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1838
1839 r = bus_message_new_method_call(bus, &m, bus_mgr, "ResizeHome");
1840 if (r < 0)
1841 return bus_log_create_error(r);
1842
1843 r = sd_bus_message_append(m, "st", argv[1], ds);
1844 if (r < 0)
1845 return bus_log_create_error(r);
1846
1847 r = bus_message_append_secret(m, secret);
1848 if (r < 0)
1849 return bus_log_create_error(r);
1850
1851 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1852 if (r < 0) {
1853 r = handle_generic_user_record_error(argv[1], secret, &error, r, false);
1854 if (r < 0)
1855 return r;
1856 } else
1857 break;
1858 }
1859
1860 return 0;
1861 }
1862
1863 static int lock_home(int argc, char *argv[], void *userdata) {
1864 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1865 int r, ret = 0;
1866 char **i;
1867
1868 r = acquire_bus(&bus);
1869 if (r < 0)
1870 return r;
1871
1872 STRV_FOREACH(i, strv_skip(argv, 1)) {
1873 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1874 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1875
1876 r = bus_message_new_method_call(bus, &m, bus_mgr, "LockHome");
1877 if (r < 0)
1878 return bus_log_create_error(r);
1879
1880 r = sd_bus_message_append(m, "s", *i);
1881 if (r < 0)
1882 return bus_log_create_error(r);
1883
1884 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1885 if (r < 0) {
1886 log_error_errno(r, "Failed to lock home: %s", bus_error_message(&error, r));
1887 if (ret == 0)
1888 ret = r;
1889 }
1890 }
1891
1892 return ret;
1893 }
1894
1895 static int unlock_home(int argc, char *argv[], void *userdata) {
1896 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1897 int r, ret = 0;
1898 char **i;
1899
1900 r = acquire_bus(&bus);
1901 if (r < 0)
1902 return r;
1903
1904 STRV_FOREACH(i, strv_skip(argv, 1)) {
1905 _cleanup_(user_record_unrefp) UserRecord *secret = NULL;
1906
1907 r = acquire_passed_secrets(*i, &secret);
1908 if (r < 0)
1909 return r;
1910
1911 for (;;) {
1912 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1913 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1914
1915 r = bus_message_new_method_call(bus, &m, bus_mgr, "UnlockHome");
1916 if (r < 0)
1917 return bus_log_create_error(r);
1918
1919 r = sd_bus_message_append(m, "s", *i);
1920 if (r < 0)
1921 return bus_log_create_error(r);
1922
1923 r = bus_message_append_secret(m, secret);
1924 if (r < 0)
1925 return bus_log_create_error(r);
1926
1927 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
1928 if (r < 0) {
1929 r = handle_generic_user_record_error(argv[1], secret, &error, r, false);
1930 if (r < 0) {
1931 if (ret == 0)
1932 ret = r;
1933
1934 break;
1935 }
1936 } else
1937 break;
1938 }
1939 }
1940
1941 return ret;
1942 }
1943
1944 static int with_home(int argc, char *argv[], void *userdata) {
1945 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1946 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
1947 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1948 _cleanup_(user_record_unrefp) UserRecord *secret = NULL;
1949 _cleanup_close_ int acquired_fd = -1;
1950 _cleanup_strv_free_ char **cmdline = NULL;
1951 const char *home;
1952 int r, ret;
1953 pid_t pid;
1954
1955 r = acquire_bus(&bus);
1956 if (r < 0)
1957 return r;
1958
1959 if (argc < 3) {
1960 _cleanup_free_ char *shell = NULL;
1961
1962 /* If no command is specified, spawn a shell */
1963 r = get_shell(&shell);
1964 if (r < 0)
1965 return log_error_errno(r, "Failed to acquire shell: %m");
1966
1967 cmdline = strv_new(shell);
1968 } else
1969 cmdline = strv_copy(argv + 2);
1970 if (!cmdline)
1971 return log_oom();
1972
1973 r = acquire_passed_secrets(argv[1], &secret);
1974 if (r < 0)
1975 return r;
1976
1977 for (;;) {
1978 r = bus_message_new_method_call(bus, &m, bus_mgr, "AcquireHome");
1979 if (r < 0)
1980 return bus_log_create_error(r);
1981
1982 r = sd_bus_message_append(m, "s", argv[1]);
1983 if (r < 0)
1984 return bus_log_create_error(r);
1985
1986 r = bus_message_append_secret(m, secret);
1987 if (r < 0)
1988 return bus_log_create_error(r);
1989
1990 r = sd_bus_message_append(m, "b", /* please_suspend = */ getenv_bool("SYSTEMD_PLEASE_SUSPEND_HOME") > 0);
1991 if (r < 0)
1992 return bus_log_create_error(r);
1993
1994 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, &reply);
1995 m = sd_bus_message_unref(m);
1996 if (r < 0) {
1997 r = handle_generic_user_record_error(argv[1], secret, &error, r, false);
1998 if (r < 0)
1999 return r;
2000
2001 sd_bus_error_free(&error);
2002 } else {
2003 int fd;
2004
2005 r = sd_bus_message_read(reply, "h", &fd);
2006 if (r < 0)
2007 return bus_log_parse_error(r);
2008
2009 acquired_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2010 if (acquired_fd < 0)
2011 return log_error_errno(errno, "Failed to duplicate acquired fd: %m");
2012
2013 reply = sd_bus_message_unref(reply);
2014 break;
2015 }
2016 }
2017
2018 r = bus_call_method(bus, bus_mgr, "GetHomeByName", &error, &reply, "s", argv[1]);
2019 if (r < 0)
2020 return log_error_errno(r, "Failed to inspect home: %s", bus_error_message(&error, r));
2021
2022 r = sd_bus_message_read(reply, "usussso", NULL, NULL, NULL, NULL, &home, NULL, NULL);
2023 if (r < 0)
2024 return bus_log_parse_error(r);
2025
2026 r = safe_fork("(with)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG|FORK_LOG|FORK_RLIMIT_NOFILE_SAFE|FORK_REOPEN_LOG, &pid);
2027 if (r < 0)
2028 return r;
2029 if (r == 0) {
2030 if (chdir(home) < 0) {
2031 log_error_errno(errno, "Failed to change to directory %s: %m", home);
2032 _exit(255);
2033 }
2034
2035 execvp(cmdline[0], cmdline);
2036 log_error_errno(errno, "Failed to execute %s: %m", cmdline[0]);
2037 _exit(255);
2038 }
2039
2040 ret = wait_for_terminate_and_check(cmdline[0], pid, WAIT_LOG_ABNORMAL);
2041
2042 /* Close the fd that pings the home now. */
2043 acquired_fd = safe_close(acquired_fd);
2044
2045 r = bus_message_new_method_call(bus, &m, bus_mgr, "ReleaseHome");
2046 if (r < 0)
2047 return bus_log_create_error(r);
2048
2049 r = sd_bus_message_append(m, "s", argv[1]);
2050 if (r < 0)
2051 return bus_log_create_error(r);
2052
2053 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
2054 if (r < 0) {
2055 if (sd_bus_error_has_name(&error, BUS_ERROR_HOME_BUSY))
2056 log_notice("Not deactivating home directory of %s, as it is still used.", argv[1]);
2057 else
2058 return log_error_errno(r, "Failed to release user home: %s", bus_error_message(&error, r));
2059 }
2060
2061 return ret;
2062 }
2063
2064 static int lock_all_homes(int argc, char *argv[], void *userdata) {
2065 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2066 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2067 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2068 int r;
2069
2070 r = acquire_bus(&bus);
2071 if (r < 0)
2072 return r;
2073
2074 r = bus_message_new_method_call(bus, &m, bus_mgr, "LockAllHomes");
2075 if (r < 0)
2076 return bus_log_create_error(r);
2077
2078 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
2079 if (r < 0)
2080 return log_error_errno(r, "Failed to lock all homes: %s", bus_error_message(&error, r));
2081
2082 return 0;
2083 }
2084
2085 static int deactivate_all_homes(int argc, char *argv[], void *userdata) {
2086 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2087 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2088 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2089 int r;
2090
2091 r = acquire_bus(&bus);
2092 if (r < 0)
2093 return r;
2094
2095 r = bus_message_new_method_call(bus, &m, bus_mgr, "DeactivateAllHomes");
2096 if (r < 0)
2097 return bus_log_create_error(r);
2098
2099 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
2100 if (r < 0)
2101 return log_error_errno(r, "Failed to deactivate all homes: %s", bus_error_message(&error, r));
2102
2103 return 0;
2104 }
2105
2106 static int rebalance(int argc, char *argv[], void *userdata) {
2107 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2108 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2109 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2110 int r;
2111
2112 r = acquire_bus(&bus);
2113 if (r < 0)
2114 return r;
2115
2116 r = bus_message_new_method_call(bus, &m, bus_mgr, "Rebalance");
2117 if (r < 0)
2118 return bus_log_create_error(r);
2119
2120 r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
2121 if (r < 0) {
2122 if (sd_bus_error_has_name(&error, BUS_ERROR_REBALANCE_NOT_NEEDED))
2123 log_info("No homes needed rebalancing.");
2124 else
2125 return log_error_errno(r, "Failed to rebalance: %s", bus_error_message(&error, r));
2126 } else
2127 log_info("Completed rebalancing.");
2128
2129 return 0;
2130 }
2131
2132 static int drop_from_identity(const char *field) {
2133 int r;
2134
2135 assert(field);
2136
2137 /* If we are called to update an identity record and drop some field, let's keep track of what to
2138 * remove from the old record */
2139 r = strv_extend(&arg_identity_filter, field);
2140 if (r < 0)
2141 return log_oom();
2142
2143 /* Let's also drop the field if it was previously set to a new value on the same command line */
2144 r = json_variant_filter(&arg_identity_extra, STRV_MAKE(field));
2145 if (r < 0)
2146 return log_error_errno(r, "Failed to filter JSON identity data: %m");
2147
2148 r = json_variant_filter(&arg_identity_extra_this_machine, STRV_MAKE(field));
2149 if (r < 0)
2150 return log_error_errno(r, "Failed to filter JSON identity data: %m");
2151
2152 r = json_variant_filter(&arg_identity_extra_privileged, STRV_MAKE(field));
2153 if (r < 0)
2154 return log_error_errno(r, "Failed to filter JSON identity data: %m");
2155
2156 return 0;
2157 }
2158
2159 static int help(int argc, char *argv[], void *userdata) {
2160 _cleanup_free_ char *link = NULL;
2161 int r;
2162
2163 pager_open(arg_pager_flags);
2164
2165 r = terminal_urlify_man("homectl", "1", &link);
2166 if (r < 0)
2167 return log_oom();
2168
2169 printf("%1$s [OPTIONS...] COMMAND ...\n\n"
2170 "%2$sCreate, manipulate or inspect home directories.%3$s\n"
2171 "\n%4$sCommands:%5$s\n"
2172 " list List home areas\n"
2173 " activate USER… Activate a home area\n"
2174 " deactivate USER… Deactivate a home area\n"
2175 " inspect USER… Inspect a home area\n"
2176 " authenticate USER… Authenticate a home area\n"
2177 " create USER Create a home area\n"
2178 " remove USER… Remove a home area\n"
2179 " update USER Update a home area\n"
2180 " passwd USER Change password of a home area\n"
2181 " resize USER SIZE Resize a home area\n"
2182 " lock USER… Temporarily lock an active home area\n"
2183 " unlock USER… Unlock a temporarily locked home area\n"
2184 " lock-all Lock all suitable home areas\n"
2185 " deactivate-all Deactivate all active home areas\n"
2186 " rebalance Rebalance free space between home areas\n"
2187 " with USER [COMMAND…] Run shell or command with access to a home area\n"
2188 "\n%4$sOptions:%5$s\n"
2189 " -h --help Show this help\n"
2190 " --version Show package version\n"
2191 " --no-pager Do not pipe output into a pager\n"
2192 " --no-legend Do not show the headers and footers\n"
2193 " --no-ask-password Do not ask for system passwords\n"
2194 " -H --host=[USER@]HOST Operate on remote host\n"
2195 " -M --machine=CONTAINER Operate on local container\n"
2196 " --identity=PATH Read JSON identity from file\n"
2197 " --json=FORMAT Output inspection data in JSON (takes one of\n"
2198 " pretty, short, off)\n"
2199 " -j Equivalent to --json=pretty (on TTY) or\n"
2200 " --json=short (otherwise)\n"
2201 " --export-format= Strip JSON inspection data (full, stripped,\n"
2202 " minimal)\n"
2203 " -E When specified once equals -j --export-format=\n"
2204 " stripped, when specified twice equals\n"
2205 " -j --export-format=minimal\n"
2206 "\n%4$sGeneral User Record Properties:%5$s\n"
2207 " -c --real-name=REALNAME Real name for user\n"
2208 " --realm=REALM Realm to create user in\n"
2209 " --email-address=EMAIL Email address for user\n"
2210 " --location=LOCATION Set location of user on earth\n"
2211 " --icon-name=NAME Icon name for user\n"
2212 " -d --home-dir=PATH Home directory\n"
2213 " -u --uid=UID Numeric UID for user\n"
2214 " -G --member-of=GROUP Add user to group\n"
2215 " --skel=PATH Skeleton directory to use\n"
2216 " --shell=PATH Shell for account\n"
2217 " --setenv=VARIABLE[=VALUE] Set an environment variable at log-in\n"
2218 " --timezone=TIMEZONE Set a time-zone\n"
2219 " --language=LOCALE Set preferred language\n"
2220 " --ssh-authorized-keys=KEYS\n"
2221 " Specify SSH public keys\n"
2222 " --pkcs11-token-uri=URI URI to PKCS#11 security token containing\n"
2223 " private key and matching X.509 certificate\n"
2224 " --fido2-device=PATH Path to FIDO2 hidraw device with hmac-secret\n"
2225 " extension\n"
2226 " --fido2-with-client-pin=BOOL\n"
2227 " Whether to require entering a PIN to unlock the\n"
2228 " account\n"
2229 " --fido2-with-user-presence=BOOL\n"
2230 " Whether to require user presence to unlock the\n"
2231 " account\n"
2232 " --fido2-with-user-verification=BOOL\n"
2233 " Whether to require user verification to unlock\n"
2234 " the account\n"
2235 " --recovery-key=BOOL Add a recovery key\n"
2236 "\n%4$sAccount Management User Record Properties:%5$s\n"
2237 " --locked=BOOL Set locked account state\n"
2238 " --not-before=TIMESTAMP Do not allow logins before\n"
2239 " --not-after=TIMESTAMP Do not allow logins after\n"
2240 " --rate-limit-interval=SECS\n"
2241 " Login rate-limit interval in seconds\n"
2242 " --rate-limit-burst=NUMBER\n"
2243 " Login rate-limit attempts per interval\n"
2244 "\n%4$sPassword Policy User Record Properties:%5$s\n"
2245 " --password-hint=HINT Set Password hint\n"
2246 " --enforce-password-policy=BOOL\n"
2247 " Control whether to enforce system's password\n"
2248 " policy for this user\n"
2249 " -P Same as --enforce-password-password=no\n"
2250 " --password-change-now=BOOL\n"
2251 " Require the password to be changed on next login\n"
2252 " --password-change-min=TIME\n"
2253 " Require minimum time between password changes\n"
2254 " --password-change-max=TIME\n"
2255 " Require maximum time between password changes\n"
2256 " --password-change-warn=TIME\n"
2257 " How much time to warn before password expiry\n"
2258 " --password-change-inactive=TIME\n"
2259 " How much time to block password after expiry\n"
2260 "\n%4$sResource Management User Record Properties:%5$s\n"
2261 " --disk-size=BYTES Size to assign the user on disk\n"
2262 " --access-mode=MODE User home directory access mode\n"
2263 " --umask=MODE Umask for user when logging in\n"
2264 " --nice=NICE Nice level for user\n"
2265 " --rlimit=LIMIT=VALUE[:VALUE]\n"
2266 " Set resource limits\n"
2267 " --tasks-max=MAX Set maximum number of per-user tasks\n"
2268 " --memory-high=BYTES Set high memory threshold in bytes\n"
2269 " --memory-max=BYTES Set maximum memory limit\n"
2270 " --cpu-weight=WEIGHT Set CPU weight\n"
2271 " --io-weight=WEIGHT Set IO weight\n"
2272 "\n%4$sStorage User Record Properties:%5$s\n"
2273 " --storage=STORAGE Storage type to use (luks, fscrypt, directory,\n"
2274 " subvolume, cifs)\n"
2275 " --image-path=PATH Path to image file/directory\n"
2276 " --drop-caches=BOOL Whether to automatically drop caches on logout\n"
2277 "\n%4$sLUKS Storage User Record Properties:%5$s\n"
2278 " --fs-type=TYPE File system type to use in case of luks\n"
2279 " storage (btrfs, ext4, xfs)\n"
2280 " --luks-discard=BOOL Whether to use 'discard' feature of file system\n"
2281 " when activated (mounted)\n"
2282 " --luks-offline-discard=BOOL\n"
2283 " Whether to trim file on logout\n"
2284 " --luks-cipher=CIPHER Cipher to use for LUKS encryption\n"
2285 " --luks-cipher-mode=MODE Cipher mode to use for LUKS encryption\n"
2286 " --luks-volume-key-size=BITS\n"
2287 " Volume key size to use for LUKS encryption\n"
2288 " --luks-pbkdf-type=TYPE Password-based Key Derivation Function to use\n"
2289 " --luks-pbkdf-hash-algorithm=ALGORITHM\n"
2290 " PBKDF hash algorithm to use\n"
2291 " --luks-pbkdf-time-cost=SECS\n"
2292 " Time cost for PBKDF in seconds\n"
2293 " --luks-pbkdf-memory-cost=BYTES\n"
2294 " Memory cost for PBKDF in bytes\n"
2295 " --luks-pbkdf-parallel-threads=NUMBER\n"
2296 " Number of parallel threads for PKBDF\n"
2297 " --luks-extra-mount-options=OPTIONS\n"
2298 " LUKS extra mount options\n"
2299 " --auto-resize-mode=MODE Automatically grow/shrink home on login/logout\n"
2300 " --rebalance-weight=WEIGHT Weight while rebalancing\n"
2301 "\n%4$sMounting User Record Properties:%5$s\n"
2302 " --nosuid=BOOL Control the 'nosuid' flag of the home mount\n"
2303 " --nodev=BOOL Control the 'nodev' flag of the home mount\n"
2304 " --noexec=BOOL Control the 'noexec' flag of the home mount\n"
2305 "\n%4$sCIFS User Record Properties:%5$s\n"
2306 " --cifs-domain=DOMAIN CIFS (Windows) domain\n"
2307 " --cifs-user-name=USER CIFS (Windows) user name\n"
2308 " --cifs-service=SERVICE CIFS (Windows) service to mount as home area\n"
2309 " --cifs-extra-mount-options=OPTIONS\n"
2310 " CIFS (Windows) extra mount options\n"
2311 "\n%4$sLogin Behaviour User Record Properties:%5$s\n"
2312 " --stop-delay=SECS How long to leave user services running after\n"
2313 " logout\n"
2314 " --kill-processes=BOOL Whether to kill user processes when sessions\n"
2315 " terminate\n"
2316 " --auto-login=BOOL Try to log this user in automatically\n"
2317 "\nSee the %6$s for details.\n",
2318 program_invocation_short_name,
2319 ansi_highlight(),
2320 ansi_normal(),
2321 ansi_underline(),
2322 ansi_normal(),
2323 link);
2324
2325 return 0;
2326 }
2327
2328 static int parse_argv(int argc, char *argv[]) {
2329
2330 enum {
2331 ARG_VERSION = 0x100,
2332 ARG_NO_PAGER,
2333 ARG_NO_LEGEND,
2334 ARG_NO_ASK_PASSWORD,
2335 ARG_REALM,
2336 ARG_EMAIL_ADDRESS,
2337 ARG_DISK_SIZE,
2338 ARG_ACCESS_MODE,
2339 ARG_STORAGE,
2340 ARG_FS_TYPE,
2341 ARG_IMAGE_PATH,
2342 ARG_UMASK,
2343 ARG_LUKS_DISCARD,
2344 ARG_LUKS_OFFLINE_DISCARD,
2345 ARG_JSON,
2346 ARG_SETENV,
2347 ARG_TIMEZONE,
2348 ARG_LANGUAGE,
2349 ARG_LOCKED,
2350 ARG_SSH_AUTHORIZED_KEYS,
2351 ARG_LOCATION,
2352 ARG_ICON_NAME,
2353 ARG_PASSWORD_HINT,
2354 ARG_NICE,
2355 ARG_RLIMIT,
2356 ARG_NOT_BEFORE,
2357 ARG_NOT_AFTER,
2358 ARG_LUKS_CIPHER,
2359 ARG_LUKS_CIPHER_MODE,
2360 ARG_LUKS_VOLUME_KEY_SIZE,
2361 ARG_NOSUID,
2362 ARG_NODEV,
2363 ARG_NOEXEC,
2364 ARG_CIFS_DOMAIN,
2365 ARG_CIFS_USER_NAME,
2366 ARG_CIFS_SERVICE,
2367 ARG_CIFS_EXTRA_MOUNT_OPTIONS,
2368 ARG_TASKS_MAX,
2369 ARG_MEMORY_HIGH,
2370 ARG_MEMORY_MAX,
2371 ARG_CPU_WEIGHT,
2372 ARG_IO_WEIGHT,
2373 ARG_LUKS_PBKDF_TYPE,
2374 ARG_LUKS_PBKDF_HASH_ALGORITHM,
2375 ARG_LUKS_PBKDF_TIME_COST,
2376 ARG_LUKS_PBKDF_MEMORY_COST,
2377 ARG_LUKS_PBKDF_PARALLEL_THREADS,
2378 ARG_RATE_LIMIT_INTERVAL,
2379 ARG_RATE_LIMIT_BURST,
2380 ARG_STOP_DELAY,
2381 ARG_KILL_PROCESSES,
2382 ARG_ENFORCE_PASSWORD_POLICY,
2383 ARG_PASSWORD_CHANGE_NOW,
2384 ARG_PASSWORD_CHANGE_MIN,
2385 ARG_PASSWORD_CHANGE_MAX,
2386 ARG_PASSWORD_CHANGE_WARN,
2387 ARG_PASSWORD_CHANGE_INACTIVE,
2388 ARG_EXPORT_FORMAT,
2389 ARG_AUTO_LOGIN,
2390 ARG_PKCS11_TOKEN_URI,
2391 ARG_FIDO2_DEVICE,
2392 ARG_FIDO2_WITH_PIN,
2393 ARG_FIDO2_WITH_UP,
2394 ARG_FIDO2_WITH_UV,
2395 ARG_RECOVERY_KEY,
2396 ARG_AND_RESIZE,
2397 ARG_AND_CHANGE_PASSWORD,
2398 ARG_DROP_CACHES,
2399 ARG_LUKS_EXTRA_MOUNT_OPTIONS,
2400 ARG_AUTO_RESIZE_MODE,
2401 ARG_REBALANCE_WEIGHT,
2402 };
2403
2404 static const struct option options[] = {
2405 { "help", no_argument, NULL, 'h' },
2406 { "version", no_argument, NULL, ARG_VERSION },
2407 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
2408 { "no-legend", no_argument, NULL, ARG_NO_LEGEND },
2409 { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
2410 { "host", required_argument, NULL, 'H' },
2411 { "machine", required_argument, NULL, 'M' },
2412 { "identity", required_argument, NULL, 'I' },
2413 { "real-name", required_argument, NULL, 'c' },
2414 { "comment", required_argument, NULL, 'c' }, /* Compat alias to keep thing in sync with useradd(8) */
2415 { "realm", required_argument, NULL, ARG_REALM },
2416 { "email-address", required_argument, NULL, ARG_EMAIL_ADDRESS },
2417 { "location", required_argument, NULL, ARG_LOCATION },
2418 { "password-hint", required_argument, NULL, ARG_PASSWORD_HINT },
2419 { "icon-name", required_argument, NULL, ARG_ICON_NAME },
2420 { "home-dir", required_argument, NULL, 'd' }, /* Compatible with useradd(8) */
2421 { "uid", required_argument, NULL, 'u' }, /* Compatible with useradd(8) */
2422 { "member-of", required_argument, NULL, 'G' },
2423 { "groups", required_argument, NULL, 'G' }, /* Compat alias to keep thing in sync with useradd(8) */
2424 { "skel", required_argument, NULL, 'k' }, /* Compatible with useradd(8) */
2425 { "shell", required_argument, NULL, 's' }, /* Compatible with useradd(8) */
2426 { "setenv", required_argument, NULL, ARG_SETENV },
2427 { "timezone", required_argument, NULL, ARG_TIMEZONE },
2428 { "language", required_argument, NULL, ARG_LANGUAGE },
2429 { "locked", required_argument, NULL, ARG_LOCKED },
2430 { "not-before", required_argument, NULL, ARG_NOT_BEFORE },
2431 { "not-after", required_argument, NULL, ARG_NOT_AFTER },
2432 { "expiredate", required_argument, NULL, 'e' }, /* Compat alias to keep thing in sync with useradd(8) */
2433 { "ssh-authorized-keys", required_argument, NULL, ARG_SSH_AUTHORIZED_KEYS },
2434 { "disk-size", required_argument, NULL, ARG_DISK_SIZE },
2435 { "access-mode", required_argument, NULL, ARG_ACCESS_MODE },
2436 { "umask", required_argument, NULL, ARG_UMASK },
2437 { "nice", required_argument, NULL, ARG_NICE },
2438 { "rlimit", required_argument, NULL, ARG_RLIMIT },
2439 { "tasks-max", required_argument, NULL, ARG_TASKS_MAX },
2440 { "memory-high", required_argument, NULL, ARG_MEMORY_HIGH },
2441 { "memory-max", required_argument, NULL, ARG_MEMORY_MAX },
2442 { "cpu-weight", required_argument, NULL, ARG_CPU_WEIGHT },
2443 { "io-weight", required_argument, NULL, ARG_IO_WEIGHT },
2444 { "storage", required_argument, NULL, ARG_STORAGE },
2445 { "image-path", required_argument, NULL, ARG_IMAGE_PATH },
2446 { "fs-type", required_argument, NULL, ARG_FS_TYPE },
2447 { "luks-discard", required_argument, NULL, ARG_LUKS_DISCARD },
2448 { "luks-offline-discard", required_argument, NULL, ARG_LUKS_OFFLINE_DISCARD },
2449 { "luks-cipher", required_argument, NULL, ARG_LUKS_CIPHER },
2450 { "luks-cipher-mode", required_argument, NULL, ARG_LUKS_CIPHER_MODE },
2451 { "luks-volume-key-size", required_argument, NULL, ARG_LUKS_VOLUME_KEY_SIZE },
2452 { "luks-pbkdf-type", required_argument, NULL, ARG_LUKS_PBKDF_TYPE },
2453 { "luks-pbkdf-hash-algorithm", required_argument, NULL, ARG_LUKS_PBKDF_HASH_ALGORITHM },
2454 { "luks-pbkdf-time-cost", required_argument, NULL, ARG_LUKS_PBKDF_TIME_COST },
2455 { "luks-pbkdf-memory-cost", required_argument, NULL, ARG_LUKS_PBKDF_MEMORY_COST },
2456 { "luks-pbkdf-parallel-threads", required_argument, NULL, ARG_LUKS_PBKDF_PARALLEL_THREADS },
2457 { "nosuid", required_argument, NULL, ARG_NOSUID },
2458 { "nodev", required_argument, NULL, ARG_NODEV },
2459 { "noexec", required_argument, NULL, ARG_NOEXEC },
2460 { "cifs-user-name", required_argument, NULL, ARG_CIFS_USER_NAME },
2461 { "cifs-domain", required_argument, NULL, ARG_CIFS_DOMAIN },
2462 { "cifs-service", required_argument, NULL, ARG_CIFS_SERVICE },
2463 { "cifs-extra-mount-options", required_argument, NULL, ARG_CIFS_EXTRA_MOUNT_OPTIONS },
2464 { "rate-limit-interval", required_argument, NULL, ARG_RATE_LIMIT_INTERVAL },
2465 { "rate-limit-burst", required_argument, NULL, ARG_RATE_LIMIT_BURST },
2466 { "stop-delay", required_argument, NULL, ARG_STOP_DELAY },
2467 { "kill-processes", required_argument, NULL, ARG_KILL_PROCESSES },
2468 { "enforce-password-policy", required_argument, NULL, ARG_ENFORCE_PASSWORD_POLICY },
2469 { "password-change-now", required_argument, NULL, ARG_PASSWORD_CHANGE_NOW },
2470 { "password-change-min", required_argument, NULL, ARG_PASSWORD_CHANGE_MIN },
2471 { "password-change-max", required_argument, NULL, ARG_PASSWORD_CHANGE_MAX },
2472 { "password-change-warn", required_argument, NULL, ARG_PASSWORD_CHANGE_WARN },
2473 { "password-change-inactive", required_argument, NULL, ARG_PASSWORD_CHANGE_INACTIVE },
2474 { "auto-login", required_argument, NULL, ARG_AUTO_LOGIN },
2475 { "json", required_argument, NULL, ARG_JSON },
2476 { "export-format", required_argument, NULL, ARG_EXPORT_FORMAT },
2477 { "pkcs11-token-uri", required_argument, NULL, ARG_PKCS11_TOKEN_URI },
2478 { "fido2-device", required_argument, NULL, ARG_FIDO2_DEVICE },
2479 { "fido2-with-client-pin", required_argument, NULL, ARG_FIDO2_WITH_PIN },
2480 { "fido2-with-user-presence", required_argument, NULL, ARG_FIDO2_WITH_UP },
2481 { "fido2-with-user-verification",required_argument, NULL, ARG_FIDO2_WITH_UV },
2482 { "recovery-key", required_argument, NULL, ARG_RECOVERY_KEY },
2483 { "and-resize", required_argument, NULL, ARG_AND_RESIZE },
2484 { "and-change-password", required_argument, NULL, ARG_AND_CHANGE_PASSWORD },
2485 { "drop-caches", required_argument, NULL, ARG_DROP_CACHES },
2486 { "luks-extra-mount-options", required_argument, NULL, ARG_LUKS_EXTRA_MOUNT_OPTIONS },
2487 { "auto-resize-mode", required_argument, NULL, ARG_AUTO_RESIZE_MODE },
2488 { "rebalance-weight", required_argument, NULL, ARG_REBALANCE_WEIGHT },
2489 {}
2490 };
2491
2492 int r;
2493
2494 assert(argc >= 0);
2495 assert(argv);
2496
2497 for (;;) {
2498 int c;
2499
2500 c = getopt_long(argc, argv, "hH:M:I:c:d:u:k:s:e:G:jPE", options, NULL);
2501 if (c < 0)
2502 break;
2503
2504 switch (c) {
2505
2506 case 'h':
2507 return help(0, NULL, NULL);
2508
2509 case ARG_VERSION:
2510 return version();
2511
2512 case ARG_NO_PAGER:
2513 arg_pager_flags |= PAGER_DISABLE;
2514 break;
2515
2516 case ARG_NO_LEGEND:
2517 arg_legend = false;
2518 break;
2519
2520 case ARG_NO_ASK_PASSWORD:
2521 arg_ask_password = false;
2522 break;
2523
2524 case 'H':
2525 arg_transport = BUS_TRANSPORT_REMOTE;
2526 arg_host = optarg;
2527 break;
2528
2529 case 'M':
2530 arg_transport = BUS_TRANSPORT_MACHINE;
2531 arg_host = optarg;
2532 break;
2533
2534 case 'I':
2535 arg_identity = optarg;
2536 break;
2537
2538 case 'c':
2539 if (isempty(optarg)) {
2540 r = drop_from_identity("realName");
2541 if (r < 0)
2542 return r;
2543
2544 break;
2545 }
2546
2547 if (!valid_gecos(optarg))
2548 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Real name '%s' not a valid GECOS field.", optarg);
2549
2550 r = json_variant_set_field_string(&arg_identity_extra, "realName", optarg);
2551 if (r < 0)
2552 return log_error_errno(r, "Failed to set realName field: %m");
2553
2554 break;
2555
2556 case 'd': {
2557 _cleanup_free_ char *hd = NULL;
2558
2559 if (isempty(optarg)) {
2560 r = drop_from_identity("homeDirectory");
2561 if (r < 0)
2562 return r;
2563
2564 break;
2565 }
2566
2567 r = parse_path_argument(optarg, false, &hd);
2568 if (r < 0)
2569 return r;
2570
2571 if (!valid_home(hd))
2572 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Home directory '%s' not valid.", hd);
2573
2574 r = json_variant_set_field_string(&arg_identity_extra, "homeDirectory", hd);
2575 if (r < 0)
2576 return log_error_errno(r, "Failed to set homeDirectory field: %m");
2577
2578 break;
2579 }
2580
2581 case ARG_REALM:
2582 if (isempty(optarg)) {
2583 r = drop_from_identity("realm");
2584 if (r < 0)
2585 return r;
2586
2587 break;
2588 }
2589
2590 r = dns_name_is_valid(optarg);
2591 if (r < 0)
2592 return log_error_errno(r, "Failed to determine whether realm '%s' is a valid DNS domain: %m", optarg);
2593 if (r == 0)
2594 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Realm '%s' is not a valid DNS domain: %m", optarg);
2595
2596 r = json_variant_set_field_string(&arg_identity_extra, "realm", optarg);
2597 if (r < 0)
2598 return log_error_errno(r, "Failed to set realm field: %m");
2599 break;
2600
2601 case ARG_EMAIL_ADDRESS:
2602 case ARG_LOCATION:
2603 case ARG_ICON_NAME:
2604 case ARG_CIFS_USER_NAME:
2605 case ARG_CIFS_DOMAIN:
2606 case ARG_CIFS_EXTRA_MOUNT_OPTIONS:
2607 case ARG_LUKS_EXTRA_MOUNT_OPTIONS: {
2608
2609 const char *field =
2610 c == ARG_EMAIL_ADDRESS ? "emailAddress" :
2611 c == ARG_LOCATION ? "location" :
2612 c == ARG_ICON_NAME ? "iconName" :
2613 c == ARG_CIFS_USER_NAME ? "cifsUserName" :
2614 c == ARG_CIFS_DOMAIN ? "cifsDomain" :
2615 c == ARG_CIFS_EXTRA_MOUNT_OPTIONS ? "cifsExtraMountOptions" :
2616 c == ARG_LUKS_EXTRA_MOUNT_OPTIONS ? "luksExtraMountOptions" :
2617 NULL;
2618
2619 assert(field);
2620
2621 if (isempty(optarg)) {
2622 r = drop_from_identity(field);
2623 if (r < 0)
2624 return r;
2625
2626 break;
2627 }
2628
2629 r = json_variant_set_field_string(&arg_identity_extra, field, optarg);
2630 if (r < 0)
2631 return log_error_errno(r, "Failed to set %s field: %m", field);
2632
2633 break;
2634 }
2635
2636 case ARG_CIFS_SERVICE:
2637 if (isempty(optarg)) {
2638 r = drop_from_identity("cifsService");
2639 if (r < 0)
2640 return r;
2641
2642 break;
2643 }
2644
2645 r = parse_cifs_service(optarg, NULL, NULL, NULL);
2646 if (r < 0)
2647 return log_error_errno(r, "Failed to validate CIFS service name: %s", optarg);
2648
2649 r = json_variant_set_field_string(&arg_identity_extra, "cifsService", optarg);
2650 if (r < 0)
2651 return log_error_errno(r, "Failed to set cifsService field: %m");
2652
2653 break;
2654
2655 case ARG_PASSWORD_HINT:
2656 if (isempty(optarg)) {
2657 r = drop_from_identity("passwordHint");
2658 if (r < 0)
2659 return r;
2660
2661 break;
2662 }
2663
2664 r = json_variant_set_field_string(&arg_identity_extra_privileged, "passwordHint", optarg);
2665 if (r < 0)
2666 return log_error_errno(r, "Failed to set passwordHint field: %m");
2667
2668 string_erase(optarg);
2669 break;
2670
2671 case ARG_NICE: {
2672 int nc;
2673
2674 if (isempty(optarg)) {
2675 r = drop_from_identity("niceLevel");
2676 if (r < 0)
2677 return r;
2678 break;
2679 }
2680
2681 r = parse_nice(optarg, &nc);
2682 if (r < 0)
2683 return log_error_errno(r, "Failed to parse nice level: %s", optarg);
2684
2685 r = json_variant_set_field_integer(&arg_identity_extra, "niceLevel", nc);
2686 if (r < 0)
2687 return log_error_errno(r, "Failed to set niceLevel field: %m");
2688
2689 break;
2690 }
2691
2692 case ARG_RLIMIT: {
2693 _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *jcur = NULL, *jmax = NULL;
2694 _cleanup_free_ char *field = NULL, *t = NULL;
2695 const char *eq;
2696 struct rlimit rl;
2697 int l;
2698
2699 if (isempty(optarg)) {
2700 /* Remove all resource limits */
2701
2702 r = drop_from_identity("resourceLimits");
2703 if (r < 0)
2704 return r;
2705
2706 arg_identity_filter_rlimits = strv_free(arg_identity_filter_rlimits);
2707 arg_identity_extra_rlimits = json_variant_unref(arg_identity_extra_rlimits);
2708 break;
2709 }
2710
2711 eq = strchr(optarg, '=');
2712 if (!eq)
2713 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Can't parse resource limit assignment: %s", optarg);
2714
2715 field = strndup(optarg, eq - optarg);
2716 if (!field)
2717 return log_oom();
2718
2719 l = rlimit_from_string_harder(field);
2720 if (l < 0)
2721 return log_error_errno(l, "Unknown resource limit type: %s", field);
2722
2723 if (isempty(eq + 1)) {
2724 /* Remove only the specific rlimit */
2725
2726 r = strv_extend(&arg_identity_filter_rlimits, rlimit_to_string(l));
2727 if (r < 0)
2728 return r;
2729
2730 r = json_variant_filter(&arg_identity_extra_rlimits, STRV_MAKE(field));
2731 if (r < 0)
2732 return log_error_errno(r, "Failed to filter JSON identity data: %m");
2733
2734 break;
2735 }
2736
2737 r = rlimit_parse(l, eq + 1, &rl);
2738 if (r < 0)
2739 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse resource limit value: %s", eq + 1);
2740
2741 r = rl.rlim_cur == RLIM_INFINITY ? json_variant_new_null(&jcur) : json_variant_new_unsigned(&jcur, rl.rlim_cur);
2742 if (r < 0)
2743 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to allocate current integer: %m");
2744
2745 r = rl.rlim_max == RLIM_INFINITY ? json_variant_new_null(&jmax) : json_variant_new_unsigned(&jmax, rl.rlim_max);
2746 if (r < 0)
2747 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to allocate maximum integer: %m");
2748
2749 r = json_build(&v,
2750 JSON_BUILD_OBJECT(
2751 JSON_BUILD_PAIR("cur", JSON_BUILD_VARIANT(jcur)),
2752 JSON_BUILD_PAIR("max", JSON_BUILD_VARIANT(jmax))));
2753 if (r < 0)
2754 return log_error_errno(r, "Failed to build resource limit: %m");
2755
2756 t = strjoin("RLIMIT_", rlimit_to_string(l));
2757 if (!t)
2758 return log_oom();
2759
2760 r = json_variant_set_field(&arg_identity_extra_rlimits, t, v);
2761 if (r < 0)
2762 return log_error_errno(r, "Failed to set %s field: %m", rlimit_to_string(l));
2763
2764 break;
2765 }
2766
2767 case 'u': {
2768 uid_t uid;
2769
2770 if (isempty(optarg)) {
2771 r = drop_from_identity("uid");
2772 if (r < 0)
2773 return r;
2774
2775 break;
2776 }
2777
2778 r = parse_uid(optarg, &uid);
2779 if (r < 0)
2780 return log_error_errno(r, "Failed to parse UID '%s'.", optarg);
2781
2782 if (uid_is_system(uid))
2783 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "UID " UID_FMT " is in system range, refusing.", uid);
2784 if (uid_is_dynamic(uid))
2785 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "UID " UID_FMT " is in dynamic range, refusing.", uid);
2786 if (uid == UID_NOBODY)
2787 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "UID " UID_FMT " is nobody UID, refusing.", uid);
2788
2789 r = json_variant_set_field_unsigned(&arg_identity_extra, "uid", uid);
2790 if (r < 0)
2791 return log_error_errno(r, "Failed to set realm field: %m");
2792
2793 break;
2794 }
2795
2796 case 'k':
2797 case ARG_IMAGE_PATH: {
2798 const char *field = c == 'k' ? "skeletonDirectory" : "imagePath";
2799 _cleanup_free_ char *v = NULL;
2800
2801 if (isempty(optarg)) {
2802 r = drop_from_identity(field);
2803 if (r < 0)
2804 return r;
2805
2806 break;
2807 }
2808
2809 r = parse_path_argument(optarg, false, &v);
2810 if (r < 0)
2811 return r;
2812
2813 r = json_variant_set_field_string(&arg_identity_extra_this_machine, field, v);
2814 if (r < 0)
2815 return log_error_errno(r, "Failed to set %s field: %m", v);
2816
2817 break;
2818 }
2819
2820 case 's':
2821 if (isempty(optarg)) {
2822 r = drop_from_identity("shell");
2823 if (r < 0)
2824 return r;
2825
2826 break;
2827 }
2828
2829 if (!valid_shell(optarg))
2830 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Shell '%s' not valid.", optarg);
2831
2832 r = json_variant_set_field_string(&arg_identity_extra, "shell", optarg);
2833 if (r < 0)
2834 return log_error_errno(r, "Failed to set shell field: %m");
2835
2836 break;
2837
2838 case ARG_SETENV: {
2839 _cleanup_free_ char **l = NULL;
2840 _cleanup_(json_variant_unrefp) JsonVariant *ne = NULL;
2841 JsonVariant *e;
2842
2843 if (isempty(optarg)) {
2844 r = drop_from_identity("environment");
2845 if (r < 0)
2846 return r;
2847
2848 break;
2849 }
2850
2851 e = json_variant_by_key(arg_identity_extra, "environment");
2852 if (e) {
2853 r = json_variant_strv(e, &l);
2854 if (r < 0)
2855 return log_error_errno(r, "Failed to parse JSON environment field: %m");
2856 }
2857
2858 r = strv_env_replace_strdup_passthrough(&l, optarg);
2859 if (r < 0)
2860 return log_error_errno(r, "Cannot assign environment variable %s: %m", optarg);
2861
2862 strv_sort(l);
2863
2864 r = json_variant_new_array_strv(&ne, l);
2865 if (r < 0)
2866 return log_error_errno(r, "Failed to allocate environment list JSON: %m");
2867
2868 r = json_variant_set_field(&arg_identity_extra, "environment", ne);
2869 if (r < 0)
2870 return log_error_errno(r, "Failed to set environment list: %m");
2871
2872 break;
2873 }
2874
2875 case ARG_TIMEZONE:
2876
2877 if (isempty(optarg)) {
2878 r = drop_from_identity("timeZone");
2879 if (r < 0)
2880 return r;
2881
2882 break;
2883 }
2884
2885 if (!timezone_is_valid(optarg, LOG_DEBUG))
2886 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Timezone '%s' is not valid.", optarg);
2887
2888 r = json_variant_set_field_string(&arg_identity_extra, "timeZone", optarg);
2889 if (r < 0)
2890 return log_error_errno(r, "Failed to set timezone field: %m");
2891
2892 break;
2893
2894 case ARG_LANGUAGE:
2895 if (isempty(optarg)) {
2896 r = drop_from_identity("language");
2897 if (r < 0)
2898 return r;
2899
2900 break;
2901 }
2902
2903 if (!locale_is_valid(optarg))
2904 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Locale '%s' is not valid.", optarg);
2905
2906 if (locale_is_installed(optarg) <= 0)
2907 log_warning("Locale '%s' is not installed, accepting anyway.", optarg);
2908
2909 r = json_variant_set_field_string(&arg_identity_extra, "preferredLanguage", optarg);
2910 if (r < 0)
2911 return log_error_errno(r, "Failed to set preferredLanguage field: %m");
2912
2913 break;
2914
2915 case ARG_NOSUID:
2916 case ARG_NODEV:
2917 case ARG_NOEXEC:
2918 case ARG_LOCKED:
2919 case ARG_KILL_PROCESSES:
2920 case ARG_ENFORCE_PASSWORD_POLICY:
2921 case ARG_AUTO_LOGIN:
2922 case ARG_PASSWORD_CHANGE_NOW: {
2923 const char *field =
2924 c == ARG_LOCKED ? "locked" :
2925 c == ARG_NOSUID ? "mountNoSuid" :
2926 c == ARG_NODEV ? "mountNoDevices" :
2927 c == ARG_NOEXEC ? "mountNoExecute" :
2928 c == ARG_KILL_PROCESSES ? "killProcesses" :
2929 c == ARG_ENFORCE_PASSWORD_POLICY ? "enforcePasswordPolicy" :
2930 c == ARG_AUTO_LOGIN ? "autoLogin" :
2931 c == ARG_PASSWORD_CHANGE_NOW ? "passwordChangeNow" :
2932 NULL;
2933
2934 assert(field);
2935
2936 if (isempty(optarg)) {
2937 r = drop_from_identity(field);
2938 if (r < 0)
2939 return r;
2940
2941 break;
2942 }
2943
2944 r = parse_boolean(optarg);
2945 if (r < 0)
2946 return log_error_errno(r, "Failed to parse %s boolean: %m", field);
2947
2948 r = json_variant_set_field_boolean(&arg_identity_extra, field, r > 0);
2949 if (r < 0)
2950 return log_error_errno(r, "Failed to set %s field: %m", field);
2951
2952 break;
2953 }
2954
2955 case 'P':
2956 r = json_variant_set_field_boolean(&arg_identity_extra, "enforcePasswordPolicy", false);
2957 if (r < 0)
2958 return log_error_errno(r, "Failed to set enforcePasswordPolicy field: %m");
2959
2960 break;
2961
2962 case ARG_DISK_SIZE:
2963 if (isempty(optarg)) {
2964 const char *prop;
2965
2966 FOREACH_STRING(prop, "diskSize", "diskSizeRelative", "rebalanceWeight") {
2967 r = drop_from_identity(prop);
2968 if (r < 0)
2969 return r;
2970 }
2971
2972 arg_disk_size = arg_disk_size_relative = UINT64_MAX;
2973 break;
2974 }
2975
2976 r = parse_permyriad(optarg);
2977 if (r < 0) {
2978 r = parse_disk_size(optarg, &arg_disk_size);
2979 if (r < 0)
2980 return r;
2981
2982 r = drop_from_identity("diskSizeRelative");
2983 if (r < 0)
2984 return r;
2985
2986 r = json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "diskSize", arg_disk_size);
2987 if (r < 0)
2988 return log_error_errno(r, "Failed to set diskSize field: %m");
2989
2990 arg_disk_size_relative = UINT64_MAX;
2991 } else {
2992 /* Normalize to UINT32_MAX == 100% */
2993 arg_disk_size_relative = UINT32_SCALE_FROM_PERMYRIAD(r);
2994
2995 r = drop_from_identity("diskSize");
2996 if (r < 0)
2997 return r;
2998
2999 r = json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "diskSizeRelative", arg_disk_size_relative);
3000 if (r < 0)
3001 return log_error_errno(r, "Failed to set diskSizeRelative field: %m");
3002
3003 arg_disk_size = UINT64_MAX;
3004 }
3005
3006 /* Automatically turn off the rebalance logic if user configured a size explicitly */
3007 r = json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "rebalanceWeight", REBALANCE_WEIGHT_OFF);
3008 if (r < 0)
3009 return log_error_errno(r, "Failed to set rebalanceWeight field: %m");
3010
3011 break;
3012
3013 case ARG_ACCESS_MODE: {
3014 mode_t mode;
3015
3016 if (isempty(optarg)) {
3017 r = drop_from_identity("accessMode");
3018 if (r < 0)
3019 return r;
3020
3021 break;
3022 }
3023
3024 r = parse_mode(optarg, &mode);
3025 if (r < 0)
3026 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Access mode '%s' not valid.", optarg);
3027
3028 r = json_variant_set_field_unsigned(&arg_identity_extra, "accessMode", mode);
3029 if (r < 0)
3030 return log_error_errno(r, "Failed to set access mode field: %m");
3031
3032 break;
3033 }
3034
3035 case ARG_LUKS_DISCARD:
3036 if (isempty(optarg)) {
3037 r = drop_from_identity("luksDiscard");
3038 if (r < 0)
3039 return r;
3040
3041 break;
3042 }
3043
3044 r = parse_boolean(optarg);
3045 if (r < 0)
3046 return log_error_errno(r, "Failed to parse --luks-discard= parameter: %s", optarg);
3047
3048 r = json_variant_set_field_boolean(&arg_identity_extra, "luksDiscard", r);
3049 if (r < 0)
3050 return log_error_errno(r, "Failed to set discard field: %m");
3051
3052 break;
3053
3054 case ARG_LUKS_OFFLINE_DISCARD:
3055 if (isempty(optarg)) {
3056 r = drop_from_identity("luksOfflineDiscard");
3057 if (r < 0)
3058 return r;
3059
3060 break;
3061 }
3062
3063 r = parse_boolean(optarg);
3064 if (r < 0)
3065 return log_error_errno(r, "Failed to parse --luks-offline-discard= parameter: %s", optarg);
3066
3067 r = json_variant_set_field_boolean(&arg_identity_extra, "luksOfflineDiscard", r);
3068 if (r < 0)
3069 return log_error_errno(r, "Failed to set offline discard field: %m");
3070
3071 break;
3072
3073 case ARG_LUKS_VOLUME_KEY_SIZE:
3074 case ARG_LUKS_PBKDF_PARALLEL_THREADS:
3075 case ARG_RATE_LIMIT_BURST: {
3076 const char *field =
3077 c == ARG_LUKS_VOLUME_KEY_SIZE ? "luksVolumeKeySize" :
3078 c == ARG_LUKS_PBKDF_PARALLEL_THREADS ? "luksPbkdfParallelThreads" :
3079 c == ARG_RATE_LIMIT_BURST ? "rateLimitBurst" : NULL;
3080 unsigned n;
3081
3082 assert(field);
3083
3084 if (isempty(optarg)) {
3085 r = drop_from_identity(field);
3086 if (r < 0)
3087 return r;
3088 }
3089
3090 r = safe_atou(optarg, &n);
3091 if (r < 0)
3092 return log_error_errno(r, "Failed to parse %s parameter: %s", field, optarg);
3093
3094 r = json_variant_set_field_unsigned(&arg_identity_extra, field, n);
3095 if (r < 0)
3096 return log_error_errno(r, "Failed to set %s field: %m", field);
3097
3098 break;
3099 }
3100
3101 case ARG_UMASK: {
3102 mode_t m;
3103
3104 if (isempty(optarg)) {
3105 r = drop_from_identity("umask");
3106 if (r < 0)
3107 return r;
3108
3109 break;
3110 }
3111
3112 r = parse_mode(optarg, &m);
3113 if (r < 0)
3114 return log_error_errno(r, "Failed to parse umask: %m");
3115
3116 r = json_variant_set_field_integer(&arg_identity_extra, "umask", m);
3117 if (r < 0)
3118 return log_error_errno(r, "Failed to set umask field: %m");
3119
3120 break;
3121 }
3122
3123 case ARG_SSH_AUTHORIZED_KEYS: {
3124 _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
3125 _cleanup_(strv_freep) char **l = NULL, **add = NULL;
3126
3127 if (isempty(optarg)) {
3128 r = drop_from_identity("sshAuthorizedKeys");
3129 if (r < 0)
3130 return r;
3131
3132 break;
3133 }
3134
3135 if (optarg[0] == '@') {
3136 _cleanup_fclose_ FILE *f = NULL;
3137
3138 /* If prefixed with '@' read from a file */
3139
3140 f = fopen(optarg+1, "re");
3141 if (!f)
3142 return log_error_errno(errno, "Failed to open '%s': %m", optarg+1);
3143
3144 for (;;) {
3145 _cleanup_free_ char *line = NULL;
3146
3147 r = read_line(f, LONG_LINE_MAX, &line);
3148 if (r < 0)
3149 return log_error_errno(r, "Failed to read from '%s': %m", optarg+1);
3150 if (r == 0)
3151 break;
3152
3153 if (isempty(line))
3154 continue;
3155
3156 if (line[0] == '#')
3157 continue;
3158
3159 r = strv_consume(&add, TAKE_PTR(line));
3160 if (r < 0)
3161 return log_oom();
3162 }
3163 } else {
3164 /* Otherwise, assume it's a literal key. Let's do some superficial checks
3165 * before accept it though. */
3166
3167 if (string_has_cc(optarg, NULL))
3168 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Authorized key contains control characters, refusing.");
3169 if (optarg[0] == '#')
3170 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Specified key is a comment?");
3171
3172 add = strv_new(optarg);
3173 if (!add)
3174 return log_oom();
3175 }
3176
3177 v = json_variant_ref(json_variant_by_key(arg_identity_extra_privileged, "sshAuthorizedKeys"));
3178 if (v) {
3179 r = json_variant_strv(v, &l);
3180 if (r < 0)
3181 return log_error_errno(r, "Failed to parse SSH authorized keys list: %m");
3182 }
3183
3184 r = strv_extend_strv(&l, add, true);
3185 if (r < 0)
3186 return log_oom();
3187
3188 v = json_variant_unref(v);
3189
3190 r = json_variant_new_array_strv(&v, l);
3191 if (r < 0)
3192 return log_oom();
3193
3194 r = json_variant_set_field(&arg_identity_extra_privileged, "sshAuthorizedKeys", v);
3195 if (r < 0)
3196 return log_error_errno(r, "Failed to set authorized keys: %m");
3197
3198 break;
3199 }
3200
3201 case ARG_NOT_BEFORE:
3202 case ARG_NOT_AFTER:
3203 case 'e': {
3204 const char *field;
3205 usec_t n;
3206
3207 field = c == ARG_NOT_BEFORE ? "notBeforeUSec" :
3208 IN_SET(c, ARG_NOT_AFTER, 'e') ? "notAfterUSec" : NULL;
3209
3210 assert(field);
3211
3212 if (isempty(optarg)) {
3213 r = drop_from_identity(field);
3214 if (r < 0)
3215 return r;
3216
3217 break;
3218 }
3219
3220 /* Note the minor discrepancy regarding -e parsing here: we support that for compat
3221 * reasons, and in the original useradd(8) implementation it accepts dates in the
3222 * format YYYY-MM-DD. Coincidentally, we accept dates formatted like that too, but
3223 * with greater precision. */
3224 r = parse_timestamp(optarg, &n);
3225 if (r < 0)
3226 return log_error_errno(r, "Failed to parse %s parameter: %m", field);
3227
3228 r = json_variant_set_field_unsigned(&arg_identity_extra, field, n);
3229 if (r < 0)
3230 return log_error_errno(r, "Failed to set %s field: %m", field);
3231 break;
3232 }
3233
3234 case ARG_PASSWORD_CHANGE_MIN:
3235 case ARG_PASSWORD_CHANGE_MAX:
3236 case ARG_PASSWORD_CHANGE_WARN:
3237 case ARG_PASSWORD_CHANGE_INACTIVE: {
3238 const char *field;
3239 usec_t n;
3240
3241 field = c == ARG_PASSWORD_CHANGE_MIN ? "passwordChangeMinUSec" :
3242 c == ARG_PASSWORD_CHANGE_MAX ? "passwordChangeMaxUSec" :
3243 c == ARG_PASSWORD_CHANGE_WARN ? "passwordChangeWarnUSec" :
3244 c == ARG_PASSWORD_CHANGE_INACTIVE ? "passwordChangeInactiveUSec" :
3245 NULL;
3246
3247 assert(field);
3248
3249 if (isempty(optarg)) {
3250 r = drop_from_identity(field);
3251 if (r < 0)
3252 return r;
3253
3254 break;
3255 }
3256
3257 r = parse_sec(optarg, &n);
3258 if (r < 0)
3259 return log_error_errno(r, "Failed to parse %s parameter: %m", field);
3260
3261 r = json_variant_set_field_unsigned(&arg_identity_extra, field, n);
3262 if (r < 0)
3263 return log_error_errno(r, "Failed to set %s field: %m", field);
3264 break;
3265 }
3266
3267 case ARG_STORAGE:
3268 case ARG_FS_TYPE:
3269 case ARG_LUKS_CIPHER:
3270 case ARG_LUKS_CIPHER_MODE:
3271 case ARG_LUKS_PBKDF_TYPE:
3272 case ARG_LUKS_PBKDF_HASH_ALGORITHM: {
3273
3274 const char *field =
3275 c == ARG_STORAGE ? "storage" :
3276 c == ARG_FS_TYPE ? "fileSystemType" :
3277 c == ARG_LUKS_CIPHER ? "luksCipher" :
3278 c == ARG_LUKS_CIPHER_MODE ? "luksCipherMode" :
3279 c == ARG_LUKS_PBKDF_TYPE ? "luksPbkdfType" :
3280 c == ARG_LUKS_PBKDF_HASH_ALGORITHM ? "luksPbkdfHashAlgorithm" : NULL;
3281
3282 assert(field);
3283
3284 if (isempty(optarg)) {
3285 r = drop_from_identity(field);
3286 if (r < 0)
3287 return r;
3288
3289 break;
3290 }
3291
3292 if (!string_is_safe(optarg))
3293 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Parameter for %s field not valid: %s", field, optarg);
3294
3295 r = json_variant_set_field_string(
3296 IN_SET(c, ARG_STORAGE, ARG_FS_TYPE) ?
3297 &arg_identity_extra_this_machine :
3298 &arg_identity_extra, field, optarg);
3299 if (r < 0)
3300 return log_error_errno(r, "Failed to set %s field: %m", field);
3301
3302 break;
3303 }
3304
3305 case ARG_LUKS_PBKDF_TIME_COST:
3306 case ARG_RATE_LIMIT_INTERVAL:
3307 case ARG_STOP_DELAY: {
3308 const char *field =
3309 c == ARG_LUKS_PBKDF_TIME_COST ? "luksPbkdfTimeCostUSec" :
3310 c == ARG_RATE_LIMIT_INTERVAL ? "rateLimitIntervalUSec" :
3311 c == ARG_STOP_DELAY ? "stopDelayUSec" :
3312 NULL;
3313 usec_t t;
3314
3315 assert(field);
3316
3317 if (isempty(optarg)) {
3318 r = drop_from_identity(field);
3319 if (r < 0)
3320 return r;
3321
3322 break;
3323 }
3324
3325 r = parse_sec(optarg, &t);
3326 if (r < 0)
3327 return log_error_errno(r, "Failed to parse %s field: %s", field, optarg);
3328
3329 r = json_variant_set_field_unsigned(&arg_identity_extra, field, t);
3330 if (r < 0)
3331 return log_error_errno(r, "Failed to set %s field: %m", field);
3332
3333 break;
3334 }
3335
3336 case 'G': {
3337 const char *p = optarg;
3338
3339 if (isempty(p)) {
3340 r = drop_from_identity("memberOf");
3341 if (r < 0)
3342 return r;
3343
3344 break;
3345 }
3346
3347 for (;;) {
3348 _cleanup_(json_variant_unrefp) JsonVariant *mo = NULL;
3349 _cleanup_strv_free_ char **list = NULL;
3350 _cleanup_free_ char *word = NULL;
3351
3352 r = extract_first_word(&p, &word, ",", 0);
3353 if (r < 0)
3354 return log_error_errno(r, "Failed to parse group list: %m");
3355 if (r == 0)
3356 break;
3357
3358 if (!valid_user_group_name(word, 0))
3359 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid group name %s.", word);
3360
3361 mo = json_variant_ref(json_variant_by_key(arg_identity_extra, "memberOf"));
3362
3363 r = json_variant_strv(mo, &list);
3364 if (r < 0)
3365 return log_error_errno(r, "Failed to parse group list: %m");
3366
3367 r = strv_extend(&list, word);
3368 if (r < 0)
3369 return log_oom();
3370
3371 strv_sort(list);
3372 strv_uniq(list);
3373
3374 mo = json_variant_unref(mo);
3375 r = json_variant_new_array_strv(&mo, list);
3376 if (r < 0)
3377 return log_error_errno(r, "Failed to create group list JSON: %m");
3378
3379 r = json_variant_set_field(&arg_identity_extra, "memberOf", mo);
3380 if (r < 0)
3381 return log_error_errno(r, "Failed to update group list: %m");
3382 }
3383
3384 break;
3385 }
3386
3387 case ARG_TASKS_MAX: {
3388 uint64_t u;
3389
3390 if (isempty(optarg)) {
3391 r = drop_from_identity("tasksMax");
3392 if (r < 0)
3393 return r;
3394 break;
3395 }
3396
3397 r = safe_atou64(optarg, &u);
3398 if (r < 0)
3399 return log_error_errno(r, "Failed to parse --tasks-max= parameter: %s", optarg);
3400
3401 r = json_variant_set_field_unsigned(&arg_identity_extra, "tasksMax", u);
3402 if (r < 0)
3403 return log_error_errno(r, "Failed to set tasksMax field: %m");
3404
3405 break;
3406 }
3407
3408 case ARG_MEMORY_MAX:
3409 case ARG_MEMORY_HIGH:
3410 case ARG_LUKS_PBKDF_MEMORY_COST: {
3411 const char *field =
3412 c == ARG_MEMORY_MAX ? "memoryMax" :
3413 c == ARG_MEMORY_HIGH ? "memoryHigh" :
3414 c == ARG_LUKS_PBKDF_MEMORY_COST ? "luksPbkdfMemoryCost" : NULL;
3415
3416 uint64_t u;
3417
3418 assert(field);
3419
3420 if (isempty(optarg)) {
3421 r = drop_from_identity(field);
3422 if (r < 0)
3423 return r;
3424 break;
3425 }
3426
3427 r = parse_size(optarg, 1024, &u);
3428 if (r < 0)
3429 return log_error_errno(r, "Failed to parse %s parameter: %s", field, optarg);
3430
3431 r = json_variant_set_field_unsigned(&arg_identity_extra_this_machine, field, u);
3432 if (r < 0)
3433 return log_error_errno(r, "Failed to set %s field: %m", field);
3434
3435 break;
3436 }
3437
3438 case ARG_CPU_WEIGHT:
3439 case ARG_IO_WEIGHT: {
3440 const char *field = c == ARG_CPU_WEIGHT ? "cpuWeight" :
3441 c == ARG_IO_WEIGHT ? "ioWeight" : NULL;
3442 uint64_t u;
3443
3444 assert(field);
3445
3446 if (isempty(optarg)) {
3447 r = drop_from_identity(field);
3448 if (r < 0)
3449 return r;
3450 break;
3451 }
3452
3453 r = safe_atou64(optarg, &u);
3454 if (r < 0)
3455 return log_error_errno(r, "Failed to parse --cpu-weight=/--io-weight= parameter: %s", optarg);
3456
3457 if (!CGROUP_WEIGHT_IS_OK(u))
3458 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Weight %" PRIu64 " is out of valid weight range.", u);
3459
3460 r = json_variant_set_field_unsigned(&arg_identity_extra, field, u);
3461 if (r < 0)
3462 return log_error_errno(r, "Failed to set %s field: %m", field);
3463
3464 break;
3465 }
3466
3467 case ARG_PKCS11_TOKEN_URI: {
3468 const char *p;
3469
3470 if (streq(optarg, "list"))
3471 return pkcs11_list_tokens();
3472
3473 /* If --pkcs11-token-uri= is specified we always drop everything old */
3474 FOREACH_STRING(p, "pkcs11TokenUri", "pkcs11EncryptedKey") {
3475 r = drop_from_identity(p);
3476 if (r < 0)
3477 return r;
3478 }
3479
3480 if (isempty(optarg)) {
3481 arg_pkcs11_token_uri = strv_free(arg_pkcs11_token_uri);
3482 break;
3483 }
3484
3485 if (streq(optarg, "auto")) {
3486 _cleanup_free_ char *found = NULL;
3487
3488 r = pkcs11_find_token_auto(&found);
3489 if (r < 0)
3490 return r;
3491 r = strv_consume(&arg_pkcs11_token_uri, TAKE_PTR(found));
3492 } else {
3493 if (!pkcs11_uri_valid(optarg))
3494 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Not a valid PKCS#11 URI: %s", optarg);
3495
3496 r = strv_extend(&arg_pkcs11_token_uri, optarg);
3497 }
3498 if (r < 0)
3499 return r;
3500
3501 strv_uniq(arg_pkcs11_token_uri);
3502 break;
3503 }
3504
3505 case ARG_FIDO2_DEVICE: {
3506 const char *p;
3507
3508 if (streq(optarg, "list"))
3509 return fido2_list_devices();
3510
3511 FOREACH_STRING(p, "fido2HmacCredential", "fido2HmacSalt") {
3512 r = drop_from_identity(p);
3513 if (r < 0)
3514 return r;
3515 }
3516
3517 if (isempty(optarg)) {
3518 arg_fido2_device = strv_free(arg_fido2_device);
3519 break;
3520 }
3521
3522 if (streq(optarg, "auto")) {
3523 _cleanup_free_ char *found = NULL;
3524
3525 r = fido2_find_device_auto(&found);
3526 if (r < 0)
3527 return r;
3528
3529 r = strv_consume(&arg_fido2_device, TAKE_PTR(found));
3530 } else
3531 r = strv_extend(&arg_fido2_device, optarg);
3532 if (r < 0)
3533 return r;
3534
3535 strv_uniq(arg_fido2_device);
3536 break;
3537 }
3538
3539 case ARG_FIDO2_WITH_PIN: {
3540 bool lock_with_pin;
3541
3542 r = parse_boolean_argument("--fido2-with-client-pin=", optarg, &lock_with_pin);
3543 if (r < 0)
3544 return r;
3545
3546 SET_FLAG(arg_fido2_lock_with, FIDO2ENROLL_PIN, lock_with_pin);
3547 break;
3548 }
3549
3550 case ARG_FIDO2_WITH_UP: {
3551 bool lock_with_up;
3552
3553 r = parse_boolean_argument("--fido2-with-user-presence=", optarg, &lock_with_up);
3554 if (r < 0)
3555 return r;
3556
3557 SET_FLAG(arg_fido2_lock_with, FIDO2ENROLL_UP, lock_with_up);
3558 break;
3559 }
3560
3561 case ARG_FIDO2_WITH_UV: {
3562 bool lock_with_uv;
3563
3564 r = parse_boolean_argument("--fido2-with-user-verification=", optarg, &lock_with_uv);
3565 if (r < 0)
3566 return r;
3567
3568 SET_FLAG(arg_fido2_lock_with, FIDO2ENROLL_UV, lock_with_uv);
3569 break;
3570 }
3571
3572 case ARG_RECOVERY_KEY: {
3573 const char *p;
3574
3575 r = parse_boolean(optarg);
3576 if (r < 0)
3577 return log_error_errno(r, "Failed to parse --recovery-key= argument: %s", optarg);
3578
3579 arg_recovery_key = r;
3580
3581 FOREACH_STRING(p, "recoveryKey", "recoveryKeyType") {
3582 r = drop_from_identity(p);
3583 if (r < 0)
3584 return r;
3585 }
3586
3587 break;
3588 }
3589
3590 case ARG_AUTO_RESIZE_MODE:
3591 if (isempty(optarg)) {
3592 r = drop_from_identity("autoResizeMode");
3593 if (r < 0)
3594 return r;
3595
3596 break;
3597 }
3598
3599 r = auto_resize_mode_from_string(optarg);
3600 if (r < 0)
3601 return log_error_errno(r, "Failed to parse --auto-resize-mode= argument: %s", optarg);
3602
3603 r = json_variant_set_field_string(&arg_identity_extra, "autoResizeMode", auto_resize_mode_to_string(r));
3604 if (r < 0)
3605 return log_error_errno(r, "Failed to set autoResizeMode field: %m");
3606
3607 break;
3608
3609 case ARG_REBALANCE_WEIGHT: {
3610 uint64_t u;
3611
3612 if (isempty(optarg)) {
3613 r = drop_from_identity("rebalanceWeight");
3614 if (r < 0)
3615 return r;
3616 }
3617
3618 if (streq(optarg, "off"))
3619 u = REBALANCE_WEIGHT_OFF;
3620 else {
3621 r = safe_atou64(optarg, &u);
3622 if (r < 0)
3623 return log_error_errno(r, "Failed to parse --rebalance-weight= argument: %s", optarg);
3624
3625 if (u < REBALANCE_WEIGHT_MIN || u > REBALANCE_WEIGHT_MAX)
3626 return log_error_errno(SYNTHETIC_ERRNO(ERANGE), "Rebalancing weight out of valid range %" PRIu64 "…%" PRIu64 ": %s",
3627 REBALANCE_WEIGHT_MIN, REBALANCE_WEIGHT_MAX, optarg);
3628 }
3629
3630 /* Drop from per machine stuff and everywhere */
3631 r = drop_from_identity("rebalanceWeight");
3632 if (r < 0)
3633 return r;
3634
3635 /* Add to main identity */
3636 r = json_variant_set_field_unsigned(&arg_identity_extra, "rebalanceWeight", u);
3637 if (r < 0)
3638 return log_error_errno(r, "Failed to set rebalanceWeight field: %m");
3639
3640 break;
3641 }
3642
3643 case 'j':
3644 arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
3645 break;
3646
3647 case ARG_JSON:
3648 r = parse_json_argument(optarg, &arg_json_format_flags);
3649 if (r <= 0)
3650 return r;
3651
3652 break;
3653
3654 case 'E':
3655 if (arg_export_format == EXPORT_FORMAT_FULL)
3656 arg_export_format = EXPORT_FORMAT_STRIPPED;
3657 else if (arg_export_format == EXPORT_FORMAT_STRIPPED)
3658 arg_export_format = EXPORT_FORMAT_MINIMAL;
3659 else
3660 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Specifying -E more than twice is not supported.");
3661
3662 arg_json_format_flags &= ~JSON_FORMAT_OFF;
3663 if (arg_json_format_flags == 0)
3664 arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
3665 break;
3666
3667 case ARG_EXPORT_FORMAT:
3668 if (streq(optarg, "full"))
3669 arg_export_format = EXPORT_FORMAT_FULL;
3670 else if (streq(optarg, "stripped"))
3671 arg_export_format = EXPORT_FORMAT_STRIPPED;
3672 else if (streq(optarg, "minimal"))
3673 arg_export_format = EXPORT_FORMAT_MINIMAL;
3674 else if (streq(optarg, "help")) {
3675 puts("full\n"
3676 "stripped\n"
3677 "minimal");
3678 return 0;
3679 }
3680
3681 break;
3682
3683 case ARG_AND_RESIZE:
3684 arg_and_resize = true;
3685 break;
3686
3687 case ARG_AND_CHANGE_PASSWORD:
3688 arg_and_change_password = true;
3689 break;
3690
3691 case ARG_DROP_CACHES: {
3692 bool drop_caches;
3693
3694 if (isempty(optarg)) {
3695 r = drop_from_identity("dropCaches");
3696 if (r < 0)
3697 return r;
3698 }
3699
3700 r = parse_boolean_argument("--drop-caches=", optarg, &drop_caches);
3701 if (r < 0)
3702 return r;
3703
3704 r = json_variant_set_field_boolean(&arg_identity_extra, "dropCaches", r);
3705 if (r < 0)
3706 return log_error_errno(r, "Failed to set drop caches field: %m");
3707
3708 break;
3709 }
3710
3711 case '?':
3712 return -EINVAL;
3713
3714 default:
3715 assert_not_reached();
3716 }
3717 }
3718
3719 if (!strv_isempty(arg_pkcs11_token_uri) || !strv_isempty(arg_fido2_device))
3720 arg_and_change_password = true;
3721
3722 if (arg_disk_size != UINT64_MAX || arg_disk_size_relative != UINT64_MAX)
3723 arg_and_resize = true;
3724
3725 return 1;
3726 }
3727
3728 static int redirect_bus_mgr(void) {
3729 const char *suffix;
3730
3731 /* Talk to a different service if that's requested. (The same env var is also understood by homed, so
3732 * that it is relatively easily possible to invoke a second instance of homed for debug purposes and
3733 * have homectl talk to it, without colliding with the host version. This is handy when operating
3734 * from a homed-managed account.) */
3735
3736 suffix = getenv("SYSTEMD_HOME_DEBUG_SUFFIX");
3737 if (suffix) {
3738 static BusLocator locator = {
3739 .path = "/org/freedesktop/home1",
3740 .interface = "org.freedesktop.home1.Manager",
3741 };
3742
3743 /* Yes, we leak this memory, but there's little point to collect this, given that we only do
3744 * this in a debug environment, do it only once, and the string shall live for out entire
3745 * process runtime. */
3746
3747 locator.destination = strjoin("org.freedesktop.home1.", suffix);
3748 if (!locator.destination)
3749 return log_oom();
3750
3751 bus_mgr = &locator;
3752 } else
3753 bus_mgr = bus_home_mgr;
3754
3755 return 0;
3756 }
3757
3758 static int run(int argc, char *argv[]) {
3759 static const Verb verbs[] = {
3760 { "help", VERB_ANY, VERB_ANY, 0, help },
3761 { "list", VERB_ANY, 1, VERB_DEFAULT, list_homes },
3762 { "activate", 2, VERB_ANY, 0, activate_home },
3763 { "deactivate", 2, VERB_ANY, 0, deactivate_home },
3764 { "inspect", VERB_ANY, VERB_ANY, 0, inspect_home },
3765 { "authenticate", VERB_ANY, VERB_ANY, 0, authenticate_home },
3766 { "create", VERB_ANY, 2, 0, create_home },
3767 { "remove", 2, VERB_ANY, 0, remove_home },
3768 { "update", VERB_ANY, 2, 0, update_home },
3769 { "passwd", VERB_ANY, 2, 0, passwd_home },
3770 { "resize", 2, 3, 0, resize_home },
3771 { "lock", 2, VERB_ANY, 0, lock_home },
3772 { "unlock", 2, VERB_ANY, 0, unlock_home },
3773 { "with", 2, VERB_ANY, 0, with_home },
3774 { "lock-all", VERB_ANY, 1, 0, lock_all_homes },
3775 { "deactivate-all", VERB_ANY, 1, 0, deactivate_all_homes },
3776 { "rebalance", VERB_ANY, 1, 0, rebalance },
3777 {}
3778 };
3779
3780 int r;
3781
3782 log_setup();
3783
3784 r = redirect_bus_mgr();
3785 if (r < 0)
3786 return r;
3787
3788 r = parse_argv(argc, argv);
3789 if (r <= 0)
3790 return r;
3791
3792 return dispatch_verb(argc, argv, verbs, NULL);
3793 }
3794
3795 DEFINE_MAIN_FUNCTION_WITH_POSITIVE_FAILURE(run);
Unnamed repository; edit this file 'description' to name the repository.