/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-12-10 01:26:02 UTC
  • mfrom: (237.1.2 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20081210012602-vhz3h75xkj24t340
First version of a somewhat complete D-Bus server interface.  Also
change user/group name to "_mandos".

* debian/mandos.postinst: Rename old "mandos" user and group to
                          "_mandos"; create "_mandos" user and group
                          if none exist.
* debian/mandos-client.postinst: - '' -

* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
                        group name.

* mandos (_datetime_to_dbus_struct): New; was previously local.
  (Client.started): Renamed to "last_started".  All users changed.
  (Client.started): New; boolean.
  (Client.dbus_object_path): New.
  (Client.check_command): Renamed to "checker_command".  All users
                          changed.
  (Client.__init__): Set and use "self.dbus_object_path".  Set
                     "self.started".
  (Client.start): Update "self.started".  Emit "self.PropertyChanged"
                  signals for both "started" and "last_started".
  (Client.stop): Update "self.started".  Emit "self.PropertyChanged"
                 signal for "started".
  (Client.checker_callback): Take additional "command" argument.  All
                             callers changed. Emit
                             "self.PropertyChanged" signal.
  (Client.bump_timeout): Emit "self.PropertyChanged" signal for
                         "last_checked_ok".
  (Client.start_checker): Emit "self.PropertyChanged" signal for
                          "checker_running".
  (Client.stop_checker): Emit "self.PropertyChanged" signal for
                         "checker_running".
  (Client.still_valid): Bug fix: use "getattr(self, started, False)"
                        instead of "self.started" in case this client
                        object is so new that the "started" attribute
                        has not been created yet.
  (Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
  Client.GetCreated, Client.GetFingerprint, Client.GetHost,
  Client.GetInterval, Client.GetName, Client.GetStarted,
  Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
  Removed; all callers changed.
  (Client.CheckerCompleted): Add "condition" and "command" arguments.
                             All callers changed.
  (Client.GetAllProperties, Client.PropertyChanged): New.
  (Client.StillValid): Renamed to "IsStillValid".
  (Client.StartChecker): Changed to its own function to avoid the
                         return value from "Client.start_checker()".
  (Client.Stop): Changed to its own function to avoid the return value
                 from "Client.stop()".
  (main): Try "_mandos" before "mandos" as user and group name.
          Removed inner function "remove_from_clients".  New inner
          class "MandosServer".

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