src/ask-password/ask-password.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <sys/socket.h>
  23 #include <sys/poll.h>
  24 #include <sys/types.h>
  25 #include <assert.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <sys/un.h>
  31 #include <sys/stat.h>
  32 #include <sys/signalfd.h>
  33 #include <getopt.h>
  34 #include <termios.h>
  35 #include <limits.h>
  36 #include <stddef.h>
  37
  38 #include "log.h"
  39 #include "macro.h"
  40 #include "util.h"
  41 #include "strv.h"
  42 #include "ask-password-api.h"
  43 #include "def.h"
  44
  45 static const char *arg_icon = NULL;
  46 static const char *arg_id = NULL;
  47 static const char *arg_message = NULL;
  48 static bool arg_use_tty = true;
  49 static usec_t arg_timeout = DEFAULT_TIMEOUT_USEC;
  50 static bool arg_accept_cached = false;
  51 static bool arg_multiple = false;
  52
  53 static void help(void) {
  54         printf("%s [OPTIONS...] MESSAGE\n\n"
  55                "Query the user for a system passphrase, via the TTY or an UI agent.\n\n"
  56                "  -h --help          Show this help\n"
  57                "     --icon=NAME     Icon name\n"
  58                "     --timeout=SEC   Timeout in sec\n"
  59                "     --no-tty        Ask question via agent even on TTY\n"
  60                "     --accept-cached Accept cached passwords\n"
  61                "     --multiple      List multiple passwords if available\n"
  62                "     --id=ID         Query identifier (e.g. cryptsetup:/dev/sda5)\n"
  63                , program_invocation_short_name);
  64 }
  65
  66 static int parse_argv(int argc, char *argv[]) {
  67
  68         enum {
  69                 ARG_ICON = 0x100,
  70                 ARG_TIMEOUT,
  71                 ARG_NO_TTY,
  72                 ARG_ACCEPT_CACHED,
  73                 ARG_MULTIPLE,
  74                 ARG_ID
  75         };
  76
  77         static const struct option options[] = {
  78                 { "help",          no_argument,       NULL, 'h'               },
  79                 { "icon",          required_argument, NULL, ARG_ICON          },
  80                 { "timeout",       required_argument, NULL, ARG_TIMEOUT       },
  81                 { "no-tty",        no_argument,       NULL, ARG_NO_TTY        },
  82                 { "accept-cached", no_argument,       NULL, ARG_ACCEPT_CACHED },
  83                 { "multiple",      no_argument,       NULL, ARG_MULTIPLE      },
  84                 { "id",            required_argument, NULL, ARG_ID            },
  85                 {}
  86         };
  87
  88         int c;
  89
  90         assert(argc >= 0);
  91         assert(argv);
  92
  93         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
  94
  95                 switch (c) {
  96
  97                 case 'h':
  98                         help();
  99                         return 0;
 100
 101                 case ARG_ICON:
 102                         arg_icon = optarg;
 103                         break;
 104
 105                 case ARG_TIMEOUT:
 106                         if (parse_sec(optarg, &arg_timeout) < 0) {
 107                                 log_error("Failed to parse --timeout parameter %s", optarg);
 108                                 return -EINVAL;
 109                         }
 110                         break;
 111
 112                 case ARG_NO_TTY:
 113                         arg_use_tty = false;
 114                         break;
 115
 116                 case ARG_ACCEPT_CACHED:
 117                         arg_accept_cached = true;
 118                         break;
 119
 120                 case ARG_MULTIPLE:
 121                         arg_multiple = true;
 122                         break;
 123
 124                 case ARG_ID:
 125                         arg_id = optarg;
 126                         break;
 127
 128                 case '?':
 129                         return -EINVAL;
 130
 131                 default:
 132                         assert_not_reached("Unhandled option");
 133                 }
 134
 135         if (optind != argc - 1) {
 136                 log_error("%s: required argument missing.", program_invocation_short_name);
 137                 return -EINVAL;
 138         }
 139
 140         arg_message = argv[optind];
 141         return 1;
 142 }
 143
 144 int main(int argc, char *argv[]) {
 145         int r;
 146         usec_t timeout;
 147
 148         log_parse_environment();
 149         log_open();
 150
 151         r = parse_argv(argc, argv);
 152         if (r <= 0)
 153                 goto finish;
 154
 155         if (arg_timeout > 0)
 156                 timeout = now(CLOCK_MONOTONIC) + arg_timeout;
 157         else
 158                 timeout = 0;
 159
 160         if (arg_use_tty && isatty(STDIN_FILENO)) {
 161                 char *password = NULL;
 162
 163                 if ((r = ask_password_tty(arg_message, timeout, NULL, &password)) >= 0) {
 164                         puts(password);
 165                         free(password);
 166                 }
 167
 168         } else {
 169                 char **l;
 170
 171                 if ((r = ask_password_agent(arg_message, arg_icon, arg_id, timeout, arg_accept_cached, &l)) >= 0) {
 172                         char **p;
 173
 174                         STRV_FOREACH(p, l) {
 175                                 puts(*p);
 176
 177                                 if (!arg_multiple)
 178                                         break;
 179                         }
 180
 181                         strv_free(l);
 182                 }
 183         }
 184
 185 finish:
 186
 187         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 188 }