/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
 
      continue;
459
 
    }
460
 
    strcpy(filename, plugindir); /* Spurious warning */
461
 
    strcat(filename, "/");      /* Spurious warning */
462
 
    strcat(filename, dirst->d_name); /* Spurious warning */
463
 
    
464
 
    ret = stat(filename, &st);
465
 
    if (ret == -1){
466
 
      perror("stat");
467
 
      free(filename);
468
 
      continue;
469
 
    }
470
 
    
471
 
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
472
 
      if(debug){
473
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
474
 
                " with bad type or mode\n", filename);
475
 
      }
476
 
      free(filename);
477
 
      continue;
478
 
    }
479
 
    if(getplugin(dirst->d_name, &plugin_list)->disabled){
480
 
      if(debug){
481
 
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
482
 
                dirst->d_name);
483
 
      }
484
 
      free(filename);
485
 
      continue;
486
 
    }
487
 
    plugin *p = getplugin(dirst->d_name, &plugin_list);
488
 
    {
489
 
      /* Add global arguments to argument list for this plugin */
490
 
      plugin *g = getplugin(NULL, &plugin_list);
491
 
      for(char **a = g->argv + 1; *a != NULL; a++){
492
 
        addargument(p, *a);
493
 
      }
494
 
    }
495
 
    int pipefd[2]; 
496
 
    ret = pipe(pipefd);
497
 
    if (ret == -1){
498
 
      perror("pipe");
499
 
      exitstatus = EXIT_FAILURE;
500
 
      goto end;
501
 
    }
502
 
    ret = set_cloexec_flag(pipefd[0]);
503
 
    if(ret < 0){
504
 
      perror("set_cloexec_flag");
505
 
      exitstatus = EXIT_FAILURE;
506
 
      goto end;
507
 
    }
508
 
    ret = set_cloexec_flag(pipefd[1]);
509
 
    if(ret < 0){
510
 
      perror("set_cloexec_flag");
511
 
      exitstatus = EXIT_FAILURE;
512
 
      goto end;
513
 
    }
514
 
    /* Block SIGCHLD until process is safely in process list */
515
 
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
516
 
    if(ret < 0){
517
 
      perror("sigprocmask");
518
 
      exitstatus = EXIT_FAILURE;
519
 
      goto end;
520
 
    }
521
 
    // Starting a new process to be watched
522
 
    pid_t pid = fork();
523
 
    if(pid == -1){
524
 
      perror("fork");
525
 
      exitstatus = EXIT_FAILURE;
526
 
      goto end;
527
 
    }
528
 
    if(pid == 0){
529
 
      /* this is the child process */
530
 
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
531
 
      if(ret < 0){
532
 
        perror("sigaction");
533
 
        _exit(EXIT_FAILURE);
534
 
      }
535
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
536
 
      if(ret < 0){
537
 
        perror("sigprocmask");
538
 
        _exit(EXIT_FAILURE);
539
 
      }
 
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);
540
70
 
541
 
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
542
 
      if(ret == -1){
543
 
        perror("dup2");
544
 
        _exit(EXIT_FAILURE);
545
 
      }
546
 
      
547
 
      if(dirfd(dir) < 0){
548
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
549
 
           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 */
550
79
        closedir(dir);
551
 
      }
552
 
      if(execv(filename, p->argv) < 0){
553
 
        perror("execv");
554
 
        _exit(EXIT_FAILURE);
555
 
      }
556
 
      /* no return */
557
 
    }
558
 
    /* parent process */
559
 
    free(filename);
560
 
    close(pipefd[1]);           /* close unused write end of pipe */
561
 
    process *new_process = malloc(sizeof(process));
562
 
    if (new_process == NULL){
563
 
      perror("malloc");
564
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
565
 
      if(ret < 0){
566
 
        perror("sigprocmask");
567
 
      }
568
 
      exitstatus = EXIT_FAILURE;
569
 
      goto end;
570
 
    }
571
 
    
572
 
    *new_process = (struct process){ .pid = pid,
573
 
                                     .fd = pipefd[0],
574
 
                                     .next = process_list };
575
 
    // List handling
576
 
    process_list = new_process;
577
 
    /* Unblock SIGCHLD so signal handler can be run if this process
578
 
       has already completed */
579
 
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
580
 
    if(ret < 0){
581
 
      perror("sigprocmask");
582
 
      exitstatus = EXIT_FAILURE;
583
 
      goto end;
584
 
    }
585
 
    
586
 
    FD_SET(new_process->fd, &rfds_all);
587
 
    
588
 
    if (maxfd < new_process->fd){
589
 
      maxfd = new_process->fd;
590
 
    }
591
 
    
592
 
  }
593
 
  
594
 
  /* Free the plugin list */
595
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
596
 
    next = plugin_list->next;
597
 
    free(plugin_list->argv);
598
 
    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
    }
599
115
  }
600
116
  
601
117
  closedir(dir);
602
 
  dir = NULL;
603
 
    
604
 
  if (process_list == NULL){
605
 
    fprintf(stderr, "No plugin processes started. Incorrect plugin"
606
 
            " directory?\n");
607
 
    process_list = NULL;
608
 
  }
609
 
  while(process_list){
610
 
    fd_set rfds = rfds_all;
611
 
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
612
 
    if (select_ret == -1){
613
 
      perror("select");
614
 
      exitstatus = EXIT_FAILURE;
615
 
      goto end;
616
 
    }
617
 
    /* OK, now either a process completed, or something can be read
618
 
       from one of them */
619
 
    for(process *proc = process_list; proc ; proc = proc->next){
620
 
      /* Is this process completely done? */
621
 
      if(proc->eof and proc->completed){
622
 
        /* Only accept the plugin output if it exited cleanly */
623
 
        if(not WIFEXITED(proc->status)
624
 
           or WEXITSTATUS(proc->status) != 0){
625
 
          /* Bad exit by plugin */
626
 
          if(debug){
627
 
            if(WIFEXITED(proc->status)){
628
 
              fprintf(stderr, "Plugin %u exited with status %d\n",
629
 
                      (unsigned int) (proc->pid),
630
 
                      WEXITSTATUS(proc->status));
631
 
            } else if(WIFSIGNALED(proc->status)) {
632
 
              fprintf(stderr, "Plugin %u killed by signal %d\n",
633
 
                      (unsigned int) (proc->pid),
634
 
                      WTERMSIG(proc->status));
635
 
            } else if(WCOREDUMP(proc->status)){
636
 
              fprintf(stderr, "Plugin %d dumped core\n",
637
 
                      (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;
638
140
            }
639
 
          }
640
 
          /* Remove the plugin */
641
 
          FD_CLR(proc->fd, &rfds_all);
642
 
          /* Block signal while modifying process_list */
643
 
          ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
644
 
          if(ret < 0){
645
 
            perror("sigprocmask");
646
 
            exitstatus = EXIT_FAILURE;
647
 
            goto end;
648
 
          }
649
 
          /* Delete this process entry from the list */
650
 
          if(process_list == proc){
651
 
            /* First one - simple */
652
 
            process_list = proc->next;
653
 
          } else {
654
 
            /* Second one or later */
655
 
            for(process *p = process_list; p != NULL; p = p->next){
656
 
              if(p->next == proc){
657
 
                p->next = proc->next;
658
 
                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);
659
155
              }
660
156
            }
661
157
          }
662
 
          /* We are done modifying process list, so unblock signal */
663
 
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
664
 
                             NULL);
665
 
          if(ret < 0){
666
 
            perror("sigprocmask");
667
 
          }
668
 
          free(proc->buffer);
669
 
          free(proc);
670
 
          /* We deleted this process from the list, so we can't go
671
 
             proc->next.  Therefore, start over from the beginning of
672
 
             the process list */
673
 
          break;
674
 
        }
675
 
        /* This process exited nicely, so print its buffer */
676
 
 
677
 
        bool bret = print_out_password(proc->buffer, proc->buffer_length);
678
 
        if(not bret){
679
 
          perror("print_out_password");
680
 
          exitstatus = EXIT_FAILURE;
681
 
        }
682
 
        goto end;
683
 
      }
684
 
      /* This process has not completed.  Does it have any output? */
685
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
686
 
        /* This process had nothing to say at this time */
687
 
        continue;
688
 
      }
689
 
      /* Before reading, make the process' data buffer large enough */
690
 
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
691
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
692
 
                               + (size_t) BUFFER_SIZE);
693
 
        if (proc->buffer == NULL){
694
 
          perror("malloc");
695
 
          exitstatus = EXIT_FAILURE;
696
 
          goto end;
697
 
        }
698
 
        proc->buffer_size += BUFFER_SIZE;
699
 
      }
700
 
      /* Read from the process */
701
 
      ret = read(proc->fd, proc->buffer + proc->buffer_length,
702
 
                 BUFFER_SIZE);
703
 
      if(ret < 0){
704
 
        /* Read error from this process; ignore the error */
705
 
        continue;
706
 
      }
707
 
      if(ret == 0){
708
 
        /* got EOF */
709
 
        proc->eof = true;
710
 
      } else {
711
 
        proc->buffer_length += (size_t) ret;
 
158
        }
712
159
      }
713
160
    }
714
161
  }
715
 
 
716
 
 
 
162
  
717
163
 end:
718
 
  
719
 
  if(process_list == NULL or exitstatus != EXIT_SUCCESS){
720
 
    /* Fallback if all plugins failed, none are found or an error occured */
721
 
    bool bret;
722
 
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
723
 
    char *passwordbuffer = getpass("Password: ");
724
 
    bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
725
 
    if(not bret){
726
 
      perror("print_out_password");
727
 
      exitstatus = EXIT_FAILURE;
728
 
      goto end;
729
 
    }
730
 
  }
731
 
  
732
 
  /* Restore old signal handler */
733
 
  sigaction(SIGCHLD, &old_sigchld_action, NULL);
734
 
  
735
 
  free(plus_argv);
736
 
  
737
 
  /* Free the plugin list */
738
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
739
 
    next = plugin_list->next;
740
 
    free(plugin_list->argv);
741
 
    free(plugin_list);
742
 
  }
743
 
  
744
 
  if(dir != NULL){
745
 
    closedir(dir);
746
 
  }
747
 
  
748
 
  /* Free the process list and kill the processes */
749
 
  for(process *next; process_list != NULL; process_list = next){
750
 
    next = process_list->next;
751
 
    close(process_list->fd);
752
 
    ret = kill(process_list->pid, SIGTERM);
753
 
    if(ret == -1 and errno != ESRCH){
754
 
      /* set-uid proccesses migth not get closed */
755
 
      perror("kill");
756
 
    }
757
 
    free(process_list->buffer);
758
 
    free(process_list);
759
 
  }
760
 
  
761
 
  /* Wait for any remaining child processes to terminate */
762
 
  do{
763
 
    ret = wait(NULL);
764
 
  } while(ret >= 0);
765
 
  if(errno != ECHILD){
766
 
    perror("wait");
767
 
  }
768
 
  
769
 
  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;
770
182
}