/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/passprompt.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-02 10:48:24 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080802104824-fx0miwp9o4g9r31e
* plugbasedclient.c (struct process): New fields "eof", "completed",
                                      and "status".
  (handle_sigchld): New function.
  (main): Initialize "dir" to NULL to only closedir() it if necessary.
          Move "process_list" to be a global variable to be accessible
          by "handle_sigchld".  Make "handle_sigchld" handle SIGCHLD.
          Remove redundant check for NULL "dir".  Free "filename" when
          no longer used.  Block SIGCHLD around fork()/exec().
          Restore normal signals in child.  Only loop while running
          processes exist.  Print process buffer when the process is
          done and it has emitted EOF, not when it only emits EOF.
          Remove processes from list which exit non-cleanly.  In
          cleaning up, closedir() if necessary.  Bug fix: set next
          pointer correctly when freeing process list.

* plugins.d/passprompt.c (main): Do not ignore SIGQUIT.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/passprompt.c
1
1
/*  -*- coding: utf-8 -*- */
2
2
/*
3
3
 * Passprompt - Read a password from the terminal and print it
4
 
 * 
5
 
 * Copyright © 2008,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 Björn Påhlsson
 
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
34
33
                                   sigaction, sigemptyset(),
35
34
                                   sigaction(), sigaddset(), SIGINT,
36
35
                                   SIGQUIT, SIGHUP, SIGTERM */
37
 
#include <stddef.h>             /* NULL, size_t, ssize_t */
 
36
#include <stddef.h>             /* NULL, size_t */
38
37
#include <sys/types.h>          /* ssize_t */
39
38
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
40
 
                                   getopt_long, getenv() */
 
39
                                   getopt_long */
41
40
#include <stdio.h>              /* fprintf(), stderr, getline(),
42
41
                                   stdin, feof(), perror(), fputc(),
43
42
                                   stdout, getopt_long */
45
44
#include <iso646.h>             /* or, not */
46
45
#include <stdbool.h>            /* bool, false, true */
47
46
#include <string.h>             /* strlen, rindex, strncmp, strcmp */
48
 
#include <argp.h>               /* struct argp_option, struct
49
 
                                   argp_state, struct argp,
50
 
                                   argp_parse(), error_t,
51
 
                                   ARGP_KEY_ARG, ARGP_KEY_END,
52
 
                                   ARGP_ERR_UNKNOWN */
 
47
#include <getopt.h>             /* getopt_long */
53
48
 
54
49
volatile bool quit_now = false;
55
50
bool debug = false;
56
 
const char *argp_program_version = "password-prompt " VERSION;
57
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
58
51
 
59
 
static void termination_handler(__attribute__((unused))int signum){
 
52
void termination_handler(__attribute__((unused))int signum){
60
53
  quit_now = true;
61
54
}
62
55
 
70
63
  struct sigaction old_action,
71
64
    new_action = { .sa_handler = termination_handler,
72
65
                   .sa_flags = 0 };
73
 
  {
74
 
    struct argp_option options[] = {
75
 
      { .name = "prefix", .key = 'p',
76
 
        .arg = "PREFIX", .flags = 0,
77
 
        .doc = "Prefix shown before the prompt", .group = 2 },
78
 
      { .name = "debug", .key = 128,
79
 
        .doc = "Debug mode", .group = 3 },
80
 
      { .name = NULL }
81
 
    };
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) {
87
 
      case 'p':
88
 
        prefix = arg;
89
 
        break;
90
 
      case 128:
91
 
        debug = true;
92
 
        break;
93
 
      case ARGP_KEY_ARG:
94
 
        argp_usage (state);
95
 
        break;
96
 
      case ARGP_KEY_END:
97
 
        break;
98
 
      default:
99
 
        return ARGP_ERR_UNKNOWN;
100
 
      }
101
 
      return 0;
 
66
 
 
67
  while (true){
 
68
    static struct option long_options[] = {
 
69
      {"debug", no_argument, (int *)&debug, 1},
 
70
      {"prefix", required_argument, 0, 'p'},
 
71
      {0, 0, 0, 0} };
 
72
 
 
73
    int option_index = 0;
 
74
    ret = getopt_long (argc, argv, "p:", long_options, &option_index);
 
75
 
 
76
    if (ret == -1){
 
77
      break;
102
78
    }
103
 
    
104
 
    struct argp argp = { .options = options, .parser = parse_opt,
105
 
                         .args_doc = "",
106
 
                         .doc = "Mandos password-prompt -- Read and"
107
 
                         " output a password" };
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;
 
79
      
 
80
    switch(ret){
 
81
    case 0:
 
82
      break;
 
83
    case 'p':
 
84
      prefix = optarg;
 
85
      break;
 
86
    default:
 
87
      fprintf(stderr, "bad arguments\n");
 
88
      exit(EXIT_FAILURE);
112
89
    }
113
90
  }
114
 
  
 
91
      
115
92
  if (debug){
116
93
    fprintf(stderr, "Starting %s\n", argv[0]);
117
94
  }
120
97
  }
121
98
  
122
99
  if (tcgetattr(STDIN_FILENO, &t_old) != 0){
123
 
    perror("tcgetattr");
124
100
    return EXIT_FAILURE;
125
101
  }
126
102
  
128
104
  sigaddset(&new_action.sa_mask, SIGINT);
129
105
  sigaddset(&new_action.sa_mask, SIGHUP);
130
106
  sigaddset(&new_action.sa_mask, SIGTERM);
131
 
  ret = sigaction(SIGINT, NULL, &old_action);
132
 
  if(ret == -1){
133
 
    perror("sigaction");
134
 
    return EXIT_FAILURE;
135
 
  }
136
 
  if (old_action.sa_handler != SIG_IGN){
137
 
    ret = sigaction(SIGINT, &new_action, NULL);
138
 
    if(ret == -1){
139
 
      perror("sigaction");
140
 
      return EXIT_FAILURE;
141
 
    }
142
 
  }
143
 
  ret = sigaction(SIGHUP, NULL, &old_action);
144
 
  if(ret == -1){
145
 
    perror("sigaction");
146
 
    return EXIT_FAILURE;
147
 
  }
148
 
  if (old_action.sa_handler != SIG_IGN){
149
 
    ret = sigaction(SIGHUP, &new_action, NULL);
150
 
    if(ret == -1){
151
 
      perror("sigaction");
152
 
      return EXIT_FAILURE;
153
 
    }
154
 
  }
155
 
  ret = sigaction(SIGTERM, NULL, &old_action);
156
 
  if(ret == -1){
157
 
    perror("sigaction");
158
 
    return EXIT_FAILURE;
159
 
  }
160
 
  if (old_action.sa_handler != SIG_IGN){
161
 
    ret = sigaction(SIGTERM, &new_action, NULL);
162
 
    if(ret == -1){
163
 
      perror("sigaction");
164
 
      return EXIT_FAILURE;
165
 
    }
166
 
  }
167
 
  
 
107
  sigaction(SIGINT, NULL, &old_action);
 
108
  if (old_action.sa_handler != SIG_IGN)
 
109
    sigaction(SIGINT, &new_action, NULL);
 
110
  sigaction(SIGHUP, NULL, &old_action);
 
111
  if (old_action.sa_handler != SIG_IGN)
 
112
    sigaction(SIGHUP, &new_action, NULL);
 
113
  sigaction(SIGTERM, NULL, &old_action);
 
114
  if (old_action.sa_handler != SIG_IGN)
 
115
    sigaction(SIGTERM, &new_action, NULL);
 
116
 
168
117
  
169
118
  if (debug){
170
119
    fprintf(stderr, "Removing echo flag from terminal attributes\n");
182
131
  }
183
132
  while(true){
184
133
    if (quit_now){
185
 
      if(debug){
186
 
        fprintf(stderr, "Interrupted by signal, exiting.\n");
187
 
      }
188
134
      status = EXIT_FAILURE;
189
135
      break;
190
136
    }
191
137
 
192
138
    if(prefix){
193
 
      fprintf(stderr, "%s ", prefix);
194
 
    }
195
 
    {
196
 
      const char *cryptsource = getenv("cryptsource");
197
 
      const char *crypttarget = getenv("crypttarget");
198
 
      const char *const prompt
199
 
        = "Enter passphrase to unlock the disk";
200
 
      if(cryptsource == NULL){
201
 
        if(crypttarget == NULL){
202
 
          fprintf(stderr, "%s: ", prompt);
203
 
        } else {
204
 
          fprintf(stderr, "%s (%s): ", prompt, crypttarget);
205
 
        }
206
 
      } else {
207
 
        if(crypttarget == NULL){
208
 
          fprintf(stderr, "%s %s: ", prompt, cryptsource);
209
 
        } else {
210
 
          fprintf(stderr, "%s %s (%s): ", prompt, cryptsource,
211
 
                  crypttarget);
212
 
        }
213
 
      }
214
 
    }
 
139
      fprintf(stderr, "%s Password: ", prefix);
 
140
    } else {
 
141
      fprintf(stderr, "Password: ");
 
142
    }      
215
143
    ret = getline(&buffer, &n, stdin);
216
144
    if (ret > 0){
 
145
      fprintf(stdout, "%s", buffer);
217
146
      status = EXIT_SUCCESS;
218
 
      /* Make n = data size instead of allocated buffer size */
219
 
      n = (size_t)ret;
220
 
      /* Strip final newline */
221
 
      if(n>0 and buffer[n-1] == '\n'){
222
 
        buffer[n-1] = '\0';     /* not strictly necessary */
223
 
        n--;
224
 
      }
225
 
      size_t written = 0;
226
 
      while(written < n){
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;
234
 
      }
235
147
      break;
236
148
    }
 
149
    // ret == 0 makes no other sence than to retry to read from stdin
237
150
    if (ret < 0){
238
151
      if (errno != EINTR and not feof(stdin)){
239
152
        perror("getline");
241
154
        break;
242
155
      }
243
156
    }
244
 
    /* if(ret == 0), then the only sensible thing to do is to retry to
245
 
       read from stdin */
246
157
    fputc('\n', stderr);
247
 
    if(debug and not quit_now){
248
 
      /* If quit_now is true, we were interrupted by a signal, and
249
 
         will print that later, so no need to show this too. */
250
 
      fprintf(stderr, "getline() returned 0, retrying.\n");
251
 
    }
252
158
  }
253
 
  
254
 
  free(buffer);
255
 
  
 
159
 
256
160
  if (debug){
257
161
    fprintf(stderr, "Restoring terminal attributes\n");
258
162
  }
259
163
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
260
164
    perror("tcsetattr+echo");
261
165
  }
262
 
  
 
166
 
263
167
  if (debug){
264
 
    fprintf(stderr, "%s is exiting with status %d\n", argv[0],
265
 
            status);
266
 
  }
267
 
  if(status == EXIT_SUCCESS){
268
 
    fputc('\n', stderr);
 
168
    fprintf(stderr, "%s is exiting\n", argv[0]);
269
169
  }
270
170
  
271
171
  return status;