src/tty-ask-password-agent/tty-ask-password-agent.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2015 Werner Fink
   4 ***/
   5
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <getopt.h>
   9 #include <poll.h>
  10 #include <signal.h>
  11 #include <stdbool.h>
  12 #include <stddef.h>
  13 #include <string.h>
  14 #include <sys/inotify.h>
  15 #include <sys/prctl.h>
  16 #include <sys/signalfd.h>
  17 #include <sys/socket.h>
  18 #include <sys/wait.h>
  19 #include <sys/un.h>
  20 #include <unistd.h>
  21
  22 #include "alloc-util.h"
  23 #include "ask-password-api.h"
  24 #include "conf-parser.h"
  25 #include "def.h"
  26 #include "dirent-util.h"
  27 #include "exit-status.h"
  28 #include "fd-util.h"
  29 #include "fileio.h"
  30 #include "hashmap.h"
  31 #include "io-util.h"
  32 #include "macro.h"
  33 #include "mkdir.h"
  34 #include "path-util.h"
  35 #include "process-util.h"
  36 #include "signal-util.h"
  37 #include "socket-util.h"
  38 #include "string-util.h"
  39 #include "strv.h"
  40 #include "terminal-util.h"
  41 #include "util.h"
  42 #include "utmp-wtmp.h"
  43
  44 static enum {
  45         ACTION_LIST,
  46         ACTION_QUERY,
  47         ACTION_WATCH,
  48         ACTION_WALL
  49 } arg_action = ACTION_QUERY;
  50
  51 static bool arg_plymouth = false;
  52 static bool arg_console = false;
  53 static const char *arg_device = NULL;
  54
  55 static int ask_password_plymouth(
  56                 const char *message,
  57                 usec_t until,
  58                 AskPasswordFlags flags,
  59                 const char *flag_file,
  60                 char ***ret) {
  61
  62         static const union sockaddr_union sa = PLYMOUTH_SOCKET;
  63         _cleanup_close_ int fd = -1, notify = -1;
  64         _cleanup_free_ char *packet = NULL;
  65         ssize_t k;
  66         int r, n;
  67         struct pollfd pollfd[2] = {};
  68         char buffer[LINE_MAX];
  69         size_t p = 0;
  70         enum {
  71                 POLL_SOCKET,
  72                 POLL_INOTIFY
  73         };
  74
  75         assert(ret);
  76
  77         if (flag_file) {
  78                 notify = inotify_init1(IN_CLOEXEC|IN_NONBLOCK);
  79                 if (notify < 0)
  80                         return -errno;
  81
  82                 r = inotify_add_watch(notify, flag_file, IN_ATTRIB); /* for the link count */
  83                 if (r < 0)
  84                         return -errno;
  85         }
  86
  87         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
  88         if (fd < 0)
  89                 return -errno;
  90
  91         r = connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
  92         if (r < 0)
  93                 return -errno;
  94
  95         if (flags & ASK_PASSWORD_ACCEPT_CACHED) {
  96                 packet = strdup("c");
  97                 n = 1;
  98         } else if (asprintf(&packet, "*\002%c%s%n", (int) (strlen(message) + 1), message, &n) < 0)
  99                 packet = NULL;
 100         if (!packet)
 101                 return -ENOMEM;
 102
 103         r = loop_write(fd, packet, n + 1, true);
 104         if (r < 0)
 105                 return r;
 106
 107         pollfd[POLL_SOCKET].fd = fd;
 108         pollfd[POLL_SOCKET].events = POLLIN;
 109         pollfd[POLL_INOTIFY].fd = notify;
 110         pollfd[POLL_INOTIFY].events = POLLIN;
 111
 112         for (;;) {
 113                 int sleep_for = -1, j;
 114
 115                 if (until > 0) {
 116                         usec_t y;
 117
 118                         y = now(CLOCK_MONOTONIC);
 119
 120                         if (y > until) {
 121                                 r = -ETIME;
 122                                 goto finish;
 123                         }
 124
 125                         sleep_for = (int) ((until - y) / USEC_PER_MSEC);
 126                 }
 127
 128                 if (flag_file && access(flag_file, F_OK) < 0) {
 129                         r = -errno;
 130                         goto finish;
 131                 }
 132
 133                 j = poll(pollfd, notify >= 0 ? 2 : 1, sleep_for);
 134                 if (j < 0) {
 135                         if (errno == EINTR)
 136                                 continue;
 137
 138                         r = -errno;
 139                         goto finish;
 140                 } else if (j == 0) {
 141                         r = -ETIME;
 142                         goto finish;
 143                 }
 144
 145                 if (notify >= 0 && pollfd[POLL_INOTIFY].revents != 0)
 146                         (void) flush_fd(notify);
 147
 148                 if (pollfd[POLL_SOCKET].revents == 0)
 149                         continue;
 150
 151                 k = read(fd, buffer + p, sizeof(buffer) - p);
 152                 if (k < 0) {
 153                         if (IN_SET(errno, EINTR, EAGAIN))
 154                                 continue;
 155
 156                         r = -errno;
 157                         goto finish;
 158                 } else if (k == 0) {
 159                         r = -EIO;
 160                         goto finish;
 161                 }
 162
 163                 p += k;
 164
 165                 if (p < 1)
 166                         continue;
 167
 168                 if (buffer[0] == 5) {
 169
 170                         if (flags & ASK_PASSWORD_ACCEPT_CACHED) {
 171                                 /* Hmm, first try with cached
 172                                  * passwords failed, so let's retry
 173                                  * with a normal password request */
 174                                 packet = mfree(packet);
 175
 176                                 if (asprintf(&packet, "*\002%c%s%n", (int) (strlen(message) + 1), message, &n) < 0) {
 177                                         r = -ENOMEM;
 178                                         goto finish;
 179                                 }
 180
 181                                 r = loop_write(fd, packet, n+1, true);
 182                                 if (r < 0)
 183                                         goto finish;
 184
 185                                 flags &= ~ASK_PASSWORD_ACCEPT_CACHED;
 186                                 p = 0;
 187                                 continue;
 188                         }
 189
 190                         /* No password, because UI not shown */
 191                         r = -ENOENT;
 192                         goto finish;
 193
 194                 } else if (IN_SET(buffer[0], 2, 9)) {
 195                         uint32_t size;
 196                         char **l;
 197
 198                         /* One or more answers */
 199                         if (p < 5)
 200                                 continue;
 201
 202                         memcpy(&size, buffer+1, sizeof(size));
 203                         size = le32toh(size);
 204                         if (size + 5 > sizeof(buffer)) {
 205                                 r = -EIO;
 206                                 goto finish;
 207                         }
 208
 209                         if (p-5 < size)
 210                                 continue;
 211
 212                         l = strv_parse_nulstr(buffer + 5, size);
 213                         if (!l) {
 214                                 r = -ENOMEM;
 215                                 goto finish;
 216                         }
 217
 218                         *ret = l;
 219                         break;
 220
 221                 } else {
 222                         /* Unknown packet */
 223                         r = -EIO;
 224                         goto finish;
 225                 }
 226         }
 227
 228         r = 0;
 229
 230 finish:
 231         explicit_bzero(buffer, sizeof(buffer));
 232         return r;
 233 }
 234
 235 static int send_passwords(const char *socket_name, char **passwords) {
 236         _cleanup_free_ char *packet = NULL;
 237         _cleanup_close_ int socket_fd = -1;
 238         union sockaddr_union sa = { .un.sun_family = AF_UNIX };
 239         size_t packet_length = 1;
 240         char **p, *d;
 241         ssize_t n;
 242         int r;
 243
 244         assert(socket_name);
 245
 246         STRV_FOREACH(p, passwords)
 247                 packet_length += strlen(*p) + 1;
 248
 249         packet = new(char, packet_length);
 250         if (!packet)
 251                 return -ENOMEM;
 252
 253         packet[0] = '+';
 254
 255         d = packet + 1;
 256         STRV_FOREACH(p, passwords)
 257                 d = stpcpy(d, *p) + 1;
 258
 259         socket_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
 260         if (socket_fd < 0) {
 261                 r = log_debug_errno(errno, "socket(): %m");
 262                 goto finish;
 263         }
 264
 265         strncpy(sa.un.sun_path, socket_name, sizeof(sa.un.sun_path));
 266
 267         n = sendto(socket_fd, packet, packet_length, MSG_NOSIGNAL, &sa.sa, SOCKADDR_UN_LEN(sa.un));
 268         if (n < 0) {
 269                 r = log_debug_errno(errno, "sendto(): %m");
 270                 goto finish;
 271         }
 272
 273         r = (int) n;
 274
 275 finish:
 276         explicit_bzero(packet, packet_length);
 277         return r;
 278 }
 279
 280 static int parse_password(const char *filename, char **wall) {
 281         _cleanup_free_ char *socket_name = NULL, *message = NULL;
 282         bool accept_cached = false, echo = false;
 283         uint64_t not_after = 0;
 284         unsigned pid = 0;
 285
 286         const ConfigTableItem items[] = {
 287                 { "Ask", "Socket",       config_parse_string,   0, &socket_name   },
 288                 { "Ask", "NotAfter",     config_parse_uint64,   0, &not_after     },
 289                 { "Ask", "Message",      config_parse_string,   0, &message       },
 290                 { "Ask", "PID",          config_parse_unsigned, 0, &pid           },
 291                 { "Ask", "AcceptCached", config_parse_bool,     0, &accept_cached },
 292                 { "Ask", "Echo",         config_parse_bool,     0, &echo          },
 293                 {}
 294         };
 295
 296         int r;
 297
 298         assert(filename);
 299
 300         r = config_parse(NULL, filename, NULL,
 301                          NULL,
 302                          config_item_table_lookup, items,
 303                          CONFIG_PARSE_RELAXED|CONFIG_PARSE_WARN, NULL);
 304         if (r < 0)
 305                 return r;
 306
 307         if (!socket_name) {
 308                 log_error("Invalid password file %s", filename);
 309                 return -EBADMSG;
 310         }
 311
 312         if (not_after > 0 && now(CLOCK_MONOTONIC) > not_after)
 313                 return 0;
 314
 315         if (pid > 0 && !pid_is_alive(pid))
 316                 return 0;
 317
 318         if (arg_action == ACTION_LIST)
 319                 printf("'%s' (PID %u)\n", message, pid);
 320
 321         else if (arg_action == ACTION_WALL) {
 322                 char *_wall;
 323
 324                 if (asprintf(&_wall,
 325                              "%s%sPassword entry required for \'%s\' (PID %u).\r\n"
 326                              "Please enter password with the systemd-tty-ask-password-agent tool!",
 327                              strempty(*wall),
 328                              *wall ? "\r\n\r\n" : "",
 329                              message,
 330                              pid) < 0)
 331                         return log_oom();
 332
 333                 free(*wall);
 334                 *wall = _wall;
 335
 336         } else {
 337                 _cleanup_strv_free_erase_ char **passwords = NULL;
 338
 339                 assert(IN_SET(arg_action, ACTION_QUERY, ACTION_WATCH));
 340
 341                 if (access(socket_name, W_OK) < 0) {
 342                         if (arg_action == ACTION_QUERY)
 343                                 log_info("Not querying '%s' (PID %u), lacking privileges.", message, pid);
 344
 345                         return 0;
 346                 }
 347
 348                 if (arg_plymouth)
 349                         r = ask_password_plymouth(message, not_after, accept_cached ? ASK_PASSWORD_ACCEPT_CACHED : 0, filename, &passwords);
 350                 else {
 351                         char *password = NULL;
 352                         int tty_fd = -1;
 353
 354                         if (arg_console) {
 355                                 const char *con = arg_device ?: "/dev/console";
 356
 357                                 tty_fd = acquire_terminal(con, ACQUIRE_TERMINAL_WAIT, USEC_INFINITY);
 358                                 if (tty_fd < 0)
 359                                         return log_error_errno(tty_fd, "Failed to acquire %s: %m", con);
 360
 361                                 r = reset_terminal_fd(tty_fd, true);
 362                                 if (r < 0)
 363                                         log_warning_errno(r, "Failed to reset terminal, ignoring: %m");
 364                         }
 365
 366                         r = ask_password_tty(tty_fd, message, NULL, not_after,
 367                                              (echo ? ASK_PASSWORD_ECHO : 0) |
 368                                              (arg_console ? ASK_PASSWORD_CONSOLE_COLOR : 0),
 369                                              filename, &password);
 370
 371                         if (arg_console) {
 372                                 tty_fd = safe_close(tty_fd);
 373                                 release_terminal();
 374                         }
 375
 376                         if (r >= 0)
 377                                 r = strv_push(&passwords, password);
 378
 379                         if (r < 0)
 380                                 string_free_erase(password);
 381                 }
 382
 383                 /* If the query went away, that's OK */
 384                 if (IN_SET(r, -ETIME, -ENOENT))
 385                         return 0;
 386
 387                 if (r < 0)
 388                         return log_error_errno(r, "Failed to query password: %m");
 389
 390                 r = send_passwords(socket_name, passwords);
 391                 if (r < 0)
 392                         return log_error_errno(r, "Failed to send: %m");
 393         }
 394
 395         return 0;
 396 }
 397
 398 static int wall_tty_block(void) {
 399         _cleanup_free_ char *p = NULL;
 400         dev_t devnr;
 401         int fd, r;
 402
 403         r = get_ctty_devnr(0, &devnr);
 404         if (r == -ENXIO) /* We have no controlling tty */
 405                 return -ENOTTY;
 406         if (r < 0)
 407                 return log_error_errno(r, "Failed to get controlling TTY: %m");
 408
 409         if (asprintf(&p, "/run/systemd/ask-password-block/%u:%u", major(devnr), minor(devnr)) < 0)
 410                 return log_oom();
 411
 412         (void) mkdir_parents_label(p, 0700);
 413         (void) mkfifo(p, 0600);
 414
 415         fd = open(p, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
 416         if (fd < 0)
 417                 return log_debug_errno(errno, "Failed to open %s: %m", p);
 418
 419         return fd;
 420 }
 421
 422 static bool wall_tty_match(const char *path, void *userdata) {
 423         _cleanup_free_ char *p = NULL;
 424         _cleanup_close_ int fd = -1;
 425         struct stat st;
 426
 427         if (!path_is_absolute(path))
 428                 path = strjoina("/dev/", path);
 429
 430         if (lstat(path, &st) < 0) {
 431                 log_debug_errno(errno, "Failed to stat %s: %m", path);
 432                 return true;
 433         }
 434
 435         if (!S_ISCHR(st.st_mode)) {
 436                 log_debug("%s is not a character device.", path);
 437                 return true;
 438         }
 439
 440         /* We use named pipes to ensure that wall messages suggesting
 441          * password entry are not printed over password prompts
 442          * already shown. We use the fact here that opening a pipe in
 443          * non-blocking mode for write-only will succeed only if
 444          * there's some writer behind it. Using pipes has the
 445          * advantage that the block will automatically go away if the
 446          * process dies. */
 447
 448         if (asprintf(&p, "/run/systemd/ask-password-block/%u:%u", major(st.st_rdev), minor(st.st_rdev)) < 0) {
 449                 log_oom();
 450                 return true;
 451         }
 452
 453         fd = open(p, O_WRONLY|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
 454         if (fd < 0) {
 455                 log_debug_errno(errno, "Failed to open the wall pipe: %m");
 456                 return 1;
 457         }
 458
 459         /* What, we managed to open the pipe? Then this tty is filtered. */
 460         return 0;
 461 }
 462
 463 static int show_passwords(void) {
 464         _cleanup_closedir_ DIR *d;
 465         struct dirent *de;
 466         int r = 0;
 467
 468         d = opendir("/run/systemd/ask-password");
 469         if (!d) {
 470                 if (errno == ENOENT)
 471                         return 0;
 472
 473                 return log_error_errno(errno, "Failed to open /run/systemd/ask-password: %m");
 474         }
 475
 476         FOREACH_DIRENT_ALL(de, d, return log_error_errno(errno, "Failed to read directory: %m")) {
 477                 _cleanup_free_ char *p = NULL, *wall = NULL;
 478                 int q;
 479
 480                 /* We only support /dev on tmpfs, hence we can rely on
 481                  * d_type to be reliable */
 482
 483                 if (de->d_type != DT_REG)
 484                         continue;
 485
 486                 if (hidden_or_backup_file(de->d_name))
 487                         continue;
 488
 489                 if (!startswith(de->d_name, "ask."))
 490                         continue;
 491
 492                 p = strappend("/run/systemd/ask-password/", de->d_name);
 493                 if (!p)
 494                         return log_oom();
 495
 496                 q = parse_password(p, &wall);
 497                 if (q < 0 && r == 0)
 498                         r = q;
 499
 500                 if (wall)
 501                         (void) utmp_wall(wall, NULL, NULL, wall_tty_match, NULL);
 502         }
 503
 504         return r;
 505 }
 506
 507 static int watch_passwords(void) {
 508         enum {
 509                 FD_INOTIFY,
 510                 FD_SIGNAL,
 511                 _FD_MAX
 512         };
 513
 514         _cleanup_close_ int notify = -1, signal_fd = -1, tty_block_fd = -1;
 515         struct pollfd pollfd[_FD_MAX] = {};
 516         sigset_t mask;
 517         int r;
 518
 519         tty_block_fd = wall_tty_block();
 520
 521         (void) mkdir_p_label("/run/systemd/ask-password", 0755);
 522
 523         notify = inotify_init1(IN_CLOEXEC);
 524         if (notify < 0)
 525                 return log_error_errno(errno, "Failed to allocate directory watch: %m");
 526
 527         if (inotify_add_watch(notify, "/run/systemd/ask-password", IN_CLOSE_WRITE|IN_MOVED_TO) < 0)
 528                 return log_error_errno(errno, "Failed to add /run/systemd/ask-password to directory watch: %m");
 529
 530         assert_se(sigemptyset(&mask) >= 0);
 531         assert_se(sigset_add_many(&mask, SIGINT, SIGTERM, -1) >= 0);
 532         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) >= 0);
 533
 534         signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 535         if (signal_fd < 0)
 536                 return log_error_errno(errno, "Failed to allocate signal file descriptor: %m");
 537
 538         pollfd[FD_INOTIFY].fd = notify;
 539         pollfd[FD_INOTIFY].events = POLLIN;
 540         pollfd[FD_SIGNAL].fd = signal_fd;
 541         pollfd[FD_SIGNAL].events = POLLIN;
 542
 543         for (;;) {
 544                 r = show_passwords();
 545                 if (r < 0)
 546                         log_error_errno(r, "Failed to show password: %m");
 547
 548                 if (poll(pollfd, _FD_MAX, -1) < 0) {
 549                         if (errno == EINTR)
 550                                 continue;
 551
 552                         return -errno;
 553                 }
 554
 555                 if (pollfd[FD_INOTIFY].revents != 0)
 556                         (void) flush_fd(notify);
 557
 558                 if (pollfd[FD_SIGNAL].revents != 0)
 559                         break;
 560         }
 561
 562         return 0;
 563 }
 564
 565 static void help(void) {
 566         printf("%s [OPTIONS...]\n\n"
 567                "Process system password requests.\n\n"
 568                "  -h --help     Show this help\n"
 569                "     --version  Show package version\n"
 570                "     --list     Show pending password requests\n"
 571                "     --query    Process pending password requests\n"
 572                "     --watch    Continuously process password requests\n"
 573                "     --wall     Continuously forward password requests to wall\n"
 574                "     --plymouth Ask question with Plymouth instead of on TTY\n"
 575                "     --console  Ask question on /dev/console instead of current TTY\n",
 576                program_invocation_short_name);
 577 }
 578
 579 static int parse_argv(int argc, char *argv[]) {
 580
 581         enum {
 582                 ARG_LIST = 0x100,
 583                 ARG_QUERY,
 584                 ARG_WATCH,
 585                 ARG_WALL,
 586                 ARG_PLYMOUTH,
 587                 ARG_CONSOLE,
 588                 ARG_VERSION
 589         };
 590
 591         static const struct option options[] = {
 592                 { "help",     no_argument,       NULL, 'h'          },
 593                 { "version",  no_argument,       NULL, ARG_VERSION  },
 594                 { "list",     no_argument,       NULL, ARG_LIST     },
 595                 { "query",    no_argument,       NULL, ARG_QUERY    },
 596                 { "watch",    no_argument,       NULL, ARG_WATCH    },
 597                 { "wall",     no_argument,       NULL, ARG_WALL     },
 598                 { "plymouth", no_argument,       NULL, ARG_PLYMOUTH },
 599                 { "console",  optional_argument, NULL, ARG_CONSOLE  },
 600                 {}
 601         };
 602
 603         int c;
 604
 605         assert(argc >= 0);
 606         assert(argv);
 607
 608         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
 609
 610                 switch (c) {
 611
 612                 case 'h':
 613                         help();
 614                         return 0;
 615
 616                 case ARG_VERSION:
 617                         return version();
 618
 619                 case ARG_LIST:
 620                         arg_action = ACTION_LIST;
 621                         break;
 622
 623                 case ARG_QUERY:
 624                         arg_action = ACTION_QUERY;
 625                         break;
 626
 627                 case ARG_WATCH:
 628                         arg_action = ACTION_WATCH;
 629                         break;
 630
 631                 case ARG_WALL:
 632                         arg_action = ACTION_WALL;
 633                         break;
 634
 635                 case ARG_PLYMOUTH:
 636                         arg_plymouth = true;
 637                         break;
 638
 639                 case ARG_CONSOLE:
 640                         arg_console = true;
 641                         if (optarg) {
 642
 643                                 if (isempty(optarg)) {
 644                                         log_error("Empty console device path is not allowed.");
 645                                         return -EINVAL;
 646                                 }
 647
 648                                 arg_device = optarg;
 649                         }
 650                         break;
 651
 652                 case '?':
 653                         return -EINVAL;
 654
 655                 default:
 656                         assert_not_reached("Unhandled option");
 657                 }
 658
 659         if (optind != argc) {
 660                 log_error("%s takes no arguments.", program_invocation_short_name);
 661                 return -EINVAL;
 662         }
 663
 664         if (arg_plymouth || arg_console) {
 665
 666                 if (!IN_SET(arg_action, ACTION_QUERY, ACTION_WATCH)) {
 667                         log_error("Options --query and --watch conflict.");
 668                         return -EINVAL;
 669                 }
 670
 671                 if (arg_plymouth && arg_console) {
 672                         log_error("Options --plymouth and --console conflict.");
 673                         return -EINVAL;
 674                 }
 675         }
 676
 677         return 1;
 678 }
 679
 680 /*
 681  * To be able to ask on all terminal devices of /dev/console
 682  * the devices are collected. If more than one device is found,
 683  * then on each of the terminals a inquiring task is forked.
 684  * Every task has its own session and its own controlling terminal.
 685  * If one of the tasks does handle a password, the remaining tasks
 686  * will be terminated.
 687  */
 688 static int ask_on_this_console(const char *tty, pid_t *ret_pid, int argc, char *argv[]) {
 689         struct sigaction sig = {
 690                 .sa_handler = nop_signal_handler,
 691                 .sa_flags = SA_NOCLDSTOP | SA_RESTART,
 692         };
 693         pid_t pid;
 694         int r;
 695
 696         assert_se(sigprocmask_many(SIG_UNBLOCK, NULL, SIGHUP, SIGCHLD, -1) >= 0);
 697
 698         assert_se(sigemptyset(&sig.sa_mask) >= 0);
 699         assert_se(sigaction(SIGCHLD, &sig, NULL) >= 0);
 700
 701         sig.sa_handler = SIG_DFL;
 702         assert_se(sigaction(SIGHUP, &sig, NULL) >= 0);
 703
 704         r = safe_fork("(sd-passwd)", FORK_RESET_SIGNALS|FORK_LOG, &pid);
 705         if (r < 0)
 706                 return r;
 707         if (r == 0) {
 708                 int ac;
 709
 710                 assert_se(prctl(PR_SET_PDEATHSIG, SIGHUP) >= 0);
 711
 712                 for (ac = 0; ac < argc; ac++) {
 713                         if (streq(argv[ac], "--console")) {
 714                                 argv[ac] = strjoina("--console=", tty);
 715                                 break;
 716                         }
 717                 }
 718
 719                 assert(ac < argc);
 720
 721                 execv(SYSTEMD_TTY_ASK_PASSWORD_AGENT_BINARY_PATH, argv);
 722                 _exit(EXIT_FAILURE);
 723         }
 724
 725         *ret_pid = pid;
 726         return 0;
 727 }
 728
 729 static void terminate_agents(Set *pids) {
 730         struct timespec ts;
 731         siginfo_t status = {};
 732         sigset_t set;
 733         Iterator i;
 734         void *p;
 735         int r, signum;
 736
 737         /*
 738          * Request termination of the remaining processes as those
 739          * are not required anymore.
 740          */
 741         SET_FOREACH(p, pids, i)
 742                 (void) kill(PTR_TO_PID(p), SIGTERM);
 743
 744         /*
 745          * Collect the processes which have go away.
 746          */
 747         assert_se(sigemptyset(&set) >= 0);
 748         assert_se(sigaddset(&set, SIGCHLD) >= 0);
 749         timespec_store(&ts, 50 * USEC_PER_MSEC);
 750
 751         while (!set_isempty(pids)) {
 752
 753                 zero(status);
 754                 r = waitid(P_ALL, 0, &status, WEXITED|WNOHANG);
 755                 if (r < 0 && errno == EINTR)
 756                         continue;
 757
 758                 if (r == 0 && status.si_pid > 0) {
 759                         set_remove(pids, PID_TO_PTR(status.si_pid));
 760                         continue;
 761                 }
 762
 763                 signum = sigtimedwait(&set, NULL, &ts);
 764                 if (signum < 0) {
 765                         if (errno != EAGAIN)
 766                                 log_error_errno(errno, "sigtimedwait() failed: %m");
 767                         break;
 768                 }
 769                 assert(signum == SIGCHLD);
 770         }
 771
 772         /*
 773          * Kill hanging processes.
 774          */
 775         SET_FOREACH(p, pids, i) {
 776                 log_warning("Failed to terminate child %d, killing it", PTR_TO_PID(p));
 777                 (void) kill(PTR_TO_PID(p), SIGKILL);
 778         }
 779 }
 780
 781 static int ask_on_consoles(int argc, char *argv[]) {
 782         _cleanup_set_free_ Set *pids = NULL;
 783         _cleanup_strv_free_ char **consoles = NULL;
 784         siginfo_t status = {};
 785         char **tty;
 786         pid_t pid;
 787         int r;
 788
 789         r = get_kernel_consoles(&consoles);
 790         if (r < 0)
 791                 return log_error_errno(r, "Failed to determine devices of /dev/console: %m");
 792
 793         pids = set_new(NULL);
 794         if (!pids)
 795                 return log_oom();
 796
 797         /* Start an agent on each console. */
 798         STRV_FOREACH(tty, consoles) {
 799                 r = ask_on_this_console(*tty, &pid, argc, argv);
 800                 if (r < 0)
 801                         return r;
 802
 803                 if (set_put(pids, PID_TO_PTR(pid)) < 0)
 804                         return log_oom();
 805         }
 806
 807         /* Wait for an agent to exit. */
 808         for (;;) {
 809                 zero(status);
 810
 811                 if (waitid(P_ALL, 0, &status, WEXITED) < 0) {
 812                         if (errno == EINTR)
 813                                 continue;
 814
 815                         return log_error_errno(errno, "waitid() failed: %m");
 816                 }
 817
 818                 set_remove(pids, PID_TO_PTR(status.si_pid));
 819                 break;
 820         }
 821
 822         if (!is_clean_exit(status.si_code, status.si_status, EXIT_CLEAN_DAEMON, NULL))
 823                 log_error("Password agent failed with: %d", status.si_status);
 824
 825         terminate_agents(pids);
 826         return 0;
 827 }
 828
 829 int main(int argc, char *argv[]) {
 830         int r;
 831
 832         log_set_target(LOG_TARGET_AUTO);
 833         log_parse_environment();
 834         log_open();
 835
 836         umask(0022);
 837
 838         r = parse_argv(argc, argv);
 839         if (r <= 0)
 840                 goto finish;
 841
 842         if (arg_console && !arg_device)
 843                 /*
 844                  * Spawn for each console device a separate process.
 845                  */
 846                 r = ask_on_consoles(argc, argv);
 847         else {
 848
 849                 if (arg_device) {
 850                         /*
 851                          * Later on, a controlling terminal will be acquired,
 852                          * therefore the current process has to become a session
 853                          * leader and should not have a controlling terminal already.
 854                          */
 855                         (void) setsid();
 856                         (void) release_terminal();
 857                 }
 858
 859                 if (IN_SET(arg_action, ACTION_WATCH, ACTION_WALL))
 860                         r = watch_passwords();
 861                 else
 862                         r = show_passwords();
 863         }
 864
 865 finish:
 866         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 867 }