/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-08-02 22:16:53 UTC
  • mto: This revision was merged to the branch mainline in revision 386.
  • Revision ID: teddy@recompile.se-20190802221653-ic1iko9hbefzwsk7
Fix bug in server Debian package: Fails to start on first install

There has been a very long-standing bug where installation of the
server (the "mandos" Debian package) would fail to start the server
properly right after installation.  It would work on manual (re)start
after installation, or after reboot, and even after package purge and
reinstall, it would then work the first time.  The problem, it turns
out, is when the new "_mandos" user (and corresponding group) is
created, the D-Bus server is not reloaded, and is therefore not aware
of that user, and does not recognize the user and group name in the
/etc/dbus-1/system.d/mandos.conf file.  The Mandos server, when it
tries to start and access the D-Bus, is then not permitted to connect
to its D-Bus bus name, and disables D-Bus use as a fallback measure;
i.e. the server works, but it is not controllable via D-Bus commands
(via mandos-ctl or mandos-monitor).  The next time the D-Bus daemon is
reloaded for any reason, the new user & group would become visible to
the D-Bus daemon and after that, any restart of the Mandos server
would succeed and it would bind to its D-Bus name properly, and
thereby be visible and controllable by mandos-ctl & mandos-monitor.
This was mostly invisible when using sysvinit, but systemd makes the
problem visible since the systemd service file for the Mandos server
is configured to not consider the Mandos server "started" until the
D-Bus name has been bound; this makes the starting of the service wait
for 90 seconds and then fail with a timeout error.

Fixing this should also make the Debian CI autopkgtest tests work.

* debian/mandos.postinst (configure): After creating (or renaming)
                                      user & group, reload D-Bus
                                      daemon (if present).

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/plymouth.c
2
2
/*
3
3
 * Plymouth - Read a password from Plymouth and output it
4
4
 * 
5
 
 * Copyright © 2010-2013 Teddy Hogeborn
6
 
 * Copyright © 2010-2013 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
 
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
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
52
53
#include <errno.h>              /* TEMP_FAILURE_RETRY */
53
54
#include <argz.h>               /* argz_count(), argz_extract() */
54
55
#include <stdarg.h>             /* va_list, va_start(), ... */
 
56
#include <argp.h>
55
57
 
56
58
sig_atomic_t interrupted_by_signal = 0;
 
59
const char *argp_program_version = "plymouth " VERSION;
 
60
const char *argp_program_bug_address = "<mandos@recompile.se>";
57
61
 
58
62
/* Used by Ubuntu 11.04 (Natty Narwahl) */
59
 
const char plymouth_old_pid[] = "/dev/.initramfs/plymouth.pid";
 
63
const char plymouth_old_old_pid[] = "/dev/.initramfs/plymouth.pid";
60
64
/* Used by Ubuntu 11.10 (Oneiric Ocelot) */
61
 
const char plymouth_pid[] = "/run/initramfs/plymouth.pid";
 
65
const char plymouth_old_pid[] = "/run/initramfs/plymouth.pid";
 
66
/* Used by Debian 9 (stretch) */
 
67
const char plymouth_pid[] = "/run/plymouth/pid";
62
68
 
63
69
const char plymouth_path[] = "/bin/plymouth";
64
70
const char plymouthd_path[] = "/sbin/plymouthd";
66
72
                                        "--mode=boot",
67
73
                                        "--attach-to-session",
68
74
                                        NULL };
 
75
bool debug = false;
69
76
 
70
77
static void termination_handler(__attribute__((unused))int signum){
71
78
  if(interrupted_by_signal){
74
81
  interrupted_by_signal = 1;
75
82
}
76
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
 
77
92
/* Function to use when printing errors */
78
93
__attribute__((format (gnu_printf, 3, 4)))
79
94
void error_plus(int status, int errnum, const char *formatstring,
84
99
  
85
100
  va_start(ap, formatstring);
86
101
  ret = vasprintf(&text, formatstring, ap);
87
 
  if (ret == -1){
 
102
  if(ret == -1){
88
103
    fprintf(stderr, "Mandos plugin %s: ",
89
104
            program_invocation_short_name);
90
105
    vfprintf(stderr, formatstring, ap);
156
171
 
157
172
__attribute__((nonnull (2, 3)))
158
173
bool exec_and_wait(pid_t *pid_return, const char *path,
159
 
                   const char * const *argv, bool interruptable,
 
174
                   const char * const * const argv, bool interruptable,
160
175
                   bool daemonize){
161
176
  int status;
162
177
  int ret;
163
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
 
164
186
  pid = fork();
165
187
  if(pid == -1){
166
188
    error_plus(0, errno, "fork");
174
196
      }
175
197
    }
176
198
    
177
 
    char **new_argv = NULL;
 
199
    char **new_argv = malloc(sizeof(const char *));
 
200
    if(new_argv == NULL){
 
201
      error_plus(0, errno, "malloc");
 
202
      _exit(EX_OSERR);
 
203
    }
178
204
    char **tmp;
179
205
    int i = 0;
180
 
    for (; argv[i]!=NULL; i++){
181
 
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
182
 
      if (tmp == NULL){
 
206
    for (; argv[i] != NULL; i++){
 
207
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 2));
 
208
      if(tmp == NULL){
183
209
        error_plus(0, errno, "realloc");
184
210
        free(new_argv);
185
211
        _exit(EX_OSERR);
202
228
          and ((not interrupted_by_signal)
203
229
               or (not interruptable)));
204
230
  if(interrupted_by_signal and interruptable){
 
231
    if(debug){
 
232
      fprintf_plus(stderr, "Interrupted by signal\n");
 
233
    }
205
234
    return false;
206
235
  }
207
236
  if(ret == -1){
208
237
    error_plus(0, errno, "waitpid");
209
238
    return false;
210
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
  }
211
249
  if(WIFEXITED(status) and (WEXITSTATUS(status) == 0)){
212
250
    return true;
213
251
  }
277
315
  }
278
316
  /* Try the old pid file location */
279
317
  if(proc_id == 0){
280
 
    pidfile = fopen(plymouth_pid, "r");
 
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");
281
330
    if(pidfile != NULL){
282
331
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
283
332
      if(ret != 1){
290
339
  if(proc_id == 0){
291
340
    struct dirent **direntries = NULL;
292
341
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
293
 
    if (ret == -1){
 
342
    if(ret == -1){
294
343
      error_plus(0, errno, "scandir");
295
344
    }
296
 
    if (ret > 0){
297
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &proc_id);
298
 
      if (ret < 0){
299
 
        error_plus(0, errno, "sscanf");
 
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]);
300
354
      }
301
355
    }
302
356
    /* scandir might preallocate for this variable (man page unclear).
312
366
  return 0;
313
367
}
314
368
 
315
 
const char * const * getargv(pid_t pid){
 
369
char **getargv(pid_t pid){
316
370
  int cl_fd;
317
371
  char *cmdline_filename;
318
372
  ssize_t sret;
379
433
    return NULL;
380
434
  }
381
435
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
382
 
  return (const char * const *)argv;
 
436
  return argv;
383
437
}
384
438
 
385
439
int main(__attribute__((unused))int argc,
386
440
         __attribute__((unused))char **argv){
387
 
  char *prompt;
 
441
  char *prompt = NULL;
388
442
  char *prompt_arg;
389
443
  pid_t plymouth_command_pid;
390
444
  int ret;
391
445
  bool bret;
392
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
  
393
495
  /* test -x /bin/plymouth */
394
496
  ret = access(plymouth_path, X_OK);
395
497
  if(ret == -1){
396
498
    /* Plymouth is probably not installed.  Don't print an error
397
499
       message, just exit. */
 
500
    if(debug){
 
501
      fprintf_plus(stderr, "Plymouth (%s) not found\n",
 
502
                   plymouth_path);
 
503
    }
398
504
    exit(EX_UNAVAILABLE);
399
505
  }
400
506
  
434
540
    }
435
541
    /* Plymouth is probably not running.  Don't print an error
436
542
       message, just exit. */
 
543
    if(debug){
 
544
      fprintf_plus(stderr, "Plymouth not running\n");
 
545
    }
437
546
    exit(EX_UNAVAILABLE);
438
547
  }
439
548
  
440
 
  prompt = makeprompt();
441
 
  ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
442
 
  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
  }
443
556
  if(ret == -1){
444
557
    error_plus(EX_OSERR, errno, "asprintf");
445
558
  }
446
559
  
447
560
  /* plymouth ask-for-password --prompt="$prompt" */
 
561
  if(debug){
 
562
    fprintf_plus(stderr, "Prompting for password via Plymouth\n");
 
563
  }
448
564
  bret = exec_and_wait(&plymouth_command_pid,
449
565
                       plymouth_path, (const char *[])
450
566
                       { plymouth_path, "ask-for-password",
460
576
  }
461
577
  kill_and_wait(plymouth_command_pid);
462
578
  
463
 
  const char * const *plymouthd_argv;
 
579
  char **plymouthd_argv = NULL;
464
580
  pid_t pid = get_pid();
465
581
  if(pid == 0){
466
582
    error_plus(0, 0, "plymouthd pid not found");
467
 
    plymouthd_argv = plymouthd_default_argv;
468
583
  } else {
469
584
    plymouthd_argv = getargv(pid);
470
585
  }
473
588
                       { plymouth_path, "quit", NULL },
474
589
                       false, false);
475
590
  if(not bret){
 
591
    if(plymouthd_argv != NULL){
 
592
      free(*plymouthd_argv);
 
593
      free(plymouthd_argv);
 
594
    }
476
595
    exit(EXIT_FAILURE);
477
596
  }
478
 
  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,
479
601
                       false, true);
 
602
  if(plymouthd_argv != NULL){
 
603
    free(*plymouthd_argv);
 
604
    free(plymouthd_argv);
 
605
  }
480
606
  if(not bret){
481
607
    exit(EXIT_FAILURE);
482
608
  }