/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

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