/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: 2019-07-29 16:35:53 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match

Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.

* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
  Remove "--verbose" option, since the manual does not have it as the
  first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
  which test function they correspond to.  Also remove unnecessary
  quotes from option arguments in fourth example, and clarify language
  slightly in fifth example.

Show diffs side-by-side

added added

removed removed

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