/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/password-prompt.c

  • Committer: Teddy Hogeborn
  • Date: 2015-03-10 18:03:38 UTC
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

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,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 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 <https://www.fukt.bsnet.se/~belorn/> and
23
 
 * <https://www.fukt.bsnet.se/~teddy/>.
 
22
 * Contact the authors at <mandos@recompile.se>.
24
23
 */
25
24
 
26
 
#define _GNU_SOURCE             /* getline() */
 
25
#define _GNU_SOURCE             /* getline(), asprintf() */
27
26
 
28
 
#include <termios.h>            /* struct termios, tcsetattr(),
 
27
#include <termios.h>            /* struct termios, tcsetattr(),
29
28
                                   TCSAFLUSH, tcgetattr(), ECHO */
30
29
#include <unistd.h>             /* struct termios, tcsetattr(),
31
30
                                   STDIN_FILENO, TCSAFLUSH,
32
 
                                   tcgetattr(), ECHO */
 
31
                                   tcgetattr(), ECHO, readlink() */
33
32
#include <signal.h>             /* sig_atomic_t, raise(), struct
34
33
                                   sigaction, sigemptyset(),
35
34
                                   sigaction(), sigaddset(), SIGINT,
36
35
                                   SIGQUIT, SIGHUP, SIGTERM,
37
36
                                   raise() */
38
37
#include <stddef.h>             /* NULL, size_t, ssize_t */
39
 
#include <sys/types.h>          /* ssize_t */
 
38
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t,
 
39
                                   ssize_t, open() */
40
40
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
41
 
                                   getopt_long, getenv() */
 
41
                                   getenv(), free() */
 
42
#include <dirent.h>             /* scandir(), alphasort() */
42
43
#include <stdio.h>              /* fprintf(), stderr, getline(),
43
 
                                   stdin, feof(), perror(), fputc(),
44
 
                                   stdout, getopt_long */
45
 
#include <errno.h>              /* errno, EINVAL */
 
44
                                   stdin, feof(), fputc(), vfprintf(),
 
45
                                   vasprintf() */
 
46
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
 
47
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
 
48
                                */
 
49
#include <error.h>              /* error() */
46
50
#include <iso646.h>             /* or, not */
47
51
#include <stdbool.h>            /* bool, false, true */
48
 
#include <string.h>             /* strlen, rindex, strncmp, strcmp */
 
52
#include <inttypes.h>           /* strtoumax() */
 
53
#include <sys/stat.h>           /* struct stat, lstat(), open() */
 
54
#include <string.h>             /* strlen, rindex, memcmp, strerror()
 
55
                                 */
49
56
#include <argp.h>               /* struct argp_option, struct
50
57
                                   argp_state, struct argp,
51
58
                                   argp_parse(), error_t,
52
59
                                   ARGP_KEY_ARG, ARGP_KEY_END,
53
60
                                   ARGP_ERR_UNKNOWN */
 
61
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
 
62
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
 
63
#include <fcntl.h>              /* open() */
 
64
#include <stdarg.h>             /* va_list, va_start(), ... */
54
65
 
55
66
volatile sig_atomic_t quit_now = 0;
56
67
int signal_received;
57
68
bool debug = false;
58
69
const char *argp_program_version = "password-prompt " VERSION;
59
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
70
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
71
 
 
72
/* Needed for conflict resolution */
 
73
const char plymouth_name[] = "plymouthd";
 
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
}
60
97
 
61
98
static void termination_handler(int signum){
62
99
  if(quit_now){
66
103
  signal_received = signum;
67
104
}
68
105
 
 
106
bool conflict_detection(void){
 
107
 
 
108
  /* plymouth conflicts with password-prompt since both want to read
 
109
     from the terminal.  Password-prompt will exit if it detects
 
110
     plymouth since plymouth performs the same functionality.
 
111
   */
 
112
  __attribute__((nonnull))
 
113
  int is_plymouth(const struct dirent *proc_entry){
 
114
    int ret;
 
115
    int cl_fd;
 
116
    {
 
117
      uintmax_t proc_id;
 
118
      char *tmp;
 
119
      errno = 0;
 
120
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
 
121
      
 
122
      if(errno != 0 or *tmp != '\0'
 
123
         or proc_id != (uintmax_t)((pid_t)proc_id)){
 
124
        return 0;
 
125
      }
 
126
    }
 
127
    
 
128
    char *cmdline_filename;
 
129
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
130
                   proc_entry->d_name);
 
131
    if(ret == -1){
 
132
      error_plus(0, errno, "asprintf");
 
133
      return 0;
 
134
    }
 
135
    
 
136
    /* Open /proc/<pid>/cmdline */
 
137
    cl_fd = open(cmdline_filename, O_RDONLY);
 
138
    free(cmdline_filename);
 
139
    if(cl_fd == -1){
 
140
      if(errno != ENOENT){
 
141
        error_plus(0, errno, "open");
 
142
      }
 
143
      return 0;
 
144
    }
 
145
    
 
146
    char *cmdline = NULL;
 
147
    {
 
148
      size_t cmdline_len = 0;
 
149
      size_t cmdline_allocated = 0;
 
150
      char *tmp;
 
151
      const size_t blocksize = 1024;
 
152
      ssize_t sret;
 
153
      do {
 
154
        /* Allocate more space? */
 
155
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
 
156
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
 
157
          if(tmp == NULL){
 
158
            error_plus(0, errno, "realloc");
 
159
            free(cmdline);
 
160
            close(cl_fd);
 
161
            return 0;
 
162
          }
 
163
          cmdline = tmp;
 
164
          cmdline_allocated += blocksize;
 
165
        }
 
166
        
 
167
        /* Read data */
 
168
        sret = read(cl_fd, cmdline + cmdline_len,
 
169
                    cmdline_allocated - cmdline_len);
 
170
        if(sret == -1){
 
171
          error_plus(0, errno, "read");
 
172
          free(cmdline);
 
173
          close(cl_fd);
 
174
          return 0;
 
175
        }
 
176
        cmdline_len += (size_t)sret;
 
177
      } while(sret != 0);
 
178
      ret = close(cl_fd);
 
179
      if(ret == -1){
 
180
        error_plus(0, errno, "close");
 
181
        free(cmdline);
 
182
        return 0;
 
183
      }
 
184
      cmdline[cmdline_len] = '\0'; /* Make sure it is terminated */
 
185
    }
 
186
    /* we now have cmdline */
 
187
    
 
188
    /* get basename */
 
189
    char *cmdline_base = strrchr(cmdline, '/');
 
190
    if(cmdline_base != NULL){
 
191
      cmdline_base += 1;                /* skip the slash */
 
192
    } else {
 
193
      cmdline_base = cmdline;
 
194
    }
 
195
    
 
196
    if(strcmp(cmdline_base, plymouth_name) != 0){
 
197
      if(debug){
 
198
        fprintf(stderr, "\"%s\" is not \"%s\"\n", cmdline_base,
 
199
                plymouth_name);
 
200
      }
 
201
      free(cmdline);
 
202
      return 0;
 
203
    }
 
204
    if(debug){
 
205
      fprintf(stderr, "\"%s\" equals \"%s\"\n", cmdline_base,
 
206
              plymouth_name);
 
207
    }
 
208
    free(cmdline);
 
209
    return 1;
 
210
  }
 
211
  
 
212
  struct dirent **direntries = NULL;
 
213
  int ret;
 
214
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
 
215
  if(ret == -1){
 
216
    error_plus(1, errno, "scandir");
 
217
  }
 
218
  free(direntries);
 
219
  return ret > 0;
 
220
}
 
221
 
 
222
 
69
223
int main(int argc, char **argv){
70
 
  ssize_t ret;
 
224
  ssize_t sret;
 
225
  int ret;
71
226
  size_t n;
72
227
  struct termios t_new, t_old;
73
228
  char *buffer = NULL;
83
238
        .doc = "Prefix shown before the prompt", .group = 2 },
84
239
      { .name = "debug", .key = 128,
85
240
        .doc = "Debug mode", .group = 3 },
 
241
      /*
 
242
       * These reproduce what we would get without ARGP_NO_HELP
 
243
       */
 
244
      { .name = "help", .key = '?',
 
245
        .doc = "Give this help list", .group = -1 },
 
246
      { .name = "usage", .key = -3,
 
247
        .doc = "Give a short usage message", .group = -1 },
 
248
      { .name = "version", .key = 'V',
 
249
        .doc = "Print program version", .group = -1 },
86
250
      { .name = NULL }
87
251
    };
88
252
    
 
253
    __attribute__((nonnull(3)))
89
254
    error_t parse_opt (int key, char *arg, struct argp_state *state){
 
255
      errno = 0;
90
256
      switch (key){
91
257
      case 'p':
92
258
        prefix = arg;
94
260
      case 128:
95
261
        debug = true;
96
262
        break;
97
 
      case ARGP_KEY_ARG:
98
 
        argp_usage(state);
99
 
        break;
100
 
      case ARGP_KEY_END:
 
263
        /*
 
264
         * These reproduce what we would get without ARGP_NO_HELP
 
265
         */
 
266
      case '?':                 /* --help */
 
267
        argp_state_help(state, state->out_stream,
 
268
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
 
269
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
270
      case -3:                  /* --usage */
 
271
        argp_state_help(state, state->out_stream,
 
272
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
273
      case 'V':                 /* --version */
 
274
        fprintf(state->out_stream, "%s\n", argp_program_version);
 
275
        exit(argp_err_exit_status);
101
276
        break;
102
277
      default:
103
278
        return ARGP_ERR_UNKNOWN;
104
279
      }
105
 
      return 0;
 
280
      return errno;
106
281
    }
107
282
    
108
283
    struct argp argp = { .options = options, .parser = parse_opt,
109
284
                         .args_doc = "",
110
285
                         .doc = "Mandos password-prompt -- Read and"
111
286
                         " output a password" };
112
 
    ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
113
 
    if(ret == ARGP_ERR_UNKNOWN){
114
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
115
 
      return EXIT_FAILURE;
 
287
    ret = argp_parse(&argp, argc, argv,
 
288
                     ARGP_IN_ORDER | ARGP_NO_HELP, NULL, NULL);
 
289
    switch(ret){
 
290
    case 0:
 
291
      break;
 
292
    case ENOMEM:
 
293
    default:
 
294
      errno = ret;
 
295
      error_plus(0, errno, "argp_parse");
 
296
      return EX_OSERR;
 
297
    case EINVAL:
 
298
      return EX_USAGE;
116
299
    }
117
300
  }
118
301
  
119
302
  if(debug){
120
303
    fprintf(stderr, "Starting %s\n", argv[0]);
121
304
  }
 
305
 
 
306
  if(conflict_detection()){
 
307
    if(debug){
 
308
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
 
309
    }
 
310
    return EXIT_FAILURE;
 
311
  }
 
312
  
122
313
  if(debug){
123
314
    fprintf(stderr, "Storing current terminal attributes\n");
124
315
  }
125
316
  
126
317
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
127
 
    perror("tcgetattr");
128
 
    return EXIT_FAILURE;
 
318
    int e = errno;
 
319
    error_plus(0, errno, "tcgetattr");
 
320
    switch(e){
 
321
    case EBADF:
 
322
    case ENOTTY:
 
323
      return EX_UNAVAILABLE;
 
324
    default:
 
325
      return EX_OSERR;
 
326
    }
129
327
  }
130
328
  
131
329
  sigemptyset(&new_action.sa_mask);
132
330
  ret = sigaddset(&new_action.sa_mask, SIGINT);
133
331
  if(ret == -1){
134
 
    perror("sigaddset");
135
 
    return EXIT_FAILURE;
 
332
    error_plus(0, errno, "sigaddset");
 
333
    return EX_OSERR;
136
334
  }
137
335
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
138
336
  if(ret == -1){
139
 
    perror("sigaddset");
140
 
    return EXIT_FAILURE;
 
337
    error_plus(0, errno, "sigaddset");
 
338
    return EX_OSERR;
141
339
  }
142
340
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
143
341
  if(ret == -1){
144
 
    perror("sigaddset");
145
 
    return EXIT_FAILURE;
 
342
    error_plus(0, errno, "sigaddset");
 
343
    return EX_OSERR;
146
344
  }
147
345
  /* Need to check if the handler is SIG_IGN before handling:
148
346
     | [[info:libc:Initial Signal Actions]] |
150
348
  */
151
349
  ret = sigaction(SIGINT, NULL, &old_action);
152
350
  if(ret == -1){
153
 
    perror("sigaction");
154
 
    return EXIT_FAILURE;
 
351
    error_plus(0, errno, "sigaction");
 
352
    return EX_OSERR;
155
353
  }
156
354
  if(old_action.sa_handler != SIG_IGN){
157
355
    ret = sigaction(SIGINT, &new_action, NULL);
158
356
    if(ret == -1){
159
 
      perror("sigaction");
160
 
      return EXIT_FAILURE;
 
357
      error_plus(0, errno, "sigaction");
 
358
      return EX_OSERR;
161
359
    }
162
360
  }
163
361
  ret = sigaction(SIGHUP, NULL, &old_action);
164
362
  if(ret == -1){
165
 
    perror("sigaction");
166
 
    return EXIT_FAILURE;
 
363
    error_plus(0, errno, "sigaction");
 
364
    return EX_OSERR;
167
365
  }
168
366
  if(old_action.sa_handler != SIG_IGN){
169
367
    ret = sigaction(SIGHUP, &new_action, NULL);
170
368
    if(ret == -1){
171
 
      perror("sigaction");
172
 
      return EXIT_FAILURE;
 
369
      error_plus(0, errno, "sigaction");
 
370
      return EX_OSERR;
173
371
    }
174
372
  }
175
373
  ret = sigaction(SIGTERM, NULL, &old_action);
176
374
  if(ret == -1){
177
 
    perror("sigaction");
178
 
    return EXIT_FAILURE;
 
375
    error_plus(0, errno, "sigaction");
 
376
    return EX_OSERR;
179
377
  }
180
378
  if(old_action.sa_handler != SIG_IGN){
181
379
    ret = sigaction(SIGTERM, &new_action, NULL);
182
380
    if(ret == -1){
183
 
      perror("sigaction");
184
 
      return EXIT_FAILURE;
 
381
      error_plus(0, errno, "sigaction");
 
382
      return EX_OSERR;
185
383
    }
186
384
  }
187
385
  
191
389
  }
192
390
  
193
391
  t_new = t_old;
194
 
  t_new.c_lflag &= ~ECHO;
 
392
  t_new.c_lflag &= ~(tcflag_t)ECHO;
195
393
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
196
 
    perror("tcsetattr-echo");
197
 
    return EXIT_FAILURE;
 
394
    int e = errno;
 
395
    error_plus(0, errno, "tcsetattr-echo");
 
396
    switch(e){
 
397
    case EBADF:
 
398
    case ENOTTY:
 
399
      return EX_UNAVAILABLE;
 
400
    case EINVAL:
 
401
    default:
 
402
      return EX_OSERR;
 
403
    }
198
404
  }
199
 
 
 
405
  
200
406
  if(debug){
201
407
    fprintf(stderr, "Waiting for input from stdin \n");
202
408
  }
213
419
      fprintf(stderr, "%s ", prefix);
214
420
    }
215
421
    {
216
 
      const char *cryptsource = getenv("cryptsource");
217
 
      const char *crypttarget = getenv("crypttarget");
218
 
      const char *const prompt
219
 
        = "Enter passphrase to unlock the disk";
 
422
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
 
423
      const char *crypttarget = getenv("CRYPTTAB_NAME");
 
424
      /* Before cryptsetup 1.1.0~rc2 */
 
425
      if(cryptsource == NULL){
 
426
        cryptsource = getenv("cryptsource");
 
427
      }
 
428
      if(crypttarget == NULL){
 
429
        crypttarget = getenv("crypttarget");
 
430
      }
 
431
      const char *const prompt1 = "Unlocking the disk";
 
432
      const char *const prompt2 = "Enter passphrase";
220
433
      if(cryptsource == NULL){
221
434
        if(crypttarget == NULL){
222
 
          fprintf(stderr, "%s: ", prompt);
 
435
          fprintf(stderr, "%s to unlock the disk: ", prompt2);
223
436
        } else {
224
 
          fprintf(stderr, "%s (%s): ", prompt, crypttarget);
 
437
          fprintf(stderr, "%s (%s)\n%s: ", prompt1, crypttarget,
 
438
                  prompt2);
225
439
        }
226
440
      } else {
227
441
        if(crypttarget == NULL){
228
 
          fprintf(stderr, "%s %s: ", prompt, cryptsource);
 
442
          fprintf(stderr, "%s %s\n%s: ", prompt1, cryptsource,
 
443
                  prompt2);
229
444
        } else {
230
 
          fprintf(stderr, "%s %s (%s): ", prompt, cryptsource,
231
 
                  crypttarget);
 
445
          fprintf(stderr, "%s %s (%s)\n%s: ", prompt1, cryptsource,
 
446
                  crypttarget, prompt2);
232
447
        }
233
448
      }
234
449
    }
235
 
    ret = getline(&buffer, &n, stdin);
236
 
    if(ret > 0){
 
450
    sret = getline(&buffer, &n, stdin);
 
451
    if(sret > 0){
237
452
      status = EXIT_SUCCESS;
238
453
      /* Make n = data size instead of allocated buffer size */
239
 
      n = (size_t)ret;
 
454
      n = (size_t)sret;
240
455
      /* Strip final newline */
241
 
      if(n>0 and buffer[n-1] == '\n'){
 
456
      if(n > 0 and buffer[n-1] == '\n'){
242
457
        buffer[n-1] = '\0';     /* not strictly necessary */
243
458
        n--;
244
459
      }
245
460
      size_t written = 0;
246
461
      while(written < n){
247
 
        ret = write(STDOUT_FILENO, buffer + written, n - written);
248
 
        if(ret < 0){
249
 
          perror("write");
250
 
          status = EXIT_FAILURE;
251
 
          break;
252
 
        }
253
 
        written += (size_t)ret;
 
462
        sret = write(STDOUT_FILENO, buffer + written, n - written);
 
463
        if(sret < 0){
 
464
          int e = errno;
 
465
          error_plus(0, errno, "write");
 
466
          switch(e){
 
467
          case EBADF:
 
468
          case EFAULT:
 
469
          case EINVAL:
 
470
          case EFBIG:
 
471
          case EIO:
 
472
          case ENOSPC:
 
473
          default:
 
474
            status = EX_IOERR;
 
475
            break;
 
476
          case EINTR:
 
477
            status = EXIT_FAILURE;
 
478
            break;
 
479
          }
 
480
          break;
 
481
        }
 
482
        written += (size_t)sret;
 
483
      }
 
484
      sret = close(STDOUT_FILENO);
 
485
      if(sret == -1){
 
486
        int e = errno;
 
487
        error_plus(0, errno, "close");
 
488
        switch(e){
 
489
        case EBADF:
 
490
          status = EX_OSFILE;
 
491
          break;
 
492
        case EIO:
 
493
        default:
 
494
          status = EX_IOERR;
 
495
          break;
 
496
        }
254
497
      }
255
498
      break;
256
499
    }
257
 
    if(ret < 0){
 
500
    if(sret < 0){
 
501
      int e = errno;
258
502
      if(errno != EINTR and not feof(stdin)){
259
 
        perror("getline");
260
 
        status = EXIT_FAILURE;
 
503
        error_plus(0, errno, "getline");
 
504
        switch(e){
 
505
        case EBADF:
 
506
          status = EX_UNAVAILABLE;
 
507
          break;
 
508
        case EIO:
 
509
        case EINVAL:
 
510
        default:
 
511
          status = EX_IOERR;
 
512
          break;
 
513
        }
261
514
        break;
262
515
      }
263
516
    }
264
 
    /* if(ret == 0), then the only sensible thing to do is to retry to
265
 
       read from stdin */
 
517
    /* if(sret == 0), then the only sensible thing to do is to retry
 
518
       to read from stdin */
266
519
    fputc('\n', stderr);
267
520
    if(debug and not quit_now){
268
521
      /* If quit_now is nonzero, we were interrupted by a signal, and
277
530
    fprintf(stderr, "Restoring terminal attributes\n");
278
531
  }
279
532
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
280
 
    perror("tcsetattr+echo");
 
533
    error_plus(0, errno, "tcsetattr+echo");
281
534
  }
282
535
  
283
536
  if(quit_now){
285
538
    old_action.sa_handler = SIG_DFL;
286
539
    ret = sigaction(signal_received, &old_action, NULL);
287
540
    if(ret == -1){
288
 
      perror("sigaction");
 
541
      error_plus(0, errno, "sigaction");
289
542
    }
290
543
    raise(signal_received);
291
544
  }
294
547
    fprintf(stderr, "%s is exiting with status %d\n", argv[0],
295
548
            status);
296
549
  }
297
 
  if(status == EXIT_SUCCESS){
 
550
  if(status == EXIT_SUCCESS or status == EX_OK){
298
551
    fputc('\n', stderr);
299
552
  }
300
553