/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:
2
2
/*
3
3
 * Plymouth - Read a password from Plymouth and output it
4
4
 * 
5
 
 * Copyright © 2010-2016 Teddy Hogeborn
6
 
 * Copyright © 2010-2016 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,
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");
181
203
    }
182
204
    char **tmp;
183
205
    int i = 0;
184
 
    for (; argv[i]!=NULL; i++){
 
206
    for (; argv[i] != NULL; i++){
185
207
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 2));
186
208
      if(tmp == NULL){
187
209
        error_plus(0, errno, "realloc");
206
228
          and ((not interrupted_by_signal)
207
229
               or (not interruptable)));
208
230
  if(interrupted_by_signal and interruptable){
 
231
    if(debug){
 
232
      fprintf_plus(stderr, "Interrupted by signal\n");
 
233
    }
209
234
    return false;
210
235
  }
211
236
  if(ret == -1){
212
237
    error_plus(0, errno, "waitpid");
213
238
    return false;
214
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
  }
215
249
  if(WIFEXITED(status) and (WEXITSTATUS(status) == 0)){
216
250
    return true;
217
251
  }
281
315
  }
282
316
  /* Try the old pid file location */
283
317
  if(proc_id == 0){
284
 
    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");
285
330
    if(pidfile != NULL){
286
331
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
287
332
      if(ret != 1){
298
343
      error_plus(0, errno, "scandir");
299
344
    }
300
345
    if(ret > 0){
301
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &proc_id);
302
 
      if(ret < 0){
303
 
        error_plus(0, errno, "sscanf");
 
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]);
304
354
      }
305
355
    }
306
356
    /* scandir might preallocate for this variable (man page unclear).
316
366
  return 0;
317
367
}
318
368
 
319
 
const char * const * getargv(pid_t pid){
 
369
char **getargv(pid_t pid){
320
370
  int cl_fd;
321
371
  char *cmdline_filename;
322
372
  ssize_t sret;
383
433
    return NULL;
384
434
  }
385
435
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
386
 
  return (const char * const *)argv;
 
436
  return argv;
387
437
}
388
438
 
389
439
int main(__attribute__((unused))int argc,
390
440
         __attribute__((unused))char **argv){
391
 
  char *prompt;
 
441
  char *prompt = NULL;
392
442
  char *prompt_arg;
393
443
  pid_t plymouth_command_pid;
394
444
  int ret;
395
445
  bool bret;
396
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
  
397
495
  /* test -x /bin/plymouth */
398
496
  ret = access(plymouth_path, X_OK);
399
497
  if(ret == -1){
400
498
    /* Plymouth is probably not installed.  Don't print an error
401
499
       message, just exit. */
 
500
    if(debug){
 
501
      fprintf_plus(stderr, "Plymouth (%s) not found\n",
 
502
                   plymouth_path);
 
503
    }
402
504
    exit(EX_UNAVAILABLE);
403
505
  }
404
506
  
438
540
    }
439
541
    /* Plymouth is probably not running.  Don't print an error
440
542
       message, just exit. */
 
543
    if(debug){
 
544
      fprintf_plus(stderr, "Plymouth not running\n");
 
545
    }
441
546
    exit(EX_UNAVAILABLE);
442
547
  }
443
548
  
444
 
  prompt = makeprompt();
445
 
  ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
446
 
  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
  }
447
556
  if(ret == -1){
448
557
    error_plus(EX_OSERR, errno, "asprintf");
449
558
  }
450
559
  
451
560
  /* plymouth ask-for-password --prompt="$prompt" */
 
561
  if(debug){
 
562
    fprintf_plus(stderr, "Prompting for password via Plymouth\n");
 
563
  }
452
564
  bret = exec_and_wait(&plymouth_command_pid,
453
565
                       plymouth_path, (const char *[])
454
566
                       { plymouth_path, "ask-for-password",
464
576
  }
465
577
  kill_and_wait(plymouth_command_pid);
466
578
  
467
 
  const char * const *plymouthd_argv;
 
579
  char **plymouthd_argv = NULL;
468
580
  pid_t pid = get_pid();
469
581
  if(pid == 0){
470
582
    error_plus(0, 0, "plymouthd pid not found");
471
 
    plymouthd_argv = plymouthd_default_argv;
472
583
  } else {
473
584
    plymouthd_argv = getargv(pid);
474
585
  }
477
588
                       { plymouth_path, "quit", NULL },
478
589
                       false, false);
479
590
  if(not bret){
 
591
    if(plymouthd_argv != NULL){
 
592
      free(*plymouthd_argv);
 
593
      free(plymouthd_argv);
 
594
    }
480
595
    exit(EXIT_FAILURE);
481
596
  }
482
 
  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,
483
601
                       false, true);
 
602
  if(plymouthd_argv != NULL){
 
603
    free(*plymouthd_argv);
 
604
    free(plymouthd_argv);
 
605
  }
484
606
  if(not bret){
485
607
    exit(EXIT_FAILURE);
486
608
  }