/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 mandos-client.c

Added configuration files support for mandos-client
Removed plus argument support for mandos-client

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-client.c
21
21
 * Contact the authors at <mandos@fukt.bsnet.se>.
22
22
 */
23
23
 
24
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
25
 
                                   asprintf() */
 
24
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
 
25
 
26
26
#include <stddef.h>             /* size_t, NULL */
27
27
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
28
28
                                   EXIT_SUCCESS, realloc() */
51
51
                                   close() */
52
52
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
53
53
                                   FD_CLOEXEC */
54
 
#include <string.h>             /* strsep, strlen(), asprintf() */
 
54
#include <string.h>             /* strsep, strlen(), strcpy(),
 
55
                                   strcat() */
55
56
#include <errno.h>              /* errno */
56
57
#include <argp.h>               /* struct argp_option, struct
57
58
                                   argp_state, struct argp,
64
65
#include <errno.h>              /* errno, EBADF */
65
66
 
66
67
#define BUFFER_SIZE 256
67
 
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
 
68
#define CONFFILE "/conf/conf.d/mandos/client.conf"
68
69
 
69
 
const char *argp_program_version = "plugin-runner 1.0";
 
70
const char *argp_program_version = "mandos-client 1.0";
70
71
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
71
72
 
72
73
struct process;
87
88
  char *name;                   /* can be NULL or any plugin name */
88
89
  char **argv;
89
90
  int argc;
90
 
  char **environ;
91
 
  int envc;
92
91
  bool disabled;
93
92
  struct plugin *next;
94
93
} plugin;
103
102
  /* Create a new plugin */
104
103
  plugin *new_plugin = malloc(sizeof(plugin));
105
104
  if (new_plugin == NULL){
106
 
    return NULL;
 
105
    perror("malloc");
 
106
    exit(EXIT_FAILURE);
107
107
  }
108
 
  *new_plugin = (plugin) { .name = name,
109
 
                           .argc = 1,
110
 
                           .envc = 0,
111
 
                           .disabled = false,
112
 
                           .next = *plugin_list };
113
 
  
 
108
  new_plugin->name = name;
114
109
  new_plugin->argv = malloc(sizeof(char *) * 2);
115
110
  if (new_plugin->argv == NULL){
116
 
    free(new_plugin);
117
 
    return NULL;
 
111
    perror("malloc");
 
112
    exit(EXIT_FAILURE);
118
113
  }
119
114
  new_plugin->argv[0] = name;
120
115
  new_plugin->argv[1] = NULL;
121
 
 
122
 
  new_plugin->environ = malloc(sizeof(char *));
123
 
  if(new_plugin->environ == NULL){
124
 
    free(new_plugin->argv);
125
 
    free(new_plugin);
126
 
    return NULL;
127
 
  }
128
 
  new_plugin->environ[0] = NULL;
 
116
  new_plugin->argc = 1;
 
117
  new_plugin->disabled = false;
 
118
  new_plugin->next = *plugin_list;
129
119
  /* Append the new plugin to the list */
130
120
  *plugin_list = new_plugin;
131
121
  return new_plugin;
132
122
}
133
123
 
134
 
/* Helper function for add_argument and add_environment */
135
 
static bool add_to_char_array(const char *new, char ***array,
136
 
                              int *len){
137
 
  /* Resize the pointed-to array to hold one more pointer */
138
 
  *array = realloc(*array, sizeof(char *)
139
 
                   * (size_t) ((*len) + 2));
140
 
  /* Malloc check */
141
 
  if(*array == NULL){
142
 
    return false;
143
 
  }
144
 
  /* Make a copy of the new string */
145
 
  char *copy = strdup(new);
146
 
  if(copy == NULL){
147
 
    return false;
148
 
  }
149
 
  /* Insert the copy */
150
 
  (*array)[*len] = copy;
151
 
  (*len)++;
152
 
  /* Add a new terminating NULL pointer to the last element */
153
 
  (*array)[*len] = NULL;
154
 
  return true;
155
 
}
156
 
 
157
 
/* Add to a plugin's argument vector */
158
 
static bool add_argument(plugin *p, const char *arg){
159
 
  if(p == NULL){
160
 
    return false;
161
 
  }
162
 
  return add_to_char_array(arg, &(p->argv), &(p->argc));
163
 
}
164
 
 
165
 
/* Add to a plugin's environment */
166
 
static bool add_environment(plugin *p, const char *def){
167
 
  if(p == NULL){
168
 
    return false;
169
 
  }
170
 
  return add_to_char_array(def, &(p->environ), &(p->envc));
171
 
}
172
 
 
 
124
static void addargument(plugin *p, char *arg){
 
125
  p->argv[p->argc] = arg;
 
126
  p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
 
127
  if (p->argv == NULL){
 
128
    perror("malloc");
 
129
    exit(EXIT_FAILURE);
 
130
  }
 
131
  p->argc++;
 
132
  p->argv[p->argc] = NULL;
 
133
}
173
134
 
174
135
/*
175
136
 * Based on the example in the GNU LibC manual chapter 13.13 "File
225
186
  return true;
226
187
}
227
188
 
228
 
char **add_to_argv(char **argv, int *argc, char *arg){
 
189
char ** addcustomargument(char **argv, int *argc, char *arg){
 
190
 
229
191
  if (argv == NULL){
230
192
    *argc = 1;
231
193
    argv = malloc(sizeof(char*) * 2);
247
209
}
248
210
 
249
211
int main(int argc, char *argv[]){
250
 
  const char *plugindir = "/lib/mandos/plugins.d";
251
 
  const char *argfile = ARGFILE;
 
212
  const char *plugindir = "/conf/conf.d/mandos/plugins.d";
 
213
  const char *conffile = CONFFILE;
252
214
  FILE *conffp;
253
215
  size_t d_name_len;
254
216
  DIR *dir = NULL;
284
246
    { .name = "global-options", .key = 'g',
285
247
      .arg = "OPTION[,OPTION[,...]]",
286
248
      .doc = "Options passed to all plugins" },
287
 
    { .name = "global-envs", .key = 'e',
288
 
      .arg = "VAR=value",
289
 
      .doc = "Environment variable passed to all plugins" },
290
249
    { .name = "options-for", .key = 'o',
291
250
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
292
251
      .doc = "Options passed only to specified plugin" },
293
 
    { .name = "envs-for", .key = 'f',
294
 
      .arg = "PLUGIN:ENV=value",
295
 
      .doc = "Environment variable passed to specified plugin" },
296
252
    { .name = "disable", .key = 'd',
297
253
      .arg = "PLUGIN",
298
254
      .doc = "Disable a specific plugin", .group = 1 },
322
278
          if(p[0] == '\0'){
323
279
            continue;
324
280
          }
325
 
          if(not add_argument(getplugin(NULL, plugins), p)){
326
 
            perror("add_argument");
327
 
            return ARGP_ERR_UNKNOWN;
328
 
          }
329
 
        }
330
 
      }
331
 
      break;
332
 
    case 'e':
333
 
      if(arg == NULL){
334
 
        break;
335
 
      }
336
 
      {
337
 
        char *envdef = strdup(arg);
338
 
        if(envdef == NULL){
339
 
          break;
340
 
        }
341
 
        if(not add_environment(getplugin(NULL, plugins), envdef)){
342
 
          perror("add_environment");
 
281
          addargument(getplugin(NULL, plugins), p);
343
282
        }
344
283
      }
345
284
      break;
346
285
    case 'o':
347
286
      if (arg != NULL){
348
 
        char *p_name = strsep(&arg, ":");
349
 
        if(p_name[0] == '\0'){
 
287
        char *name = strsep(&arg, ":");
 
288
        if(name[0] == '\0'){
350
289
          break;
351
290
        }
352
291
        char *opt = strsep(&arg, ":");
359
298
            if(p[0] == '\0'){
360
299
              continue;
361
300
            }
362
 
            if(not add_argument(getplugin(p_name, plugins), p)){
363
 
              perror("add_argument");
364
 
              return ARGP_ERR_UNKNOWN;
365
 
            }
 
301
            addargument(getplugin(name, plugins), p);
366
302
          }
367
303
        }
368
304
      }
369
305
      break;
370
 
    case 'f':
371
 
      if(arg == NULL){
372
 
        break;
373
 
      }
374
 
      {
375
 
        char *envdef = strchr(arg, ':');
376
 
        if(envdef == NULL){
377
 
          break;
378
 
        }
379
 
        char *p_name = strndup(arg, (size_t) (envdef-arg));
380
 
        if(p_name == NULL){
381
 
          break;
382
 
        }
383
 
        envdef++;
384
 
        if(not add_environment(getplugin(p_name, plugins), envdef)){
385
 
          perror("add_environment");
386
 
        }
387
 
      }
388
 
      break;
389
306
    case 'd':
390
307
      if (arg != NULL){
391
 
        plugin *p = getplugin(arg, plugins);
392
 
        if(p == NULL){
393
 
          return ARGP_ERR_UNKNOWN;
394
 
        }
395
 
        p->disabled = true;
 
308
        getplugin(arg, plugins)->disabled = true;
396
309
      }
397
310
      break;
398
311
    case 128:
408
321
      debug = true;
409
322
      break;
410
323
    case ARGP_KEY_ARG:
411
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
 
324
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg); 
412
325
      break;
413
326
    case ARGP_KEY_END:
414
327
      break;
431
344
    goto end;
432
345
  }
433
346
 
434
 
  conffp = fopen(argfile, "r");
 
347
  conffp = fopen(conffile, "r");
435
348
  if(conffp != NULL){
436
349
    char *org_line = NULL;
437
350
    size_t size = 0;
453
366
          continue;
454
367
        }
455
368
        new_arg = strdup(p);
456
 
        custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
 
369
        custom_argv = addcustomargument(custom_argv, &custom_argc, new_arg);
457
370
        if (custom_argv == NULL){
458
 
          perror("add_to_argv");
 
371
          perror("addcustomargument");
459
372
          exitstatus = EXIT_FAILURE;
460
373
          goto end;
461
374
        }
463
376
    }
464
377
    free(org_line);
465
378
  } else{
466
 
    /* Check for harmful errors and go to fallback. Other errors might
467
 
       not affect opening plugins */
 
379
    /* check for harmfull errors */
468
380
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
469
381
      perror("fopen");
470
382
      exitstatus = EXIT_FAILURE;
489
401
      for(char **a = p->argv; *a != NULL; a++){
490
402
        fprintf(stderr, "\tArg: %s\n", *a);
491
403
      }
492
 
      fprintf(stderr, "...and %u environment variables\n", p->envc);
493
 
      for(char **a = p->environ; *a != NULL; a++){
494
 
        fprintf(stderr, "\t%s\n", *a);
495
 
      }
496
404
    }
497
405
  }
498
406
  
587
495
        continue;
588
496
      }
589
497
    }
590
 
 
591
 
    char *filename;
592
 
    ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
593
 
    if(ret < 0){
594
 
      perror("asprintf");
 
498
    
 
499
    char *filename = malloc(d_name_len + strlen(plugindir) + 2);
 
500
    if (filename == NULL){
 
501
      perror("malloc");
595
502
      continue;
596
503
    }
 
504
    strcpy(filename, plugindir); /* Spurious warning */
 
505
    strcat(filename, "/");      /* Spurious warning */
 
506
    strcat(filename, dirst->d_name); /* Spurious warning */
597
507
    
598
508
    ret = stat(filename, &st);
599
509
    if (ret == -1){
610
520
      free(filename);
611
521
      continue;
612
522
    }
613
 
    plugin *p = getplugin(dirst->d_name, &plugin_list);
614
 
    if(p == NULL){
615
 
      perror("getplugin");
616
 
      free(filename);
617
 
      continue;
618
 
    }
619
 
    if(p->disabled){
 
523
    if(getplugin(dirst->d_name, &plugin_list)->disabled){
620
524
      if(debug){
621
525
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
622
526
                dirst->d_name);
624
528
      free(filename);
625
529
      continue;
626
530
    }
 
531
    plugin *p = getplugin(dirst->d_name, &plugin_list);
627
532
    {
628
533
      /* Add global arguments to argument list for this plugin */
629
534
      plugin *g = getplugin(NULL, &plugin_list);
630
 
      if(g != NULL){
631
 
        for(char **a = g->argv + 1; *a != NULL; a++){
632
 
          if(not add_argument(p, *a)){
633
 
            perror("add_argument");
634
 
          }
635
 
        }
636
 
        /* Add global environment variables */
637
 
        for(char **e = g->environ; *e != NULL; e++){
638
 
          if(not add_environment(p, *e)){
639
 
            perror("add_environment");
640
 
          }
641
 
        }
642
 
      }
643
 
    }
644
 
    /* If this plugin has any environment variables, we will call
645
 
       using execve and need to duplicate the environment from this
646
 
       process, too. */
647
 
    if(p->environ[0] != NULL){
648
 
      for(char **e = environ; *e != NULL; e++){
649
 
        char *copy = strdup(*e);
650
 
        if(copy == NULL){
651
 
          perror("strdup");
652
 
          continue;
653
 
        }
654
 
        if(not add_environment(p, copy)){
655
 
          perror("add_environment");
656
 
        }
657
 
      }
658
 
    }
659
 
    
 
535
      for(char **a = g->argv + 1; *a != NULL; a++){
 
536
        addargument(p, *a);
 
537
      }
 
538
    }
660
539
    int pipefd[2]; 
661
540
    ret = pipe(pipefd);
662
541
    if (ret == -1){
714
593
           above and must now close it manually here. */
715
594
        closedir(dir);
716
595
      }
717
 
      if(p->environ[0] == NULL){
718
 
        if(execv(filename, p->argv) < 0){
719
 
          perror("execv");
720
 
          _exit(EXIT_FAILURE);
721
 
        }
722
 
      } else {
723
 
        if(execve(filename, p->argv, p->environ) < 0){
724
 
          perror("execve");
725
 
          _exit(EXIT_FAILURE);
726
 
        }
 
596
      if(execv(filename, p->argv) < 0){
 
597
        perror("execv");
 
598
        _exit(EXIT_FAILURE);
727
599
      }
728
600
      /* no return */
729
601
    }
767
639
  for(plugin *next; plugin_list != NULL; plugin_list = next){
768
640
    next = plugin_list->next;
769
641
    free(plugin_list->argv);
770
 
    if(plugin_list->environ[0] != NULL){
771
 
      for(char **e = plugin_list->environ; *e != NULL; e++){
772
 
        free(*e);
773
 
      }
774
 
    }
775
642
    free(plugin_list);
776
643
  }
777
644
  
915
782
  for(plugin *next; plugin_list != NULL; plugin_list = next){
916
783
    next = plugin_list->next;
917
784
    free(plugin_list->argv);
918
 
    if(plugin_list->environ[0] != NULL){
919
 
      for(char **e = plugin_list->environ; *e != NULL; e++){
920
 
        free(*e);
921
 
      }
922
 
    }
923
 
    free(plugin_list->environ);
924
785
    free(plugin_list);
925
786
  }
926
787