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