/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-05-23 20:18:34 UTC
  • mto: This revision was merged to the branch mainline in revision 756.
  • Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.

For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished".  This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found.  One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD.  To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous).  In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.

This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.

DBUS-API (CheckerCompleted): Change the second value provided by this
                             D-Bus signal from the raw wait(2) status
                             to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
                               multiprocessing.Process (starting a
                               separate process).
(Client.last_checker signal): New attribute for signal which
                              terminated last checker.  Like
                              last_checker_status, only not accessible
                              via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
                           to get returncode; set last_checker_signal.
                           Return False so gobject does not call this
                           callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
                        instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument.        Call
                               Client.checker_callback early to have
                               it set last_checker_status and
                               last_checker_signal; use those.  Change
                               second value provided to D-Bus signal
                               CheckerCompleted to use
                               last_checker_signal if checker was
                               terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
                                        "condition" argument.  Use it
                                        accordingly.  Remove dead code
                                        (os.WCOREDUMP case).

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
 
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
75
75
}
76
76
 
77
77
/* Function to use when printing errors */
 
78
__attribute__((format (gnu_printf, 3, 4)))
78
79
void error_plus(int status, int errnum, const char *formatstring,
79
80
                ...){
80
81
  va_list ap;
83
84
  
84
85
  va_start(ap, formatstring);
85
86
  ret = vasprintf(&text, formatstring, ap);
86
 
  if (ret == -1){
 
87
  if(ret == -1){
87
88
    fprintf(stderr, "Mandos plugin %s: ",
88
89
            program_invocation_short_name);
89
90
    vfprintf(stderr, formatstring, ap);
153
154
  return true;
154
155
}
155
156
 
 
157
__attribute__((nonnull (2, 3)))
156
158
bool exec_and_wait(pid_t *pid_return, const char *path,
157
 
                   const char **argv, bool interruptable,
 
159
                   const char * const *argv, bool interruptable,
158
160
                   bool daemonize){
159
161
  int status;
160
162
  int ret;
177
179
    int i = 0;
178
180
    for (; argv[i]!=NULL; i++){
179
181
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
180
 
      if (tmp == NULL){
 
182
      if(tmp == NULL){
181
183
        error_plus(0, errno, "realloc");
182
184
        free(new_argv);
183
185
        _exit(EX_OSERR);
212
214
  return false;
213
215
}
214
216
 
 
217
__attribute__((nonnull))
215
218
int is_plymouth(const struct dirent *proc_entry){
216
219
  int ret;
217
220
  {
218
 
    uintmax_t maxvalue;
 
221
    uintmax_t proc_id;
219
222
    char *tmp;
220
223
    errno = 0;
221
 
    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
224
    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
222
225
 
223
226
    if(errno != 0 or *tmp != '\0'
224
 
       or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
227
       or proc_id != (uintmax_t)((pid_t)proc_id)){
225
228
      return 0;
226
229
    }
227
230
  }
262
265
 
263
266
pid_t get_pid(void){
264
267
  int ret;
265
 
  uintmax_t maxvalue = 0;
 
268
  uintmax_t proc_id = 0;
266
269
  FILE *pidfile = fopen(plymouth_pid, "r");
267
270
  /* Try the new pid file location */
268
271
  if(pidfile != NULL){
269
 
    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
272
    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
270
273
    if(ret != 1){
271
 
      maxvalue = 0;
 
274
      proc_id = 0;
272
275
    }
273
276
    fclose(pidfile);
274
277
  }
275
278
  /* Try the old pid file location */
276
 
  if(maxvalue == 0){
 
279
  if(proc_id == 0){
277
280
    pidfile = fopen(plymouth_pid, "r");
278
281
    if(pidfile != NULL){
279
 
      ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
282
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
280
283
      if(ret != 1){
281
 
        maxvalue = 0;
 
284
        proc_id = 0;
282
285
      }
283
286
      fclose(pidfile);
284
287
    }
285
288
  }
286
289
  /* Look for a plymouth process */
287
 
  if(maxvalue == 0){
 
290
  if(proc_id == 0){
288
291
    struct dirent **direntries = NULL;
289
292
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
290
 
    if (ret == -1){
 
293
    if(ret == -1){
291
294
      error_plus(0, errno, "scandir");
292
295
    }
293
 
    if (ret > 0){
294
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
295
 
      if (ret < 0){
 
296
    if(ret > 0){
 
297
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &proc_id);
 
298
      if(ret < 0){
296
299
        error_plus(0, errno, "sscanf");
297
300
      }
298
301
    }
301
304
    free(direntries);
302
305
  }
303
306
  pid_t pid;
304
 
  pid = (pid_t)maxvalue;
305
 
  if((uintmax_t)pid == maxvalue){
 
307
  pid = (pid_t)proc_id;
 
308
  if((uintmax_t)pid == proc_id){
306
309
    return pid;
307
310
  }
308
311
  
309
312
  return 0;
310
313
}
311
314
 
312
 
const char **getargv(pid_t pid){
 
315
const char * const * getargv(pid_t pid){
313
316
  int cl_fd;
314
317
  char *cmdline_filename;
315
318
  ssize_t sret;
376
379
    return NULL;
377
380
  }
378
381
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
379
 
  return (const char **)argv;
 
382
  return (const char * const *)argv;
380
383
}
381
384
 
382
385
int main(__attribute__((unused))int argc,
457
460
  }
458
461
  kill_and_wait(plymouth_command_pid);
459
462
  
460
 
  const char **plymouthd_argv;
 
463
  const char * const *plymouthd_argv;
461
464
  pid_t pid = get_pid();
462
465
  if(pid == 0){
463
466
    error_plus(0, 0, "plymouthd pid not found");