/mandos/release

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

« back to all changes in this revision

Viewing changes to plugins.d/plymouth.c

  • Committer: Teddy Hogeborn
  • Date: 2024-09-09 04:24:39 UTC
  • mto: This revision was merged to the branch mainline in revision 410.
  • Revision ID: teddy@recompile.se-20240909042439-j85mr20uli2hnyis
Eliminate compiler warnings

Many programs use nested functions, which now result in a linker
warning about executable stack.  Hide this warning.  Also, rewrite a
loop in the plymouth plugin to avoid warning about signed overflow.
This change also makes the plugin pick the alphabetically first
process entry instead of the last, in case many plymouth processes are
found (which should be unlikely).

* Makefile (plugin-runner, dracut-module/password-agent,
  plugins.d/password-prompt, plugins.d/mandos-client,
  plugins.d/plymouth): New target; set LDFLAGS to add "-Xlinker
  --no-warn-execstack".
* plugins.d/plymouth.c (get_pid): When no pid files are found, and we
  are looking through the process list, go though it from the start
  instead of from the end, i.e. in normal alphabetical order and not
  in reverse order.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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-2022 Teddy Hogeborn
 
6
 * Copyright © 2010-2022 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
      const int num_entries = ret;
 
376
      for(int i = 0; i < num_entries; i++){
 
377
        if(proc_id == 0){
 
378
          ret = sscanf(direntries[i]->d_name, "%" SCNuMAX, &proc_id);
 
379
          if(ret < 0){
 
380
            error_plus(0, errno, "sscanf");
 
381
          }
 
382
        }
 
383
        free(direntries[i]);
 
384
      }
 
385
    }
 
386
    /* scandir might preallocate for this variable (man page unclear).
 
387
       even if ret == 0, therefore we need to free it. */
 
388
    free(direntries);
225
389
  }
226
390
  pid_t pid;
227
 
  pid = (pid_t)maxvalue;
228
 
  if((uintmax_t)pid == maxvalue){
 
391
  pid = (pid_t)proc_id;
 
392
  if((uintmax_t)pid == proc_id){
229
393
    return pid;
230
394
  }
231
395
  
232
396
  return 0;
233
397
}
234
398
 
235
 
const char **getargv(pid_t pid){
 
399
char **getargv(pid_t pid){
236
400
  int cl_fd;
237
401
  char *cmdline_filename;
238
402
  ssize_t sret;
241
405
  ret = asprintf(&cmdline_filename, "/proc/%" PRIuMAX "/cmdline",
242
406
                 (uintmax_t)pid);
243
407
  if(ret == -1){
244
 
    error(0, errno, "asprintf");
 
408
    error_plus(0, errno, "asprintf");
245
409
    return NULL;
246
410
  }
247
411
  
249
413
  cl_fd = open(cmdline_filename, O_RDONLY);
250
414
  free(cmdline_filename);
251
415
  if(cl_fd == -1){
252
 
    error(0, errno, "open");
 
416
    error_plus(0, errno, "open");
253
417
    return NULL;
254
418
  }
255
419
  
263
427
    if(cmdline_len + blocksize > cmdline_allocated){
264
428
      tmp = realloc(cmdline, cmdline_allocated + blocksize);
265
429
      if(tmp == NULL){
266
 
        error(0, errno, "realloc");
 
430
        error_plus(0, errno, "realloc");
267
431
        free(cmdline);
268
432
        close(cl_fd);
269
433
        return NULL;
276
440
    sret = read(cl_fd, cmdline + cmdline_len,
277
441
                cmdline_allocated - cmdline_len);
278
442
    if(sret == -1){
279
 
      error(0, errno, "read");
 
443
      error_plus(0, errno, "read");
280
444
      free(cmdline);
281
445
      close(cl_fd);
282
446
      return NULL;
285
449
  } while(sret != 0);
286
450
  ret = close(cl_fd);
287
451
  if(ret == -1){
288
 
    error(0, errno, "close");
 
452
    error_plus(0, errno, "close");
289
453
    free(cmdline);
290
454
    return NULL;
291
455
  }
294
458
  char **argv = malloc((argz_count(cmdline, cmdline_len) + 1)
295
459
                       * sizeof(char *)); /* Get number of args */
296
460
  if(argv == NULL){
297
 
    error(0, errno, "argv = malloc()");
 
461
    error_plus(0, errno, "argv = malloc()");
298
462
    free(cmdline);
299
463
    return NULL;
300
464
  }
301
465
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
302
 
  return (const char **)argv;
 
466
  return argv;
303
467
}
304
468
 
305
469
int main(__attribute__((unused))int argc,
306
470
         __attribute__((unused))char **argv){
307
 
  char *prompt;
 
471
  char *prompt = NULL;
308
472
  char *prompt_arg;
309
473
  pid_t plymouth_command_pid;
310
474
  int ret;
311
475
  bool bret;
312
476
 
 
477
  {
 
478
    struct argp_option options[] = {
 
479
      { .name = "prompt", .key = 128, .arg = "PROMPT",
 
480
        .doc = "The prompt to show" },
 
481
      { .name = "debug", .key = 129,
 
482
        .doc = "Debug mode" },
 
483
      { .name = NULL }
 
484
    };
 
485
    
 
486
    __attribute__((nonnull(3)))
 
487
    error_t parse_opt (int key, char *arg, __attribute__((unused))
 
488
                       struct argp_state *state){
 
489
      errno = 0;
 
490
      switch (key){
 
491
      case 128:                 /* --prompt */
 
492
        prompt = arg;
 
493
        if(debug){
 
494
          fprintf_plus(stderr, "Custom prompt \"%s\"\n", prompt);
 
495
        }
 
496
        break;
 
497
      case 129:                 /* --debug */
 
498
        debug = true;
 
499
        break;
 
500
      default:
 
501
        return ARGP_ERR_UNKNOWN;
 
502
      }
 
503
      return errno;
 
504
    }
 
505
    
 
506
    struct argp argp = { .options = options, .parser = parse_opt,
 
507
                         .args_doc = "",
 
508
                         .doc = "Mandos plymouth -- Read and"
 
509
                         " output a password" };
 
510
    ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, NULL);
 
511
    switch(ret){
 
512
    case 0:
 
513
      break;
 
514
    case ENOMEM:
 
515
    default:
 
516
      errno = ret;
 
517
      error_plus(0, errno, "argp_parse");
 
518
      return EX_OSERR;
 
519
    case EINVAL:
 
520
      error_plus(0, errno, "argp_parse");
 
521
      return EX_USAGE;
 
522
    }
 
523
  }
 
524
  
313
525
  /* test -x /bin/plymouth */
314
526
  ret = access(plymouth_path, X_OK);
315
527
  if(ret == -1){
316
528
    /* Plymouth is probably not installed.  Don't print an error
317
529
       message, just exit. */
 
530
    if(debug){
 
531
      fprintf_plus(stderr, "Plymouth (%s) not found\n",
 
532
                   plymouth_path);
 
533
    }
318
534
    exit(EX_UNAVAILABLE);
319
535
  }
320
536
  
327
543
        *sig != 0; sig++){
328
544
      ret = sigaddset(&new_action.sa_mask, *sig);
329
545
      if(ret == -1){
330
 
        error(EX_OSERR, errno, "sigaddset");
 
546
        error_plus(EX_OSERR, errno, "sigaddset");
331
547
      }
332
548
      ret = sigaction(*sig, NULL, &old_action);
333
549
      if(ret == -1){
334
 
        error(EX_OSERR, errno, "sigaction");
 
550
        error_plus(EX_OSERR, errno, "sigaction");
335
551
      }
336
552
      if(old_action.sa_handler != SIG_IGN){
337
553
        ret = sigaction(*sig, &new_action, NULL);
338
554
        if(ret == -1){
339
 
          error(EX_OSERR, errno, "sigaction");
 
555
          error_plus(EX_OSERR, errno, "sigaction");
340
556
        }
341
557
      }
342
558
    }
354
570
    }
355
571
    /* Plymouth is probably not running.  Don't print an error
356
572
       message, just exit. */
 
573
    if(debug){
 
574
      fprintf_plus(stderr, "Plymouth not running\n");
 
575
    }
357
576
    exit(EX_UNAVAILABLE);
358
577
  }
359
578
  
360
 
  prompt = makeprompt();
361
 
  ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
362
 
  free(prompt);
 
579
  if(prompt != NULL){
 
580
    ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
 
581
  } else {
 
582
    char *made_prompt = makeprompt();
 
583
    ret = asprintf(&prompt_arg, "--prompt=%s", made_prompt);
 
584
    free(made_prompt);
 
585
  }
363
586
  if(ret == -1){
364
 
    error(EX_OSERR, errno, "asprintf");
 
587
    error_plus(EX_OSERR, errno, "asprintf");
365
588
  }
366
589
  
367
590
  /* plymouth ask-for-password --prompt="$prompt" */
 
591
  if(debug){
 
592
    fprintf_plus(stderr, "Prompting for password via Plymouth\n");
 
593
  }
368
594
  bret = exec_and_wait(&plymouth_command_pid,
369
595
                       plymouth_path, (const char *[])
370
596
                       { plymouth_path, "ask-for-password",
380
606
  }
381
607
  kill_and_wait(plymouth_command_pid);
382
608
  
383
 
  const char **plymouthd_argv;
 
609
  char **plymouthd_argv = NULL;
384
610
  pid_t pid = get_pid();
385
611
  if(pid == 0){
386
 
    error(0, 0, "plymouthd pid not found");
387
 
    plymouthd_argv = plymouthd_default_argv;
 
612
    error_plus(0, 0, "plymouthd pid not found");
388
613
  } else {
389
614
    plymouthd_argv = getargv(pid);
390
615
  }
393
618
                       { plymouth_path, "quit", NULL },
394
619
                       false, false);
395
620
  if(not bret){
 
621
    if(plymouthd_argv != NULL){
 
622
      free(*plymouthd_argv);
 
623
      free(plymouthd_argv);
 
624
    }
396
625
    exit(EXIT_FAILURE);
397
626
  }
398
 
  bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,
 
627
  bret = exec_and_wait(NULL, plymouthd_path,
 
628
                       (plymouthd_argv != NULL)
 
629
                       ? (const char * const *)plymouthd_argv
 
630
                       : plymouthd_default_argv,
399
631
                       false, true);
 
632
  if(plymouthd_argv != NULL){
 
633
    free(*plymouthd_argv);
 
634
    free(plymouthd_argv);
 
635
  }
400
636
  if(not bret){
401
637
    exit(EXIT_FAILURE);
402
638
  }