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