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:
- COPYING
- files removed:
- ca.pem
- files renamed:
- server.py => mandos
- server.conf => mandos.conf
- plugbasedclient.c => plugin-runner.c
- plugins.d/passprompt.c => plugins.d/password-prompt.c
- plugins.d/mandosclient.c => plugins.d/password-request.c
- files modified:
- Makefile
added
removed
plugin-runner.c
21
21
* Contact the authors at <mandos@fukt.bsnet.se>.
22
22
*/
23
23
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
25
26
#include <stdio.h> /* popen(), fileno(), fprintf(),
27
stderr, STDOUT_FILENO */
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
25
asprintf() */
26
#include <stddef.h> /* size_t, NULL */
27
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
28
EXIT_SUCCESS, realloc() */
29
#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
33
stat, waitpid(), WIFEXITED(),
34
WEXITSTATUS(), wait(), pid_t,
35
uid_t, gid_t, getuid(), getgid(),
36
dirfd() */
37
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
38
FD_SET(), FD_ISSET(), FD_CLR */
39
#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),
40
WEXITSTATUS() */
41
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
28
42
#include <iso646.h> /* and, or, not */
29
#include <sys/types.h> /* DIR, opendir(), stat(),
30
struct stat, waitpid(),
31
WIFEXITED(), WEXITSTATUS(),
32
wait() */
33
#include <sys/wait.h> /* wait() */
34
43
#include <dirent.h> /* DIR, struct dirent, opendir(),
35
readdir(), closedir() */
36
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
44
readdir(), closedir(), dirfd() */
37
45
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
38
fcntl() */
39
#include <fcntl.h> /* fcntl() */
40
#include <stddef.h> /* NULL */
41
#include <stdlib.h> /* EXIT_FAILURE */
42
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
43
FD_SET(), FD_ISSET() */
44
#include <string.h> /* strlen(), strcpy(), strcat() */
45
#include <stdbool.h> /* true */
46
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
47
WEXITSTATUS() */
46
fcntl(), setuid(), setgid(),
47
F_GETFD, F_SETFD, FD_CLOEXEC,
48
access(), pipe(), fork(), close()
49
dup2, STDOUT_FILENO, _exit(),
50
execv(), write(), read(),
51
close() */
52
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
53
FD_CLOEXEC */
54
#include <string.h> /* strsep, strlen(), asprintf() */
48
55
#include <errno.h> /* errno */
49
#include <argp.h> /* struct argp_option,
50
struct argp_state, struct argp,
51
argp_parse() */
56
#include <argp.h> /* struct argp_option, struct
57
argp_state, struct argp,
58
argp_parse(), ARGP_ERR_UNKNOWN,
59
ARGP_KEY_END, ARGP_KEY_ARG, error_t */
60
#include <signal.h> /* struct sigaction, sigemptyset(),
61
sigaddset(), sigaction(),
62
sigprocmask(), SIG_BLOCK, SIGCHLD,
63
SIG_UNBLOCK, kill() */
64
#include <errno.h> /* errno, EBADF */
65
66
#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>";
52
71
53
72
struct process;
54
73
68
87
char *name; /* can be NULL or any plugin name */
69
88
char **argv;
70
89
int argc;
90
char **environ;
91
int envc;
71
92
bool disabled;
72
93
struct plugin *next;
73
94
} plugin;
74
95
75
plugin *getplugin(char *name, plugin **plugin_list){
96
static plugin *getplugin(char *name, plugin **plugin_list){
76
97
for (plugin *p = *plugin_list; p != NULL; p = p->next){
77
98
if ((p->name == name)
78
99
or (p->name and name and (strcmp(p->name, name) == 0))){
82
103
/* Create a new plugin */
83
104
plugin *new_plugin = malloc(sizeof(plugin));
84
105
if (new_plugin == NULL){
85
perror("malloc");
86
exit(EXIT_FAILURE);
106
return NULL;
87
107
}
88
new_plugin->name = name;
108
*new_plugin = (plugin) { .name = name,
109
.argc = 1,
110
.envc = 0,
111
.disabled = false,
112
.next = *plugin_list };
113
89
114
new_plugin->argv = malloc(sizeof(char *) * 2);
90
115
if (new_plugin->argv == NULL){
91
perror("malloc");
92
exit(EXIT_FAILURE);
116
free(new_plugin);
117
return NULL;
93
118
}
94
119
new_plugin->argv[0] = name;
95
120
new_plugin->argv[1] = NULL;
96
new_plugin->argc = 1;
97
new_plugin->disabled = false;
98
new_plugin->next = *plugin_list;
121
122
new_plugin->environ = malloc(sizeof(char *));
123
if(new_plugin->environ == NULL){
124
free(new_plugin->argv);
125
free(new_plugin);
126
return NULL;
127
}
128
new_plugin->environ[0] = NULL;
99
129
/* Append the new plugin to the list */
100
130
*plugin_list = new_plugin;
101
131
return new_plugin;
102
132
}
103
133
104
void addargument(plugin *p, char *arg){
105
p->argv[p->argc] = arg;
106
p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
107
if (p->argv == NULL){
108
perror("malloc");
109
exit(EXIT_FAILURE);
110
}
111
p->argc++;
112
p->argv[p->argc] = NULL;
113
}
134
/* Helper function for add_argument and add_environment */
135
static bool add_to_char_array(const char *new, char ***array,
136
int *len){
137
/* Resize the pointed-to array to hold one more pointer */
138
*array = realloc(*array, sizeof(char *)
139
* (size_t) ((*len) + 2));
140
/* Malloc check */
141
if(*array == NULL){
142
return false;
143
}
144
/* Make a copy of the new string */
145
char *copy = strdup(new);
146
if(copy == NULL){
147
return false;
148
}
149
/* Insert the copy */
150
(*array)[*len] = copy;
151
(*len)++;
152
/* Add a new terminating NULL pointer to the last element */
153
(*array)[*len] = NULL;
154
return true;
155
}
156
157
/* Add to a plugin's argument vector */
158
static bool add_argument(plugin *p, const char *arg){
159
if(p == NULL){
160
return false;
161
}
162
return add_to_char_array(arg, &(p->argv), &(p->argc));
163
}
164
165
/* Add to a plugin's environment */
166
static bool add_environment(plugin *p, const char *def){
167
if(p == NULL){
168
return false;
169
}
170
return add_to_char_array(def, &(p->environ), &(p->envc));
171
}
172
114
173
115
174
/*
116
175
* Based on the example in the GNU LibC manual chapter 13.13 "File
117
176
* Descriptor Flags".
118
177
* *Note File Descriptor Flags:(libc)Descriptor Flags.
119
178
*/
120
int set_cloexec_flag(int fd)
179
static int set_cloexec_flag(int fd)
121
180
{
122
181
int ret = fcntl(fd, F_GETFD, 0);
123
182
/* If reading the flags failed, return error indication now. */
128
187
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
129
188
}
130
189
131
#define BUFFER_SIZE 256
132
133
const char *argp_program_version = "plugbasedclient 0.9";
134
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
135
136
190
process *process_list = NULL;
137
191
138
192
/* Mark a process as completed when it exits, and save its exit
141
195
process *proc = process_list;
142
196
int status;
143
197
pid_t pid = wait(&status);
198
if(pid == -1){
199
perror("wait");
200
return;
201
}
144
202
while(proc != NULL and proc->pid != pid){
145
proc = proc->next;
203
proc = proc->next;
146
204
}
147
205
if(proc == NULL){
148
206
/* Process not found in process list */
152
210
proc->completed = true;
153
211
}
154
212
213
bool print_out_password(const char *buffer, size_t length){
214
ssize_t ret;
215
if(length>0 and buffer[length-1] == '\n'){
216
length--;
217
}
218
for(size_t written = 0; written < length; written += (size_t)ret){
219
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
220
length - written));
221
if(ret < 0){
222
return false;
223
}
224
}
225
return true;
226
}
227
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;
234
}
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;
247
}
248
155
249
int main(int argc, char *argv[]){
156
const char *plugindir = "/conf/conf.d/mandos/plugins.d";
250
const char *plugindir = "/lib/mandos/plugins.d";
251
const char *argfile = ARGFILE;
252
FILE *conffp;
157
253
size_t d_name_len;
158
254
DIR *dir = NULL;
159
255
struct dirent *dirst;
160
256
struct stat st;
161
257
fd_set rfds_all;
162
258
int ret, maxfd = 0;
259
uid_t uid = 65534;
260
gid_t gid = 65534;
163
261
bool debug = false;
164
262
int exitstatus = EXIT_SUCCESS;
263
struct sigaction old_sigchld_action;
264
struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
265
.sa_flags = SA_NOCLDSTOP };
266
char **custom_argv = NULL;
267
int custom_argc = 0;
165
268
166
269
/* Establish a signal handler */
167
struct sigaction old_sigchld_action,
168
sigchld_action = { .sa_handler = handle_sigchld,
169
.sa_flags = SA_NOCLDSTOP };
170
270
sigemptyset(&sigchld_action.sa_mask);
171
271
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
172
272
if(ret < 0){
184
284
{ .name = "global-options", .key = 'g',
185
285
.arg = "OPTION[,OPTION[,...]]",
186
286
.doc = "Options passed to all plugins" },
287
{ .name = "global-envs", .key = 'e',
288
.arg = "VAR=value",
289
.doc = "Environment variable passed to all plugins" },
187
290
{ .name = "options-for", .key = 'o',
188
291
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
189
292
.doc = "Options passed only to specified plugin" },
293
{ .name = "envs-for", .key = 'f',
294
.arg = "PLUGIN:ENV=value",
295
.doc = "Environment variable passed to specified plugin" },
190
296
{ .name = "disable", .key = 'd',
191
297
.arg = "PLUGIN",
192
298
.doc = "Disable a specific plugin", .group = 1 },
193
299
{ .name = "plugin-dir", .key = 128,
194
300
.arg = "DIRECTORY",
195
301
.doc = "Specify a different plugin directory", .group = 2 },
196
{ .name = "debug", .key = 129,
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,
197
309
.doc = "Debug mode", .group = 3 },
198
310
{ .name = NULL }
199
311
};
205
317
switch (key) {
206
318
case 'g':
207
319
if (arg != NULL){
208
char *p = strtok(arg, ",");
209
do{
210
addargument(getplugin(NULL, plugins), p);
211
p = strtok(NULL, ",");
212
} while (p);
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
}
213
344
}
214
345
break;
215
346
case 'o':
216
347
if (arg != NULL){
217
char *name = strtok(arg, ":");
218
char *p = strtok(NULL, ":");
219
if(p){
220
p = strtok(p, ",");
221
do{
222
addargument(getplugin(name, plugins), p);
223
p = strtok(NULL, ",");
224
} while (p);
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
}
374
{
375
char *envdef = strchr(arg, ':');
376
if(envdef == NULL){
377
break;
378
}
379
char *p_name = strndup(arg, (size_t) (envdef-arg));
380
if(p_name == NULL){
381
break;
382
}
383
envdef++;
384
if(not add_environment(getplugin(p_name, plugins), envdef)){
385
perror("add_environment");
225
386
}
226
387
}
227
388
break;
228
389
case 'd':
229
390
if (arg != NULL){
230
getplugin(arg, plugins)->disabled = true;
391
plugin *p = getplugin(arg, plugins);
392
if(p == NULL){
393
return ARGP_ERR_UNKNOWN;
394
}
395
p->disabled = true;
231
396
}
232
397
break;
233
398
case 128:
234
399
plugindir = arg;
235
400
break;
236
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:
237
408
debug = true;
238
409
break;
239
410
case ARGP_KEY_ARG:
240
argp_usage (state);
411
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
241
412
break;
242
413
case ARGP_KEY_END:
243
414
break;
250
421
plugin *plugin_list = NULL;
251
422
252
423
struct argp argp = { .options = options, .parser = parse_opt,
253
.args_doc = "",
424
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
254
425
.doc = "Mandos plugin runner -- Run plugins" };
255
426
256
argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
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");
435
if(conffp != NULL){
436
char *org_line = NULL;
437
size_t size = 0;
438
ssize_t sret;
439
char *p, *arg, *new_arg, *line;
440
const char whitespace_delims[] = " \r\t\f\v\n";
441
const char comment_delim[] = "#";
442
443
while(true){
444
sret = getline(&org_line, &size, conffp);
445
if(sret == -1){
446
break;
447
}
448
449
line = org_line;
450
arg = strsep(&line, comment_delim);
451
while((p = strsep(&arg, whitespace_delims)) != NULL){
452
if(p[0] == '\0'){
453
continue;
454
}
455
new_arg = strdup(p);
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
}
462
}
463
}
464
free(org_line);
465
} else{
466
/* Check for harmful errors and go to fallback. Other errors might
467
not affect opening plugins */
468
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
469
perror("fopen");
470
exitstatus = EXIT_FAILURE;
471
goto end;
472
}
473
}
474
475
if(custom_argv != NULL){
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;
482
}
483
}
257
484
258
485
if(debug){
259
486
for(plugin *p = plugin_list; p != NULL; p=p->next){
262
489
for(char **a = p->argv; *a != NULL; a++){
263
490
fprintf(stderr, "\tArg: %s\n", *a);
264
491
}
492
fprintf(stderr, "...and %u environment variables\n", p->envc);
493
for(char **a = p->environ; *a != NULL; a++){
494
fprintf(stderr, "\t%s\n", *a);
495
}
265
496
}
266
497
}
267
498
499
ret = setuid(uid);
500
if (ret == -1){
501
perror("setuid");
502
}
503
504
setgid(gid);
505
if (ret == -1){
506
perror("setgid");
507
}
508
268
509
dir = opendir(plugindir);
269
510
if(dir == NULL){
270
511
perror("Could not open plugin dir");
292
533
293
534
// All directory entries have been processed
294
535
if(dirst == NULL){
536
if (errno == EBADF){
537
perror("readdir");
538
exitstatus = EXIT_FAILURE;
539
goto end;
540
}
295
541
break;
296
542
}
297
543
341
587
continue;
342
588
}
343
589
}
344
345
char *filename = malloc(d_name_len + strlen(plugindir) + 2);
346
if (filename == NULL){
347
perror("malloc");
348
exitstatus = EXIT_FAILURE;
349
goto end;
350
}
351
strcpy(filename, plugindir); /* Spurious warning */
352
strcat(filename, "/"); /* Spurious warning */
353
strcat(filename, dirst->d_name); /* Spurious warning */
354
355
stat(filename, &st);
590
591
char *filename;
592
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
593
if(ret < 0){
594
perror("asprintf");
595
continue;
596
}
597
598
ret = stat(filename, &st);
599
if (ret == -1){
600
perror("stat");
601
free(filename);
602
continue;
603
}
356
604
357
605
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
358
606
if(debug){
362
610
free(filename);
363
611
continue;
364
612
}
365
if(getplugin(dirst->d_name, &plugin_list)->disabled){
613
plugin *p = getplugin(dirst->d_name, &plugin_list);
614
if(p == NULL){
615
perror("getplugin");
616
free(filename);
617
continue;
618
}
619
if(p->disabled){
366
620
if(debug){
367
621
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
368
622
dirst->d_name);
370
624
free(filename);
371
625
continue;
372
626
}
373
plugin *p = getplugin(dirst->d_name, &plugin_list);
374
627
{
375
628
/* Add global arguments to argument list for this plugin */
376
629
plugin *g = getplugin(NULL, &plugin_list);
377
for(char **a = g->argv + 1; *a != NULL; a++){
378
addargument(p, *a);
379
}
380
}
630
if(g != NULL){
631
for(char **a = g->argv + 1; *a != NULL; a++){
632
if(not add_argument(p, *a)){
633
perror("add_argument");
634
}
635
}
636
/* Add global environment variables */
637
for(char **e = g->environ; *e != NULL; e++){
638
if(not add_environment(p, *e)){
639
perror("add_environment");
640
}
641
}
642
}
643
}
644
/* If this plugin has any environment variables, we will call
645
using execve and need to duplicate the environment from this
646
process, too. */
647
if(p->environ[0] != NULL){
648
for(char **e = environ; *e != NULL; e++){
649
char *copy = strdup(*e);
650
if(copy == NULL){
651
perror("strdup");
652
continue;
653
}
654
if(not add_environment(p, copy)){
655
perror("add_environment");
656
}
657
}
658
}
659
381
660
int pipefd[2];
382
661
ret = pipe(pipefd);
383
662
if (ret == -1){
406
685
}
407
686
// Starting a new process to be watched
408
687
pid_t pid = fork();
688
if(pid == -1){
689
perror("fork");
690
exitstatus = EXIT_FAILURE;
691
goto end;
692
}
409
693
if(pid == 0){
410
694
/* this is the child process */
411
695
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
418
702
perror("sigprocmask");
419
703
_exit(EXIT_FAILURE);
420
704
}
421
dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
705
706
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
707
if(ret == -1){
708
perror("dup2");
709
_exit(EXIT_FAILURE);
710
}
422
711
423
712
if(dirfd(dir) < 0){
424
713
/* If dir has no file descriptor, we could not set FD_CLOEXEC
425
714
above and must now close it manually here. */
426
715
closedir(dir);
427
716
}
428
if(execv(filename, p->argv) < 0){
429
perror("execv");
430
_exit(EXIT_FAILURE);
717
if(p->environ[0] == NULL){
718
if(execv(filename, p->argv) < 0){
719
perror("execv");
720
_exit(EXIT_FAILURE);
721
}
722
} else {
723
if(execve(filename, p->argv, p->environ) < 0){
724
perror("execve");
725
_exit(EXIT_FAILURE);
726
}
431
727
}
432
728
/* no return */
433
729
}
471
767
for(plugin *next; plugin_list != NULL; plugin_list = next){
472
768
next = plugin_list->next;
473
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
}
474
775
free(plugin_list);
475
776
}
476
777
477
778
closedir(dir);
478
779
dir = NULL;
479
780
480
781
if (process_list == NULL){
481
fprintf(stderr, "No plugin processes started, exiting\n");
482
exitstatus = EXIT_FAILURE;
483
goto end;
782
fprintf(stderr, "No plugin processes started. Incorrect plugin"
783
" directory?\n");
784
process_list = NULL;
484
785
}
485
786
while(process_list){
486
787
fd_set rfds = rfds_all;
501
802
/* Bad exit by plugin */
502
803
if(debug){
503
804
if(WIFEXITED(proc->status)){
504
fprintf(stderr, "Plugin %d exited with status %d\n",
505
proc->pid, WEXITSTATUS(proc->status));
805
fprintf(stderr, "Plugin %u exited with status %d\n",
806
(unsigned int) (proc->pid),
807
WEXITSTATUS(proc->status));
506
808
} else if(WIFSIGNALED(proc->status)) {
507
fprintf(stderr, "Plugin %d killed by signal %d\n",
508
proc->pid, WTERMSIG(proc->status));
809
fprintf(stderr, "Plugin %u killed by signal %d\n",
810
(unsigned int) (proc->pid),
811
WTERMSIG(proc->status));
509
812
} else if(WCOREDUMP(proc->status)){
510
fprintf(stderr, "Plugin %d dumped core\n", proc->pid);
813
fprintf(stderr, "Plugin %d dumped core\n",
814
(unsigned int) (proc->pid));
511
815
}
512
816
}
513
817
/* Remove the plugin */
546
850
break;
547
851
}
548
852
/* This process exited nicely, so print its buffer */
549
for(size_t written = 0; written < proc->buffer_length;
550
written += (size_t)ret){
551
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO,
552
proc->buffer + written,
553
proc->buffer_length
554
- written));
555
if(ret < 0){
556
perror("write");
557
exitstatus = EXIT_FAILURE;
558
goto end;
559
}
853
854
bool bret = print_out_password(proc->buffer, proc->buffer_length);
855
if(not bret){
856
perror("print_out_password");
857
exitstatus = EXIT_FAILURE;
560
858
}
561
859
goto end;
562
860
}
591
889
}
592
890
}
593
891
}
594
if(process_list == NULL){
595
fprintf(stderr, "All plugin processes failed, exiting\n");
596
exitstatus = EXIT_FAILURE;
597
}
598
892
893
599
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 */
898
bool bret;
899
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
900
char *passwordbuffer = getpass("Password: ");
901
bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
902
if(not bret){
903
perror("print_out_password");
904
exitstatus = EXIT_FAILURE;
905
goto end;
906
}
907
}
908
600
909
/* Restore old signal handler */
601
910
sigaction(SIGCHLD, &old_sigchld_action, NULL);
602
911
912
free(custom_argv);
913
603
914
/* Free the plugin list */
604
915
for(plugin *next; plugin_list != NULL; plugin_list = next){
605
916
next = plugin_list->next;
606
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
}
922
}
923
free(plugin_list->environ);
607
924
free(plugin_list);
608
925
}
609
926
615
932
for(process *next; process_list != NULL; process_list = next){
616
933
next = process_list->next;
617
934
close(process_list->fd);
618
kill(process_list->pid, SIGTERM);
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");
939
}
619
940
free(process_list->buffer);
620
941
free(process_list);
621
942
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0