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