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