/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-21 03:58:36 UTC
  • mfrom: (17 mandos)
  • mto: This revision was merged to the branch mainline in revision 20.
  • Revision ID: belorn@braxen-20080721035836-v7220bmolr608r61
Added getopt_long support for mandosclient and passprompt
Added support for --interface for mandosclient
Added support for --prefix for passprompt

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugbasedclient.c
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
1
#include <stdio.h>      /* popen, fileno */
25
2
#include <iso646.h>     /* and, or, not */
26
3
#include <sys/types.h>  /* DIR, opendir, stat, struct stat, waitpid,
30
7
#include <sys/stat.h>   /* stat, struct stat */
31
8
#include <unistd.h>     /* stat, struct stat, chdir */
32
9
#include <stdlib.h>     /* EXIT_FAILURE */
33
 
#include <sys/select.h> /* fd_set, select, FD_ZERO, FD_SET,
34
 
                           FD_ISSET */
 
10
#include <sys/select.h> /* fd_set, select, FD_ZERO, FD_SET, FD_ISSET */
35
11
#include <string.h>     /* strlen, strcpy, strcat */
36
12
#include <stdbool.h>    /* true */
37
13
#include <sys/wait.h>   /* waitpid, WIFEXITED, WEXITSTATUS */
38
14
#include <errno.h>      /* errno */
39
 
#include <argp.h>       /* argp */
40
15
 
41
16
struct process;
42
17
 
44
19
  pid_t pid;
45
20
  int fd;
46
21
  char *buffer;
47
 
  size_t buffer_size;
48
 
  size_t buffer_length;
 
22
  int buffer_size;
 
23
  int buffer_length;
49
24
  struct process *next;
50
25
} process;
51
26
 
52
 
typedef struct plugin{
53
 
  char *name;           /* can be "global" and any plugin name */
54
 
  char **argv;
55
 
  int argc;
56
 
  struct plugin *next;
57
 
} plugin;
58
 
 
59
 
plugin *getplugin(char *name, plugin **plugin_list){
60
 
  for (plugin *p = *plugin_list; p != NULL; p = p->next){
61
 
    if ((p->name == name)
62
 
        or (p->name and name and (strcmp(p->name, name) == 0))){
63
 
      return p;
64
 
    }
65
 
  }
66
 
  /* Create a new plugin */
67
 
  plugin *new_plugin = malloc(sizeof(plugin));
68
 
  if (new_plugin == NULL){
69
 
    perror("malloc");
70
 
    exit(EXIT_FAILURE);
71
 
  }
72
 
  new_plugin->name = name;
73
 
  new_plugin->argv = malloc(sizeof(char *) * 2);
74
 
  if (new_plugin->argv == NULL){
75
 
    perror("malloc");
76
 
    exit(EXIT_FAILURE);
77
 
  }
78
 
  new_plugin->argv[0] = name;
79
 
  new_plugin->argv[1] = NULL;
80
 
  new_plugin->argc = 1;
81
 
  /* Append the new plugin to the list */
82
 
  new_plugin->next = *plugin_list;
83
 
  *plugin_list = new_plugin;
84
 
  return new_plugin;
85
 
}
86
 
 
87
 
void addarguments(plugin *p, char *arg){
88
 
  p->argv[p->argc] = arg;
89
 
  p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
90
 
  if (p->argv == NULL){
91
 
    perror("malloc");
92
 
    exit(EXIT_FAILURE);
93
 
  }
94
 
  p->argc++;
95
 
  p->argv[p->argc] = NULL;
96
 
}
97
 
        
98
27
#define BUFFER_SIZE 256
99
28
 
100
 
const char *argp_program_version =
101
 
  "plugbasedclient 0.9";
102
 
const char *argp_program_bug_address =
103
 
  "<mandos@fukt.bsnet.se>";
104
 
static char doc[] =
105
 
  "Mandos plugin runner -- Run Mandos plugins";
106
 
/* A description of the arguments we accept. */
107
 
static char args_doc[] = "";
108
 
 
109
29
int main(int argc, char *argv[]){
110
30
  char plugindir[] = "plugins.d";
111
31
  size_t d_name_len, plugindir_len = sizeof(plugindir)-1;
116
36
  int ret, maxfd = 0;
117
37
  process *process_list = NULL;
118
38
  
119
 
  /* The options we understand. */
120
 
  struct argp_option options[] = {
121
 
    { .name = "global-options", .key = 'g',
122
 
      .arg = "option[,option[,...]]", .flags = 0,
123
 
      .doc = "Options effecting all plugins" },
124
 
    { .name = "options-for", .key = 'o',
125
 
      .arg = "plugin:option[,option[,...]]", .flags = 0,
126
 
      .doc = "Options effecting only specified plugins" },
127
 
    { .name = NULL }
128
 
  };
129
 
  
130
 
  error_t parse_opt (int key, char *arg, struct argp_state *state) {
131
 
       /* Get the INPUT argument from `argp_parse', which we
132
 
          know is a pointer to our arguments structure. */
133
 
    plugin **plugins = state->input;
134
 
    switch (key) {
135
 
    case 'g':
136
 
      if (arg != NULL){
137
 
        char *p = strtok(arg, ",");
138
 
        do{
139
 
          addarguments(getplugin(NULL, plugins), p);
140
 
          p = strtok(NULL, ",");
141
 
        } while (p);
142
 
      }
143
 
      break;
144
 
    case 'o':
145
 
      if (arg != NULL){
146
 
        char *name = strtok(arg, ":");
147
 
        char *p = strtok(NULL, ":");
148
 
        p = strtok(p, ",");
149
 
        do{
150
 
          addarguments(getplugin(name, plugins), p);
151
 
          p = strtok(NULL, ",");
152
 
        } while (p);
153
 
      }
154
 
      break;
155
 
    case ARGP_KEY_ARG:
156
 
      argp_usage (state);
157
 
      break;
158
 
    case ARGP_KEY_END:
159
 
      break;
160
 
    default:
161
 
      return ARGP_ERR_UNKNOWN;
162
 
    }
163
 
    return 0;
164
 
  }
165
 
 
166
 
  plugin *plugin_list = NULL;
167
 
  
168
 
  struct argp argp = { .options = options, .parser = parse_opt,
169
 
                       .args_doc = args_doc, .doc = doc };
170
 
 
171
 
  argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
172
 
 
173
 
/*   for(plugin *p = plugin_list; p != NULL; p=p->next){ */
174
 
/*     fprintf(stderr, "Plugin: %s has %d arguments\n", p->name ? p->name : "Global", p->argc); */
175
 
/*     for(char **a = p->argv + 1; *a != NULL; a++){ */
176
 
/*       fprintf(stderr, "\tArg: %s\n", *a); */
177
 
/*     } */
178
 
/*   } */
179
 
  
180
 
/*   return 0; */
181
 
  
182
39
  dir = opendir(plugindir);
183
 
  
 
40
 
184
41
  if(dir == NULL){
185
42
    fprintf(stderr, "Can not open directory\n");
186
43
    return EXIT_FAILURE;
215
72
      // Starting a new process to be watched
216
73
      process *new_process = malloc(sizeof(process));
217
74
      int pipefd[2];
218
 
      ret = pipe(pipefd);
219
 
      if (ret == -1){
220
 
        perror(argv[0]);
221
 
        goto end;
222
 
      }
 
75
      pipe(pipefd);
223
76
      new_process->pid = fork();
224
77
      if(new_process->pid == 0){
225
78
        /* this is the child process */
226
79
        closedir(dir);
227
80
        close(pipefd[0]);       /* close unused read end of pipe */
228
81
        dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
229
 
        char *basename;
230
 
        basename = strrchr(filename, '/');
231
 
        if (basename == NULL){
232
 
          basename = filename;
233
 
        } else {
234
 
          basename++;
235
 
        }
236
 
        plugin *p = getplugin(basename, &plugin_list);
237
 
 
238
 
        plugin *g = getplugin(NULL, &plugin_list);
239
 
        for(char **a = g->argv + 1; *a != NULL; a++){
240
 
          addarguments(p, *a);
241
 
        }
242
 
        if(execv(filename, p->argv) < 0){
 
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){
243
90
          perror(argv[0]);
244
91
          close(pipefd[1]);
245
92
          exit(EXIT_FAILURE);
284
131
               > process_itr->buffer_size){
285
132
                process_itr->buffer = realloc(process_itr->buffer,
286
133
                                              process_itr->buffer_size
287
 
                                              + (size_t) BUFFER_SIZE);
 
134
                                              + BUFFER_SIZE);
288
135
                if (process_itr->buffer == NULL){
289
136
                  perror(argv[0]);
290
137
                  goto end;
293
140
            }
294
141
            ret = read(process_itr->fd, process_itr->buffer
295
142
                       + process_itr->buffer_length, BUFFER_SIZE);
296
 
            if(ret < 0){
297
 
              /* Read error from this process; ignore it */
298
 
              continue;
299
 
            }
300
 
            process_itr->buffer_length += (size_t) ret;
 
143
            process_itr->buffer_length+=ret;
301
144
            if(ret == 0){
302
145
              /* got EOF */
303
146
              /* wait for process exit */
304
147
              int status;
305
148
              waitpid(process_itr->pid, &status, 0);
306
149
              if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
307
 
                for(size_t written = 0;
308
 
                    written < process_itr->buffer_length;){
309
 
                  ret = write(STDOUT_FILENO,
310
 
                              process_itr->buffer + written,
311
 
                              process_itr->buffer_length - written);
312
 
                  if(ret < 0){
313
 
                    perror(argv[0]);
314
 
                    goto end;
315
 
                  }
316
 
                  written += (size_t)ret;
317
 
                }
 
150
                write(STDOUT_FILENO, process_itr->buffer,
 
151
                      process_itr->buffer_length);
318
152
                goto end;
319
153
              } else {
320
154
                FD_CLR(process_itr->fd, &rfds_orig);