/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 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(), getline(),
25
 
                                   asprintf() */
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>             /* strsep, strlen(), asprintf() */
55
 
#include <errno.h>              /* errno */
56
 
#include <argp.h>               /* struct argp_option, struct
57
 
                                   argp_state, struct argp,
58
 
                                   argp_parse(), ARGP_ERR_UNKNOWN,
59
 
                                   ARGP_KEY_END, ARGP_KEY_ARG,
60
 
                                   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
 
#define PDIR "/lib/mandos/plugins.d"
70
 
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
71
 
 
72
 
const char *argp_program_version = "plugin-runner 1.0";
73
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
74
 
 
75
 
struct plugin;
76
 
 
77
 
typedef struct plugin{
78
 
  char *name;                   /* can be NULL or any plugin name */
79
 
  char **argv;
80
 
  int argc;
81
 
  char **environ;
82
 
  int envc;
83
 
  bool disabled;
84
 
 
85
 
  /* Variables used for running processes*/
 
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 */
 
15
 
 
16
struct process;
 
17
 
 
18
typedef struct process{
86
19
  pid_t pid;
87
20
  int fd;
88
21
  char *buffer;
89
 
  size_t buffer_size;
90
 
  size_t buffer_length;
91
 
  bool eof;
92
 
  volatile bool completed;
93
 
  volatile int status;
94
 
  struct plugin *next;
95
 
} plugin;
96
 
 
97
 
static plugin *plugin_list = NULL;
98
 
 
99
 
/* Gets a existing plugin based on name,
100
 
   or if none is found, creates a new one */
101
 
static plugin *getplugin(char *name){
102
 
  /* Check for exiting plugin with that name */
103
 
  for (plugin *p = plugin_list; p != NULL; p = p->next){
104
 
    if ((p->name == name)
105
 
        or (p->name and name and (strcmp(p->name, name) == 0))){
106
 
      return p;
107
 
    }
108
 
  }
109
 
  /* Create a new plugin */
110
 
  plugin *new_plugin = malloc(sizeof(plugin));
111
 
  if (new_plugin == NULL){
112
 
    return NULL;
113
 
  }
114
 
  char *copy_name = NULL;
115
 
  if(name != NULL){
116
 
    copy_name = strdup(name);
117
 
    if(copy_name == NULL){
118
 
      return NULL;
119
 
    }
120
 
  }
121
 
 
122
 
  *new_plugin = (plugin) { .name = copy_name,
123
 
                           .argc = 1,
124
 
                           .disabled = false,
125
 
                           .next = plugin_list };
126
 
  
127
 
  new_plugin->argv = malloc(sizeof(char *) * 2);
128
 
  if (new_plugin->argv == NULL){
129
 
    free(copy_name);
130
 
    free(new_plugin);
131
 
    return NULL;
132
 
  }
133
 
  new_plugin->argv[0] = copy_name;
134
 
  new_plugin->argv[1] = NULL;
135
 
  
136
 
  new_plugin->environ = malloc(sizeof(char *));
137
 
  if(new_plugin->environ == NULL){
138
 
    free(copy_name);
139
 
    free(new_plugin->argv);
140
 
    free(new_plugin);
141
 
    return NULL;
142
 
  }
143
 
  new_plugin->environ[0] = NULL;
144
 
  
145
 
  /* Append the new plugin to the list */
146
 
  plugin_list = new_plugin;
147
 
  return new_plugin;
148
 
}
149
 
 
150
 
/* Helper function for add_argument and add_environment */
151
 
static bool add_to_char_array(const char *new, char ***array,
152
 
                              int *len){
153
 
  /* Resize the pointed-to array to hold one more pointer */
154
 
  *array = realloc(*array, sizeof(char *)
155
 
                   * (size_t) ((*len) + 2));
156
 
  /* Malloc check */
157
 
  if(*array == NULL){
158
 
    return false;
159
 
  }
160
 
  /* Make a copy of the new string */
161
 
  char *copy = strdup(new);
162
 
  if(copy == NULL){
163
 
    return false;
164
 
  }
165
 
  /* Insert the copy */
166
 
  (*array)[*len] = copy;
167
 
  (*len)++;
168
 
  /* Add a new terminating NULL pointer to the last element */
169
 
  (*array)[*len] = NULL;
170
 
  return true;
171
 
}
172
 
 
173
 
/* Add to a plugin's argument vector */
174
 
static bool add_argument(plugin *p, const char *arg){
175
 
  if(p == NULL){
176
 
    return false;
177
 
  }
178
 
  return add_to_char_array(arg, &(p->argv), &(p->argc));
179
 
}
180
 
 
181
 
/* Add to a plugin's environment */
182
 
static bool add_environment(plugin *p, const char *def, bool replace){
183
 
  if(p == NULL){
184
 
    return false;
185
 
  }
186
 
  /* namelen = length of name of environment variable */
187
 
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
188
 
  /* Search for this environment variable */
189
 
  for(char **e = p->environ; *e != NULL; e++){
190
 
    if(strncmp(*e, def, namelen+1) == 0){
191
 
      /* It already exists */
192
 
      if(replace){
193
 
        char *new = realloc(*e, strlen(def));
194
 
        if(new == NULL){
195
 
          return false;
196
 
        }
197
 
        *e = new;
198
 
        strcpy(*e, def);
199
 
      }
200
 
      return true;
201
 
    }
202
 
  }
203
 
  return add_to_char_array(def, &(p->environ), &(p->envc));
204
 
}
205
 
 
206
 
/*
207
 
 * Based on the example in the GNU LibC manual chapter 13.13 "File
208
 
 * Descriptor Flags".
209
 
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
210
 
 */
211
 
static int set_cloexec_flag(int fd)
212
 
{
213
 
  int ret = fcntl(fd, F_GETFD, 0);
214
 
  /* If reading the flags failed, return error indication now. */
215
 
  if(ret < 0){
216
 
    return ret;
217
 
  }
218
 
  /* Store modified flag word in the descriptor. */
219
 
  return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
220
 
}
221
 
 
222
 
 
223
 
/* Mark processes as completed when they exit, and save their exit
224
 
   status. */
225
 
void handle_sigchld(__attribute__((unused)) int sig){
226
 
  while(true){
227
 
    plugin *proc = plugin_list;
228
 
    int status;
229
 
    pid_t pid = waitpid(-1, &status, WNOHANG);
230
 
    if(pid == 0){
231
 
      /* Only still running child processes */
232
 
      break;
233
 
    }
234
 
    if(pid == -1){
235
 
      if (errno != ECHILD){
236
 
        perror("waitpid");
237
 
      }
238
 
      /* No child processes */
239
 
      break;
240
 
    }
241
 
 
242
 
    /* A child exited, find it in process_list */
243
 
    while(proc != NULL and proc->pid != pid){
244
 
      proc = proc->next;
245
 
    }
246
 
    if(proc == NULL){
247
 
      /* Process not found in process list */
248
 
      continue;
249
 
    }
250
 
    proc->status = status;
251
 
    proc->completed = true;
252
 
  }
253
 
}
254
 
 
255
 
/* Prints out a password to stdout */
256
 
bool print_out_password(const char *buffer, size_t length){
257
 
  ssize_t ret;
258
 
  if(length>0 and buffer[length-1] == '\n'){
259
 
    length--;
260
 
  }
261
 
  for(size_t written = 0; written < length; written += (size_t)ret){
262
 
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
263
 
                                   length - written));
264
 
    if(ret < 0){
265
 
      return false;
266
 
    }
267
 
  }
268
 
  return true;
269
 
}
270
 
 
271
 
/* Removes and free a plugin from the plugin list */
272
 
static void free_plugin(plugin *plugin_node){
273
 
  
274
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
275
 
    free(*arg);
276
 
  }
277
 
  free(plugin_node->argv);
278
 
  for(char **env = plugin_node->environ; *env != NULL; env++){
279
 
    free(*env);
280
 
  }
281
 
  free(plugin_node->environ);
282
 
  free(plugin_node->buffer);
283
 
 
284
 
  /* Removes the plugin from the singly-linked list */
285
 
  if(plugin_node == plugin_list){
286
 
    /* First one - simple */
287
 
    plugin_list = plugin_list->next;
288
 
  } else {
289
 
    /* Second one or later */
290
 
    for(plugin *p = plugin_list; p != NULL; p = p->next){
291
 
      if(p->next == plugin_node){
292
 
        p->next = plugin_node->next;
293
 
        break;
294
 
      }
295
 
    }
296
 
  }
297
 
  
298
 
  free(plugin_node);
299
 
}
300
 
 
301
 
static void free_plugin_list(void){
302
 
  while(plugin_list != NULL){
303
 
    free_plugin(plugin_list);
304
 
  }
305
 
}
 
22
  int buffer_size;
 
23
  int buffer_length;
 
24
  struct process *next;
 
25
} process;
 
26
 
 
27
#define BUFFER_SIZE 256
306
28
 
307
29
int main(int argc, char *argv[]){
308
 
  char *plugindir = NULL;
309
 
  char *argfile = NULL;
310
 
  FILE *conffp;
311
 
  size_t d_name_len;
312
 
  DIR *dir = NULL;
 
30
  char plugindir[] = "plugins.d";
 
31
  size_t d_name_len, plugindir_len = sizeof(plugindir)-1;
 
32
  DIR *dir;
313
33
  struct dirent *dirst;
314
34
  struct stat st;
315
 
  fd_set rfds_all;
 
35
  fd_set rfds_orig;
316
36
  int ret, maxfd = 0;
317
 
  uid_t uid = 65534;
318
 
  gid_t gid = 65534;
319
 
  bool debug = false;
320
 
  int exitstatus = EXIT_SUCCESS;
321
 
  struct sigaction old_sigchld_action;
322
 
  struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
323
 
                                      .sa_flags = SA_NOCLDSTOP };
324
 
  char **custom_argv = NULL;
325
 
  int custom_argc = 0;
326
 
  
327
 
  /* Establish a signal handler */
328
 
  sigemptyset(&sigchld_action.sa_mask);
329
 
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
330
 
  if(ret == -1){
331
 
    perror("sigaddset");
332
 
    exitstatus = EXIT_FAILURE;
333
 
    goto fallback;
334
 
  }
335
 
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
336
 
  if(ret == -1){
337
 
    perror("sigaction");
338
 
    exitstatus = EXIT_FAILURE;
339
 
    goto fallback;
340
 
  }
341
 
  
342
 
  /* The options we understand. */
343
 
  struct argp_option options[] = {
344
 
    { .name = "global-options", .key = 'g',
345
 
      .arg = "OPTION[,OPTION[,...]]",
346
 
      .doc = "Options passed to all plugins" },
347
 
    { .name = "global-env", .key = 'e',
348
 
      .arg = "VAR=value",
349
 
      .doc = "Environment variable passed to all plugins" },
350
 
    { .name = "options-for", .key = 'o',
351
 
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
352
 
      .doc = "Options passed only to specified plugin" },
353
 
    { .name = "env-for", .key = 'f',
354
 
      .arg = "PLUGIN:ENV=value",
355
 
      .doc = "Environment variable passed to specified plugin" },
356
 
    { .name = "disable", .key = 'd',
357
 
      .arg = "PLUGIN",
358
 
      .doc = "Disable a specific plugin", .group = 1 },
359
 
    { .name = "plugin-dir", .key = 128,
360
 
      .arg = "DIRECTORY",
361
 
      .doc = "Specify a different plugin directory", .group = 2 },
362
 
    { .name = "config-file", .key = 129,
363
 
      .arg = "FILE",
364
 
      .doc = "Specify a different configuration file", .group = 2 },
365
 
    { .name = "userid", .key = 130,
366
 
      .arg = "ID", .flags = 0,
367
 
      .doc = "User ID the plugins will run as", .group = 3 },
368
 
    { .name = "groupid", .key = 131,
369
 
      .arg = "ID", .flags = 0,
370
 
      .doc = "Group ID the plugins will run as", .group = 3 },
371
 
    { .name = "debug", .key = 132,
372
 
      .doc = "Debug mode", .group = 4 },
373
 
    { .name = NULL }
374
 
  };
375
 
  
376
 
  error_t parse_opt (int key, char *arg, __attribute__((unused))
377
 
                     struct argp_state *state) {
378
 
    /* Get the INPUT argument from `argp_parse', which we know is a
379
 
       pointer to our plugin list pointer. */
380
 
    switch (key) {
381
 
    case 'g':                   /* --global-options */
382
 
      if (arg != NULL){
383
 
        char *p;
384
 
        while((p = strsep(&arg, ",")) != NULL){
385
 
          if(p[0] == '\0'){
386
 
            continue;
387
 
          }
388
 
          if(not add_argument(getplugin(NULL), p)){
389
 
            perror("add_argument");
390
 
            return ARGP_ERR_UNKNOWN;
391
 
          }
392
 
        }
393
 
      }
394
 
      break;
395
 
    case 'e':                   /* --global-env */
396
 
      if(arg == NULL){
397
 
        break;
398
 
      }
399
 
      {
400
 
        char *envdef = strdup(arg);
401
 
        if(envdef == NULL){
402
 
          break;
403
 
        }
404
 
        if(not add_environment(getplugin(NULL), envdef, true)){
405
 
          perror("add_environment");
406
 
        }
407
 
      }
408
 
      break;
409
 
    case 'o':                   /* --options-for */
410
 
      if (arg != NULL){
411
 
        char *p_name = strsep(&arg, ":");
412
 
        if(p_name[0] == '\0'){
413
 
          break;
414
 
        }
415
 
        char *opt = strsep(&arg, ":");
416
 
        if(opt[0] == '\0'){
417
 
          break;
418
 
        }
419
 
        if(opt != NULL){
420
 
          char *p;
421
 
          while((p = strsep(&opt, ",")) != NULL){
422
 
            if(p[0] == '\0'){
423
 
              continue;
424
 
            }
425
 
            if(not add_argument(getplugin(p_name), p)){
426
 
              perror("add_argument");
427
 
              return ARGP_ERR_UNKNOWN;
428
 
            }
429
 
          }
430
 
        }
431
 
      }
432
 
      break;
433
 
    case 'f':                   /* --env-for */
434
 
      if(arg == NULL){
435
 
        break;
436
 
      }
437
 
      {
438
 
        char *envdef = strchr(arg, ':');
439
 
        if(envdef == NULL){
440
 
          break;
441
 
        }
442
 
        char *p_name = strndup(arg, (size_t) (envdef-arg));
443
 
        if(p_name == NULL){
444
 
          break;
445
 
        }
446
 
        envdef++;
447
 
        if(not add_environment(getplugin(p_name), envdef, true)){
448
 
          perror("add_environment");
449
 
        }
450
 
      }
451
 
      break;
452
 
    case 'd':                   /* --disable */
453
 
      if (arg != NULL){
454
 
        plugin *p = getplugin(arg);
455
 
        if(p == NULL){
456
 
          return ARGP_ERR_UNKNOWN;
457
 
        }
458
 
        p->disabled = true;
459
 
      }
460
 
      break;
461
 
    case 128:                   /* --plugin-dir */
462
 
      plugindir = strdup(arg);
463
 
      if(plugindir == NULL){
464
 
        perror("strdup");
465
 
      }      
466
 
      break;
467
 
    case 129:                   /* --config-file */
468
 
      argfile = strdup(arg);
469
 
      if(argfile == NULL){
470
 
        perror("strdup");
471
 
      }
472
 
      break;      
473
 
    case 130:                   /* --userid */
474
 
      uid = (uid_t)strtol(arg, NULL, 10);
475
 
      break;
476
 
    case 131:                   /* --groupid */
477
 
      gid = (gid_t)strtol(arg, NULL, 10);
478
 
      break;
479
 
    case 132:                   /* --debug */
480
 
      debug = true;
481
 
      break;
482
 
    case ARGP_KEY_ARG:
483
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
484
 
      break;
485
 
    case ARGP_KEY_END:
486
 
      break;
487
 
    default:
488
 
      return ARGP_ERR_UNKNOWN;
489
 
    }
490
 
    return 0;
491
 
  }
492
 
  
493
 
  struct argp argp = { .options = options, .parser = parse_opt,
494
 
                       .args_doc = "",
495
 
                       .doc = "Mandos plugin runner -- Run plugins" };
496
 
  
497
 
  /* Open the configfile if available */
498
 
  if (argfile == NULL){
499
 
    conffp = fopen(AFILE, "r");
500
 
  } else {
501
 
    conffp = fopen(argfile, "r");
502
 
  }  
503
 
  if(conffp != NULL){
504
 
    char *org_line = NULL;
505
 
    char *p, *arg, *new_arg, *line;
506
 
    size_t size = 0;
507
 
    ssize_t sret;
508
 
    const char whitespace_delims[] = " \r\t\f\v\n";
509
 
    const char comment_delim[] = "#";
510
 
 
511
 
    custom_argc = 1;
512
 
    custom_argv = malloc(sizeof(char*) * 2);
513
 
    if(custom_argv == NULL){
514
 
      perror("malloc");
515
 
      exitstatus = EXIT_FAILURE;
516
 
      goto fallback;
517
 
    }
518
 
    custom_argv[0] = argv[0];
519
 
    custom_argv[1] = NULL;
520
 
 
521
 
    /* for each line in the config file, strip whitespace and ignore
522
 
       commented text */
523
 
    while(true){
524
 
      sret = getline(&org_line, &size, conffp);
525
 
      if(sret == -1){
526
 
        break;
527
 
      }
528
 
 
529
 
      line = org_line;
530
 
      arg = strsep(&line, comment_delim);
531
 
      while((p = strsep(&arg, whitespace_delims)) != NULL){
532
 
        if(p[0] == '\0'){
533
 
          continue;
534
 
        }
535
 
        new_arg = strdup(p);
536
 
        if(new_arg == NULL){
537
 
          perror("strdup");
538
 
          exitstatus = EXIT_FAILURE;
539
 
          free(org_line);
540
 
          goto fallback;
541
 
        }
542
 
        
543
 
        custom_argc += 1;
544
 
        custom_argv = realloc(custom_argv, sizeof(char *)
545
 
                              * ((unsigned int) custom_argc + 1));
546
 
        if(custom_argv == NULL){
547
 
          perror("realloc");
548
 
          exitstatus = EXIT_FAILURE;
549
 
          free(org_line);
550
 
          goto fallback;
551
 
        }
552
 
        custom_argv[custom_argc-1] = new_arg;
553
 
        custom_argv[custom_argc] = NULL;        
554
 
      }
555
 
    }
556
 
    free(org_line);
557
 
  } else {
558
 
    /* Check for harmful errors and go to fallback. Other errors might
559
 
       not affect opening plugins */
560
 
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
561
 
      perror("fopen");
562
 
      exitstatus = EXIT_FAILURE;
563
 
      goto fallback;
564
 
    }
565
 
  }
566
 
  /* If there was any arguments from configuration file,
567
 
     pass them to parser as command arguments */
568
 
  if(custom_argv != NULL){
569
 
    ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
570
 
                      0, NULL);
571
 
    if (ret == ARGP_ERR_UNKNOWN){
572
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
573
 
      exitstatus = EXIT_FAILURE;
574
 
      goto fallback;
575
 
    }
576
 
  }
577
 
  
578
 
  /* Parse actual command line arguments, to let them override the
579
 
     config file */
580
 
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
581
 
  if (ret == ARGP_ERR_UNKNOWN){
582
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
583
 
    exitstatus = EXIT_FAILURE;
584
 
    goto fallback;
585
 
  }
586
 
  
587
 
  if(debug){
588
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
589
 
      fprintf(stderr, "Plugin: %s has %d arguments\n",
590
 
              p->name ? p->name : "Global", p->argc - 1);
591
 
      for(char **a = p->argv; *a != NULL; a++){
592
 
        fprintf(stderr, "\tArg: %s\n", *a);
593
 
      }
594
 
      fprintf(stderr, "...and %u environment variables\n", p->envc);
595
 
      for(char **a = p->environ; *a != NULL; a++){
596
 
        fprintf(stderr, "\t%s\n", *a);
597
 
      }
598
 
    }
599
 
  }
600
 
  
601
 
  /* Strip permissions down to nobody */
602
 
  ret = setuid(uid);
603
 
  if (ret == -1){
604
 
    perror("setuid");
605
 
  }  
606
 
  setgid(gid);
607
 
  if (ret == -1){
608
 
    perror("setgid");
609
 
  }
610
 
  
611
 
  if (plugindir == NULL){
612
 
    dir = opendir(PDIR);
613
 
  } else {
614
 
    dir = opendir(plugindir);
615
 
  }
616
 
  
 
37
  process *process_list = NULL;
 
38
  
 
39
  dir = opendir(plugindir);
 
40
 
617
41
  if(dir == NULL){
618
 
    perror("Could not open plugin dir");
619
 
    exitstatus = EXIT_FAILURE;
620
 
    goto fallback;
621
 
  }
622
 
  
623
 
  /* Set the FD_CLOEXEC flag on the directory, if possible */
624
 
  {
625
 
    int dir_fd = dirfd(dir);
626
 
    if(dir_fd >= 0){
627
 
      ret = set_cloexec_flag(dir_fd);
628
 
      if(ret < 0){
629
 
        perror("set_cloexec_flag");
630
 
        exitstatus = EXIT_FAILURE;
631
 
        goto fallback;
632
 
      }
633
 
    }
634
 
  }
635
 
  
636
 
  FD_ZERO(&rfds_all);
637
 
  
638
 
  /* Read and execute any executable in the plugin directory*/
 
42
    fprintf(stderr, "Can not open directory\n");
 
43
    return EXIT_FAILURE;
 
44
  }
 
45
  
 
46
  FD_ZERO(&rfds_orig);
 
47
  
639
48
  while(true){
640
49
    dirst = readdir(dir);
641
50
    
642
 
    /* All directory entries have been processed */
 
51
    // All directory entries have been processed
643
52
    if(dirst == NULL){
644
 
      if (errno == EBADF){
645
 
        perror("readdir");
646
 
        exitstatus = EXIT_FAILURE;
647
 
        goto fallback;
648
 
      }
649
53
      break;
650
54
    }
651
55
    
652
56
    d_name_len = strlen(dirst->d_name);
653
57
    
654
 
    /* Ignore dotfiles, backup files and other junk */
655
 
    {
656
 
      bool bad_name = false;
657
 
      
658
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
659
 
      
660
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
661
 
                                           ".dpkg-old",
662
 
                                           ".dpkg-divert", NULL };
663
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
664
 
        size_t pre_len = strlen(*pre);
665
 
        if((d_name_len >= pre_len)
666
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
667
 
          if(debug){
668
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
669
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
670
 
          }
671
 
          bad_name = true;
672
 
          break;
673
 
        }
674
 
      }
675
 
      if(bad_name){
676
 
        continue;
677
 
      }
678
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
679
 
        size_t suf_len = strlen(*suf);
680
 
        if((d_name_len >= suf_len)
681
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
682
 
                == 0)){
683
 
          if(debug){
684
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
685
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
686
 
          }
687
 
          bad_name = true;
688
 
          break;
689
 
        }
690
 
      }
691
 
      
692
 
      if(bad_name){
693
 
        continue;
694
 
      }
695
 
    }
696
 
 
697
 
    char *filename;
698
 
    ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
699
 
    if(ret < 0){
700
 
      perror("asprintf");
701
 
      continue;
702
 
    }
703
 
    
704
 
    ret = stat(filename, &st);
705
 
    if (ret == -1){
706
 
      perror("stat");
707
 
      free(filename);
708
 
      continue;
709
 
    }
710
 
 
711
 
    /* Ignore non-executable files */
712
 
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
713
 
      if(debug){
714
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
715
 
                " with bad type or mode\n", filename);
716
 
      }
717
 
      free(filename);
718
 
      continue;
719
 
    }
720
 
    
721
 
    plugin *p = getplugin(dirst->d_name);
722
 
    if(p == NULL){
723
 
      perror("getplugin");
724
 
      free(filename);
725
 
      continue;
726
 
    }
727
 
    if(p->disabled){
728
 
      if(debug){
729
 
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
730
 
                dirst->d_name);
731
 
      }
732
 
      free(filename);
733
 
      continue;
734
 
    }
735
 
    {
736
 
      /* Add global arguments to argument list for this plugin */
737
 
      plugin *g = getplugin(NULL);
738
 
      if(g != NULL){
739
 
        for(char **a = g->argv + 1; *a != NULL; a++){
740
 
          if(not add_argument(p, *a)){
741
 
            perror("add_argument");
742
 
          }
743
 
        }
744
 
        /* Add global environment variables */
745
 
        for(char **e = g->environ; *e != NULL; e++){
746
 
          if(not add_environment(p, *e, false)){
747
 
            perror("add_environment");
748
 
          }
749
 
        }
750
 
      }
751
 
    }
752
 
    /* If this plugin has any environment variables, we will call
753
 
       using execve and need to duplicate the environment from this
754
 
       process, too. */
755
 
    if(p->environ[0] != NULL){
756
 
      for(char **e = environ; *e != NULL; e++){
757
 
        if(not add_environment(p, *e, false)){
758
 
          perror("add_environment");
759
 
        }
760
 
      }
761
 
    }
762
 
    
763
 
    int pipefd[2];
764
 
    ret = pipe(pipefd);
765
 
    if (ret == -1){
766
 
      perror("pipe");
767
 
      exitstatus = EXIT_FAILURE;
768
 
      goto fallback;
769
 
    }
770
 
    /* Ask OS to automatic close the pipe on exec */
771
 
    ret = set_cloexec_flag(pipefd[0]);
772
 
    if(ret < 0){
773
 
      perror("set_cloexec_flag");
774
 
      exitstatus = EXIT_FAILURE;
775
 
      goto fallback;
776
 
    }
777
 
    ret = set_cloexec_flag(pipefd[1]);
778
 
    if(ret < 0){
779
 
      perror("set_cloexec_flag");
780
 
      exitstatus = EXIT_FAILURE;
781
 
      goto fallback;
782
 
    }
783
 
    /* Block SIGCHLD until process is safely in process list */
784
 
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
785
 
    if(ret < 0){
786
 
      perror("sigprocmask");
787
 
      exitstatus = EXIT_FAILURE;
788
 
      goto fallback;
789
 
    }
790
 
    /* Starting a new process to be watched */
791
 
    pid_t pid = fork();
792
 
    if(pid == -1){
793
 
      perror("fork");
794
 
      exitstatus = EXIT_FAILURE;
795
 
      goto fallback;
796
 
    }
797
 
    if(pid == 0){
798
 
      /* this is the child process */
799
 
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
800
 
      if(ret < 0){
801
 
        perror("sigaction");
802
 
        _exit(EXIT_FAILURE);
803
 
      }
804
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
805
 
      if(ret < 0){
806
 
        perror("sigprocmask");
807
 
        _exit(EXIT_FAILURE);
808
 
      }
809
 
 
810
 
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
811
 
      if(ret == -1){
812
 
        perror("dup2");
813
 
        _exit(EXIT_FAILURE);
814
 
      }
815
 
      
816
 
      if(dirfd(dir) < 0){
817
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
818
 
           above and must now close it manually here. */
 
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);
 
70
 
 
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 */
819
79
        closedir(dir);
820
 
      }
821
 
      if(p->environ[0] == NULL){
822
 
        if(execv(filename, p->argv) < 0){
823
 
          perror("execv");
824
 
          _exit(EXIT_FAILURE);
825
 
        }
826
 
      } else {
827
 
        if(execve(filename, p->argv, p->environ) < 0){
828
 
          perror("execve");
829
 
          _exit(EXIT_FAILURE);
830
 
        }
831
 
      }
832
 
      /* no return */
833
 
    }
834
 
    /* Parent process */
835
 
    close(pipefd[1]);           /* Close unused write end of pipe */
836
 
    free(filename);
837
 
    plugin *new_plugin = getplugin(dirst->d_name);
838
 
    if (new_plugin == NULL){
839
 
      perror("getplugin");
840
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
841
 
      if(ret < 0){
842
 
        perror("sigprocmask");
843
 
      }
844
 
      exitstatus = EXIT_FAILURE;
845
 
      goto fallback;
846
 
    }
847
 
    
848
 
    new_plugin->pid = pid;
849
 
    new_plugin->fd = pipefd[0];
850
 
    
851
 
    /* Unblock SIGCHLD so signal handler can be run if this process
852
 
       has already completed */
853
 
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
854
 
    if(ret < 0){
855
 
      perror("sigprocmask");
856
 
      exitstatus = EXIT_FAILURE;
857
 
      goto fallback;
858
 
    }
859
 
    
860
 
    FD_SET(new_plugin->fd, &rfds_all);
861
 
    
862
 
    if (maxfd < new_plugin->fd){
863
 
      maxfd = new_plugin->fd;
864
 
    }
865
 
    
 
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
    }
866
115
  }
867
116
  
868
117
  closedir(dir);
869
 
  dir = NULL;
870
 
 
871
 
  for(plugin *p = plugin_list; p != NULL; p = p->next){
872
 
    if(p->pid != 0){
 
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;
 
140
            }
 
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);
 
155
              }
 
156
            }
 
157
          }
 
158
        }
 
159
      }
 
160
    }
 
161
  }
 
162
  
 
163
 end:
 
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
      }
873
178
      break;
874
179
    }
875
 
    if(p->next == NULL){
876
 
      fprintf(stderr, "No plugin processes started. Incorrect plugin"
877
 
              " directory?\n");
878
 
      free_plugin_list();
879
 
    }
880
 
  }
881
 
 
882
 
  /* Main loop while running plugins exist */
883
 
  while(plugin_list){
884
 
    fd_set rfds = rfds_all;
885
 
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
886
 
    if (select_ret == -1){
887
 
      perror("select");
888
 
      exitstatus = EXIT_FAILURE;
889
 
      goto fallback;
890
 
    }
891
 
    /* OK, now either a process completed, or something can be read
892
 
       from one of them */
893
 
    for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
894
 
      /* Is this process completely done? */
895
 
      if(proc->eof and proc->completed){
896
 
        /* Only accept the plugin output if it exited cleanly */
897
 
        if(not WIFEXITED(proc->status)
898
 
           or WEXITSTATUS(proc->status) != 0){
899
 
          /* Bad exit by plugin */
900
 
 
901
 
          if(debug){
902
 
            if(WIFEXITED(proc->status)){
903
 
              fprintf(stderr, "Plugin %u exited with status %d\n",
904
 
                      (unsigned int) (proc->pid),
905
 
                      WEXITSTATUS(proc->status));
906
 
            } else if(WIFSIGNALED(proc->status)) {
907
 
              fprintf(stderr, "Plugin %u killed by signal %d\n",
908
 
                      (unsigned int) (proc->pid),
909
 
                      WTERMSIG(proc->status));
910
 
            } else if(WCOREDUMP(proc->status)){
911
 
              fprintf(stderr, "Plugin %d dumped core\n",
912
 
                      (unsigned int) (proc->pid));
913
 
            }
914
 
          }
915
 
          
916
 
          /* Remove the plugin */
917
 
          FD_CLR(proc->fd, &rfds_all);
918
 
 
919
 
          /* Block signal while modifying process_list */
920
 
          ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
921
 
          if(ret < 0){
922
 
            perror("sigprocmask");
923
 
            exitstatus = EXIT_FAILURE;
924
 
            goto fallback;
925
 
          }
926
 
          free_plugin(proc);
927
 
          /* We are done modifying process list, so unblock signal */
928
 
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
929
 
                             NULL);
930
 
          if(ret < 0){
931
 
            perror("sigprocmask");
932
 
            exitstatus = EXIT_FAILURE;
933
 
            goto fallback;
934
 
          }
935
 
          
936
 
          if(plugin_list == NULL){
937
 
            break;
938
 
          }
939
 
          continue;
940
 
        }
941
 
        
942
 
        /* This process exited nicely, so print its buffer */
943
 
 
944
 
        bool bret = print_out_password(proc->buffer,
945
 
                                       proc->buffer_length);
946
 
        if(not bret){
947
 
          perror("print_out_password");
948
 
          exitstatus = EXIT_FAILURE;
949
 
        }
950
 
        goto fallback;
951
 
      }
952
 
      
953
 
      /* This process has not completed.  Does it have any output? */
954
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
955
 
        /* This process had nothing to say at this time */
956
 
        continue;
957
 
      }
958
 
      /* Before reading, make the process' data buffer large enough */
959
 
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
960
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
961
 
                               + (size_t) BUFFER_SIZE);
962
 
        if (proc->buffer == NULL){
963
 
          perror("malloc");
964
 
          exitstatus = EXIT_FAILURE;
965
 
          goto fallback;
966
 
        }
967
 
        proc->buffer_size += BUFFER_SIZE;
968
 
      }
969
 
      /* Read from the process */
970
 
      ret = read(proc->fd, proc->buffer + proc->buffer_length,
971
 
                 BUFFER_SIZE);
972
 
      if(ret < 0){
973
 
        /* Read error from this process; ignore the error */
974
 
        continue;
975
 
      }
976
 
      if(ret == 0){
977
 
        /* got EOF */
978
 
        proc->eof = true;
979
 
      } else {
980
 
        proc->buffer_length += (size_t) ret;
981
 
      }
982
 
    }
983
 
  }
984
 
 
985
 
 
986
 
 fallback:
987
 
  
988
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
989
 
    /* Fallback if all plugins failed, none are found or an error
990
 
       occured */
991
 
    bool bret;
992
 
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
993
 
    char *passwordbuffer = getpass("Password: ");
994
 
    bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
995
 
    if(not bret){
996
 
      perror("print_out_password");
997
 
      exitstatus = EXIT_FAILURE;
998
 
    }
999
 
  }
1000
 
  
1001
 
  /* Restore old signal handler */
1002
 
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1003
 
  if(ret == -1){
1004
 
    perror("sigaction");
1005
 
    exitstatus = EXIT_FAILURE;
1006
 
  }
1007
 
 
1008
 
  if(custom_argv != NULL){
1009
 
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
1010
 
      free(*arg);
1011
 
    }
1012
 
    free(custom_argv);
1013
 
  }
1014
 
  
1015
 
  if(dir != NULL){
1016
 
    closedir(dir);
1017
 
  }
1018
 
  
1019
 
  /* Free the process list and kill the processes */
1020
 
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1021
 
    if(p->pid != 0){
1022
 
      close(p->fd);
1023
 
      ret = kill(p->pid, SIGTERM);
1024
 
      if(ret == -1 and errno != ESRCH){
1025
 
        /* Set-uid proccesses might not get closed */
1026
 
        perror("kill");
1027
 
      }
1028
 
    }
1029
 
  }
1030
 
  
1031
 
  /* Wait for any remaining child processes to terminate */
1032
 
  do{
1033
 
    ret = wait(NULL);
1034
 
  } while(ret >= 0);
1035
 
  if(errno != ECHILD){
1036
 
    perror("wait");
1037
 
  }
1038
 
 
1039
 
  free_plugin_list();
1040
 
  
1041
 
  free(plugindir);
1042
 
  free(argfile);
1043
 
  
1044
 
  return exitstatus;
 
180
  }  
 
181
  return EXIT_SUCCESS;
1045
182
}