/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/passprompt.c

  • Committer: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

Show diffs side-by-side

added added

removed removed

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