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 <errno.h>
  23 #include <getopt.h>
  24 #include <stddef.h>
  25 #include <unistd.h>
  26
  27 #include "ask-password-api.h"
  28 #include "def.h"
  29 #include "log.h"
  30 #include "macro.h"
  31 #include "strv.h"
  32
  33 static const char *arg_icon = NULL;
  34 static const char *arg_id = NULL;
  35 static const char *arg_keyname = NULL;
  36 static char *arg_message = NULL;
  37 static usec_t arg_timeout = DEFAULT_TIMEOUT_USEC;
  38 static bool arg_multiple = false;
  39 static AskPasswordFlags arg_flags = ASK_PASSWORD_PUSH_CACHE;
  40
  41 static void help(void) {
  42         printf("%s [OPTIONS...] MESSAGE\n\n"
  43                "Query the user for a system passphrase, via the TTY or an UI agent.\n\n"
  44                "  -h --help           Show this help\n"
  45                "     --icon=NAME      Icon name\n"
  46                "     --id=ID          Query identifier (e.g. \"cryptsetup:/dev/sda5\")\n"
  47                "     --keyname=NAME   Kernel key name for caching passwords (e.g. \"cryptsetup\")\n"
  48                "     --timeout=SEC    Timeout in seconds\n"
  49                "     --echo           Do not mask input (useful for usernames)\n"
  50                "     --no-tty         Ask question via agent even on TTY\n"
  51                "     --accept-cached  Accept cached passwords\n"
  52                "     --multiple       List multiple passwords if available\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         };
  68
  69         static const struct option options[] = {
  70                 { "help",          no_argument,       NULL, 'h'               },
  71                 { "icon",          required_argument, NULL, ARG_ICON          },
  72                 { "timeout",       required_argument, NULL, ARG_TIMEOUT       },
  73                 { "echo",          no_argument,       NULL, ARG_ECHO          },
  74                 { "no-tty",        no_argument,       NULL, ARG_NO_TTY        },
  75                 { "accept-cached", no_argument,       NULL, ARG_ACCEPT_CACHED },
  76                 { "multiple",      no_argument,       NULL, ARG_MULTIPLE      },
  77                 { "id",            required_argument, NULL, ARG_ID            },
  78                 { "keyname",       required_argument, NULL, ARG_KEYNAME       },
  79                 {}
  80         };
  81
  82         int c;
  83
  84         assert(argc >= 0);
  85         assert(argv);
  86
  87         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
  88
  89                 switch (c) {
  90
  91                 case 'h':
  92                         help();
  93                         return 0;
  94
  95                 case ARG_ICON:
  96                         arg_icon = optarg;
  97                         break;
  98
  99                 case ARG_TIMEOUT:
 100                         if (parse_sec(optarg, &arg_timeout) < 0) {
 101                                 log_error("Failed to parse --timeout parameter %s", optarg);
 102                                 return -EINVAL;
 103                         }
 104                         break;
 105
 106                 case ARG_ECHO:
 107                         arg_flags |= ASK_PASSWORD_ECHO;
 108                         break;
 109
 110                 case ARG_NO_TTY:
 111                         arg_flags |= ASK_PASSWORD_NO_TTY;
 112                         break;
 113
 114                 case ARG_ACCEPT_CACHED:
 115                         arg_flags |= ASK_PASSWORD_ACCEPT_CACHED;
 116                         break;
 117
 118                 case ARG_MULTIPLE:
 119                         arg_multiple = true;
 120                         break;
 121
 122                 case ARG_ID:
 123                         arg_id = optarg;
 124                         break;
 125
 126                 case ARG_KEYNAME:
 127                         arg_keyname = optarg;
 128                         break;
 129
 130                 case '?':
 131                         return -EINVAL;
 132
 133                 default:
 134                         assert_not_reached("Unhandled option");
 135                 }
 136
 137         if (argc > optind) {
 138                 arg_message = strv_join(argv + optind, " ");
 139                 if (!arg_message)
 140                         return log_oom();
 141         }
 142
 143         return 1;
 144 }
 145
 146 int main(int argc, char *argv[]) {
 147         _cleanup_strv_free_erase_ char **l = NULL;
 148         usec_t timeout;
 149         char **p;
 150         int r;
 151
 152         log_parse_environment();
 153         log_open();
 154
 155         r = parse_argv(argc, argv);
 156         if (r <= 0)
 157                 goto finish;
 158
 159         if (arg_timeout > 0)
 160                 timeout = now(CLOCK_MONOTONIC) + arg_timeout;
 161         else
 162                 timeout = 0;
 163
 164         r = ask_password_auto(arg_message, arg_icon, arg_id, arg_keyname, timeout, arg_flags, &l);
 165         if (r < 0) {
 166                 log_error_errno(r, "Failed to query password: %m");
 167                 goto finish;
 168         }
 169
 170         STRV_FOREACH(p, l) {
 171                 puts(*p);
 172
 173                 if (!arg_multiple)
 174                         break;
 175         }
 176
 177 finish:
 178         free(arg_message);
 179
 180         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 181 }