/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 at recompile
  • Date: 2020-04-05 21:30:59 UTC
  • Revision ID: teddy@recompile.se-20200405213059-fb2a61ckqynrmatk
Fix file descriptor leak in mandos-client

When the local network has Mandos servers announcing themselves using
real, globally reachable, IPv6 addresses (i.e. not link-local
addresses), but there is no router on the local network providing IPv6
RA (Router Advertisement) packets, the client cannot reach the server
by normal means, since the client only has a link-local IPv6 address,
and has no usable route to reach the server's global IPv6 address.
(This is not a common situation, and usually only happens when the
router itself reboots and runs a Mandos client, since it cannot then
give RA packets to itself.)  The client code has a solution for
this, which consists of adding a temporary local route to reach the
address of the server during communication, and removing this
temporary route afterwards.

This solution with a temporary route works, but has a file descriptor
leak; it leaks one file descriptor for each addition and for each
removal of a route.  If one server requiring an added route is present
on the network, but no servers gives a password, making the client
retry after the default ten seconds, and we furthermore assume a
default 1024 open files limit, the client runs out of file descriptors
after about 90 minutes, after which time the client process will be
useless and fail to retrieve any passwords, necessitating manual
password entry via the keyboard.

Fix this by eliminating the file descriptor leak in the client.

* plugins.d/mandos-client.c (add_delete_local_route): Do
  close(devnull) also in parent process, also if fork() fails, and on
  any failure in child process.

Show diffs side-by-side

added added

removed removed

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