/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: 2019-03-18 22:29:25 UTC
  • Revision ID: teddy@recompile.se-20190318222925-jvhek84dgcfgj6g3
mandos-ctl: Refactor tests

* mandos-ctl: Where the clients names "foo" and "barbar" do not refer
              to the actual mock clients in the TestCommand class,
              change all occurrences of these names to "client1" and
              "client2" (or just "client" when only one is used) .
              Also change all test doubles to use correct terminology;
              some things called mocks are actually stubs or spies,
              and rename all true mocks to have "mock" in their names.
              Also eliminate duplicate values in tests; derive values
              from previously defined values whenever possible.

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