src/ask-password/ask-password.c

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