/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-08-02 09:36:40 UTC
  • Revision ID: teddy@recompile.se-20150802093640-nc0n17rbmqlbaxuf
Add D-Bus annotations on a few properties on the Client object.

The D-Bus property "Secret" on the interface
"se.recompile.Mandos.Client" should have the annotation
"org.freedesktop.DBus.Property.EmitsChangedSignal" set to
"invalidates".  Also, the properties "Created", "Fingerprint", "Name",
and "ObjectPath" should have the same annotation set to "const".

* mandos (ClientDBus.Name_dbus_property): Set annotation
                    "org.freedesktop.DBus.Property.EmitsChangedSignal"
                    to "const".
  (ClientDBus.Fingerprint_dbus_property): - '' -
  (ClientDBus.Created_dbus_property): - '' -
  (ClientDBus.ObjectPath_dbus_property): - '' -
  (ClientDBus.Secret_dbus_property): Set annotation
                    "org.freedesktop.DBus.Property.EmitsChangedSignal"
                    to "invalidates".

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-2015 Teddy Hogeborn
 
6
 * Copyright © 2010-2015 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() */
36
36
#include <stddef.h>             /* NULL */
37
37
#include <string.h>             /* strchr(), memcmp() */
38
38
#include <stdio.h>              /* asprintf(), perror(), fopen(),
39
 
                                   fscanf(), vasprintf(), fprintf(), vfprintf() */
 
39
                                   fscanf(), vasprintf(), fprintf(),
 
40
                                   vfprintf() */
40
41
#include <unistd.h>             /* close(), readlink(), read(),
41
42
                                   fork(), setsid(), chdir(), dup2(),
42
43
                                   STDERR_FILENO, execv(), access() */
53
54
#include <stdarg.h>             /* va_list, va_start(), ... */
54
55
 
55
56
sig_atomic_t interrupted_by_signal = 0;
56
 
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
 
57
63
const char plymouth_path[] = "/bin/plymouth";
58
64
const char plymouthd_path[] = "/sbin/plymouthd";
59
65
const char *plymouthd_default_argv[] = {"/sbin/plymouthd",
60
66
                                        "--mode=boot",
61
67
                                        "--attach-to-session",
62
 
                                        "--pid-file="
63
 
                                        "/dev/.initramfs/"
64
 
                                        "plymouth.pid",
65
68
                                        NULL };
66
69
 
67
70
static void termination_handler(__attribute__((unused))int signum){
72
75
}
73
76
 
74
77
/* Function to use when printing errors */
75
 
void error_plus(int status, int errnum, const char *formatstring, ...){
 
78
__attribute__((format (gnu_printf, 3, 4)))
 
79
void error_plus(int status, int errnum, const char *formatstring,
 
80
                ...){
76
81
  va_list ap;
77
82
  char *text;
78
83
  int ret;
79
84
  
80
85
  va_start(ap, formatstring);
81
86
  ret = vasprintf(&text, formatstring, ap);
82
 
  if (ret == -1){
83
 
    fprintf(stderr, "Mandos plugin %s: ", program_invocation_short_name);
 
87
  if(ret == -1){
 
88
    fprintf(stderr, "Mandos plugin %s: ",
 
89
            program_invocation_short_name);
84
90
    vfprintf(stderr, formatstring, ap);
85
91
    fprintf(stderr, ": ");
86
92
    fprintf(stderr, "%s\n", strerror(errnum));
148
154
  return true;
149
155
}
150
156
 
 
157
__attribute__((nonnull (2, 3)))
151
158
bool exec_and_wait(pid_t *pid_return, const char *path,
152
 
                   const char **argv, bool interruptable,
 
159
                   const char * const *argv, bool interruptable,
153
160
                   bool daemonize){
154
161
  int status;
155
162
  int ret;
172
179
    int i = 0;
173
180
    for (; argv[i]!=NULL; i++){
174
181
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
175
 
      if (tmp == NULL){
 
182
      if(tmp == NULL){
176
183
        error_plus(0, errno, "realloc");
177
184
        free(new_argv);
178
185
        _exit(EX_OSERR);
207
214
  return false;
208
215
}
209
216
 
 
217
__attribute__((nonnull))
210
218
int is_plymouth(const struct dirent *proc_entry){
211
219
  int ret;
212
220
  {
213
 
    uintmax_t maxvalue;
 
221
    uintmax_t proc_id;
214
222
    char *tmp;
215
223
    errno = 0;
216
 
    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
224
    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
217
225
 
218
226
    if(errno != 0 or *tmp != '\0'
219
 
       or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
227
       or proc_id != (uintmax_t)((pid_t)proc_id)){
220
228
      return 0;
221
229
    }
222
230
  }
257
265
 
258
266
pid_t get_pid(void){
259
267
  int ret;
 
268
  uintmax_t proc_id = 0;
260
269
  FILE *pidfile = fopen(plymouth_pid, "r");
261
 
  uintmax_t maxvalue = 0;
 
270
  /* Try the new pid file location */
262
271
  if(pidfile != NULL){
263
 
    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
272
    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
264
273
    if(ret != 1){
265
 
      maxvalue = 0;
 
274
      proc_id = 0;
266
275
    }
267
276
    fclose(pidfile);
268
277
  }
269
 
  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){
270
291
    struct dirent **direntries = NULL;
271
292
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
272
 
    if (ret == -1){
 
293
    if(ret == -1){
273
294
      error_plus(0, errno, "scandir");
274
295
    }
275
 
    if (ret > 0){
276
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
277
 
      if (ret < 0){
 
296
    if(ret > 0){
 
297
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &proc_id);
 
298
      if(ret < 0){
278
299
        error_plus(0, errno, "sscanf");
279
300
      }
280
301
    }
281
302
    /* scandir might preallocate for this variable (man page unclear).
282
 
       even if ret == 0, we need to free it. */
 
303
       even if ret == 0, therefore we need to free it. */
283
304
    free(direntries);
284
305
  }
285
306
  pid_t pid;
286
 
  pid = (pid_t)maxvalue;
287
 
  if((uintmax_t)pid == maxvalue){
 
307
  pid = (pid_t)proc_id;
 
308
  if((uintmax_t)pid == proc_id){
288
309
    return pid;
289
310
  }
290
311
  
291
312
  return 0;
292
313
}
293
314
 
294
 
const char **getargv(pid_t pid){
 
315
const char * const * getargv(pid_t pid){
295
316
  int cl_fd;
296
317
  char *cmdline_filename;
297
318
  ssize_t sret;
358
379
    return NULL;
359
380
  }
360
381
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
361
 
  return (const char **)argv;
 
382
  return (const char * const *)argv;
362
383
}
363
384
 
364
385
int main(__attribute__((unused))int argc,
439
460
  }
440
461
  kill_and_wait(plymouth_command_pid);
441
462
  
442
 
  const char **plymouthd_argv;
 
463
  const char * const *plymouthd_argv;
443
464
  pid_t pid = get_pid();
444
465
  if(pid == 0){
445
466
    error_plus(0, 0, "plymouthd pid not found");