/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: 2014-07-25 22:44:20 UTC
  • mto: This revision was merged to the branch mainline in revision 724.
  • Revision ID: teddy@recompile.se-20140725224420-4a5ct2ptt0hsc92z
Require Python 2.7.

This is in preparation for the eventual move to Python 3, which will
happen as soon as all Python modules required by Mandos are available.
The mandos-ctl and mandos-monitor programs are already portable
between Python 2.6 and Python 3 without changes; this change will
bring the requirement up to Python 2.7.

* INSTALL (Prerequisites/Libraries/Mandos Server): Document
                                                   requirement of
                                                   Python 2.7; remove
                                                   Python-argparse
                                                   which is in the
                                                   Python 2.7 standard
                                                   library.
* debian/control (Source: mandos/Build-Depends-Indep): Depend on
                                                       exactly the
                                                       python2.7
                                                       package and all
                                                       the Python 2.7
                                                       versions of the
                                                       python modules.
  (Package: mandos/Depends): - '' - but still depend on python (<=2.7)
                            and the generic versions of the Python
                            modules; this is for mandos-ctl and
                            mandos-monitor, both of which are
                            compatible with Python 3, and use
                            #!/usr/bin/python.
* mandos: Use #!/usr/bin/python2.7 instead of #!/usr/bin/python.

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