/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
http://bugs.debian.org/894495
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:
plugins.d/plymouth.c
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";
84
87
  
85
88
  va_start(ap, formatstring);
86
89
  ret = vasprintf(&text, formatstring, ap);
87
 
  if (ret == -1){
 
90
  if(ret == -1){
88
91
    fprintf(stderr, "Mandos plugin %s: ",
89
92
            program_invocation_short_name);
90
93
    vfprintf(stderr, formatstring, ap);
154
157
  return true;
155
158
}
156
159
 
 
160
__attribute__((nonnull (2, 3)))
157
161
bool exec_and_wait(pid_t *pid_return, const char *path,
158
 
                   const char **argv, bool interruptable,
 
162
                   const char * const *argv, bool interruptable,
159
163
                   bool daemonize){
160
164
  int status;
161
165
  int ret;
173
177
      }
174
178
    }
175
179
    
176
 
    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
    }
177
185
    char **tmp;
178
186
    int i = 0;
179
 
    for (; argv[i]!=NULL; i++){
180
 
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
181
 
      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){
182
190
        error_plus(0, errno, "realloc");
183
191
        free(new_argv);
184
192
        _exit(EX_OSERR);
213
221
  return false;
214
222
}
215
223
 
 
224
__attribute__((nonnull))
216
225
int is_plymouth(const struct dirent *proc_entry){
217
226
  int ret;
218
227
  {
219
 
    uintmax_t maxvalue;
 
228
    uintmax_t proc_id;
220
229
    char *tmp;
221
230
    errno = 0;
222
 
    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
231
    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
223
232
 
224
233
    if(errno != 0 or *tmp != '\0'
225
 
       or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
234
       or proc_id != (uintmax_t)((pid_t)proc_id)){
226
235
      return 0;
227
236
    }
228
237
  }
263
272
 
264
273
pid_t get_pid(void){
265
274
  int ret;
266
 
  uintmax_t maxvalue = 0;
 
275
  uintmax_t proc_id = 0;
267
276
  FILE *pidfile = fopen(plymouth_pid, "r");
268
277
  /* Try the new pid file location */
269
278
  if(pidfile != NULL){
270
 
    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
279
    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
271
280
    if(ret != 1){
272
 
      maxvalue = 0;
 
281
      proc_id = 0;
273
282
    }
274
283
    fclose(pidfile);
275
284
  }
276
285
  /* Try the old pid file location */
277
 
  if(maxvalue == 0){
278
 
    pidfile = fopen(plymouth_pid, "r");
279
 
    if(pidfile != NULL){
280
 
      ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
281
 
      if(ret != 1){
282
 
        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;
283
303
      }
284
304
      fclose(pidfile);
285
305
    }
286
306
  }
287
307
  /* Look for a plymouth process */
288
 
  if(maxvalue == 0){
 
308
  if(proc_id == 0){
289
309
    struct dirent **direntries = NULL;
290
310
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
291
 
    if (ret == -1){
 
311
    if(ret == -1){
292
312
      error_plus(0, errno, "scandir");
293
313
    }
294
 
    if (ret > 0){
295
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
296
 
      if (ret < 0){
297
 
        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]);
298
323
      }
299
324
    }
300
325
    /* scandir might preallocate for this variable (man page unclear).
302
327
    free(direntries);
303
328
  }
304
329
  pid_t pid;
305
 
  pid = (pid_t)maxvalue;
306
 
  if((uintmax_t)pid == maxvalue){
 
330
  pid = (pid_t)proc_id;
 
331
  if((uintmax_t)pid == proc_id){
307
332
    return pid;
308
333
  }
309
334
  
310
335
  return 0;
311
336
}
312
337
 
313
 
const char **getargv(pid_t pid){
 
338
char **getargv(pid_t pid){
314
339
  int cl_fd;
315
340
  char *cmdline_filename;
316
341
  ssize_t sret;
377
402
    return NULL;
378
403
  }
379
404
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
380
 
  return (const char **)argv;
 
405
  return argv;
381
406
}
382
407
 
383
408
int main(__attribute__((unused))int argc,
458
483
  }
459
484
  kill_and_wait(plymouth_command_pid);
460
485
  
461
 
  const char **plymouthd_argv;
 
486
  char **plymouthd_argv = NULL;
462
487
  pid_t pid = get_pid();
463
488
  if(pid == 0){
464
489
    error_plus(0, 0, "plymouthd pid not found");
465
 
    plymouthd_argv = plymouthd_default_argv;
466
490
  } else {
467
491
    plymouthd_argv = getargv(pid);
468
492
  }
471
495
                       { plymouth_path, "quit", NULL },
472
496
                       false, false);
473
497
  if(not bret){
 
498
    if(plymouthd_argv != NULL){
 
499
      free(*plymouthd_argv);
 
500
      free(plymouthd_argv);
 
501
    }
474
502
    exit(EXIT_FAILURE);
475
503
  }
476
 
  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,
477
508
                       false, true);
 
509
  if(plymouthd_argv != NULL){
 
510
    free(*plymouthd_argv);
 
511
    free(plymouthd_argv);
 
512
  }
478
513
  if(not bret){
479
514
    exit(EXIT_FAILURE);
480
515
  }