/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: 2008-08-29 05:53:59 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080829055359-wkdasnyxtylmnxus
* mandos.xml (EXAMPLE): Replaced all occurences of command name with
                        "&COMMANDNAME;".

* plugins.d/password-prompt.c (main): Improved some documentation
                                      strings.  Do perror() of
                                      tcgetattr() fails.  Add debug
                                      output if interrupted by signal.
                                      Loop over write() instead of
                                      using fwrite() when outputting
                                      password.  Add debug output if
                                      getline() returns 0, unless it
                                      was caused by a signal.  Add
                                      exit status code to debug
                                      output.

* plugins.d/password-prompt.xml: Changed all single quotes to double
                                 quotes for consistency.  Removed
                                 <?xml-stylesheet>.
  (ENTITY TIMESTAMP): New.  Automatically updated by Emacs time-stamp
                      by using Emacs local variables.
  (/refentry/refentryinfo/title): Changed to "Mandos Manual".
  (/refentry/refentryinfo/productname): Changed to "Mandos".
  (/refentry/refentryinfo/date): New; set to "&TIMESTAMP;".
  (/refentry/refentryinfo/copyright): Split copyright holders.
  (/refentry/refnamediv/refpurpose): Improved wording.
  (SYNOPSIS): Fix to use correct markup.  Add short options.
  (DESCRIPTION, OPTIONS): Improved wording.
  (OPTIONS): Improved wording.  Use more correct markup.  Document
             short options.
  (EXIT STATUS): Add text.
  (ENVIRONMENT): Document use of "cryptsource" and "crypttarget".
  (FILES): REMOVED.
  (BUGS): Add text.
  (EXAMPLE): Added some examples.
  (SECURITY): Added text.
  (SEE ALSO): Remove reference to mandos(8).  Add reference to
              crypttab(5).

Show diffs side-by-side

added added

removed removed

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