/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/plymouth.c

  • Committer: Teddy Hogeborn
  • Date: 2021-02-03 23:10:42 UTC
  • Revision ID: teddy@recompile.se-20210203231042-2z3egrvpo1zt7nej
mandos-ctl: Fix bad test for command.Remove and related minor issues

The test for command.Remove removes all clients from the spy server,
and then loops over all clients, looking for the corresponding Remove
command as recorded by the spy server.  But since since there aren't
any clients left after they were removed, no assertions are made, and
the test therefore does nothing.  Fix this.

In tests for command.Approve and command.Deny, add checks that clients
were not somehow removed by the command (in which case, likewise, no
assertions are made).

Add related checks to TestPropertySetterCmd.runTest; i.e. test that a
sequence is not empty before looping over it and making assertions.

* mandos-ctl (TestBaseCommands.test_Remove): Save a copy of the
  original "clients" dict, and loop over those instead.  Add assertion
  that all clients were indeed removed.  Also fix the code which looks
  for the Remove command, which now needs to actually work.
  (TestBaseCommands.test_Approve, TestBaseCommands.test_Deny): Add
  assertion that there are still clients before looping over them.
  (TestPropertySetterCmd.runTest): Add assertion that the list of
  values to get is not empty before looping over them.  Also add check
  that there are still clients before looping over clients.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/plymouth.c
1
 
#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */
2
 
#include <signal.h>             /* sig_atomic_t, struct sigaction,
3
 
                                   sigemptyset(), sigaddset(), SIGINT,
4
 
                                   SIGHUP, SIGTERM, sigaction(),
5
 
                                   kill(), SIG_IGN */
 
1
/*  -*- coding: utf-8 -*- */
 
2
/*
 
3
 * Plymouth - Read a password from Plymouth and output it
 
4
 * 
 
5
 * Copyright © 2010-2021 Teddy Hogeborn
 
6
 * Copyright © 2010-2021 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
 
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
18
 * General Public License for more details.
 
19
 * 
 
20
 * You should have received a copy of the GNU General Public License
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
22
 * 
 
23
 * Contact the authors at <mandos@recompile.se>.
 
24
 */
 
25
 
 
26
#define _GNU_SOURCE             /* program_invocation_short_name,
 
27
                                   vasprintf(), asprintf(),
 
28
                                   TEMP_FAILURE_RETRY() */
 
29
#include <sys/types.h>          /* sig_atomic_t, pid_t, setuid(),
 
30
                                   geteuid(), setsid() */
 
31
#include <argp.h>               /* argp_program_version,
 
32
                                   argp_program_bug_address,
 
33
                                   struct argp_option,
 
34
                                   struct argp_state,
 
35
                                   ARGP_ERR_UNKNOWN, struct argp,
 
36
                                   argp_parse(), ARGP_IN_ORDER */
 
37
#include <stddef.h>             /* NULL, size_t */
6
38
#include <stdbool.h>            /* bool, false, true */
 
39
#include <stdio.h>              /* FILE, fprintf(), vfprintf(),
 
40
                                   vasprintf(), stderr, asprintf(),
 
41
                                   fopen(), fscanf(), fclose(),
 
42
                                   sscanf() */
 
43
#include <stdarg.h>             /* va_list, va_start(), vfprintf() */
 
44
#include <errno.h>              /* program_invocation_short_name,
 
45
                                   errno, ENOMEM, EINTR, ENOENT,
 
46
                                   error_t, EINVAL */
 
47
#include <string.h>             /* strerror(), strdup(), memcmp() */
 
48
#include <error.h>              /* error() */
 
49
#include <stdlib.h>             /* free(), getenv(), malloc(),
 
50
                                   reallocarray(), realloc(),
 
51
                                   EXIT_FAILURE, EXIT_SUCCESS */
 
52
#include <unistd.h>             /* TEMP_FAILURE_RETRY(), setuid(),
 
53
                                   geteuid(), setsid(), chdir(),
 
54
                                   dup2(), STDERR_FILENO,
 
55
                                   STDOUT_FILENO, fork(), _exit(),
 
56
                                   execv(), ssize_t, readlink(),
 
57
                                   close(), read(), access(), X_OK */
 
58
#include <signal.h>             /* kill(), SIGTERM, struct sigaction,
 
59
                                   sigemptyset(), SIGINT, SIGHUP,
 
60
                                   sigaddset(), SIG_IGN */
 
61
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
 
62
                                   WEXITSTATUS(), WIFSIGNALED(),
 
63
                                   WTERMSIG() */
 
64
#include <iso646.h>             /* not, and, or */
 
65
#include <sysexits.h>           /* EX_OSERR, EX_USAGE,
 
66
                                   EX_UNAVAILABLE */
 
67
#include <stdint.h>             /* SIZE_MAX */
 
68
#include <dirent.h>             /* struct dirent, scandir(),
 
69
                                   alphasort() */
 
70
#include <inttypes.h>           /* uintmax_t, strtoumax(), SCNuMAX,
 
71
                                   PRIuMAX */
 
72
#include <sys/stat.h>           /* struct stat, lstat(), S_ISLNK() */
7
73
#include <fcntl.h>              /* open(), O_RDONLY */
8
 
#include <iso646.h>             /* and, or, not*/
9
 
#include <sys/types.h>          /* size_t, ssize_t, pid_t, struct
10
 
                                   dirent, waitpid() */
11
 
#include <sys/wait.h>           /* waitpid() */
12
 
#include <stddef.h>             /* NULL */
13
 
#include <string.h>             /* strchr(), memcmp() */
14
 
#include <stdio.h>              /* asprintf(), perror(), fopen(),
15
 
                                   fscanf() */
16
 
#include <unistd.h>             /* close(), readlink(), read(),
17
 
                                   fork(), setsid(), chdir(), dup2(),
18
 
                                   STDERR_FILENO, execv(), access() */
19
 
#include <stdlib.h>             /* free(), EXIT_FAILURE, realloc(),
20
 
                                   EXIT_SUCCESS, malloc(), _exit(),
21
 
                                   getenv() */
22
 
#include <dirent.h>             /* scandir(), alphasort() */
23
 
#include <inttypes.h>           /* intmax_t, strtoumax(), SCNuMAX */
24
 
#include <sys/stat.h>           /* struct stat, lstat() */
25
 
#include <sysexits.h>           /* EX_OSERR, EX_UNAVAILABLE */
26
 
#include <error.h>              /* error() */
27
 
#include <errno.h>              /* TEMP_FAILURE_RETRY */
28
74
#include <argz.h>               /* argz_count(), argz_extract() */
29
75
 
30
76
sig_atomic_t interrupted_by_signal = 0;
31
 
const char plymouth_pid[] = "/dev/.initramfs/plymouth.pid";
 
77
const char *argp_program_version = "plymouth " VERSION;
 
78
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
79
 
 
80
/* Used by Ubuntu 11.04 (Natty Narwahl) */
 
81
const char plymouth_old_old_pid[] = "/dev/.initramfs/plymouth.pid";
 
82
/* Used by Ubuntu 11.10 (Oneiric Ocelot) */
 
83
const char plymouth_old_pid[] = "/run/initramfs/plymouth.pid";
 
84
/* Used by Debian 9 (stretch) */
 
85
const char plymouth_pid[] = "/run/plymouth/pid";
 
86
 
32
87
const char plymouth_path[] = "/bin/plymouth";
33
88
const char plymouthd_path[] = "/sbin/plymouthd";
34
89
const char *plymouthd_default_argv[] = {"/sbin/plymouthd",
35
90
                                        "--mode=boot",
36
91
                                        "--attach-to-session",
37
 
                                        "--pid-file="
38
 
                                        "/dev/.initramfs/"
39
 
                                        "plymouth.pid",
40
92
                                        NULL };
 
93
bool debug = false;
41
94
 
42
95
static void termination_handler(__attribute__((unused))int signum){
43
96
  if(interrupted_by_signal){
46
99
  interrupted_by_signal = 1;
47
100
}
48
101
 
 
102
__attribute__((format (gnu_printf, 2, 3), nonnull))
 
103
int fprintf_plus(FILE *stream, const char *format, ...){
 
104
  va_list ap;
 
105
  va_start (ap, format);
 
106
  fprintf(stream, "Mandos plugin %s: ", program_invocation_short_name);
 
107
  return vfprintf(stream, format, ap);
 
108
}
 
109
 
 
110
/* Function to use when printing errors */
 
111
__attribute__((format (gnu_printf, 3, 4)))
 
112
void error_plus(int status, int errnum, const char *formatstring,
 
113
                ...){
 
114
  va_list ap;
 
115
  char *text;
 
116
  int ret;
 
117
  
 
118
  va_start(ap, formatstring);
 
119
  ret = vasprintf(&text, formatstring, ap);
 
120
  if(ret == -1){
 
121
    fprintf(stderr, "Mandos plugin %s: ",
 
122
            program_invocation_short_name);
 
123
    vfprintf(stderr, formatstring, ap);
 
124
    fprintf(stderr, ": ");
 
125
    fprintf(stderr, "%s\n", strerror(errnum));
 
126
    error(status, errno, "vasprintf while printing error");
 
127
    return;
 
128
  }
 
129
  fprintf(stderr, "Mandos plugin ");
 
130
  error(status, errnum, "%s", text);
 
131
  free(text);
 
132
}
 
133
 
49
134
/* Create prompt string */
50
135
char *makeprompt(void){
51
136
  int ret = 0;
52
137
  char *prompt;
53
138
  const char *const cryptsource = getenv("cryptsource");
54
139
  const char *const crypttarget = getenv("crypttarget");
55
 
  const char prompt_start[] = "Enter passphrase to unlock the disk";
 
140
  const char prompt_start[] = "Unlocking the disk";
 
141
  const char prompt_end[] = "Enter passphrase";
56
142
  
57
143
  if(cryptsource == NULL){
58
144
    if(crypttarget == NULL){
59
 
      ret = asprintf(&prompt, "%s: ", prompt_start);
 
145
      ret = asprintf(&prompt, "%s\n%s", prompt_start, prompt_end);
60
146
    } else {
61
 
      ret = asprintf(&prompt, "%s (%s): ", prompt_start,
62
 
                     crypttarget);
 
147
      ret = asprintf(&prompt, "%s (%s)\n%s", prompt_start,
 
148
                     crypttarget, prompt_end);
63
149
    }
64
150
  } else {
65
151
    if(crypttarget == NULL){
66
 
      ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
 
152
      ret = asprintf(&prompt, "%s %s\n%s", prompt_start, cryptsource,
 
153
                     prompt_end);
67
154
    } else {
68
 
      ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
69
 
                     cryptsource, crypttarget);
 
155
      ret = asprintf(&prompt, "%s %s (%s)\n%s", prompt_start,
 
156
                     cryptsource, crypttarget, prompt_end);
70
157
    }
71
158
  }
72
159
  if(ret == -1){
83
170
bool become_a_daemon(void){
84
171
  int ret = setuid(geteuid());
85
172
  if(ret == -1){
86
 
    error(0, errno, "setuid");
 
173
    error_plus(0, errno, "setuid");
87
174
  }
88
175
    
89
176
  setsid();
90
177
  ret = chdir("/");
91
178
  if(ret == -1){
92
 
    error(0, errno, "chdir");
 
179
    error_plus(0, errno, "chdir");
93
180
    return false;
94
181
  }
95
182
  ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
96
183
  if(ret == -1){
97
 
    error(0, errno, "dup2");
 
184
    error_plus(0, errno, "dup2");
98
185
    return false;
99
186
  }
100
187
  return true;
101
188
}
102
189
 
 
190
__attribute__((nonnull (2, 3)))
103
191
bool exec_and_wait(pid_t *pid_return, const char *path,
104
 
                   const char **argv, bool interruptable,
 
192
                   const char * const * const argv, bool interruptable,
105
193
                   bool daemonize){
106
194
  int status;
107
195
  int ret;
108
196
  pid_t pid;
 
197
  if(debug){
 
198
    for(const char * const *arg = argv; *arg != NULL; arg++){
 
199
      fprintf_plus(stderr, "exec_and_wait arg: %s\n", *arg);
 
200
    }
 
201
    fprintf_plus(stderr, "exec_and_wait end of args\n");
 
202
  }
 
203
 
109
204
  pid = fork();
110
205
  if(pid == -1){
111
 
    error(0, errno, "fork");
 
206
    error_plus(0, errno, "fork");
112
207
    return false;
113
208
  }
114
209
  if(pid == 0){
118
213
        _exit(EX_OSERR);
119
214
      }
120
215
    }
121
 
 
122
 
    char **new_argv = NULL;
123
 
    char *tmp;
 
216
    
 
217
    char **new_argv = malloc(sizeof(const char *));
 
218
    if(new_argv == NULL){
 
219
      error_plus(0, errno, "malloc");
 
220
      _exit(EX_OSERR);
 
221
    }
 
222
    char **tmp;
124
223
    int i = 0;
125
 
    for (; argv[i]!=(char *)NULL; i++){
126
 
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
127
 
      if (tmp == NULL){
128
 
        error(0, errno, "realloc");
 
224
    for (; argv[i] != NULL; i++){
 
225
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
226
      tmp = reallocarray(new_argv, ((size_t)i + 2),
 
227
                         sizeof(const char *));
 
228
#else
 
229
      if(((size_t)i + 2) > (SIZE_MAX / sizeof(const char *))){
 
230
        /* overflow */
 
231
        tmp = NULL;
 
232
        errno = ENOMEM;
 
233
      } else {
 
234
        tmp = realloc(new_argv, ((size_t)i + 2) * sizeof(const char *));
 
235
      }
 
236
#endif
 
237
      if(tmp == NULL){
 
238
        error_plus(0, errno, "reallocarray");
129
239
        free(new_argv);
130
240
        _exit(EX_OSERR);
131
241
      }
132
 
      new_argv = (char **)tmp;
 
242
      new_argv = tmp;
133
243
      new_argv[i] = strdup(argv[i]);
134
244
    }
135
 
    new_argv[i] = (char *) NULL;
 
245
    new_argv[i] = NULL;
136
246
    
137
247
    execv(path, (char *const *)new_argv);
138
 
    error(0, errno, "execv");
 
248
    error_plus(0, errno, "execv");
139
249
    _exit(EXIT_FAILURE);
140
250
  }
141
251
  if(pid_return != NULL){
147
257
          and ((not interrupted_by_signal)
148
258
               or (not interruptable)));
149
259
  if(interrupted_by_signal and interruptable){
 
260
    if(debug){
 
261
      fprintf_plus(stderr, "Interrupted by signal\n");
 
262
    }
150
263
    return false;
151
264
  }
152
265
  if(ret == -1){
153
 
    error(0, errno, "waitpid");
 
266
    error_plus(0, errno, "waitpid");
154
267
    return false;
155
268
  }
 
269
  if(debug){
 
270
    if(WIFEXITED(status)){
 
271
      fprintf_plus(stderr, "exec_and_wait exited: %d\n",
 
272
                   WEXITSTATUS(status));
 
273
    } else if(WIFSIGNALED(status)) {
 
274
      fprintf_plus(stderr, "exec_and_wait signaled: %d\n",
 
275
                   WTERMSIG(status));
 
276
    }
 
277
  }
156
278
  if(WIFEXITED(status) and (WEXITSTATUS(status) == 0)){
157
279
    return true;
158
280
  }
159
281
  return false;
160
282
}
161
283
 
 
284
__attribute__((nonnull))
162
285
int is_plymouth(const struct dirent *proc_entry){
163
286
  int ret;
164
287
  {
165
 
    uintmax_t maxvalue;
 
288
    uintmax_t proc_id;
166
289
    char *tmp;
167
290
    errno = 0;
168
 
    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
291
    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
169
292
 
170
293
    if(errno != 0 or *tmp != '\0'
171
 
       or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
294
       or proc_id != (uintmax_t)((pid_t)proc_id)){
172
295
      return 0;
173
296
    }
174
297
  }
175
 
  char exe_target[sizeof(plymouth_path)];
 
298
  char exe_target[sizeof(plymouthd_path)];
176
299
  char *exe_link;
177
300
  ret = asprintf(&exe_link, "/proc/%s/exe", proc_entry->d_name);
178
301
  if(ret == -1){
179
 
    error(0, errno, "asprintf");
 
302
    error_plus(0, errno, "asprintf");
180
303
    return 0;
181
304
  }
182
305
  
185
308
  if(ret == -1){
186
309
    free(exe_link);
187
310
    if(errno != ENOENT){
188
 
      error(0, errno, "lstat");
 
311
      error_plus(0, errno, "lstat");
189
312
    }
190
313
    return 0;
191
314
  }
199
322
  
200
323
  ssize_t sret = readlink(exe_link, exe_target, sizeof(exe_target));
201
324
  free(exe_link);
202
 
  if((sret != (ssize_t)sizeof(plymouth_path)-1) or
203
 
      (memcmp(plymouth_path, exe_target,
204
 
              sizeof(plymouth_path)-1) != 0)){
 
325
  if((sret != (ssize_t)sizeof(plymouthd_path)-1) or
 
326
      (memcmp(plymouthd_path, exe_target,
 
327
              sizeof(plymouthd_path)-1) != 0)){
205
328
    return 0;
206
329
  }
207
330
  return 1;
209
332
 
210
333
pid_t get_pid(void){
211
334
  int ret;
 
335
  uintmax_t proc_id = 0;
212
336
  FILE *pidfile = fopen(plymouth_pid, "r");
213
 
  uintmax_t maxvalue = 0;
 
337
  /* Try the new pid file location */
214
338
  if(pidfile != NULL){
215
 
    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
339
    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
216
340
    if(ret != 1){
217
 
      maxvalue = 0;
 
341
      proc_id = 0;
218
342
    }
219
343
    fclose(pidfile);
220
344
  }
221
 
  if(maxvalue == 0){
222
 
    struct dirent **direntries;
 
345
  /* Try the old pid file location */
 
346
  if(proc_id == 0){
 
347
    pidfile = fopen(plymouth_old_pid, "r");
 
348
    if(pidfile != NULL){
 
349
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
350
      if(ret != 1){
 
351
        proc_id = 0;
 
352
      }
 
353
      fclose(pidfile);
 
354
    }
 
355
  }
 
356
  /* Try the old old pid file location */
 
357
  if(proc_id == 0){
 
358
    pidfile = fopen(plymouth_old_old_pid, "r");
 
359
    if(pidfile != NULL){
 
360
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
361
      if(ret != 1){
 
362
        proc_id = 0;
 
363
      }
 
364
      fclose(pidfile);
 
365
    }
 
366
  }
 
367
  /* Look for a plymouth process */
 
368
  if(proc_id == 0){
 
369
    struct dirent **direntries = NULL;
223
370
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
224
 
    sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
 
371
    if(ret == -1){
 
372
      error_plus(0, errno, "scandir");
 
373
    }
 
374
    if(ret > 0){
 
375
      for(int i = ret-1; i >= 0; i--){
 
376
        if(proc_id == 0){
 
377
          ret = sscanf(direntries[i]->d_name, "%" SCNuMAX, &proc_id);
 
378
          if(ret < 0){
 
379
            error_plus(0, errno, "sscanf");
 
380
          }
 
381
        }
 
382
        free(direntries[i]);
 
383
      }
 
384
    }
 
385
    /* scandir might preallocate for this variable (man page unclear).
 
386
       even if ret == 0, therefore we need to free it. */
 
387
    free(direntries);
225
388
  }
226
389
  pid_t pid;
227
 
  pid = (pid_t)maxvalue;
228
 
  if((uintmax_t)pid == maxvalue){
 
390
  pid = (pid_t)proc_id;
 
391
  if((uintmax_t)pid == proc_id){
229
392
    return pid;
230
393
  }
231
394
  
232
395
  return 0;
233
396
}
234
397
 
235
 
const char **getargv(pid_t pid){
 
398
char **getargv(pid_t pid){
236
399
  int cl_fd;
237
400
  char *cmdline_filename;
238
401
  ssize_t sret;
241
404
  ret = asprintf(&cmdline_filename, "/proc/%" PRIuMAX "/cmdline",
242
405
                 (uintmax_t)pid);
243
406
  if(ret == -1){
244
 
    error(0, errno, "asprintf");
 
407
    error_plus(0, errno, "asprintf");
245
408
    return NULL;
246
409
  }
247
410
  
249
412
  cl_fd = open(cmdline_filename, O_RDONLY);
250
413
  free(cmdline_filename);
251
414
  if(cl_fd == -1){
252
 
    error(0, errno, "open");
 
415
    error_plus(0, errno, "open");
253
416
    return NULL;
254
417
  }
255
418
  
263
426
    if(cmdline_len + blocksize > cmdline_allocated){
264
427
      tmp = realloc(cmdline, cmdline_allocated + blocksize);
265
428
      if(tmp == NULL){
266
 
        error(0, errno, "realloc");
 
429
        error_plus(0, errno, "realloc");
267
430
        free(cmdline);
268
431
        close(cl_fd);
269
432
        return NULL;
276
439
    sret = read(cl_fd, cmdline + cmdline_len,
277
440
                cmdline_allocated - cmdline_len);
278
441
    if(sret == -1){
279
 
      error(0, errno, "read");
 
442
      error_plus(0, errno, "read");
280
443
      free(cmdline);
281
444
      close(cl_fd);
282
445
      return NULL;
285
448
  } while(sret != 0);
286
449
  ret = close(cl_fd);
287
450
  if(ret == -1){
288
 
    error(0, errno, "close");
 
451
    error_plus(0, errno, "close");
289
452
    free(cmdline);
290
453
    return NULL;
291
454
  }
294
457
  char **argv = malloc((argz_count(cmdline, cmdline_len) + 1)
295
458
                       * sizeof(char *)); /* Get number of args */
296
459
  if(argv == NULL){
297
 
    error(0, errno, "argv = malloc()");
 
460
    error_plus(0, errno, "argv = malloc()");
298
461
    free(cmdline);
299
462
    return NULL;
300
463
  }
301
464
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
302
 
  return (const char **)argv;
 
465
  return argv;
303
466
}
304
467
 
305
468
int main(__attribute__((unused))int argc,
306
469
         __attribute__((unused))char **argv){
307
 
  char *prompt;
 
470
  char *prompt = NULL;
308
471
  char *prompt_arg;
309
472
  pid_t plymouth_command_pid;
310
473
  int ret;
311
474
  bool bret;
312
475
 
 
476
  {
 
477
    struct argp_option options[] = {
 
478
      { .name = "prompt", .key = 128, .arg = "PROMPT",
 
479
        .doc = "The prompt to show" },
 
480
      { .name = "debug", .key = 129,
 
481
        .doc = "Debug mode" },
 
482
      { .name = NULL }
 
483
    };
 
484
    
 
485
    __attribute__((nonnull(3)))
 
486
    error_t parse_opt (int key, char *arg, __attribute__((unused))
 
487
                       struct argp_state *state){
 
488
      errno = 0;
 
489
      switch (key){
 
490
      case 128:                 /* --prompt */
 
491
        prompt = arg;
 
492
        if(debug){
 
493
          fprintf_plus(stderr, "Custom prompt \"%s\"\n", prompt);
 
494
        }
 
495
        break;
 
496
      case 129:                 /* --debug */
 
497
        debug = true;
 
498
        break;
 
499
      default:
 
500
        return ARGP_ERR_UNKNOWN;
 
501
      }
 
502
      return errno;
 
503
    }
 
504
    
 
505
    struct argp argp = { .options = options, .parser = parse_opt,
 
506
                         .args_doc = "",
 
507
                         .doc = "Mandos plymouth -- Read and"
 
508
                         " output a password" };
 
509
    ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, NULL);
 
510
    switch(ret){
 
511
    case 0:
 
512
      break;
 
513
    case ENOMEM:
 
514
    default:
 
515
      errno = ret;
 
516
      error_plus(0, errno, "argp_parse");
 
517
      return EX_OSERR;
 
518
    case EINVAL:
 
519
      error_plus(0, errno, "argp_parse");
 
520
      return EX_USAGE;
 
521
    }
 
522
  }
 
523
  
313
524
  /* test -x /bin/plymouth */
314
525
  ret = access(plymouth_path, X_OK);
315
526
  if(ret == -1){
316
527
    /* Plymouth is probably not installed.  Don't print an error
317
528
       message, just exit. */
 
529
    if(debug){
 
530
      fprintf_plus(stderr, "Plymouth (%s) not found\n",
 
531
                   plymouth_path);
 
532
    }
318
533
    exit(EX_UNAVAILABLE);
319
534
  }
320
535
  
327
542
        *sig != 0; sig++){
328
543
      ret = sigaddset(&new_action.sa_mask, *sig);
329
544
      if(ret == -1){
330
 
        error(EX_OSERR, errno, "sigaddset");
 
545
        error_plus(EX_OSERR, errno, "sigaddset");
331
546
      }
332
547
      ret = sigaction(*sig, NULL, &old_action);
333
548
      if(ret == -1){
334
 
        error(EX_OSERR, errno, "sigaction");
 
549
        error_plus(EX_OSERR, errno, "sigaction");
335
550
      }
336
551
      if(old_action.sa_handler != SIG_IGN){
337
552
        ret = sigaction(*sig, &new_action, NULL);
338
553
        if(ret == -1){
339
 
          error(EX_OSERR, errno, "sigaction");
 
554
          error_plus(EX_OSERR, errno, "sigaction");
340
555
        }
341
556
      }
342
557
    }
354
569
    }
355
570
    /* Plymouth is probably not running.  Don't print an error
356
571
       message, just exit. */
 
572
    if(debug){
 
573
      fprintf_plus(stderr, "Plymouth not running\n");
 
574
    }
357
575
    exit(EX_UNAVAILABLE);
358
576
  }
359
577
  
360
 
  prompt = makeprompt();
361
 
  ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
362
 
  free(prompt);
 
578
  if(prompt != NULL){
 
579
    ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
 
580
  } else {
 
581
    char *made_prompt = makeprompt();
 
582
    ret = asprintf(&prompt_arg, "--prompt=%s", made_prompt);
 
583
    free(made_prompt);
 
584
  }
363
585
  if(ret == -1){
364
 
    error(EX_OSERR, errno, "asprintf");
 
586
    error_plus(EX_OSERR, errno, "asprintf");
365
587
  }
366
588
  
367
589
  /* plymouth ask-for-password --prompt="$prompt" */
 
590
  if(debug){
 
591
    fprintf_plus(stderr, "Prompting for password via Plymouth\n");
 
592
  }
368
593
  bret = exec_and_wait(&plymouth_command_pid,
369
594
                       plymouth_path, (const char *[])
370
595
                       { plymouth_path, "ask-for-password",
380
605
  }
381
606
  kill_and_wait(plymouth_command_pid);
382
607
  
383
 
  const char **plymouthd_argv;
 
608
  char **plymouthd_argv = NULL;
384
609
  pid_t pid = get_pid();
385
610
  if(pid == 0){
386
 
    error(0, 0, "plymouthd pid not found");
387
 
    plymouthd_argv = plymouthd_default_argv;
 
611
    error_plus(0, 0, "plymouthd pid not found");
388
612
  } else {
389
613
    plymouthd_argv = getargv(pid);
390
614
  }
393
617
                       { plymouth_path, "quit", NULL },
394
618
                       false, false);
395
619
  if(not bret){
 
620
    if(plymouthd_argv != NULL){
 
621
      free(*plymouthd_argv);
 
622
      free(plymouthd_argv);
 
623
    }
396
624
    exit(EXIT_FAILURE);
397
625
  }
398
 
  bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,
 
626
  bret = exec_and_wait(NULL, plymouthd_path,
 
627
                       (plymouthd_argv != NULL)
 
628
                       ? (const char * const *)plymouthd_argv
 
629
                       : plymouthd_default_argv,
399
630
                       false, true);
 
631
  if(plymouthd_argv != NULL){
 
632
    free(*plymouthd_argv);
 
633
    free(plymouthd_argv);
 
634
  }
400
635
  if(not bret){
401
636
    exit(EXIT_FAILURE);
402
637
  }