/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugins.d/password-prompt.c

  • Committer: Teddy Hogeborn
  • Date: 2015-05-23 20:18:34 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • 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:
plugins.d/password-prompt.c
2
2
/*
3
3
 * Password-prompt - Read a password from the terminal and print it
4
4
 * 
5
 
 * Copyright © 2008-2010 Teddy Hogeborn
6
 
 * Copyright © 2008-2010 Björn Påhlsson
 
5
 * Copyright © 2008-2014 Teddy Hogeborn
 
6
 * Copyright © 2008-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             /* getline(), asprintf() */
41
41
                                   getenv(), free() */
42
42
#include <dirent.h>             /* scandir(), alphasort() */
43
43
#include <stdio.h>              /* fprintf(), stderr, getline(),
44
 
                                   stdin, feof(), fputc()
45
 
                                */
 
44
                                   stdin, feof(), fputc(), vfprintf(),
 
45
                                   vasprintf() */
46
46
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
47
47
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
48
48
                                */
51
51
#include <stdbool.h>            /* bool, false, true */
52
52
#include <inttypes.h>           /* strtoumax() */
53
53
#include <sys/stat.h>           /* struct stat, lstat(), open() */
54
 
#include <string.h>             /* strlen, rindex, memcmp */
 
54
#include <string.h>             /* strlen, rindex, memcmp, strerror()
 
55
                                 */
55
56
#include <argp.h>               /* struct argp_option, struct
56
57
                                   argp_state, struct argp,
57
58
                                   argp_parse(), error_t,
60
61
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
61
62
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
62
63
#include <fcntl.h>              /* open() */
 
64
#include <stdarg.h>             /* va_list, va_start(), ... */
63
65
 
64
66
volatile sig_atomic_t quit_now = 0;
65
67
int signal_received;
66
68
bool debug = false;
67
69
const char *argp_program_version = "password-prompt " VERSION;
68
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
70
const char *argp_program_bug_address = "<mandos@recompile.se>";
69
71
 
70
72
/* Needed for conflict resolution */
71
73
const char plymouth_name[] = "plymouthd";
72
74
 
 
75
/* Function to use when printing errors */
 
76
__attribute__((format (gnu_printf, 3, 4)))
 
77
void error_plus(int status, int errnum, const char *formatstring,
 
78
                ...){
 
79
  va_list ap;
 
80
  char *text;
 
81
  int ret;
 
82
  
 
83
  va_start(ap, formatstring);
 
84
  ret = vasprintf(&text, formatstring, ap);
 
85
  if(ret == -1){
 
86
    fprintf(stderr, "Mandos plugin %s: ",
 
87
            program_invocation_short_name);
 
88
    vfprintf(stderr, formatstring, ap);
 
89
    fprintf(stderr, ": %s\n", strerror(errnum));
 
90
    error(status, errno, "vasprintf while printing error");
 
91
    return;
 
92
  }
 
93
  fprintf(stderr, "Mandos plugin ");
 
94
  error(status, errnum, "%s", text);
 
95
  free(text);
 
96
}
 
97
 
73
98
static void termination_handler(int signum){
74
99
  if(quit_now){
75
100
    return;
84
109
     from the terminal.  Password-prompt will exit if it detects
85
110
     plymouth since plymouth performs the same functionality.
86
111
   */
 
112
  __attribute__((nonnull))
87
113
  int is_plymouth(const struct dirent *proc_entry){
88
114
    int ret;
89
115
    int cl_fd;
90
116
    {
91
 
      uintmax_t maxvalue;
 
117
      uintmax_t proc_id;
92
118
      char *tmp;
93
119
      errno = 0;
94
 
      maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
120
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
95
121
      
96
122
      if(errno != 0 or *tmp != '\0'
97
 
         or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
123
         or proc_id != (uintmax_t)((pid_t)proc_id)){
98
124
        return 0;
99
125
      }
100
126
    }
103
129
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
104
130
                   proc_entry->d_name);
105
131
    if(ret == -1){
106
 
      error(0, errno, "asprintf");
 
132
      error_plus(0, errno, "asprintf");
107
133
      return 0;
108
134
    }
109
135
    
111
137
    cl_fd = open(cmdline_filename, O_RDONLY);
112
138
    free(cmdline_filename);
113
139
    if(cl_fd == -1){
114
 
      error(0, errno, "open");
 
140
      if(errno != ENOENT){
 
141
        error_plus(0, errno, "open");
 
142
      }
115
143
      return 0;
116
144
    }
117
145
    
127
155
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
128
156
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
129
157
          if(tmp == NULL){
130
 
            error(0, errno, "realloc");
 
158
            error_plus(0, errno, "realloc");
131
159
            free(cmdline);
132
160
            close(cl_fd);
133
161
            return 0;
140
168
        sret = read(cl_fd, cmdline + cmdline_len,
141
169
                    cmdline_allocated - cmdline_len);
142
170
        if(sret == -1){
143
 
          error(0, errno, "read");
 
171
          error_plus(0, errno, "read");
144
172
          free(cmdline);
145
173
          close(cl_fd);
146
174
          return 0;
149
177
      } while(sret != 0);
150
178
      ret = close(cl_fd);
151
179
      if(ret == -1){
152
 
        error(0, errno, "close");
 
180
        error_plus(0, errno, "close");
153
181
        free(cmdline);
154
182
        return 0;
155
183
      }
181
209
    return 1;
182
210
  }
183
211
  
184
 
  struct dirent **direntries;
 
212
  struct dirent **direntries = NULL;
185
213
  int ret;
186
214
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
187
 
  if (ret == -1){
188
 
    error(1, errno, "scandir");
 
215
  if(ret == -1){
 
216
    error_plus(1, errno, "scandir");
189
217
  }
 
218
  free(direntries);
190
219
  return ret > 0;
191
220
}
192
221
 
221
250
      { .name = NULL }
222
251
    };
223
252
    
 
253
    __attribute__((nonnull(3)))
224
254
    error_t parse_opt (int key, char *arg, struct argp_state *state){
225
255
      errno = 0;
226
256
      switch (key){
262
292
    case ENOMEM:
263
293
    default:
264
294
      errno = ret;
265
 
      error(0, errno, "argp_parse");
 
295
      error_plus(0, errno, "argp_parse");
266
296
      return EX_OSERR;
267
297
    case EINVAL:
268
298
      return EX_USAGE;
273
303
    fprintf(stderr, "Starting %s\n", argv[0]);
274
304
  }
275
305
 
276
 
  if (conflict_detection()){
 
306
  if(conflict_detection()){
277
307
    if(debug){
278
308
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
279
309
    }
286
316
  
287
317
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
288
318
    int e = errno;
289
 
    error(0, errno, "tcgetattr");
 
319
    error_plus(0, errno, "tcgetattr");
290
320
    switch(e){
291
321
    case EBADF:
292
322
    case ENOTTY:
299
329
  sigemptyset(&new_action.sa_mask);
300
330
  ret = sigaddset(&new_action.sa_mask, SIGINT);
301
331
  if(ret == -1){
302
 
    error(0, errno, "sigaddset");
 
332
    error_plus(0, errno, "sigaddset");
303
333
    return EX_OSERR;
304
334
  }
305
335
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
306
336
  if(ret == -1){
307
 
    error(0, errno, "sigaddset");
 
337
    error_plus(0, errno, "sigaddset");
308
338
    return EX_OSERR;
309
339
  }
310
340
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
311
341
  if(ret == -1){
312
 
    error(0, errno, "sigaddset");
 
342
    error_plus(0, errno, "sigaddset");
313
343
    return EX_OSERR;
314
344
  }
315
345
  /* Need to check if the handler is SIG_IGN before handling:
318
348
  */
319
349
  ret = sigaction(SIGINT, NULL, &old_action);
320
350
  if(ret == -1){
321
 
    error(0, errno, "sigaction");
 
351
    error_plus(0, errno, "sigaction");
322
352
    return EX_OSERR;
323
353
  }
324
354
  if(old_action.sa_handler != SIG_IGN){
325
355
    ret = sigaction(SIGINT, &new_action, NULL);
326
356
    if(ret == -1){
327
 
      error(0, errno, "sigaction");
 
357
      error_plus(0, errno, "sigaction");
328
358
      return EX_OSERR;
329
359
    }
330
360
  }
331
361
  ret = sigaction(SIGHUP, NULL, &old_action);
332
362
  if(ret == -1){
333
 
    error(0, errno, "sigaction");
 
363
    error_plus(0, errno, "sigaction");
334
364
    return EX_OSERR;
335
365
  }
336
366
  if(old_action.sa_handler != SIG_IGN){
337
367
    ret = sigaction(SIGHUP, &new_action, NULL);
338
368
    if(ret == -1){
339
 
      error(0, errno, "sigaction");
 
369
      error_plus(0, errno, "sigaction");
340
370
      return EX_OSERR;
341
371
    }
342
372
  }
343
373
  ret = sigaction(SIGTERM, NULL, &old_action);
344
374
  if(ret == -1){
345
 
    error(0, errno, "sigaction");
 
375
    error_plus(0, errno, "sigaction");
346
376
    return EX_OSERR;
347
377
  }
348
378
  if(old_action.sa_handler != SIG_IGN){
349
379
    ret = sigaction(SIGTERM, &new_action, NULL);
350
380
    if(ret == -1){
351
 
      error(0, errno, "sigaction");
 
381
      error_plus(0, errno, "sigaction");
352
382
      return EX_OSERR;
353
383
    }
354
384
  }
362
392
  t_new.c_lflag &= ~(tcflag_t)ECHO;
363
393
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
364
394
    int e = errno;
365
 
    error(0, errno, "tcsetattr-echo");
 
395
    error_plus(0, errno, "tcsetattr-echo");
366
396
    switch(e){
367
397
    case EBADF:
368
398
    case ENOTTY:
432
462
        sret = write(STDOUT_FILENO, buffer + written, n - written);
433
463
        if(sret < 0){
434
464
          int e = errno;
435
 
          error(0, errno, "write");
 
465
          error_plus(0, errno, "write");
436
466
          switch(e){
437
467
          case EBADF:
438
468
          case EFAULT:
454
484
      sret = close(STDOUT_FILENO);
455
485
      if(sret == -1){
456
486
        int e = errno;
457
 
        error(0, errno, "close");
 
487
        error_plus(0, errno, "close");
458
488
        switch(e){
459
489
        case EBADF:
460
490
          status = EX_OSFILE;
470
500
    if(sret < 0){
471
501
      int e = errno;
472
502
      if(errno != EINTR and not feof(stdin)){
473
 
        error(0, errno, "getline");
 
503
        error_plus(0, errno, "getline");
474
504
        switch(e){
475
505
        case EBADF:
476
506
          status = EX_UNAVAILABLE;
 
507
          break;
477
508
        case EIO:
478
509
        case EINVAL:
479
510
        default:
499
530
    fprintf(stderr, "Restoring terminal attributes\n");
500
531
  }
501
532
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
502
 
    error(0, errno, "tcsetattr+echo");
 
533
    error_plus(0, errno, "tcsetattr+echo");
503
534
  }
504
535
  
505
536
  if(quit_now){
507
538
    old_action.sa_handler = SIG_DFL;
508
539
    ret = sigaction(signal_received, &old_action, NULL);
509
540
    if(ret == -1){
510
 
      error(0, errno, "sigaction");
 
541
      error_plus(0, errno, "sigaction");
511
542
    }
512
543
    raise(signal_received);
513
544
  }