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

  • Committer: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*  -*- coding: utf-8 -*- */
2
 
/*
3
 
 * Mandos plugin runner - Run Mandos plugins
4
 
 *
5
 
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
 
 * 
7
 
 * This program is free software: you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License as
9
 
 * published by the Free Software Foundation, either version 3 of the
10
 
 * License, or (at your option) any later version.
11
 
 * 
12
 
 * This program is distributed in the hope that it will be useful, but
13
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 
 * General Public License for more details.
16
 
 * 
17
 
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program.  If not, see
19
 
 * <http://www.gnu.org/licenses/>.
20
 
 * 
21
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
22
 
 */
23
 
 
24
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
25
 
 
26
 
#include <stddef.h>             /* size_t, NULL */
27
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
28
 
                                   EXIT_SUCCESS, realloc() */
29
 
#include <stdbool.h>            /* bool, true, false */
30
 
#include <stdio.h>              /* perror, popen(), fileno(),
31
 
                                   fprintf(), stderr, STDOUT_FILENO */
32
 
#include <sys/types.h>          /* DIR, opendir(), stat(), struct
33
 
                                   stat, waitpid(), WIFEXITED(),
34
 
                                   WEXITSTATUS(), wait(), pid_t,
35
 
                                   uid_t, gid_t, getuid(), getgid(),
36
 
                                   dirfd() */
37
 
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
38
 
                                   FD_SET(), FD_ISSET(), FD_CLR */
39
 
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
40
 
                                   WEXITSTATUS() */
41
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
42
 
#include <iso646.h>             /* and, or, not */
43
 
#include <dirent.h>             /* DIR, struct dirent, opendir(),
44
 
                                   readdir(), closedir(), dirfd() */
45
 
#include <unistd.h>             /* struct stat, stat(), S_ISREG(),
46
 
                                   fcntl(), setuid(), setgid(),
47
 
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
48
 
                                   access(), pipe(), fork(), close()
49
 
                                   dup2, STDOUT_FILENO, _exit(),
50
 
                                   execv(), write(), read(),
51
 
                                   close() */
52
 
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
53
 
                                   FD_CLOEXEC */
54
 
#include <string.h>             /* strtok, strlen(), strcpy(),
55
 
                                   strcat() */
56
 
#include <errno.h>              /* errno */
57
 
#include <argp.h>               /* struct argp_option, struct
58
 
                                   argp_state, struct argp,
59
 
                                   argp_parse(), ARGP_ERR_UNKNOWN,
60
 
                                   ARGP_KEY_END, ARGP_KEY_ARG, error_t */
61
 
#include <signal.h>             /* struct sigaction, sigemptyset(),
62
 
                                   sigaddset(), sigaction(),
63
 
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
64
 
                                   SIG_UNBLOCK, kill() */
65
 
#include <errno.h>              /* errno, EBADF */
66
 
 
67
 
#define BUFFER_SIZE 256
68
 
 
69
 
const char *argp_program_version = "mandos-client 1.0";
70
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
1
#include <stdio.h>      /* popen, fileno */
 
2
#include <iso646.h>     /* and, or, not */
 
3
#include <sys/types.h>  /* DIR, opendir, stat, struct stat, waitpid,
 
4
                           WIFEXITED, WEXITSTATUS, wait */
 
5
#include <sys/wait.h>   /* wait */
 
6
#include <dirent.h>     /* DIR, opendir */
 
7
#include <sys/stat.h>   /* stat, struct stat */
 
8
#include <unistd.h>     /* stat, struct stat, chdir */
 
9
#include <stdlib.h>     /* EXIT_FAILURE */
 
10
#include <sys/select.h> /* fd_set, select, FD_ZERO, FD_SET, FD_ISSET */
 
11
#include <string.h>     /* strlen, strcpy, strcat */
 
12
#include <stdbool.h>    /* true */
 
13
#include <sys/wait.h>   /* waitpid, WIFEXITED, WEXITSTATUS */
 
14
#include <errno.h>      /* errno */
71
15
 
72
16
struct process;
73
17
 
75
19
  pid_t pid;
76
20
  int fd;
77
21
  char *buffer;
78
 
  size_t buffer_size;
79
 
  size_t buffer_length;
80
 
  bool eof;
81
 
  bool completed;
82
 
  int status;
 
22
  int buffer_size;
 
23
  int buffer_length;
83
24
  struct process *next;
84
25
} process;
85
26
 
86
 
typedef struct plugin{
87
 
  char *name;                   /* can be NULL or any plugin name */
88
 
  char **argv;
89
 
  int argc;
90
 
  bool disabled;
91
 
  struct plugin *next;
92
 
} plugin;
93
 
 
94
 
static plugin *getplugin(char *name, plugin **plugin_list){
95
 
  for (plugin *p = *plugin_list; p != NULL; p = p->next){
96
 
    if ((p->name == name)
97
 
        or (p->name and name and (strcmp(p->name, name) == 0))){
98
 
      return p;
99
 
    }
100
 
  }
101
 
  /* Create a new plugin */
102
 
  plugin *new_plugin = malloc(sizeof(plugin));
103
 
  if (new_plugin == NULL){
104
 
    perror("malloc");
105
 
    exit(EXIT_FAILURE);
106
 
  }
107
 
  new_plugin->name = name;
108
 
  new_plugin->argv = malloc(sizeof(char *) * 2);
109
 
  if (new_plugin->argv == NULL){
110
 
    perror("malloc");
111
 
    exit(EXIT_FAILURE);
112
 
  }
113
 
  new_plugin->argv[0] = name;
114
 
  new_plugin->argv[1] = NULL;
115
 
  new_plugin->argc = 1;
116
 
  new_plugin->disabled = false;
117
 
  new_plugin->next = *plugin_list;
118
 
  /* Append the new plugin to the list */
119
 
  *plugin_list = new_plugin;
120
 
  return new_plugin;
121
 
}
122
 
 
123
 
static void addargument(plugin *p, char *arg){
124
 
  p->argv[p->argc] = arg;
125
 
  p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
126
 
  if (p->argv == NULL){
127
 
    perror("malloc");
128
 
    exit(EXIT_FAILURE);
129
 
  }
130
 
  p->argc++;
131
 
  p->argv[p->argc] = NULL;
132
 
}
133
 
 
134
 
/*
135
 
 * Based on the example in the GNU LibC manual chapter 13.13 "File
136
 
 * Descriptor Flags".
137
 
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
138
 
 */
139
 
static int set_cloexec_flag(int fd)
140
 
{
141
 
  int ret = fcntl(fd, F_GETFD, 0);
142
 
  /* If reading the flags failed, return error indication now. */
143
 
  if(ret < 0){
144
 
    return ret;
145
 
  }
146
 
  /* Store modified flag word in the descriptor. */
147
 
  return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
148
 
}
149
 
 
150
 
process *process_list = NULL;
151
 
 
152
 
/* Mark a process as completed when it exits, and save its exit
153
 
   status. */
154
 
void handle_sigchld(__attribute__((unused)) int sig){
155
 
  process *proc = process_list;
156
 
  int status;
157
 
  pid_t pid = wait(&status);
158
 
  if(pid == -1){
159
 
    perror("wait");
160
 
    return;
161
 
  }
162
 
  while(proc != NULL and proc->pid != pid){
163
 
    proc = proc->next;
164
 
  }
165
 
  if(proc == NULL){
166
 
    /* Process not found in process list */
167
 
    return;
168
 
  }
169
 
  proc->status = status;
170
 
  proc->completed = true;
171
 
}
172
 
 
173
 
bool print_out_password(const char *buffer, size_t length){
174
 
  ssize_t ret;
175
 
  if(length>0 and buffer[length-1] == '\n'){
176
 
    length--;
177
 
  }
178
 
  for(size_t written = 0; written < length; written += (size_t)ret){
179
 
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
180
 
                                   length - written));
181
 
    if(ret < 0){
182
 
      return false;
183
 
    }
184
 
  }
185
 
  return true;
186
 
}
 
27
#define BUFFER_SIZE 256
187
28
 
188
29
int main(int argc, char *argv[]){
189
 
  const char *plugindir = "/conf/conf.d/mandos/plugins.d";
190
 
  size_t d_name_len;
191
 
  DIR *dir = NULL;
 
30
  char plugindir[] = "plugins.d";
 
31
  size_t d_name_len, plugindir_len = sizeof(plugindir)-1;
 
32
  DIR *dir;
192
33
  struct dirent *dirst;
193
34
  struct stat st;
194
 
  fd_set rfds_all;
 
35
  fd_set rfds_orig;
195
36
  int ret, maxfd = 0;
196
 
  uid_t uid = 65534;
197
 
  gid_t gid = 65534;
198
 
  bool debug = false;
199
 
  int exitstatus = EXIT_SUCCESS;
200
 
  struct sigaction old_sigchld_action;
201
 
  struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
202
 
                                      .sa_flags = SA_NOCLDSTOP };
203
 
  char *plus_options = NULL;
204
 
  char **plus_argv = NULL;
205
 
 
206
 
  /* Establish a signal handler */
207
 
  sigemptyset(&sigchld_action.sa_mask);
208
 
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
209
 
  if(ret < 0){
210
 
    perror("sigaddset");
211
 
    exit(EXIT_FAILURE);
212
 
  }
213
 
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
214
 
  if(ret < 0){
215
 
    perror("sigaction");
216
 
    exit(EXIT_FAILURE);
217
 
  }
218
 
  
219
 
  /* The options we understand. */
220
 
  struct argp_option options[] = {
221
 
    { .name = "global-options", .key = 'g',
222
 
      .arg = "OPTION[,OPTION[,...]]",
223
 
      .doc = "Options passed to all plugins" },
224
 
    { .name = "options-for", .key = 'o',
225
 
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
226
 
      .doc = "Options passed only to specified plugin" },
227
 
    { .name = "disable", .key = 'd',
228
 
      .arg = "PLUGIN",
229
 
      .doc = "Disable a specific plugin", .group = 1 },
230
 
    { .name = "plugin-dir", .key = 128,
231
 
      .arg = "DIRECTORY",
232
 
      .doc = "Specify a different plugin directory", .group = 2 },
233
 
    { .name = "userid", .key = 129,
234
 
      .arg = "ID", .flags = 0,
235
 
      .doc = "User ID the plugins will run as", .group = 2 },
236
 
    { .name = "groupid", .key = 130,
237
 
      .arg = "ID", .flags = 0,
238
 
      .doc = "Group ID the plugins will run as", .group = 2 },
239
 
    { .name = "debug", .key = 131,
240
 
      .doc = "Debug mode", .group = 3 },
241
 
    { .name = NULL }
242
 
  };
243
 
  
244
 
  error_t parse_opt (int key, char *arg, struct argp_state *state) {
245
 
    /* Get the INPUT argument from `argp_parse', which we know is a
246
 
       pointer to our plugin list pointer. */
247
 
    plugin **plugins = state->input;
248
 
    switch (key) {
249
 
    case 'g':
250
 
      if (arg != NULL){
251
 
        char *p = strtok(arg, ",");
252
 
        do{
253
 
          addargument(getplugin(NULL, plugins), p);
254
 
          p = strtok(NULL, ",");
255
 
        } while (p != NULL);
256
 
      }
257
 
      break;
258
 
    case 'o':
259
 
      if (arg != NULL){
260
 
        char *name = strtok(arg, ":");
261
 
        char *p = strtok(NULL, ":");
262
 
        if(p != NULL){
263
 
          p = strtok(p, ",");
264
 
          do{
265
 
            addargument(getplugin(name, plugins), p);
266
 
            p = strtok(NULL, ",");
267
 
          } while (p != NULL);
268
 
        }
269
 
      }
270
 
      break;
271
 
    case 'd':
272
 
      if (arg != NULL){
273
 
        getplugin(arg, plugins)->disabled = true;
274
 
      }
275
 
      break;
276
 
    case 128:
277
 
      plugindir = arg;
278
 
      break;
279
 
    case 129:
280
 
      uid = (uid_t)strtol(arg, NULL, 10);
281
 
      break;
282
 
    case 130:
283
 
      gid = (gid_t)strtol(arg, NULL, 10);
284
 
      break;
285
 
    case 131:
286
 
      debug = true;
287
 
      break;
288
 
    case ARGP_KEY_ARG:
289
 
      if(plus_options != NULL or arg == NULL or arg[0] != '+'){
290
 
        argp_usage (state);
291
 
      }
292
 
      plus_options = arg;
293
 
      break;
294
 
    case ARGP_KEY_END:
295
 
      break;
296
 
    default:
297
 
      return ARGP_ERR_UNKNOWN;
298
 
    }
299
 
    return 0;
300
 
  }
301
 
  
302
 
  plugin *plugin_list = NULL;
303
 
  
304
 
  struct argp argp = { .options = options, .parser = parse_opt,
305
 
                       .args_doc = "[+PLUS_SEPARATED_OPTIONS]",
306
 
                       .doc = "Mandos plugin runner -- Run plugins" };
307
 
  
308
 
  ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
309
 
  if (ret == ARGP_ERR_UNKNOWN){
310
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
311
 
    exitstatus = EXIT_FAILURE;
312
 
    goto end;
313
 
  }
314
 
  
315
 
  if(plus_options){
316
 
    /* This is a mangled argument in the form of
317
 
     "+--option+--other-option=parameter+--yet-another-option", etc */
318
 
    /* Make new argc and argv vars, and call argp_parse() again. */
319
 
    plus_options++;             /* skip the first '+' character */
320
 
    const char delims[] = "+";
321
 
    char *arg;
322
 
    int new_argc = 1;
323
 
    plus_argv = malloc(sizeof(char*) * 2);
324
 
    if(plus_argv == NULL){
325
 
      perror("malloc");
326
 
      exitstatus = EXIT_FAILURE;
327
 
      goto end;
328
 
    }
329
 
    plus_argv[0] = argv[0];
330
 
    plus_argv[1] = NULL;
331
 
    arg = strtok(plus_options, delims); /* Get first argument */
332
 
    while(arg != NULL){
333
 
      new_argc++;
334
 
      plus_argv = realloc(plus_argv, sizeof(char *)
335
 
                         * ((unsigned int) new_argc + 1));
336
 
      if(plus_argv == NULL){
337
 
        perror("realloc");
338
 
        exitstatus = EXIT_FAILURE;
339
 
        goto end;
340
 
      }
341
 
      plus_argv[new_argc-1] = arg;
342
 
      plus_argv[new_argc] = NULL;
343
 
      arg = strtok(NULL, delims); /* Get next argument */
344
 
    }
345
 
    ret = argp_parse (&argp, new_argc, plus_argv, 0, 0, &plugin_list);
346
 
    if (ret == ARGP_ERR_UNKNOWN){
347
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
348
 
      exitstatus = EXIT_FAILURE;
349
 
      goto end;
350
 
    }
351
 
  }
352
 
  
353
 
  if(debug){
354
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
355
 
      fprintf(stderr, "Plugin: %s has %d arguments\n",
356
 
              p->name ? p->name : "Global", p->argc - 1);
357
 
      for(char **a = p->argv; *a != NULL; a++){
358
 
        fprintf(stderr, "\tArg: %s\n", *a);
359
 
      }
360
 
    }
361
 
  }
362
 
  
363
 
  ret = setuid(uid);
364
 
  if (ret == -1){
365
 
    perror("setuid");
366
 
  }
367
 
  
368
 
  setgid(gid);
369
 
  if (ret == -1){
370
 
    perror("setgid");
371
 
  }
 
37
  process *process_list = NULL;
372
38
  
373
39
  dir = opendir(plugindir);
 
40
 
374
41
  if(dir == NULL){
375
 
    perror("Could not open plugin dir");
376
 
    exitstatus = EXIT_FAILURE;
377
 
    goto end;
378
 
  }
379
 
  
380
 
  /* Set the FD_CLOEXEC flag on the directory, if possible */
381
 
  {
382
 
    int dir_fd = dirfd(dir);
383
 
    if(dir_fd >= 0){
384
 
      ret = set_cloexec_flag(dir_fd);
385
 
      if(ret < 0){
386
 
        perror("set_cloexec_flag");
387
 
        exitstatus = EXIT_FAILURE;
388
 
        goto end;
389
 
      }
390
 
    }
391
 
  }
392
 
  
393
 
  FD_ZERO(&rfds_all);
 
42
    fprintf(stderr, "Can not open directory\n");
 
43
    return EXIT_FAILURE;
 
44
  }
 
45
  
 
46
  FD_ZERO(&rfds_orig);
394
47
  
395
48
  while(true){
396
49
    dirst = readdir(dir);
397
50
    
398
51
    // All directory entries have been processed
399
52
    if(dirst == NULL){
400
 
      if (errno == EBADF){
401
 
        perror("readdir");
402
 
        exitstatus = EXIT_FAILURE;
403
 
        goto end;
404
 
      }
405
53
      break;
406
54
    }
407
55
    
408
56
    d_name_len = strlen(dirst->d_name);
409
57
    
410
 
    // Ignore dotfiles, backup files and other junk
411
 
    {
412
 
      bool bad_name = false;
413
 
      
414
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
415
 
      
416
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
417
 
                                           ".dpkg-old",
418
 
                                           ".dpkg-divert", NULL };
419
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
420
 
        size_t pre_len = strlen(*pre);
421
 
        if((d_name_len >= pre_len)
422
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
423
 
          if(debug){
424
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
425
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
426
 
          }
427
 
          bad_name = true;
428
 
          break;
429
 
        }
430
 
      }
431
 
      
432
 
      if(bad_name){
433
 
        continue;
434
 
      }
435
 
      
436
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
437
 
        size_t suf_len = strlen(*suf);
438
 
        if((d_name_len >= suf_len)
439
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
440
 
                == 0)){
441
 
          if(debug){
442
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
443
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
444
 
          }
445
 
          bad_name = true;
446
 
          break;
447
 
        }
448
 
      }
449
 
      
450
 
      if(bad_name){
451
 
        continue;
452
 
      }
453
 
    }
454
 
    
455
 
    char *filename = malloc(d_name_len + strlen(plugindir) + 2);
456
 
    if (filename == NULL){
457
 
      perror("malloc");
458
 
      exitstatus = EXIT_FAILURE;
459
 
      goto end;
460
 
    }
461
 
    strcpy(filename, plugindir); /* Spurious warning */
462
 
    strcat(filename, "/");      /* Spurious warning */
463
 
    strcat(filename, dirst->d_name); /* Spurious warning */
464
 
    
465
 
    ret = stat(filename, &st);
466
 
    if (ret == -1){
467
 
      perror("stat");
468
 
      exitstatus = EXIT_FAILURE;
469
 
      goto end;
470
 
    }
471
 
    
472
 
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
473
 
      if(debug){
474
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
475
 
                " with bad type or mode\n", filename);
476
 
      }
477
 
      free(filename);
478
 
      continue;
479
 
    }
480
 
    if(getplugin(dirst->d_name, &plugin_list)->disabled){
481
 
      if(debug){
482
 
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
483
 
                dirst->d_name);
484
 
      }
485
 
      free(filename);
486
 
      continue;
487
 
    }
488
 
    plugin *p = getplugin(dirst->d_name, &plugin_list);
489
 
    {
490
 
      /* Add global arguments to argument list for this plugin */
491
 
      plugin *g = getplugin(NULL, &plugin_list);
492
 
      for(char **a = g->argv + 1; *a != NULL; a++){
493
 
        addargument(p, *a);
494
 
      }
495
 
    }
496
 
    int pipefd[2]; 
497
 
    ret = pipe(pipefd);
498
 
    if (ret == -1){
499
 
      perror("pipe");
500
 
      exitstatus = EXIT_FAILURE;
501
 
      goto end;
502
 
    }
503
 
    ret = set_cloexec_flag(pipefd[0]);
504
 
    if(ret < 0){
505
 
      perror("set_cloexec_flag");
506
 
      exitstatus = EXIT_FAILURE;
507
 
      goto end;
508
 
    }
509
 
    ret = set_cloexec_flag(pipefd[1]);
510
 
    if(ret < 0){
511
 
      perror("set_cloexec_flag");
512
 
      exitstatus = EXIT_FAILURE;
513
 
      goto end;
514
 
    }
515
 
    /* Block SIGCHLD until process is safely in process list */
516
 
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
517
 
    if(ret < 0){
518
 
      perror("sigprocmask");
519
 
      exitstatus = EXIT_FAILURE;
520
 
      goto end;
521
 
    }
522
 
    // Starting a new process to be watched
523
 
    pid_t pid = fork();
524
 
    if(pid == 0){
525
 
      /* this is the child process */
526
 
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
527
 
      if(ret < 0){
528
 
        perror("sigaction");
529
 
        _exit(EXIT_FAILURE);
530
 
      }
531
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
532
 
      if(ret < 0){
533
 
        perror("sigprocmask");
534
 
        _exit(EXIT_FAILURE);
535
 
      }
 
58
    // Ignore dotfiles and backup files
 
59
    if (dirst->d_name[0] == '.'
 
60
        or dirst->d_name[d_name_len - 1] == '~'){
 
61
      continue;
 
62
    }
 
63
    
 
64
    char *filename = malloc(d_name_len + plugindir_len + 1);
 
65
    strcpy(filename, plugindir);
 
66
    strcat(filename, "/");
 
67
    strcat(filename, dirst->d_name);    
 
68
    
 
69
    stat(filename, &st);
536
70
 
537
 
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
538
 
      if(ret == -1){
539
 
        perror("dup2");
540
 
        _exit(EXIT_FAILURE);
541
 
      }
542
 
      
543
 
      if(dirfd(dir) < 0){
544
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
545
 
           above and must now close it manually here. */
 
71
    if (S_ISREG(st.st_mode) and (access(filename, X_OK) == 0)){
 
72
      // Starting a new process to be watched
 
73
      process *new_process = malloc(sizeof(process));
 
74
      int pipefd[2];
 
75
      pipe(pipefd);
 
76
      new_process->pid = fork();
 
77
      if(new_process->pid == 0){
 
78
        /* this is the child process */
546
79
        closedir(dir);
547
 
      }
548
 
      if(execv(filename, p->argv) < 0){
549
 
        perror("execv");
550
 
        _exit(EXIT_FAILURE);
551
 
      }
552
 
      /* no return */
553
 
    }
554
 
    /* parent process */
555
 
    free(filename);
556
 
    close(pipefd[1]);           /* close unused write end of pipe */
557
 
    process *new_process = malloc(sizeof(process));
558
 
    if (new_process == NULL){
559
 
      perror("malloc");
560
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
561
 
      if(ret < 0){
562
 
        perror("sigprocmask");
563
 
      }
564
 
      exitstatus = EXIT_FAILURE;
565
 
      goto end;
566
 
    }
567
 
    
568
 
    *new_process = (struct process){ .pid = pid,
569
 
                                     .fd = pipefd[0],
570
 
                                     .next = process_list };
571
 
    // List handling
572
 
    process_list = new_process;
573
 
    /* Unblock SIGCHLD so signal handler can be run if this process
574
 
       has already completed */
575
 
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
576
 
    if(ret < 0){
577
 
      perror("sigprocmask");
578
 
      exitstatus = EXIT_FAILURE;
579
 
      goto end;
580
 
    }
581
 
    
582
 
    FD_SET(new_process->fd, &rfds_all);
583
 
    
584
 
    if (maxfd < new_process->fd){
585
 
      maxfd = new_process->fd;
586
 
    }
587
 
    
588
 
  }
589
 
  
590
 
  /* Free the plugin list */
591
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
592
 
    next = plugin_list->next;
593
 
    free(plugin_list->argv);
594
 
    free(plugin_list);
 
80
        close(pipefd[0]);       /* close unused read end of pipe */
 
81
        dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
 
82
        /* create a new modified argument list */
 
83
        char **new_argv = malloc(sizeof(char *) * argc + 1);
 
84
        new_argv[0] = filename;
 
85
        for(int i = 1; i < argc; i++){
 
86
          new_argv[i] = argv[i];
 
87
        }
 
88
        new_argv[argc] = NULL;
 
89
        if(execv(filename, new_argv) < 0){
 
90
          perror(argv[0]);
 
91
          close(pipefd[1]);
 
92
          exit(EXIT_FAILURE);
 
93
        }
 
94
        /* no return */
 
95
      }
 
96
      close(pipefd[1]);         /* close unused write end of pipe */
 
97
      new_process->fd = pipefd[0];
 
98
      new_process->buffer = malloc(BUFFER_SIZE);
 
99
      if (new_process->buffer == NULL){
 
100
        perror(argv[0]);
 
101
        goto end;
 
102
      }
 
103
      new_process->buffer_size = BUFFER_SIZE;
 
104
      new_process->buffer_length = 0;
 
105
      FD_SET(new_process->fd, &rfds_orig);
 
106
      
 
107
      if (maxfd < new_process->fd){
 
108
        maxfd = new_process->fd;
 
109
      }
 
110
      
 
111
      //List handling
 
112
      new_process->next = process_list;
 
113
      process_list = new_process;
 
114
    }
595
115
  }
596
116
  
597
117
  closedir(dir);
598
 
  dir = NULL;
599
 
    
600
 
  if (process_list == NULL){
601
 
    fprintf(stderr, "No plugin processes started. Incorrect plugin"
602
 
            " directory?\n");
603
 
    process_list = NULL;
604
 
  }
605
 
  while(process_list){
606
 
    fd_set rfds = rfds_all;
607
 
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
608
 
    if (select_ret == -1){
609
 
      perror("select");
610
 
      exitstatus = EXIT_FAILURE;
611
 
      goto end;
612
 
    }
613
 
    /* OK, now either a process completed, or something can be read
614
 
       from one of them */
615
 
    for(process *proc = process_list; proc ; proc = proc->next){
616
 
      /* Is this process completely done? */
617
 
      if(proc->eof and proc->completed){
618
 
        /* Only accept the plugin output if it exited cleanly */
619
 
        if(not WIFEXITED(proc->status)
620
 
           or WEXITSTATUS(proc->status) != 0){
621
 
          /* Bad exit by plugin */
622
 
          if(debug){
623
 
            if(WIFEXITED(proc->status)){
624
 
              fprintf(stderr, "Plugin %u exited with status %d\n",
625
 
                      (unsigned int) (proc->pid),
626
 
                      WEXITSTATUS(proc->status));
627
 
            } else if(WIFSIGNALED(proc->status)) {
628
 
              fprintf(stderr, "Plugin %u killed by signal %d\n",
629
 
                      (unsigned int) (proc->pid),
630
 
                      WTERMSIG(proc->status));
631
 
            } else if(WCOREDUMP(proc->status)){
632
 
              fprintf(stderr, "Plugin %d dumped core\n",
633
 
                      (unsigned int) (proc->pid));
 
118
  
 
119
  if (process_list != NULL){
 
120
    while(true){
 
121
      fd_set rfds = rfds_orig;
 
122
      int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
 
123
      if (select_ret == -1){
 
124
        perror(argv[0]);
 
125
        goto end;
 
126
      }else{    
 
127
        for(process *process_itr = process_list; process_itr != NULL;
 
128
            process_itr = process_itr->next){
 
129
          if(FD_ISSET(process_itr->fd, &rfds)){
 
130
            if(process_itr->buffer_length + BUFFER_SIZE
 
131
               > process_itr->buffer_size){
 
132
                process_itr->buffer = realloc(process_itr->buffer,
 
133
                                              process_itr->buffer_size
 
134
                                              + BUFFER_SIZE);
 
135
                if (process_itr->buffer == NULL){
 
136
                  perror(argv[0]);
 
137
                  goto end;
 
138
                }
 
139
                process_itr->buffer_size += BUFFER_SIZE;
634
140
            }
635
 
          }
636
 
          /* Remove the plugin */
637
 
          FD_CLR(proc->fd, &rfds_all);
638
 
          /* Block signal while modifying process_list */
639
 
          ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
640
 
          if(ret < 0){
641
 
            perror("sigprocmask");
642
 
            exitstatus = EXIT_FAILURE;
643
 
            goto end;
644
 
          }
645
 
          /* Delete this process entry from the list */
646
 
          if(process_list == proc){
647
 
            /* First one - simple */
648
 
            process_list = proc->next;
649
 
          } else {
650
 
            /* Second one or later */
651
 
            for(process *p = process_list; p != NULL; p = p->next){
652
 
              if(p->next == proc){
653
 
                p->next = proc->next;
654
 
                break;
 
141
            ret = read(process_itr->fd, process_itr->buffer
 
142
                       + process_itr->buffer_length, BUFFER_SIZE);
 
143
            process_itr->buffer_length+=ret;
 
144
            if(ret == 0){
 
145
              /* got EOF */
 
146
              /* wait for process exit */
 
147
              int status;
 
148
              waitpid(process_itr->pid, &status, 0);
 
149
              if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
 
150
                write(STDOUT_FILENO, process_itr->buffer,
 
151
                      process_itr->buffer_length);
 
152
                goto end;
 
153
              } else {
 
154
                FD_CLR(process_itr->fd, &rfds_orig);
655
155
              }
656
156
            }
657
157
          }
658
 
          /* We are done modifying process list, so unblock signal */
659
 
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
660
 
                             NULL);
661
 
          if(ret < 0){
662
 
            perror("sigprocmask");
663
 
          }
664
 
          free(proc->buffer);
665
 
          free(proc);
666
 
          /* We deleted this process from the list, so we can't go
667
 
             proc->next.  Therefore, start over from the beginning of
668
 
             the process list */
669
 
          break;
670
 
        }
671
 
        /* This process exited nicely, so print its buffer */
672
 
 
673
 
        bool bret = print_out_password(proc->buffer, proc->buffer_length);
674
 
        if(not bret){
675
 
          perror("print_out_password");
676
 
          exitstatus = EXIT_FAILURE;
677
 
        }
678
 
        goto end;
679
 
      }
680
 
      /* This process has not completed.  Does it have any output? */
681
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
682
 
        /* This process had nothing to say at this time */
683
 
        continue;
684
 
      }
685
 
      /* Before reading, make the process' data buffer large enough */
686
 
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
687
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
688
 
                               + (size_t) BUFFER_SIZE);
689
 
        if (proc->buffer == NULL){
690
 
          perror("malloc");
691
 
          exitstatus = EXIT_FAILURE;
692
 
          goto end;
693
 
        }
694
 
        proc->buffer_size += BUFFER_SIZE;
695
 
      }
696
 
      /* Read from the process */
697
 
      ret = read(proc->fd, proc->buffer + proc->buffer_length,
698
 
                 BUFFER_SIZE);
699
 
      if(ret < 0){
700
 
        /* Read error from this process; ignore the error */
701
 
        continue;
702
 
      }
703
 
      if(ret == 0){
704
 
        /* got EOF */
705
 
        proc->eof = true;
706
 
      } else {
707
 
        proc->buffer_length += (size_t) ret;
 
158
        }
708
159
      }
709
160
    }
710
161
  }
711
 
 
712
 
 
 
162
  
713
163
 end:
714
 
  
715
 
  if(process_list == NULL or exitstatus != EXIT_SUCCESS){
716
 
    /* Fallback if all plugins failed or an error occured */
717
 
    bool bret;
718
 
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
719
 
    char *passwordbuffer = getpass("Password: ");
720
 
    bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
721
 
    if(not bret){
722
 
      perror("print_out_password");
723
 
      exitstatus = EXIT_FAILURE;
724
 
      goto end;
725
 
    }
726
 
  }
727
 
  
728
 
  /* Restore old signal handler */
729
 
  sigaction(SIGCHLD, &old_sigchld_action, NULL);
730
 
  
731
 
  free(plus_argv);
732
 
  
733
 
  /* Free the plugin list */
734
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
735
 
    next = plugin_list->next;
736
 
    free(plugin_list->argv);
737
 
    free(plugin_list);
738
 
  }
739
 
  
740
 
  if(dir != NULL){
741
 
    closedir(dir);
742
 
  }
743
 
  
744
 
  /* Free the process list and kill the processes */
745
 
  for(process *next; process_list != NULL; process_list = next){
746
 
    next = process_list->next;
747
 
    close(process_list->fd);
748
 
    ret = kill(process_list->pid, SIGTERM);
749
 
    if(ret == -1 and errno != ESRCH){
750
 
      /* set-uid proccesses migth not get closed */
751
 
      perror("kill");
752
 
    }
753
 
    free(process_list->buffer);
754
 
    free(process_list);
755
 
  }
756
 
  
757
 
  /* Wait for any remaining child processes to terminate */
758
 
  do{
759
 
    ret = wait(NULL);
760
 
  } while(ret >= 0);
761
 
  if(errno != ECHILD){
762
 
    perror("wait");
763
 
  }
764
 
  
765
 
  return exitstatus;
 
164
  for(process *process_itr = process_list; process_itr != NULL;
 
165
      process_itr = process_itr->next){
 
166
    close(process_itr->fd);
 
167
    kill(process_itr->pid, SIGTERM);
 
168
    free(process_itr->buffer);
 
169
  }
 
170
  
 
171
  while(true){
 
172
    int status;
 
173
    ret = wait(&status);
 
174
    if (ret == -1){
 
175
      if(errno != ECHILD){
 
176
        perror("wait");
 
177
      }
 
178
      break;
 
179
    }
 
180
  }  
 
181
  return EXIT_SUCCESS;
766
182
}