/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: 2015-01-25 00:02:51 UTC
  • Revision ID: teddy@recompile.se-20150125000251-j2bw50gfq9smqyxe
mandos.xml (SEE ALSO): Update links.

Update link to GnuPG home page, change reference from TLS 1.1 to TLS
1.2, and change to latest RFC for using OpenPGP keys with TLS (and use
its correct title).

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
 
5
 * Copyright © 2010-2014 Teddy Hogeborn
 
6
 * Copyright © 2010-2014 Björn Påhlsson
7
7
 * 
8
8
 * This program is free software: you can redistribute it and/or
9
9
 * modify it under the terms of the GNU General Public License as
19
19
 * along with this program.  If not, see
20
20
 * <http://www.gnu.org/licenses/>.
21
21
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
22
 * Contact the authors at <mandos@recompile.se>.
23
23
 */
24
24
 
25
25
#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */
54
54
#include <stdarg.h>             /* va_list, va_start(), ... */
55
55
 
56
56
sig_atomic_t interrupted_by_signal = 0;
57
 
const char plymouth_pid[] = "/dev/.initramfs/plymouth.pid";
 
57
 
 
58
/* Used by Ubuntu 11.04 (Natty Narwahl) */
 
59
const char plymouth_old_pid[] = "/dev/.initramfs/plymouth.pid";
 
60
/* Used by Ubuntu 11.10 (Oneiric Ocelot) */
 
61
const char plymouth_pid[] = "/run/initramfs/plymouth.pid";
 
62
 
58
63
const char plymouth_path[] = "/bin/plymouth";
59
64
const char plymouthd_path[] = "/sbin/plymouthd";
60
65
const char *plymouthd_default_argv[] = {"/sbin/plymouthd",
61
66
                                        "--mode=boot",
62
67
                                        "--attach-to-session",
63
 
                                        "--pid-file="
64
 
                                        "/dev/.initramfs/"
65
 
                                        "plymouth.pid",
66
68
                                        NULL };
67
69
 
68
70
static void termination_handler(__attribute__((unused))int signum){
73
75
}
74
76
 
75
77
/* Function to use when printing errors */
 
78
__attribute__((format (gnu_printf, 3, 4)))
76
79
void error_plus(int status, int errnum, const char *formatstring,
77
80
                ...){
78
81
  va_list ap;
81
84
  
82
85
  va_start(ap, formatstring);
83
86
  ret = vasprintf(&text, formatstring, ap);
84
 
  if (ret == -1){
 
87
  if(ret == -1){
85
88
    fprintf(stderr, "Mandos plugin %s: ",
86
89
            program_invocation_short_name);
87
90
    vfprintf(stderr, formatstring, ap);
151
154
  return true;
152
155
}
153
156
 
 
157
__attribute__((nonnull (2, 3)))
154
158
bool exec_and_wait(pid_t *pid_return, const char *path,
155
 
                   const char **argv, bool interruptable,
 
159
                   const char * const *argv, bool interruptable,
156
160
                   bool daemonize){
157
161
  int status;
158
162
  int ret;
175
179
    int i = 0;
176
180
    for (; argv[i]!=NULL; i++){
177
181
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
178
 
      if (tmp == NULL){
 
182
      if(tmp == NULL){
179
183
        error_plus(0, errno, "realloc");
180
184
        free(new_argv);
181
185
        _exit(EX_OSERR);
210
214
  return false;
211
215
}
212
216
 
 
217
__attribute__((nonnull))
213
218
int is_plymouth(const struct dirent *proc_entry){
214
219
  int ret;
215
220
  {
216
 
    uintmax_t maxvalue;
 
221
    uintmax_t proc_id;
217
222
    char *tmp;
218
223
    errno = 0;
219
 
    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
224
    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
220
225
 
221
226
    if(errno != 0 or *tmp != '\0'
222
 
       or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
227
       or proc_id != (uintmax_t)((pid_t)proc_id)){
223
228
      return 0;
224
229
    }
225
230
  }
260
265
 
261
266
pid_t get_pid(void){
262
267
  int ret;
 
268
  uintmax_t proc_id = 0;
263
269
  FILE *pidfile = fopen(plymouth_pid, "r");
264
 
  uintmax_t maxvalue = 0;
 
270
  /* Try the new pid file location */
265
271
  if(pidfile != NULL){
266
 
    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
272
    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
267
273
    if(ret != 1){
268
 
      maxvalue = 0;
 
274
      proc_id = 0;
269
275
    }
270
276
    fclose(pidfile);
271
277
  }
272
 
  if(maxvalue == 0){
 
278
  /* Try the old pid file location */
 
279
  if(proc_id == 0){
 
280
    pidfile = fopen(plymouth_pid, "r");
 
281
    if(pidfile != NULL){
 
282
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
283
      if(ret != 1){
 
284
        proc_id = 0;
 
285
      }
 
286
      fclose(pidfile);
 
287
    }
 
288
  }
 
289
  /* Look for a plymouth process */
 
290
  if(proc_id == 0){
273
291
    struct dirent **direntries = NULL;
274
292
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
275
 
    if (ret == -1){
 
293
    if(ret == -1){
276
294
      error_plus(0, errno, "scandir");
277
295
    }
278
 
    if (ret > 0){
279
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
280
 
      if (ret < 0){
 
296
    if(ret > 0){
 
297
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &proc_id);
 
298
      if(ret < 0){
281
299
        error_plus(0, errno, "sscanf");
282
300
      }
283
301
    }
286
304
    free(direntries);
287
305
  }
288
306
  pid_t pid;
289
 
  pid = (pid_t)maxvalue;
290
 
  if((uintmax_t)pid == maxvalue){
 
307
  pid = (pid_t)proc_id;
 
308
  if((uintmax_t)pid == proc_id){
291
309
    return pid;
292
310
  }
293
311
  
294
312
  return 0;
295
313
}
296
314
 
297
 
const char **getargv(pid_t pid){
 
315
const char * const * getargv(pid_t pid){
298
316
  int cl_fd;
299
317
  char *cmdline_filename;
300
318
  ssize_t sret;
361
379
    return NULL;
362
380
  }
363
381
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
364
 
  return (const char **)argv;
 
382
  return (const char * const *)argv;
365
383
}
366
384
 
367
385
int main(__attribute__((unused))int argc,
442
460
  }
443
461
  kill_and_wait(plymouth_command_pid);
444
462
  
445
 
  const char **plymouthd_argv;
 
463
  const char * const *plymouthd_argv;
446
464
  pid_t pid = get_pid();
447
465
  if(pid == 0){
448
466
    error_plus(0, 0, "plymouthd pid not found");