1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 Copyright © 2015 Werner Fink
14 #include <sys/inotify.h>
15 #include <sys/prctl.h>
16 #include <sys/signalfd.h>
17 #include <sys/socket.h>
22 #include "alloc-util.h"
23 #include "ask-password-api.h"
24 #include "conf-parser.h"
26 #include "dirent-util.h"
27 #include "exit-status.h"
33 #include "main-func.h"
35 #include "path-util.h"
36 #include "pretty-print.h"
37 #include "process-util.h"
38 #include "signal-util.h"
39 #include "socket-util.h"
40 #include "string-util.h"
42 #include "terminal-util.h"
44 #include "utmp-wtmp.h"
51 } arg_action
= ACTION_QUERY
;
53 static bool arg_plymouth
= false;
54 static bool arg_console
= false;
55 static const char *arg_device
= NULL
;
57 static int ask_password_plymouth(
60 AskPasswordFlags flags
,
61 const char *flag_file
,
64 static const union sockaddr_union sa
= PLYMOUTH_SOCKET
;
65 _cleanup_close_
int fd
= -1, notify
= -1;
66 _cleanup_free_
char *packet
= NULL
;
69 struct pollfd pollfd
[2] = {};
70 char buffer
[LINE_MAX
];
80 notify
= inotify_init1(IN_CLOEXEC
|IN_NONBLOCK
);
84 r
= inotify_add_watch(notify
, flag_file
, IN_ATTRIB
); /* for the link count */
89 fd
= socket(AF_UNIX
, SOCK_STREAM
|SOCK_CLOEXEC
|SOCK_NONBLOCK
, 0);
93 r
= connect(fd
, &sa
.sa
, SOCKADDR_UN_LEN(sa
.un
));
97 if (flags
& ASK_PASSWORD_ACCEPT_CACHED
) {
100 } else if (asprintf(&packet
, "*\002%c%s%n", (int) (strlen(message
) + 1), message
, &n
) < 0)
105 r
= loop_write(fd
, packet
, n
+ 1, true);
109 pollfd
[POLL_SOCKET
].fd
= fd
;
110 pollfd
[POLL_SOCKET
].events
= POLLIN
;
111 pollfd
[POLL_INOTIFY
].fd
= notify
;
112 pollfd
[POLL_INOTIFY
].events
= POLLIN
;
115 int sleep_for
= -1, j
;
120 y
= now(CLOCK_MONOTONIC
);
127 sleep_for
= (int) ((until
- y
) / USEC_PER_MSEC
);
130 if (flag_file
&& access(flag_file
, F_OK
) < 0) {
135 j
= poll(pollfd
, notify
>= 0 ? 2 : 1, sleep_for
);
147 if (notify
>= 0 && pollfd
[POLL_INOTIFY
].revents
!= 0)
148 (void) flush_fd(notify
);
150 if (pollfd
[POLL_SOCKET
].revents
== 0)
153 k
= read(fd
, buffer
+ p
, sizeof(buffer
) - p
);
155 if (IN_SET(errno
, EINTR
, EAGAIN
))
170 if (buffer
[0] == 5) {
172 if (flags
& ASK_PASSWORD_ACCEPT_CACHED
) {
173 /* Hmm, first try with cached
174 * passwords failed, so let's retry
175 * with a normal password request */
176 packet
= mfree(packet
);
178 if (asprintf(&packet
, "*\002%c%s%n", (int) (strlen(message
) + 1), message
, &n
) < 0) {
183 r
= loop_write(fd
, packet
, n
+1, true);
187 flags
&= ~ASK_PASSWORD_ACCEPT_CACHED
;
192 /* No password, because UI not shown */
196 } else if (IN_SET(buffer
[0], 2, 9)) {
200 /* One or more answers */
204 memcpy(&size
, buffer
+1, sizeof(size
));
205 size
= le32toh(size
);
206 if (size
+ 5 > sizeof(buffer
)) {
214 l
= strv_parse_nulstr(buffer
+ 5, size
);
233 explicit_bzero_safe(buffer
, sizeof(buffer
));
237 static int send_passwords(const char *socket_name
, char **passwords
) {
238 _cleanup_free_
char *packet
= NULL
;
239 _cleanup_close_
int socket_fd
= -1;
240 union sockaddr_union sa
= {};
241 size_t packet_length
= 1;
248 salen
= sockaddr_un_set_path(&sa
.un
, socket_name
);
252 STRV_FOREACH(p
, passwords
)
253 packet_length
+= strlen(*p
) + 1;
255 packet
= new(char, packet_length
);
262 STRV_FOREACH(p
, passwords
)
263 d
= stpcpy(d
, *p
) + 1;
265 socket_fd
= socket(AF_UNIX
, SOCK_DGRAM
|SOCK_CLOEXEC
, 0);
267 r
= log_debug_errno(errno
, "socket(): %m");
271 n
= sendto(socket_fd
, packet
, packet_length
, MSG_NOSIGNAL
, &sa
.sa
, salen
);
273 r
= log_debug_errno(errno
, "sendto(): %m");
280 explicit_bzero_safe(packet
, packet_length
);
284 static int parse_password(const char *filename
, char **wall
) {
285 _cleanup_free_
char *socket_name
= NULL
, *message
= NULL
;
286 bool accept_cached
= false, echo
= false;
287 uint64_t not_after
= 0;
290 const ConfigTableItem items
[] = {
291 { "Ask", "Socket", config_parse_string
, 0, &socket_name
},
292 { "Ask", "NotAfter", config_parse_uint64
, 0, ¬_after
},
293 { "Ask", "Message", config_parse_string
, 0, &message
},
294 { "Ask", "PID", config_parse_unsigned
, 0, &pid
},
295 { "Ask", "AcceptCached", config_parse_bool
, 0, &accept_cached
},
296 { "Ask", "Echo", config_parse_bool
, 0, &echo
},
304 r
= config_parse(NULL
, filename
, NULL
,
306 config_item_table_lookup
, items
,
307 CONFIG_PARSE_RELAXED
|CONFIG_PARSE_WARN
, NULL
);
312 return log_error_errno(SYNTHETIC_ERRNO(EBADMSG
),
313 "Invalid password file %s", filename
);
315 if (not_after
> 0 && now(CLOCK_MONOTONIC
) > not_after
)
318 if (pid
> 0 && !pid_is_alive(pid
))
321 if (arg_action
== ACTION_LIST
)
322 printf("'%s' (PID %u)\n", message
, pid
);
324 else if (arg_action
== ACTION_WALL
) {
328 "%s%sPassword entry required for \'%s\' (PID %u).\r\n"
329 "Please enter password with the systemd-tty-ask-password-agent tool:",
331 *wall
? "\r\n\r\n" : "",
340 _cleanup_strv_free_erase_
char **passwords
= NULL
;
342 assert(IN_SET(arg_action
, ACTION_QUERY
, ACTION_WATCH
));
344 if (access(socket_name
, W_OK
) < 0) {
345 if (arg_action
== ACTION_QUERY
)
346 log_info("Not querying '%s' (PID %u), lacking privileges.", message
, pid
);
352 r
= ask_password_plymouth(message
, not_after
, accept_cached
? ASK_PASSWORD_ACCEPT_CACHED
: 0, filename
, &passwords
);
357 const char *con
= arg_device
?: "/dev/console";
359 tty_fd
= acquire_terminal(con
, ACQUIRE_TERMINAL_WAIT
, USEC_INFINITY
);
361 return log_error_errno(tty_fd
, "Failed to acquire %s: %m", con
);
363 r
= reset_terminal_fd(tty_fd
, true);
365 log_warning_errno(r
, "Failed to reset terminal, ignoring: %m");
368 r
= ask_password_tty(tty_fd
, message
, NULL
, not_after
,
369 (echo
? ASK_PASSWORD_ECHO
: 0) |
370 (arg_console
? ASK_PASSWORD_CONSOLE_COLOR
: 0),
371 filename
, &passwords
);
374 tty_fd
= safe_close(tty_fd
);
379 /* If the query went away, that's OK */
380 if (IN_SET(r
, -ETIME
, -ENOENT
))
384 return log_error_errno(r
, "Failed to query password: %m");
386 r
= send_passwords(socket_name
, passwords
);
388 return log_error_errno(r
, "Failed to send: %m");
394 static int wall_tty_block(void) {
395 _cleanup_free_
char *p
= NULL
;
399 r
= get_ctty_devnr(0, &devnr
);
400 if (r
== -ENXIO
) /* We have no controlling tty */
403 return log_error_errno(r
, "Failed to get controlling TTY: %m");
405 if (asprintf(&p
, "/run/systemd/ask-password-block/%u:%u", major(devnr
), minor(devnr
)) < 0)
408 (void) mkdir_parents_label(p
, 0700);
409 (void) mkfifo(p
, 0600);
411 fd
= open(p
, O_RDONLY
|O_CLOEXEC
|O_NONBLOCK
|O_NOCTTY
);
413 return log_debug_errno(errno
, "Failed to open %s: %m", p
);
418 static bool wall_tty_match(const char *path
, void *userdata
) {
419 _cleanup_free_
char *p
= NULL
;
420 _cleanup_close_
int fd
= -1;
423 if (!path_is_absolute(path
))
424 path
= strjoina("/dev/", path
);
426 if (lstat(path
, &st
) < 0) {
427 log_debug_errno(errno
, "Failed to stat %s: %m", path
);
431 if (!S_ISCHR(st
.st_mode
)) {
432 log_debug("%s is not a character device.", path
);
436 /* We use named pipes to ensure that wall messages suggesting
437 * password entry are not printed over password prompts
438 * already shown. We use the fact here that opening a pipe in
439 * non-blocking mode for write-only will succeed only if
440 * there's some writer behind it. Using pipes has the
441 * advantage that the block will automatically go away if the
444 if (asprintf(&p
, "/run/systemd/ask-password-block/%u:%u", major(st
.st_rdev
), minor(st
.st_rdev
)) < 0) {
449 fd
= open(p
, O_WRONLY
|O_CLOEXEC
|O_NONBLOCK
|O_NOCTTY
);
451 log_debug_errno(errno
, "Failed to open the wall pipe: %m");
455 /* What, we managed to open the pipe? Then this tty is filtered. */
459 static int show_passwords(void) {
460 _cleanup_closedir_
DIR *d
;
464 d
= opendir("/run/systemd/ask-password");
469 return log_error_errno(errno
, "Failed to open /run/systemd/ask-password: %m");
472 FOREACH_DIRENT_ALL(de
, d
, return log_error_errno(errno
, "Failed to read directory: %m")) {
473 _cleanup_free_
char *p
= NULL
, *wall
= NULL
;
476 /* We only support /dev on tmpfs, hence we can rely on
477 * d_type to be reliable */
479 if (de
->d_type
!= DT_REG
)
482 if (hidden_or_backup_file(de
->d_name
))
485 if (!startswith(de
->d_name
, "ask."))
488 p
= strappend("/run/systemd/ask-password/", de
->d_name
);
492 q
= parse_password(p
, &wall
);
497 (void) utmp_wall(wall
, NULL
, NULL
, wall_tty_match
, NULL
);
503 static int watch_passwords(void) {
510 _cleanup_close_
int notify
= -1, signal_fd
= -1, tty_block_fd
= -1;
511 struct pollfd pollfd
[_FD_MAX
] = {};
515 tty_block_fd
= wall_tty_block();
517 (void) mkdir_p_label("/run/systemd/ask-password", 0755);
519 notify
= inotify_init1(IN_CLOEXEC
);
521 return log_error_errno(errno
, "Failed to allocate directory watch: %m");
523 if (inotify_add_watch(notify
, "/run/systemd/ask-password", IN_CLOSE_WRITE
|IN_MOVED_TO
) < 0) {
525 return log_error_errno(errno
, "Failed to add /run/systemd/ask-password to directory watch: inotify watch limit reached");
527 return log_error_errno(errno
, "Failed to add /run/systemd/ask-password to directory watch: %m");
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);
534 signal_fd
= signalfd(-1, &mask
, SFD_NONBLOCK
|SFD_CLOEXEC
);
536 return log_error_errno(errno
, "Failed to allocate signal file descriptor: %m");
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
;
544 r
= show_passwords();
546 log_error_errno(r
, "Failed to show password: %m");
548 if (poll(pollfd
, _FD_MAX
, -1) < 0) {
555 if (pollfd
[FD_INOTIFY
].revents
!= 0)
556 (void) flush_fd(notify
);
558 if (pollfd
[FD_SIGNAL
].revents
!= 0)
565 static int help(void) {
566 _cleanup_free_
char *link
= NULL
;
569 r
= terminal_urlify_man("systemd-tty-ask-password-agent", "1", &link
);
573 printf("%s [OPTIONS...]\n\n"
574 "Process system password requests.\n\n"
575 " -h --help Show this help\n"
576 " --version Show package version\n"
577 " --list Show pending password requests\n"
578 " --query Process pending password requests\n"
579 " --watch Continuously process password requests\n"
580 " --wall Continuously forward password requests to wall\n"
581 " --plymouth Ask question with Plymouth instead of on TTY\n"
582 " --console Ask question on /dev/console instead of current TTY\n"
583 "\nSee the %s for details.\n"
584 , program_invocation_short_name
591 static int parse_argv(int argc
, char *argv
[]) {
603 static const struct option options
[] = {
604 { "help", no_argument
, NULL
, 'h' },
605 { "version", no_argument
, NULL
, ARG_VERSION
},
606 { "list", no_argument
, NULL
, ARG_LIST
},
607 { "query", no_argument
, NULL
, ARG_QUERY
},
608 { "watch", no_argument
, NULL
, ARG_WATCH
},
609 { "wall", no_argument
, NULL
, ARG_WALL
},
610 { "plymouth", no_argument
, NULL
, ARG_PLYMOUTH
},
611 { "console", optional_argument
, NULL
, ARG_CONSOLE
},
620 while ((c
= getopt_long(argc
, argv
, "h", options
, NULL
)) >= 0)
631 arg_action
= ACTION_LIST
;
635 arg_action
= ACTION_QUERY
;
639 arg_action
= ACTION_WATCH
;
643 arg_action
= ACTION_WALL
;
655 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
656 "Empty console device path is not allowed.");
666 assert_not_reached("Unhandled option");
670 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
671 "%s takes no arguments.", program_invocation_short_name
);
673 if (arg_plymouth
|| arg_console
) {
675 if (!IN_SET(arg_action
, ACTION_QUERY
, ACTION_WATCH
))
676 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
677 "Options --query and --watch conflict.");
679 if (arg_plymouth
&& arg_console
)
680 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
681 "Options --plymouth and --console conflict.");
688 * To be able to ask on all terminal devices of /dev/console
689 * the devices are collected. If more than one device is found,
690 * then on each of the terminals a inquiring task is forked.
691 * Every task has its own session and its own controlling terminal.
692 * If one of the tasks does handle a password, the remaining tasks
693 * will be terminated.
695 static int ask_on_this_console(const char *tty
, pid_t
*ret_pid
, int argc
, char *argv
[]) {
696 struct sigaction sig
= {
697 .sa_handler
= nop_signal_handler
,
698 .sa_flags
= SA_NOCLDSTOP
| SA_RESTART
,
703 assert_se(sigprocmask_many(SIG_UNBLOCK
, NULL
, SIGHUP
, SIGCHLD
, -1) >= 0);
705 assert_se(sigemptyset(&sig
.sa_mask
) >= 0);
706 assert_se(sigaction(SIGCHLD
, &sig
, NULL
) >= 0);
708 sig
.sa_handler
= SIG_DFL
;
709 assert_se(sigaction(SIGHUP
, &sig
, NULL
) >= 0);
711 r
= safe_fork("(sd-passwd)", FORK_RESET_SIGNALS
|FORK_LOG
, &pid
);
717 assert_se(prctl(PR_SET_PDEATHSIG
, SIGHUP
) >= 0);
719 for (ac
= 0; ac
< argc
; ac
++) {
720 if (streq(argv
[ac
], "--console")) {
721 argv
[ac
] = strjoina("--console=", tty
);
728 execv(SYSTEMD_TTY_ASK_PASSWORD_AGENT_BINARY_PATH
, argv
);
736 static void terminate_agents(Set
*pids
) {
738 siginfo_t status
= {};
745 * Request termination of the remaining processes as those
746 * are not required anymore.
748 SET_FOREACH(p
, pids
, i
)
749 (void) kill(PTR_TO_PID(p
), SIGTERM
);
752 * Collect the processes which have go away.
754 assert_se(sigemptyset(&set
) >= 0);
755 assert_se(sigaddset(&set
, SIGCHLD
) >= 0);
756 timespec_store(&ts
, 50 * USEC_PER_MSEC
);
758 while (!set_isempty(pids
)) {
761 r
= waitid(P_ALL
, 0, &status
, WEXITED
|WNOHANG
);
762 if (r
< 0 && errno
== EINTR
)
765 if (r
== 0 && status
.si_pid
> 0) {
766 set_remove(pids
, PID_TO_PTR(status
.si_pid
));
770 signum
= sigtimedwait(&set
, NULL
, &ts
);
773 log_error_errno(errno
, "sigtimedwait() failed: %m");
776 assert(signum
== SIGCHLD
);
780 * Kill hanging processes.
782 SET_FOREACH(p
, pids
, i
) {
783 log_warning("Failed to terminate child %d, killing it", PTR_TO_PID(p
));
784 (void) kill(PTR_TO_PID(p
), SIGKILL
);
788 static int ask_on_consoles(int argc
, char *argv
[]) {
789 _cleanup_set_free_ Set
*pids
= NULL
;
790 _cleanup_strv_free_
char **consoles
= NULL
;
791 siginfo_t status
= {};
796 r
= get_kernel_consoles(&consoles
);
798 return log_error_errno(r
, "Failed to determine devices of /dev/console: %m");
800 pids
= set_new(NULL
);
804 /* Start an agent on each console. */
805 STRV_FOREACH(tty
, consoles
) {
806 r
= ask_on_this_console(*tty
, &pid
, argc
, argv
);
810 if (set_put(pids
, PID_TO_PTR(pid
)) < 0)
814 /* Wait for an agent to exit. */
818 if (waitid(P_ALL
, 0, &status
, WEXITED
) < 0) {
822 return log_error_errno(errno
, "waitid() failed: %m");
825 set_remove(pids
, PID_TO_PTR(status
.si_pid
));
829 if (!is_clean_exit(status
.si_code
, status
.si_status
, EXIT_CLEAN_DAEMON
, NULL
))
830 log_error("Password agent failed with: %d", status
.si_status
);
832 terminate_agents(pids
);
836 static int run(int argc
, char *argv
[]) {
843 r
= parse_argv(argc
, argv
);
847 if (arg_console
&& !arg_device
)
849 * Spawn a separate process for each console device.
851 return ask_on_consoles(argc
, argv
);
855 * Later on, a controlling terminal will be acquired,
856 * therefore the current process has to become a session
857 * leader and should not have a controlling terminal already.
860 (void) release_terminal();
863 if (IN_SET(arg_action
, ACTION_WATCH
, ACTION_WALL
))
864 return watch_passwords();
866 return show_passwords();
869 DEFINE_MAIN_FUNCTION(run
);