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 541
- compare with another revision
- download diff
- download tarball
- view history from revision 541
- Committer: Teddy Hogeborn
- Date: 2011-12-31 20:07:11 UTC
- mfrom: (535.1.9 wireless-network-hook)
- Revision ID: teddy@recompile.se-20111231200711-6dli3r8drftem57r
Merge new wireless network hook. Fix bridge network hook to use
hardware addresses instead of interface names. Implement and document
new "CONNECT" environment variable for network hooks.
hardware addresses instead of interface names. Implement and document
new "CONNECT" environment variable for network hooks.
- files added:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- network-hooks.d
- files removed:
- network-protocol.txt
- files renamed:
- 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
1
/* -*- coding: utf-8 -*- */
1
/* -*- coding: utf-8; mode: c; mode: orgtbl -*- */
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-2011 Teddy Hogeborn
6
* Copyright © 2008-2011 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
18
19
* along with this program. If not, see
19
20
* <http://www.gnu.org/licenses/>.
20
21
*
21
* Contact the authors at <mandos@fukt.bsnet.se>.
22
* Contact the authors at <mandos@recompile.se>.
22
23
*/
23
24
24
25
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
25
asprintf() */
26
asprintf(), O_CLOEXEC */
26
27
#include <stddef.h> /* size_t, NULL */
27
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
28
EXIT_SUCCESS, realloc() */
28
#include <stdlib.h> /* malloc(), exit(), EXIT_SUCCESS,
29
realloc() */
29
30
#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
31
#include <stdio.h> /* fileno(), fprintf(),
32
stderr, STDOUT_FILENO */
33
#include <sys/types.h> /* DIR, fdopendir(), stat(), struct
33
34
stat, waitpid(), WIFEXITED(),
34
35
WEXITSTATUS(), wait(), pid_t,
35
36
uid_t, gid_t, getuid(), getgid(),
37
38
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
38
39
FD_SET(), FD_ISSET(), FD_CLR */
39
40
#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),
40
WEXITSTATUS() */
41
WEXITSTATUS(), WTERMSIG(),
42
WCOREDUMP() */
41
43
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
42
44
#include <iso646.h> /* and, or, not */
43
#include <dirent.h> /* DIR, struct dirent, opendir(),
45
#include <dirent.h> /* DIR, struct dirent, fdopendir(),
44
46
readdir(), closedir(), dirfd() */
45
47
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
46
48
fcntl(), setuid(), setgid(),
47
49
F_GETFD, F_SETFD, FD_CLOEXEC,
48
50
access(), pipe(), fork(), close()
49
dup2, STDOUT_FILENO, _exit(),
51
dup2(), STDOUT_FILENO, _exit(),
50
52
execv(), write(), read(),
51
53
close() */
52
54
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
53
55
FD_CLOEXEC */
54
#include <string.h> /* strsep, strlen(), asprintf() */
56
#include <string.h> /* strsep, strlen(), asprintf(),
57
strsignal(), strcmp(), strncmp() */
55
58
#include <errno.h> /* errno */
56
59
#include <argp.h> /* struct argp_option, struct
57
60
argp_state, struct argp,
58
61
argp_parse(), ARGP_ERR_UNKNOWN,
59
ARGP_KEY_END, ARGP_KEY_ARG, error_t */
62
ARGP_KEY_END, ARGP_KEY_ARG,
63
error_t */
60
64
#include <signal.h> /* struct sigaction, sigemptyset(),
61
65
sigaddset(), sigaction(),
62
66
sigprocmask(), SIG_BLOCK, SIGCHLD,
63
SIG_UNBLOCK, kill() */
67
SIG_UNBLOCK, kill(), sig_atomic_t
68
*/
64
69
#include <errno.h> /* errno, EBADF */
70
#include <inttypes.h> /* intmax_t, PRIdMAX, strtoimax() */
71
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_IOERR,
72
EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
#include <errno.h> /* errno */
74
#include <error.h> /* error() */
65
75
66
76
#define BUFFER_SIZE 256
67
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
68
69
const char *argp_program_version = "plugin-runner 1.0";
70
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
71
72
struct process;
73
74
typedef struct process{
75
pid_t pid;
76
int fd;
77
char *buffer;
78
size_t buffer_size;
79
size_t buffer_length;
80
bool eof;
81
bool completed;
82
int status;
83
struct process *next;
84
} process;
77
78
#define PDIR "/lib/mandos/plugins.d"
79
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
81
const char *argp_program_version = "plugin-runner " VERSION;
82
const char *argp_program_bug_address = "<mandos@recompile.se>";
85
83
86
84
typedef struct plugin{
87
85
char *name; /* can be NULL or any plugin name */
90
88
char **environ;
91
89
int envc;
92
90
bool disabled;
91
92
/* Variables used for running processes*/
93
pid_t pid;
94
int fd;
95
char *buffer;
96
size_t buffer_size;
97
size_t buffer_length;
98
bool eof;
99
volatile sig_atomic_t completed;
100
int status;
93
101
struct plugin *next;
94
102
} plugin;
95
103
96
static plugin *getplugin(char *name, plugin **plugin_list){
97
for (plugin *p = *plugin_list; p != NULL; p = p->next){
98
if ((p->name == name)
99
or (p->name and name and (strcmp(p->name, name) == 0))){
104
static plugin *plugin_list = NULL;
105
106
/* Gets an existing plugin based on name,
107
or if none is found, creates a new one */
108
static plugin *getplugin(char *name){
109
/* Check for existing plugin with that name */
110
for(plugin *p = plugin_list; p != NULL; p = p->next){
111
if((p->name == name)
112
or (p->name and name and (strcmp(p->name, name) == 0))){
100
113
return p;
101
114
}
102
115
}
103
116
/* Create a new plugin */
104
plugin *new_plugin = malloc(sizeof(plugin));
105
if (new_plugin == NULL){
106
return NULL;
107
}
108
char *copy_name = strdup(name);
109
if(copy_name == NULL){
110
return NULL;
111
}
112
113
*new_plugin = (plugin) { .name = copy_name,
114
.argc = 1,
115
.envc = 0,
116
.disabled = false,
117
.next = *plugin_list };
118
119
new_plugin->argv = malloc(sizeof(char *) * 2);
120
if (new_plugin->argv == NULL){
117
plugin *new_plugin = NULL;
118
do {
119
new_plugin = malloc(sizeof(plugin));
120
} while(new_plugin == NULL and errno == EINTR);
121
if(new_plugin == NULL){
122
return NULL;
123
}
124
char *copy_name = NULL;
125
if(name != NULL){
126
do {
127
copy_name = strdup(name);
128
} while(copy_name == NULL and errno == EINTR);
129
if(copy_name == NULL){
130
int e = errno;
131
free(new_plugin);
132
errno = e;
133
return NULL;
134
}
135
}
136
137
*new_plugin = (plugin){ .name = copy_name,
138
.argc = 1,
139
.disabled = false,
140
.next = plugin_list };
141
142
do {
143
new_plugin->argv = malloc(sizeof(char *) * 2);
144
} while(new_plugin->argv == NULL and errno == EINTR);
145
if(new_plugin->argv == NULL){
146
int e = errno;
147
free(copy_name);
121
148
free(new_plugin);
149
errno = e;
122
150
return NULL;
123
151
}
124
152
new_plugin->argv[0] = copy_name;
125
153
new_plugin->argv[1] = NULL;
126
127
new_plugin->environ = malloc(sizeof(char *));
154
155
do {
156
new_plugin->environ = malloc(sizeof(char *));
157
} while(new_plugin->environ == NULL and errno == EINTR);
128
158
if(new_plugin->environ == NULL){
159
int e = errno;
160
free(copy_name);
129
161
free(new_plugin->argv);
130
162
free(new_plugin);
163
errno = e;
131
164
return NULL;
132
165
}
133
166
new_plugin->environ[0] = NULL;
167
134
168
/* Append the new plugin to the list */
135
*plugin_list = new_plugin;
169
plugin_list = new_plugin;
136
170
return new_plugin;
137
171
}
138
172
139
173
/* Helper function for add_argument and add_environment */
174
__attribute__((nonnull))
140
175
static bool add_to_char_array(const char *new, char ***array,
141
176
int *len){
142
177
/* Resize the pointed-to array to hold one more pointer */
143
*array = realloc(*array, sizeof(char *)
144
* (size_t) ((*len) + 2));
178
do {
179
*array = realloc(*array, sizeof(char *)
180
* (size_t) ((*len) + 2));
181
} while(*array == NULL and errno == EINTR);
145
182
/* Malloc check */
146
183
if(*array == NULL){
147
184
return false;
148
185
}
149
186
/* Make a copy of the new string */
150
char *copy = strdup(new);
187
char *copy;
188
do {
189
copy = strdup(new);
190
} while(copy == NULL and errno == EINTR);
151
191
if(copy == NULL){
152
192
return false;
153
193
}
160
200
}
161
201
162
202
/* Add to a plugin's argument vector */
203
__attribute__((nonnull(2)))
163
204
static bool add_argument(plugin *p, const char *arg){
164
205
if(p == NULL){
165
206
return false;
168
209
}
169
210
170
211
/* Add to a plugin's environment */
171
static bool add_environment(plugin *p, const char *def){
212
__attribute__((nonnull(2)))
213
static bool add_environment(plugin *p, const char *def, bool replace){
172
214
if(p == NULL){
173
215
return false;
174
216
}
217
/* namelen = length of name of environment variable */
218
size_t namelen = (size_t)(strchrnul(def, '=') - def);
219
/* Search for this environment variable */
220
for(char **e = p->environ; *e != NULL; e++){
221
if(strncmp(*e, def, namelen + 1) == 0){
222
/* It already exists */
223
if(replace){
224
char *new;
225
do {
226
new = realloc(*e, strlen(def) + 1);
227
} while(new == NULL and errno == EINTR);
228
if(new == NULL){
229
return false;
230
}
231
*e = new;
232
strcpy(*e, def);
233
}
234
return true;
235
}
236
}
175
237
return add_to_char_array(def, &(p->environ), &(p->envc));
176
238
}
177
239
178
179
240
/*
180
241
* Based on the example in the GNU LibC manual chapter 13.13 "File
181
242
* Descriptor Flags".
182
* *Note File Descriptor Flags:(libc)Descriptor Flags.
243
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
183
244
*/
184
static int set_cloexec_flag(int fd)
185
{
186
int ret = fcntl(fd, F_GETFD, 0);
245
static int set_cloexec_flag(int fd){
246
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
187
247
/* If reading the flags failed, return error indication now. */
188
248
if(ret < 0){
189
249
return ret;
190
250
}
191
251
/* Store modified flag word in the descriptor. */
192
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
252
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
ret | FD_CLOEXEC));
193
254
}
194
255
195
process *process_list = NULL;
196
256
197
/* Mark a process as completed when it exits, and save its exit
257
/* Mark processes as completed when they exit, and save their exit
198
258
status. */
199
void handle_sigchld(__attribute__((unused)) int sig){
200
process *proc = process_list;
201
int status;
202
pid_t pid = wait(&status);
203
if(pid == -1){
204
perror("wait");
205
return;
206
}
207
while(proc != NULL and proc->pid != pid){
208
proc = proc->next;
209
}
210
if(proc == NULL){
211
/* Process not found in process list */
212
return;
213
}
214
proc->status = status;
215
proc->completed = true;
259
static void handle_sigchld(__attribute__((unused)) int sig){
260
int old_errno = errno;
261
while(true){
262
plugin *proc = plugin_list;
263
int status;
264
pid_t pid = waitpid(-1, &status, WNOHANG);
265
if(pid == 0){
266
/* Only still running child processes */
267
break;
268
}
269
if(pid == -1){
270
if(errno == ECHILD){
271
/* No child processes */
272
break;
273
}
274
error(0, errno, "waitpid");
275
}
276
277
/* A child exited, find it in process_list */
278
while(proc != NULL and proc->pid != pid){
279
proc = proc->next;
280
}
281
if(proc == NULL){
282
/* Process not found in process list */
283
continue;
284
}
285
proc->status = status;
286
proc->completed = 1;
287
}
288
errno = old_errno;
216
289
}
217
290
218
bool print_out_password(const char *buffer, size_t length){
291
/* Prints out a password to stdout */
292
__attribute__((nonnull))
293
static bool print_out_password(const char *buffer, size_t length){
219
294
ssize_t ret;
220
if(length>0 and buffer[length-1] == '\n'){
221
length--;
222
}
223
295
for(size_t written = 0; written < length; written += (size_t)ret){
224
296
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
225
297
length - written));
230
302
return true;
231
303
}
232
304
233
char **add_to_argv(char **argv, int *argc, char *arg){
234
if (argv == NULL){
235
*argc = 1;
236
argv = malloc(sizeof(char*) * 2);
237
if(argv == NULL){
238
return NULL;
305
/* Removes and free a plugin from the plugin list */
306
__attribute__((nonnull))
307
static void free_plugin(plugin *plugin_node){
308
309
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
310
free(*arg);
311
}
312
free(plugin_node->argv);
313
for(char **env = plugin_node->environ; *env != NULL; env++){
314
free(*env);
315
}
316
free(plugin_node->environ);
317
free(plugin_node->buffer);
318
319
/* Removes the plugin from the singly-linked list */
320
if(plugin_node == plugin_list){
321
/* First one - simple */
322
plugin_list = plugin_list->next;
323
} else {
324
/* Second one or later */
325
for(plugin *p = plugin_list; p != NULL; p = p->next){
326
if(p->next == plugin_node){
327
p->next = plugin_node->next;
328
break;
329
}
239
330
}
240
argv[0] = NULL; /* Will be set to argv[0] in main before parsing */
241
argv[1] = NULL;
242
}
243
*argc += 1;
244
argv = realloc(argv, sizeof(char *)
245
* ((unsigned int) *argc + 1));
246
if(argv == NULL){
247
return NULL;
248
}
249
argv[*argc-1] = arg;
250
argv[*argc] = NULL;
251
return argv;
331
}
332
333
free(plugin_node);
252
334
}
253
335
254
static void free_plugin_list(plugin *plugin_list){
255
for(plugin *next = plugin_list; plugin_list != NULL; plugin_list = next){
256
next = plugin_list->next;
257
free(plugin_list->name);
258
for(char **arg = plugin_list->argv; *arg != NULL; arg++){
259
free(*arg);
260
}
261
free(plugin_list->argv);
262
for(char **env = plugin_list->environ; *env != NULL; env++){
263
free(*env);
264
}
265
free(plugin_list->environ);
266
free(plugin_list);
267
}
336
static void free_plugin_list(void){
337
while(plugin_list != NULL){
338
free_plugin(plugin_list);
339
}
268
340
}
269
341
270
342
int main(int argc, char *argv[]){
271
const char *plugindir = "/lib/mandos/plugins.d";
272
const char *argfile = ARGFILE;
343
char *plugindir = NULL;
344
char *argfile = NULL;
273
345
FILE *conffp;
274
346
size_t d_name_len;
275
347
DIR *dir = NULL;
277
349
struct stat st;
278
350
fd_set rfds_all;
279
351
int ret, maxfd = 0;
352
ssize_t sret;
280
353
uid_t uid = 65534;
281
354
gid_t gid = 65534;
282
355
bool debug = false;
291
364
sigemptyset(&sigchld_action.sa_mask);
292
365
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
293
366
if(ret == -1){
294
perror("sigaddset");
295
exitstatus = EXIT_FAILURE;
367
error(0, errno, "sigaddset");
368
exitstatus = EX_OSERR;
296
369
goto fallback;
297
370
}
298
371
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
299
372
if(ret == -1){
300
perror("sigaction");
301
exitstatus = EXIT_FAILURE;
373
error(0, errno, "sigaction");
374
exitstatus = EX_OSERR;
302
375
goto fallback;
303
376
}
304
377
307
380
{ .name = "global-options", .key = 'g',
308
381
.arg = "OPTION[,OPTION[,...]]",
309
382
.doc = "Options passed to all plugins" },
310
{ .name = "global-envs", .key = 'e',
383
{ .name = "global-env", .key = 'G',
311
384
.arg = "VAR=value",
312
385
.doc = "Environment variable passed to all plugins" },
313
386
{ .name = "options-for", .key = 'o',
314
387
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
315
388
.doc = "Options passed only to specified plugin" },
316
{ .name = "envs-for", .key = 'f',
389
{ .name = "env-for", .key = 'E',
317
390
.arg = "PLUGIN:ENV=value",
318
391
.doc = "Environment variable passed to specified plugin" },
319
392
{ .name = "disable", .key = 'd',
320
393
.arg = "PLUGIN",
321
394
.doc = "Disable a specific plugin", .group = 1 },
395
{ .name = "enable", .key = 'e',
396
.arg = "PLUGIN",
397
.doc = "Enable a specific plugin", .group = 1 },
322
398
{ .name = "plugin-dir", .key = 128,
323
399
.arg = "DIRECTORY",
324
400
.doc = "Specify a different plugin directory", .group = 2 },
325
{ .name = "userid", .key = 129,
326
.arg = "ID", .flags = 0,
327
.doc = "User ID the plugins will run as", .group = 2 },
328
{ .name = "groupid", .key = 130,
329
.arg = "ID", .flags = 0,
330
.doc = "Group ID the plugins will run as", .group = 2 },
331
{ .name = "debug", .key = 131,
332
.doc = "Debug mode", .group = 3 },
401
{ .name = "config-file", .key = 129,
402
.arg = "FILE",
403
.doc = "Specify a different configuration file", .group = 2 },
404
{ .name = "userid", .key = 130,
405
.arg = "ID", .flags = 0,
406
.doc = "User ID the plugins will run as", .group = 3 },
407
{ .name = "groupid", .key = 131,
408
.arg = "ID", .flags = 0,
409
.doc = "Group ID the plugins will run as", .group = 3 },
410
{ .name = "debug", .key = 132,
411
.doc = "Debug mode", .group = 4 },
412
/*
413
* These reproduce what we would get without ARGP_NO_HELP
414
*/
415
{ .name = "help", .key = '?',
416
.doc = "Give this help list", .group = -1 },
417
{ .name = "usage", .key = -3,
418
.doc = "Give a short usage message", .group = -1 },
419
{ .name = "version", .key = 'V',
420
.doc = "Print program version", .group = -1 },
333
421
{ .name = NULL }
334
422
};
335
423
336
error_t parse_opt (int key, char *arg, struct argp_state *state) {
337
/* Get the INPUT argument from `argp_parse', which we know is a
338
pointer to our plugin list pointer. */
339
plugin **plugins = state->input;
340
switch (key) {
341
case 'g':
342
if (arg != NULL){
343
char *p;
344
while((p = strsep(&arg, ",")) != NULL){
345
if(p[0] == '\0'){
346
continue;
347
}
348
if(not add_argument(getplugin(NULL, plugins), p)){
349
perror("add_argument");
350
return ARGP_ERR_UNKNOWN;
351
}
352
}
353
}
354
break;
355
case 'e':
356
if(arg == NULL){
357
break;
358
}
359
{
360
char *envdef = strdup(arg);
361
if(envdef == NULL){
362
break;
363
}
364
if(not add_environment(getplugin(NULL, plugins), envdef)){
365
perror("add_environment");
366
}
367
}
368
break;
369
case 'o':
370
if (arg != NULL){
371
char *p_name = strsep(&arg, ":");
372
if(p_name[0] == '\0'){
373
break;
374
}
375
char *opt = strsep(&arg, ":");
376
if(opt[0] == '\0'){
377
break;
378
}
379
if(opt != NULL){
380
char *p;
381
while((p = strsep(&opt, ",")) != NULL){
382
if(p[0] == '\0'){
383
continue;
384
}
385
if(not add_argument(getplugin(p_name, plugins), p)){
386
perror("add_argument");
387
return ARGP_ERR_UNKNOWN;
388
}
389
}
390
}
391
}
392
break;
393
case 'f':
394
if(arg == NULL){
395
break;
396
}
424
__attribute__((nonnull(3)))
425
error_t parse_opt(int key, char *arg, struct argp_state *state){
426
errno = 0;
427
switch(key){
428
char *tmp;
429
intmax_t tmp_id;
430
case 'g': /* --global-options */
431
{
432
char *plugin_option;
433
while((plugin_option = strsep(&arg, ",")) != NULL){
434
if(not add_argument(getplugin(NULL), plugin_option)){
435
break;
436
}
437
}
438
}
439
break;
440
case 'G': /* --global-env */
441
add_environment(getplugin(NULL), arg, true);
442
break;
443
case 'o': /* --options-for */
444
{
445
char *option_list = strchr(arg, ':');
446
if(option_list == NULL){
447
argp_error(state, "No colon in \"%s\"", arg);
448
errno = EINVAL;
449
break;
450
}
451
*option_list = '\0';
452
option_list++;
453
if(arg[0] == '\0'){
454
argp_error(state, "Empty plugin name");
455
errno = EINVAL;
456
break;
457
}
458
char *option;
459
while((option = strsep(&option_list, ",")) != NULL){
460
if(not add_argument(getplugin(arg), option)){
461
break;
462
}
463
}
464
}
465
break;
466
case 'E': /* --env-for */
397
467
{
398
468
char *envdef = strchr(arg, ':');
399
469
if(envdef == NULL){
400
break;
401
}
402
char *p_name = strndup(arg, (size_t) (envdef-arg));
403
if(p_name == NULL){
404
break;
405
}
470
argp_error(state, "No colon in \"%s\"", arg);
471
errno = EINVAL;
472
break;
473
}
474
*envdef = '\0';
406
475
envdef++;
407
if(not add_environment(getplugin(p_name, plugins), envdef)){
408
perror("add_environment");
409
}
410
}
411
break;
412
case 'd':
413
if (arg != NULL){
414
plugin *p = getplugin(arg, plugins);
415
if(p == NULL){
416
return ARGP_ERR_UNKNOWN;
417
}
418
p->disabled = true;
419
}
420
break;
421
case 128:
422
plugindir = arg;
423
break;
424
case 129:
425
uid = (uid_t)strtol(arg, NULL, 10);
426
break;
427
case 130:
428
gid = (gid_t)strtol(arg, NULL, 10);
429
break;
430
case 131:
476
if(arg[0] == '\0'){
477
argp_error(state, "Empty plugin name");
478
errno = EINVAL;
479
break;
480
}
481
add_environment(getplugin(arg), envdef, true);
482
}
483
break;
484
case 'd': /* --disable */
485
{
486
plugin *p = getplugin(arg);
487
if(p != NULL){
488
p->disabled = true;
489
}
490
}
491
break;
492
case 'e': /* --enable */
493
{
494
plugin *p = getplugin(arg);
495
if(p != NULL){
496
p->disabled = false;
497
}
498
}
499
break;
500
case 128: /* --plugin-dir */
501
free(plugindir);
502
plugindir = strdup(arg);
503
break;
504
case 129: /* --config-file */
505
/* This is already done by parse_opt_config_file() */
506
break;
507
case 130: /* --userid */
508
tmp_id = strtoimax(arg, &tmp, 10);
509
if(errno != 0 or tmp == arg or *tmp != '\0'
510
or tmp_id != (uid_t)tmp_id){
511
argp_error(state, "Bad user ID number: \"%s\", using %"
512
PRIdMAX, arg, (intmax_t)uid);
513
break;
514
}
515
uid = (uid_t)tmp_id;
516
break;
517
case 131: /* --groupid */
518
tmp_id = strtoimax(arg, &tmp, 10);
519
if(errno != 0 or tmp == arg or *tmp != '\0'
520
or tmp_id != (gid_t)tmp_id){
521
argp_error(state, "Bad group ID number: \"%s\", using %"
522
PRIdMAX, arg, (intmax_t)gid);
523
break;
524
}
525
gid = (gid_t)tmp_id;
526
break;
527
case 132: /* --debug */
431
528
debug = true;
432
529
break;
433
case ARGP_KEY_ARG:
434
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
435
break;
436
case ARGP_KEY_END:
437
break;
438
default:
439
return ARGP_ERR_UNKNOWN;
440
}
441
return 0;
442
}
443
444
plugin *plugin_list = NULL;
445
446
struct argp argp = { .options = options, .parser = parse_opt,
447
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
530
/*
531
* These reproduce what we would get without ARGP_NO_HELP
532
*/
533
case '?': /* --help */
534
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
535
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
536
case -3: /* --usage */
537
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
538
argp_state_help(state, state->out_stream,
539
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
540
case 'V': /* --version */
541
fprintf(state->out_stream, "%s\n", argp_program_version);
542
exit(EXIT_SUCCESS);
543
break;
544
/*
545
* When adding more options before this line, remember to also add a
546
* "case" to the "parse_opt_config_file" function below.
547
*/
548
case ARGP_KEY_ARG:
549
/* Cryptsetup always passes an argument, which is an empty
550
string if "none" was specified in /etc/crypttab. So if
551
argument was empty, we ignore it silently. */
552
if(arg[0] == '\0'){
553
break;
554
}
555
default:
556
return ARGP_ERR_UNKNOWN;
557
}
558
return errno; /* Set to 0 at start */
559
}
560
561
/* This option parser is the same as parse_opt() above, except it
562
ignores everything but the --config-file option. */
563
error_t parse_opt_config_file(int key, char *arg,
564
__attribute__((unused))
565
struct argp_state *state){
566
errno = 0;
567
switch(key){
568
case 'g': /* --global-options */
569
case 'G': /* --global-env */
570
case 'o': /* --options-for */
571
case 'E': /* --env-for */
572
case 'd': /* --disable */
573
case 'e': /* --enable */
574
case 128: /* --plugin-dir */
575
break;
576
case 129: /* --config-file */
577
free(argfile);
578
argfile = strdup(arg);
579
break;
580
case 130: /* --userid */
581
case 131: /* --groupid */
582
case 132: /* --debug */
583
case '?': /* --help */
584
case -3: /* --usage */
585
case 'V': /* --version */
586
case ARGP_KEY_ARG:
587
break;
588
default:
589
return ARGP_ERR_UNKNOWN;
590
}
591
return errno;
592
}
593
594
struct argp argp = { .options = options,
595
.parser = parse_opt_config_file,
596
.args_doc = "",
448
597
.doc = "Mandos plugin runner -- Run plugins" };
449
598
450
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
451
if (ret == ARGP_ERR_UNKNOWN){
452
fprintf(stderr, "Unknown error while parsing arguments\n");
453
exitstatus = EXIT_FAILURE;
454
goto fallback;
455
}
456
457
conffp = fopen(argfile, "r");
599
/* Parse using parse_opt_config_file() in order to get the custom
600
config file location, if any. */
601
ret = argp_parse(&argp, argc, argv,
602
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
603
NULL, NULL);
604
switch(ret){
605
case 0:
606
break;
607
case ENOMEM:
608
default:
609
errno = ret;
610
error(0, errno, "argp_parse");
611
exitstatus = EX_OSERR;
612
goto fallback;
613
case EINVAL:
614
exitstatus = EX_USAGE;
615
goto fallback;
616
}
617
618
/* Reset to the normal argument parser */
619
argp.parser = parse_opt;
620
621
/* Open the configfile if available */
622
if(argfile == NULL){
623
conffp = fopen(AFILE, "r");
624
} else {
625
conffp = fopen(argfile, "r");
626
}
458
627
if(conffp != NULL){
459
628
char *org_line = NULL;
460
629
char *p, *arg, *new_arg, *line;
461
630
size_t size = 0;
462
ssize_t sret;
463
631
const char whitespace_delims[] = " \r\t\f\v\n";
464
632
const char comment_delim[] = "#";
465
633
634
custom_argc = 1;
635
custom_argv = malloc(sizeof(char*) * 2);
636
if(custom_argv == NULL){
637
error(0, errno, "malloc");
638
exitstatus = EX_OSERR;
639
goto fallback;
640
}
641
custom_argv[0] = argv[0];
642
custom_argv[1] = NULL;
643
644
/* for each line in the config file, strip whitespace and ignore
645
commented text */
466
646
while(true){
467
647
sret = getline(&org_line, &size, conffp);
468
648
if(sret == -1){
469
649
break;
470
650
}
471
651
472
652
line = org_line;
473
653
arg = strsep(&line, comment_delim);
474
654
while((p = strsep(&arg, whitespace_delims)) != NULL){
476
656
continue;
477
657
}
478
658
new_arg = strdup(p);
479
custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
480
if (custom_argv == NULL){
481
perror("add_to_argv");
482
exitstatus = EXIT_FAILURE;
483
goto fallback;
484
}
659
if(new_arg == NULL){
660
error(0, errno, "strdup");
661
exitstatus = EX_OSERR;
662
free(org_line);
663
goto fallback;
664
}
665
666
custom_argc += 1;
667
custom_argv = realloc(custom_argv, sizeof(char *)
668
* ((unsigned int) custom_argc + 1));
669
if(custom_argv == NULL){
670
error(0, errno, "realloc");
671
exitstatus = EX_OSERR;
672
free(org_line);
673
goto fallback;
674
}
675
custom_argv[custom_argc-1] = new_arg;
676
custom_argv[custom_argc] = NULL;
485
677
}
486
678
}
679
do {
680
ret = fclose(conffp);
681
} while(ret == EOF and errno == EINTR);
682
if(ret == EOF){
683
error(0, errno, "fclose");
684
exitstatus = EX_IOERR;
685
goto fallback;
686
}
487
687
free(org_line);
488
} else{
688
} else {
489
689
/* Check for harmful errors and go to fallback. Other errors might
490
690
not affect opening plugins */
491
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
492
perror("fopen");
493
exitstatus = EXIT_FAILURE;
691
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
692
error(0, errno, "fopen");
693
exitstatus = EX_OSERR;
494
694
goto fallback;
495
695
}
496
696
}
497
697
/* If there were any arguments from the configuration file, pass
698
them to parser as command line arguments */
498
699
if(custom_argv != NULL){
499
custom_argv[0] = argv[0];
500
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
501
if (ret == ARGP_ERR_UNKNOWN){
502
fprintf(stderr, "Unknown error while parsing arguments\n");
503
exitstatus = EXIT_FAILURE;
700
ret = argp_parse(&argp, custom_argc, custom_argv,
701
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
702
NULL, NULL);
703
switch(ret){
704
case 0:
705
break;
706
case ENOMEM:
707
default:
708
errno = ret;
709
error(0, errno, "argp_parse");
710
exitstatus = EX_OSERR;
711
goto fallback;
712
case EINVAL:
713
exitstatus = EX_CONFIG;
504
714
goto fallback;
505
715
}
506
716
}
507
717
718
/* Parse actual command line arguments, to let them override the
719
config file */
720
ret = argp_parse(&argp, argc, argv,
721
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
722
NULL, NULL);
723
switch(ret){
724
case 0:
725
break;
726
case ENOMEM:
727
default:
728
errno = ret;
729
error(0, errno, "argp_parse");
730
exitstatus = EX_OSERR;
731
goto fallback;
732
case EINVAL:
733
exitstatus = EX_USAGE;
734
goto fallback;
735
}
736
508
737
if(debug){
509
738
for(plugin *p = plugin_list; p != NULL; p=p->next){
510
739
fprintf(stderr, "Plugin: %s has %d arguments\n",
512
741
for(char **a = p->argv; *a != NULL; a++){
513
742
fprintf(stderr, "\tArg: %s\n", *a);
514
743
}
515
fprintf(stderr, "...and %u environment variables\n", p->envc);
744
fprintf(stderr, "...and %d environment variables\n", p->envc);
516
745
for(char **a = p->environ; *a != NULL; a++){
517
746
fprintf(stderr, "\t%s\n", *a);
518
747
}
519
748
}
520
749
}
521
750
751
if(getuid() == 0){
752
/* Work around Debian bug #633582:
753
<http://bugs.debian.org/633582> */
754
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
755
if(plugindir_fd == -1){
756
error(0, errno, "open");
757
} else {
758
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
759
if(ret == -1){
760
error(0, errno, "fstat");
761
} else {
762
if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
763
ret = fchown(plugindir_fd, uid, gid);
764
if(ret == -1){
765
error(0, errno, "fchown");
766
}
767
}
768
}
769
TEMP_FAILURE_RETRY(close(plugindir_fd));
770
}
771
}
772
773
/* Lower permissions */
774
setgid(gid);
775
if(ret == -1){
776
error(0, errno, "setgid");
777
}
522
778
ret = setuid(uid);
523
if (ret == -1){
524
perror("setuid");
525
}
526
527
setgid(gid);
528
if (ret == -1){
529
perror("setgid");
530
}
531
532
dir = opendir(plugindir);
533
if(dir == NULL){
534
perror("Could not open plugin dir");
535
exitstatus = EXIT_FAILURE;
536
goto fallback;
537
}
538
539
/* Set the FD_CLOEXEC flag on the directory, if possible */
779
if(ret == -1){
780
error(0, errno, "setuid");
781
}
782
783
/* Open plugin directory with close_on_exec flag */
540
784
{
541
int dir_fd = dirfd(dir);
542
if(dir_fd >= 0){
543
ret = set_cloexec_flag(dir_fd);
544
if(ret < 0){
545
perror("set_cloexec_flag");
546
exitstatus = EXIT_FAILURE;
547
goto fallback;
548
}
785
int dir_fd = -1;
786
if(plugindir == NULL){
787
dir_fd = open(PDIR, O_RDONLY |
788
#ifdef O_CLOEXEC
789
O_CLOEXEC
790
#else /* not O_CLOEXEC */
791
0
792
#endif /* not O_CLOEXEC */
793
);
794
} else {
795
dir_fd = open(plugindir, O_RDONLY |
796
#ifdef O_CLOEXEC
797
O_CLOEXEC
798
#else /* not O_CLOEXEC */
799
0
800
#endif /* not O_CLOEXEC */
801
);
802
}
803
if(dir_fd == -1){
804
error(0, errno, "Could not open plugin dir");
805
exitstatus = EX_UNAVAILABLE;
806
goto fallback;
807
}
808
809
#ifndef O_CLOEXEC
810
/* Set the FD_CLOEXEC flag on the directory */
811
ret = set_cloexec_flag(dir_fd);
812
if(ret < 0){
813
error(0, errno, "set_cloexec_flag");
814
TEMP_FAILURE_RETRY(close(dir_fd));
815
exitstatus = EX_OSERR;
816
goto fallback;
817
}
818
#endif /* O_CLOEXEC */
819
820
dir = fdopendir(dir_fd);
821
if(dir == NULL){
822
error(0, errno, "Could not open plugin dir");
823
TEMP_FAILURE_RETRY(close(dir_fd));
824
exitstatus = EX_OSERR;
825
goto fallback;
549
826
}
550
827
}
551
828
552
829
FD_ZERO(&rfds_all);
553
830
831
/* Read and execute any executable in the plugin directory*/
554
832
while(true){
555
dirst = readdir(dir);
833
do {
834
dirst = readdir(dir);
835
} while(dirst == NULL and errno == EINTR);
556
836
557
// All directory entries have been processed
837
/* All directory entries have been processed */
558
838
if(dirst == NULL){
559
if (errno == EBADF){
560
perror("readdir");
561
exitstatus = EXIT_FAILURE;
839
if(errno == EBADF){
840
error(0, errno, "readdir");
841
exitstatus = EX_IOERR;
562
842
goto fallback;
563
843
}
564
844
break;
566
846
567
847
d_name_len = strlen(dirst->d_name);
568
848
569
// Ignore dotfiles, backup files and other junk
849
/* Ignore dotfiles, backup files and other junk */
570
850
{
571
851
bool bad_name = false;
572
852
574
854
575
855
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
576
856
".dpkg-old",
857
".dpkg-bak",
577
858
".dpkg-divert", NULL };
578
859
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
579
860
size_t pre_len = strlen(*pre);
587
868
break;
588
869
}
589
870
}
590
591
871
if(bad_name){
592
872
continue;
593
873
}
594
595
874
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
596
875
size_t suf_len = strlen(*suf);
597
876
if((d_name_len >= suf_len)
598
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
877
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
599
878
== 0)){
600
879
if(debug){
601
880
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
610
889
continue;
611
890
}
612
891
}
613
892
614
893
char *filename;
615
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
894
if(plugindir == NULL){
895
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
896
dirst->d_name));
897
} else {
898
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
899
plugindir,
900
dirst->d_name));
901
}
616
902
if(ret < 0){
617
perror("asprintf");
903
error(0, errno, "asprintf");
618
904
continue;
619
905
}
620
906
621
ret = stat(filename, &st);
622
if (ret == -1){
623
perror("stat");
907
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
908
if(ret == -1){
909
error(0, errno, "stat");
624
910
free(filename);
625
911
continue;
626
912
}
627
913
628
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
914
/* Ignore non-executable files */
915
if(not S_ISREG(st.st_mode)
916
or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
629
917
if(debug){
630
918
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
631
919
" with bad type or mode\n", filename);
633
921
free(filename);
634
922
continue;
635
923
}
636
plugin *p = getplugin(dirst->d_name, &plugin_list);
924
925
plugin *p = getplugin(dirst->d_name);
637
926
if(p == NULL){
638
perror("getplugin");
927
error(0, errno, "getplugin");
639
928
free(filename);
640
929
continue;
641
930
}
649
938
}
650
939
{
651
940
/* Add global arguments to argument list for this plugin */
652
plugin *g = getplugin(NULL, &plugin_list);
941
plugin *g = getplugin(NULL);
653
942
if(g != NULL){
654
943
for(char **a = g->argv + 1; *a != NULL; a++){
655
944
if(not add_argument(p, *a)){
656
perror("add_argument");
945
error(0, errno, "add_argument");
657
946
}
658
947
}
659
948
/* Add global environment variables */
660
949
for(char **e = g->environ; *e != NULL; e++){
661
if(not add_environment(p, *e)){
662
perror("add_environment");
950
if(not add_environment(p, *e, false)){
951
error(0, errno, "add_environment");
663
952
}
664
953
}
665
954
}
669
958
process, too. */
670
959
if(p->environ[0] != NULL){
671
960
for(char **e = environ; *e != NULL; e++){
672
char *copy = strdup(*e);
673
if(copy == NULL){
674
perror("strdup");
675
continue;
676
}
677
if(not add_environment(p, copy)){
678
perror("add_environment");
961
if(not add_environment(p, *e, false)){
962
error(0, errno, "add_environment");
679
963
}
680
964
}
681
965
}
682
966
683
int pipefd[2];
684
ret = pipe(pipefd);
685
if (ret == -1){
686
perror("pipe");
687
exitstatus = EXIT_FAILURE;
967
int pipefd[2];
968
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
969
if(ret == -1){
970
error(0, errno, "pipe");
971
exitstatus = EX_OSERR;
688
972
goto fallback;
689
973
}
974
/* Ask OS to automatic close the pipe on exec */
690
975
ret = set_cloexec_flag(pipefd[0]);
691
976
if(ret < 0){
692
perror("set_cloexec_flag");
693
exitstatus = EXIT_FAILURE;
977
error(0, errno, "set_cloexec_flag");
978
exitstatus = EX_OSERR;
694
979
goto fallback;
695
980
}
696
981
ret = set_cloexec_flag(pipefd[1]);
697
982
if(ret < 0){
698
perror("set_cloexec_flag");
699
exitstatus = EXIT_FAILURE;
983
error(0, errno, "set_cloexec_flag");
984
exitstatus = EX_OSERR;
700
985
goto fallback;
701
986
}
702
987
/* Block SIGCHLD until process is safely in process list */
703
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
988
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
989
&sigchld_action.sa_mask,
990
NULL));
704
991
if(ret < 0){
705
perror("sigprocmask");
706
exitstatus = EXIT_FAILURE;
992
error(0, errno, "sigprocmask");
993
exitstatus = EX_OSERR;
707
994
goto fallback;
708
995
}
709
// Starting a new process to be watched
710
pid_t pid = fork();
996
/* Starting a new process to be watched */
997
pid_t pid;
998
do {
999
pid = fork();
1000
} while(pid == -1 and errno == EINTR);
711
1001
if(pid == -1){
712
perror("fork");
713
exitstatus = EXIT_FAILURE;
1002
error(0, errno, "fork");
1003
exitstatus = EX_OSERR;
714
1004
goto fallback;
715
1005
}
716
1006
if(pid == 0){
717
1007
/* this is the child process */
718
1008
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
719
1009
if(ret < 0){
720
perror("sigaction");
721
_exit(EXIT_FAILURE);
1010
error(0, errno, "sigaction");
1011
_exit(EX_OSERR);
722
1012
}
723
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1013
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
724
1014
if(ret < 0){
725
perror("sigprocmask");
726
_exit(EXIT_FAILURE);
1015
error(0, errno, "sigprocmask");
1016
_exit(EX_OSERR);
727
1017
}
728
1018
729
1019
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
730
1020
if(ret == -1){
731
perror("dup2");
732
_exit(EXIT_FAILURE);
1021
error(0, errno, "dup2");
1022
_exit(EX_OSERR);
733
1023
}
734
1024
735
1025
if(dirfd(dir) < 0){
739
1029
}
740
1030
if(p->environ[0] == NULL){
741
1031
if(execv(filename, p->argv) < 0){
742
perror("execv");
743
_exit(EXIT_FAILURE);
1032
error(0, errno, "execv for %s", filename);
1033
_exit(EX_OSERR);
744
1034
}
745
1035
} else {
746
1036
if(execve(filename, p->argv, p->environ) < 0){
747
perror("execve");
748
_exit(EXIT_FAILURE);
1037
error(0, errno, "execve for %s", filename);
1038
_exit(EX_OSERR);
749
1039
}
750
1040
}
751
1041
/* no return */
752
1042
}
753
/* parent process */
1043
/* Parent process */
1044
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
pipe */
754
1046
free(filename);
755
close(pipefd[1]); /* close unused write end of pipe */
756
process *new_process = malloc(sizeof(process));
757
if (new_process == NULL){
758
perror("malloc");
759
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1047
plugin *new_plugin = getplugin(dirst->d_name);
1048
if(new_plugin == NULL){
1049
error(0, errno, "getplugin");
1050
ret = (int)(TEMP_FAILURE_RETRY
1051
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1052
NULL)));
760
1053
if(ret < 0){
761
perror("sigprocmask");
1054
error(0, errno, "sigprocmask");
762
1055
}
763
exitstatus = EXIT_FAILURE;
1056
exitstatus = EX_OSERR;
764
1057
goto fallback;
765
1058
}
766
1059
767
*new_process = (struct process){ .pid = pid,
768
.fd = pipefd[0],
769
.next = process_list };
770
// List handling
771
process_list = new_process;
1060
new_plugin->pid = pid;
1061
new_plugin->fd = pipefd[0];
1062
772
1063
/* Unblock SIGCHLD so signal handler can be run if this process
773
1064
has already completed */
774
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1065
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1066
&sigchld_action.sa_mask,
1067
NULL));
775
1068
if(ret < 0){
776
perror("sigprocmask");
777
exitstatus = EXIT_FAILURE;
1069
error(0, errno, "sigprocmask");
1070
exitstatus = EX_OSERR;
778
1071
goto fallback;
779
1072
}
780
1073
781
FD_SET(new_process->fd, &rfds_all);
1074
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1075
-Wconversion */
782
1076
783
if (maxfd < new_process->fd){
784
maxfd = new_process->fd;
1077
if(maxfd < new_plugin->fd){
1078
maxfd = new_plugin->fd;
785
1079
}
786
787
1080
}
788
1081
789
free_plugin_list(plugin_list);
790
791
closedir(dir);
1082
TEMP_FAILURE_RETRY(closedir(dir));
792
1083
dir = NULL;
793
794
if (process_list == NULL){
795
fprintf(stderr, "No plugin processes started. Incorrect plugin"
796
" directory?\n");
797
process_list = NULL;
1084
free_plugin(getplugin(NULL));
1085
1086
for(plugin *p = plugin_list; p != NULL; p = p->next){
1087
if(p->pid != 0){
1088
break;
1089
}
1090
if(p->next == NULL){
1091
fprintf(stderr, "No plugin processes started. Incorrect plugin"
1092
" directory?\n");
1093
free_plugin_list();
1094
}
798
1095
}
799
while(process_list){
1096
1097
/* Main loop while running plugins exist */
1098
while(plugin_list){
800
1099
fd_set rfds = rfds_all;
801
1100
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
802
if (select_ret == -1){
803
perror("select");
804
exitstatus = EXIT_FAILURE;
1101
if(select_ret == -1 and errno != EINTR){
1102
error(0, errno, "select");
1103
exitstatus = EX_OSERR;
805
1104
goto fallback;
806
1105
}
807
1106
/* OK, now either a process completed, or something can be read
808
1107
from one of them */
809
for(process *proc = process_list; proc ; proc = proc->next){
1108
for(plugin *proc = plugin_list; proc != NULL;){
810
1109
/* Is this process completely done? */
811
if(proc->eof and proc->completed){
1110
if(proc->completed and proc->eof){
812
1111
/* Only accept the plugin output if it exited cleanly */
813
1112
if(not WIFEXITED(proc->status)
814
1113
or WEXITSTATUS(proc->status) != 0){
815
1114
/* Bad exit by plugin */
1115
816
1116
if(debug){
817
1117
if(WIFEXITED(proc->status)){
818
fprintf(stderr, "Plugin %u exited with status %d\n",
819
(unsigned int) (proc->pid),
1118
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1119
" status %d\n", proc->name,
1120
(intmax_t) (proc->pid),
820
1121
WEXITSTATUS(proc->status));
821
} else if(WIFSIGNALED(proc->status)) {
822
fprintf(stderr, "Plugin %u killed by signal %d\n",
823
(unsigned int) (proc->pid),
824
WTERMSIG(proc->status));
1122
} else if(WIFSIGNALED(proc->status)){
1123
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
1124
" signal %d: %s\n", proc->name,
1125
(intmax_t) (proc->pid),
1126
WTERMSIG(proc->status),
1127
strsignal(WTERMSIG(proc->status)));
825
1128
} else if(WCOREDUMP(proc->status)){
826
fprintf(stderr, "Plugin %d dumped core\n",
827
(unsigned int) (proc->pid));
1129
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1130
" core\n", proc->name, (intmax_t) (proc->pid));
828
1131
}
829
1132
}
1133
830
1134
/* Remove the plugin */
831
FD_CLR(proc->fd, &rfds_all);
1135
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1136
-Wconversion */
1137
832
1138
/* Block signal while modifying process_list */
833
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1139
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1140
(SIG_BLOCK,
1141
&sigchld_action.sa_mask,
1142
NULL));
834
1143
if(ret < 0){
835
perror("sigprocmask");
836
exitstatus = EXIT_FAILURE;
1144
error(0, errno, "sigprocmask");
1145
exitstatus = EX_OSERR;
837
1146
goto fallback;
838
1147
}
839
/* Delete this process entry from the list */
840
if(process_list == proc){
841
/* First one - simple */
842
process_list = proc->next;
843
} else {
844
/* Second one or later */
845
for(process *p = process_list; p != NULL; p = p->next){
846
if(p->next == proc){
847
p->next = proc->next;
848
break;
849
}
850
}
851
}
1148
1149
plugin *next_plugin = proc->next;
1150
free_plugin(proc);
1151
proc = next_plugin;
1152
852
1153
/* We are done modifying process list, so unblock signal */
853
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
854
NULL);
1154
ret = (int)(TEMP_FAILURE_RETRY
1155
(sigprocmask(SIG_UNBLOCK,
1156
&sigchld_action.sa_mask, NULL)));
855
1157
if(ret < 0){
856
perror("sigprocmask");
857
}
858
free(proc->buffer);
859
free(proc);
860
/* We deleted this process from the list, so we can't go
861
proc->next. Therefore, start over from the beginning of
862
the process list */
863
break;
1158
error(0, errno, "sigprocmask");
1159
exitstatus = EX_OSERR;
1160
goto fallback;
1161
}
1162
1163
if(plugin_list == NULL){
1164
break;
1165
}
1166
1167
continue;
864
1168
}
1169
865
1170
/* This process exited nicely, so print its buffer */
866
867
bool bret = print_out_password(proc->buffer, proc->buffer_length);
1171
1172
bool bret = print_out_password(proc->buffer,
1173
proc->buffer_length);
868
1174
if(not bret){
869
perror("print_out_password");
870
exitstatus = EXIT_FAILURE;
1175
error(0, errno, "print_out_password");
1176
exitstatus = EX_IOERR;
871
1177
}
872
1178
goto fallback;
873
1179
}
1180
874
1181
/* This process has not completed. Does it have any output? */
875
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1182
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1183
warning from
1184
-Wconversion */
876
1185
/* This process had nothing to say at this time */
1186
proc = proc->next;
877
1187
continue;
878
1188
}
879
1189
/* Before reading, make the process' data buffer large enough */
880
1190
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
881
1191
proc->buffer = realloc(proc->buffer, proc->buffer_size
882
1192
+ (size_t) BUFFER_SIZE);
883
if (proc->buffer == NULL){
884
perror("malloc");
885
exitstatus = EXIT_FAILURE;
1193
if(proc->buffer == NULL){
1194
error(0, errno, "malloc");
1195
exitstatus = EX_OSERR;
886
1196
goto fallback;
887
1197
}
888
1198
proc->buffer_size += BUFFER_SIZE;
889
1199
}
890
1200
/* Read from the process */
891
ret = read(proc->fd, proc->buffer + proc->buffer_length,
892
BUFFER_SIZE);
893
if(ret < 0){
1201
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1202
proc->buffer
1203
+ proc->buffer_length,
1204
BUFFER_SIZE));
1205
if(sret < 0){
894
1206
/* Read error from this process; ignore the error */
1207
proc = proc->next;
895
1208
continue;
896
1209
}
897
if(ret == 0){
1210
if(sret == 0){
898
1211
/* got EOF */
899
1212
proc->eof = true;
900
1213
} else {
901
proc->buffer_length += (size_t) ret;
1214
proc->buffer_length += (size_t) sret;
902
1215
}
903
1216
}
904
1217
}
905
906
1218
1219
907
1220
fallback:
908
1221
909
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
910
/* Fallback if all plugins failed, none are found or an error occured */
1222
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1223
and exitstatus != EX_OK)){
1224
/* Fallback if all plugins failed, none are found or an error
1225
occured */
911
1226
bool bret;
912
1227
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
913
1228
char *passwordbuffer = getpass("Password: ");
914
bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
1229
size_t len = strlen(passwordbuffer);
1230
/* Strip trailing newline */
1231
if(len > 0 and passwordbuffer[len-1] == '\n'){
1232
passwordbuffer[len-1] = '\0'; /* not strictly necessary */
1233
len--;
1234
}
1235
bret = print_out_password(passwordbuffer, len);
915
1236
if(not bret){
916
perror("print_out_password");
917
exitstatus = EXIT_FAILURE;
1237
error(0, errno, "print_out_password");
1238
exitstatus = EX_IOERR;
918
1239
}
919
1240
}
920
1241
921
1242
/* Restore old signal handler */
922
1243
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
923
1244
if(ret == -1){
924
perror("sigaction");
925
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "sigaction");
1246
exitstatus = EX_OSERR;
926
1247
}
927
1248
928
1249
if(custom_argv != NULL){
929
for(char **arg = custom_argv; *arg != NULL; arg++){
1250
for(char **arg = custom_argv+1; *arg != NULL; arg++){
930
1251
free(*arg);
931
1252
}
932
1253
free(custom_argv);
933
1254
}
934
free_plugin_list(plugin_list);
935
1255
936
1256
if(dir != NULL){
937
1257
closedir(dir);
938
1258
}
939
1259
940
/* Free the process list and kill the processes */
941
for(process *next; process_list != NULL; process_list = next){
942
next = process_list->next;
943
close(process_list->fd);
944
ret = kill(process_list->pid, SIGTERM);
945
if(ret == -1 and errno != ESRCH){
946
/* set-uid proccesses migth not get closed */
947
perror("kill");
1260
/* Kill the processes */
1261
for(plugin *p = plugin_list; p != NULL; p = p->next){
1262
if(p->pid != 0){
1263
close(p->fd);
1264
ret = kill(p->pid, SIGTERM);
1265
if(ret == -1 and errno != ESRCH){
1266
/* Set-uid proccesses might not get closed */
1267
error(0, errno, "kill");
1268
}
948
1269
}
949
free(process_list->buffer);
950
free(process_list);
951
1270
}
952
1271
953
1272
/* Wait for any remaining child processes to terminate */
954
do{
1273
do {
955
1274
ret = wait(NULL);
956
1275
} while(ret >= 0);
957
1276
if(errno != ECHILD){
958
perror("wait");
1277
error(0, errno, "wait");
959
1278
}
960
1279
1280
free_plugin_list();
1281
1282
free(plugindir);
1283
free(argfile);
1284
961
1285
return exitstatus;
962
1286
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0