/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: 2011-12-31 20:07:11 UTC
  • mfrom: (535.1.9 wireless-network-hook)
  • Revision ID: teddy@recompile.se-20111231200711-6dli3r8drftem57r
Merge new wireless network hook.  Fix bridge network hook to use
hardware addresses instead of interface names.  Implement and document
new "CONNECT" environment variable for network hooks.

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