/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
1
 
/*  -*- coding: utf-8 -*- */
 
1
/*  -*- coding: utf-8; mode: c; mode: orgtbl -*- */
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
 
                                   SIGQUIT, SIGHUP, SIGTERM */
 
36
                                   SIGQUIT, SIGHUP, SIGTERM,
 
37
                                   raise() */
37
38
#include <stddef.h>             /* NULL, size_t, ssize_t */
38
 
#include <sys/types.h>          /* ssize_t */
 
39
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t,
 
40
                                   ssize_t, open() */
39
41
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
40
 
                                   getopt_long, getenv() */
 
42
                                   getenv(), free() */
 
43
#include <dirent.h>             /* scandir(), alphasort() */
41
44
#include <stdio.h>              /* fprintf(), stderr, getline(),
42
 
                                   stdin, feof(), perror(), fputc(),
43
 
                                   stdout, getopt_long */
44
 
#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() */
45
51
#include <iso646.h>             /* or, not */
46
52
#include <stdbool.h>            /* bool, false, true */
47
 
#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
                                 */
48
57
#include <argp.h>               /* struct argp_option, struct
49
58
                                   argp_state, struct argp,
50
59
                                   argp_parse(), error_t,
51
60
                                   ARGP_KEY_ARG, ARGP_KEY_END,
52
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(), ... */
53
66
 
54
67
volatile sig_atomic_t quit_now = 0;
 
68
int signal_received;
55
69
bool debug = false;
56
70
const char *argp_program_version = "password-prompt " VERSION;
57
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
58
 
 
59
 
static void termination_handler(__attribute__((unused))int signum){
 
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
}
 
98
 
 
99
static void termination_handler(int signum){
 
100
  if(quit_now){
 
101
    return;
 
102
  }
60
103
  quit_now = 1;
61
 
}
 
104
  signal_received = signum;
 
105
}
 
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
 
62
229
 
63
230
int main(int argc, char **argv){
64
 
  ssize_t ret;
 
231
  ssize_t sret;
 
232
  int ret;
65
233
  size_t n;
66
234
  struct termios t_new, t_old;
67
235
  char *buffer = NULL;
77
245
        .doc = "Prefix shown before the prompt", .group = 2 },
78
246
      { .name = "debug", .key = 128,
79
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 },
80
257
      { .name = NULL }
81
258
    };
82
259
    
 
260
    __attribute__((nonnull(3)))
83
261
    error_t parse_opt (int key, char *arg, struct argp_state *state){
 
262
      errno = 0;
84
263
      switch (key){
85
264
      case 'p':
86
265
        prefix = arg;
88
267
      case 128:
89
268
        debug = true;
90
269
        break;
91
 
      case ARGP_KEY_ARG:
92
 
        argp_usage(state);
93
 
        break;
94
 
      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);
95
285
        break;
96
286
      default:
97
287
        return ARGP_ERR_UNKNOWN;
98
288
      }
99
 
      return 0;
 
289
      return errno;
100
290
    }
101
291
    
102
292
    struct argp argp = { .options = options, .parser = parse_opt,
103
293
                         .args_doc = "",
104
294
                         .doc = "Mandos password-prompt -- Read and"
105
295
                         " output a password" };
106
 
    ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
107
 
    if(ret == ARGP_ERR_UNKNOWN){
108
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
109
 
      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;
110
308
    }
111
309
  }
112
310
  
113
311
  if(debug){
114
312
    fprintf(stderr, "Starting %s\n", argv[0]);
115
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
  
116
322
  if(debug){
117
323
    fprintf(stderr, "Storing current terminal attributes\n");
118
324
  }
119
325
  
120
326
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
121
 
    perror("tcgetattr");
122
 
    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
    }
123
336
  }
124
337
  
125
338
  sigemptyset(&new_action.sa_mask);
126
 
  sigaddset(&new_action.sa_mask, SIGINT);
127
 
  sigaddset(&new_action.sa_mask, SIGHUP);
128
 
  sigaddset(&new_action.sa_mask, SIGTERM);
 
339
  ret = sigaddset(&new_action.sa_mask, SIGINT);
 
340
  if(ret == -1){
 
341
    error_plus(0, errno, "sigaddset");
 
342
    return EX_OSERR;
 
343
  }
 
344
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
 
345
  if(ret == -1){
 
346
    error_plus(0, errno, "sigaddset");
 
347
    return EX_OSERR;
 
348
  }
 
349
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
 
350
  if(ret == -1){
 
351
    error_plus(0, errno, "sigaddset");
 
352
    return EX_OSERR;
 
353
  }
 
354
  /* Need to check if the handler is SIG_IGN before handling:
 
355
     | [[info:libc:Initial Signal Actions]] |
 
356
     | [[info:libc:Basic Signal Handling]]  |
 
357
  */
129
358
  ret = sigaction(SIGINT, NULL, &old_action);
130
359
  if(ret == -1){
131
 
    perror("sigaction");
132
 
    return EXIT_FAILURE;
 
360
    error_plus(0, errno, "sigaction");
 
361
    return EX_OSERR;
133
362
  }
134
363
  if(old_action.sa_handler != SIG_IGN){
135
364
    ret = sigaction(SIGINT, &new_action, NULL);
136
365
    if(ret == -1){
137
 
      perror("sigaction");
138
 
      return EXIT_FAILURE;
 
366
      error_plus(0, errno, "sigaction");
 
367
      return EX_OSERR;
139
368
    }
140
369
  }
141
370
  ret = sigaction(SIGHUP, NULL, &old_action);
142
371
  if(ret == -1){
143
 
    perror("sigaction");
144
 
    return EXIT_FAILURE;
 
372
    error_plus(0, errno, "sigaction");
 
373
    return EX_OSERR;
145
374
  }
146
375
  if(old_action.sa_handler != SIG_IGN){
147
376
    ret = sigaction(SIGHUP, &new_action, NULL);
148
377
    if(ret == -1){
149
 
      perror("sigaction");
150
 
      return EXIT_FAILURE;
 
378
      error_plus(0, errno, "sigaction");
 
379
      return EX_OSERR;
151
380
    }
152
381
  }
153
382
  ret = sigaction(SIGTERM, NULL, &old_action);
154
383
  if(ret == -1){
155
 
    perror("sigaction");
156
 
    return EXIT_FAILURE;
 
384
    error_plus(0, errno, "sigaction");
 
385
    return EX_OSERR;
157
386
  }
158
387
  if(old_action.sa_handler != SIG_IGN){
159
388
    ret = sigaction(SIGTERM, &new_action, NULL);
160
389
    if(ret == -1){
161
 
      perror("sigaction");
162
 
      return EXIT_FAILURE;
 
390
      error_plus(0, errno, "sigaction");
 
391
      return EX_OSERR;
163
392
    }
164
393
  }
165
394
  
169
398
  }
170
399
  
171
400
  t_new = t_old;
172
 
  t_new.c_lflag &= ~ECHO;
 
401
  t_new.c_lflag &= ~(tcflag_t)ECHO;
173
402
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
174
 
    perror("tcsetattr-echo");
175
 
    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
    }
176
413
  }
177
 
 
 
414
  
178
415
  if(debug){
179
416
    fprintf(stderr, "Waiting for input from stdin \n");
180
417
  }
191
428
      fprintf(stderr, "%s ", prefix);
192
429
    }
193
430
    {
194
 
      const char *cryptsource = getenv("cryptsource");
195
 
      const char *crypttarget = getenv("crypttarget");
196
 
      const char *const prompt
197
 
        = "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";
198
442
      if(cryptsource == NULL){
199
443
        if(crypttarget == NULL){
200
 
          fprintf(stderr, "%s: ", prompt);
 
444
          fprintf(stderr, "%s to unlock the disk: ", prompt2);
201
445
        } else {
202
 
          fprintf(stderr, "%s (%s): ", prompt, crypttarget);
 
446
          fprintf(stderr, "%s (%s)\n%s: ", prompt1, crypttarget,
 
447
                  prompt2);
203
448
        }
204
449
      } else {
205
450
        if(crypttarget == NULL){
206
 
          fprintf(stderr, "%s %s: ", prompt, cryptsource);
 
451
          fprintf(stderr, "%s %s\n%s: ", prompt1, cryptsource,
 
452
                  prompt2);
207
453
        } else {
208
 
          fprintf(stderr, "%s %s (%s): ", prompt, cryptsource,
209
 
                  crypttarget);
 
454
          fprintf(stderr, "%s %s (%s)\n%s: ", prompt1, cryptsource,
 
455
                  crypttarget, prompt2);
210
456
        }
211
457
      }
212
458
    }
213
 
    ret = getline(&buffer, &n, stdin);
214
 
    if(ret > 0){
 
459
    sret = getline(&buffer, &n, stdin);
 
460
    if(sret > 0){
215
461
      status = EXIT_SUCCESS;
216
462
      /* Make n = data size instead of allocated buffer size */
217
 
      n = (size_t)ret;
 
463
      n = (size_t)sret;
218
464
      /* Strip final newline */
219
 
      if(n>0 and buffer[n-1] == '\n'){
 
465
      if(n > 0 and buffer[n-1] == '\n'){
220
466
        buffer[n-1] = '\0';     /* not strictly necessary */
221
467
        n--;
222
468
      }
223
469
      size_t written = 0;
224
470
      while(written < n){
225
 
        ret = write(STDOUT_FILENO, buffer + written, n - written);
226
 
        if(ret < 0){
227
 
          perror("write");
228
 
          status = EXIT_FAILURE;
229
 
          break;
230
 
        }
231
 
        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
        }
232
506
      }
233
507
      break;
234
508
    }
235
 
    if(ret < 0){
 
509
    if(sret < 0){
 
510
      int e = errno;
236
511
      if(errno != EINTR and not feof(stdin)){
237
 
        perror("getline");
238
 
        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
        }
239
523
        break;
240
524
      }
241
525
    }
242
 
    /* if(ret == 0), then the only sensible thing to do is to retry to
243
 
       read from stdin */
 
526
    /* if(sret == 0), then the only sensible thing to do is to retry
 
527
       to read from stdin */
244
528
    fputc('\n', stderr);
245
 
    if(debug and quit_now == 0){
 
529
    if(debug and not quit_now){
246
530
      /* If quit_now is nonzero, we were interrupted by a signal, and
247
531
         will print that later, so no need to show this too. */
248
532
      fprintf(stderr, "getline() returned 0, retrying.\n");
255
539
    fprintf(stderr, "Restoring terminal attributes\n");
256
540
  }
257
541
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
258
 
    perror("tcsetattr+echo");
 
542
    error_plus(0, errno, "tcsetattr+echo");
 
543
  }
 
544
  
 
545
  if(quit_now){
 
546
    sigemptyset(&old_action.sa_mask);
 
547
    old_action.sa_handler = SIG_DFL;
 
548
    ret = sigaction(signal_received, &old_action, NULL);
 
549
    if(ret == -1){
 
550
      error_plus(0, errno, "sigaction");
 
551
    }
 
552
    raise(signal_received);
259
553
  }
260
554
  
261
555
  if(debug){
262
556
    fprintf(stderr, "%s is exiting with status %d\n", argv[0],
263
557
            status);
264
558
  }
265
 
  if(status == EXIT_SUCCESS){
 
559
  if(status == EXIT_SUCCESS or status == EX_OK){
266
560
    fputc('\n', stderr);
267
561
  }
268
562