/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

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