/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 Hogeborn
  • Date: 2018-08-15 09:26:02 UTC
  • Revision ID: teddy@recompile.se-20180815092602-xoyb5s6gf8376i7u
mandos-client: Set system clock if necessary

* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
  clock is not set, or set to january 1970, set the system clock to
  the more plausible value that is the mtime of the key file.  This is
  required by GnuPG to be able to import the keys.  (We can't pass the
  --ignore-time-conflict or the --ignore-valid-from options though
  GPGME.)

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-2011 Teddy Hogeborn
6
 
 * Copyright © 2010-2011 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-2018 Teddy Hogeborn
 
6
 * Copyright © 2010-2018 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
 */
56
57
sig_atomic_t interrupted_by_signal = 0;
57
58
 
58
59
/* Used by Ubuntu 11.04 (Natty Narwahl) */
59
 
const char plymouth_old_pid[] = "/dev/.initramfs/plymouth.pid";
 
60
const char plymouth_old_old_pid[] = "/dev/.initramfs/plymouth.pid";
60
61
/* Used by Ubuntu 11.10 (Oneiric Ocelot) */
61
 
const char plymouth_pid[] = "/run/initramfs/plymouth.pid";
 
62
const char plymouth_old_pid[] = "/run/initramfs/plymouth.pid";
 
63
/* Used by Debian 9 (stretch) */
 
64
const char plymouth_pid[] = "/run/plymouth/pid";
62
65
 
63
66
const char plymouth_path[] = "/bin/plymouth";
64
67
const char plymouthd_path[] = "/sbin/plymouthd";
75
78
}
76
79
 
77
80
/* Function to use when printing errors */
 
81
__attribute__((format (gnu_printf, 3, 4)))
78
82
void error_plus(int status, int errnum, const char *formatstring,
79
83
                ...){
80
84
  va_list ap;
83
87
  
84
88
  va_start(ap, formatstring);
85
89
  ret = vasprintf(&text, formatstring, ap);
86
 
  if (ret == -1){
 
90
  if(ret == -1){
87
91
    fprintf(stderr, "Mandos plugin %s: ",
88
92
            program_invocation_short_name);
89
93
    vfprintf(stderr, formatstring, ap);
153
157
  return true;
154
158
}
155
159
 
 
160
__attribute__((nonnull (2, 3)))
156
161
bool exec_and_wait(pid_t *pid_return, const char *path,
157
 
                   const char **argv, bool interruptable,
 
162
                   const char * const *argv, bool interruptable,
158
163
                   bool daemonize){
159
164
  int status;
160
165
  int ret;
172
177
      }
173
178
    }
174
179
    
175
 
    char **new_argv = NULL;
 
180
    char **new_argv = malloc(sizeof(const char *));
 
181
    if(new_argv == NULL){
 
182
      error_plus(0, errno, "malloc");
 
183
      _exit(EX_OSERR);
 
184
    }
176
185
    char **tmp;
177
186
    int i = 0;
178
 
    for (; argv[i]!=NULL; i++){
179
 
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
180
 
      if (tmp == NULL){
 
187
    for (; argv[i] != NULL; i++){
 
188
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 2));
 
189
      if(tmp == NULL){
181
190
        error_plus(0, errno, "realloc");
182
191
        free(new_argv);
183
192
        _exit(EX_OSERR);
212
221
  return false;
213
222
}
214
223
 
 
224
__attribute__((nonnull))
215
225
int is_plymouth(const struct dirent *proc_entry){
216
226
  int ret;
217
227
  {
218
 
    uintmax_t maxvalue;
 
228
    uintmax_t proc_id;
219
229
    char *tmp;
220
230
    errno = 0;
221
 
    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
231
    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
222
232
 
223
233
    if(errno != 0 or *tmp != '\0'
224
 
       or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
234
       or proc_id != (uintmax_t)((pid_t)proc_id)){
225
235
      return 0;
226
236
    }
227
237
  }
262
272
 
263
273
pid_t get_pid(void){
264
274
  int ret;
265
 
  uintmax_t maxvalue = 0;
 
275
  uintmax_t proc_id = 0;
266
276
  FILE *pidfile = fopen(plymouth_pid, "r");
267
277
  /* Try the new pid file location */
268
278
  if(pidfile != NULL){
269
 
    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
279
    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
270
280
    if(ret != 1){
271
 
      maxvalue = 0;
 
281
      proc_id = 0;
272
282
    }
273
283
    fclose(pidfile);
274
284
  }
275
285
  /* Try the old pid file location */
276
 
  if(maxvalue == 0){
277
 
    pidfile = fopen(plymouth_pid, "r");
278
 
    if(pidfile != NULL){
279
 
      ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
280
 
      if(ret != 1){
281
 
        maxvalue = 0;
 
286
  if(proc_id == 0){
 
287
    pidfile = fopen(plymouth_old_pid, "r");
 
288
    if(pidfile != NULL){
 
289
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
290
      if(ret != 1){
 
291
        proc_id = 0;
 
292
      }
 
293
      fclose(pidfile);
 
294
    }
 
295
  }
 
296
  /* Try the old old pid file location */
 
297
  if(proc_id == 0){
 
298
    pidfile = fopen(plymouth_old_old_pid, "r");
 
299
    if(pidfile != NULL){
 
300
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
301
      if(ret != 1){
 
302
        proc_id = 0;
282
303
      }
283
304
      fclose(pidfile);
284
305
    }
285
306
  }
286
307
  /* Look for a plymouth process */
287
 
  if(maxvalue == 0){
 
308
  if(proc_id == 0){
288
309
    struct dirent **direntries = NULL;
289
310
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
290
 
    if (ret == -1){
 
311
    if(ret == -1){
291
312
      error_plus(0, errno, "scandir");
292
313
    }
293
 
    if (ret > 0){
294
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
295
 
      if (ret < 0){
296
 
        error_plus(0, errno, "sscanf");
 
314
    if(ret > 0){
 
315
      for(int i = ret-1; i >= 0; i--){
 
316
        if(proc_id == 0){
 
317
          ret = sscanf(direntries[i]->d_name, "%" SCNuMAX, &proc_id);
 
318
          if(ret < 0){
 
319
            error_plus(0, errno, "sscanf");
 
320
          }
 
321
        }
 
322
        free(direntries[i]);
297
323
      }
298
324
    }
299
325
    /* scandir might preallocate for this variable (man page unclear).
301
327
    free(direntries);
302
328
  }
303
329
  pid_t pid;
304
 
  pid = (pid_t)maxvalue;
305
 
  if((uintmax_t)pid == maxvalue){
 
330
  pid = (pid_t)proc_id;
 
331
  if((uintmax_t)pid == proc_id){
306
332
    return pid;
307
333
  }
308
334
  
309
335
  return 0;
310
336
}
311
337
 
312
 
const char **getargv(pid_t pid){
 
338
char **getargv(pid_t pid){
313
339
  int cl_fd;
314
340
  char *cmdline_filename;
315
341
  ssize_t sret;
376
402
    return NULL;
377
403
  }
378
404
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
379
 
  return (const char **)argv;
 
405
  return argv;
380
406
}
381
407
 
382
408
int main(__attribute__((unused))int argc,
457
483
  }
458
484
  kill_and_wait(plymouth_command_pid);
459
485
  
460
 
  const char **plymouthd_argv;
 
486
  char **plymouthd_argv = NULL;
461
487
  pid_t pid = get_pid();
462
488
  if(pid == 0){
463
489
    error_plus(0, 0, "plymouthd pid not found");
464
 
    plymouthd_argv = plymouthd_default_argv;
465
490
  } else {
466
491
    plymouthd_argv = getargv(pid);
467
492
  }
470
495
                       { plymouth_path, "quit", NULL },
471
496
                       false, false);
472
497
  if(not bret){
 
498
    if(plymouthd_argv != NULL){
 
499
      free(*plymouthd_argv);
 
500
      free(plymouthd_argv);
 
501
    }
473
502
    exit(EXIT_FAILURE);
474
503
  }
475
 
  bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,
 
504
  bret = exec_and_wait(NULL, plymouthd_path,
 
505
                       (plymouthd_argv != NULL)
 
506
                       ? (const char * const *)plymouthd_argv
 
507
                       : plymouthd_default_argv,
476
508
                       false, true);
 
509
  if(plymouthd_argv != NULL){
 
510
    free(*plymouthd_argv);
 
511
    free(plymouthd_argv);
 
512
  }
477
513
  if(not bret){
478
514
    exit(EXIT_FAILURE);
479
515
  }