/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: Teddy Hogeborn
  • Date: 2008-08-02 10:48:24 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080802104824-fx0miwp9o4g9r31e
* plugbasedclient.c (struct process): New fields "eof", "completed",
                                      and "status".
  (handle_sigchld): New function.
  (main): Initialize "dir" to NULL to only closedir() it if necessary.
          Move "process_list" to be a global variable to be accessible
          by "handle_sigchld".  Make "handle_sigchld" handle SIGCHLD.
          Remove redundant check for NULL "dir".  Free "filename" when
          no longer used.  Block SIGCHLD around fork()/exec().
          Restore normal signals in child.  Only loop while running
          processes exist.  Print process buffer when the process is
          done and it has emitted EOF, not when it only emits EOF.
          Remove processes from list which exit non-cleanly.  In
          cleaning up, closedir() if necessary.  Bug fix: set next
          pointer correctly when freeing process list.

* plugins.d/passprompt.c (main): Do not ignore SIGQUIT.

Show diffs side-by-side

added added

removed removed

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