To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugbasedclient.c
- browse files at revision 13
- compare with another revision
- download diff
- download tarball
- view history from revision 13
- Committer: Björn Påhlsson
- Date: 2008-07-20 02:52:20 UTC
- Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
Avahi instead of udp server discovery
openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server
Pluginbased client handler
rewritten Mandos client
Avahi instead of udp server discovery
openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server
- files added:
- ca.pem
- files removed:
- initramfs-tools-hook
- files renamed:
- clients.conf => mandos-clients.conf
- mandos-client.c => plugbasedclient.c
- plugins.d/password-request.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos => server.py
- files modified:
- Makefile
added
removed
plugbasedclient.c
1
/* -*- coding: utf-8 -*- */
2
/*
3
* Mandos plugin runner - Run Mandos plugins
4
*
5
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
*
7
* This program is free software: you can redistribute it and/or
8
* modify it under the terms of the GNU General Public License as
9
* published by the Free Software Foundation, either version 3 of the
10
* License, or (at your option) any later version.
11
*
12
* This program is distributed in the hope that it will be useful, but
13
* WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
* General Public License for more details.
16
*
17
* You should have received a copy of the GNU General Public License
18
* along with this program. If not, see
19
* <http://www.gnu.org/licenses/>.
20
*
21
* Contact the authors at <mandos@fukt.bsnet.se>.
22
*/
23
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
25
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() */
42
#include <iso646.h> /* and, or, not */
43
#include <dirent.h> /* DIR, struct dirent, opendir(),
44
readdir(), closedir(), dirfd() */
45
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
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> /* strtok, strlen(), strcpy(),
55
strcat() */
56
#include <errno.h> /* errno */
57
#include <argp.h> /* struct argp_option, struct
58
argp_state, struct argp,
59
argp_parse(), ARGP_ERR_UNKNOWN,
60
ARGP_KEY_END, ARGP_KEY_ARG, error_t */
61
#include <signal.h> /* struct sigaction, sigemptyset(),
62
sigaddset(), sigaction(),
63
sigprocmask(), SIG_BLOCK, SIGCHLD,
64
SIG_UNBLOCK, kill() */
65
#include <errno.h> /* errno, EBADF */
66
67
#define BUFFER_SIZE 256
68
69
const char *argp_program_version = "mandos-client 1.0";
70
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
1
#include <stdio.h> /* popen, fileno */
2
#include <iso646.h> /* and, or, not */
3
#include <sys/types.h> /* DIR, opendir, stat, struct stat, waitpid,
4
WIFEXITED, WEXITSTATUS, wait */
5
#include <sys/wait.h> /* wait */
6
#include <dirent.h> /* DIR, opendir */
7
#include <sys/stat.h> /* stat, struct stat */
8
#include <unistd.h> /* stat, struct stat, chdir */
9
#include <stdlib.h> /* EXIT_FAILURE */
10
#include <sys/select.h> /* fd_set, select, FD_ZERO, FD_SET, FD_ISSET */
11
#include <string.h> /* strlen, strcpy, strcat */
12
#include <stdbool.h> /* true */
13
#include <sys/wait.h> /* waitpid, WIFEXITED, WEXITSTATUS */
14
#include <errno.h> /* errno */
71
15
72
16
struct process;
73
17
75
19
pid_t pid;
76
20
int fd;
77
21
char *buffer;
78
size_t buffer_size;
79
size_t buffer_length;
80
bool eof;
81
bool completed;
82
int status;
22
int buffer_size;
23
int buffer_length;
83
24
struct process *next;
84
25
} process;
85
26
86
typedef struct plugin{
87
char *name; /* can be NULL or any plugin name */
88
char **argv;
89
int argc;
90
bool disabled;
91
struct plugin *next;
92
} plugin;
93
94
static plugin *getplugin(char *name, plugin **plugin_list){
95
for (plugin *p = *plugin_list; p != NULL; p = p->next){
96
if ((p->name == name)
97
or (p->name and name and (strcmp(p->name, name) == 0))){
98
return p;
99
}
100
}
101
/* Create a new plugin */
102
plugin *new_plugin = malloc(sizeof(plugin));
103
if (new_plugin == NULL){
104
perror("malloc");
105
exit(EXIT_FAILURE);
106
}
107
new_plugin->name = name;
108
new_plugin->argv = malloc(sizeof(char *) * 2);
109
if (new_plugin->argv == NULL){
110
perror("malloc");
111
exit(EXIT_FAILURE);
112
}
113
new_plugin->argv[0] = name;
114
new_plugin->argv[1] = NULL;
115
new_plugin->argc = 1;
116
new_plugin->disabled = false;
117
new_plugin->next = *plugin_list;
118
/* Append the new plugin to the list */
119
*plugin_list = new_plugin;
120
return new_plugin;
121
}
122
123
static void addargument(plugin *p, char *arg){
124
p->argv[p->argc] = arg;
125
p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
126
if (p->argv == NULL){
127
perror("malloc");
128
exit(EXIT_FAILURE);
129
}
130
p->argc++;
131
p->argv[p->argc] = NULL;
132
}
133
134
/*
135
* Based on the example in the GNU LibC manual chapter 13.13 "File
136
* Descriptor Flags".
137
* *Note File Descriptor Flags:(libc)Descriptor Flags.
138
*/
139
static int set_cloexec_flag(int fd)
140
{
141
int ret = fcntl(fd, F_GETFD, 0);
142
/* If reading the flags failed, return error indication now. */
143
if(ret < 0){
144
return ret;
145
}
146
/* Store modified flag word in the descriptor. */
147
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
148
}
149
150
process *process_list = NULL;
151
152
/* Mark a process as completed when it exits, and save its exit
153
status. */
154
void handle_sigchld(__attribute__((unused)) int sig){
155
process *proc = process_list;
156
int status;
157
pid_t pid = wait(&status);
158
if(pid == -1){
159
perror("wait");
160
return;
161
}
162
while(proc != NULL and proc->pid != pid){
163
proc = proc->next;
164
}
165
if(proc == NULL){
166
/* Process not found in process list */
167
return;
168
}
169
proc->status = status;
170
proc->completed = true;
171
}
172
173
bool print_out_password(const char *buffer, size_t length){
174
ssize_t ret;
175
if(length>0 and buffer[length-1] == '\n'){
176
length--;
177
}
178
for(size_t written = 0; written < length; written += (size_t)ret){
179
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
180
length - written));
181
if(ret < 0){
182
return false;
183
}
184
}
185
return true;
186
}
27
#define BUFFER_SIZE 256
187
28
188
29
int main(int argc, char *argv[]){
189
const char *plugindir = "/conf/conf.d/mandos/plugins.d";
190
size_t d_name_len;
191
DIR *dir = NULL;
30
char plugindir[] = "plugins.d";
31
size_t d_name_len, plugindir_len = sizeof(plugindir)-1;
32
DIR *dir;
192
33
struct dirent *dirst;
193
34
struct stat st;
194
fd_set rfds_all;
35
fd_set rfds_orig;
195
36
int ret, maxfd = 0;
196
uid_t uid = 65534;
197
gid_t gid = 65534;
198
bool debug = false;
199
int exitstatus = EXIT_SUCCESS;
200
struct sigaction old_sigchld_action;
201
struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
202
.sa_flags = SA_NOCLDSTOP };
203
char *plus_options = NULL;
204
char **plus_argv = NULL;
205
206
/* Establish a signal handler */
207
sigemptyset(&sigchld_action.sa_mask);
208
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
209
if(ret < 0){
210
perror("sigaddset");
211
exit(EXIT_FAILURE);
212
}
213
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
214
if(ret < 0){
215
perror("sigaction");
216
exit(EXIT_FAILURE);
217
}
218
219
/* The options we understand. */
220
struct argp_option options[] = {
221
{ .name = "global-options", .key = 'g',
222
.arg = "OPTION[,OPTION[,...]]",
223
.doc = "Options passed to all plugins" },
224
{ .name = "options-for", .key = 'o',
225
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
226
.doc = "Options passed only to specified plugin" },
227
{ .name = "disable", .key = 'd',
228
.arg = "PLUGIN",
229
.doc = "Disable a specific plugin", .group = 1 },
230
{ .name = "plugin-dir", .key = 128,
231
.arg = "DIRECTORY",
232
.doc = "Specify a different plugin directory", .group = 2 },
233
{ .name = "userid", .key = 129,
234
.arg = "ID", .flags = 0,
235
.doc = "User ID the plugins will run as", .group = 2 },
236
{ .name = "groupid", .key = 130,
237
.arg = "ID", .flags = 0,
238
.doc = "Group ID the plugins will run as", .group = 2 },
239
{ .name = "debug", .key = 131,
240
.doc = "Debug mode", .group = 3 },
241
{ .name = NULL }
242
};
243
244
error_t parse_opt (int key, char *arg, struct argp_state *state) {
245
/* Get the INPUT argument from `argp_parse', which we know is a
246
pointer to our plugin list pointer. */
247
plugin **plugins = state->input;
248
switch (key) {
249
case 'g':
250
if (arg != NULL){
251
char *p = strtok(arg, ",");
252
do{
253
addargument(getplugin(NULL, plugins), p);
254
p = strtok(NULL, ",");
255
} while (p != NULL);
256
}
257
break;
258
case 'o':
259
if (arg != NULL){
260
char *name = strtok(arg, ":");
261
char *p = strtok(NULL, ":");
262
if(p != NULL){
263
p = strtok(p, ",");
264
do{
265
addargument(getplugin(name, plugins), p);
266
p = strtok(NULL, ",");
267
} while (p != NULL);
268
}
269
}
270
break;
271
case 'd':
272
if (arg != NULL){
273
getplugin(arg, plugins)->disabled = true;
274
}
275
break;
276
case 128:
277
plugindir = arg;
278
break;
279
case 129:
280
uid = (uid_t)strtol(arg, NULL, 10);
281
break;
282
case 130:
283
gid = (gid_t)strtol(arg, NULL, 10);
284
break;
285
case 131:
286
debug = true;
287
break;
288
case ARGP_KEY_ARG:
289
if(plus_options != NULL or arg == NULL or arg[0] != '+'){
290
argp_usage (state);
291
}
292
plus_options = arg;
293
break;
294
case ARGP_KEY_END:
295
break;
296
default:
297
return ARGP_ERR_UNKNOWN;
298
}
299
return 0;
300
}
301
302
plugin *plugin_list = NULL;
303
304
struct argp argp = { .options = options, .parser = parse_opt,
305
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
306
.doc = "Mandos plugin runner -- Run plugins" };
307
308
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
309
if (ret == ARGP_ERR_UNKNOWN){
310
fprintf(stderr, "Unknown error while parsing arguments\n");
311
exitstatus = EXIT_FAILURE;
312
goto end;
313
}
314
315
if(plus_options){
316
/* This is a mangled argument in the form of
317
"+--option+--other-option=parameter+--yet-another-option", etc */
318
/* Make new argc and argv vars, and call argp_parse() again. */
319
plus_options++; /* skip the first '+' character */
320
const char delims[] = "+";
321
char *arg;
322
int new_argc = 1;
323
plus_argv = malloc(sizeof(char*) * 2);
324
if(plus_argv == NULL){
325
perror("malloc");
326
exitstatus = EXIT_FAILURE;
327
goto end;
328
}
329
plus_argv[0] = argv[0];
330
plus_argv[1] = NULL;
331
arg = strtok(plus_options, delims); /* Get first argument */
332
while(arg != NULL){
333
new_argc++;
334
plus_argv = realloc(plus_argv, sizeof(char *)
335
* ((unsigned int) new_argc + 1));
336
if(plus_argv == NULL){
337
perror("realloc");
338
exitstatus = EXIT_FAILURE;
339
goto end;
340
}
341
plus_argv[new_argc-1] = arg;
342
plus_argv[new_argc] = NULL;
343
arg = strtok(NULL, delims); /* Get next argument */
344
}
345
ret = argp_parse (&argp, new_argc, plus_argv, 0, 0, &plugin_list);
346
if (ret == ARGP_ERR_UNKNOWN){
347
fprintf(stderr, "Unknown error while parsing arguments\n");
348
exitstatus = EXIT_FAILURE;
349
goto end;
350
}
351
}
352
353
if(debug){
354
for(plugin *p = plugin_list; p != NULL; p=p->next){
355
fprintf(stderr, "Plugin: %s has %d arguments\n",
356
p->name ? p->name : "Global", p->argc - 1);
357
for(char **a = p->argv; *a != NULL; a++){
358
fprintf(stderr, "\tArg: %s\n", *a);
359
}
360
}
361
}
362
363
ret = setuid(uid);
364
if (ret == -1){
365
perror("setuid");
366
}
367
368
setgid(gid);
369
if (ret == -1){
370
perror("setgid");
371
}
37
process *process_list = NULL;
372
38
373
39
dir = opendir(plugindir);
40
374
41
if(dir == NULL){
375
perror("Could not open plugin dir");
376
exitstatus = EXIT_FAILURE;
377
goto end;
378
}
379
380
/* Set the FD_CLOEXEC flag on the directory, if possible */
381
{
382
int dir_fd = dirfd(dir);
383
if(dir_fd >= 0){
384
ret = set_cloexec_flag(dir_fd);
385
if(ret < 0){
386
perror("set_cloexec_flag");
387
exitstatus = EXIT_FAILURE;
388
goto end;
389
}
390
}
391
}
392
393
FD_ZERO(&rfds_all);
42
fprintf(stderr, "Can not open directory\n");
43
return EXIT_FAILURE;
44
}
45
46
FD_ZERO(&rfds_orig);
394
47
395
48
while(true){
396
49
dirst = readdir(dir);
397
50
398
51
// All directory entries have been processed
399
52
if(dirst == NULL){
400
if (errno == EBADF){
401
perror("readdir");
402
exitstatus = EXIT_FAILURE;
403
goto end;
404
}
405
53
break;
406
54
}
407
55
408
56
d_name_len = strlen(dirst->d_name);
409
57
410
// Ignore dotfiles, backup files and other junk
411
{
412
bool bad_name = false;
413
414
const char const *bad_prefixes[] = { ".", "#", NULL };
415
416
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
417
".dpkg-old",
418
".dpkg-divert", NULL };
419
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
420
size_t pre_len = strlen(*pre);
421
if((d_name_len >= pre_len)
422
and strncmp((dirst->d_name), *pre, pre_len) == 0){
423
if(debug){
424
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
425
" with bad prefix %s\n", dirst->d_name, *pre);
426
}
427
bad_name = true;
428
break;
429
}
430
}
431
432
if(bad_name){
433
continue;
434
}
435
436
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
437
size_t suf_len = strlen(*suf);
438
if((d_name_len >= suf_len)
439
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
440
== 0)){
441
if(debug){
442
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
443
" with bad suffix %s\n", dirst->d_name, *suf);
444
}
445
bad_name = true;
446
break;
447
}
448
}
449
450
if(bad_name){
451
continue;
452
}
453
}
454
455
char *filename = malloc(d_name_len + strlen(plugindir) + 2);
456
if (filename == NULL){
457
perror("malloc");
458
continue;
459
}
460
strcpy(filename, plugindir); /* Spurious warning */
461
strcat(filename, "/"); /* Spurious warning */
462
strcat(filename, dirst->d_name); /* Spurious warning */
463
464
ret = stat(filename, &st);
465
if (ret == -1){
466
perror("stat");
467
free(filename);
468
continue;
469
}
470
471
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
472
if(debug){
473
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
474
" with bad type or mode\n", filename);
475
}
476
free(filename);
477
continue;
478
}
479
if(getplugin(dirst->d_name, &plugin_list)->disabled){
480
if(debug){
481
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
482
dirst->d_name);
483
}
484
free(filename);
485
continue;
486
}
487
plugin *p = getplugin(dirst->d_name, &plugin_list);
488
{
489
/* Add global arguments to argument list for this plugin */
490
plugin *g = getplugin(NULL, &plugin_list);
491
for(char **a = g->argv + 1; *a != NULL; a++){
492
addargument(p, *a);
493
}
494
}
495
int pipefd[2];
496
ret = pipe(pipefd);
497
if (ret == -1){
498
perror("pipe");
499
exitstatus = EXIT_FAILURE;
500
goto end;
501
}
502
ret = set_cloexec_flag(pipefd[0]);
503
if(ret < 0){
504
perror("set_cloexec_flag");
505
exitstatus = EXIT_FAILURE;
506
goto end;
507
}
508
ret = set_cloexec_flag(pipefd[1]);
509
if(ret < 0){
510
perror("set_cloexec_flag");
511
exitstatus = EXIT_FAILURE;
512
goto end;
513
}
514
/* Block SIGCHLD until process is safely in process list */
515
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
516
if(ret < 0){
517
perror("sigprocmask");
518
exitstatus = EXIT_FAILURE;
519
goto end;
520
}
521
// Starting a new process to be watched
522
pid_t pid = fork();
523
if(pid == -1){
524
perror("fork");
525
exitstatus = EXIT_FAILURE;
526
goto end;
527
}
528
if(pid == 0){
529
/* this is the child process */
530
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
531
if(ret < 0){
532
perror("sigaction");
533
_exit(EXIT_FAILURE);
534
}
535
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
536
if(ret < 0){
537
perror("sigprocmask");
538
_exit(EXIT_FAILURE);
539
}
58
// Ignore dotfiles and backup files
59
if (dirst->d_name[0] == '.'
60
or dirst->d_name[d_name_len - 1] == '~'){
61
continue;
62
}
63
64
char *filename = malloc(d_name_len + plugindir_len + 1);
65
strcpy(filename, plugindir);
66
strcat(filename, "/");
67
strcat(filename, dirst->d_name);
68
69
stat(filename, &st);
540
70
541
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
542
if(ret == -1){
543
perror("dup2");
544
_exit(EXIT_FAILURE);
545
}
546
547
if(dirfd(dir) < 0){
548
/* If dir has no file descriptor, we could not set FD_CLOEXEC
549
above and must now close it manually here. */
71
if (S_ISREG(st.st_mode) and (access(filename, X_OK) == 0)){
72
// Starting a new process to be watched
73
process *new_process = malloc(sizeof(process));
74
int pipefd[2];
75
pipe(pipefd);
76
new_process->pid = fork();
77
if(new_process->pid == 0){
78
/* this is the child process */
550
79
closedir(dir);
551
}
552
if(execv(filename, p->argv) < 0){
553
perror("execv");
554
_exit(EXIT_FAILURE);
555
}
556
/* no return */
557
}
558
/* parent process */
559
free(filename);
560
close(pipefd[1]); /* close unused write end of pipe */
561
process *new_process = malloc(sizeof(process));
562
if (new_process == NULL){
563
perror("malloc");
564
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
565
if(ret < 0){
566
perror("sigprocmask");
567
}
568
exitstatus = EXIT_FAILURE;
569
goto end;
570
}
571
572
*new_process = (struct process){ .pid = pid,
573
.fd = pipefd[0],
574
.next = process_list };
575
// List handling
576
process_list = new_process;
577
/* Unblock SIGCHLD so signal handler can be run if this process
578
has already completed */
579
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
580
if(ret < 0){
581
perror("sigprocmask");
582
exitstatus = EXIT_FAILURE;
583
goto end;
584
}
585
586
FD_SET(new_process->fd, &rfds_all);
587
588
if (maxfd < new_process->fd){
589
maxfd = new_process->fd;
590
}
591
592
}
593
594
/* Free the plugin list */
595
for(plugin *next; plugin_list != NULL; plugin_list = next){
596
next = plugin_list->next;
597
free(plugin_list->argv);
598
free(plugin_list);
80
close(pipefd[0]); /* close unused read end of pipe */
81
dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
82
/* create a new modified argument list */
83
char **new_argv = malloc(sizeof(char *) * argc + 1);
84
new_argv[0] = filename;
85
for(int i = 1; i < argc; i++){
86
new_argv[i] = argv[i];
87
}
88
new_argv[argc] = NULL;
89
if(execv(filename, new_argv) < 0){
90
perror(argv[0]);
91
close(pipefd[1]);
92
exit(EXIT_FAILURE);
93
}
94
/* no return */
95
}
96
close(pipefd[1]); /* close unused write end of pipe */
97
new_process->fd = pipefd[0];
98
new_process->buffer = malloc(BUFFER_SIZE);
99
if (new_process->buffer == NULL){
100
perror(argv[0]);
101
goto end;
102
}
103
new_process->buffer_size = BUFFER_SIZE;
104
new_process->buffer_length = 0;
105
FD_SET(new_process->fd, &rfds_orig);
106
107
if (maxfd < new_process->fd){
108
maxfd = new_process->fd;
109
}
110
111
//List handling
112
new_process->next = process_list;
113
process_list = new_process;
114
}
599
115
}
600
116
601
117
closedir(dir);
602
dir = NULL;
603
604
if (process_list == NULL){
605
fprintf(stderr, "No plugin processes started. Incorrect plugin"
606
" directory?\n");
607
process_list = NULL;
608
}
609
while(process_list){
610
fd_set rfds = rfds_all;
611
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
612
if (select_ret == -1){
613
perror("select");
614
exitstatus = EXIT_FAILURE;
615
goto end;
616
}
617
/* OK, now either a process completed, or something can be read
618
from one of them */
619
for(process *proc = process_list; proc ; proc = proc->next){
620
/* Is this process completely done? */
621
if(proc->eof and proc->completed){
622
/* Only accept the plugin output if it exited cleanly */
623
if(not WIFEXITED(proc->status)
624
or WEXITSTATUS(proc->status) != 0){
625
/* Bad exit by plugin */
626
if(debug){
627
if(WIFEXITED(proc->status)){
628
fprintf(stderr, "Plugin %u exited with status %d\n",
629
(unsigned int) (proc->pid),
630
WEXITSTATUS(proc->status));
631
} else if(WIFSIGNALED(proc->status)) {
632
fprintf(stderr, "Plugin %u killed by signal %d\n",
633
(unsigned int) (proc->pid),
634
WTERMSIG(proc->status));
635
} else if(WCOREDUMP(proc->status)){
636
fprintf(stderr, "Plugin %d dumped core\n",
637
(unsigned int) (proc->pid));
118
119
if (process_list != NULL){
120
while(true){
121
fd_set rfds = rfds_orig;
122
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
123
if (select_ret == -1){
124
perror(argv[0]);
125
goto end;
126
}else{
127
for(process *process_itr = process_list; process_itr != NULL;
128
process_itr = process_itr->next){
129
if(FD_ISSET(process_itr->fd, &rfds)){
130
if(process_itr->buffer_length + BUFFER_SIZE
131
> process_itr->buffer_size){
132
process_itr->buffer = realloc(process_itr->buffer,
133
process_itr->buffer_size
134
+ BUFFER_SIZE);
135
if (process_itr->buffer == NULL){
136
perror(argv[0]);
137
goto end;
138
}
139
process_itr->buffer_size += BUFFER_SIZE;
638
140
}
639
}
640
/* Remove the plugin */
641
FD_CLR(proc->fd, &rfds_all);
642
/* Block signal while modifying process_list */
643
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
644
if(ret < 0){
645
perror("sigprocmask");
646
exitstatus = EXIT_FAILURE;
647
goto end;
648
}
649
/* Delete this process entry from the list */
650
if(process_list == proc){
651
/* First one - simple */
652
process_list = proc->next;
653
} else {
654
/* Second one or later */
655
for(process *p = process_list; p != NULL; p = p->next){
656
if(p->next == proc){
657
p->next = proc->next;
658
break;
141
ret = read(process_itr->fd, process_itr->buffer
142
+ process_itr->buffer_length, BUFFER_SIZE);
143
process_itr->buffer_length+=ret;
144
if(ret == 0){
145
/* got EOF */
146
/* wait for process exit */
147
int status;
148
waitpid(process_itr->pid, &status, 0);
149
if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
150
write(STDOUT_FILENO, process_itr->buffer,
151
process_itr->buffer_length);
152
goto end;
153
} else {
154
FD_CLR(process_itr->fd, &rfds_orig);
659
155
}
660
156
}
661
157
}
662
/* We are done modifying process list, so unblock signal */
663
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
664
NULL);
665
if(ret < 0){
666
perror("sigprocmask");
667
}
668
free(proc->buffer);
669
free(proc);
670
/* We deleted this process from the list, so we can't go
671
proc->next. Therefore, start over from the beginning of
672
the process list */
673
break;
674
}
675
/* This process exited nicely, so print its buffer */
676
677
bool bret = print_out_password(proc->buffer, proc->buffer_length);
678
if(not bret){
679
perror("print_out_password");
680
exitstatus = EXIT_FAILURE;
681
}
682
goto end;
683
}
684
/* This process has not completed. Does it have any output? */
685
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
686
/* This process had nothing to say at this time */
687
continue;
688
}
689
/* Before reading, make the process' data buffer large enough */
690
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
691
proc->buffer = realloc(proc->buffer, proc->buffer_size
692
+ (size_t) BUFFER_SIZE);
693
if (proc->buffer == NULL){
694
perror("malloc");
695
exitstatus = EXIT_FAILURE;
696
goto end;
697
}
698
proc->buffer_size += BUFFER_SIZE;
699
}
700
/* Read from the process */
701
ret = read(proc->fd, proc->buffer + proc->buffer_length,
702
BUFFER_SIZE);
703
if(ret < 0){
704
/* Read error from this process; ignore the error */
705
continue;
706
}
707
if(ret == 0){
708
/* got EOF */
709
proc->eof = true;
710
} else {
711
proc->buffer_length += (size_t) ret;
158
}
712
159
}
713
160
}
714
161
}
715
716
162
717
163
end:
718
719
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
720
/* Fallback if all plugins failed, none are found or an error occured */
721
bool bret;
722
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
723
char *passwordbuffer = getpass("Password: ");
724
bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
725
if(not bret){
726
perror("print_out_password");
727
exitstatus = EXIT_FAILURE;
728
goto end;
729
}
730
}
731
732
/* Restore old signal handler */
733
sigaction(SIGCHLD, &old_sigchld_action, NULL);
734
735
free(plus_argv);
736
737
/* Free the plugin list */
738
for(plugin *next; plugin_list != NULL; plugin_list = next){
739
next = plugin_list->next;
740
free(plugin_list->argv);
741
free(plugin_list);
742
}
743
744
if(dir != NULL){
745
closedir(dir);
746
}
747
748
/* Free the process list and kill the processes */
749
for(process *next; process_list != NULL; process_list = next){
750
next = process_list->next;
751
close(process_list->fd);
752
ret = kill(process_list->pid, SIGTERM);
753
if(ret == -1 and errno != ESRCH){
754
/* set-uid proccesses migth not get closed */
755
perror("kill");
756
}
757
free(process_list->buffer);
758
free(process_list);
759
}
760
761
/* Wait for any remaining child processes to terminate */
762
do{
763
ret = wait(NULL);
764
} while(ret >= 0);
765
if(errno != ECHILD){
766
perror("wait");
767
}
768
769
return exitstatus;
164
for(process *process_itr = process_list; process_itr != NULL;
165
process_itr = process_itr->next){
166
close(process_itr->fd);
167
kill(process_itr->pid, SIGTERM);
168
free(process_itr->buffer);
169
}
170
171
while(true){
172
int status;
173
ret = wait(&status);
174
if (ret == -1){
175
if(errno != ECHILD){
176
perror("wait");
177
}
178
break;
179
}
180
}
181
return EXIT_SUCCESS;
770
182
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0